Changeset 86 for GPL/trunk/alsa-kernel

Timestamp:

Jan 23, 2007, 10:34:32 PM (19 years ago)

Author:

vladest

Message:

Added missed files
Applied latest modifications of ALSA
Reworked sharing strategy between MMOS2 and UNIAUD API

Location:

GPL/trunk/alsa-kernel

Files:

• core/misc.c (modified) (1 diff)
• include/sound/ac97_codec.h (modified) (4 diffs)
• include/sound/config.h (modified) (1 diff)
• include/sound/driver.h (modified) (1 diff)
• pci/ac97/ac97_codec.c (modified) (27 diffs)
• pci/ac97/ac97_patch.c (modified) (31 diffs)
• pci/ac97/ac97_patch.h (modified) (1 diff)
• pci/hda/hda_codec.c (modified) (14 diffs)
• pci/hda/hda_generic.c (modified) (33 diffs)
• pci/hda/hda_intel.c (modified) (52 diffs)
• pci/hda/hda_local.h (modified) (4 diffs)
• pci/hda/makefile.os2 (modified) (1 diff)
• pci/hda/patch_analog.c (modified) (49 diffs)
• pci/hda/patch_cmedia.c (modified) (3 diffs)
• pci/hda/patch_realtek.c (modified) (117 diffs)
• pci/hda/patch_sigmatel.c (modified) (48 diffs)
• pci/intel8x0.c (modified) (4 diffs)

GPL/trunk/alsa-kernel/core/misc.c

@@ -712 +712 @@
 }
 
+/**
+ * snd_pci_quirk_lookup - look up a PCI SSID quirk list
+ * @pci: pci_dev handle
+ * @list: quirk list, terminated by a null entry
+ *
+ * Look through the given quirk list and finds a matching entry
+ * with the same PCI SSID.  When subdevice is 0, all subdevice
+ * values may match.
+ *
+ * Returns the matched entry pointer, or NULL if nothing matched.
+ */
+const struct snd_pci_quirk *
+snd_pci_quirk_lookup(struct pci_dev *pci, const struct snd_pci_quirk *list)
+{
+        const struct snd_pci_quirk *q;
+
+        for (q = list; q->subvendor; q++)
+                if (q->subvendor == pci->subsystem_vendor &&
+                    (!q->subdevice || q->subdevice == pci->subsystem_device))
+                        return q;
+        return NULL;
+}
+

GPL/trunk/alsa-kernel/include/sound/ac97_codec.h

@@ -32 +32 @@
 #include "info.h"
 
-#define CONFIG_SND_AC97_POWER_SAVE /* experimental !!! */
 /*
  *  AC'97 codec registers
@@ -376 +375 @@
 #define AC97_SCAP_NO_SPDIF      (1<<9)  /* don't build SPDIF controls */
 #define AC97_SCAP_EAPD_LED      (1<<10) /* EAPD as mute LED */
+#define AC97_SCAP_POWER_SAVE    (1<<11) /* capable for aggresive power-saving */
 
 /* ac97->flags */
@@ -425 +425 @@
 
 struct snd_ac97_bus_ops {
-        void (*reset) (struct snd_ac97 *ac97);
+    void (*reset) (struct snd_ac97 *ac97);
+    void (*warm_reset)(struct snd_ac97 *ac97);
         void (*write) (struct snd_ac97 *ac97, unsigned short reg, unsigned short val);
         unsigned short (*read) (struct snd_ac97 *ac97, unsigned short reg);
@@ -501 +502 @@
                         unsigned short id[3];           // codec IDs (lower 16-bit word)
                         unsigned short pcmreg[3];       // PCM registers
-                        unsigned short codec_cfg[3];    // CODEC_CFG bits
+                        unsigned short codec_cfg[3];    // CODEC_CFG bits
+                        unsigned char swap_mic_linein;  // AD1986/AD1986A only
                 } ad18xx;
                 unsigned int dev_flags;         /* device specific */

GPL/trunk/alsa-kernel/include/sound/config.h

@@ -204 +204 @@
 };
 
+/* PCI quirk list helper */
+struct snd_pci_quirk {
+        unsigned short subvendor;       /* PCI subvendor ID */
+        unsigned short subdevice;       /* PCI subdevice ID */
+        int value;                      /* value */
+#ifdef CONFIG_SND_DEBUG_DETECT
+        const char *name;               /* name of the device (optional) */
+#endif
+};
+
+#define _SND_PCI_QUIRK_ID(vend,dev) \
+        .subvendor = (vend), .subdevice = (dev)
+#define SND_PCI_QUIRK_ID(vend,dev) {_SND_PCI_QUIRK_ID(vend, dev)}
+#ifdef CONFIG_SND_DEBUG_DETECT
+#define SND_PCI_QUIRK(vend,dev,xname,val) \
+        {_SND_PCI_QUIRK_ID(vend, dev), .value = (val), .name = (xname)}
+#else
+#define SND_PCI_QUIRK(vend,dev,xname,val) \
+        {_SND_PCI_QUIRK_ID(vend, dev), .value = (val)}
+#endif
+
+const struct snd_pci_quirk *
+snd_pci_quirk_lookup(struct pci_dev *pci, const struct snd_pci_quirk *list);
+
 /* misc.c */
 struct resource;

GPL/trunk/alsa-kernel/include/sound/driver.h

@@ -753 +753 @@
 #endif
 
+static inline int snd_pci_enable_msi(struct pci_dev *dev) { return -1; }
+#undef pci_enable_msi
+#define pci_enable_msi(dev) snd_pci_enable_msi(dev)
+#undef pci_disable_msi
+#define pci_disable_msi(dev)
+
+#undef pci_intx
+#define pci_intx(pci,x)
+
+
 #endif                          /* __DRIVER_H */

GPL/trunk/alsa-kernel/pci/ac97/ac97_codec.c

@@ -31 +31 @@
 #include <sound/core.h>
 #include <sound/pcm.h>
+#include <sound/tlv.h>
 #include <sound/ac97_codec.h>
 #include <sound/asoundef.h>
@@ -110 +111 @@
 { 0x41445374, 0xffffffff, "AD1981B",            patch_ad1981b,  NULL },
 { 0x41445375, 0xffffffff, "AD1985",             patch_ad1985,   NULL },
-{ 0x41445378, 0xffffffff, "AD1986",             patch_ad1985,   NULL },
+{ 0x41445378, 0xffffffff, "AD1986",             patch_ad1986,   NULL },
 { 0x414c4300, 0xffffff00, "ALC100,100P",        NULL,           NULL },
 { 0x414c4710, 0xfffffff0, "ALC200,200P",        NULL,           NULL },
@@ -128 +129 @@
 { 0x434d4961, 0xffffffff, "CMI9739",            patch_cm9739,   NULL },
 { 0x434d4969, 0xffffffff, "CMI9780",            patch_cm9780,   NULL },
-{ 0x434d4978, 0xffffffff, "CMI9761",            patch_cm9761,   NULL },
-{ 0x434d4982, 0xffffffff, "CMI9761",            patch_cm9761,   NULL },
-{ 0x434d4983, 0xffffffff, "CMI9761",            patch_cm9761,   NULL },
+{ 0x434d4978, 0xffffffff, "CMI9761A",           patch_cm9761,   NULL },
+{ 0x434d4982, 0xffffffff, "CMI9761B",           patch_cm9761,   NULL },
+{ 0x434d4983, 0xffffffff, "CMI9761A+",          patch_cm9761,   NULL },
 { 0x43525900, 0xfffffff8, "CS4297",             NULL,           NULL },
 { 0x43525910, 0xfffffff8, "CS4297A",            patch_cirrus_spdif,     NULL },
@@ -155 +156 @@
 { 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",            patch_ucb1400,  NULL },
@@ -166 +166 @@
 { 0x56494161, 0xffffffff, "VIA1612A",           NULL,           NULL }, // modified ICE1232 with S/PDIF
 { 0x56494170, 0xffffffff, "VIA1617A",           patch_vt1617a,  NULL }, // modified VT1616 with S/PDIF
+{ 0x56494182, 0xffffffff, "VIA1618",            NULL,           NULL },
 { 0x57454301, 0xffffffff, "W83971D",            NULL,           NULL },
 { 0x574d4c00, 0xffffffff, "WM9701A",            NULL,           NULL },
@@ -192 +193 @@
 
 static void update_power_regs(struct snd_ac97 *ac97);
+#ifdef CONFIG_SND_AC97_POWER_SAVE
+#define ac97_is_power_save_mode(ac97) \
+        ((ac97->scaps & AC97_SCAP_POWER_SAVE) && power_save)
+#else
+#define ac97_is_power_save_mode(ac97) 0
+#endif
+
 
 /*
@@ -259 +267 @@
 }
 
+EXPORT_SYMBOL(snd_ac97_write);
+
 /**
  * snd_ac97_read - read a value from the given register
@@ -276 +286 @@
         return ac97->bus->ops->read(ac97, reg);
 }
+
+EXPORT_SYMBOL(snd_ac97_read);
 
 /* read a register - return the cached value if already read */
@@ -369 +381 @@
         unsigned short old, new;
 
-        old = snd_ac97_read_cache(ac97, reg);
-        new = (old & ~mask) | value;
+        old = snd_ac97_read_cache(ac97, reg);
+        new = (old & ~mask) | (value & mask);
         change = old != new;
         if (change) {
@@ -386 +398 @@
 
         down(&ac97->page_mutex);
-        old = ac97->spec.ad18xx.pcmreg[codec];
-        new = (old & ~mask) | value;
+        old = ac97->spec.ad18xx.pcmreg[codec];
+        new = (old & ~mask) | (value & mask);
         change = old != new;
         if (change) {
@@ -557 +569 @@
                         ac97->power_up &= ~(1 << (reg>>1));
                 else
-                        ac97->power_up |= 1 << (reg>>1);
-                if (power_save)
-                        update_power_regs(ac97);
+                    ac97->power_up |= 1 << (reg>>1);
+                update_power_regs(ac97);
         }
 #endif
@@ -1173 +1184 @@
                 kctl = snd_ctl_new1(&tmp, ac97);
         } else {
-                struct snd_kcontrol_new tmp = AC97_SINGLE(name, reg, 15, 1, 1);
+            struct snd_kcontrol_new tmp = AC97_SINGLE(name, reg, 15, 1, 1);
+            if (check_amix)
+                tmp.private_value |= (1 << 30);
+
                 tmp.index = ac97->num;
                 kctl = snd_ctl_new1(&tmp, ac97);
@@ -1187 +1201 @@
 
 /*
+ * set dB information
+ */
+static DECLARE_TLV_DB_SCALE(db_scale_4bit, -4500, 300, 0);
+static DECLARE_TLV_DB_SCALE(db_scale_5bit, -4650, 150, 0);
+static DECLARE_TLV_DB_SCALE(db_scale_6bit, -9450, 150, 0);
+static DECLARE_TLV_DB_SCALE(db_scale_5bit_12db_max, -3450, 150, 0);
+static DECLARE_TLV_DB_SCALE(db_scale_rec_gain, 0, 150, 0);
+
+static unsigned int *find_db_scale(unsigned int maxval)
+{
+        switch (maxval) {
+        case 0x0f: return db_scale_4bit;
+        case 0x1f: return db_scale_5bit;
+        case 0x3f: return db_scale_6bit;
+        }
+        return NULL;
+}
+
+static void set_tlv_db_scale(struct snd_kcontrol *kctl, unsigned int *tlv)
+{       
+        kctl->tlv.p = tlv;
+        if (tlv)
+                kctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_TLV_READ;
+}
+
+/*
+
  * create a volume for normal stereo/mono controls
  */
@@ -1228 +1269 @@
         }
 #endif
-        err = snd_ctl_add(card, kctl);
+        if (reg >= AC97_PHONE && reg <= AC97_PCM)
+                set_tlv_db_scale(kctl, db_scale_5bit_12db_max);
+        else
+                set_tlv_db_scale(kctl, find_db_scale(lo_max));
+        err = snd_ctl_add(card, kctl);
         if (err < 0)
                 return err;
@@ -1308 +1353 @@
                 snd_ac97_change_volume_params2(ac97, AC97_CENTER_LFE_MASTER, 0, &max);
                 kctl->private_value &= ~(0xff << 16);
-                kctl->private_value |= (int)max << 16;
+                kctl->private_value |= (int)max << 16;
+                set_tlv_db_scale(kctl, find_db_scale(max));
                 snd_ac97_write_cache(ac97, AC97_CENTER_LFE_MASTER, ac97->regs[AC97_CENTER_LFE_MASTER] | max);
         }
@@ -1321 +1367 @@
                 snd_ac97_change_volume_params2(ac97, AC97_CENTER_LFE_MASTER, 8, &max);
                 kctl->private_value &= ~(0xff << 16);
-                kctl->private_value |= (int)max << 16;
+                kctl->private_value |= (int)max << 16;
+                set_tlv_db_scale(kctl, find_db_scale(max));
                 snd_ac97_write_cache(ac97, AC97_CENTER_LFE_MASTER, ac97->regs[AC97_CENTER_LFE_MASTER] | max << 8);
         }
@@ -1369 +1416 @@
             snd_ac97_try_volume_mix(ac97, AC97_PC_BEEP))) {
                 for (idx = 0; idx < 2; idx++)
-                        if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_pc_beep[idx], ac97))) < 0)
-                                return err;
+                        if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_pc_beep[idx], ac97))) < 0)
+                                return err;
+                set_tlv_db_scale(kctl, db_scale_4bit);
                 snd_ac97_write_cache(ac97, AC97_PC_BEEP,
                                      snd_ac97_read(ac97, AC97_PC_BEEP) | 0x801e);
@@ -1436 +1484 @@
                 else
                         init_val = 0x9f1f;
-                for (idx = 0; idx < 2; idx++)
-                        if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_ad18xx_pcm[idx], ac97))) < 0)
-                                return err;
+                for (idx = 0; idx < 2; idx++)
+                    if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_ad18xx_pcm[idx], ac97))) < 0)
+                        return err;
+                set_tlv_db_scale(kctl, db_scale_5bit);
                 ac97->spec.ad18xx.pcmreg[0] = init_val;
                 if (ac97->scaps & AC97_SCAP_SURROUND_DAC) {
-                        for (idx = 0; idx < 2; idx++)
-                                if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_ad18xx_surround[idx], ac97))) < 0)
-                                        return err;
-                        ac97->spec.ad18xx.pcmreg[1] = init_val;
+                    for (idx = 0; idx < 2; idx++)
+                        if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_ad18xx_surround[idx], ac97))) < 0)
+                            return err;
+                    set_tlv_db_scale(kctl, db_scale_5bit);
+                    ac97->spec.ad18xx.pcmreg[1] = init_val;
                 }
                 if (ac97->scaps & AC97_SCAP_CENTER_LFE_DAC) {
-                        for (idx = 0; idx < 2; idx++)
-                                if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_ad18xx_center[idx], ac97))) < 0)
-                                        return err;
-                        for (idx = 0; idx < 2; idx++)
-                                if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_ad18xx_lfe[idx], ac97))) < 0)
-                                        return err;
+                    for (idx = 0; idx < 2; idx++)
+                        if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_ad18xx_center[idx], ac97))) < 0)
+                            return err;
+                    set_tlv_db_scale(kctl, db_scale_5bit);
+                    for (idx = 0; idx < 2; idx++)
+                        if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_ad18xx_lfe[idx], ac97))) < 0)
+                            return err;
+                    set_tlv_db_scale(kctl, db_scale_5bit);
                         ac97->spec.ad18xx.pcmreg[2] = init_val;
                 }
@@ -1481 +1533 @@
                     if (err < 0)
                         return err;
-                }
-                if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_control_capture_vol, ac97))) < 0)
-                        return err;
+                }
+                if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_control_capture_vol, ac97))) < 0)
+                    return err;
+                set_tlv_db_scale(kctl, db_scale_rec_gain);
                 snd_ac97_write_cache(ac97, AC97_REC_SEL, 0x0000);
                 snd_ac97_write_cache(ac97, AC97_REC_GAIN, 0x0000);
@@ -1489 +1542 @@
         /* build MIC Capture controls */
         if (snd_ac97_try_volume_mix(ac97, AC97_REC_GAIN_MIC)) {
-                for (idx = 0; idx < 2; idx++)
-                        if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_mic_capture[idx], ac97))) < 0)
-                                return err;
-                snd_ac97_write_cache(ac97, AC97_REC_GAIN_MIC, 0x0000);
+            for (idx = 0; idx < 2; idx++)
+                if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_mic_capture[idx], ac97))) < 0)
+                    return err;
+            set_tlv_db_scale(kctl, db_scale_rec_gain);
+            snd_ac97_write_cache(ac97, AC97_REC_GAIN_MIC, 0x0000);
         }
 
@@ -1561 +1615 @@
         }
 
-        /* build S/PDIF controls */
+        /* build S/PDIF controls */
+
+        /* Hack for ASUS P5P800-VM, which does not indicate S/PDIF capability */
+        if (ac97->subsystem_vendor == 0x1043 &&
+            ac97->subsystem_device == 0x810f)
+                ac97->ext_id |= AC97_EI_SPDIF;
+
         if ((ac97->ext_id & AC97_EI_SPDIF) && !(ac97->scaps & AC97_SCAP_NO_SPDIF)) {
                 if (ac97->build_ops->build_spdif) {
@@ -1642 +1702 @@
         unsigned short saved;
 
-        if (ac97->bus->no_vra || !(ac97->ext_id & AC97_EI_VRA) ) {
+        if (ac97->bus->no_vra) {
                 *r_result = SNDRV_PCM_RATE_48000;
                 if ((ac97->flags & AC97_DOUBLE_RATE) &&
@@ -2261 +2321 @@
         power |= AC97_PD_PR2 | AC97_PD_PR3;     /* Analog Mixer powerdown */
         snd_ac97_write(ac97, AC97_POWERDOWN, power);
-#ifdef CONFIG_SND_AC97_POWER_SAVE
-        if (power_save) {
+        if (ac97_is_power_save_mode(ac97)) {
             udelay(100);
             /* AC-link powerdown, internal Clk disable */
@@ -2269 +2328 @@
             snd_ac97_write(ac97, AC97_POWERDOWN, power);
         }
-#endif
 }
 
@@ -2323 +2381 @@
     }
 
-    if (! power_save)
-        return 0;
-
-    if (! powerup && ac97->power_workq)
+    if (ac97_is_power_save_mode(ac97) && !powerup)
         /* adjust power-down bits after two seconds delay
          * (for avoiding loud click noises for many (OSS) apps
@@ -2346 +2401 @@
     int i;
 
-#ifdef CONFIG_SND_AC97_POWER_SAVE
-    if (power_save)
-        power_up = ac97->power_up;
-    else {
-#endif
         power_up = (1 << PWIDX_FRONT) | (1 << PWIDX_ADC);
         power_up |= (1 << PWIDX_MIC);
@@ -2358 +2408 @@
             power_up |= (1 << PWIDX_CLFE);
 #ifdef CONFIG_SND_AC97_POWER_SAVE
-    }
+        if (ac97_is_power_save_mode(ac97))
+                power_up = ac97->power_up;
 #endif
     if (power_up) {

GPL/trunk/alsa-kernel/pci/ac97/ac97_patch.c

@@ -31 +31 @@
 #include <sound/pcm.h>
 #include <sound/control.h>
+#include <sound/tlv.h>
 #include <sound/ac97_codec.h>
 #include "ac97_patch.h"
@@ -48 +49 @@
                         return err;
         return 0;
+}
+
+/* replace with a new TLV */
+static void reset_tlv(struct snd_ac97 *ac97, const char *name,
+                      unsigned int *tlv)
+{
+        struct snd_ctl_elem_id sid;
+        struct snd_kcontrol *kctl;
+        memset(&sid, 0, sizeof(sid));
+        strcpy(sid.name, name);
+        sid.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
+        kctl = snd_ctl_find_id(ac97->bus->card, &sid);
+        if (kctl && kctl->tlv.p)
+                kctl->tlv.p = tlv;
 }
 
@@ -174 +189 @@
 }
 
+/* system has shared jacks with surround out enabled */
+static inline int is_shared_surrout(struct snd_ac97 *ac97)
+{
+        return ! ac97->indep_surround && is_surround_on(ac97);
+}
+
+/* system has shared jacks with center/lfe out enabled */
+static inline int is_shared_clfeout(struct snd_ac97 *ac97)
+{
+        return ! ac97->indep_surround && is_clfe_on(ac97);
+}
+
+/* system has shared jacks with line in enabled */
 static inline int is_shared_linein(struct snd_ac97 *ac97)
 {
-        return ! ac97->indep_surround && is_surround_on(ac97);
-}
-
+        return !ac97->indep_surround && !is_surround_on(ac97);
+}
+
+/* system has shared jacks with mic in enabled */
 static inline int is_shared_micin(struct snd_ac97 *ac97)
 {
-        return ! ac97->indep_surround && is_clfe_on(ac97);
-}
-
+        return !ac97->indep_surround && !is_clfe_on(ac97);
+}
 
 /* The following snd_ac97_ymf753_... items added by David Shust (dshust@shustring.com) */
@@ -514 +542 @@
 
 AC97_SINGLE("Out3 Switch", AC97_AUX, 15, 1, 1),
-AC97_SINGLE("Out3 ZC Switch", AC97_AUX, 7, 1, 1),
+AC97_SINGLE("Out3 ZC Switch", AC97_AUX, 7, 1, 0),
 AC97_ENUM("Out3 Mux", wm9711_enum[2]),
 AC97_ENUM("Out3 LR Mux", wm9711_enum[3]),
@@ -559 +587 @@
 AC97_SINGLE("ADC Switch", AC97_REC_GAIN, 15, 1, 1),
 AC97_ENUM("Capture Volume Steps", wm9711_enum[6]),
-AC97_DOUBLE("Capture Volume", AC97_REC_GAIN, 8, 0, 15, 1),
+AC97_DOUBLE("Capture Volume", AC97_REC_GAIN, 8, 0, 63, 1),
 AC97_SINGLE("Capture ZC Switch", AC97_REC_GAIN, 7, 1, 0),
 
@@ -565 +593 @@
 AC97_SINGLE("Mic 2 to Phone Switch", AC97_MIC, 13, 1, 1),
 AC97_ENUM("Mic Select Source", wm9711_enum[7]),
-AC97_SINGLE("Mic 1 Volume", AC97_MIC, 8, 32, 1),
+AC97_SINGLE("Mic 1 Volume", AC97_MIC, 8, 31, 1),
+AC97_SINGLE("Mic 2 Volume", AC97_MIC, 0, 31, 1),
 AC97_SINGLE("Mic 20dB Boost Switch", AC97_MIC, 7, 1, 0),
 
@@ -923 +952 @@
 {
         int err;
+
+        /* the register bit is writable, but the function is not implemented: */
+        snd_ac97_remove_ctl(ac97, "PCM Out Path & Mute", NULL);
 
         snd_ac97_rename_vol_ctl(ac97, "Headphone Playback", "Sigmatel Surround Playback");
@@ -1379 +1411 @@
 #endif
 
+static const struct snd_ac97_res_table ad1819_restbl[] = {
+        { AC97_PHONE, 0x9f1f },
+        { AC97_MIC, 0x9f1f },
+        { AC97_LINE, 0x9f1f },
+        { AC97_CD, 0x9f1f },
+        { AC97_VIDEO, 0x9f1f },
+        { AC97_AUX, 0x9f1f },
+        { AC97_PCM, 0x9f1f },
+        {0} /* terminator */
+};
+
 int patch_ad1819(struct snd_ac97 * ac97)
 {
@@ -1385 +1428 @@
         // patch for Analog Devices
         scfg = snd_ac97_read(ac97, AC97_AD_SERIAL_CFG);
-        snd_ac97_write_cache(ac97, AC97_AD_SERIAL_CFG, scfg | 0x7000); /* select all codecs */
+        snd_ac97_write_cache(ac97, AC97_AD_SERIAL_CFG, scfg | 0x7000); /* select all codecs */
+        ac97->res_table = ad1819_restbl;
         return 0;
 }
@@ -1438 +1482 @@
         ac97->spec.ad18xx.codec_cfg[unchained_idx] = 0x0002;
         if (cidx1 >= 0) {
-                if (patch_ad1881_chained1(ac97, cidx1, 0x0006))         // SDIE | ID1C
+                if (cidx2 < 0)
+                        patch_ad1881_chained1(ac97, cidx1, 0);
+                else if (patch_ad1881_chained1(ac97, cidx1, 0x0006))    // SDIE | ID1C
                         patch_ad1881_chained1(ac97, cidx2, 0);
                 else if (patch_ad1881_chained1(ac97, cidx2, 0x0006))    // SDIE | ID1C
@@ -1521 +1567 @@
 };
 
+static DECLARE_TLV_DB_SCALE(db_scale_6bit_6db_max, -8850, 150, 0);
+
 static int patch_ad1885_specific(struct snd_ac97 * ac97)
 {
@@ -1527 +1575 @@
         if ((err = patch_build_controls(ac97, snd_ac97_controls_ad1885, ARRAY_SIZE(snd_ac97_controls_ad1885))) < 0)
                 return err;
+        reset_tlv(ac97, "Headphone Playback Volume",
+                  db_scale_6bit_6db_max);
         return 0;
 }
@@ -1550 +1600 @@
 }
 
+static int patch_ad1886_specific(struct snd_ac97 * ac97)
+{
+        reset_tlv(ac97, "Headphone Playback Volume",
+                  db_scale_6bit_6db_max);
+        return 0;
+}
+
+static struct snd_ac97_build_ops patch_ad1886_build_ops = {
+        .build_specific = &patch_ad1886_specific,
+#ifdef CONFIG_PM
+        .resume = ad18xx_resume
+#endif
+};
+
 int patch_ad1886(struct snd_ac97 * ac97)
 {
@@ -1555 +1619 @@
         /* Presario700 workaround */
         /* for Jack Sense/SPDIF Register misetting causing */
-        snd_ac97_write_cache(ac97, AC97_AD_JACK_SPDIF, 0x0010);
-        return 0;
-}
-
-/* MISC bits */
+        snd_ac97_write_cache(ac97, AC97_AD_JACK_SPDIF, 0x0010);
+        ac97->build_ops = &patch_ad1886_build_ops;
+        return 0;
+}
+
+/* MISC bits (AD1888/AD1980/AD1985 register 0x76) */
 #define AC97_AD198X_MBC         0x0003  /* mic boost */
 #define AC97_AD198X_MBC_20      0x0000  /* +20dB */
@@ -1565 +1630 @@
 #define AC97_AD198X_MBC_30      0x0002  /* +30dB */
 #define AC97_AD198X_VREFD       0x0004  /* VREF high-Z */
-#define AC97_AD198X_VREFH       0x0008  /* 2.25V, 3.7V */
-#define AC97_AD198X_VREF_0      0x000c  /* 0V */
+#define AC97_AD198X_VREFH       0x0008  /* 0=2.25V, 1=3.7V */
+#define AC97_AD198X_VREF_0      0x000c  /* 0V (AD1985 only) */
+#define AC97_AD198X_VREF_MASK   (AC97_AD198X_VREFH | AC97_AD198X_VREFD)
+#define AC97_AD198X_VREF_SHIFT  2
 #define AC97_AD198X_SRU         0x0010  /* sample rate unlock */
 #define AC97_AD198X_LOSEL       0x0020  /* LINE_OUT amplifiers input select */
 #define AC97_AD198X_2MIC        0x0040  /* 2-channel mic select */
 #define AC97_AD198X_SPRD        0x0080  /* SPREAD enable */
-#define AC97_AD198X_DMIX0       0x0100  /* downmix mode: 0 = 6-to-4, 1 = 6-to-2 downmix */
+#define AC97_AD198X_DMIX0       0x0100  /* downmix mode: */
+                                        /*  0 = 6-to-4, 1 = 6-to-2 downmix */
 #define AC97_AD198X_DMIX1       0x0200  /* downmix mode: 1 = enabled */
 #define AC97_AD198X_HPSEL       0x0400  /* headphone amplifier input select */
@@ -1579 +1647 @@
 #define AC97_AD198X_AC97NC      0x4000  /* AC97 no compatible mode */
 #define AC97_AD198X_DACZ        0x8000  /* DAC zero-fill mode */
+
+/* MISC 1 bits (AD1986 register 0x76) */
+#define AC97_AD1986_MBC         0x0003  /* mic boost */
+#define AC97_AD1986_MBC_20      0x0000  /* +20dB */
+#define AC97_AD1986_MBC_10      0x0001  /* +10dB */
+#define AC97_AD1986_MBC_30      0x0002  /* +30dB */
+#define AC97_AD1986_LISEL0      0x0004  /* LINE_IN select bit 0 */
+#define AC97_AD1986_LISEL1      0x0008  /* LINE_IN select bit 1 */
+#define AC97_AD1986_LISEL_MASK  (AC97_AD1986_LISEL1 | AC97_AD1986_LISEL0)
+#define AC97_AD1986_LISEL_LI    0x0000  /* LINE_IN pins as LINE_IN source */
+#define AC97_AD1986_LISEL_SURR  0x0004  /* SURROUND pins as LINE_IN source */
+#define AC97_AD1986_LISEL_MIC   0x0008  /* MIC_1/2 pins as LINE_IN source */
+#define AC97_AD1986_SRU         0x0010  /* sample rate unlock */
+#define AC97_AD1986_SOSEL       0x0020  /* SURROUND_OUT amplifiers input sel */
+#define AC97_AD1986_2MIC        0x0040  /* 2-channel mic select */
+#define AC97_AD1986_SPRD        0x0080  /* SPREAD enable */
+#define AC97_AD1986_DMIX0       0x0100  /* downmix mode: */
+                                        /*  0 = 6-to-4, 1 = 6-to-2 downmix */
+#define AC97_AD1986_DMIX1       0x0200  /* downmix mode: 1 = enabled */
+#define AC97_AD1986_CLDIS       0x0800  /* center/lfe disable */
+#define AC97_AD1986_SODIS       0x1000  /* SURROUND_OUT disable */
+#define AC97_AD1986_MSPLT       0x2000  /* mute split (read only 1) */
+#define AC97_AD1986_AC97NC      0x4000  /* AC97 no compatible mode (r/o 1) */
+#define AC97_AD1986_DACZ        0x8000  /* DAC zero-fill mode */
+
+/* MISC 2 bits (AD1986 register 0x70) */
+#define AC97_AD_MISC2           0x70    /* Misc Control Bits 2 (AD1986) */
+
+#define AC97_AD1986_CVREF0      0x0004  /* C/LFE VREF_OUT 2.25V */
+#define AC97_AD1986_CVREF1      0x0008  /* C/LFE VREF_OUT 0V */
+#define AC97_AD1986_CVREF2      0x0010  /* C/LFE VREF_OUT 3.7V */
+#define AC97_AD1986_CVREF_MASK \
+        (AC97_AD1986_CVREF2 | AC97_AD1986_CVREF1 | AC97_AD1986_CVREF0)
+#define AC97_AD1986_JSMAP       0x0020  /* Jack Sense Mapping 1 = alternate */
+#define AC97_AD1986_MMDIS       0x0080  /* Mono Mute Disable */
+#define AC97_AD1986_MVREF0      0x0400  /* MIC VREF_OUT 2.25V */
+#define AC97_AD1986_MVREF1      0x0800  /* MIC VREF_OUT 0V */
+#define AC97_AD1986_MVREF2      0x1000  /* MIC VREF_OUT 3.7V */
+#define AC97_AD1986_MVREF_MASK \
+        (AC97_AD1986_MVREF2 | AC97_AD1986_MVREF1 | AC97_AD1986_MVREF0)
+
+/* MISC 3 bits (AD1986 register 0x7a) */
+#define AC97_AD_MISC3           0x7a    /* Misc Control Bits 3 (AD1986) */
+
+#define AC97_AD1986_MMIX        0x0004  /* Mic Mix, left/right */
+#define AC97_AD1986_GPO         0x0008  /* General Purpose Out */
+#define AC97_AD1986_LOHPEN      0x0010  /* LINE_OUT headphone drive */
+#define AC97_AD1986_LVREF0      0x0100  /* LINE_OUT VREF_OUT 2.25V */
+#define AC97_AD1986_LVREF1      0x0200  /* LINE_OUT VREF_OUT 0V */
+#define AC97_AD1986_LVREF2      0x0400  /* LINE_OUT VREF_OUT 3.7V */
+#define AC97_AD1986_LVREF_MASK \
+        (AC97_AD1986_LVREF2 | AC97_AD1986_LVREF1 | AC97_AD1986_LVREF0)
+#define AC97_AD1986_JSINVA      0x0800  /* Jack Sense Invert SENSE_A */
+#define AC97_AD1986_LOSEL       0x1000  /* LINE_OUT amplifiers input select */
+#define AC97_AD1986_HPSEL0      0x2000  /* Headphone amplifiers */
+                                        /*   input select Surround DACs */
+#define AC97_AD1986_HPSEL1      0x4000  /* Headphone amplifiers input */
+                                        /*   select C/LFE DACs */
+#define AC97_AD1986_JSINVB      0x8000  /* Jack Sense Invert SENSE_B */
+
+/* Serial Config bits (AD1986 register 0x74) (incomplete) */
+#define AC97_AD1986_OMS0        0x0100  /* Optional Mic Selector bit 0 */
+#define AC97_AD1986_OMS1        0x0200  /* Optional Mic Selector bit 1 */
+#define AC97_AD1986_OMS2        0x0400  /* Optional Mic Selector bit 2 */
+#define AC97_AD1986_OMS_MASK \
+        (AC97_AD1986_OMS2 | AC97_AD1986_OMS1 | AC97_AD1986_OMS0)
+#define AC97_AD1986_OMS_M       0x0000  /* MIC_1/2 pins are MIC sources */
+#define AC97_AD1986_OMS_L       0x0100  /* LINE_IN pins are MIC sources */
+#define AC97_AD1986_OMS_C       0x0200  /* Center/LFE pins are MCI sources */
+#define AC97_AD1986_OMS_MC      0x0400  /* Mix of MIC and C/LFE pins */
+                                        /*   are MIC sources */
+#define AC97_AD1986_OMS_ML      0x0500  /* MIX of MIC and LINE_IN pins */
+                                        /*   are MIC sources */
+#define AC97_AD1986_OMS_LC      0x0600  /* MIX of LINE_IN and C/LFE pins */
+                                        /*   are MIC sources */
+#define AC97_AD1986_OMS_MLC     0x0700  /* MIX of MIC, LINE_IN, C/LFE pins */
+                                        /*   are MIC sources */
 
 
@@ -1902 +2047 @@
 }
 
+static int snd_ac97_ad1985_vrefout_info(struct snd_kcontrol *kcontrol,
+                                        struct snd_ctl_elem_info *uinfo)
+{
+        static char *texts[4] = {"High-Z", "3.7 V", "2.25 V", "0 V"};
+
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        uinfo->count = 1;
+        uinfo->value.enumerated.items = 4;
+        if (uinfo->value.enumerated.item > 3)
+                uinfo->value.enumerated.item = 3;
+        strcpy(uinfo->value.enumerated.name,
+               texts[uinfo->value.enumerated.item]);
+        return 0;
+}
+
+static int snd_ac97_ad1985_vrefout_get(struct snd_kcontrol *kcontrol,
+                                       struct snd_ctl_elem_value *ucontrol)
+{
+        static const int reg2ctrl[4] = {2, 0, 1, 3};
+        struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
+        unsigned short val;
+        val = (ac97->regs[AC97_AD_MISC] & AC97_AD198X_VREF_MASK)
+              >> AC97_AD198X_VREF_SHIFT;
+        ucontrol->value.enumerated.item[0] = reg2ctrl[val];
+        return 0;
+}
+
+static int snd_ac97_ad1985_vrefout_put(struct snd_kcontrol *kcontrol, 
+                                       struct snd_ctl_elem_value *ucontrol)
+{
+        static const int ctrl2reg[4] = {1, 2, 0, 3};
+        struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
+        unsigned short val;
+
+        if (ucontrol->value.enumerated.item[0] > 3
+            || ucontrol->value.enumerated.item[0] < 0)
+                return -EINVAL;
+        val = ctrl2reg[ucontrol->value.enumerated.item[0]]
+              << AC97_AD198X_VREF_SHIFT;
+        return snd_ac97_update_bits(ac97, AC97_AD_MISC,
+                                    AC97_AD198X_VREF_MASK, val);
+}
+
+
 static const struct snd_kcontrol_new snd_ac97_ad1985_controls[] = {
-        AC97_SINGLE("Exchange Center/LFE", AC97_AD_SERIAL_CFG, 3, 1, 0)
+        AC97_SINGLE("Exchange Center/LFE", AC97_AD_SERIAL_CFG, 3, 1, 0),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Exchange Front/Surround",
+                .info = snd_ac97_ad1888_lohpsel_info,
+                .get = snd_ac97_ad1888_lohpsel_get,
+                .put = snd_ac97_ad1888_lohpsel_put
+        },
+        AC97_SINGLE("High Pass Filter Enable", AC97_AD_TEST2, 12, 1, 1),
+        AC97_SINGLE("Spread Front to Surround and Center/LFE",
+                    AC97_AD_MISC, 7, 1, 0),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Downmix",
+                .info = snd_ac97_ad1888_downmix_info,
+                .get = snd_ac97_ad1888_downmix_get,
+                .put = snd_ac97_ad1888_downmix_put
+        },
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "V_REFOUT",
+                .info = snd_ac97_ad1985_vrefout_info,
+                .get = snd_ac97_ad1985_vrefout_get,
+                .put = snd_ac97_ad1985_vrefout_put
+        },
+        AC97_SURROUND_JACK_MODE_CTL,
+        AC97_CHANNEL_MODE_CTL,
+
+        AC97_SINGLE("Headphone Jack Sense", AC97_AD_JACK_SPDIF, 10, 1, 0),
+        AC97_SINGLE("Line Jack Sense", AC97_AD_JACK_SPDIF, 12, 1, 0),
 };
 
@@ -1917 +2135 @@
         int err;
 
-        if ((err = patch_ad1980_specific(ac97)) < 0)
+        /* rename 0x04 as "Master" and 0x02 as "Master Surround" */
+        snd_ac97_rename_vol_ctl(ac97, "Master Playback",
+                                "Master Surround Playback");
+        snd_ac97_rename_vol_ctl(ac97, "Headphone Playback", "Master Playback");
+
+        if ((err = patch_build_controls(ac97, &snd_ac97_ad198x_2cmic, 1)) < 0)
                 return err;
-        return patch_build_controls(ac97, snd_ac97_ad1985_controls, ARRAY_SIZE(snd_ac97_ad1985_controls));
+
+        return patch_build_controls(ac97, snd_ac97_ad1985_controls,
+                                    ARRAY_SIZE(snd_ac97_ad1985_controls));
 }
 
@@ -1939 +2164 @@
         misc = snd_ac97_read(ac97, AC97_AD_MISC);
         /* switch front/surround line-out/hp-out */
-        /* center/LFE, mic in 3.75V mode */
         /* AD-compatible mode */
         /* Stereo mutes enabled */
-        /* in accordance with ADI driver: misc | 0x5c28 */
         snd_ac97_write_cache(ac97, AC97_AD_MISC, misc |
-                             AC97_AD198X_VREFH |
                              AC97_AD198X_LOSEL |
                              AC97_AD198X_HPSEL |
-                             AC97_AD198X_CLDIS |
-                             AC97_AD198X_LODIS |
                              AC97_AD198X_MSPLT |
                              AC97_AD198X_AC97NC);
         ac97->flags |= AC97_STEREO_MUTES;
-        /* on AD1985 rev. 3, AC'97 revision bits are zero */
+
+        /* update current jack configuration */
+        ad1985_update_jacks(ac97);
+
+        /* on AD1985 rev. 3, AC'97 revision bits are zero */
         ac97->ext_id = (ac97->ext_id & ~AC97_EI_REV_MASK) | AC97_EI_REV_23;
         return 0;
 }
+
+static int snd_ac97_ad1986_bool_info(struct snd_kcontrol *kcontrol,
+                                     struct snd_ctl_elem_info *uinfo)
+{
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
+        uinfo->count = 1;
+        uinfo->value.integer.min = 0;
+        uinfo->value.integer.max = 1;
+        return 0;
+}
+
+static int snd_ac97_ad1986_lososel_get(struct snd_kcontrol *kcontrol,
+                                       struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
+        unsigned short val;
+
+        val = ac97->regs[AC97_AD_MISC3];
+        ucontrol->value.integer.value[0] = (val & AC97_AD1986_LOSEL) != 0;
+        return 0;
+}
+
+static int snd_ac97_ad1986_lososel_put(struct snd_kcontrol *kcontrol,
+                                       struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
+        int ret0;
+        int ret1;
+        int sprd = (ac97->regs[AC97_AD_MISC] & AC97_AD1986_SPRD) != 0;
+
+        ret0 = snd_ac97_update_bits(ac97, AC97_AD_MISC3, AC97_AD1986_LOSEL,
+                                        ucontrol->value.integer.value[0] != 0
+                                    ? AC97_AD1986_LOSEL : 0);
+        if (ret0 < 0)
+                return ret0;
+
+        /* SOSEL is set to values of "Spread" or "Exchange F/S" controls */
+        ret1 = snd_ac97_update_bits(ac97, AC97_AD_MISC, AC97_AD1986_SOSEL,
+                                    (ucontrol->value.integer.value[0] != 0
+                                     || sprd)
+                                    ? AC97_AD1986_SOSEL : 0);
+        if (ret1 < 0)
+                return ret1;
+
+        return (ret0 > 0 || ret1 > 0) ? 1 : 0;
+}
+
+static int snd_ac97_ad1986_spread_get(struct snd_kcontrol *kcontrol,
+                                      struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
+        unsigned short val;
+
+        val = ac97->regs[AC97_AD_MISC];
+        ucontrol->value.integer.value[0] = (val & AC97_AD1986_SPRD) != 0;
+        return 0;
+}
+
+static int snd_ac97_ad1986_spread_put(struct snd_kcontrol *kcontrol,
+                                      struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
+        int ret0;
+        int ret1;
+        int sprd = (ac97->regs[AC97_AD_MISC3] & AC97_AD1986_LOSEL) != 0;
+
+        ret0 = snd_ac97_update_bits(ac97, AC97_AD_MISC, AC97_AD1986_SPRD,
+                                        ucontrol->value.integer.value[0] != 0
+                                    ? AC97_AD1986_SPRD : 0);
+        if (ret0 < 0)
+                return ret0;
+
+        /* SOSEL is set to values of "Spread" or "Exchange F/S" controls */
+        ret1 = snd_ac97_update_bits(ac97, AC97_AD_MISC, AC97_AD1986_SOSEL,
+                                    (ucontrol->value.integer.value[0] != 0
+                                     || sprd)
+                                    ? AC97_AD1986_SOSEL : 0);
+        if (ret1 < 0)
+                return ret1;
+
+        return (ret0 > 0 || ret1 > 0) ? 1 : 0;
+}
+
+static int snd_ac97_ad1986_miclisel_get(struct snd_kcontrol *kcontrol,
+                                        struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
+
+        ucontrol->value.integer.value[0] = ac97->spec.ad18xx.swap_mic_linein;
+        return 0;
+}
+
+static int snd_ac97_ad1986_miclisel_put(struct snd_kcontrol *kcontrol,
+                                        struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
+        unsigned char swap = ucontrol->value.integer.value[0] != 0;
+
+        if (swap != ac97->spec.ad18xx.swap_mic_linein) {
+                ac97->spec.ad18xx.swap_mic_linein = swap;
+                if (ac97->build_ops->update_jacks)
+                        ac97->build_ops->update_jacks(ac97);
+                return 1;
+        }
+        return 0;
+}
+
+static int snd_ac97_ad1986_vrefout_get(struct snd_kcontrol *kcontrol,
+                                       struct snd_ctl_elem_value *ucontrol)
+{
+        /* Use MIC_1/2 V_REFOUT as the "get" value */
+        struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
+        unsigned short val;
+        unsigned short reg = ac97->regs[AC97_AD_MISC2];
+        if ((reg & AC97_AD1986_MVREF0) != 0)
+                val = 2;
+        else if ((reg & AC97_AD1986_MVREF1) != 0)
+                val = 3;
+        else if ((reg & AC97_AD1986_MVREF2) != 0)
+                val = 1;
+        else
+                val = 0;
+        ucontrol->value.enumerated.item[0] = val;
+        return 0;
+}
+
+static int snd_ac97_ad1986_vrefout_put(struct snd_kcontrol *kcontrol,
+                                       struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
+        unsigned short cval;
+        unsigned short lval;
+        unsigned short mval;
+        int cret;
+        int lret;
+        int mret;
+
+        switch (ucontrol->value.enumerated.item[0])
+        {
+        case 0: /* High-Z */
+                cval = 0;
+                lval = 0;
+                mval = 0;
+                break;
+        case 1: /* 3.7 V */
+                cval = AC97_AD1986_CVREF2;
+                lval = AC97_AD1986_LVREF2;
+                mval = AC97_AD1986_MVREF2;
+                break;
+        case 2: /* 2.25 V */
+                cval = AC97_AD1986_CVREF0;
+                lval = AC97_AD1986_LVREF0;
+                mval = AC97_AD1986_MVREF0;
+                break;
+        case 3: /* 0 V */
+                cval = AC97_AD1986_CVREF1;
+                lval = AC97_AD1986_LVREF1;
+                mval = AC97_AD1986_MVREF1;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        cret = snd_ac97_update_bits(ac97, AC97_AD_MISC2,
+                                    AC97_AD1986_CVREF_MASK, cval);
+        if (cret < 0)
+                return cret;
+        lret = snd_ac97_update_bits(ac97, AC97_AD_MISC3,
+                                    AC97_AD1986_LVREF_MASK, lval);
+        if (lret < 0)
+                return lret;
+        mret = snd_ac97_update_bits(ac97, AC97_AD_MISC2,
+                                    AC97_AD1986_MVREF_MASK, mval);
+        if (mret < 0)
+                return mret;
+
+        return (cret > 0 || lret > 0 || mret > 0) ? 1 : 0;
+}
+
+static const struct snd_kcontrol_new snd_ac97_ad1986_controls[] = {
+        AC97_SINGLE("Exchange Center/LFE", AC97_AD_SERIAL_CFG, 3, 1, 0),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Exchange Front/Surround",
+                .info = snd_ac97_ad1986_bool_info,
+                .get = snd_ac97_ad1986_lososel_get,
+                .put = snd_ac97_ad1986_lososel_put
+        },
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Exchange Mic/Line In",
+                .info = snd_ac97_ad1986_bool_info,
+                .get = snd_ac97_ad1986_miclisel_get,
+                .put = snd_ac97_ad1986_miclisel_put
+        },
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Spread Front to Surround and Center/LFE",
+                .info = snd_ac97_ad1986_bool_info,
+                .get = snd_ac97_ad1986_spread_get,
+                .put = snd_ac97_ad1986_spread_put
+        },
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Downmix",
+                .info = snd_ac97_ad1888_downmix_info,
+                .get = snd_ac97_ad1888_downmix_get,
+                .put = snd_ac97_ad1888_downmix_put
+        },
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "V_REFOUT",
+                .info = snd_ac97_ad1985_vrefout_info,
+                .get = snd_ac97_ad1986_vrefout_get,
+                .put = snd_ac97_ad1986_vrefout_put
+        },
+        AC97_SURROUND_JACK_MODE_CTL,
+        AC97_CHANNEL_MODE_CTL,
+
+        AC97_SINGLE("Headphone Jack Sense", AC97_AD_JACK_SPDIF, 10, 1, 0),
+        AC97_SINGLE("Line Jack Sense", AC97_AD_JACK_SPDIF, 12, 1, 0)
+};
+
+static void ad1986_update_jacks(struct snd_ac97 *ac97)
+{
+        unsigned short misc_val = 0;
+        unsigned short ser_val;
+
+        /* disable SURROUND and CENTER/LFE if not surround mode */
+        if (! is_surround_on(ac97))
+                misc_val |= AC97_AD1986_SODIS;
+        if (! is_clfe_on(ac97))
+                misc_val |= AC97_AD1986_CLDIS;
+
+        /* select line input (default=LINE_IN, SURROUND or MIC_1/2) */
+        if (is_shared_linein(ac97))
+                misc_val |= AC97_AD1986_LISEL_SURR;
+        else if (ac97->spec.ad18xx.swap_mic_linein != 0)
+                misc_val |= AC97_AD1986_LISEL_MIC;
+        snd_ac97_update_bits(ac97, AC97_AD_MISC,
+                             AC97_AD1986_SODIS | AC97_AD1986_CLDIS |
+                             AC97_AD1986_LISEL_MASK,
+                             misc_val);
+
+        /* select microphone input (MIC_1/2, Center/LFE or LINE_IN) */
+        if (is_shared_micin(ac97))
+                ser_val = AC97_AD1986_OMS_C;
+        else if (ac97->spec.ad18xx.swap_mic_linein != 0)
+                ser_val = AC97_AD1986_OMS_L;
+        else
+                ser_val = AC97_AD1986_OMS_M;
+        snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG,
+                             AC97_AD1986_OMS_MASK,
+                             ser_val);
+}
+
+static int patch_ad1986_specific(struct snd_ac97 *ac97)
+{
+        int err;
+
+        if ((err = patch_build_controls(ac97, &snd_ac97_ad198x_2cmic, 1)) < 0)
+                return err;
+
+        return patch_build_controls(ac97, snd_ac97_ad1986_controls,
+                                    ARRAY_SIZE(snd_ac97_ad1985_controls));
+}
+
+static struct snd_ac97_build_ops patch_ad1986_build_ops = {
+        .build_post_spdif = patch_ad198x_post_spdif,
+        .build_specific = patch_ad1986_specific,
+#ifdef CONFIG_PM
+        .resume = ad18xx_resume,
+#endif
+        .update_jacks = ad1986_update_jacks,
+};
+
+int patch_ad1986(struct snd_ac97 * ac97)
+{
+        patch_ad1881(ac97);
+        ac97->build_ops = &patch_ad1986_build_ops;
+        ac97->flags |= AC97_STEREO_MUTES;
+
+        /* update current jack configuration */
+        ad1986_update_jacks(ac97);
+
+        return 0;
+}
+
 
 /*
@@ -1964 +2476 @@
         int shared;
 
-        /* shared Line-In */
-        shared = is_shared_linein(ac97);
+        /* shared Line-In / Surround Out */
+        shared = is_shared_surrout(ac97);
         snd_ac97_update_bits(ac97, AC97_ALC650_MULTICH, 1 << 9,
                              shared ? (1 << 9) : 0);
-        /* update shared Mic */
-        shared = is_shared_micin(ac97);
+        /* update shared Mic In / Center/LFE Out */
+        shared = is_shared_clfeout(ac97);
         /* disable/enable vref */
         snd_ac97_update_bits(ac97, AC97_ALC650_CLOCK, 1 << 12,
@@ -2014 +2526 @@
 };
 
+static DECLARE_TLV_DB_SCALE(db_scale_5bit_3db_max, -4350, 150, 0);
+
 static int patch_alc650_specific(struct snd_ac97 * ac97)
 {
@@ -2024 +2538 @@
                         return err;
         }
+        if (ac97->id != AC97_ID_ALC650F)
+                reset_tlv(ac97, "Master Playback Volume",
+                          db_scale_5bit_3db_max);
         return 0;
 }
@@ -2094 +2611 @@
         int shared;
 
-        /* shared Line-In */
-        shared = is_shared_linein(ac97);
+        /* shared Line-In / Surround Out */
+        shared = is_shared_surrout(ac97);
         ac97_update_bits_page(ac97, AC97_ALC650_MULTICH, 1 << 9,
                               shared ? (1 << 9) : 0, 0);
-        /* update shared mic */
-        shared = is_shared_micin(ac97);
+        /* update shared Mic In / Center/LFE Out */
+        shared = is_shared_clfeout(ac97);
         /* misc control; vrefout disable */
         snd_ac97_update_bits(ac97, AC97_ALC650_CLOCK, 1 << 12,
@@ -2207 +2724 @@
         else { /* ALC655 */
                 if (ac97->subsystem_vendor == 0x1462 &&
-                    ac97->subsystem_device == 0x0131) /* MSI S270 laptop */
+                    (ac97->subsystem_device == 0x0131 || /* MSI S270 laptop */
+                     ac97->subsystem_device == 0x0161 || /* LG K1 Express */
+                     ac97->subsystem_device == 0x0351 || /* MSI L725 laptop */
+                     ac97->subsystem_device == 0x0061))  /* MSI S250 laptop */
                         val &= ~(1 << 1); /* Pin 47 is EAPD (for internal speaker) */
                 else
@@ -2240 +2760 @@
         int shared;
 
-        /* shared Line-In */
-        shared = is_shared_linein(ac97);
+        /* shared Line-In / Surround Out */
+        shared = is_shared_surrout(ac97);
         /* SURR 1kOhm (bit4), Amp (bit5) */
         snd_ac97_update_bits(ac97, AC97_ALC850_MISC1, (1<<4)|(1<<5),
@@ -2248 +2768 @@
         snd_ac97_update_bits(ac97, AC97_ALC850_JACK_SELECT, 7 << 12,
                              shared ? (2<<12) : (0<<12));
-        /* update shared mic */
-        shared = is_shared_micin(ac97);
+        /* update shared Mic In / Center/LFE Out */
+        shared = is_shared_clfeout(ac97);
         /* Vref disable (bit12), 1kOhm (bit13) */
         snd_ac97_update_bits(ac97, AC97_ALC850_MISC1, (1<<12)|(1<<13),
@@ -2322 +2842 @@
 static void cm9738_update_jacks(struct snd_ac97 *ac97)
 {
-        /* shared Line-In */
+        /* shared Line-In / Surround Out */
         snd_ac97_update_bits(ac97, AC97_CM9738_VENDOR_CTRL, 1 << 10,
-                             is_shared_linein(ac97) ? (1 << 10) : 0);
+                             is_shared_surrout(ac97) ? (1 << 10) : 0);
 }
 
@@ -2406 +2926 @@
 static void cm9739_update_jacks(struct snd_ac97 *ac97)
 {
-        /* shared Line-In */
+        /* shared Line-In / Surround Out */
         snd_ac97_update_bits(ac97, AC97_CM9739_MULTI_CHAN, 1 << 10,
-                             is_shared_linein(ac97) ? (1 << 10) : 0);
-        /* shared Mic */
+                             is_shared_surrout(ac97) ? (1 << 10) : 0);
+        /* shared Mic In / Center/LFE Out **/
         snd_ac97_update_bits(ac97, AC97_CM9739_MULTI_CHAN, 0x3000,
-                             is_shared_micin(ac97) ? 0x1000 : 0x2000);
+                             is_shared_clfeout(ac97) ? 0x1000 : 0x2000);
 }
 
@@ -2523 +3043 @@
         val |= surr_on[ac97->spec.dev_flags][is_surround_on(ac97)];
         val |= clfe_on[ac97->spec.dev_flags][is_clfe_on(ac97)];
-        val |= surr_shared[ac97->spec.dev_flags][is_shared_linein(ac97)];
-        val |= clfe_shared[ac97->spec.dev_flags][is_shared_micin(ac97)];
+        val |= surr_shared[ac97->spec.dev_flags][is_shared_surrout(ac97)];
+        val |= clfe_shared[ac97->spec.dev_flags][is_shared_clfeout(ac97)];
 
         snd_ac97_update_bits(ac97, AC97_CM9761_MULTI_CHAN, 0x3c88, val);
@@ -2758 +3278 @@
 int patch_vt1617a(struct snd_ac97 * ac97)
 {
+        /* bring analog power consumption to normal, like WinXP driver
+         * for EPIA SP
+         */
+        snd_ac97_write_cache(ac97, 0x5c, 0x20);
         ac97->ext_id |= AC97_EI_SPDIF;  /* force the detection of spdif */
-        ac97->rates[AC97_RATES_SPDIF] = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000;
+        ac97->rates[AC97_RATES_SPDIF] = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000;
+        ac97->build_ops = &patch_vt1616_ops;
         return 0;
 }
@@ -2767 +3292 @@
 static void it2646_update_jacks(struct snd_ac97 *ac97)
 {
-        /* shared Line-In */
-        snd_ac97_update_bits(ac97, 0x76, 1 << 9,
-                             is_shared_linein(ac97) ? (1<<9) : 0);
-        /* shared Mic */
+    /* shared Line-In / Surround Out */
+    snd_ac97_update_bits(ac97, 0x76, 1 << 9,
+                             is_shared_surrout(ac97) ? (1<<9) : 0);
+        /* shared Mic / Center/LFE Out */
+
         snd_ac97_update_bits(ac97, 0x76, 1 << 10,
-                             is_shared_micin(ac97) ? (1<<10) : 0);
+                             is_shared_clfeout(ac97) ? (1<<10) : 0);
 }
 

GPL/trunk/alsa-kernel/pci/ac97/ac97_patch.h

@@ -49 +49 @@
 int patch_ad1981b(struct snd_ac97 * ac97);
 int patch_ad1985(struct snd_ac97 * ac97);
+int patch_ad1986(struct snd_ac97 * ac97);
 int patch_alc650(struct snd_ac97 * ac97);
 int patch_alc655(struct snd_ac97 * ac97);

GPL/trunk/alsa-kernel/pci/hda/hda_codec.c

@@ -29 +29 @@
 #include "hda_codec.h"
 #include <sound/asoundef.h>
+#include <sound/tlv.h>
 #include <sound/initval.h>
 #include "hda_local.h"
@@ -50 +51 @@
 static struct hda_vendor_id hda_vendor_ids[] = {
     { 0x10ec, "Realtek" },
+    { 0x1057, "Motorola" },
+    { 0x1106, "VIA" },
     { 0x11d4, "Analog Devices" },
     { 0x13f6, "C-Media" },
+    { 0x14f1, "Conexant" },
     { 0x434d, "C-Media" },
     { 0x8384, "SigmaTel" },
@@ -85 +89 @@
     return res;
 }
+
+EXPORT_SYMBOL(snd_hda_codec_read);
 
 /**
@@ -397 +403 @@
             if (! mask)
                 mask = ~0;
-            if (preset->id == (codec->vendor_id & mask))
-                if (preset->id == (codec->vendor_id & mask) &&
-                    (! preset->rev ||
-                     preset->rev == codec->revision_id))
-                    return preset;
+            if (preset->id == (codec->vendor_id & mask) &&
+                (! preset->rev ||
+                 preset->rev == codec->revision_id))
+                return preset;
         }
     }
@@ -827 +832 @@
     return change;
 }
+
+int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
+                          unsigned int size, unsigned int __user *_tlv)
+{
+    struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+    hda_nid_t nid = get_amp_nid(kcontrol);
+    int dir = get_amp_direction(kcontrol);
+    u32 caps, val1, val2;
+
+    if (size < 4 * sizeof(unsigned int))
+        return -ENOMEM;
+    caps = query_amp_caps(codec, nid, dir);
+    val2 = (((caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT) + 1) * 25;
+    val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
+    val1 = ((int)val1) * ((int)val2);
+    if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
+        return -EFAULT;
+    if (put_user(2 * sizeof(unsigned int), _tlv + 1))
+        return -EFAULT;
+    if (put_user(val1, _tlv + 2))
+        return -EFAULT;
+    if (put_user(val2, _tlv + 3))
+        return -EFAULT;
+    return 0;
+}
+
 
 /* switch */
@@ -1323 +1354 @@
     { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */
 
-    /* not autodetected value */
-    { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */
-
     { 0 } /* terminator */
 };
@@ -1461 +1489 @@
                 if (val & AC_SUPPCM_BITS_32)
                     bps = 32;
+                else if (val & AC_SUPPCM_BITS_24)
+                    bps = 24;
                 else if (val & AC_SUPPCM_BITS_20)
                     bps = 20;
-                else if (val & AC_SUPPCM_BITS_24)
-                    bps = 24;
             }
         }
@@ -1670 +1698 @@
  * snd_hda_check_board_config - compare the current codec with the config table
  * @codec: the HDA codec
+ * @num_configs: number of config enums
+ * @models: array of model name strings
  * @tbl: configuration table, terminated by null entries
  *
@@ -1678 +1708 @@
  * If no entries are matching, the function returns a negative value.
  */
-int snd_hda_check_board_config(struct hda_codec *codec, const struct hda_board_config *tbl)
-{
-    const struct hda_board_config *c;
-
-    if (codec->bus->modelname) {
-        for (c = tbl; c->modelname || c->pci_subvendor; c++) {
-            if (c->modelname &&
-                ! strcmp(codec->bus->modelname, c->modelname)) {
-                snd_printd(KERN_INFO "hda_codec: model '%s' is selected\n", c->modelname);
-                return c->config;
+int snd_hda_check_board_config(struct hda_codec *codec,
+                               int num_configs, const char **models,
+                               const struct snd_pci_quirk *tbl)
+{
+    if (codec->bus->modelname && models) {
+        int i;
+        for (i = 0; i < num_configs; i++) {
+            if (models[i] &&
+                !strcmp(codec->bus->modelname, models[i])) {
+                snd_printd(KERN_INFO "hda_codec: model '%s' is "
+                           "selected\n", models[i]);
+                return i;
             }
         }
     }
 
-    if (codec->bus->pci) {
-        u16 subsystem_vendor, subsystem_device;
-        pci_read_config_word(codec->bus->pci, PCI_SUBSYSTEM_VENDOR_ID, &subsystem_vendor);
-        pci_read_config_word(codec->bus->pci, PCI_SUBSYSTEM_ID, &subsystem_device);
-        for (c = tbl; c->modelname || c->pci_subvendor; c++) {
-            if (c->pci_subvendor == subsystem_vendor &&
-                (! c->pci_subdevice /* all match */||
-                 (c->pci_subdevice == subsystem_device))) {
-                snd_printdd(KERN_INFO "hda_codec: PCI %x:%x, codec config %d is selected\n",
-                            subsystem_vendor, subsystem_device, c->config);
-                return c->config;
-            }
+    if (!codec->bus->pci || !tbl)
+        return -1;
+
+    tbl = snd_pci_quirk_lookup(codec->bus->pci, tbl);
+    if (!tbl)
+        return -1;
+    if (tbl->value >= 0 && tbl->value < num_configs) {
+#ifdef CONFIG_SND_DEBUG_DETECT
+        char tmp[10];
+        const char *model = NULL;
+        if (models)
+            model = models[tbl->value];
+        if (!model) {
+            sprintf(tmp, "#%d", tbl->value);
+            model = tmp;
         }
+        snd_printdd(KERN_INFO "hda_codec: model '%s' is selected "
+                    "for config %x:%x (%s)\n",
+                    model, tbl->subvendor, tbl->subdevice,
+                    (tbl->name ? tbl->name : "Unknown device"));
+#endif
+        return tbl->value;
     }
     return -1;
@@ -1899 +1940 @@
     /* front */
     snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag, 0, format);
-    if (mout->hp_nid)
+    if (mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
         /* headphone out will just decode front left/right (stereo) */
         snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag, 0, format);
@@ -1967 +2008 @@
  *
  * If more extra outputs (speaker and headphone) are found, the pins are
- * assisnged to hp_pin and speaker_pins[], respectively.  If no line-out jack
+ * assisnged to hp_pins[] and speaker_pins[], respectively.  If no line-out jack
  * is detected, one of speaker of HP pins is assigned as the primary
  * output, i.e. to line_out_pins[0].  So, line_outs is always positive
@@ -2029 +2070 @@
             break;
         case AC_JACK_HP_OUT:
-            cfg->hp_pin = nid;
+            if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins))
+                continue;
+            cfg->hp_pins[cfg->hp_outs] = nid;
+            cfg->hp_outs++;
             break;
-        case AC_JACK_MIC_IN:
-            if (loc == AC_JACK_LOC_FRONT)
-                cfg->input_pins[AUTO_PIN_FRONT_MIC] = nid;
-            else
-                cfg->input_pins[AUTO_PIN_MIC] = nid;
+        case AC_JACK_MIC_IN: {
+            int preferred, alt;
+            if (loc == AC_JACK_LOC_FRONT) {
+                preferred = AUTO_PIN_FRONT_MIC;
+                alt = AUTO_PIN_MIC;
+            } else {
+                preferred = AUTO_PIN_MIC;
+                alt = AUTO_PIN_FRONT_MIC;
+            }
+            if (!cfg->input_pins[preferred])
+                cfg->input_pins[preferred] = nid;
+            else if (!cfg->input_pins[alt])
+                cfg->input_pins[alt] = nid;
             break;
+        }
         case AC_JACK_LINE_IN:
             if (loc == AC_JACK_LOC_FRONT)
@@ -2101 +2154 @@
                cfg->speaker_pins[1], cfg->speaker_pins[2],
                cfg->speaker_pins[3], cfg->speaker_pins[4]);
-    snd_printd("   hp=0x%x, dig_out=0x%x, din_in=0x%x\n",
-               cfg->hp_pin, cfg->dig_out_pin, cfg->dig_in_pin);
+    snd_printd("   hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
+               cfg->hp_outs, cfg->hp_pins[0],
+               cfg->hp_pins[1], cfg->hp_pins[2],
+               cfg->hp_pins[3], cfg->hp_pins[4]);
     snd_printd("   inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x,"
                " cd=0x%x, aux=0x%x\n",
@@ -2123 +2178 @@
             cfg->speaker_outs = 0;
             memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
-        } else if (cfg->hp_pin) {
-            cfg->line_outs = 1;
-            cfg->line_out_pins[0] = cfg->hp_pin;
-            cfg->hp_pin = 0;
+        } else if (cfg->hp_outs) {
+            cfg->line_outs = cfg->hp_outs;
+            memcpy(cfg->line_out_pins, cfg->hp_pins,
+                   sizeof(cfg->hp_pins));
+            cfg->hp_outs = 0;
+            memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
         }
     }

GPL/trunk/alsa-kernel/pci/hda/hda_generic.c

@@ -47 +47 @@
 
 /* patch-specific record */
+
+#define MAX_PCM_VOLS    2
+struct pcm_vol {
+        struct hda_gnode *node; /* Node for PCM volume */
+        unsigned int index;     /* connection of PCM volume */
+};
+
 struct hda_gspec {
-    struct hda_gnode *dac_node[2];  /* DAC node */
-    struct hda_gnode *out_pin_node[2];      /* Output pin (Line-Out) node */
-    struct hda_gnode *pcm_vol_node[2];      /* Node for PCM volume */
-    unsigned int pcm_vol_index[2];  /* connection of PCM volume */
+        struct hda_gnode *dac_node[2];  /* DAC node */
+        struct hda_gnode *out_pin_node[2];      /* Output pin (Line-Out) node */
+        struct pcm_vol pcm_vol[MAX_PCM_VOLS];   /* PCM volumes */
+        unsigned int pcm_vol_nodes;     /* number of PCM volumes */
 
         struct hda_gnode *adc_node;     /* ADC node */
@@ -71 +78 @@
  */
 #define defcfg_type(node) (((node)->def_cfg & AC_DEFCFG_DEVICE) >> \
-    AC_DEFCFG_DEVICE_SHIFT)
+                           AC_DEFCFG_DEVICE_SHIFT)
 #define defcfg_location(node) (((node)->def_cfg & AC_DEFCFG_LOCATION) >> \
-    AC_DEFCFG_LOCATION_SHIFT)
+                               AC_DEFCFG_LOCATION_SHIFT)
 #define defcfg_port_conn(node) (((node)->def_cfg & AC_DEFCFG_PORT_CONN) >> \
-    AC_DEFCFG_PORT_CONN_SHIFT)
+                                AC_DEFCFG_PORT_CONN_SHIFT)
+
 /*
  * destructor
@@ -265 +273 @@
  */
 static int parse_output_path(struct hda_codec *codec, struct hda_gspec *spec,
-                             struct hda_gnode *node, int dac_idx)
+                             struct hda_gnode *node, int dac_idx)
 {
         int i, err;
@@ -279 +287 @@
                         return 0;
                 }
-                snd_printdd("AUD_OUT found %x\n", node->nid);
-                if (spec->dac_node[dac_idx]) {
-                    /* already DAC node is assigned, just unmute & connect */
-                    return node == spec->dac_node[dac_idx];
-                }
-                spec->dac_node[dac_idx] = node;
-                if (node->wid_caps & AC_WCAP_OUT_AMP) {
-                    spec->pcm_vol_node[dac_idx] = node;
-                    spec->pcm_vol_index[dac_idx] = 0;
+                snd_printdd("AUD_OUT found %x\n", node->nid);
+                if (spec->dac_node[dac_idx]) {
+                        /* already DAC node is assigned, just unmute & connect */
+                        return node == spec->dac_node[dac_idx];
+                }
+                spec->dac_node[dac_idx] = node;
+                if ((node->wid_caps & AC_WCAP_OUT_AMP) &&
+                    spec->pcm_vol_nodes < MAX_PCM_VOLS) {
+                        spec->pcm_vol[spec->pcm_vol_nodes].node = node;
+                        spec->pcm_vol[spec->pcm_vol_nodes].index = 0;
+                        spec->pcm_vol_nodes++;
                 }
                 return 1; /* found */
@@ -295 +305 @@
                 child = hda_get_node(spec, node->conn_list[i]);
                 if (! child)
-                    continue;
-                err = parse_output_path(codec, spec, child, dac_idx);
+                        continue;
+                err = parse_output_path(codec, spec, child, dac_idx);
                 if (err < 0)
                         return err;
@@ -306 +316 @@
                                 select_input_connection(codec, node, i);
                         unmute_input(codec, node, i);
-                        unmute_output(codec, node);
-                        if (! spec->pcm_vol_node[dac_idx]) {
-                            if (node->wid_caps & AC_WCAP_IN_AMP) {
-                                spec->pcm_vol_node[dac_idx] = node;
-                                spec->pcm_vol_index[dac_idx] = i;
-                            } else if (node->wid_caps & AC_WCAP_OUT_AMP) {
-                                spec->pcm_vol_node[dac_idx] = node;
-                                spec->pcm_vol_index[dac_idx] = 0;
-                            }
+                        unmute_output(codec, node);
+                        if (spec->dac_node[dac_idx] &&
+                            spec->pcm_vol_nodes < MAX_PCM_VOLS &&
+                            !(spec->dac_node[dac_idx]->wid_caps &
+                              AC_WCAP_OUT_AMP)) {
+                                if ((node->wid_caps & AC_WCAP_IN_AMP) ||
+                                    (node->wid_caps & AC_WCAP_OUT_AMP)) {
+                                        int n = spec->pcm_vol_nodes;
+                                        spec->pcm_vol[n].node = node;
+                                        spec->pcm_vol[n].index = i;
+                                        spec->pcm_vol_nodes++;
+                                }
                         }
                         return 1;
@@ -342 +355 @@
                 /* output capable? */
                 if (! (node->pin_caps & AC_PINCAP_OUT))
-                    continue;
-                if (defcfg_port_conn(node) == AC_JACK_PORT_NONE)
-                    continue; /* unconnected */
+                        continue;
+                if (defcfg_port_conn(node) == AC_JACK_PORT_NONE)
+                        continue; /* unconnected */
                 if (jack_type >= 0) {
                         if (jack_type != defcfg_type(node))
@@ -355 +368 @@
                                 continue;
                 }
-                clear_check_flags(spec);
-                err = parse_output_path(codec, spec, node, 0);
+                clear_check_flags(spec);
+                err = parse_output_path(codec, spec, node, 0);
                 if (err < 0)
-                    return NULL;
-                if (! err && spec->out_pin_node[0]) {
-                    err = parse_output_path(codec, spec, node, 1);
-                    if (err < 0)
-                        return NULL;
-                }
-                if (err > 0) {
+                        return NULL;
+                if (! err && spec->out_pin_node[0]) {
+                        err = parse_output_path(codec, spec, node, 1);
+                        if (err < 0)
+                                return NULL;
+                }
+                if (err > 0) {
                         /* unmute the PIN output */
                         unmute_output(codec, node);
@@ -370 +383 @@
                         snd_hda_codec_write(codec, node->nid, 0,
                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
-                                            AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
+                                            AC_PINCTL_OUT_EN |
+                                            ((node->pin_caps & AC_PINCAP_HP_DRV) ?
+                                             AC_PINCTL_HP_EN : 0));
                         return node;
                 }
@@ -391 +406 @@
         /* first, look for the line-out pin */
         node = parse_output_jack(codec, spec, AC_JACK_LINE_OUT);
-        if (node) /* found, remember the PIN node */
-            spec->out_pin_node[0] = node;
-        else {
-            /* if no line-out is found, try speaker out */
-            node = parse_output_jack(codec, spec, AC_JACK_SPEAKER);
-            if (node)
-                spec->out_pin_node[0] = node;
-        }
+        if (node) /* found, remember the PIN node */
+                spec->out_pin_node[0] = node;
+        else {
+                /* if no line-out is found, try speaker out */
+                node = parse_output_jack(codec, spec, AC_JACK_SPEAKER);
+                if (node)
+                        spec->out_pin_node[0] = node;
+        }
         /* look for the HP-out pin */
         node = parse_output_jack(codec, spec, AC_JACK_HP_OUT);
-        if (node) {
-            if (! spec->out_pin_node[0])
-                spec->out_pin_node[0] = node;
-            else
-                spec->out_pin_node[1] = node;
-        }
-
-        if (! spec->out_pin_node[0]) {
+        if (node) {
+                if (! spec->out_pin_node[0])
+                        spec->out_pin_node[0] = node;
+                else
+                        spec->out_pin_node[1] = node;
+        }
+
+        if (! spec->out_pin_node[0]) {
                 /* no line-out or HP pins found,
                  * then choose for the first output pin
-                 */
-            spec->out_pin_node[0] = parse_output_jack(codec, spec, -1);
-            if (! spec->out_pin_node[0])
-                snd_printd("hda_generic: no proper output path found\n");
+                 */
+                spec->out_pin_node[0] = parse_output_jack(codec, spec, -1);
+                if (! spec->out_pin_node[0])
+                        snd_printd("hda_generic: no proper output path found\n");
         }
 
@@ -461 +476 @@
                 return "Line";
         case AC_JACK_CD:
+#if 0
                 if (pinctl)
                         *pinctl |= AC_PINCTL_VREF_GRD;
+#endif
                 return "CD";
         case AC_JACK_AUX:
@@ -469 +486 @@
                 return "Aux";
         case AC_JACK_MIC_IN:
-                if ((location & 0x0f) == AC_JACK_LOC_FRONT)
-                        return "Front Mic";
-                return "Mic";
+            if (pinctl &&
+                (node->pin_caps &
+                 (AC_PINCAP_VREF_80 << AC_PINCAP_VREF_SHIFT)))
+                *pinctl |= AC_PINCTL_VREF_80;
+            if ((location & 0x0f) == AC_JACK_LOC_FRONT)
+                return "Front Mic";
+            return "Mic";
         case AC_JACK_SPDIF_IN:
                 return "SPDIF";
@@ -524 +545 @@
                 return 0;
 
-        if (defcfg_port_conn(node) == AC_JACK_PORT_NONE)
-            return 0; /* unconnected */
-
-        if (node->wid_caps & AC_WCAP_DIGITAL)
+        if (defcfg_port_conn(node) == AC_JACK_PORT_NONE)
+                return 0; /* unconnected */
+
+        if (node->wid_caps & AC_WCAP_DIGITAL)
                 return 0; /* skip SPDIF */
 
@@ -556 +577 @@
 }
 
+/* add a capture source element */
+static void add_cap_src(struct hda_gspec *spec, int idx)
+{
+        struct hda_input_mux_item *csrc;
+        char *buf;
+        int num, ocap;
+
+        num = spec->input_mux.num_items;
+        csrc = &spec->input_mux.items[num];
+        buf = spec->cap_labels[num];
+        for (ocap = 0; ocap < num; ocap++) {
+                if (! strcmp(buf, spec->cap_labels[ocap])) {
+                        /* same label already exists,
+                         * put the index number to be unique
+                         */
+                        sprintf(buf, "%s %d", spec->cap_labels[ocap], num);
+                        break;
+                }
+        }
+        csrc->index = idx;
+        spec->input_mux.num_items++;
+}
+
 /*
  * parse input
@@ -570 +614 @@
         // awk added - fixed no recording due to muted widget
         unmute_input(codec, adc_node, 0);
-
+        
         /*
          * check each connection of the ADC
@@ -576 +620 @@
          * input path.
          */
+        /* first, check the direct connections to PIN widgets */
         for (i = 0; i < adc_node->nconns; i++) {
                 node = hda_get_node(spec, adc_node->conn_list[i]);
-                if (! node)
-                        continue;
-                err = parse_adc_sub_nodes(codec, spec, node);
-                if (err < 0)
-                        return err;
-                else if (err > 0) {
-                        struct hda_input_mux_item *csrc = &spec->input_mux.items[spec->input_mux.num_items];
-                        char *buf = spec->cap_labels[spec->input_mux.num_items];
-                        int ocap;
-                        for (ocap = 0; ocap < spec->input_mux.num_items; ocap++) {
-                                if (! strcmp(buf, spec->cap_labels[ocap])) {
-                                        /* same label already exists,
-                                         * put the index number to be unique
-                                         */
-                                        sprintf(buf, "%s %d", spec->cap_labels[ocap],
-                                                spec->input_mux.num_items);
-                                }
-                        }
-                        csrc->index = i;
-                        spec->input_mux.num_items++;
+                if (node && node->type == AC_WID_PIN) {
+                        err = parse_adc_sub_nodes(codec, spec, node);
+                        if (err < 0)
+                                return err;
+                        else if (err > 0)
+                                add_cap_src(spec, i);
+                }
+        }
+        /* ... then check the rests, more complicated connections */
+        for (i = 0; i < adc_node->nconns; i++) {
+                node = hda_get_node(spec, adc_node->conn_list[i]);
+                if (node && node->type != AC_WID_PIN) {
+                        err = parse_adc_sub_nodes(codec, spec, node);
+                        if (err < 0)
+                                return err;
+                        else if (err > 0)
+                                add_cap_src(spec, i);
                 }
         }
@@ -644 +686 @@
 }
 
+
 /*
  * create mixer controls if possible
  */
-#define DIR_OUT         0x1
-#define DIR_IN          0x2
-
 static int create_mixer(struct hda_codec *codec, struct hda_gnode *node,
                         unsigned int index, const char *type, const char *dir_sfx)
@@ -656 +696 @@
         int err;
         int created = 0;
-        struct snd_kcontrol_new knew = {0};
+        struct snd_kcontrol_new knew;
 
         if (type)
@@ -663 +703 @@
                 sprintf(name, "%s Switch", dir_sfx);
         if ((node->wid_caps & AC_WCAP_IN_AMP) &&
-            (node->amp_in_caps & AC_AMPCAP_MUTE)) {
+            (node->amp_in_caps & AC_AMPCAP_MUTE)) {
+            /*knew = (struct snd_kcontrol_new)HDA_CODEC_MUTE(name, node->nid, index, HDA_INPUT);*/
             knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
             knew.name = name;
@@ -671 +712 @@
             knew.private_value = (node->nid | (3 << 16) | (HDA_INPUT << 18) | (index << 19));
 
-            //knew = (struct snd_kcontrol_new)HDA_CODEC_MUTE(name, node->nid, index, HDA_INPUT);
                 snd_printdd("[%s] NID=0x%x, DIR=IN, IDX=0x%x\n", name, node->nid, index);
                 if ((err = snd_ctl_add(codec->bus->card, snd_ctl_new1(&knew, codec))) < 0)
@@ -677 +717 @@
                 created = 1;
         } else if ((node->wid_caps & AC_WCAP_OUT_AMP) &&
-                   (node->amp_out_caps & AC_AMPCAP_MUTE)) {
+                   (node->amp_out_caps & AC_AMPCAP_MUTE)) {
+            /*knew = (struct snd_kcontrol_new)HDA_CODEC_MUTE(name, node->nid, 0, HDA_OUTPUT);*/
         knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
         knew.name = name;
@@ -685 +726 @@
         knew.private_value = (node->nid | (3 << 16) | (HDA_OUTPUT << 18) | (0 << 19));
 
-                //knew = (struct snd_kcontrol_new)HDA_CODEC_MUTE(name, node->nid, 0, HDA_OUTPUT);
                 snd_printdd("[%s] NID=0x%x, DIR=OUT\n", name, node->nid);
                 if ((err = snd_ctl_add(codec->bus->card, snd_ctl_new1(&knew, codec))) < 0)
@@ -697 +737 @@
                 sprintf(name, "%s Volume", dir_sfx);
         if ((node->wid_caps & AC_WCAP_IN_AMP) &&
-            (node->amp_in_caps & AC_AMPCAP_NUM_STEPS)) {
+            (node->amp_in_caps & AC_AMPCAP_NUM_STEPS)) {
+            /*knew = (struct snd_kcontrol_new)HDA_CODEC_VOLUME(name, node->nid, index, HDA_INPUT);*/
         knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
         knew.name = name;
@@ -705 +746 @@
         knew.private_value = (node->nid | (3 << 16) | (HDA_INPUT << 18) | (index << 19));
 
-                //knew = (struct snd_kcontrol_new)HDA_CODEC_VOLUME(name, node->nid, index, HDA_INPUT);
                 snd_printdd("[%s] NID=0x%x, DIR=IN, IDX=0x%x\n", name, node->nid, index);
                 if ((err = snd_ctl_add(codec->bus->card, snd_ctl_new1(&knew, codec))) < 0)
@@ -712 +752 @@
         } else if ((node->wid_caps & AC_WCAP_OUT_AMP) &&
                    (node->amp_out_caps & AC_AMPCAP_NUM_STEPS)) {
-            //knew = (struct snd_kcontrol_new)HDA_CODEC_VOLUME(name, node->nid, 0, HDA_OUTPUT);
+                /*knew = (struct snd_kcontrol_new)HDA_CODEC_VOLUME(name, node->nid, 0, HDA_OUTPUT);*/
         knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
         knew.name = name;
@@ -719 +759 @@
         knew.put = snd_hda_mixer_amp_volume_put;
         knew.private_value = (node->nid | (3 << 16) | (HDA_OUTPUT << 18) | (0 << 19));
-
                 snd_printdd("[%s] NID=0x%x, DIR=OUT\n", name, node->nid);
                 if ((err = snd_ctl_add(codec->bus->card, snd_ctl_new1(&knew, codec))) < 0)
@@ -750 +789 @@
  * build output mixer controls
  */
+static int create_output_mixers(struct hda_codec *codec, const char **names)
+{
+        struct hda_gspec *spec = codec->spec;
+        int i, err;
+
+        for (i = 0; i < spec->pcm_vol_nodes; i++) {
+                err = create_mixer(codec, spec->pcm_vol[i].node,
+                                   spec->pcm_vol[i].index,
+                                   names[i], "Playback");
+                if (err < 0)
+                        return err;
+        }
+        return 0;
+}
+
 static int build_output_controls(struct hda_codec *codec)
 {
         struct hda_gspec *spec = codec->spec;
-        static const char *types[2] = { "Master", "Headphone" };
-        int i, err;
-
-        for (i = 0; i < 2 && spec->pcm_vol_node[i]; i++) {
-            err = create_mixer(codec, spec->pcm_vol_node[i],
-                               spec->pcm_vol_index[i],
-                               types[i], "Playback");
-            if (err < 0)
-                return err;
-        }
+        static const char *types_speaker[] = { "Speaker", "Headphone" };
+        static const char *types_line[] = { "Front", "Headphone" };
+
+        switch (spec->pcm_vol_nodes) {
+        case 1:
+                return create_mixer(codec, spec->pcm_vol[0].node,
+                                    spec->pcm_vol[0].index,
+                                    "Master", "Playback");
+        case 2:
+                if (defcfg_type(spec->out_pin_node[0]) == AC_JACK_SPEAKER)
+                        return create_output_mixers(codec, types_speaker);
+                else
+                        return create_output_mixers(codec, types_line);
+        }
         return 0;
 }
@@ -771 +829 @@
         struct hda_gspec *spec = codec->spec;
         struct hda_gnode *adc_node = spec->adc_node;
-        int err;
-
-        if (! adc_node)
+        int i, err;
+        static struct snd_kcontrol_new cap_sel = {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Capture Source",
+                .info = capture_source_info,
+                .get = capture_source_get,
+                .put = capture_source_put,
+        };
+
+        if (! adc_node || ! spec->input_mux.num_items)
                 return 0; /* not found */
 
+        spec->cur_cap_src = 0;
+        select_input_connection(codec, adc_node,
+                                spec->input_mux.items[0].index);
+
         /* create capture volume and switch controls if the ADC has an amp */
-        err = create_mixer(codec, adc_node, 0, NULL, "Capture");
+        /* do we have only a single item? */
+        if (spec->input_mux.num_items == 1) {
+                err = create_mixer(codec, adc_node,
+                                   spec->input_mux.items[0].index,
+                                   NULL, "Capture");
+                if (err < 0)
+                        return err;
+                return 0;
+        }
 
         /* create input MUX if multiple sources are available */
-        if (spec->input_mux.num_items > 1) {
-                static struct snd_kcontrol_new cap_sel = {
-                        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-                        .name = "Capture Source",
-                        .info = capture_source_info,
-                        .get = capture_source_get,
-                        .put = capture_source_put,
-                };
-                if ((err = snd_ctl_add(codec->bus->card, snd_ctl_new1(&cap_sel, codec))) < 0)
+        if ((err = snd_ctl_add(codec->bus->card,
+                               snd_ctl_new1(&cap_sel, codec))) < 0)
+                return err;
+
+        /* no volume control? */
+        if (! (adc_node->wid_caps & AC_WCAP_IN_AMP) ||
+            ! (adc_node->amp_in_caps & AC_AMPCAP_NUM_STEPS))
+                return 0;
+
+        for (i = 0; i < spec->input_mux.num_items; i++) {
+                struct snd_kcontrol_new knew;
+                char name[32];
+                sprintf(name, "%s Capture Volume",
+                        spec->input_mux.items[i].label);
+                /*knew = (struct snd_kcontrol_new)
+                        HDA_CODEC_VOLUME(name, adc_node->nid,
+                                         spec->input_mux.items[i].index,
+                                         HDA_INPUT);*/
+                knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
+                knew.name = name;
+                knew.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
+                    SNDRV_CTL_ELEM_ACCESS_TLV_READ |
+                    SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
+                knew.info = snd_hda_mixer_amp_volume_info;
+                knew.get = snd_hda_mixer_amp_volume_get;
+                knew.put = snd_hda_mixer_amp_volume_put;
+                knew.tlv.c = snd_hda_mixer_amp_tlv,
+                knew.private_value = (adc_node->nid | (3 << 16) | (HDA_INPUT << 18) | (spec->input_mux.items[i].index << 19));
+
+                if ((err = snd_ctl_add(codec->bus->card,
+                                       snd_ctl_new1(&knew, codec))) < 0)
                         return err;
-                spec->cur_cap_src = 0;
-                select_input_connection(codec, adc_node, spec->input_mux.items[0].index);
-        }
+        }
+
         return 0;
 }
@@ -859 +957 @@
         const char *type;
 
-        if (! spec->out_pin_node[0])
+        if (! spec->out_pin_node[0])
                 return 0;
 
@@ -873 +971 @@
                         if (check_existing_control(codec, type, "Playback"))
                                 continue;
-                        clear_check_flags(spec);
-                        err = parse_loopback_path(codec, spec,
-                                                  spec->out_pin_node[0],
+                        clear_check_flags(spec);
+                        err = parse_loopback_path(codec, spec,
+                                                  spec->out_pin_node[0],
                                                   node, type);
                         if (err < 0)
@@ -911 +1009 @@
 
 static int generic_pcm2_prepare(struct hda_pcm_stream *hinfo,
-                                struct hda_codec *codec,
-                                unsigned int stream_tag,
-                                unsigned int format,
-                                struct snd_pcm_substream *substream)
-{
-    struct hda_gspec *spec = codec->spec;
-
-    snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
-    snd_hda_codec_setup_stream(codec, spec->dac_node[1]->nid,
-                               stream_tag, 0, format);
-    return 0;
+                                struct hda_codec *codec,
+                                unsigned int stream_tag,
+                                unsigned int format,
+                                struct snd_pcm_substream *substream)
+{
+        struct hda_gspec *spec = codec->spec;
+
+        snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
+        snd_hda_codec_setup_stream(codec, spec->dac_node[1]->nid,
+                                   stream_tag, 0, format);
+        return 0;
 }
 
 static int generic_pcm2_cleanup(struct hda_pcm_stream *hinfo,
-                                struct hda_codec *codec,
-                                struct snd_pcm_substream *substream)
-{
-    struct hda_gspec *spec = codec->spec;
-
-    snd_hda_codec_setup_stream(codec, hinfo->nid, 0, 0, 0);
-    snd_hda_codec_setup_stream(codec, spec->dac_node[1]->nid, 0, 0, 0);
-    return 0;
+                                struct hda_codec *codec,
+                                struct snd_pcm_substream *substream)
+{
+        struct hda_gspec *spec = codec->spec;
+
+        snd_hda_codec_setup_stream(codec, hinfo->nid, 0, 0, 0);
+        snd_hda_codec_setup_stream(codec, spec->dac_node[1]->nid, 0, 0, 0);
+        return 0;
 }
 
@@ -940 +1038 @@
         struct hda_pcm *info = &spec->pcm_rec;
 
-        if (! spec->dac_node[0] && ! spec->adc_node) {
+        if (! spec->dac_node[0] && ! spec->adc_node) {
                 snd_printd("hda_generic: no PCM found\n");
                 return 0;
@@ -948 +1046 @@
         codec->pcm_info = info;
 
-        info->name = "HDA Generic";
-        if (spec->dac_node[0]) {
-            info->stream[0] = generic_pcm_playback;
-            info->stream[0].nid = spec->dac_node[0]->nid;
-            if (spec->dac_node[1]) {
-                info->stream[0].ops.prepare = generic_pcm2_prepare;
-                info->stream[0].ops.cleanup = generic_pcm2_cleanup;
-            }
+        info->name = "HDA Generic";
+        if (spec->dac_node[0]) {
+                info->stream[0] = generic_pcm_playback;
+                info->stream[0].nid = spec->dac_node[0]->nid;
+                if (spec->dac_node[1]) {
+                        info->stream[0].ops.prepare = generic_pcm2_prepare;
+                        info->stream[0].ops.cleanup = generic_pcm2_cleanup;
+                }
         }
         if (spec->adc_node) {

GPL/trunk/alsa-kernel/pci/hda/hda_intel.c

@@ -31 +31 @@
  *
  *  2004.12.01  Major rewrite by tiwai, merged the work of pshou
- *
+ * 
  */
 
@@ -44 +44 @@
 #include <linux/slab.h>
 #include <linux/pci.h>
+#include <linux/mutex.h>
 #include <sound/core.h>
 #include <sound/initval.h>
@@ -55 +56 @@
 static int probe_mask = -1;
 static int single_cmd;
+static int enable_msi;
 
 //module_param(index, int, 0444);
@@ -68 +70 @@
 //module_param(single_cmd, bool, 0444);
 MODULE_PARM_DESC(single_cmd, "Use single command to communicate with codecs (for debugging only).");
+//module_param(enable_msi, int, 0);
+MODULE_PARM_DESC(enable_msi, "Enable Message Signaled Interrupt (MSI)");
 
 
@@ -80 +84 @@
                          "{Intel, ESB2},"
                          "{Intel, ICH8},"
-                        "{ATI, SB450},"
-                        "{ATI, RS600},"
+                         "{Intel, ICH9},"
+                         "{ATI, SB450},"
+                         "{ATI, SB600},"
+                         "{ATI, RS600},"
+                         "{ATI, RS690},"
                          "{VIA, VT8251},"
                          "{VIA, VT8237A},"
@@ -105 +112 @@
 #define ICH6_REG_INTSTS                 0x24
 #define ICH6_REG_WALCLK                 0x30
-#define ICH6_REG_SYNC                   0x34
+#define ICH6_REG_SYNC                   0x34    
 #define ICH6_REG_CORBLBASE              0x40
 #define ICH6_REG_CORBUBASE              0x44
@@ -251 +258 @@
         u32 *bdl;                       /* virtual address of the BDL */
         dma_addr_t bdl_addr;            /* physical address of the BDL */
-        volatile u32 *posbuf;                   /* position buffer pointer */
+        u32 *posbuf;                    /* position buffer pointer */
 
         unsigned int bufsize;           /* size of the play buffer in bytes */
@@ -266 +273 @@
         unsigned int format_val;        /* format value to be set in the controller and the codec */
         unsigned char stream_tag;       /* assigned stream */
-        unsigned char index;            /* stream index */
-        /* for sanity check of position buffer */
-        unsigned int period_intr;
-
-        unsigned int opened: 1;
-        unsigned int running: 1;
+        unsigned char index;            /* stream index */
+        /* for sanity check of position buffer */
+        unsigned int period_intr;
+
+        unsigned int opened :1;
+        unsigned int running :1;
 };
 
@@ -305 +312 @@
         /* locks */
         spinlock_t reg_lock;
-        struct semaphore open_mutex;
+        struct mutex open_mutex;
 
         /* streams (x num_streams) */
@@ -329 +336 @@
         /* flags */
         int position_fix;
-        unsigned int initialized: 1;
-        unsigned int single_cmd: 1;
+        unsigned int initialized :1;
+        unsigned int single_cmd :1;
+        unsigned int polling_mode :1;
+        unsigned int msi :1;
 };
 
@@ -336 +345 @@
 enum {
         AZX_DRIVER_ICH,
-        AZX_DRIVER_ATI,
-        AZX_DRIVER_ATIHDMI,
+        AZX_DRIVER_ATI,
+        AZX_DRIVER_ATIHDMI,
         AZX_DRIVER_VIA,
         AZX_DRIVER_SIS,
@@ -346 +355 @@
 static char *driver_short_names[] __devinitdata = {
         [AZX_DRIVER_ICH] = "HDA Intel",
-        [AZX_DRIVER_ATI] = "HDA ATI SB",
-        [AZX_DRIVER_ATIHDMI] = "HDA ATI HDMI",
+        [AZX_DRIVER_ATI] = "HDA ATI SB",
+        [AZX_DRIVER_ATIHDMI] = "HDA ATI HDMI",
         [AZX_DRIVER_VIA] = "HDA VIA VT82xx",
         [AZX_DRIVER_SIS] = "HDA SIS966",
@@ -391 +400 @@
 #define upper_32bit(addr) (sizeof(addr) > 4 ? (u32)((addr) >> 32) : (u32)0)
 
+static int azx_acquire_irq(struct azx *chip, int do_disconnect);
 
 /*
@@ -456 +466 @@
 /* send a command */
 static int azx_corb_send_cmd(struct hda_codec *codec, hda_nid_t nid, int direct,
-                        unsigned int verb, unsigned int para)
+                             unsigned int verb, unsigned int para)
 {
         struct azx *chip = codec->bus->private_data;
@@ -494 +504 @@
                 return;
         chip->rirb.wp = wp;
-
+                
         while (chip->rirb.rp != wp) {
                 chip->rirb.rp++;
@@ -515 +525 @@
 {
         struct azx *chip = codec->bus->private_data;
-        int timeout = 50;
-
-        while (chip->rirb.cmds) {
-            if (! --timeout) {
-                snd_printk(KERN_ERR
-                           "hda_intel: azx_get_response timeout, "
-                           "switching to single_cmd mode...\n");
-                chip->rirb.rp = azx_readb(chip, RIRBWP);
-                chip->rirb.cmds = 0;
-                /* switch to single_cmd mode */
-                chip->single_cmd = 1;
-                azx_free_cmd_io(chip);
-                return -1;
-            }
-            msleep(1);
-        }
-        return chip->rirb.res; /* the last value */
+        unsigned long timeout;
+
+ again:
+        timeout = jiffies + msecs_to_jiffies(1000);
+        do {
+                if (chip->polling_mode) {
+                        spin_lock_irq(&chip->reg_lock);
+                        azx_update_rirb(chip);
+                        spin_unlock_irq(&chip->reg_lock);
+                }
+                if (! chip->rirb.cmds)
+                        return chip->rirb.res; /* the last value */
+                schedule_timeout_interruptible(1);
+        } while (time_after_eq(timeout, jiffies));
+
+        if (chip->msi) {
+                snd_printk(KERN_WARNING "hda_intel: No response from codec, "
+                           "disabling MSI...\n");
+                free_irq(chip->irq, chip);
+                chip->irq = -1;
+                pci_disable_msi(chip->pci);
+                chip->msi = 0;
+                if (azx_acquire_irq(chip, 1) < 0)
+                        return -1;
+                goto again;
+        }
+
+        if (!chip->polling_mode) {
+                snd_printk(KERN_WARNING "hda_intel: azx_get_response timeout, "
+                           "switching to polling mode...\n");
+                chip->polling_mode = 1;
+                goto again;
+        }
+
+        snd_printk(KERN_ERR "hda_intel: azx_get_response timeout, "
+                   "switching to single_cmd mode...\n");
+        chip->rirb.rp = azx_readb(chip, RIRBWP);
+        chip->rirb.cmds = 0;
+        /* switch to single_cmd mode */
+        chip->single_cmd = 1;
+        azx_free_cmd_io(chip);
+        return -1;
 }
 
@@ -599 +634 @@
 /* send a command */
 static int azx_send_cmd(struct hda_codec *codec, hda_nid_t nid,
-                        int direct, unsigned int verb,
-                        unsigned int para)
-{
-    struct azx *chip = codec->bus->private_data;
-    if (chip->single_cmd)
-        return azx_single_send_cmd(codec, nid, direct, verb, para);
-    else
-        return azx_corb_send_cmd(codec, nid, direct, verb, para);
+                        int direct, unsigned int verb,
+                        unsigned int para)
+{
+        struct azx *chip = codec->bus->private_data;
+        if (chip->single_cmd)
+                return azx_single_send_cmd(codec, nid, direct, verb, para);
+        else
+                return azx_corb_send_cmd(codec, nid, direct, verb, para);
 }
 
@@ -612 +647 @@
 static unsigned int azx_get_response(struct hda_codec *codec)
 {
-    struct azx *chip = codec->bus->private_data;
-    if (chip->single_cmd)
-        return azx_single_get_response(codec);
-    else
-        return azx_rirb_get_response(codec);
+        struct azx *chip = codec->bus->private_data;
+        if (chip->single_cmd)
+                return azx_single_get_response(codec);
+        else
+                return azx_rirb_get_response(codec);
 }
 
@@ -641 +676 @@
 
         count = 50;
-        while (! azx_readb(chip, GCTL) && --count)
+        while (!azx_readb(chip, GCTL) && --count)
                 msleep(1);
 
-        /* Brent Chartrand said to wait >= 540us for codecs to intialize */
+        /* Brent Chartrand said to wait >= 540us for codecs to initialize */
         msleep(1);
 
         /* check to see if controller is ready */
-        if (! azx_readb(chip, GCTL)) {
+        if (!azx_readb(chip, GCTL)) {
                 snd_printd("azx_reset: controller not ready!\n");
                 return -EBUSY;
@@ -657 +692 @@
 
         /* detect codecs */
-        if (! chip->codec_mask) {
+        if (!chip->codec_mask) {
                 chip->codec_mask = azx_readw(chip, STATESTS);
                 snd_printdd("codec_mask = 0x%x\n", chip->codec_mask);
@@ -668 +703 @@
 /*
  * Lowlevel interface
- */
+ */  
 
 /* enable interrupts */
@@ -765 +800 @@
 
         /* initialize the codec command I/O */
-        if (! chip->single_cmd)
+        if (!chip->single_cmd)
                 azx_init_cmd_io(chip);
 
@@ -775 +810 @@
         case AZX_DRIVER_ATI:
                 /* For ATI SB450 azalia HD audio, we need to enable snoop */
-                pci_read_config_byte(chip->pci, ATI_SB450_HDAUDIO_MISC_CNTR2_ADDR,
+                pci_read_config_byte(chip->pci, ATI_SB450_HDAUDIO_MISC_CNTR2_ADDR, 
                                      &reg);
-                pci_write_config_byte(chip->pci, ATI_SB450_HDAUDIO_MISC_CNTR2_ADDR,
+                pci_write_config_byte(chip->pci, ATI_SB450_HDAUDIO_MISC_CNTR2_ADDR, 
                                       (reg & 0xf8) | ATI_SB450_HDAUDIO_ENABLE_SNOOP);
                 break;
@@ -793 +828 @@
  * interrupt handler
  */
-static irqreturn_t azx_interrupt(int irq, void* dev_id, struct pt_regs *regs)
+static irqreturn_t azx_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 {
         struct azx *chip = dev_id;
@@ -807 +842 @@
                 return IRQ_NONE;
         }
-
+        
         for (i = 0; i < chip->num_streams; i++) {
                 azx_dev = &chip->azx_dev[i];
                 if (status & azx_dev->sd_int_sta_mask) {
                         azx_sd_writeb(azx_dev, SD_STS, SD_INT_MASK);
-                        if (azx_dev->substream && azx_dev->running) {
-                            azx_dev->period_intr++;
+                        if (azx_dev->substream && azx_dev->running) {
+                                azx_dev->period_intr++;
                                 spin_unlock(&chip->reg_lock);
                                 snd_pcm_period_elapsed(azx_dev->substream);
@@ -835 +870 @@
 #endif
         spin_unlock(&chip->reg_lock);
-
+        
         return IRQ_HANDLED;
 }
@@ -940 +975 @@
         bus_temp.private_data = chip;
         bus_temp.modelname = model;
-        bus_temp.pci = chip->pci;
-        bus_temp.ops.command = azx_send_cmd;
-        bus_temp.ops.get_response = azx_get_response;
+        bus_temp.pci = chip->pci;
+        bus_temp.ops.command = azx_send_cmd;
+        bus_temp.ops.get_response = azx_get_response;
 
         if ((err = snd_hda_bus_new(chip->card, &bus_temp, &chip->bus)) < 0)
@@ -998 +1033 @@
                                  SNDRV_PCM_INFO_BLOCK_TRANSFER |
                                  SNDRV_PCM_INFO_MMAP_VALID |
-                                 SNDRV_PCM_INFO_PAUSE /*|*/
-                                 /*SNDRV_PCM_INFO_RESUME*/),
+                                 /* No full-resume yet implemented */
+                                 /* SNDRV_PCM_INFO_RESUME |*/
+                                 SNDRV_PCM_INFO_PAUSE),
         .formats =              SNDRV_PCM_FMTBIT_S16_LE,
         .rates =                SNDRV_PCM_RATE_48000,
@@ -1030 +1066 @@
         int err;
 
-        down(&chip->open_mutex);
+        mutex_lock(&chip->open_mutex);
         azx_dev = azx_assign_device(chip, substream->stream);
         if (azx_dev == NULL) {
-                up(&chip->open_mutex);
+                mutex_unlock(&chip->open_mutex);
                 return -EBUSY;
         }
@@ -1040 +1076 @@
         runtime->hw.channels_max = hinfo->channels_max;
         runtime->hw.formats = hinfo->formats;
-        runtime->hw.rates = hinfo->rates;
-        printk("azx hw rates: %x. ratemin: %i, ratemax: %i\n",
-               runtime->hw.rates, runtime->hw.rate_min, runtime->hw.rate_max);
+        runtime->hw.rates = hinfo->rates;
         snd_pcm_limit_hw_rates(runtime);
         snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
         if ((err = hinfo->ops.open(hinfo, apcm->codec, substream)) < 0) {
                 azx_release_device(azx_dev);
-                up(&chip->open_mutex);
+                mutex_unlock(&chip->open_mutex);
                 return err;
         }
@@ -1056 +1090 @@
 
         runtime->private_data = azx_dev;
-        up(&chip->open_mutex);
+        mutex_unlock(&chip->open_mutex);
         return 0;
 }
@@ -1068 +1102 @@
         unsigned long flags;
 
-        down(&chip->open_mutex);
+        mutex_lock(&chip->open_mutex);
         spin_lock_irqsave(&chip->reg_lock, flags);
         azx_dev->substream = NULL;
@@ -1075 +1109 @@
         azx_release_device(azx_dev);
         hinfo->ops.close(hinfo, apcm->codec, substream);
-        up(&chip->open_mutex);
+        mutex_unlock(&chip->open_mutex);
         return 0;
 }
@@ -1176 +1210 @@
         unsigned int pos;
 
-        if (chip->position_fix == POS_FIX_POSBUF ||
-            chip->position_fix == POS_FIX_AUTO) {
+        if (chip->position_fix == POS_FIX_POSBUF ||
+            chip->position_fix == POS_FIX_AUTO) {
                 /* use the position buffer */
-            pos = *azx_dev->posbuf;
-            if (chip->position_fix == POS_FIX_AUTO &&
-                azx_dev->period_intr == 1 && ! pos) {
-                printk(KERN_WARNING
-                       "hda-intel: Invalid position buffer, "
-                       "using LPIB read method instead.\n");
-                chip->position_fix = POS_FIX_NONE;
-                goto read_lpib;
-            }
-        } else {
-        read_lpib:
+                pos = le32_to_cpu(*azx_dev->posbuf);
+                if (chip->position_fix == POS_FIX_AUTO &&
+                    azx_dev->period_intr == 1 && ! pos) {
+                        printk(KERN_WARNING
+                               "hda-intel: Invalid position buffer, "
+                               "using LPIB read method instead.\n");
+                        chip->position_fix = POS_FIX_NONE;
+                        goto read_lpib;
+                }
+        } else {
+        read_lpib:
                 /* read LPIB */
                 pos = azx_sd_readl(azx_dev, SD_LPIB);
@@ -1223 +1257 @@
         struct azx_pcm *apcm;
 
-        snd_assert(cpcm->stream[0].substreams || cpcm->stream[1].substreams, return -EINVAL);
+        /* if no substreams are defined for both playback and capture,
+         * it's just a placeholder.  ignore it.
+         */
+        if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
+                return 0;
+
         snd_assert(cpcm->name, return -EINVAL);
 
@@ -1247 +1286 @@
         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
                                               snd_dma_pci_data(chip->pci),
-                                              1024 * 64, 1024 * 128);
+                                              1024 * 64, 1024 * 1024);
         chip->pcm[pcm_dev] = pcm;
-        chip->pcm_devs = pcm_dev + 1;
+        if (chip->pcm_devs < pcm_dev + 1)
+                chip->pcm_devs = pcm_dev + 1;
 
         return 0;
@@ -1327 +1367 @@
                 azx_dev->bdl = (u32 *)(chip->bdl.area + off);
                 azx_dev->bdl_addr = chip->bdl.addr + off;
-                azx_dev->posbuf = (volatile u32 *)(chip->posbuf.area + i * 8);
+                azx_dev->posbuf = (u32 __iomem *)(chip->posbuf.area + i * 8);
                 /* offset: SDI0=0x80, SDI1=0xa0, ... SDO3=0x160 */
                 azx_dev->sd_addr = chip->remap_addr + (0x20 * i + 0x80);
@@ -1340 +1380 @@
 }
 
+static int azx_acquire_irq(struct azx *chip, int do_disconnect)
+{
+        if (request_irq(chip->pci->irq, azx_interrupt,
+                        chip->msi ? 0 : SA_INTERRUPT|SA_SHIRQ,
+                        "HDA Intel", chip)) {
+                printk(KERN_ERR "hda-intel: unable to grab IRQ %d, "
+                       "disabling device\n", chip->pci->irq);
+/*              if (do_disconnect)
+                        snd_card_disconnect(chip->card);*/
+                return -1;
+        }
+        chip->irq = chip->pci->irq;
+        pci_intx(chip->pci, !chip->msi);
+        return 0;
+}
+
 
 #ifdef CONFIG_PM
@@ -1354 +1410 @@
         for (i = 0; i < chip->pcm_devs; i++)
                 snd_pcm_suspend_all(chip->pcm[i]);
-        snd_hda_suspend(chip->bus, state);
-        azx_free_cmd_io(chip);
+        snd_hda_suspend(chip->bus, state);
+        azx_free_cmd_io(chip);
+        if (chip->irq >= 0) {
+                synchronize_irq(chip->irq);
+                free_irq(chip->irq, chip);
+                chip->irq = -1;
+        }
+        if (chip->msi)
+                pci_disable_msi(chip->pci);
         pci_disable_device(pci);
         pci_save_state(pci);
+        pci_set_power_state(pci, pci_choose_state(pci, state));
         return 0;
 }
@@ -1366 +1430 @@
         struct azx *chip = card->private_data;
 
+        pci_set_power_state(pci, PCI_D0);
         pci_restore_state(pci);
-        pci_enable_device(pci);
+        if (pci_enable_device(pci) < 0) {
+                printk(KERN_ERR "hda-intel: pci_enable_device failed, "
+                       "disabling device\n");
+                snd_card_disconnect(card);
+                return -EIO;
+        }
         pci_set_master(pci);
+        if (chip->msi)
+                if (pci_enable_msi(pci) < 0)
+                        chip->msi = 0;
+        if (azx_acquire_irq(chip, 1) < 0)
+                return -EIO;
         azx_init_chip(chip);
         snd_hda_resume(chip->bus);
@@ -1392 +1467 @@
                 azx_int_clear(chip);
 
-                /* disable CORB/RIRB */
-                azx_free_cmd_io(chip);
+                /* disable CORB/RIRB */
+                azx_free_cmd_io(chip);
 
                 /* disable position buffer */
                 azx_writel(chip, DPLBASE, 0);
                 azx_writel(chip, DPUBASE, 0);
-
-                /* wait a little for interrupts to finish */
-                msleep(1);
-        }
-
-        if (chip->irq >= 0)
+        }
+
+        if (chip->irq >= 0) {
+                synchronize_irq(chip->irq);
                 free_irq(chip->irq, (void*)chip);
+        }
+        if (chip->msi)
+                pci_disable_msi(chip->pci);
         if (chip->remap_addr)
                 iounmap(chip->remap_addr);
@@ -1435 +1511 @@
 {
         struct azx *chip;
-        int err = 0;
+        int err;
         static struct snd_device_ops ops = {
                 .dev_free = azx_dev_free,
@@ -1441 +1517 @@
 
         *rchip = NULL;
-
-        if ((err = pci_enable_device(pci)) < 0)
+        
+        err = pci_enable_device(pci);
+        if (err < 0)
                 return err;
 
         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
-
-        if (NULL == chip) {
+        if (!chip) {
                 snd_printk(KERN_ERR SFX "cannot allocate chip\n");
                 pci_disable_device(pci);
@@ -1454 +1530 @@
 
         spin_lock_init(&chip->reg_lock);
-        init_MUTEX(&chip->open_mutex);
+        mutex_init(&chip->open_mutex);
         chip->card = card;
         chip->pci = pci;
         chip->irq = -1;
         chip->driver_type = driver_type;
-
-        chip->position_fix = position_fix;
+        chip->msi = enable_msi;
+
+        chip->position_fix = position_fix;
         chip->single_cmd = single_cmd;
 
@@ -1473 +1550 @@
 #endif
 
-        if ((err = pci_request_regions(pci, "ICH HD audio")) < 0) {
+        err = pci_request_regions(pci, "ICH HD audio");
+        if (err < 0) {
                 kfree(chip);
                 pci_disable_device(pci);
@@ -1479 +1557 @@
         }
 
-        chip->addr = pci_resource_start(pci,0);
+        chip->addr = pci_resource_start(pci, 0);
         chip->remap_addr = ioremap_nocache(chip->addr, pci_resource_len(pci,0));
         if (chip->remap_addr == NULL) {
@@ -1487 +1565 @@
         }
 
-        if (request_irq(pci->irq, azx_interrupt, SA_INTERRUPT|SA_SHIRQ,
-                        "HDA Intel", (void*)chip)) {
-                snd_printk(KERN_ERR SFX "unable to grab IRQ %d\n", pci->irq);
+        if (chip->msi)
+                if (pci_enable_msi(pci) < 0)
+                        chip->msi = 0;
+
+        if (azx_acquire_irq(chip, 0) < 0) {
                 err = -EBUSY;
                 goto errout;
         }
-        chip->irq = pci->irq;
 
         pci_set_master(pci);
@@ -1504 +1583 @@
                 chip->playback_index_offset = ULI_PLAYBACK_INDEX;
                 chip->capture_index_offset = ULI_CAPTURE_INDEX;
-                break;
-        case AZX_DRIVER_ATIHDMI:
+                break;
+        case AZX_DRIVER_ATIHDMI:
                 chip->playback_streams = ATIHDMI_NUM_PLAYBACK;
                 chip->capture_streams = ATIHDMI_NUM_CAPTURE;
@@ -1520 +1599 @@
         chip->num_streams = chip->playback_streams + chip->capture_streams;
         chip->azx_dev = kcalloc(chip->num_streams, sizeof(*chip->azx_dev), GFP_KERNEL);
-        if (! chip->azx_dev) {
+        if (!chip->azx_dev) {
                 snd_printk(KERN_ERR "cannot malloc azx_dev\n");
                 goto errout;
@@ -1551 +1630 @@
 
         /* codec detection */
-        if (! chip->codec_mask) {
+        if (!chip->codec_mask) {
                 snd_printk(KERN_ERR SFX "no codecs found!\n");
                 err = -ENODEV;
@@ -1578 +1657 @@
         struct snd_card *card;
         struct azx *chip;
-        int err = 0;
+        int err;
 
         card = snd_card_new(index, id, THIS_MODULE, 0);
-        if (NULL == card) {
+        if (!card) {
                 snd_printk(KERN_ERR SFX "Error creating card!\n");
                 return -ENOMEM;
         }
 
-        if ((err = azx_create(card, pci, pci_id->driver_data,
-                              &chip)) < 0) {
+        err = azx_create(card, pci, pci_id->driver_data, &chip);
+        if (err < 0) {
                 snd_card_free(card);
                 return err;
@@ -1635 +1714 @@
         { 0x8086, 0x269a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AZX_DRIVER_ICH }, /* ESB2 */
         { 0x8086, 0x284b, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AZX_DRIVER_ICH }, /* ICH8 */
-        { 0x1002, 0x437b, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AZX_DRIVER_ATI }, /* ATI SB450 */
-        { 0x1002, 0x793b, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AZX_DRIVER_ATIHDMI }, /* ATI RS600 HDMI */
+        { 0x8086, 0x293e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AZX_DRIVER_ICH }, /* ICH9 */
+        { 0x8086, 0x293f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AZX_DRIVER_ICH }, /* ICH9 */
+        { 0x1002, 0x437b, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AZX_DRIVER_ATI }, /* ATI SB450 */
+        { 0x1002, 0x4383, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AZX_DRIVER_ATI }, /* ATI SB600 */
+        { 0x1002, 0x793b, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AZX_DRIVER_ATIHDMI }, /* ATI RS600 HDMI */
+        { 0x1002, 0x7919, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AZX_DRIVER_ATIHDMI }, /* ATI RS690 HDMI */
         { 0x1106, 0x3288, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AZX_DRIVER_VIA }, /* VIA VT8251/VT8237A */
         { 0x1039, 0x7502, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AZX_DRIVER_SIS }, /* SIS966 */
         { 0x10b9, 0x5461, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AZX_DRIVER_ULI }, /* ULI M5461 */
-        { 0x10de, 0x026c, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AZX_DRIVER_NVIDIA }, /* NVIDIA 026c */
-        { 0x10de, 0x0371, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AZX_DRIVER_NVIDIA }, /* NVIDIA 0371 */
+        { 0x10de, 0x026c, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AZX_DRIVER_NVIDIA }, /* NVIDIA MCP51 */
+        { 0x10de, 0x0371, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AZX_DRIVER_NVIDIA }, /* NVIDIA MCP55 */
+        { 0x10de, 0x03e4, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AZX_DRIVER_NVIDIA }, /* NVIDIA MCP61 */
+        { 0x10de, 0x03f0, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AZX_DRIVER_NVIDIA }, /* NVIDIA MCP61 */
+        { 0x10de, 0x044a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AZX_DRIVER_NVIDIA }, /* NVIDIA MCP65 */
+        { 0x10de, 0x044b, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AZX_DRIVER_NVIDIA }, /* NVIDIA MCP65 */
+        { 0x10de, 0x055c, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AZX_DRIVER_NVIDIA }, /* NVIDIA MCP67 */
+        { 0x10de, 0x055d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AZX_DRIVER_NVIDIA }, /* NVIDIA MCP67 */
         { 0, }
 };

GPL/trunk/alsa-kernel/pci/hda/hda_local.h

@@ -31 +31 @@
 #define HDA_CODEC_VOLUME_MONO_IDX(xname, xcidx, nid, channel, xindex, direction) \
         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xcidx,  \
+          .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
+                    SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
+                    SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK, \
           .info = snd_hda_mixer_amp_volume_info, \
           .get = snd_hda_mixer_amp_volume_get, \
           .put = snd_hda_mixer_amp_volume_put, \
+          .tlv = { .c = snd_hda_mixer_amp_tlv },                \
           .private_value = HDA_COMPOSE_AMP_VAL(nid, channel, xindex, direction) }
 /* stereo volume with index */
@@ -64 +68 @@
 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol);
 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol);
+int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag, unsigned int size, unsigned int __user *tlv);
 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo);
 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol);
@@ -169 +174 @@
  * Misc
  */
-struct hda_board_config {
-        const char *modelname;
-        int config;
-        unsigned short pci_subvendor;
-        unsigned short pci_subdevice;
-};
-
-int snd_hda_check_board_config(struct hda_codec *codec, const struct hda_board_config *tbl);
+int snd_hda_check_board_config(struct hda_codec *codec, int num_configs,
+                               const char **modelnames,
+                               const struct snd_pci_quirk *pci_list);
 int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew);
 
@@ -225 +225 @@
         int speaker_outs;
         hda_nid_t speaker_pins[5];
-        hda_nid_t hp_pin;
+        int hp_outs;
+        hda_nid_t hp_pins[5];
         hda_nid_t input_pins[AUTO_PIN_LAST];
         hda_nid_t dig_out_pin;

GPL/trunk/alsa-kernel/pci/hda/makefile.os2

@@ -15 +15 @@
 FILE1    = hda_intel.obj hda_codec.obj hda_generic.obj patch_realtek.obj 
 FILE2    = patch_cmedia.obj hda_proc.obj patch_analog.obj patch_sigmatel.obj
-FILE3    = patch_si3054.obj patch_atihdmi.obj
-FILE4    = 
+FILE3    = patch_si3054.obj patch_atihdmi.obj patch_conexant.obj
+FILE4    = patch_via.obj
 FILE5    = 
 FILE6    = 

GPL/trunk/alsa-kernel/pci/hda/patch_analog.c

@@ -24 +24 @@
 #include <linux/slab.h>
 #include <linux/pci.h>
+#include <linux/mutex.h>
+
 #include <sound/core.h>
 #include "hda_codec.h"
@@ -43 +45 @@
                                          */
         unsigned int cur_eapd;
+        unsigned int need_dac_fix;
 
         /* capture */
@@ -61 +64 @@
         struct hda_pcm pcm_rec[2];      /* used in alc_build_pcms() */
 
-        struct semaphore amp_mutex;     /* PCM volume/mute control mutex */
+        struct mutex amp_mutex; /* PCM volume/mute control mutex */
         unsigned int spdif_route;
 
@@ -132 +135 @@
                 if (err < 0)
                         return err;
-        }
+        } 
         if (spec->dig_in_nid) {
                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
@@ -309 +312 @@
         int i;
 
-        codec->patch_ops.init(codec);
+        codec->patch_ops.init(codec);
         for (i = 0; i < spec->num_mixers; i++)
                 snd_hda_resume_ctls(codec, spec->mixers[i]);
@@ -336 +339 @@
  */
 static int ad198x_eapd_info(struct snd_kcontrol *kcontrol,
-                            struct snd_ctl_elem_info *uinfo)
-{
-    uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
-    uinfo->count = 1;
-    uinfo->value.integer.min = 0;
-    uinfo->value.integer.max = 1;
-    return 0;
+                            struct snd_ctl_elem_info *uinfo)
+{
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
+        uinfo->count = 1;
+        uinfo->value.integer.min = 0;
+        uinfo->value.integer.max = 1;
+        return 0;
 }
 
 static int ad198x_eapd_get(struct snd_kcontrol *kcontrol,
-                           struct snd_ctl_elem_value *ucontrol)
-{
-    struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-    struct ad198x_spec *spec = codec->spec;
-    int invert = (kcontrol->private_value >> 8) & 1;
-    if (invert)
-        ucontrol->value.integer.value[0] = ! spec->cur_eapd;
-    else
-        ucontrol->value.integer.value[0] = spec->cur_eapd;
-    return 0;
+                           struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct ad198x_spec *spec = codec->spec;
+        int invert = (kcontrol->private_value >> 8) & 1;
+        if (invert)
+                ucontrol->value.integer.value[0] = ! spec->cur_eapd;
+        else
+                ucontrol->value.integer.value[0] = spec->cur_eapd;
+        return 0;
 }
 
 static int ad198x_eapd_put(struct snd_kcontrol *kcontrol,
-                           struct snd_ctl_elem_value *ucontrol)
-{
-    struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-    struct ad198x_spec *spec = codec->spec;
-    int invert = (kcontrol->private_value >> 8) & 1;
-    hda_nid_t nid = kcontrol->private_value & 0xff;
-    unsigned int eapd;
-    eapd = ucontrol->value.integer.value[0];
-    if (invert)
-        eapd = !eapd;
-    if (eapd == spec->cur_eapd && ! codec->in_resume)
-        return 0;
-    spec->cur_eapd = eapd;
-    snd_hda_codec_write(codec, nid,
-                        0, AC_VERB_SET_EAPD_BTLENABLE,
-                        eapd ? 0x02 : 0x00);
-    return 1;
+                           struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct ad198x_spec *spec = codec->spec;
+        int invert = (kcontrol->private_value >> 8) & 1;
+        hda_nid_t nid = kcontrol->private_value & 0xff;
+        unsigned int eapd;
+        eapd = ucontrol->value.integer.value[0];
+        if (invert)
+                eapd = !eapd;
+        if (eapd == spec->cur_eapd && ! codec->in_resume)
+                return 0;
+        spec->cur_eapd = eapd;
+        snd_hda_codec_write(codec, nid,
+                            0, AC_VERB_SET_EAPD_BTLENABLE,
+                            eapd ? 0x02 : 0x00);
+        return 1;
 }
 
 static int ad198x_ch_mode_info(struct snd_kcontrol *kcontrol,
-                               struct snd_ctl_elem_info *uinfo);
+                               struct snd_ctl_elem_info *uinfo);
 static int ad198x_ch_mode_get(struct snd_kcontrol *kcontrol,
-                              struct snd_ctl_elem_value *ucontrol);
+                              struct snd_ctl_elem_value *ucontrol);
 static int ad198x_ch_mode_put(struct snd_kcontrol *kcontrol,
-                              struct snd_ctl_elem_value *ucontrol);
+                              struct snd_ctl_elem_value *ucontrol);
+
 
 /*
@@ -427 +431 @@
         struct ad198x_spec *ad = codec->spec;
 
-        down(&ad->amp_mutex);
+        mutex_lock(&ad->amp_mutex);
         snd_hda_mixer_amp_volume_get(kcontrol, ucontrol);
-        up(&ad->amp_mutex);
+        mutex_unlock(&ad->amp_mutex);
         return 0;
 }
@@ -439 +443 @@
         int i, change = 0;
 
-        down(&ad->amp_mutex);
+        mutex_lock(&ad->amp_mutex);
         for (i = 0; i < ARRAY_SIZE(ad1986a_dac_nids); i++) {
                 kcontrol->private_value = HDA_COMPOSE_AMP_VAL(ad1986a_dac_nids[i], 3, 0, HDA_OUTPUT);
@@ -445 +449 @@
         }
         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(AD1986A_FRONT_DAC, 3, 0, HDA_OUTPUT);
-        up(&ad->amp_mutex);
+        mutex_unlock(&ad->amp_mutex);
         return change;
 }
@@ -456 +460 @@
         struct ad198x_spec *ad = codec->spec;
 
-        down(&ad->amp_mutex);
+        mutex_lock(&ad->amp_mutex);
         snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
-        up(&ad->amp_mutex);
+        mutex_unlock(&ad->amp_mutex);
         return 0;
 }
@@ -468 +472 @@
         int i, change = 0;
 
-        down(&ad->amp_mutex);
+        mutex_lock(&ad->amp_mutex);
         for (i = 0; i < ARRAY_SIZE(ad1986a_dac_nids); i++) {
                 kcontrol->private_value = HDA_COMPOSE_AMP_VAL(ad1986a_dac_nids[i], 3, 0, HDA_OUTPUT);
@@ -474 +478 @@
         }
         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(AD1986A_FRONT_DAC, 3, 0, HDA_OUTPUT);
-        up(&ad->amp_mutex);
+        mutex_unlock(&ad->amp_mutex);
         return change;
 }
@@ -485 +489 @@
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
                 .name = "PCM Playback Volume",
+                .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
+                          SNDRV_CTL_ELEM_ACCESS_TLV_READ |
+                          SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK,
                 .info = ad1986a_pcm_amp_vol_info,
                 .get = ad1986a_pcm_amp_vol_get,
                 .put = ad1986a_pcm_amp_vol_put,
+                .tlv = { .c = snd_hda_mixer_amp_tlv },
                 .private_value = HDA_COMPOSE_AMP_VAL(AD1986A_FRONT_DAC, 3, 0, HDA_OUTPUT)
         },
@@ -535 +543 @@
 /* additional mixers for 3stack mode */
 static struct snd_kcontrol_new ad1986a_3st_mixers[] = {
-    {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "Channel Mode",
-        .info = ad198x_ch_mode_info,
-        .get = ad198x_ch_mode_get,
-        .put = ad198x_ch_mode_put,
-    },
-    {0} /* end */
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Channel Mode",
+                .info = ad198x_ch_mode_info,
+                .get = ad198x_ch_mode_get,
+                .put = ad198x_ch_mode_put,
+        },
+        {0} /* end */
 };
 
@@ -549 +557 @@
 
 static struct snd_kcontrol_new ad1986a_laptop_mixers[] = {
-    HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT),
-    HDA_CODEC_VOLUME("Master Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE("Master Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
-    /* HDA_CODEC_VOLUME("Headphone Playback Volume", 0x1a, 0x0, HDA_OUTPUT),
-     HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x0, HDA_OUTPUT), */
-    HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_OUTPUT),
-    HDA_CODEC_VOLUME("Line Playback Volume", 0x17, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE("Line Playback Switch", 0x17, 0x0, HDA_OUTPUT),
-    HDA_CODEC_VOLUME("Aux Playback Volume", 0x16, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE("Aux Playback Switch", 0x16, 0x0, HDA_OUTPUT),
-    HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
-    /* HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x18, 0x0, HDA_OUTPUT),
-     HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x18, 0x0, HDA_OUTPUT),
-     HDA_CODEC_VOLUME("Mono Playback Volume", 0x1e, 0x0, HDA_OUTPUT),
-     HDA_CODEC_MUTE("Mono Playback Switch", 0x1e, 0x0, HDA_OUTPUT), */
-    HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
-    {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "Capture Source",
-        .info = ad198x_mux_enum_info,
-        .get = ad198x_mux_enum_get,
-        .put = ad198x_mux_enum_put,
-    },
-    {0} /* end */
+        HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Master Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Master Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
+        /* HDA_CODEC_VOLUME("Headphone Playback Volume", 0x1a, 0x0, HDA_OUTPUT),
+           HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x0, HDA_OUTPUT), */
+        HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Line Playback Volume", 0x17, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Line Playback Switch", 0x17, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Aux Playback Volume", 0x16, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Aux Playback Switch", 0x16, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
+        /* HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x18, 0x0, HDA_OUTPUT),
+           HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x18, 0x0, HDA_OUTPUT),
+           HDA_CODEC_VOLUME("Mono Playback Volume", 0x1e, 0x0, HDA_OUTPUT),
+           HDA_CODEC_MUTE("Mono Playback Switch", 0x1e, 0x0, HDA_OUTPUT), */
+        HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Capture Source",
+                .info = ad198x_mux_enum_info,
+                .get = ad198x_mux_enum_get,
+                .put = ad198x_mux_enum_put,
+        },
+        {0} /* end */
 };
 
@@ -583 +591 @@
 /* master controls both pins 0x1a and 0x1b */
 static int ad1986a_laptop_master_vol_put(struct snd_kcontrol *kcontrol,
-                                         struct snd_ctl_elem_value *ucontrol)
-{
-    struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-    long *valp = ucontrol->value.integer.value;
-    int change;
-
-    change = snd_hda_codec_amp_update(codec, 0x1a, 0, HDA_OUTPUT, 0,
-                                      0x7f, valp[0] & 0x7f);
-    change |= snd_hda_codec_amp_update(codec, 0x1a, 1, HDA_OUTPUT, 0,
-                                       0x7f, valp[1] & 0x7f);
-    snd_hda_codec_amp_update(codec, 0x1b, 0, HDA_OUTPUT, 0,
-                             0x7f, valp[0] & 0x7f);
-    snd_hda_codec_amp_update(codec, 0x1b, 1, HDA_OUTPUT, 0,
-                             0x7f, valp[1] & 0x7f);
-    return change;
+                                         struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        long *valp = ucontrol->value.integer.value;
+        int change;
+
+        change = snd_hda_codec_amp_update(codec, 0x1a, 0, HDA_OUTPUT, 0,
+                                          0x7f, valp[0] & 0x7f);
+        change |= snd_hda_codec_amp_update(codec, 0x1a, 1, HDA_OUTPUT, 0,
+                                           0x7f, valp[1] & 0x7f);
+        snd_hda_codec_amp_update(codec, 0x1b, 0, HDA_OUTPUT, 0,
+                                 0x7f, valp[0] & 0x7f);
+        snd_hda_codec_amp_update(codec, 0x1b, 1, HDA_OUTPUT, 0,
+                                 0x7f, valp[1] & 0x7f);
+        return change;
 }
 
 static int ad1986a_laptop_master_sw_put(struct snd_kcontrol *kcontrol,
-                                        struct snd_ctl_elem_value *ucontrol)
-{
-    struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-    long *valp = ucontrol->value.integer.value;
-    int change;
-
-    change = snd_hda_codec_amp_update(codec, 0x1a, 0, HDA_OUTPUT, 0,
-                                      0x80, valp[0] ? 0 : 0x80);
-    change |= snd_hda_codec_amp_update(codec, 0x1a, 1, HDA_OUTPUT, 0,
-                                       0x80, valp[1] ? 0 : 0x80);
-    snd_hda_codec_amp_update(codec, 0x1b, 0, HDA_OUTPUT, 0,
-                             0x80, valp[0] ? 0 : 0x80);
-    snd_hda_codec_amp_update(codec, 0x1b, 1, HDA_OUTPUT, 0,
-                             0x80, valp[1] ? 0 : 0x80);
-    return change;
+                                        struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        long *valp = ucontrol->value.integer.value;
+        int change;
+
+        change = snd_hda_codec_amp_update(codec, 0x1a, 0, HDA_OUTPUT, 0,
+                                          0x80, valp[0] ? 0 : 0x80);
+        change |= snd_hda_codec_amp_update(codec, 0x1a, 1, HDA_OUTPUT, 0,
+                                           0x80, valp[1] ? 0 : 0x80);
+        snd_hda_codec_amp_update(codec, 0x1b, 0, HDA_OUTPUT, 0,
+                                 0x80, valp[0] ? 0 : 0x80);
+        snd_hda_codec_amp_update(codec, 0x1b, 1, HDA_OUTPUT, 0,
+                                 0x80, valp[1] ? 0 : 0x80);
+        return change;
 }
 
 static struct hda_input_mux ad1986a_laptop_eapd_capture_source = {
-    .num_items = 3,
-    .items = {
-        { "Mic", 0x0 },
-        { "Internal Mic", 0x4 },
-        { "Mix", 0x5 },
-    },
+        .num_items = 3,
+        .items = {
+                { "Mic", 0x0 },
+                { "Internal Mic", 0x4 },
+                { "Mix", 0x5 },
+        },
 };
 
 static struct snd_kcontrol_new ad1986a_laptop_eapd_mixers[] = {
-    {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "Master Playback Volume",
-        .info = snd_hda_mixer_amp_volume_info,
-        .get = snd_hda_mixer_amp_volume_get,
-        .put = ad1986a_laptop_master_vol_put,
-        .private_value = HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
-    },
-    {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "Master Playback Switch",
-        .info = snd_hda_mixer_amp_switch_info,
-        .get = snd_hda_mixer_amp_switch_get,
-        .put = ad1986a_laptop_master_sw_put,
-        .private_value = HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
-    },
-    HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT),
-    HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x17, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x17, 0x0, HDA_OUTPUT),
-    HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
-    HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
-    {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "Capture Source",
-        .info = ad198x_mux_enum_info,
-        .get = ad198x_mux_enum_get,
-        .put = ad198x_mux_enum_put,
-    },
-    {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "External Amplifier",
-        .info = ad198x_eapd_info,
-        .get = ad198x_eapd_get,
-        .put = ad198x_eapd_put,
-        .private_value = 0x1b | (1 << 8), /* port-D, inversed */
-    },
-    {0} /* end */
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Master Playback Volume",
+                .info = snd_hda_mixer_amp_volume_info,
+                .get = snd_hda_mixer_amp_volume_get,
+                .put = ad1986a_laptop_master_vol_put,
+                .tlv = { .c = snd_hda_mixer_amp_tlv },
+                .private_value = HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
+        },
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Master Playback Switch",
+                .info = snd_hda_mixer_amp_switch_info,
+                .get = snd_hda_mixer_amp_switch_get,
+                .put = ad1986a_laptop_master_sw_put,
+                .private_value = HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
+        },
+        HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x17, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x17, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Capture Source",
+                .info = ad198x_mux_enum_info,
+                .get = ad198x_mux_enum_get,
+                .put = ad198x_mux_enum_put,
+        },
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "External Amplifier",
+                .info = ad198x_eapd_info,
+                .get = ad198x_eapd_get,
+                .put = ad198x_eapd_put,
+                .private_value = 0x1b | (1 << 8), /* port-D, inversed */
+        },
+        {0} /* end */
 };
 
@@ -730 +739 @@
 /* additional verbs for 3-stack model */
 static struct hda_verb ad1986a_3st_init_verbs[] = {
-    /* Mic and line-in selectors */
-    {0x0f, AC_VERB_SET_CONNECT_SEL, 0x2},
-    {0x10, AC_VERB_SET_CONNECT_SEL, 0x1},
-    {0} /* end */
+        /* Mic and line-in selectors */
+        {0x0f, AC_VERB_SET_CONNECT_SEL, 0x2},
+        {0x10, AC_VERB_SET_CONNECT_SEL, 0x1},
+        {0} /* end */
 };
 
 static struct hda_verb ad1986a_ch2_init[] = {
-    /* Surround out -> Line In */
-    { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
-    { 0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
-    /* CLFE -> Mic in */
-    { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
-    { 0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
-    {0} /* end */
+        /* Surround out -> Line In */
+        { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
+        { 0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
+        /* CLFE -> Mic in */
+        { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
+        { 0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
+        {0} /* end */
 };
 
 static struct hda_verb ad1986a_ch4_init[] = {
-    /* Surround out -> Surround */
-    { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
-    { 0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
-    /* CLFE -> Mic in */
-    { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
-    { 0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
-    {0} /* end */
+        /* Surround out -> Surround */
+        { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
+        { 0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
+        /* CLFE -> Mic in */
+        { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
+        { 0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
+        {0} /* end */
 };
 
 static struct hda_verb ad1986a_ch6_init[] = {
-    /* Surround out -> Surround out */
-    { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
-    { 0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
-    /* CLFE -> CLFE */
-    { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
-    { 0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
-    {0} /* end */
+        /* Surround out -> Surround out */
+        { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
+        { 0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
+        /* CLFE -> CLFE */
+        { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
+        { 0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
+        {0} /* end */
 };
 
 static struct hda_channel_mode ad1986a_modes[3] = {
-    { 2, ad1986a_ch2_init },
-    { 4, ad1986a_ch4_init },
-    { 6, ad1986a_ch6_init },
+        { 2, ad1986a_ch2_init },
+        { 4, ad1986a_ch4_init },
+        { 6, ad1986a_ch6_init },
 };
 
 /* eapd initialization */
 static struct hda_verb ad1986a_eapd_init_verbs[] = {
-    {0x1b, AC_VERB_SET_EAPD_BTLENABLE, 0x00},
-    {0}
+        {0x1b, AC_VERB_SET_EAPD_BTLENABLE, 0x00},
+        {0}
 };
 
 /* models */
-enum { AD1986A_6STACK, AD1986A_3STACK, AD1986A_LAPTOP, AD1986A_LAPTOP_EAPD };
-
-static struct hda_board_config ad1986a_cfg_tbl[] = {
-    { .modelname = "6stack",        .config = AD1986A_6STACK },
-    { .modelname = "3stack",        .config = AD1986A_3STACK },
-    { .pci_subvendor = 0x10de, .pci_subdevice = 0xcb84,
-    .config = AD1986A_3STACK }, /* ASUS A8N-VM CSM */
-    { .pci_subvendor = 0x1043, .pci_subdevice = 0x81b3,
-    .config = AD1986A_3STACK }, /* ASUS P5RD2-VM / P5GPL-X SE */
-    { .modelname = "laptop",        .config = AD1986A_LAPTOP },
-    { .pci_subvendor = 0x144d, .pci_subdevice = 0xc01e,
-    .config = AD1986A_LAPTOP }, /* FSC V2060 */
-    { .pci_subvendor = 0x17c0, .pci_subdevice = 0x2017,
-    .config = AD1986A_LAPTOP }, /* Samsung M50 */
-    { .pci_subvendor = 0x1043, .pci_subdevice = 0x818f,
-    .config = AD1986A_LAPTOP }, /* ASUS P5GV-MX */
-    { .pci_subvendor = 0x144d, .pci_subdevice = 0xc023,
-    .config = AD1986A_LAPTOP_EAPD }, /* Samsung X60 Chane */
-    { .modelname = "laptop-eapd",   .config = AD1986A_LAPTOP_EAPD },
-    { .pci_subvendor = 0x144d, .pci_subdevice = 0xc024,
-    .config = AD1986A_LAPTOP_EAPD }, /* Samsung R65-T2300 Charis */
-    { .pci_subvendor = 0x1043, .pci_subdevice = 0x1213,
-    .config = AD1986A_LAPTOP_EAPD }, /* ASUS A6J */
-    { .pci_subvendor = 0x1043, .pci_subdevice = 0x11f7,
-    .config = AD1986A_LAPTOP_EAPD }, /* ASUS U5A */
-    { .pci_subvendor = 0x1043, .pci_subdevice = 0x1297,
-    .config = AD1986A_LAPTOP_EAPD }, /* ASUS Z62F */
-    { .pci_subvendor = 0x103c, .pci_subdevice = 0x30af,
-    .config = AD1986A_LAPTOP_EAPD }, /* HP Compaq Presario B2800 */
-    { .pci_subvendor = 0x17aa, .pci_subdevice = 0x2066,
-    .config = AD1986A_LAPTOP_EAPD }, /* Lenovo 3000 N100-07684JU */
-    {0}
+enum {
+        AD1986A_6STACK,
+        AD1986A_3STACK,
+        AD1986A_LAPTOP,
+        AD1986A_LAPTOP_EAPD,
+        AD1986A_MODELS
+};
+
+static const char *ad1986a_models[AD1986A_MODELS] = {
+        [AD1986A_6STACK]        = "6stack",
+        [AD1986A_3STACK]        = "3stack",
+        [AD1986A_LAPTOP]        = "laptop",
+        [AD1986A_LAPTOP_EAPD]   = "laptop-eapd",
+};
+
+static struct snd_pci_quirk ad1986a_cfg_tbl[] = {
+        SND_PCI_QUIRK(0x103c, 0x30af, "HP B2800", AD1986A_LAPTOP_EAPD),
+        SND_PCI_QUIRK(0x10de, 0xcb84, "ASUS A8N-VM", AD1986A_3STACK),
+        SND_PCI_QUIRK(0x1043, 0x1153, "ASUS M9", AD1986A_LAPTOP_EAPD),
+        SND_PCI_QUIRK(0x1043, 0x1213, "ASUS A6J", AD1986A_LAPTOP_EAPD),
+        SND_PCI_QUIRK(0x1043, 0x11f7, "ASUS U5A", AD1986A_LAPTOP_EAPD),
+        SND_PCI_QUIRK(0x1043, 0x1263, "ASUS U5F", AD1986A_LAPTOP_EAPD),
+        SND_PCI_QUIRK(0x1043, 0x1297, "ASUS Z62F", AD1986A_LAPTOP_EAPD),
+        SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS V1j", AD1986A_LAPTOP_EAPD),
+        SND_PCI_QUIRK(0x1043, 0x1302, "ASUS W3j", AD1986A_LAPTOP_EAPD),
+        SND_PCI_QUIRK(0x1043, 0x817f, "ASUS P5", AD1986A_3STACK),
+        SND_PCI_QUIRK(0x1043, 0x818f, "ASUS P5", AD1986A_LAPTOP),
+        SND_PCI_QUIRK(0x1043, 0x81b3, "ASUS P5", AD1986A_3STACK),
+        SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS M2N", AD1986A_3STACK),
+        SND_PCI_QUIRK(0x1043, 0x8234, "ASUS M2N", AD1986A_3STACK),
+        SND_PCI_QUIRK(0x144d, 0xc01e, "FSC V2060", AD1986A_LAPTOP),
+        SND_PCI_QUIRK(0x144d, 0xc023, "Samsung X60", AD1986A_LAPTOP_EAPD),
+        SND_PCI_QUIRK(0x144d, 0xc024, "Samsung R65", AD1986A_LAPTOP_EAPD),
+        SND_PCI_QUIRK(0x144d, 0xc026, "Samsung X11", AD1986A_LAPTOP_EAPD),
+        SND_PCI_QUIRK(0x17aa, 0x1017, "Lenovo A60", AD1986A_3STACK),
+        SND_PCI_QUIRK(0x17aa, 0x2066, "Lenovo N100", AD1986A_LAPTOP_EAPD),
+        SND_PCI_QUIRK(0x17c0, 0x2017, "Samsung M50", AD1986A_LAPTOP),
+        {0}
 };
 
 static int patch_ad1986a(struct hda_codec *codec)
 {
-    struct ad198x_spec *spec;
-    int board_config;
+        struct ad198x_spec *spec;
+        int board_config;
 
         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
@@ -822 +837 @@
                 return -ENOMEM;
 
-        init_MUTEX(&spec->amp_mutex);
+        mutex_init(&spec->amp_mutex);
         codec->spec = spec;
 
@@ -830 +845 @@
         spec->multiout.dig_out_nid = AD1986A_SPDIF_OUT;
         spec->num_adc_nids = 1;
-        spec->adc_nids = ad1986a_adc_nids;
-        spec->capsrc_nids = ad1986a_capsrc_nids;
+        spec->adc_nids = ad1986a_adc_nids;
+        spec->capsrc_nids = ad1986a_capsrc_nids;
         spec->input_mux = &ad1986a_capture_source;
         spec->num_mixers = 1;
@@ -839 +854 @@
 
         codec->patch_ops = ad198x_patch_ops;
-        /* override some parameters */
-        board_config = snd_hda_check_board_config(codec, ad1986a_cfg_tbl);
-        switch (board_config) {
-        case AD1986A_3STACK:
-            spec->num_mixers = 2;
-            spec->mixers[1] = ad1986a_3st_mixers;
-            spec->num_init_verbs = 2;
-            spec->init_verbs[1] = ad1986a_3st_init_verbs;
-            spec->channel_mode = ad1986a_modes;
-            spec->num_channel_mode = ARRAY_SIZE(ad1986a_modes);
-            break;
-        case AD1986A_LAPTOP:
-            spec->mixers[0] = ad1986a_laptop_mixers;
-            spec->multiout.max_channels = 2;
-            spec->multiout.num_dacs = 1;
-            spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
-            break;
-        case AD1986A_LAPTOP_EAPD:
-            spec->mixers[0] = ad1986a_laptop_eapd_mixers;
-            spec->num_init_verbs = 2;
-            spec->init_verbs[1] = ad1986a_eapd_init_verbs;
-            spec->multiout.max_channels = 2;
-            spec->multiout.num_dacs = 1;
-            spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
-            spec->multiout.dig_out_nid = 0;
-            spec->input_mux = &ad1986a_laptop_eapd_capture_source;
-                         break;
-        }
+
+        /* override some parameters */
+        board_config = snd_hda_check_board_config(codec, AD1986A_MODELS,
+                                                  ad1986a_models,
+                                                  ad1986a_cfg_tbl);
+        switch (board_config) {
+        case AD1986A_3STACK:
+                spec->num_mixers = 2;
+                spec->mixers[1] = ad1986a_3st_mixers;
+                spec->num_init_verbs = 3;
+                spec->init_verbs[1] = ad1986a_3st_init_verbs;
+                spec->init_verbs[2] = ad1986a_ch2_init;
+                spec->channel_mode = ad1986a_modes;
+                spec->num_channel_mode = ARRAY_SIZE(ad1986a_modes);
+                spec->need_dac_fix = 1;
+                spec->multiout.max_channels = 2;
+                spec->multiout.num_dacs = 1;
+                break;
+        case AD1986A_LAPTOP:
+                spec->mixers[0] = ad1986a_laptop_mixers;
+                spec->multiout.max_channels = 2;
+                spec->multiout.num_dacs = 1;
+                spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
+                break;
+        case AD1986A_LAPTOP_EAPD:
+                spec->mixers[0] = ad1986a_laptop_eapd_mixers;
+                spec->num_init_verbs = 2;
+                spec->init_verbs[1] = ad1986a_eapd_init_verbs;
+                spec->multiout.max_channels = 2;
+                spec->multiout.num_dacs = 1;
+                spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
+                spec->multiout.dig_out_nid = 0;
+                spec->input_mux = &ad1986a_laptop_eapd_capture_source;
+                break;
+        }
 
         return 0;
@@ -959 +981 @@
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-                .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
+                .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
                 .info = ad1983_spdif_route_info,
                 .get = ad1983_spdif_route_get,
@@ -1015 +1037 @@
                 return -ENOMEM;
 
-        init_MUTEX(&spec->amp_mutex);
+        mutex_init(&spec->amp_mutex);
         codec->spec = spec;
 
@@ -1023 +1045 @@
         spec->multiout.dig_out_nid = AD1983_SPDIF_OUT;
         spec->num_adc_nids = 1;
-        spec->adc_nids = ad1983_adc_nids;
-        spec->capsrc_nids = ad1983_capsrc_nids;
+        spec->adc_nids = ad1983_adc_nids;
+        spec->capsrc_nids = ad1983_capsrc_nids;
         spec->input_mux = &ad1983_capture_source;
         spec->num_mixers = 1;
@@ -1098 +1120 @@
         /* identical with AD1983 */
         {
-            .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-            .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
                 .info = ad1983_spdif_route_info,
                 .get = ad1983_spdif_route_get,
                 .put = ad1983_spdif_route_put,
-        },
+        },
         {0} /* end */
 };
@@ -1161 +1183 @@
  */
 
-#define AD1981_HP_EVENT         0x37
-#define AD1981_MIC_EVENT        0x38
+#define AD1981_HP_EVENT         0x37
+#define AD1981_MIC_EVENT        0x38
 
 static struct hda_verb ad1981_hp_init_verbs[] = {
-    {0x05, AC_VERB_SET_EAPD_BTLENABLE, 0x00 }, /* default off */
-    /* pin sensing on HP and Mic jacks */
-    {0x06, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_HP_EVENT},
-    {0x08, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_MIC_EVENT},
-    {0}
+        {0x05, AC_VERB_SET_EAPD_BTLENABLE, 0x00 }, /* default off */
+        /* pin sensing on HP and Mic jacks */
+        {0x06, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_HP_EVENT},
+        {0x08, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_MIC_EVENT},
+        {0}
 };
 
 /* turn on/off EAPD (+ mute HP) as a master switch */
 static int ad1981_hp_master_sw_put(struct snd_kcontrol *kcontrol,
-                                   struct snd_ctl_elem_value *ucontrol)
-{
-    struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-    struct ad198x_spec *spec = codec->spec;
-
-    if (! ad198x_eapd_put(kcontrol, ucontrol))
-        return 0;
-
-    /* toggle HP mute appropriately */
-    snd_hda_codec_amp_update(codec, 0x06, 0, HDA_OUTPUT, 0,
-                             0x80, spec->cur_eapd ? 0 : 0x80);
-    snd_hda_codec_amp_update(codec, 0x06, 1, HDA_OUTPUT, 0,
-                             0x80, spec->cur_eapd ? 0 : 0x80);
-    return 1;
+                                   struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct ad198x_spec *spec = codec->spec;
+
+        if (! ad198x_eapd_put(kcontrol, ucontrol))
+                return 0;
+
+        /* toggle HP mute appropriately */
+        snd_hda_codec_amp_update(codec, 0x06, 0, HDA_OUTPUT, 0,
+                                 0x80, spec->cur_eapd ? 0 : 0x80);
+        snd_hda_codec_amp_update(codec, 0x06, 1, HDA_OUTPUT, 0,
+                                 0x80, spec->cur_eapd ? 0 : 0x80);
+        return 1;
 }
 
 /* bind volumes of both NID 0x05 and 0x06 */
 static int ad1981_hp_master_vol_put(struct snd_kcontrol *kcontrol,
-                                    struct snd_ctl_elem_value *ucontrol)
-{
-    struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-    long *valp = ucontrol->value.integer.value;
-    int change;
-
-    change = snd_hda_codec_amp_update(codec, 0x05, 0, HDA_OUTPUT, 0,
-                                      0x7f, valp[0] & 0x7f);
-    change |= snd_hda_codec_amp_update(codec, 0x05, 1, HDA_OUTPUT, 0,
-                                       0x7f, valp[1] & 0x7f);
-    snd_hda_codec_amp_update(codec, 0x06, 0, HDA_OUTPUT, 0,
-                             0x7f, valp[0] & 0x7f);
-    snd_hda_codec_amp_update(codec, 0x06, 1, HDA_OUTPUT, 0,
-                             0x7f, valp[1] & 0x7f);
-    return change;
+                                    struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        long *valp = ucontrol->value.integer.value;
+        int change;
+
+        change = snd_hda_codec_amp_update(codec, 0x05, 0, HDA_OUTPUT, 0,
+                                          0x7f, valp[0] & 0x7f);
+        change |= snd_hda_codec_amp_update(codec, 0x05, 1, HDA_OUTPUT, 0,
+                                           0x7f, valp[1] & 0x7f);
+        snd_hda_codec_amp_update(codec, 0x06, 0, HDA_OUTPUT, 0,
+                                 0x7f, valp[0] & 0x7f);
+        snd_hda_codec_amp_update(codec, 0x06, 1, HDA_OUTPUT, 0,
+                                 0x7f, valp[1] & 0x7f);
+        return change;
 }
 
@@ -1212 +1234 @@
 static void ad1981_hp_automute(struct hda_codec *codec)
 {
-    unsigned int present;
-
-    present = snd_hda_codec_read(codec, 0x06, 0,
-                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-    snd_hda_codec_amp_update(codec, 0x05, 0, HDA_OUTPUT, 0,
-                             0x80, present ? 0x80 : 0);
-    snd_hda_codec_amp_update(codec, 0x05, 1, HDA_OUTPUT, 0,
-                             0x80, present ? 0x80 : 0);
+        unsigned int present;
+
+        present = snd_hda_codec_read(codec, 0x06, 0,
+                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
+        snd_hda_codec_amp_update(codec, 0x05, 0, HDA_OUTPUT, 0,
+                                 0x80, present ? 0x80 : 0);
+        snd_hda_codec_amp_update(codec, 0x05, 1, HDA_OUTPUT, 0,
+                                 0x80, present ? 0x80 : 0);
 }
 
@@ -1225 +1247 @@
 static void ad1981_hp_automic(struct hda_codec *codec)
 {
-    static struct hda_verb mic_jack_on[] = {
-        {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
-        {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
-        {0}
-    };
-    static struct hda_verb mic_jack_off[] = {
-        {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
-        {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
-        {0}
-    };
-    unsigned int present;
-
-    present = snd_hda_codec_read(codec, 0x08, 0,
-                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-    if (present)
-        snd_hda_sequence_write(codec, mic_jack_on);
-    else
-        snd_hda_sequence_write(codec, mic_jack_off);
+        static struct hda_verb mic_jack_on[] = {
+                {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
+                {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
+                {0}
+        };
+        static struct hda_verb mic_jack_off[] = {
+                {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
+                {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
+                {0}
+        };
+        unsigned int present;
+
+        present = snd_hda_codec_read(codec, 0x08, 0,
+                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
+        if (present)
+                snd_hda_sequence_write(codec, mic_jack_on);
+        else
+                snd_hda_sequence_write(codec, mic_jack_off);
 }
 
 /* unsolicited event for HP jack sensing */
 static void ad1981_hp_unsol_event(struct hda_codec *codec,
-                                  unsigned int res)
-{
-    res >>= 26;
-    switch (res) {
-    case AD1981_HP_EVENT:
-        ad1981_hp_automute(codec);
-        break;
-    case AD1981_MIC_EVENT:
-        ad1981_hp_automic(codec);
-        break;
-    }
+                                  unsigned int res)
+{
+        res >>= 26;
+        switch (res) {
+        case AD1981_HP_EVENT:
+                ad1981_hp_automute(codec);
+                break;
+        case AD1981_MIC_EVENT:
+                ad1981_hp_automic(codec);
+                break;
+        }
 }
 
 static struct hda_input_mux ad1981_hp_capture_source = {
-    .num_items = 3,
-    .items = {
-        { "Mic", 0x0 },
-        { "Docking-Station", 0x1 },
-        { "Mix", 0x2 },
-    },
+        .num_items = 3,
+        .items = {
+                { "Mic", 0x0 },
+                { "Docking-Station", 0x1 },
+                { "Mix", 0x2 },
+        },
 };
 
 static struct snd_kcontrol_new ad1981_hp_mixers[] = {
-    {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "Master Playback Volume",
-        .info = snd_hda_mixer_amp_volume_info,
-        .get = snd_hda_mixer_amp_volume_get,
-        .put = ad1981_hp_master_vol_put,
-        .private_value = HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
-    },
-    {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "Master Playback Switch",
-        .info = ad198x_eapd_info,
-        .get = ad198x_eapd_get,
-        .put = ad1981_hp_master_sw_put,
-        .private_value = 0x05,
-    },
-    HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Master Playback Volume",
+                .info = snd_hda_mixer_amp_volume_info,
+                .get = snd_hda_mixer_amp_volume_get,
+                .put = ad1981_hp_master_vol_put,
+                .private_value = HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
+        },
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Master Playback Switch",
+                .info = ad198x_eapd_info,
+                .get = ad198x_eapd_get,
+                .put = ad1981_hp_master_sw_put,
+                .private_value = 0x05,
+        },
+        HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
 #if 0
-    /* FIXME: analog mic/line loopback doesn't work with my tests...
-     *        (although recording is OK)
-     */
-    HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
-    HDA_CODEC_VOLUME("Docking-Station Playback Volume", 0x13, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE("Docking-Station Playback Switch", 0x13, 0x0, HDA_OUTPUT),
-    HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x1c, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
-    /* FIXME: does this laptop have analog CD connection? */
-    HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
+        /* FIXME: analog mic/line loopback doesn't work with my tests...
+         *        (although recording is OK)
+         */
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Docking-Station Playback Volume", 0x13, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Docking-Station Playback Switch", 0x13, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x1c, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
+        /* FIXME: does this laptop have analog CD connection? */
+        HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
 #endif
-    HDA_CODEC_VOLUME("Mic Boost", 0x08, 0x0, HDA_INPUT),
-    HDA_CODEC_VOLUME("Internal Mic Boost", 0x18, 0x0, HDA_INPUT),
-    HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
-    {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "Capture Source",
-        .info = ad198x_mux_enum_info,
-        .get = ad198x_mux_enum_get,
-        .put = ad198x_mux_enum_put,
-    },
-        /* identical with AD1983 */
+        HDA_CODEC_VOLUME("Mic Boost", 0x08, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Internal Mic Boost", 0x18, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Capture Source",
+                .info = ad198x_mux_enum_info,
+                .get = ad198x_mux_enum_get,
+                .put = ad198x_mux_enum_put,
+        },
+        {0} /* end */
+};
+
+/* initialize jack-sensing, too */
+static int ad1981_hp_init(struct hda_codec *codec)
+{
+        ad198x_init(codec);
+        ad1981_hp_automute(codec);
+        ad1981_hp_automic(codec);
+        return 0;
+}
+
+/* configuration for Lenovo Thinkpad T60 */
+static struct snd_kcontrol_new ad1981_thinkpad_mixers[] = {
+        HDA_CODEC_VOLUME("Master Playback Volume", 0x05, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Master Playback Switch", 0x05, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Mic Boost", 0x08, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Capture Source",
+                .info = ad198x_mux_enum_info,
+                .get = ad198x_mux_enum_get,
+                .put = ad198x_mux_enum_put,
+        },
+        /* identical with AD1983 */
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
@@ -1321 +1375 @@
                 .put = ad1983_spdif_route_put,
         },
-    {0} /* end */
-};
-
-/* initialize jack-sensing, too */
-static int ad1981_hp_init(struct hda_codec *codec)
-{
-    ad198x_init(codec);
-    ad1981_hp_automute(codec);
-    ad1981_hp_automic(codec);
-    return 0;
-}
-
-/* configuration for Lenovo Thinkpad T60 */
-static struct snd_kcontrol_new ad1981_thinkpad_mixers[] = {
-    HDA_CODEC_VOLUME("Master Playback Volume", 0x05, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE("Master Playback Switch", 0x05, 0x0, HDA_OUTPUT),
-    HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
-    HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
-    HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
-    HDA_CODEC_VOLUME("Mic Boost", 0x08, 0x0, HDA_INPUT),
-    HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
-    {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "Capture Source",
-        .info = ad198x_mux_enum_info,
-        .get = ad198x_mux_enum_get,
-        .put = ad198x_mux_enum_put,
-    },
-    {0} /* end */
+        {0} /* end */
 };
 
 static struct hda_input_mux ad1981_thinkpad_capture_source = {
-    .num_items = 3,
-    .items = {
-        { "Mic", 0x0 },
-        { "Mix", 0x2 },
-        { "CD", 0x4 },
-    },
+        .num_items = 3,
+        .items = {
+                { "Mic", 0x0 },
+                { "Mix", 0x2 },
+                { "CD", 0x4 },
+        },
 };
 
 /* models */
-enum { AD1981_BASIC, AD1981_HP, AD1981_THINKPAD };
-
-static struct hda_board_config ad1981_cfg_tbl[] = {
-    { .modelname = "hp", .config = AD1981_HP },
-    { .pci_subvendor = 0x103c, .pci_subdevice = 0x30aa,
-    .config = AD1981_HP }, /* HP nx6320 */
-    { .pci_subvendor = 0x103c, .pci_subdevice = 0x309f,
-    .config = AD1981_HP }, /* HP nx9420 AngelFire */
-    { .pci_subvendor = 0x30b0, .pci_subdevice = 0x103c,
-    .config = AD1981_HP }, /* HP nx6320 (reversed SSID, H/W bug) */
-    { .modelname = "basic", .config = AD1981_BASIC },
-    { .modelname = "thinkpad", .config = AD1981_THINKPAD },
-    /* Lenovo Thinkpad T60/X60/Z6xx */
-    { .pci_subvendor = 0x17aa, .config = AD1981_THINKPAD },
-    { .pci_subvendor = 0x1014, .pci_subdevice = 0x0597,
-    .config = AD1981_THINKPAD }, /* Z60m/t */
-    { .modelname = "basic", .config = AD1981_BASIC },
-    {0}
+enum {
+        AD1981_BASIC,
+        AD1981_HP,
+        AD1981_THINKPAD,
+        AD1981_MODELS
+};
+
+static const char *ad1981_models[AD1981_MODELS] = {
+        [AD1981_HP]             = "hp",
+        [AD1981_THINKPAD]       = "thinkpad",
+        [AD1981_BASIC]          = "basic",
+};
+
+static struct snd_pci_quirk ad1981_cfg_tbl[] = {
+        /* All HP models */
+        SND_PCI_QUIRK(0x103c, 0, "HP nx", AD1981_HP),
+        /* HP nx6320 (reversed SSID, H/W bug) */
+        SND_PCI_QUIRK(0x30b0, 0x103c, "HP nx6320", AD1981_HP),
+        /* Lenovo Thinkpad T60/X60/Z6xx */
+        SND_PCI_QUIRK(0x17aa, 0, "Lenovo Thinkpad", AD1981_THINKPAD),
+        SND_PCI_QUIRK(0x1014, 0x0597, "Lenovo Z60", AD1981_THINKPAD),
+        {0}
 };
 
 static int patch_ad1981(struct hda_codec *codec)
 {
-    struct ad198x_spec *spec;
-    int board_config;
+        struct ad198x_spec *spec;
+        int board_config;
 
         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
@@ -1395 +1421 @@
                 return -ENOMEM;
 
-        init_MUTEX(&spec->amp_mutex);
+        mutex_init(&spec->amp_mutex);
         codec->spec = spec;
 
@@ -1404 +1430 @@
         spec->num_adc_nids = 1;
         spec->adc_nids = ad1981_adc_nids;
-        spec->capsrc_nids = ad1981_capsrc_nids;
+        spec->capsrc_nids = ad1981_capsrc_nids;
         spec->input_mux = &ad1981_capture_source;
         spec->num_mixers = 1;
@@ -1414 +1440 @@
         codec->patch_ops = ad198x_patch_ops;
 
-        /* override some parameters */
-        board_config = snd_hda_check_board_config(codec, ad1981_cfg_tbl);
-        switch (board_config) {
-        case AD1981_HP:
-            spec->mixers[0] = ad1981_hp_mixers;
-            spec->num_init_verbs = 2;
-            spec->init_verbs[1] = ad1981_hp_init_verbs;
-            spec->multiout.dig_out_nid = 0;
-            spec->input_mux = &ad1981_hp_capture_source;
-
-            codec->patch_ops.init = ad1981_hp_init;
-            codec->patch_ops.unsol_event = ad1981_hp_unsol_event;
-            break;
-        case AD1981_THINKPAD:
-            spec->mixers[0] = ad1981_thinkpad_mixers;
-            spec->multiout.dig_out_nid = 0;
-            spec->input_mux = &ad1981_thinkpad_capture_source;
-            break;
-        }
+        /* override some parameters */
+        board_config = snd_hda_check_board_config(codec, AD1981_MODELS,
+                                                  ad1981_models,
+                                                  ad1981_cfg_tbl);
+        switch (board_config) {
+        case AD1981_HP:
+                spec->mixers[0] = ad1981_hp_mixers;
+                spec->num_init_verbs = 2;
+                spec->init_verbs[1] = ad1981_hp_init_verbs;
+                spec->multiout.dig_out_nid = 0;
+                spec->input_mux = &ad1981_hp_capture_source;
+
+                codec->patch_ops.init = ad1981_hp_init;
+                codec->patch_ops.unsol_event = ad1981_hp_unsol_event;
+                break;
+        case AD1981_THINKPAD:
+                spec->mixers[0] = ad1981_thinkpad_mixers;
+                spec->input_mux = &ad1981_thinkpad_capture_source;
+                break;
+        }
+
         return 0;
 }
@@ -1541 +1569 @@
         ((codec)->vendor_id == 0x11d41988 && \
          (codec)->revision_id == AD1988A_REV2)
+
 /*
  * mixers
@@ -1618 +1647 @@
         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
         struct ad198x_spec *spec = codec->spec;
-        return snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
-                                   spec->num_channel_mode, &spec->multiout.max_channels);
+        int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
+                                      spec->num_channel_mode,
+                                      &spec->multiout.max_channels);
+        if (err >= 0 && spec->need_dac_fix)
+                spec->multiout.num_dacs = spec->multiout.max_channels / 2;
+        return err;
 }
 
@@ -1629 +1662 @@
         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT),
         HDA_CODEC_VOLUME("Side Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
+        {0} /* end */
 };
 
@@ -1637 +1671 @@
         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0a, 2, 0x0, HDA_OUTPUT),
         HDA_CODEC_VOLUME("Side Playback Volume", 0x06, 0x0, HDA_OUTPUT),
+        {0} /* end */
 };
 
@@ -1675 +1710 @@
         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT),
         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT),
+        {0} /* end */
 };
 
@@ -1682 +1718 @@
         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x06, 1, 0x0, HDA_OUTPUT),
         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x06, 2, 0x0, HDA_OUTPUT),
+        {0} /* end */
 };
 
@@ -1743 +1780 @@
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-                .name = "External Amplifier",
-                .info = ad198x_eapd_info,
-                .get = ad198x_eapd_get,
-                .put = ad198x_eapd_put,
-                .private_value = 0x12 | (1 << 8), /* port-D, inversed */
+                .name = "External Amplifier",
+                .info = ad198x_eapd_info,
+                .get = ad198x_eapd_get,
+                .put = ad198x_eapd_put,
+                .private_value = 0x12 | (1 << 8), /* port-D, inversed */
         },
 
@@ -2119 +2156 @@
         else
                 snd_hda_sequence_write(codec, ad1988_laptop_hp_off);
-}
+} 
 
 
@@ -2187 +2224 @@
                 /* A     B     C     D     E     F     G     H */
                 0x04, 0x05, 0x0a, 0x04, 0x06, 0x05, 0x0a, 0x06
-        };
-        if (is_rev2(codec))
+        };
+        if (is_rev2(codec))
                 return idx_to_dac_rev2[idx];
         else
@@ -2320 +2357 @@
         idx = ad1988_pin_idx(pin);
         nid = ad1988_idx_to_dac(codec, idx);
-        /* specify the DAC as the extra output */
-        if (! spec->multiout.hp_nid)
-            spec->multiout.hp_nid = nid;
-        else
-            spec->multiout.extra_out_nid[0] = nid;
+        /* specify the DAC as the extra output */
+        if (! spec->multiout.hp_nid)
+                spec->multiout.hp_nid = nid;
+        else
+                spec->multiout.extra_out_nid[0] = nid;
         /* control HP volume/switch on the output mixer amp */
         sprintf(name, "%s Playback Volume", pfx);
@@ -2443 +2480 @@
         hda_nid_t pin;
 
-        pin = spec->autocfg.speaker_pins[0];
+        pin = spec->autocfg.speaker_pins[0];
         if (pin) /* connect to front */
                 ad1988_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
-        pin = spec->autocfg.hp_pin;
+        pin = spec->autocfg.hp_pins[0];
         if (pin) /* connect to front */
                 ad1988_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
@@ -2491 +2528 @@
                 return err;
         if ((err = ad1988_auto_fill_dac_nids(codec, &spec->autocfg)) < 0)
-            return err;
-        if (! spec->autocfg.line_outs)
+                return err;
+        if (! spec->autocfg.line_outs)
                 return 0; /* can't find valid BIOS pin config */
-        if ((err = ad1988_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0 ||
-            (err = ad1988_auto_create_extra_out(codec,
-                                                spec->autocfg.speaker_pins[0],
-                                                "Speaker")) < 0 ||
-            (err = ad1988_auto_create_extra_out(codec, spec->autocfg.hp_pin,
+        if ((err = ad1988_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0 ||
+            (err = ad1988_auto_create_extra_out(codec,
+                                                spec->autocfg.speaker_pins[0],
+                                                "Speaker")) < 0 ||
+            (err = ad1988_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
                                                 "Headphone")) < 0 ||
             (err = ad1988_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0)
@@ -2534 +2571 @@
  */
 
-static struct hda_board_config ad1988_cfg_tbl[] = {
-        { .modelname = "6stack",        .config = AD1988_6STACK },
-        { .modelname = "6stack-dig",    .config = AD1988_6STACK_DIG },
-        { .modelname = "3stack",        .config = AD1988_3STACK },
-        { .modelname = "3stack-dig",    .config = AD1988_3STACK_DIG },
-        { .modelname = "laptop",        .config = AD1988_LAPTOP },
-        { .modelname = "laptop-dig",    .config = AD1988_LAPTOP_DIG },
-        { .modelname = "auto",          .config = AD1988_AUTO },
-        {0}
+static const char *ad1988_models[AD1988_MODEL_LAST] = {
+        [AD1988_6STACK]         = "6stack",
+        [AD1988_6STACK_DIG]     = "6stack-dig",
+        [AD1988_3STACK]         = "3stack",
+        [AD1988_3STACK_DIG]     = "3stack-dig",
+        [AD1988_LAPTOP]         = "laptop",
+        [AD1988_LAPTOP_DIG]     = "laptop-dig",
+        [AD1988_AUTO]           = "auto",
 };
 
@@ -2554 +2590 @@
                 return -ENOMEM;
 
-        init_MUTEX(&spec->amp_mutex);
+        mutex_init(&spec->amp_mutex);
         codec->spec = spec;
 
-        if (is_rev2(codec))
+        if (is_rev2(codec))
                 snd_printk(KERN_INFO "patch_analog: AD1988A rev.2 is detected, enable workarounds\n");
 
-        board_config = snd_hda_check_board_config(codec, ad1988_cfg_tbl);
-        if (board_config < 0 || board_config >= AD1988_MODEL_LAST) {
+        board_config = snd_hda_check_board_config(codec, AD1988_MODEL_LAST,
+                                                  ad1988_models, NULL);
+        if (board_config < 0) {
                 printk(KERN_INFO "hda_codec: Unknown model for AD1988, trying auto-probe from BIOS...\n");
                 board_config = AD1988_AUTO;
@@ -2582 +2619 @@
         case AD1988_6STACK_DIG:
                 spec->multiout.max_channels = 8;
-                spec->multiout.num_dacs = 4;
-                if (is_rev2(codec))
+                spec->multiout.num_dacs = 4;
+                if (is_rev2(codec))
                         spec->multiout.dac_nids = ad1988_6stack_dac_nids_rev2;
                 else
                         spec->multiout.dac_nids = ad1988_6stack_dac_nids;
                 spec->input_mux = &ad1988_6stack_capture_source;
-                spec->num_mixers = 2;
-                if (is_rev2(codec))
+                spec->num_mixers = 2;
+                if (is_rev2(codec))
                         spec->mixers[0] = ad1988_6stack_mixers1_rev2;
                 else
@@ -2604 +2641 @@
         case AD1988_3STACK_DIG:
                 spec->multiout.max_channels = 6;
-                spec->multiout.num_dacs = 3;
-                if (is_rev2(codec))
+                spec->multiout.num_dacs = 3;
+                if (is_rev2(codec))
                         spec->multiout.dac_nids = ad1988_3stack_dac_nids_rev2;
                 else
@@ -2612 +2649 @@
                 spec->channel_mode = ad1988_3stack_modes;
                 spec->num_channel_mode = ARRAY_SIZE(ad1988_3stack_modes);
-                spec->num_mixers = 2;
-                if (is_rev2(codec))
+                spec->num_mixers = 2;
+                if (is_rev2(codec))
                         spec->mixers[0] = ad1988_3stack_mixers1_rev2;
                 else
@@ -2673 +2710 @@
         { .id = 0x11d41986, .name = "AD1986A", .patch = patch_ad1986a },
         { .id = 0x11d41988, .name = "AD1988", .patch = patch_ad1988 },
+        { .id = 0x11d4198b, .name = "AD1988B", .patch = patch_ad1988 },
         {0} /* terminator */
 };

GPL/trunk/alsa-kernel/pci/hda/patch_cmedia.c

@@ -41 +41 @@
         CMI_ALLOUT,     /* back 5-jack + front-panel 2-jack + digital out */
         CMI_AUTO,       /* let driver guess it */
+        CMI_MODELS
 };
 
@@ -604 +605 @@
  */
 
-static struct hda_board_config cmi9880_cfg_tbl[] = {
-        { .modelname = "minimal", .config = CMI_MINIMAL },
-        { .modelname = "min_fp", .config = CMI_MIN_FP },
-        { .modelname = "full", .config = CMI_FULL },
-        { .modelname = "full_dig", .config = CMI_FULL_DIG },
-        { .pci_subvendor = 0x1043, .pci_subdevice = 0x813d, .config = CMI_FULL_DIG }, /* ASUS P5AD2 */
-        { .modelname = "allout", .config = CMI_ALLOUT },
-        { .modelname = "auto", .config = CMI_AUTO },
+static const char *cmi9880_models[CMI_MODELS] = {
+        [CMI_MINIMAL]   = "minimal",
+        [CMI_MIN_FP]    = "min_fp",
+        [CMI_FULL]      = "full",
+        [CMI_FULL_DIG]  = "full_dig",
+        [CMI_ALLOUT]    = "allout",
+        [CMI_AUTO]      = "auto",
+};
+
+static struct snd_pci_quirk cmi9880_cfg_tbl[] = {
+        SND_PCI_QUIRK(0x1043, 0x813d, "ASUS P5AD2", CMI_FULL_DIG),
         {0} /* terminator */
 };
@@ -634 +638 @@
 
         codec->spec = spec;
-        spec->board_config = snd_hda_check_board_config(codec, cmi9880_cfg_tbl);
+        spec->board_config = snd_hda_check_board_config(codec, CMI_MODELS,
+                                                        cmi9880_models,
+                                                        cmi9880_cfg_tbl);
         if (spec->board_config < 0) {
                 snd_printdd(KERN_INFO "hda_codec: Unknown model for CMI9880\n");

GPL/trunk/alsa-kernel/pci/hda/patch_realtek.c

@@ -33 +33 @@
 #include "hda_local.h"
 
+#define ALC880_FRONT_EVENT              0x01
+#define ALC880_DCVOL_EVENT              0x02
+#define ALC880_HP_EVENT                 0x04
+#define ALC880_MIC_EVENT                0x08
 
 /* ALC880 board config type */
 enum {
-    ALC880_3ST,
-    ALC880_3ST_DIG,
-    ALC880_5ST,
-    ALC880_5ST_DIG,
-    ALC880_W810,
-    ALC880_Z71V,
-    ALC880_6ST,
-    ALC880_6ST_DIG,
-    ALC880_F1734,
-    ALC880_ASUS,
-    ALC880_ASUS_DIG,
-    ALC880_ASUS_W1V,
-    ALC880_ASUS_DIG2,
-    ALC880_UNIWILL_DIG,
-    ALC880_CLEVO,
-    ALC880_TCL_S700,
-    ALC880_LG,
-    ALC880_LG_LW,
+        ALC880_3ST,
+        ALC880_3ST_DIG,
+        ALC880_5ST,
+        ALC880_5ST_DIG,
+        ALC880_W810,
+        ALC880_Z71V,
+        ALC880_6ST,
+        ALC880_6ST_DIG,
+        ALC880_F1734,
+        ALC880_ASUS,
+        ALC880_ASUS_DIG,
+        ALC880_ASUS_W1V,
+        ALC880_ASUS_DIG2,
+        ALC880_UNIWILL_DIG,
+        ALC880_UNIWILL,
+        ALC880_UNIWILL_P53,
+        ALC880_CLEVO,
+        ALC880_TCL_S700,
+        ALC880_LG,
+        ALC880_LG_LW,
 #ifdef CONFIG_SND_DEBUG
-    ALC880_TEST,
+        ALC880_TEST,
 #endif
-    ALC880_AUTO,
-    ALC880_MODEL_LAST /* last tag */
+        ALC880_AUTO,
+        ALC880_MODEL_LAST /* last tag */
 };
 
 /* ALC260 models */
 enum {
-    ALC260_BASIC,
-    ALC260_HP,
-    ALC260_HP_3013,
-    ALC260_FUJITSU_S702X,
-    ALC260_ACER,
+        ALC260_BASIC,
+        ALC260_HP,
+        ALC260_HP_3013,
+        ALC260_FUJITSU_S702X,
+        ALC260_ACER,
 #ifdef CONFIG_SND_DEBUG
-    ALC260_TEST,
+        ALC260_TEST,
 #endif
-    ALC260_AUTO,
-    ALC260_MODEL_LAST /* last tag */
+        ALC260_AUTO,
+        ALC260_MODEL_LAST /* last tag */
 };
 
 /* ALC262 models */
 enum {
-    ALC262_BASIC,
-    ALC262_FUJITSU,
-    ALC262_HP_BPC,
-    ALC262_AUTO,
-    ALC262_MODEL_LAST /* last tag */
+        ALC262_BASIC,
+        ALC262_HIPPO,
+        ALC262_HIPPO_1,
+        ALC262_FUJITSU,
+        ALC262_HP_BPC,
+        ALC262_BENQ_ED8,
+        ALC262_AUTO,
+        ALC262_MODEL_LAST /* last tag */
 };
 
 /* ALC861 models */
 enum {
-    ALC861_3ST,
-    ALC660_3ST,
-    ALC861_3ST_DIG,
-    ALC861_6ST_DIG,
-    ALC861_AUTO,
-    ALC861_MODEL_LAST,
+        ALC861_3ST,
+        ALC660_3ST,
+        ALC861_3ST_DIG,
+        ALC861_6ST_DIG,
+        ALC861_UNIWILL_M31,
+        ALC861_TOSHIBA,
+        ALC861_ASUS,
+        ALC861_ASUS_LAPTOP,
+        ALC861_AUTO,
+        ALC861_MODEL_LAST,
 };
 
 /* ALC882 models */
 enum {
-    ALC882_3ST_DIG,
-    ALC882_6ST_DIG,
-    ALC882_AUTO,
-    ALC882_MODEL_LAST,
+        ALC882_3ST_DIG,
+        ALC882_6ST_DIG,
+        ALC882_ARIMA,
+        ALC882_AUTO,
+        ALC885_MACPRO,
+        ALC882_MODEL_LAST,
 };
 
 /* ALC883 models */
 enum {
-    ALC883_3ST_2ch_DIG,
-    ALC883_3ST_6ch_DIG,
-    ALC883_3ST_6ch,
-    ALC883_6ST_DIG,
-    ALC888_DEMO_BOARD,
-    ALC883_AUTO,
-    ALC883_MODEL_LAST,
+        ALC883_3ST_2ch_DIG,
+        ALC883_3ST_6ch_DIG,
+        ALC883_3ST_6ch,
+        ALC883_6ST_DIG,
+        ALC883_TARGA_DIG,
+        ALC883_TARGA_2ch_DIG,
+        ALC888_DEMO_BOARD,
+        ALC883_ACER,
+        ALC883_MEDION,
+        ALC883_LAPTOP_EAPD,
+        ALC883_AUTO,
+        ALC883_MODEL_LAST,
 };
 
@@ -117 +137 @@
 
 struct alc_spec {
-    /* codec parameterization */
-    struct snd_kcontrol_new *mixers[5]; /* mixer arrays */
-    unsigned int num_mixers;
-
-    const struct hda_verb *init_verbs[5]; /* initialization verbs
-    * don't forget NULL
-    * termination!
-    */
-    unsigned int num_init_verbs;
-
-    char *stream_name_analog;   /* analog PCM stream */
-    struct hda_pcm_stream *stream_analog_playback;
-    struct hda_pcm_stream *stream_analog_capture;
-
-    char *stream_name_digital;  /* digital PCM stream */
-    struct hda_pcm_stream *stream_digital_playback;
-    struct hda_pcm_stream *stream_digital_capture;
-
-    /* playback */
-    struct hda_multi_out multiout;      /* playback set-up
-    * max_channels, dacs must be set
-    * dig_out_nid and hp_nid are optional
-    */
-
-    /* capture */
-    unsigned int num_adc_nids;
-    hda_nid_t *adc_nids;
-    hda_nid_t dig_in_nid;               /* digital-in NID; optional */
-
-    /* capture source */
-    const struct hda_input_mux *input_mux;
-    unsigned int cur_mux[3];
-
-    /* channel model */
-    const struct hda_channel_mode *channel_mode;
-    int num_channel_mode;
-
-    /* PCM information */
-    struct hda_pcm pcm_rec[3];  /* used in alc_build_pcms() */
-
-    /* dynamic controls, init_verbs and input_mux */
-    struct auto_pin_cfg autocfg;
-    unsigned int num_kctl_alloc, num_kctl_used;
-    struct snd_kcontrol_new *kctl_alloc;
-    struct hda_input_mux private_imux;
-    hda_nid_t private_dac_nids[5];
-
-    /* hooks */
-    void (*init_hook)(struct hda_codec *codec);
-    void (*unsol_event)(struct hda_codec *codec, unsigned int res);
-
-    /* for pin sensing */
-    unsigned int sense_updated: 1;
-    unsigned int jack_present: 1;
+        /* codec parameterization */
+        struct snd_kcontrol_new *mixers[5];     /* mixer arrays */
+        unsigned int num_mixers;
+
+        const struct hda_verb *init_verbs[5];   /* initialization verbs
+                                                 * don't forget NULL
+                                                 * termination!
+                                                 */
+        unsigned int num_init_verbs;
+
+        char *stream_name_analog;       /* analog PCM stream */
+        struct hda_pcm_stream *stream_analog_playback;
+        struct hda_pcm_stream *stream_analog_capture;
+
+        char *stream_name_digital;      /* digital PCM stream */ 
+        struct hda_pcm_stream *stream_digital_playback;
+        struct hda_pcm_stream *stream_digital_capture;
+
+        /* playback */
+        struct hda_multi_out multiout;  /* playback set-up
+                                         * max_channels, dacs must be set
+                                         * dig_out_nid and hp_nid are optional
+                                         */
+
+        /* capture */
+        unsigned int num_adc_nids;
+        hda_nid_t *adc_nids;
+        hda_nid_t dig_in_nid;           /* digital-in NID; optional */
+
+        /* capture source */
+        unsigned int num_mux_defs;
+        const struct hda_input_mux *input_mux;
+        unsigned int cur_mux[3];
+
+        /* channel model */
+        const struct hda_channel_mode *channel_mode;
+        int num_channel_mode;
+        int need_dac_fix;
+
+        /* PCM information */
+        struct hda_pcm pcm_rec[3];      /* used in alc_build_pcms() */
+
+        /* dynamic controls, init_verbs and input_mux */
+        struct auto_pin_cfg autocfg;
+        unsigned int num_kctl_alloc, num_kctl_used;
+        struct snd_kcontrol_new *kctl_alloc;
+        struct hda_input_mux private_imux;
+        hda_nid_t private_dac_nids[5];
+
+        /* hooks */
+        void (*init_hook)(struct hda_codec *codec);
+        void (*unsol_event)(struct hda_codec *codec, unsigned int res);
+
+        /* for pin sensing */
+        unsigned int sense_updated: 1;
+        unsigned int jack_present: 1;
 };
 
@@ -177 +199 @@
  */
 struct alc_config_preset {
-    struct snd_kcontrol_new *mixers[5]; /* should be identical size with spec */
-    const struct hda_verb *init_verbs[5];
-    unsigned int num_dacs;
-    hda_nid_t *dac_nids;
-    hda_nid_t dig_out_nid;              /* optional */
-    hda_nid_t hp_nid;           /* optional */
-    unsigned int num_adc_nids;
-    hda_nid_t *adc_nids;
-    hda_nid_t dig_in_nid;
-    unsigned int num_channel_mode;
-    const struct hda_channel_mode *channel_mode;
-    const struct hda_input_mux *input_mux;
-    void (*unsol_event)(struct hda_codec *, unsigned int);
-    void (*init_hook)(struct hda_codec *);
+        struct snd_kcontrol_new *mixers[5]; /* should be identical size
+                                             * with spec
+                                             */
+        const struct hda_verb *init_verbs[5];
+        unsigned int num_dacs;
+        hda_nid_t *dac_nids;
+        hda_nid_t dig_out_nid;          /* optional */
+        hda_nid_t hp_nid;               /* optional */
+        unsigned int num_adc_nids;
+        hda_nid_t *adc_nids;
+        hda_nid_t dig_in_nid;
+        unsigned int num_channel_mode;
+        const struct hda_channel_mode *channel_mode;
+        int need_dac_fix;
+        unsigned int num_mux_defs;
+        const struct hda_input_mux *input_mux;
+        void (*unsol_event)(struct hda_codec *, unsigned int);
+        void (*init_hook)(struct hda_codec *);
 };
 
@@ -197 +223 @@
  * input MUX handling
  */
-static int alc_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
-{
-    struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-    struct alc_spec *spec = codec->spec;
-    return snd_hda_input_mux_info(spec->input_mux, uinfo);
-}
-
-static int alc_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
-{
-    struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-    struct alc_spec *spec = codec->spec;
-    unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
-
-    ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
-    return 0;
-}
-
-static int alc_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
-{
-    struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-    struct alc_spec *spec = codec->spec;
-    unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
-    return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
-                                 spec->adc_nids[adc_idx], &spec->cur_mux[adc_idx]);
+static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
+                             struct snd_ctl_elem_info *uinfo)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct alc_spec *spec = codec->spec;
+        unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
+        if (mux_idx >= spec->num_mux_defs)
+                mux_idx = 0;
+        return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
+}
+
+static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
+                            struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct alc_spec *spec = codec->spec;
+        unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
+
+        ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
+        return 0;
+}
+
+static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
+                            struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct alc_spec *spec = codec->spec;
+        unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
+        unsigned int mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
+        return snd_hda_input_mux_put(codec, &spec->input_mux[mux_idx], ucontrol,
+                                     spec->adc_nids[adc_idx],
+                                     &spec->cur_mux[adc_idx]);
 }
 
@@ -227 +261 @@
  * channel mode setting
  */
-static int alc_ch_mode_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
-{
-    struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-    struct alc_spec *spec = codec->spec;
-    return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
-                                spec->num_channel_mode);
+static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
+                            struct snd_ctl_elem_info *uinfo)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct alc_spec *spec = codec->spec;
+        return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
+                                    spec->num_channel_mode);
 }
 
 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
-                           struct snd_ctl_elem_value *ucontrol)
-{
-    struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-    struct alc_spec *spec = codec->spec;
-    return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
-                               spec->num_channel_mode,
-                               spec->multiout.max_channels);
+                           struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct alc_spec *spec = codec->spec;
+        return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
+                                   spec->num_channel_mode,
+                                   spec->multiout.max_channels);
 }
 
 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
-                           struct snd_ctl_elem_value *ucontrol)
-{
-    struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-    struct alc_spec *spec = codec->spec;
-    return snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
-                               spec->num_channel_mode,
-                               &spec->multiout.max_channels);
+                           struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct alc_spec *spec = codec->spec;
+        int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
+                                      spec->num_channel_mode,
+                                      &spec->multiout.max_channels);
+        if (err >= 0 && spec->need_dac_fix)
+                spec->multiout.num_dacs = spec->multiout.max_channels / 2;
+        return err;
 }
 
 /*
  * Control the mode of pin widget settings via the mixer.  "pc" is used
- * instead of "%" to avoid consequences of accidently treating the % as
+ * instead of "%" to avoid consequences of accidently treating the % as 
  * being part of a format specifier.  Maximum allowed length of a value is
  * 63 characters plus NULL terminator.
@@ -265 +303 @@
  * are requested.  Therefore order this list so that this behaviour will not
  * cause problems when mixer clients move through the enum sequentially.
- * NIDs 0x0f and 0x10 have been observed to have this behaviour.
+ * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
+ * March 2006.
  */
 static char *alc_pin_mode_names[] = {
-    "Mic 50pc bias", "Mic 80pc bias",
-    "Line in", "Line out", "Headphone out",
+        "Mic 50pc bias", "Mic 80pc bias",
+        "Line in", "Line out", "Headphone out",
 };
 static unsigned char alc_pin_mode_values[] = {
-    PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
+        PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
 };
 /* The control can present all 5 options, or it can limit the options based
- * in the pin being assumed to be exclusively an input or an output pin.
- */
-#define ALC_PIN_DIR_IN    0x00
-#define ALC_PIN_DIR_OUT   0x01
-#define ALC_PIN_DIR_INOUT 0x02
-
-/* Info about the pin modes supported by the three different pin directions.
+ * in the pin being assumed to be exclusively an input or an output pin.  In
+ * addition, "input" pins may or may not process the mic bias option
+ * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
+ * accept requests for bias as of chip versions up to March 2006) and/or
+ * wiring in the computer.
+ */
+#define ALC_PIN_DIR_IN              0x00
+#define ALC_PIN_DIR_OUT             0x01
+#define ALC_PIN_DIR_INOUT           0x02
+#define ALC_PIN_DIR_IN_NOMICBIAS    0x03
+#define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
+
+/* Info about the pin modes supported by the different pin direction modes. 
  * For each direction the minimum and maximum values are given.
  */
-static signed char alc_pin_mode_dir_info[3][2] = {
-    { 0, 2 },    /* ALC_PIN_DIR_IN */
-    { 3, 4 },    /* ALC_PIN_DIR_OUT */
-    { 0, 4 },    /* ALC_PIN_DIR_INOUT */
+static signed char alc_pin_mode_dir_info[5][2] = {
+        { 0, 2 },    /* ALC_PIN_DIR_IN */
+        { 3, 4 },    /* ALC_PIN_DIR_OUT */
+        { 0, 4 },    /* ALC_PIN_DIR_INOUT */
+        { 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
+        { 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
 };
 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
 #define alc_pin_mode_n_items(_dir) \
-    (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
-
-static int alc_pin_mode_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
-{
-    unsigned int item_num = uinfo->value.enumerated.item;
-    unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
-
-    uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
-    uinfo->count = 1;
-    uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
-
-    if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
-        item_num = alc_pin_mode_min(dir);
-    strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
-    return 0;
-}
-
-static int alc_pin_mode_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
-{
-    unsigned int i;
-    struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-    hda_nid_t nid = kcontrol->private_value & 0xffff;
-    unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
-    long *valp = ucontrol->value.integer.value;
-    unsigned int pinctl = snd_hda_codec_read(codec,nid,0,AC_VERB_GET_PIN_WIDGET_CONTROL,0x00);
-
-    /* Find enumerated value for current pinctl setting */
-    i = alc_pin_mode_min(dir);
-    while (alc_pin_mode_values[i]!=pinctl && i<=alc_pin_mode_max(dir))
-        i++;
-    *valp = i<=alc_pin_mode_max(dir)?i:alc_pin_mode_min(dir);
-    return 0;
-}
-
-static int alc_pin_mode_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
-{
-    signed int change;
-    struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-    hda_nid_t nid = kcontrol->private_value & 0xffff;
-    unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
-    long val = *ucontrol->value.integer.value;
-    unsigned int pinctl = snd_hda_codec_read(codec,nid,0,AC_VERB_GET_PIN_WIDGET_CONTROL,0x00);
-
-    if (val<alc_pin_mode_min(dir) || val>alc_pin_mode_max(dir))
-        val = alc_pin_mode_min(dir);
-
-    change = pinctl != alc_pin_mode_values[val];
-    if (change) {
-        /* Set pin mode to that requested */
-        snd_hda_codec_write(codec,nid,0,AC_VERB_SET_PIN_WIDGET_CONTROL,
-                            alc_pin_mode_values[val]);
-
-        /* Also enable the retasking pin's input/output as required
-         * for the requested pin mode.  Enum values of 2 or less are
-         * input modes.
-         *
-         * Dynamically switching the input/output buffers probably
-         * reduces noise slightly, particularly on input.  However,
-         * havingboth input and output buffers enabled
-         * simultaneously doesn't seem to be problematic.
-         */
-        if (val <= 2) {
-            snd_hda_codec_write(codec,nid,0,AC_VERB_SET_AMP_GAIN_MUTE,
-                                AMP_OUT_MUTE);
-            snd_hda_codec_write(codec,nid,0,AC_VERB_SET_AMP_GAIN_MUTE,
-                                AMP_IN_UNMUTE(0));
-        } else {
-            snd_hda_codec_write(codec,nid,0,AC_VERB_SET_AMP_GAIN_MUTE,
-                                AMP_IN_MUTE(0));
-            snd_hda_codec_write(codec,nid,0,AC_VERB_SET_AMP_GAIN_MUTE,
-                                AMP_OUT_UNMUTE);
-        }
-    }
-    return change;
+        (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
+
+static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
+                             struct snd_ctl_elem_info *uinfo)
+{
+        unsigned int item_num = uinfo->value.enumerated.item;
+        unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
+
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        uinfo->count = 1;
+        uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
+
+        if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
+                item_num = alc_pin_mode_min(dir);
+        strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
+        return 0;
+}
+
+static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
+                            struct snd_ctl_elem_value *ucontrol)
+{
+        unsigned int i;
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        hda_nid_t nid = kcontrol->private_value & 0xffff;
+        unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
+        long *valp = ucontrol->value.integer.value;
+        unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
+                                                 AC_VERB_GET_PIN_WIDGET_CONTROL,
+                                                 0x00);
+
+        /* Find enumerated value for current pinctl setting */
+        i = alc_pin_mode_min(dir);
+        while (alc_pin_mode_values[i] != pinctl && i <= alc_pin_mode_max(dir))
+                i++;
+        *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
+        return 0;
+}
+
+static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
+                            struct snd_ctl_elem_value *ucontrol)
+{
+        signed int change;
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        hda_nid_t nid = kcontrol->private_value & 0xffff;
+        unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
+        long val = *ucontrol->value.integer.value;
+        unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
+                                                 AC_VERB_GET_PIN_WIDGET_CONTROL,
+                                                 0x00);
+
+        if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir)) 
+                val = alc_pin_mode_min(dir);
+
+        change = pinctl != alc_pin_mode_values[val];
+        if (change) {
+                /* Set pin mode to that requested */
+                snd_hda_codec_write(codec,nid,0,AC_VERB_SET_PIN_WIDGET_CONTROL,
+                                    alc_pin_mode_values[val]);
+
+                /* Also enable the retasking pin's input/output as required 
+                 * for the requested pin mode.  Enum values of 2 or less are
+                 * input modes.
+                 *
+                 * Dynamically switching the input/output buffers probably
+                 * reduces noise slightly (particularly on input) so we'll
+                 * do it.  However, having both input and output buffers
+                 * enabled simultaneously doesn't seem to be problematic if
+                 * this turns out to be necessary in the future.
+                 */
+                if (val <= 2) {
+                        snd_hda_codec_write(codec, nid, 0,
+                                            AC_VERB_SET_AMP_GAIN_MUTE,
+                                            AMP_OUT_MUTE);
+                        snd_hda_codec_write(codec, nid, 0,
+                                            AC_VERB_SET_AMP_GAIN_MUTE,
+                                            AMP_IN_UNMUTE(0));
+                } else {
+                        snd_hda_codec_write(codec, nid, 0,
+                                            AC_VERB_SET_AMP_GAIN_MUTE,
+                                            AMP_IN_MUTE(0));
+                        snd_hda_codec_write(codec, nid, 0,
+                                            AC_VERB_SET_AMP_GAIN_MUTE,
+                                            AMP_OUT_UNMUTE);
+                }
+        }
+        return change;
 }
 
 #define ALC_PIN_MODE(xname, nid, dir) \
-    { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
-    .info = alc_pin_mode_info, \
-    .get = alc_pin_mode_get, \
-    .put = alc_pin_mode_put, \
-    .private_value = nid | (dir<<16) }
+        { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
+          .info = alc_pin_mode_info, \
+          .get = alc_pin_mode_get, \
+          .put = alc_pin_mode_put, \
+          .private_value = nid | (dir<<16) }
 
 /* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
@@ -381 +440 @@
  */
 #ifdef CONFIG_SND_DEBUG
-static int alc_gpio_data_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
-{
-    uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
-    uinfo->count = 1;
-    uinfo->value.integer.min = 0;
-    uinfo->value.integer.max = 1;
-    return 0;
-}
-static int alc_gpio_data_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
-{
-    struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-    hda_nid_t nid = kcontrol->private_value & 0xffff;
-    unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
-    long *valp = ucontrol->value.integer.value;
-    unsigned int val = snd_hda_codec_read(codec,nid,0,AC_VERB_GET_GPIO_DATA,0x00);
-
-    *valp = (val & mask) != 0;
-    return 0;
-}
-static int alc_gpio_data_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
-{
-    signed int change;
-    struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-    hda_nid_t nid = kcontrol->private_value & 0xffff;
-    unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
-    long val = *ucontrol->value.integer.value;
-    unsigned int gpio_data = snd_hda_codec_read(codec,nid,0,AC_VERB_GET_GPIO_DATA,0x00);
-
-    /* Set/unset the masked GPIO bit(s) as needed */
-    change = (val==0?0:mask) != (gpio_data & mask);
-    if (val==0)
-        gpio_data &= ~mask;
-    else
-        gpio_data |= mask;
-    snd_hda_codec_write(codec,nid,0,AC_VERB_SET_GPIO_DATA,gpio_data);
-
-    return change;
+static int alc_gpio_data_info(struct snd_kcontrol *kcontrol,
+                              struct snd_ctl_elem_info *uinfo)
+{
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
+        uinfo->count = 1;
+        uinfo->value.integer.min = 0;
+        uinfo->value.integer.max = 1;
+        return 0;
+}                                
+static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
+                             struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        hda_nid_t nid = kcontrol->private_value & 0xffff;
+        unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
+        long *valp = ucontrol->value.integer.value;
+        unsigned int val = snd_hda_codec_read(codec, nid, 0,
+                                              AC_VERB_GET_GPIO_DATA, 0x00);
+
+        *valp = (val & mask) != 0;
+        return 0;
+}
+static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
+                             struct snd_ctl_elem_value *ucontrol)
+{
+        signed int change;
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        hda_nid_t nid = kcontrol->private_value & 0xffff;
+        unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
+        long val = *ucontrol->value.integer.value;
+        unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
+                                                    AC_VERB_GET_GPIO_DATA,
+                                                    0x00);
+
+        /* Set/unset the masked GPIO bit(s) as needed */
+        change = (val == 0 ? 0 : mask) != (gpio_data & mask);
+        if (val == 0)
+                gpio_data &= ~mask;
+        else
+                gpio_data |= mask;
+        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_GPIO_DATA, gpio_data);
+
+        return change;
 }
 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
-    { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
-    .info = alc_gpio_data_info, \
-    .get = alc_gpio_data_get, \
-    .put = alc_gpio_data_put, \
-    .private_value = nid | (mask<<16) }
+        { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
+          .info = alc_gpio_data_info, \
+          .get = alc_gpio_data_get, \
+          .put = alc_gpio_data_put, \
+          .private_value = nid | (mask<<16) }
 #endif   /* CONFIG_SND_DEBUG */
 
@@ -435 +500 @@
  */
 #ifdef CONFIG_SND_DEBUG
-static int alc_spdif_ctrl_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
-{
-    uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
-    uinfo->count = 1;
-    uinfo->value.integer.min = 0;
-    uinfo->value.integer.max = 1;
-    return 0;
-}
-static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
-{
-    struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-    hda_nid_t nid = kcontrol->private_value & 0xffff;
-    unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
-    long *valp = ucontrol->value.integer.value;
-    unsigned int val = snd_hda_codec_read(codec,nid,0,AC_VERB_GET_DIGI_CONVERT,0x00);
-
-    *valp = (val & mask) != 0;
-    return 0;
-}
-static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
-{
-    signed int change;
-    struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-    hda_nid_t nid = kcontrol->private_value & 0xffff;
-    unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
-    long val = *ucontrol->value.integer.value;
-    unsigned int ctrl_data = snd_hda_codec_read(codec,nid,0,AC_VERB_GET_DIGI_CONVERT,0x00);
-
-    /* Set/unset the masked control bit(s) as needed */
-    change = (val==0?0:mask) != (ctrl_data & mask);
-    if (val==0)
-        ctrl_data &= ~mask;
-    else
-        ctrl_data |= mask;
-    snd_hda_codec_write(codec,nid,0,AC_VERB_SET_DIGI_CONVERT_1,ctrl_data);
-
-    return change;
+static int alc_spdif_ctrl_info(struct snd_kcontrol *kcontrol,
+                               struct snd_ctl_elem_info *uinfo)
+{
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
+        uinfo->count = 1;
+        uinfo->value.integer.min = 0;
+        uinfo->value.integer.max = 1;
+        return 0;
+}                                
+static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
+                              struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        hda_nid_t nid = kcontrol->private_value & 0xffff;
+        unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
+        long *valp = ucontrol->value.integer.value;
+        unsigned int val = snd_hda_codec_read(codec, nid, 0,
+                                              AC_VERB_GET_DIGI_CONVERT, 0x00);
+
+        *valp = (val & mask) != 0;
+        return 0;
+}
+static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
+                              struct snd_ctl_elem_value *ucontrol)
+{
+        signed int change;
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        hda_nid_t nid = kcontrol->private_value & 0xffff;
+        unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
+        long val = *ucontrol->value.integer.value;
+        unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
+                                                    AC_VERB_GET_DIGI_CONVERT,
+                                                    0x00);
+
+        /* Set/unset the masked control bit(s) as needed */
+        change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
+        if (val==0)
+                ctrl_data &= ~mask;
+        else
+                ctrl_data |= mask;
+        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
+                            ctrl_data);
+
+        return change;
 }
 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
-    { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
-    .info = alc_spdif_ctrl_info, \
-    .get = alc_spdif_ctrl_get, \
-    .put = alc_spdif_ctrl_put, \
-    .private_value = nid | (mask<<16) }
+        { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
+          .info = alc_spdif_ctrl_info, \
+          .get = alc_spdif_ctrl_get, \
+          .put = alc_spdif_ctrl_put, \
+          .private_value = nid | (mask<<16) }
 #endif   /* CONFIG_SND_DEBUG */
 
@@ -484 +556 @@
  * set up from the preset table
  */
-static void setup_preset(struct alc_spec *spec, const struct alc_config_preset *preset)
-{
-    int i;
-
-    for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
-        spec->mixers[spec->num_mixers++] = preset->mixers[i];
-    for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i]; i++)
-        spec->init_verbs[spec->num_init_verbs++] = preset->init_verbs[i];
-
-    spec->channel_mode = preset->channel_mode;
-    spec->num_channel_mode = preset->num_channel_mode;
-
-    spec->multiout.max_channels = spec->channel_mode[0].channels;
-
-    spec->multiout.num_dacs = preset->num_dacs;
-    spec->multiout.dac_nids = preset->dac_nids;
-    spec->multiout.dig_out_nid = preset->dig_out_nid;
-    spec->multiout.hp_nid = preset->hp_nid;
-
-    spec->input_mux = preset->input_mux;
-
-    spec->num_adc_nids = preset->num_adc_nids;
-    spec->adc_nids = preset->adc_nids;
-    spec->dig_in_nid = preset->dig_in_nid;
-    spec->unsol_event = preset->unsol_event;
-    spec->init_hook = preset->init_hook;
+static void setup_preset(struct alc_spec *spec,
+                         const struct alc_config_preset *preset)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
+                spec->mixers[spec->num_mixers++] = preset->mixers[i];
+        for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
+             i++)
+                spec->init_verbs[spec->num_init_verbs++] =
+                        preset->init_verbs[i];
+        
+        spec->channel_mode = preset->channel_mode;
+        spec->num_channel_mode = preset->num_channel_mode;
+        spec->need_dac_fix = preset->need_dac_fix;
+
+        spec->multiout.max_channels = spec->channel_mode[0].channels;
+
+        spec->multiout.num_dacs = preset->num_dacs;
+        spec->multiout.dac_nids = preset->dac_nids;
+        spec->multiout.dig_out_nid = preset->dig_out_nid;
+        spec->multiout.hp_nid = preset->hp_nid;
+        
+        spec->num_mux_defs = preset->num_mux_defs;
+        if (! spec->num_mux_defs)
+                spec->num_mux_defs = 1;
+        spec->input_mux = preset->input_mux;
+
+        spec->num_adc_nids = preset->num_adc_nids;
+        spec->adc_nids = preset->adc_nids;
+        spec->dig_in_nid = preset->dig_in_nid;
+
+        spec->unsol_event = preset->unsol_event;
+        spec->init_hook = preset->init_hook;
 }
 
@@ -516 +596 @@
  *
  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
- * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18, F-Mic = 0x1b
- *                 HP = 0x19
+ * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
+ *                 F-Mic = 0x1b, HP = 0x19
  */
 
 static hda_nid_t alc880_dac_nids[4] = {
-    /* front, rear, clfe, rear_surr */
-    0x02, 0x05, 0x04, 0x03
+        /* front, rear, clfe, rear_surr */
+        0x02, 0x05, 0x04, 0x03
 };
 
 static hda_nid_t alc880_adc_nids[3] = {
-    /* ADC0-2 */
-    0x07, 0x08, 0x09,
+        /* ADC0-2 */
+        0x07, 0x08, 0x09,
 };
 
@@ -535 +615 @@
  */
 static hda_nid_t alc880_adc_nids_alt[2] = {
-    /* ADC1-2 */
-    0x08, 0x09,
+        /* ADC1-2 */
+        0x08, 0x09,
 };
 
@@ -543 +623 @@
 
 static struct hda_input_mux alc880_capture_source = {
-    .num_items = 4,
-    .items = {
-        { "Mic", 0x0 },
-        { "Front Mic", 0x3 },
-        { "Line", 0x2 },
-        { "CD", 0x4 },
-    },
+        .num_items = 4,
+        .items = {
+                { "Mic", 0x0 },
+                { "Front Mic", 0x3 },
+                { "Line", 0x2 },
+                { "CD", 0x4 },
+        },
 };
 
@@ -555 +635 @@
 /* 2ch mode */
 static struct hda_verb alc880_threestack_ch2_init[] = {
-    /* set line-in to input, mute it */
-    { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
-    { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
-    /* set mic-in to input vref 80%, mute it */
-    { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
-    { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
-    {0} /* end */
+        /* set line-in to input, mute it */
+        { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
+        { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
+        /* set mic-in to input vref 80%, mute it */
+        { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
+        { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
+        {0} /* end */
 };
 
 /* 6ch mode */
 static struct hda_verb alc880_threestack_ch6_init[] = {
-    /* set line-in to output, unmute it */
-    { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
-    { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
-    /* set mic-in to output, unmute it */
-    { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
-    { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
-    {0} /* end */
+        /* set line-in to output, unmute it */
+        { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
+        { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
+        /* set mic-in to output, unmute it */
+        { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
+        { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
+        {0} /* end */
 };
 
 static struct hda_channel_mode alc880_threestack_modes[2] = {
-    { 2, alc880_threestack_ch2_init },
-    { 6, alc880_threestack_ch6_init },
+        { 2, alc880_threestack_ch2_init },
+        { 6, alc880_threestack_ch6_init },
 };
 
 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
-    HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
-    HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
-    HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
-    HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
-    HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
-    HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
-    HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
-    HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
-    HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
-    HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
-    HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
-    HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
-    HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
-    HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
-    HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
-    {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "Channel Mode",
-        .info = alc_ch_mode_info,
-        .get = alc_ch_mode_get,
-        .put = alc_ch_mode_put,
-    },
-    {0} /* end */
+        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
+        HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
+        HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
+        HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
+        HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
+        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
+        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
+        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
+        HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Channel Mode",
+                .info = alc_ch_mode_info,
+                .get = alc_ch_mode_get,
+                .put = alc_ch_mode_put,
+        },
+        {0} /* end */
 };
 
 /* capture mixer elements */
 static struct snd_kcontrol_new alc880_capture_mixer[] = {
-    HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
-    HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x08, 0x0, HDA_INPUT),
-    HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x09, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x09, 0x0, HDA_INPUT),
-    {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        /* The multiple "Capture Source" controls confuse alsamixer
-         * So call somewhat different..
-         * FIXME: the controls appear in the "playback" view!
-         */
-        /* .name = "Capture Source", */
-        .name = "Input Source",
-        .count = 3,
-        .info = alc_mux_enum_info,
-        .get = alc_mux_enum_get,
-        .put = alc_mux_enum_put,
-    },
-    {0} /* end */
+        HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x08, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x09, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x09, 0x0, HDA_INPUT),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                /* The multiple "Capture Source" controls confuse alsamixer
+                 * So call somewhat different..
+                 * FIXME: the controls appear in the "playback" view!
+                 */
+                /* .name = "Capture Source", */
+                .name = "Input Source",
+                .count = 3,
+                .info = alc_mux_enum_info,
+                .get = alc_mux_enum_get,
+                .put = alc_mux_enum_put,
+        },
+        {0} /* end */
 };
 
 /* capture mixer elements (in case NID 0x07 not available) */
 static struct snd_kcontrol_new alc880_capture_alt_mixer[] = {
-    HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
-    HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
-    {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        /* The multiple "Capture Source" controls confuse alsamixer
-         * So call somewhat different..
-         * FIXME: the controls appear in the "playback" view!
-         */
-        /* .name = "Capture Source", */
-        .name = "Input Source",
-        .count = 2,
-        .info = alc_mux_enum_info,
-        .get = alc_mux_enum_get,
-        .put = alc_mux_enum_put,
-    },
-    {0} /* end */
+        HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                /* The multiple "Capture Source" controls confuse alsamixer
+                 * So call somewhat different..
+                 * FIXME: the controls appear in the "playback" view!
+                 */
+                /* .name = "Capture Source", */
+                .name = "Input Source",
+                .count = 2,
+                .info = alc_mux_enum_info,
+                .get = alc_mux_enum_get,
+                .put = alc_mux_enum_put,
+        },
+        {0} /* end */
 };
 
@@ -661 +741 @@
  * ALC880 5-stack model
  *
- * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d), Side = 0x02 (0xd)
+ * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
+ *      Side = 0x02 (0xd)
  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
@@ -668 +749 @@
 /* additional mixers to alc880_three_stack_mixer */
 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
-    HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
-    {0} /* end */
+        HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
+        {0} /* end */
 };
 
@@ -676 +757 @@
 /* 6ch mode */
 static struct hda_verb alc880_fivestack_ch6_init[] = {
-    /* set line-in to input, mute it */
-    { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
-    { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
-    {0} /* end */
+        /* set line-in to input, mute it */
+        { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
+        { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
+        {0} /* end */
 };
 
 /* 8ch mode */
 static struct hda_verb alc880_fivestack_ch8_init[] = {
-    /* set line-in to output, unmute it */
-    { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
-    { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
-    {0} /* end */
+        /* set line-in to output, unmute it */
+        { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
+        { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
+        {0} /* end */
 };
 
 static struct hda_channel_mode alc880_fivestack_modes[2] = {
-    { 6, alc880_fivestack_ch6_init },
-    { 8, alc880_fivestack_ch8_init },
+        { 6, alc880_fivestack_ch6_init },
+        { 8, alc880_fivestack_ch8_init },
 };
 
@@ -699 +780 @@
  * ALC880 6-stack model
  *
- * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e), Side = 0x05 (0x0f)
+ * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
+ *      Side = 0x05 (0x0f)
  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
@@ -705 +787 @@
 
 static hda_nid_t alc880_6st_dac_nids[4] = {
-    /* front, rear, clfe, rear_surr */
-    0x02, 0x03, 0x04, 0x05
-};
+        /* front, rear, clfe, rear_surr */
+        0x02, 0x03, 0x04, 0x05
+};      
 
 static struct hda_input_mux alc880_6stack_capture_source = {
-    .num_items = 4,
-    .items = {
-        { "Mic", 0x0 },
-        { "Front Mic", 0x1 },
-        { "Line", 0x2 },
-        { "CD", 0x4 },
-    },
+        .num_items = 4,
+        .items = {
+                { "Mic", 0x0 },
+                { "Front Mic", 0x1 },
+                { "Line", 0x2 },
+                { "CD", 0x4 },
+        },
 };
 
 /* fixed 8-channels */
 static struct hda_channel_mode alc880_sixstack_modes[1] = {
-    { 8, NULL },
+        { 8, NULL },
 };
 
 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
-    HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
-    HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
-    HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
-    HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
-    HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
-    HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
-    HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
-    HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
-    HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
-    HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
-    HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
-    HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
-    HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
-    HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
-    HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
-    {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "Channel Mode",
-        .info = alc_ch_mode_info,
-        .get = alc_ch_mode_get,
-        .put = alc_ch_mode_put,
-    },
-    {0} /* end */
+        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
+        HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
+        HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
+        HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
+        HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
+        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
+        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
+        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Channel Mode",
+                .info = alc_ch_mode_info,
+                .get = alc_ch_mode_get,
+                .put = alc_ch_mode_put,
+        },
+        {0} /* end */
 };
 
@@ -767 +849 @@
  * The system also has a pair of internal speakers, and a headphone jack.
  * These are both connected to Line2 on the codec, hence to DAC 02.
- *
+ * 
  * There is a variable resistor to control the speaker or headphone
  * volume. This is a hardware-only device without a software API.
@@ -782 +864 @@
 
 static hda_nid_t alc880_w810_dac_nids[3] = {
-    /* front, rear/surround, clfe */
-    0x02, 0x03, 0x04
+        /* front, rear/surround, clfe */
+        0x02, 0x03, 0x04
 };
 
 /* fixed 6 channels */
 static struct hda_channel_mode alc880_w810_modes[1] = {
-    { 6, NULL }
+        { 6, NULL }
 };
 
 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
-    HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
-    HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
-    HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
-    HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
-    HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
-    HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
-    {0} /* end */
+        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
+        HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
+        HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
+        {0} /* end */
 };
 
@@ -810 +892 @@
  *
  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
- * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?), Line = 0x1a
+ * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
+ *                 Line = 0x1a
  */
 
 static hda_nid_t alc880_z71v_dac_nids[1] = {
-    0x02
+        0x02
 };
 #define ALC880_Z71V_HP_DAC      0x03
@@ -820 +903 @@
 /* fixed 2 channels */
 static struct hda_channel_mode alc880_2_jack_modes[1] = {
-    { 2, NULL }
+        { 2, NULL }
 };
 
 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
-    HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
-    HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
-    HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
-    HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
-    HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
-    {0} /* end */
+        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
+        HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
+        {0} /* end */
 };
 
@@ -845 +928 @@
 
 static hda_nid_t alc880_f1734_dac_nids[1] = {
-    0x03
+        0x03
 };
 #define ALC880_F1734_HP_DAC     0x02
 
 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
-    HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
-    HDA_CODEC_VOLUME("Internal Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE("Internal Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
-    HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
-    HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
-    HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
-    {0} /* end */
+        HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME("Internal Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Internal Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
+        HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
+        {0} /* end */
 };
 
@@ -875 +958 @@
 
 static struct snd_kcontrol_new alc880_asus_mixer[] = {
-    HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
-    HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
-    HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
-    HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
-    HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
-    HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
-    HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
-    HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
-    HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
-    HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
-    {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "Channel Mode",
-        .info = alc_ch_mode_info,
-        .get = alc_ch_mode_get,
-        .put = alc_ch_mode_put,
-    },
-    {0} /* end */
+        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
+        HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
+        HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
+        HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
+        HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Channel Mode",
+                .info = alc_ch_mode_info,
+                .get = alc_ch_mode_get,
+                .put = alc_ch_mode_put,
+        },
+        {0} /* end */
 };
 
@@ -910 +993 @@
 /* additional mixers to alc880_asus_mixer */
 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
-    HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
-    HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
-    {0} /* end */
+        HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
+        HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
+        {0} /* end */
 };
 
 /* additional mixers to alc880_asus_mixer */
 static struct snd_kcontrol_new alc880_pcbeep_mixer[] = {
-    HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
-    HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
-    {0} /* end */
+        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
+        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
+        {0} /* end */
 };
 
 /* TCL S700 */
 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
-    HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
-    HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
-    HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
-    HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
-    HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
-    {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        /* The multiple "Capture Source" controls confuse alsamixer
-         * So call somewhat different..
-         * FIXME: the controls appear in the "playback" view!
-         */
-        /* .name = "Capture Source", */
-        .name = "Input Source",
-        .count = 1,
-        .info = alc_mux_enum_info,
-        .get = alc_mux_enum_get,
-        .put = alc_mux_enum_put,
-    },
-    {0} /* end */
+        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
+        HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                /* The multiple "Capture Source" controls confuse alsamixer
+                 * So call somewhat different..
+                 * FIXME: the controls appear in the "playback" view!
+                 */
+                /* .name = "Capture Source", */
+                .name = "Input Source",
+                .count = 1,
+                .info = alc_mux_enum_info,
+                .get = alc_mux_enum_get,
+                .put = alc_mux_enum_put,
+        },
+        {0} /* end */
+};
+
+/* Uniwill */
+static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
+        HDA_CODEC_VOLUME("HPhone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("HPhone Playback Switch", 0x0c, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME("iSpeaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("iSpeaker Playback Switch", 0x0d, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
+        HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
+        HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
+        HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
+        HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
+        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
+        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
+        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Channel Mode",
+                .info = alc_ch_mode_info,
+                .get = alc_ch_mode_get,
+                .put = alc_ch_mode_put,
+        },
+        {0} /* end */
+};
+
+static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
+        HDA_CODEC_VOLUME("HPhone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("HPhone Playback Switch", 0x0c, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME("iSpeaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("iSpeaker Playback Switch", 0x0d, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
+        {0} /* end */
 };
 
@@ -954 +1077 @@
 static int alc_build_controls(struct hda_codec *codec)
 {
-    struct alc_spec *spec = codec->spec;
-    int err;
-    int i;
-
-    for (i = 0; i < spec->num_mixers; i++) {
-        err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
-        if (err < 0)
-            return err;
-    }
-
-    if (spec->multiout.dig_out_nid) {
-        err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
-        if (err < 0)
-            return err;
-    }
-    if (spec->dig_in_nid) {
-        err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
-        if (err < 0)
-            return err;
-    }
-    return 0;
+        struct alc_spec *spec = codec->spec;
+        int err;
+        int i;
+
+        for (i = 0; i < spec->num_mixers; i++) {
+                err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
+                if (err < 0)
+                        return err;
+        }
+
+        if (spec->multiout.dig_out_nid) {
+                err = snd_hda_create_spdif_out_ctls(codec,
+                                                    spec->multiout.dig_out_nid);
+                if (err < 0)
+                        return err;
+        }
+        if (spec->dig_in_nid) {
+                err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
+                if (err < 0)
+                        return err;
+        }
+        return 0;
 }
 
@@ -986 +1110 @@
  */
 static struct hda_verb alc880_volume_init_verbs[] = {
-    /*
-     * Unmute ADC0-2 and set the default input to mic-in
-     */
-    {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
-    {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
-    {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-
-    /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
-     * mixer widget
-     * Note: PASD motherboards uses the Line In 2 as the input for front panel
-     * mic (mic 2)
-     */
-    /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
-
-    /*
-     * Set up output mixers (0x0c - 0x0f)
-     */
-    /* set vol=0 to output mixers */
-    {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    /* set up input amps for analog loopback */
-    /* Amp Indices: DAC = 0, mixer = 1 */
-    {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
-    {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
-    {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
-    {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
-
-    {0}
+        /*
+         * Unmute ADC0-2 and set the default input to mic-in
+         */
+        {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+
+        /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
+         * mixer widget
+         * Note: PASD motherboards uses the Line In 2 as the input for front
+         * panel mic (mic 2)
+         */
+        /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
+
+        /*
+         * Set up output mixers (0x0c - 0x0f)
+         */
+        /* set vol=0 to output mixers */
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        /* set up input amps for analog loopback */
+        /* Amp Indices: DAC = 0, mixer = 1 */
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+
+        {0}
 };
 
@@ -1035 +1159 @@
  */
 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
-    /*
-     * preset connection lists of input pins
-     * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
-     */
-    {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
-    {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
-    {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
-
-    /*
-     * Set pin mode and muting
-     */
-    /* set front pin widgets 0x14 for output */
-    {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    /* Mic1 (rear panel) pin widget for input and vref at 80% */
-    {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
-    {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-    /* Mic2 (as headphone out) for HP output */
-    {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
-    {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    /* Line In pin widget for input */
-    {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
-    {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-    /* Line2 (as front mic) pin widget for input and vref at 80% */
-    {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
-    {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-    /* CD pin widget for input */
-    {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
-
-    {0}
+        /*
+         * preset connection lists of input pins
+         * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
+         */
+        {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
+        {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
+        {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
+
+        /*
+         * Set pin mode and muting
+         */
+        /* set front pin widgets 0x14 for output */
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        /* Mic1 (rear panel) pin widget for input and vref at 80% */
+        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        /* Mic2 (as headphone out) for HP output */
+        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        /* Line In pin widget for input */
+        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        /* Line2 (as front mic) pin widget for input and vref at 80% */
+        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        /* CD pin widget for input */
+        {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+
+        {0}
 };
 
@@ -1073 +1197 @@
  */
 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
-    /*
-     * preset connection lists of input pins
-     * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
-     */
-    {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
-    {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
-
-    /*
-     * Set pin mode and muting
-     */
-    /* set pin widgets 0x14-0x17 for output */
-    {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    /* unmute pins for output (no gain on this amp) */
-    {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-
-    /* Mic1 (rear panel) pin widget for input and vref at 80% */
-    {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
-    {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-    /* Mic2 (as headphone out) for HP output */
-    {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
-    {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    /* Line In pin widget for input */
-    {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
-    {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-    /* Line2 (as front mic) pin widget for input and vref at 80% */
-    {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
-    {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-    /* CD pin widget for input */
-    {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
-
-    {0}
+        /*
+         * preset connection lists of input pins
+         * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
+         */
+        {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
+        {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
+
+        /*
+         * Set pin mode and muting
+         */
+        /* set pin widgets 0x14-0x17 for output */
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        /* unmute pins for output (no gain on this amp) */
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+
+        /* Mic1 (rear panel) pin widget for input and vref at 80% */
+        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        /* Mic2 (as headphone out) for HP output */
+        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        /* Line In pin widget for input */
+        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        /* Line2 (as front mic) pin widget for input and vref at 80% */
+        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        /* CD pin widget for input */
+        {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+
+        {0}
 };
 
@@ -1117 +1241 @@
  */
 static struct hda_verb alc880_pin_w810_init_verbs[] = {
-    /* hphone/speaker input selector: front DAC */
-    {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
-
-    {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-
-    {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
-    {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-
-    {0}
+        /* hphone/speaker input selector: front DAC */
+        {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
+
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+
+        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+
+        {0}
 };
 
@@ -1138 +1262 @@
  */
 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
-    {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
-    {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-
-    {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
-    {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
-    {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
-    {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
-
-    {0}
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+
+        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+
+        {0}
 };
 
 /*
  * 6-stack pin configuration:
- * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18, f-mic = 0x19,
- * line = 0x1a, HP = 0x1b
+ * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
+ * f-mic = 0x19, line = 0x1a, HP = 0x1b
  */
 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
-    {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
-
-    {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-
-    {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
-    {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-    {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
-    {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-    {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
-    {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-    {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
-    {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
-
-    {0}
-};
+        {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
+
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+
+        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        
+        {0}
+};
+
+/*
+ * Uniwill pin configuration:
+ * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
+ * line = 0x1a
+ */
+static struct hda_verb alc880_uniwill_init_verbs[] = {
+        {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
+
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
+        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
+        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
+        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
+        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
+
+        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
+        /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
+        {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+
+        {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
+        {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
+
+        {0}
+};
+
+/*
+* Uniwill P53
+* HP = 0x14, InternalSpeaker = 0x15, mic = 0x19, 
+ */
+static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
+        {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
+
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
+        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
+        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
+        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
+        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
+
+        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+
+        {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
+        {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
+
+        {0}
+};
+
+/* toggle speaker-output according to the hp-jack state */
+static void alc880_uniwill_automute(struct hda_codec *codec)
+{
+        unsigned int present;
+
+        present = snd_hda_codec_read(codec, 0x14, 0,
+                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
+        snd_hda_codec_amp_update(codec, 0x15, 0, HDA_OUTPUT, 0,
+                                 0x80, present ? 0x80 : 0);
+        snd_hda_codec_amp_update(codec, 0x15, 1, HDA_OUTPUT, 0,
+                                 0x80, present ? 0x80 : 0);
+        snd_hda_codec_amp_update(codec, 0x16, 0, HDA_OUTPUT, 0,
+                                 0x80, present ? 0x80 : 0);
+        snd_hda_codec_amp_update(codec, 0x16, 1, HDA_OUTPUT, 0,
+                                 0x80, present ? 0x80 : 0);
+
+        present = snd_hda_codec_read(codec, 0x18, 0,
+                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
+        snd_hda_codec_write(codec, 0x0b, 0, AC_VERB_SET_AMP_GAIN_MUTE,
+                            0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
+}
+
+static void alc880_uniwill_unsol_event(struct hda_codec *codec,
+                                       unsigned int res)
+{
+        /* Looks like the unsol event is incompatible with the standard
+         * definition.  4bit tag is placed at 28 bit!
+         */
+        if ((res >> 28) == ALC880_HP_EVENT ||
+            (res >> 28) == ALC880_MIC_EVENT)
+                alc880_uniwill_automute(codec);
+}
+
+static void alc880_uniwill_p53_hp_automute(struct hda_codec *codec)
+{
+        unsigned int present;
+
+        present = snd_hda_codec_read(codec, 0x14, 0,
+                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
+
+        snd_hda_codec_amp_update(codec, 0x15, 0, HDA_INPUT, 0,
+                                 0x80, present ? 0x80 : 0);
+        snd_hda_codec_amp_update(codec, 0x15, 1, HDA_INPUT, 0,
+                                 0x80, present ? 0x80 : 0);
+}
+
+static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
+{
+        unsigned int present;
+        
+        present = snd_hda_codec_read(codec, 0x21, 0,
+                                     AC_VERB_GET_VOLUME_KNOB_CONTROL, 0) & 0x7f;
+
+        snd_hda_codec_amp_update(codec, 0x0c, 0, HDA_OUTPUT, 0,
+                                 0x7f, present);
+        snd_hda_codec_amp_update(codec, 0x0c, 1, HDA_OUTPUT, 0,
+                                 0x7f,  present);
+
+        snd_hda_codec_amp_update(codec, 0x0d, 0, HDA_OUTPUT, 0,
+                                 0x7f,  present);
+        snd_hda_codec_amp_update(codec, 0x0d, 1, HDA_OUTPUT, 0,
+                                 0x7f, present);
+
+}
+static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
+                                           unsigned int res)
+{
+        /* Looks like the unsol event is incompatible with the standard
+         * definition.  4bit tag is placed at 28 bit!
+         */
+        if ((res >> 28) == ALC880_HP_EVENT)
+                alc880_uniwill_p53_hp_automute(codec);
+        if ((res >> 28) == ALC880_DCVOL_EVENT) 
+                alc880_uniwill_p53_dcvol_automute(codec);
+}
 
 /* FIXME! */
@@ -1187 +1459 @@
  */
 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
-    {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
-    {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
-    {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
-    {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
-
-    {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
-    {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-
-    {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
-    {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-    {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
-    {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-    {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
-
-    {0}
+        {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
+        {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
+        {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
+
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+
+        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+
+        {0}
 };
 
@@ -1216 +1488 @@
  */
 static struct hda_verb alc880_pin_asus_init_verbs[] = {
-    {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
-    {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
-    {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
-    {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
-
-    {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
-    {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-
-    {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
-    {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-    {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
-    {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-    {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
-    {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-    {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
-
-    {0}
+        {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
+        {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
+        {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
+
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+
+        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        
+        {0}
 };
 
 /* Enable GPIO mask and set output */
 static struct hda_verb alc880_gpio1_init_verbs[] = {
-    {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
-    {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
-    {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
-
-    {0}
+        {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
+        {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
+        {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
+
+        {0}
 };
 
 /* Enable GPIO mask and set output */
 static struct hda_verb alc880_gpio2_init_verbs[] = {
-    {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
-    {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
-    {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
-
-    {0}
+        {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
+        {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
+        {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
+
+        {0}
 };
 
 /* Clevo m520g init */
 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
-    /* headphone output */
-    {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
-    /* line-out */
-    {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    /* Line-in */
-    {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
-    {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    /* CD */
-    {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
-    {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    /* Mic1 (rear panel) */
-    {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
-    {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    /* Mic2 (front panel) */
-    {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
-    {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    /* headphone */
-    {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
-    {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    /* change to EAPD mode */
-    {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
-    {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
-
-    {0}
+        /* headphone output */
+        {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
+        /* line-out */
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        /* Line-in */
+        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        /* CD */
+        {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        /* Mic1 (rear panel) */
+        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        /* Mic2 (front panel) */
+        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        /* headphone */
+        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        /* change to EAPD mode */
+        {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
+        {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
+
+        {0}
 };
 
 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
-    /* Headphone output */
-    {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
-    /* Front output*/
-    {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
-
-    /* Line In pin widget for input */
-    {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
-    /* CD pin widget for input */
-    {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
-    /* Mic1 (rear panel) pin widget for input and vref at 80% */
-    {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
-
-    /* change to EAPD mode */
-    {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
-    {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
-
-    {0}
+        /* change to EAPD mode */
+        {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
+        {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
+
+        /* Headphone output */
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        /* Front output*/
+        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
+
+        /* Line In pin widget for input */
+        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        /* CD pin widget for input */
+        {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        /* Mic1 (rear panel) pin widget for input and vref at 80% */
+        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+
+        /* change to EAPD mode */
+        {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
+        {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
+
+        {0}
 };
 
@@ -1325 +1601 @@
 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
 static hda_nid_t alc880_lg_dac_nids[3] = {
-    0x05, 0x02, 0x03
+        0x05, 0x02, 0x03
 };
 
 /* seems analog CD is not working */
 static struct hda_input_mux alc880_lg_capture_source = {
-    .num_items = 3,
-    .items = {
-        { "Mic", 0x1 },
-        { "Line", 0x5 },
-        { "Internal Mic", 0x6 },
-    },
+        .num_items = 3,
+        .items = {
+                { "Mic", 0x1 },
+                { "Line", 0x5 },
+                { "Internal Mic", 0x6 },
+        },
 };
 
 /* 2,4,6 channel modes */
 static struct hda_verb alc880_lg_ch2_init[] = {
-    /* set line-in and mic-in to input */
-    { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
-    { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
-    {0}
+        /* set line-in and mic-in to input */
+        { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
+        { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
+        {0}
 };
 
 static struct hda_verb alc880_lg_ch4_init[] = {
-    /* set line-in to out and mic-in to input */
-    { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
-    { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
-    {0}
+        /* set line-in to out and mic-in to input */
+        { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
+        { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
+        {0}
 };
 
 static struct hda_verb alc880_lg_ch6_init[] = {
-    /* set line-in and mic-in to output */
-    { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
-    { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
-    {0}
+        /* set line-in and mic-in to output */
+        { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
+        { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
+        {0}
 };
 
 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
-    { 2, alc880_lg_ch2_init },
-    { 4, alc880_lg_ch4_init },
-    { 6, alc880_lg_ch6_init },
+        { 2, alc880_lg_ch2_init },
+        { 4, alc880_lg_ch4_init },
+        { 6, alc880_lg_ch6_init },
 };
 
 static struct snd_kcontrol_new alc880_lg_mixer[] = {
-    /* FIXME: it's not really "master" but front channels */
-    HDA_CODEC_VOLUME("Master Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE("Master Playback Switch", 0x0f, 2, HDA_INPUT),
-    HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
-    HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
-    HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
-    HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
-    HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
-    HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
-    HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
-    HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
-    HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
-    HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
-    {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "Channel Mode",
-        .info = alc_ch_mode_info,
-        .get = alc_ch_mode_get,
-        .put = alc_ch_mode_put,
-    },
-    {0} /* end */
+        /* FIXME: it's not really "master" but front channels */
+        HDA_CODEC_VOLUME("Master Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Master Playback Switch", 0x0f, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
+        HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
+        HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
+        HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
+        HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
+        HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Channel Mode",
+                .info = alc_ch_mode_info,
+                .get = alc_ch_mode_get,
+                .put = alc_ch_mode_put,
+        },
+        {0} /* end */
 };
 
 static struct hda_verb alc880_lg_init_verbs[] = {
-    /* set capture source to mic-in */
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    /* mute all amp mixer inputs */
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(6)},
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(7)},
-    /* line-in to input */
-    {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
-    {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    /* built-in mic */
-    {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
-    {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    /* speaker-out */
-    {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
-    {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    /* mic-in to input */
-    {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
-    {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
-    {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    /* HP-out */
-    {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
-    {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
-    {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    /* jack sense */
-    {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
-    {0}
+        /* set capture source to mic-in */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        /* mute all amp mixer inputs */
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(6)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(7)},
+        /* line-in to input */
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        /* built-in mic */
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        /* speaker-out */
+        {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        /* mic-in to input */
+        {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
+        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        /* HP-out */
+        {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
+        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        /* jack sense */
+        {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
+        {0}
 };
 
@@ -1426 +1702 @@
 static void alc880_lg_automute(struct hda_codec *codec)
 {
-    unsigned int present;
-
-    present = snd_hda_codec_read(codec, 0x1b, 0,
-                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-    snd_hda_codec_amp_update(codec, 0x17, 0, HDA_OUTPUT, 0,
-                             0x80, present ? 0x80 : 0);
-    snd_hda_codec_amp_update(codec, 0x17, 1, HDA_OUTPUT, 0,
-                             0x80, present ? 0x80 : 0);
+        unsigned int present;
+
+        present = snd_hda_codec_read(codec, 0x1b, 0,
+                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
+        snd_hda_codec_amp_update(codec, 0x17, 0, HDA_OUTPUT, 0,
+                                 0x80, present ? 0x80 : 0);
+        snd_hda_codec_amp_update(codec, 0x17, 1, HDA_OUTPUT, 0,
+                                 0x80, present ? 0x80 : 0);
 }
 
 static void alc880_lg_unsol_event(struct hda_codec *codec, unsigned int res)
 {
-    /* Looks like the unsol event is incompatible with the standard
-     * definition.  4bit tag is placed at 28 bit!
-     */
-    if ((res >> 28) == 0x01)
-        alc880_lg_automute(codec);
+        /* Looks like the unsol event is incompatible with the standard
+         * definition.  4bit tag is placed at 28 bit!
+         */
+        if ((res >> 28) == 0x01)
+                alc880_lg_automute(codec);
 }
 
@@ -1458 +1734 @@
 /* seems analog CD is not working */
 static struct hda_input_mux alc880_lg_lw_capture_source = {
-    .num_items = 2,
-    .items = {
-        { "Mic", 0x0 },
-        { "Internal Mic", 0x1 },
-    },
+        .num_items = 2,
+        .items = {
+                { "Mic", 0x0 },
+                { "Internal Mic", 0x1 },
+        },
 };
 
 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
-    HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
-    HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
-    HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
-    HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
-    {0} /* end */
+        HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
+        HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
+        {0} /* end */
 };
 
 static struct hda_verb alc880_lg_lw_init_verbs[] = {
-    /* set capture source to mic-in */
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(7)},
-    /* speaker-out */
-    {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
-    {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    /* HP-out */
-    {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
-    {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
-    {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    /* mic-in to input */
-    {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
-    {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    /* built-in mic */
-    {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
-    {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    /* jack sense */
-    {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
-    {0}
+        /* set capture source to mic-in */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(7)},
+        /* speaker-out */
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        /* HP-out */
+        {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        /* mic-in to input */
+        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        /* built-in mic */
+        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        /* jack sense */
+        {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
+        {0}
 };
 
@@ -1502 +1778 @@
 static void alc880_lg_lw_automute(struct hda_codec *codec)
 {
-    unsigned int present;
-
-    present = snd_hda_codec_read(codec, 0x1b, 0,
-                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-    snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
-                             0x80, present ? 0x80 : 0);
-    snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
-                             0x80, present ? 0x80 : 0);
+        unsigned int present;
+
+        present = snd_hda_codec_read(codec, 0x1b, 0,
+                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
+        snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
+                                 0x80, present ? 0x80 : 0);
+        snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
+                                 0x80, present ? 0x80 : 0);
 }
 
 static void alc880_lg_lw_unsol_event(struct hda_codec *codec, unsigned int res)
 {
-    /* Looks like the unsol event is incompatible with the standard
-     * definition.  4bit tag is placed at 28 bit!
-     */
-    if ((res >> 28) == 0x01)
-        alc880_lg_lw_automute(codec);
+        /* Looks like the unsol event is incompatible with the standard
+         * definition.  4bit tag is placed at 28 bit!
+         */
+        if ((res >> 28) == 0x01)
+                alc880_lg_lw_automute(codec);
 }
 
@@ -1527 +1803 @@
 static int alc_init(struct hda_codec *codec)
 {
-    struct alc_spec *spec = codec->spec;
-    unsigned int i;
-
-    for (i = 0; i < spec->num_init_verbs; i++)
-        snd_hda_sequence_write(codec, spec->init_verbs[i]);
-    if (spec->init_hook)
-        spec->init_hook(codec);
-    return 0;
+        struct alc_spec *spec = codec->spec;
+        unsigned int i;
+
+        for (i = 0; i < spec->num_init_verbs; i++)
+                snd_hda_sequence_write(codec, spec->init_verbs[i]);
+
+        if (spec->init_hook)
+                spec->init_hook(codec);
+
+        return 0;
 }
 
 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
 {
-    struct alc_spec *spec = codec->spec;
-
-    if (spec->unsol_event)
-        spec->unsol_event(codec, res);
+        struct alc_spec *spec = codec->spec;
+
+        if (spec->unsol_event)
+                spec->unsol_event(codec, res);
 }
 
@@ -1551 +1829 @@
 static int alc_resume(struct hda_codec *codec)
 {
-    struct alc_spec *spec = codec->spec;
-    int i;
-
-    alc_init(codec);
-    for (i = 0; i < spec->num_mixers; i++)
-        snd_hda_resume_ctls(codec, spec->mixers[i]);
-    if (spec->multiout.dig_out_nid)
-        snd_hda_resume_spdif_out(codec);
-    if (spec->dig_in_nid)
-        snd_hda_resume_spdif_in(codec);
-
-    return 0;
+        struct alc_spec *spec = codec->spec;
+        int i;
+
+        alc_init(codec);
+        for (i = 0; i < spec->num_mixers; i++)
+                snd_hda_resume_ctls(codec, spec->mixers[i]);
+        if (spec->multiout.dig_out_nid)
+                snd_hda_resume_spdif_out(codec);
+        if (spec->dig_in_nid)
+                snd_hda_resume_spdif_in(codec);
+
+        return 0;
 }
 #endif
@@ -1570 +1848 @@
  */
 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
-                                    struct hda_codec *codec,
-                                    struct snd_pcm_substream *substream)
-{
-    struct alc_spec *spec = codec->spec;
-    return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream);
+                                    struct hda_codec *codec,
+                                    struct snd_pcm_substream *substream)
+{
+        struct alc_spec *spec = codec->spec;
+        return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream);
 }
 
 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
-                                       struct hda_codec *codec,
-                                       unsigned int stream_tag,
-                                       unsigned int format,
-                                       struct snd_pcm_substream *substream)
-{
-    struct alc_spec *spec = codec->spec;
-    return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag,
-                                            format, substream);
+                                       struct hda_codec *codec,
+                                       unsigned int stream_tag,
+                                       unsigned int format,
+                                       struct snd_pcm_substream *substream)
+{
+        struct alc_spec *spec = codec->spec;
+        return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
+                                                stream_tag, format, substream);
 }
 
 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
-                                       struct hda_codec *codec,
-                                       struct snd_pcm_substream *substream)
-{
-    struct alc_spec *spec = codec->spec;
-    return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
+                                       struct hda_codec *codec,
+                                       struct snd_pcm_substream *substream)
+{
+        struct alc_spec *spec = codec->spec;
+        return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
 }
 
@@ -1600 +1878 @@
  */
 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
-                                        struct hda_codec *codec,
-                                        struct snd_pcm_substream *substream)
-{
-    struct alc_spec *spec = codec->spec;
-    return snd_hda_multi_out_dig_open(codec, &spec->multiout);
+                                        struct hda_codec *codec,
+                                        struct snd_pcm_substream *substream)
+{
+        struct alc_spec *spec = codec->spec;
+        return snd_hda_multi_out_dig_open(codec, &spec->multiout);
 }
 
 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
-                                         struct hda_codec *codec,
-                                         struct snd_pcm_substream *substream)
-{
-    struct alc_spec *spec = codec->spec;
-    return snd_hda_multi_out_dig_close(codec, &spec->multiout);
+                                         struct hda_codec *codec,
+                                         struct snd_pcm_substream *substream)
+{
+        struct alc_spec *spec = codec->spec;
+        return snd_hda_multi_out_dig_close(codec, &spec->multiout);
 }
 
@@ -1619 +1897 @@
  */
 static int alc880_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
-                                      struct hda_codec *codec,
-                                      unsigned int stream_tag,
-                                      unsigned int format,
-                                      struct snd_pcm_substream *substream)
-{
-    struct alc_spec *spec = codec->spec;
-
-    snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
-                               stream_tag, 0, format);
-    return 0;
+                                      struct hda_codec *codec,
+                                      unsigned int stream_tag,
+                                      unsigned int format,
+                                      struct snd_pcm_substream *substream)
+{
+        struct alc_spec *spec = codec->spec;
+
+        snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
+                                   stream_tag, 0, format);
+        return 0;
 }
 
 static int alc880_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
-                                      struct hda_codec *codec,
-                                      struct snd_pcm_substream *substream)
-{
-    struct alc_spec *spec = codec->spec;
-
-    snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number], 0, 0, 0);
-    return 0;
+                                      struct hda_codec *codec,
+                                      struct snd_pcm_substream *substream)
+{
+        struct alc_spec *spec = codec->spec;
+
+        snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
+                                   0, 0, 0);
+        return 0;
 }
 
@@ -1645 +1924 @@
  */
 static struct hda_pcm_stream alc880_pcm_analog_playback = {
-    .substreams = 1,
-    .channels_min = 2,
-    .channels_max = 8,
-    /* NID is set in alc_build_pcms */
-    .ops = {
-        .open = alc880_playback_pcm_open,
-        .prepare = alc880_playback_pcm_prepare,
-        .cleanup = alc880_playback_pcm_cleanup
-    },
+        .substreams = 1,
+        .channels_min = 2,
+        .channels_max = 8,
+        /* NID is set in alc_build_pcms */
+        .ops = {
+                .open = alc880_playback_pcm_open,
+                .prepare = alc880_playback_pcm_prepare,
+                .cleanup = alc880_playback_pcm_cleanup
+        },
 };
 
 static struct hda_pcm_stream alc880_pcm_analog_capture = {
-    .substreams = 2,
-    .channels_min = 2,
-    .channels_max = 2,
-    /* NID is set in alc_build_pcms */
-    .ops = {
-        .prepare = alc880_capture_pcm_prepare,
-        .cleanup = alc880_capture_pcm_cleanup
-    },
+        .substreams = 2,
+        .channels_min = 2,
+        .channels_max = 2,
+        /* NID is set in alc_build_pcms */
+        .ops = {
+                .prepare = alc880_capture_pcm_prepare,
+                .cleanup = alc880_capture_pcm_cleanup
+        },
 };
 
 static struct hda_pcm_stream alc880_pcm_digital_playback = {
-    .substreams = 1,
-    .channels_min = 2,
-    .channels_max = 2,
-    /* NID is set in alc_build_pcms */
-    .ops = {
-        .open = alc880_dig_playback_pcm_open,
-        .close = alc880_dig_playback_pcm_close
-    },
+        .substreams = 1,
+        .channels_min = 2,
+        .channels_max = 2,
+        /* NID is set in alc_build_pcms */
+        .ops = {
+                .open = alc880_dig_playback_pcm_open,
+                .close = alc880_dig_playback_pcm_close
+        },
 };
 
 static struct hda_pcm_stream alc880_pcm_digital_capture = {
-    .substreams = 1,
-    .channels_min = 2,
-    .channels_max = 2,
-    /* NID is set in alc_build_pcms */
+        .substreams = 1,
+        .channels_min = 2,
+        .channels_max = 2,
+        /* NID is set in alc_build_pcms */
 };
 
 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
 static struct hda_pcm_stream alc_pcm_null_playback = {
-    .substreams = 0,
-    .channels_min = 0,
-    .channels_max = 0,
+        .substreams = 0,
+        .channels_min = 0,
+        .channels_max = 0,
 };
 
 static int alc_build_pcms(struct hda_codec *codec)
 {
-    struct alc_spec *spec = codec->spec;
-    struct hda_pcm *info = spec->pcm_rec;
-    int i;
-
-    codec->num_pcms = 1;
-    codec->pcm_info = info;
-
-    info->name = spec->stream_name_analog;
-    if (spec->stream_analog_playback) {
-        snd_assert(spec->multiout.dac_nids, return -EINVAL);
-        info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
-        info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
-    }
-    if (spec->stream_analog_capture) {
-        snd_assert(spec->adc_nids, return -EINVAL);
-        info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
-        info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
-    }
-
-    if (spec->channel_mode) {
-        info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
-        for (i = 0; i < spec->num_channel_mode; i++) {
-            if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
-                info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
-            }
-        }
-    }
-
-    /* If the use of more than one ADC is requested for the current
-     * model, configure a second analog capture-only PCM.
-     */
-    if (spec->num_adc_nids > 1) {
-        codec->num_pcms++;
-        info++;
-        info->name = spec->stream_name_analog;
-        /* No playback stream for second PCM */
-        info->stream[SNDRV_PCM_STREAM_PLAYBACK] = alc_pcm_null_playback;
-        info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
-        if (spec->stream_analog_capture) {
-            snd_assert(spec->adc_nids, return -EINVAL);
-            info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
-            info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[1];
-        }
-    }
-
-    if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
-        codec->num_pcms++;
-        info++;
-        info->name = spec->stream_name_digital;
-        if (spec->multiout.dig_out_nid &&
-            spec->stream_digital_playback) {
-            info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
-            info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
-        }
-        if (spec->dig_in_nid &&
-            spec->stream_digital_capture) {
-            info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
-            info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
-        }
-    }
-
-    return 0;
+        struct alc_spec *spec = codec->spec;
+        struct hda_pcm *info = spec->pcm_rec;
+        int i;
+
+        codec->num_pcms = 1;
+        codec->pcm_info = info;
+
+        info->name = spec->stream_name_analog;
+        if (spec->stream_analog_playback) {
+                snd_assert(spec->multiout.dac_nids, return -EINVAL);
+                info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
+                info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
+        }
+        if (spec->stream_analog_capture) {
+                snd_assert(spec->adc_nids, return -EINVAL);
+                info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
+                info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
+        }
+
+        if (spec->channel_mode) {
+                info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
+                for (i = 0; i < spec->num_channel_mode; i++) {
+                        if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
+                                info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
+                        }
+                }
+        }
+
+        /* SPDIF for stream index #1 */
+        if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
+                codec->num_pcms = 2;
+                info = spec->pcm_rec + 1;
+                info->name = spec->stream_name_digital;
+                if (spec->multiout.dig_out_nid &&
+                    spec->stream_digital_playback) {
+                        info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
+                        info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
+                }
+                if (spec->dig_in_nid &&
+                    spec->stream_digital_capture) {
+                        info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
+                        info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
+                }
+        }
+
+        /* If the use of more than one ADC is requested for the current
+         * model, configure a second analog capture-only PCM.
+         */
+        /* Additional Analaog capture for index #2 */
+        if (spec->num_adc_nids > 1 && spec->stream_analog_capture &&
+            spec->adc_nids) {
+                codec->num_pcms = 3;
+                info = spec->pcm_rec + 2;
+                info->name = spec->stream_name_analog;
+                /* No playback stream for second PCM */
+                info->stream[SNDRV_PCM_STREAM_PLAYBACK] = alc_pcm_null_playback;
+                info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
+                if (spec->stream_analog_capture) {
+                        info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
+                        info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[1];
+                }
+        }
+
+        return 0;
 }
 
 static void alc_free(struct hda_codec *codec)
 {
-    struct alc_spec *spec = codec->spec;
-    unsigned int i;
-
-    if (! spec)
-        return;
-
-    if (spec->kctl_alloc) {
-        for (i = 0; i < spec->num_kctl_used; i++)
-            kfree(spec->kctl_alloc[i].name);
-        kfree(spec->kctl_alloc);
-    }
-    kfree(spec);
+        struct alc_spec *spec = codec->spec;
+        unsigned int i;
+
+        if (! spec)
+                return;
+
+        if (spec->kctl_alloc) {
+                for (i = 0; i < spec->num_kctl_used; i++)
+                        kfree(spec->kctl_alloc[i].name);
+                kfree(spec->kctl_alloc);
+        }
+        kfree(spec);
 }
 
@@ -1777 +2058 @@
  */
 static struct hda_codec_ops alc_patch_ops = {
-    .build_controls = alc_build_controls,
-    .build_pcms = alc_build_pcms,
-    .init = alc_init,
-    .free = alc_free,
-    .unsol_event = alc_unsol_event,
+        .build_controls = alc_build_controls,
+        .build_pcms = alc_build_pcms,
+        .init = alc_init,
+        .free = alc_free,
+        .unsol_event = alc_unsol_event,
 #ifdef CONFIG_PM
-    .resume = alc_resume,
+        .resume = alc_resume,
 #endif
 };
@@ -1796 +2077 @@
 #ifdef CONFIG_SND_DEBUG
 static hda_nid_t alc880_test_dac_nids[4] = {
-    0x02, 0x03, 0x04, 0x05
+        0x02, 0x03, 0x04, 0x05
 };
 
 static struct hda_input_mux alc880_test_capture_source = {
-    .num_items = 7,
-    .items = {
-        { "In-1", 0x0 },
-        { "In-2", 0x1 },
-        { "In-3", 0x2 },
-        { "In-4", 0x3 },
-        { "CD", 0x4 },
-        { "Front", 0x5 },
-        { "Surround", 0x6 },
-    },
+        .num_items = 7,
+        .items = {
+                { "In-1", 0x0 },
+                { "In-2", 0x1 },
+                { "In-3", 0x2 },
+                { "In-4", 0x3 },
+                { "CD", 0x4 },
+                { "Front", 0x5 },
+                { "Surround", 0x6 },
+        },
 };
 
 static struct hda_channel_mode alc880_test_modes[4] = {
-    { 2, NULL },
-    { 4, NULL },
-    { 6, NULL },
-    { 8, NULL },
-};
-
-static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
-{
-    static char *texts[] = {
-        "N/A", "Line Out", "HP Out",
-        "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
-    };
-    uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
-    uinfo->count = 1;
-    uinfo->value.enumerated.items = 8;
-    if (uinfo->value.enumerated.item >= 8)
-        uinfo->value.enumerated.item = 7;
-    strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
-    return 0;
-}
-
-static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
-{
-    struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-    hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
-    unsigned int pin_ctl, item = 0;
-
-    pin_ctl = snd_hda_codec_read(codec, nid, 0,
-                                 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
-    if (pin_ctl & AC_PINCTL_OUT_EN) {
-        if (pin_ctl & AC_PINCTL_HP_EN)
-            item = 2;
-        else
-            item = 1;
-    } else if (pin_ctl & AC_PINCTL_IN_EN) {
-        switch (pin_ctl & AC_PINCTL_VREFEN) {
-        case AC_PINCTL_VREF_HIZ: item = 3; break;
-        case AC_PINCTL_VREF_50:  item = 4; break;
-        case AC_PINCTL_VREF_GRD: item = 5; break;
-        case AC_PINCTL_VREF_80:  item = 6; break;
-        case AC_PINCTL_VREF_100: item = 7; break;
-        }
-    }
-    ucontrol->value.enumerated.item[0] = item;
-    return 0;
-}
-
-static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
-{
-    struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-    hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
-    static unsigned int ctls[] = {
-        0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
-        AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
-        AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
-        AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
-        AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
-        AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
-    };
-    unsigned int old_ctl, new_ctl;
-
-    old_ctl = snd_hda_codec_read(codec, nid, 0,
-                                 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
-    new_ctl = ctls[ucontrol->value.enumerated.item[0]];
-    if (old_ctl != new_ctl) {
-        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, new_ctl);
-        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
-                            ucontrol->value.enumerated.item[0] >= 3 ? 0xb080 : 0xb000);
-        return 1;
-    }
-    return 0;
-}
-
-static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
-{
-    static char *texts[] = {
-        "Front", "Surround", "CLFE", "Side"
-    };
-    uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
-    uinfo->count = 1;
-    uinfo->value.enumerated.items = 4;
-    if (uinfo->value.enumerated.item >= 4)
-        uinfo->value.enumerated.item = 3;
-    strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
-    return 0;
-}
-
-static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
-{
-    struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-    hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
-    unsigned int sel;
-
-    sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
-    ucontrol->value.enumerated.item[0] = sel & 3;
-    return 0;
-}
-
-static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
-{
-    struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-    hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
-    unsigned int sel;
-
-    sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
-    if (ucontrol->value.enumerated.item[0] != sel) {
-        sel = ucontrol->value.enumerated.item[0] & 3;
-        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, sel);
-        return 1;
-    }
-    return 0;
+        { 2, NULL },
+        { 4, NULL },
+        { 6, NULL },
+        { 8, NULL },
+};
+
+static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
+                                 struct snd_ctl_elem_info *uinfo)
+{
+        static char *texts[] = {
+                "N/A", "Line Out", "HP Out",
+                "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
+        };
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        uinfo->count = 1;
+        uinfo->value.enumerated.items = 8;
+        if (uinfo->value.enumerated.item >= 8)
+                uinfo->value.enumerated.item = 7;
+        strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
+        return 0;
+}
+
+static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
+                                struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
+        unsigned int pin_ctl, item = 0;
+
+        pin_ctl = snd_hda_codec_read(codec, nid, 0,
+                                     AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
+        if (pin_ctl & AC_PINCTL_OUT_EN) {
+                if (pin_ctl & AC_PINCTL_HP_EN)
+                        item = 2;
+                else
+                        item = 1;
+        } else if (pin_ctl & AC_PINCTL_IN_EN) {
+                switch (pin_ctl & AC_PINCTL_VREFEN) {
+                case AC_PINCTL_VREF_HIZ: item = 3; break;
+                case AC_PINCTL_VREF_50:  item = 4; break;
+                case AC_PINCTL_VREF_GRD: item = 5; break;
+                case AC_PINCTL_VREF_80:  item = 6; break;
+                case AC_PINCTL_VREF_100: item = 7; break;
+                }
+        }
+        ucontrol->value.enumerated.item[0] = item;
+        return 0;
+}
+
+static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
+                                struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
+        static unsigned int ctls[] = {
+                0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
+                AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
+                AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
+                AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
+                AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
+                AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
+        };
+        unsigned int old_ctl, new_ctl;
+
+        old_ctl = snd_hda_codec_read(codec, nid, 0,
+                                     AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
+        new_ctl = ctls[ucontrol->value.enumerated.item[0]];
+        if (old_ctl != new_ctl) {
+                snd_hda_codec_write(codec, nid, 0,
+                                    AC_VERB_SET_PIN_WIDGET_CONTROL, new_ctl);
+                snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
+                                    (ucontrol->value.enumerated.item[0] >= 3 ?
+                                     0xb080 : 0xb000));
+                return 1;
+        }
+        return 0;
+}
+
+static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
+                                 struct snd_ctl_elem_info *uinfo)
+{
+        static char *texts[] = {
+                "Front", "Surround", "CLFE", "Side"
+        };
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        uinfo->count = 1;
+        uinfo->value.enumerated.items = 4;
+        if (uinfo->value.enumerated.item >= 4)
+                uinfo->value.enumerated.item = 3;
+        strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
+        return 0;
+}
+
+static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
+                                struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
+        unsigned int sel;
+
+        sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
+        ucontrol->value.enumerated.item[0] = sel & 3;
+        return 0;
+}
+
+static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
+                                struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
+        unsigned int sel;
+
+        sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
+        if (ucontrol->value.enumerated.item[0] != sel) {
+                sel = ucontrol->value.enumerated.item[0] & 3;
+                snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, sel);
+                return 1;
+        }
+        return 0;
 }
 
 #define PIN_CTL_TEST(xname,nid) {                       \
-    .iface = SNDRV_CTL_ELEM_IFACE_MIXER,        \
-    .name = xname,                     \
-    .info = alc_test_pin_ctl_info, \
-    .get = alc_test_pin_ctl_get,   \
-    .put = alc_test_pin_ctl_put,   \
-    .private_value = nid               \
-    }
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
+                        .name = xname,                 \
+                        .info = alc_test_pin_ctl_info, \
+                        .get = alc_test_pin_ctl_get,   \
+                        .put = alc_test_pin_ctl_put,   \
+                        .private_value = nid           \
+                        }
 
 #define PIN_SRC_TEST(xname,nid) {                       \
-    .iface = SNDRV_CTL_ELEM_IFACE_MIXER,        \
-    .name = xname,                     \
-    .info = alc_test_pin_src_info, \
-    .get = alc_test_pin_src_get,   \
-    .put = alc_test_pin_src_put,   \
-    .private_value = nid               \
-    }
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
+                        .name = xname,                 \
+                        .info = alc_test_pin_src_info, \
+                        .get = alc_test_pin_src_get,   \
+                        .put = alc_test_pin_src_put,   \
+                        .private_value = nid           \
+                        }
 
 static struct snd_kcontrol_new alc880_test_mixer[] = {
-    HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
-    HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
-    HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
-    HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
-    HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
-    HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
-    HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
-    PIN_CTL_TEST("Front Pin Mode", 0x14),
-    PIN_CTL_TEST("Surround Pin Mode", 0x15),
-    PIN_CTL_TEST("CLFE Pin Mode", 0x16),
-    PIN_CTL_TEST("Side Pin Mode", 0x17),
-    PIN_CTL_TEST("In-1 Pin Mode", 0x18),
-    PIN_CTL_TEST("In-2 Pin Mode", 0x19),
-    PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
-    PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
-    PIN_SRC_TEST("In-1 Pin Source", 0x18),
-    PIN_SRC_TEST("In-2 Pin Source", 0x19),
-    PIN_SRC_TEST("In-3 Pin Source", 0x1a),
-    PIN_SRC_TEST("In-4 Pin Source", 0x1b),
-    HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
-    HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
-    HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
-    HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
-    HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
-    HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
-    HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
-    HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
-    HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
-    {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "Channel Mode",
-        .info = alc_ch_mode_info,
-        .get = alc_ch_mode_get,
-        .put = alc_ch_mode_put,
-    },
-    {0} /* end */
+        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
+        HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
+        HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
+        HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
+        PIN_CTL_TEST("Front Pin Mode", 0x14),
+        PIN_CTL_TEST("Surround Pin Mode", 0x15),
+        PIN_CTL_TEST("CLFE Pin Mode", 0x16),
+        PIN_CTL_TEST("Side Pin Mode", 0x17),
+        PIN_CTL_TEST("In-1 Pin Mode", 0x18),
+        PIN_CTL_TEST("In-2 Pin Mode", 0x19),
+        PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
+        PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
+        PIN_SRC_TEST("In-1 Pin Source", 0x18),
+        PIN_SRC_TEST("In-2 Pin Source", 0x19),
+        PIN_SRC_TEST("In-3 Pin Source", 0x1a),
+        PIN_SRC_TEST("In-4 Pin Source", 0x1b),
+        HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
+        HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
+        HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
+        HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
+        HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
+        HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
+        HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
+        HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Channel Mode",
+                .info = alc_ch_mode_info,
+                .get = alc_ch_mode_get,
+                .put = alc_ch_mode_put,
+        },
+        {0} /* end */
 };
 
 static struct hda_verb alc880_test_init_verbs[] = {
-    /* Unmute inputs of 0x0c - 0x0f */
-    {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    /* Vol output for 0x0c-0x0f */
-    {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    /* Set output pins 0x14-0x17 */
-    {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    /* Unmute output pins 0x14-0x17 */
-    {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    /* Set input pins 0x18-0x1c */
-    {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
-    {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
-    {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
-    {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
-    {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
-    /* Mute input pins 0x18-0x1b */
-    {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-    {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-    {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-    {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-    /* ADC set up */
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
-    {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
-    {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
-    /* Analog input/passthru */
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
-    {0}
+        /* Unmute inputs of 0x0c - 0x0f */
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        /* Vol output for 0x0c-0x0f */
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        /* Set output pins 0x14-0x17 */
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        /* Unmute output pins 0x14-0x17 */
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        /* Set input pins 0x18-0x1c */
+        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        /* Mute input pins 0x18-0x1b */
+        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        /* ADC set up */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
+        /* Analog input/passthru */
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
+        {0}
 };
 #endif
@@ -2041 +2330 @@
  */
 
-static struct hda_board_config alc880_cfg_tbl[] = {
-    /* Back 3 jack, front 2 jack */
-    { .modelname = "3stack", .config = ALC880_3ST },
-    { .pci_subvendor = 0x8086, .pci_subdevice = 0xe200, .config = ALC880_3ST },
-    { .pci_subvendor = 0x8086, .pci_subdevice = 0xe201, .config = ALC880_3ST },
-    { .pci_subvendor = 0x8086, .pci_subdevice = 0xe202, .config = ALC880_3ST },
-    { .pci_subvendor = 0x8086, .pci_subdevice = 0xe203, .config = ALC880_3ST },
-    { .pci_subvendor = 0x8086, .pci_subdevice = 0xe204, .config = ALC880_3ST },
-    { .pci_subvendor = 0x8086, .pci_subdevice = 0xe205, .config = ALC880_3ST },
-    { .pci_subvendor = 0x8086, .pci_subdevice = 0xe206, .config = ALC880_3ST },
-    { .pci_subvendor = 0x8086, .pci_subdevice = 0xe207, .config = ALC880_3ST },
-    { .pci_subvendor = 0x8086, .pci_subdevice = 0xe208, .config = ALC880_3ST },
-    { .pci_subvendor = 0x8086, .pci_subdevice = 0xe209, .config = ALC880_3ST },
-    { .pci_subvendor = 0x8086, .pci_subdevice = 0xe20a, .config = ALC880_3ST },
-    { .pci_subvendor = 0x8086, .pci_subdevice = 0xe20b, .config = ALC880_3ST },
-    { .pci_subvendor = 0x8086, .pci_subdevice = 0xe20c, .config = ALC880_3ST },
-    { .pci_subvendor = 0x8086, .pci_subdevice = 0xe20d, .config = ALC880_3ST },
-    { .pci_subvendor = 0x8086, .pci_subdevice = 0xe20e, .config = ALC880_3ST },
-    { .pci_subvendor = 0x8086, .pci_subdevice = 0xe20f, .config = ALC880_3ST },
-    { .pci_subvendor = 0x8086, .pci_subdevice = 0xe210, .config = ALC880_3ST },
-    { .pci_subvendor = 0x8086, .pci_subdevice = 0xe211, .config = ALC880_3ST },
-    { .pci_subvendor = 0x8086, .pci_subdevice = 0xe214, .config = ALC880_3ST },
-    { .pci_subvendor = 0x8086, .pci_subdevice = 0xe302, .config = ALC880_3ST },
-    { .pci_subvendor = 0x8086, .pci_subdevice = 0xe303, .config = ALC880_3ST },
-    { .pci_subvendor = 0x8086, .pci_subdevice = 0xe304, .config = ALC880_3ST },
-    { .pci_subvendor = 0x8086, .pci_subdevice = 0xe306, .config = ALC880_3ST },
-    { .pci_subvendor = 0x8086, .pci_subdevice = 0xe307, .config = ALC880_3ST },
-    { .pci_subvendor = 0x8086, .pci_subdevice = 0xe404, .config = ALC880_3ST },
-    { .pci_subvendor = 0x8086, .pci_subdevice = 0xa101, .config = ALC880_3ST },
-    { .pci_subvendor = 0x107b, .pci_subdevice = 0x3031, .config = ALC880_3ST },
-    { .pci_subvendor = 0x107b, .pci_subdevice = 0x4036, .config = ALC880_3ST },
-    { .pci_subvendor = 0x107b, .pci_subdevice = 0x4037, .config = ALC880_3ST },
-    { .pci_subvendor = 0x107b, .pci_subdevice = 0x4038, .config = ALC880_3ST },
-    { .pci_subvendor = 0x107b, .pci_subdevice = 0x4040, .config = ALC880_3ST },
-    { .pci_subvendor = 0x107b, .pci_subdevice = 0x4041, .config = ALC880_3ST },
-    /* TCL S700 */
-    { .pci_subvendor = 0x19db, .pci_subdevice = 0x4188, .config = ALC880_TCL_S700 },
-
-    /* Back 3 jack, front 2 jack (Internal add Aux-In) */
-    { .pci_subvendor = 0x1025, .pci_subdevice = 0xe310, .config = ALC880_3ST },
-    { .pci_subvendor = 0x104d, .pci_subdevice = 0x81d6, .config = ALC880_3ST },
-    { .pci_subvendor = 0x104d, .pci_subdevice = 0x81a0, .config = ALC880_3ST },
-
-    /* Back 3 jack plus 1 SPDIF out jack, front 2 jack */
-    { .modelname = "3stack-digout", .config = ALC880_3ST_DIG },
-    { .pci_subvendor = 0x8086, .pci_subdevice = 0xe308, .config = ALC880_3ST_DIG },
-    { .pci_subvendor = 0x1025, .pci_subdevice = 0x0070, .config = ALC880_3ST_DIG },
-    /* Clevo m520G NB */
-    { .pci_subvendor = 0x1558, .pci_subdevice = 0x0520, .config = ALC880_CLEVO },
-
-    /* Back 3 jack plus 1 SPDIF out jack, front 2 jack (Internal add Aux-In)*/
-    { .pci_subvendor = 0x8086, .pci_subdevice = 0xe305, .config = ALC880_3ST_DIG },
-    { .pci_subvendor = 0x8086, .pci_subdevice = 0xd402, .config = ALC880_3ST_DIG },
-    { .pci_subvendor = 0x1025, .pci_subdevice = 0xe309, .config = ALC880_3ST_DIG },
-
-    /* Back 5 jack, front 2 jack */
-    { .modelname = "5stack", .config = ALC880_5ST },
-    { .pci_subvendor = 0x107b, .pci_subdevice = 0x3033, .config = ALC880_5ST },
-    { .pci_subvendor = 0x107b, .pci_subdevice = 0x4039, .config = ALC880_5ST },
-    { .pci_subvendor = 0x107b, .pci_subdevice = 0x3032, .config = ALC880_5ST },
-    { .pci_subvendor = 0x103c, .pci_subdevice = 0x2a09, .config = ALC880_5ST },
-    { .pci_subvendor = 0x1043, .pci_subdevice = 0x814e, .config = ALC880_5ST },
-
-    /* Back 5 jack plus 1 SPDIF out jack, front 2 jack */
-    { .modelname = "5stack-digout", .config = ALC880_5ST_DIG },
-    { .pci_subvendor = 0x8086, .pci_subdevice = 0xe224, .config = ALC880_5ST_DIG },
-    { .pci_subvendor = 0x8086, .pci_subdevice = 0xe400, .config = ALC880_5ST_DIG },
-    { .pci_subvendor = 0x8086, .pci_subdevice = 0xe401, .config = ALC880_5ST_DIG },
-    { .pci_subvendor = 0x8086, .pci_subdevice = 0xe402, .config = ALC880_5ST_DIG },
-    { .pci_subvendor = 0x8086, .pci_subdevice = 0xd400, .config = ALC880_5ST_DIG },
-    { .pci_subvendor = 0x8086, .pci_subdevice = 0xd401, .config = ALC880_5ST_DIG },
-    { .pci_subvendor = 0x8086, .pci_subdevice = 0xa100, .config = ALC880_5ST_DIG },
-    { .pci_subvendor = 0x1565, .pci_subdevice = 0x8202, .config = ALC880_5ST_DIG },
-    { .pci_subvendor = 0x1019, .pci_subdevice = 0xa880, .config = ALC880_5ST_DIG },
-    { .pci_subvendor = 0xa0a0, .pci_subdevice = 0x0560, .config = ALC880_5ST_DIG }, /* Aopen i915GMm-HFS */
-    /* { .pci_subvendor = 0x1019, .pci_subdevice = 0xa884, .config = ALC880_5ST_DIG }, */ /* conflict with 6stack */
-    { .pci_subvendor = 0x1695, .pci_subdevice = 0x400d, .config = ALC880_5ST_DIG },
-    /* note subvendor = 0 below */
-    /* { .pci_subvendor = 0x0000, .pci_subdevice = 0x8086, .config = ALC880_5ST_DIG }, */
-
-    { .modelname = "w810", .config = ALC880_W810 },
-    { .pci_subvendor = 0x161f, .pci_subdevice = 0x203d, .config = ALC880_W810 },
-
-    { .modelname = "z71v", .config = ALC880_Z71V },
-    { .pci_subvendor = 0x1043, .pci_subdevice = 0x1964, .config = ALC880_Z71V },
-
-    { .modelname = "6stack", .config = ALC880_6ST },
-    { .pci_subvendor = 0x1043, .pci_subdevice = 0x8196, .config = ALC880_6ST }, /* ASUS P5GD1-HVM */
-    { .pci_subvendor = 0x1043, .pci_subdevice = 0x81b4, .config = ALC880_6ST },
-    { .pci_subvendor = 0x1019, .pci_subdevice = 0xa884, .config = ALC880_6ST }, /* Acer APFV */
-    { .pci_subvendor = 0x1458, .pci_subdevice = 0xa102, .config = ALC880_6ST }, /* Gigabyte K8N51 */
-
-    { .modelname = "6stack-digout", .config = ALC880_6ST_DIG },
-    { .pci_subvendor = 0x2668, .pci_subdevice = 0x8086, .config = ALC880_6ST_DIG },
-    { .pci_subvendor = 0x8086, .pci_subdevice = 0x2668, .config = ALC880_6ST_DIG },
-    { .pci_subvendor = 0x1462, .pci_subdevice = 0x1150, .config = ALC880_6ST_DIG },
-    { .pci_subvendor = 0xe803, .pci_subdevice = 0x1019, .config = ALC880_6ST_DIG },
-    { .pci_subvendor = 0x1039, .pci_subdevice = 0x1234, .config = ALC880_6ST_DIG },
-    { .pci_subvendor = 0x1025, .pci_subdevice = 0x0077, .config = ALC880_6ST_DIG },
-    { .pci_subvendor = 0x1025, .pci_subdevice = 0x0078, .config = ALC880_6ST_DIG },
-    { .pci_subvendor = 0x1025, .pci_subdevice = 0x0087, .config = ALC880_6ST_DIG },
-    { .pci_subvendor = 0x1297, .pci_subdevice = 0xc790, .config = ALC880_6ST_DIG }, /* Shuttle ST20G5 */
-    { .pci_subvendor = 0x1509, .pci_subdevice = 0x925d, .config = ALC880_6ST_DIG }, /* FIC P4M-915GD1 */
-
-    { .modelname = "asus", .config = ALC880_ASUS },
-    { .pci_subvendor = 0x1043, .pci_subdevice = 0x1964, .config = ALC880_ASUS_DIG },
-    { .pci_subvendor = 0x1043, .pci_subdevice = 0x1973, .config = ALC880_ASUS_DIG },
-    { .pci_subvendor = 0x1043, .pci_subdevice = 0x19b3, .config = ALC880_ASUS_DIG },
-    { .pci_subvendor = 0x1043, .pci_subdevice = 0x1113, .config = ALC880_ASUS_DIG },
-    { .pci_subvendor = 0x1043, .pci_subdevice = 0x1173, .config = ALC880_ASUS_DIG },
-    { .pci_subvendor = 0x1043, .pci_subdevice = 0x1993, .config = ALC880_ASUS },
-    { .pci_subvendor = 0x1043, .pci_subdevice = 0x10c3, .config = ALC880_ASUS_DIG },
-    { .pci_subvendor = 0x1043, .pci_subdevice = 0x1133, .config = ALC880_ASUS },
-    { .pci_subvendor = 0x1043, .pci_subdevice = 0x1123, .config = ALC880_ASUS_DIG },
-    { .pci_subvendor = 0x1043, .pci_subdevice = 0x1143, .config = ALC880_ASUS },
-    { .pci_subvendor = 0x1043, .pci_subdevice = 0x10b3, .config = ALC880_ASUS_W1V },
-    { .pci_subvendor = 0x1043, .pci_subdevice = 0x8181, .config = ALC880_ASUS_DIG }, /* ASUS P4GPL-X */
-    { .pci_subvendor = 0x1558, .pci_subdevice = 0x5401, .config = ALC880_ASUS_DIG2 },
-
-    { .modelname = "uniwill", .config = ALC880_UNIWILL_DIG },
-    { .pci_subvendor = 0x1584, .pci_subdevice = 0x9050, .config = ALC880_UNIWILL_DIG },
-
-    { .modelname = "F1734", .config = ALC880_F1734 },
-    { .pci_subvendor = 0x1734, .pci_subdevice = 0x107c, .config = ALC880_F1734 },
-    { .pci_subvendor = 0x1584, .pci_subdevice = 0x9054, .config = ALC880_F1734 },
-
-    { .modelname = "lg", .config = ALC880_LG },
-    { .pci_subvendor = 0x1854, .pci_subdevice = 0x003b, .config = ALC880_LG },
-    { .pci_subvendor = 0x1854, .pci_subdevice = 0x0068, .config = ALC880_LG },
-    { .modelname = "lg-lw", .config = ALC880_LG_LW },
-    { .pci_subvendor = 0x1854, .pci_subdevice = 0x0018, .config = ALC880_LG_LW },
-
+static const char *alc880_models[ALC880_MODEL_LAST] = {
+        [ALC880_3ST]            = "3stack",
+        [ALC880_TCL_S700]       = "tcl",
+        [ALC880_3ST_DIG]        = "3stack-digout",
+        [ALC880_CLEVO]          = "clevo",
+        [ALC880_5ST]            = "5stack",
+        [ALC880_5ST_DIG]        = "5stack-digout",
+        [ALC880_W810]           = "w810",
+        [ALC880_Z71V]           = "z71v",
+        [ALC880_6ST]            = "6stack",
+        [ALC880_6ST_DIG]        = "6stack-digout",
+        [ALC880_ASUS]           = "asus",
+        [ALC880_ASUS_W1V]       = "asus-w1v",
+        [ALC880_ASUS_DIG]       = "asus-dig",
+        [ALC880_ASUS_DIG2]      = "asus-dig2",
+        [ALC880_UNIWILL_DIG]    = "uniwill",
+        [ALC880_F1734]          = "F1734",
+        [ALC880_LG]             = "lg",
+        [ALC880_LG_LW]          = "lg-lw",
 #ifdef CONFIG_SND_DEBUG
-    { .modelname = "test", .config = ALC880_TEST },
+        [ALC880_TEST]           = "test",
 #endif
-    { .modelname = "auto", .config = ALC880_AUTO },
-
-    {0}
+        [ALC880_AUTO]           = "auto",
+};
+
+static struct snd_pci_quirk alc880_cfg_tbl[] = {
+        /* Broken BIOS configuration */
+        SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG),
+        SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
+
+        SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
+        SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
+        SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
+        SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
+        SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
+        SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
+        SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
+        SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
+        SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
+
+        SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
+        SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
+
+        SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
+        SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
+        SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
+        SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
+        SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
+        SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
+        SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
+        /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
+        SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
+        SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
+        SND_PCI_QUIRK(0x1043, 0x814e, "ASUS", ALC880_ASUS),
+        SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
+        SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
+        SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
+        SND_PCI_QUIRK(0x1043, 0, "ASUS", ALC880_ASUS),
+
+        SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
+        SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
+        SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
+        SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
+        SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
+        SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
+        SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
+        SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
+        SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
+        SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
+        SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
+        SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
+        SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
+        SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
+        SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
+        SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
+        SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
+        SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
+
+        SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
+        SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
+        SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
+        SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
+
+        SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
+        SND_PCI_QUIRK(0x1734, 0x10ac, "FSC", ALC880_UNIWILL),
+        SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
+
+        SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
+        SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
+        SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
+        SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
+
+        SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
+        SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
+        SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
+        SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
+        SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
+        SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
+        SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
+        SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
+        SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
+        SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
+        SND_PCI_QUIRK(0x8086, 0, "Intel mobo", ALC880_3ST),
+
+        {0}
 };
 
@@ -2185 +2441 @@
  */
 static struct alc_config_preset alc880_presets[] = {
-    [ALC880_3ST] = {
-        .mixers = { alc880_three_stack_mixer },
-        .init_verbs = { alc880_volume_init_verbs, alc880_pin_3stack_init_verbs },
-        .num_dacs = ARRAY_SIZE(alc880_dac_nids),
-        .dac_nids = alc880_dac_nids,
-        .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
-        .channel_mode = alc880_threestack_modes,
-        .input_mux = &alc880_capture_source,
-    },
-    [ALC880_3ST_DIG] = {
-        .mixers = { alc880_three_stack_mixer },
-        .init_verbs = { alc880_volume_init_verbs, alc880_pin_3stack_init_verbs },
-        .num_dacs = ARRAY_SIZE(alc880_dac_nids),
-        .dac_nids = alc880_dac_nids,
-        .dig_out_nid = ALC880_DIGOUT_NID,
-        .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
-        .channel_mode = alc880_threestack_modes,
-        .input_mux = &alc880_capture_source,
-    },
-    [ALC880_TCL_S700] = {
-        .mixers = { alc880_tcl_s700_mixer },
-        .init_verbs = { alc880_volume_init_verbs,
-        alc880_pin_tcl_S700_init_verbs,
-        alc880_gpio2_init_verbs },
-        .num_dacs = ARRAY_SIZE(alc880_dac_nids),
-        .dac_nids = alc880_dac_nids,
-        .hp_nid = 0x03,
-        .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
-        .channel_mode = alc880_2_jack_modes,
-        .input_mux = &alc880_capture_source,
-    },
-    [ALC880_5ST] = {
-        .mixers = { alc880_three_stack_mixer, alc880_five_stack_mixer},
-        .init_verbs = { alc880_volume_init_verbs, alc880_pin_5stack_init_verbs },
-        .num_dacs = ARRAY_SIZE(alc880_dac_nids),
-        .dac_nids = alc880_dac_nids,
-        .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
-        .channel_mode = alc880_fivestack_modes,
-        .input_mux = &alc880_capture_source,
-    },
-    [ALC880_5ST_DIG] = {
-        .mixers = { alc880_three_stack_mixer, alc880_five_stack_mixer },
-        .init_verbs = { alc880_volume_init_verbs, alc880_pin_5stack_init_verbs },
-        .num_dacs = ARRAY_SIZE(alc880_dac_nids),
-        .dac_nids = alc880_dac_nids,
-        .dig_out_nid = ALC880_DIGOUT_NID,
-        .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
-        .channel_mode = alc880_fivestack_modes,
-        .input_mux = &alc880_capture_source,
-    },
-    [ALC880_6ST] = {
-        .mixers = { alc880_six_stack_mixer },
-        .init_verbs = { alc880_volume_init_verbs, alc880_pin_6stack_init_verbs },
-        .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
-        .dac_nids = alc880_6st_dac_nids,
-        .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
-        .channel_mode = alc880_sixstack_modes,
-        .input_mux = &alc880_6stack_capture_source,
-    },
-    [ALC880_6ST_DIG] = {
-        .mixers = { alc880_six_stack_mixer },
-        .init_verbs = { alc880_volume_init_verbs, alc880_pin_6stack_init_verbs },
-        .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
-        .dac_nids = alc880_6st_dac_nids,
-        .dig_out_nid = ALC880_DIGOUT_NID,
-        .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
-        .channel_mode = alc880_sixstack_modes,
-        .input_mux = &alc880_6stack_capture_source,
-    },
-    [ALC880_W810] = {
-        .mixers = { alc880_w810_base_mixer },
-        .init_verbs = { alc880_volume_init_verbs, alc880_pin_w810_init_verbs,
-        alc880_gpio2_init_verbs },
-        .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
-        .dac_nids = alc880_w810_dac_nids,
-        .dig_out_nid = ALC880_DIGOUT_NID,
-        .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
-        .channel_mode = alc880_w810_modes,
-        .input_mux = &alc880_capture_source,
-    },
-    [ALC880_Z71V] = {
-        .mixers = { alc880_z71v_mixer },
-        .init_verbs = { alc880_volume_init_verbs, alc880_pin_z71v_init_verbs },
-        .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
-        .dac_nids = alc880_z71v_dac_nids,
-        .dig_out_nid = ALC880_DIGOUT_NID,
-        .hp_nid = 0x03,
-        .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
-        .channel_mode = alc880_2_jack_modes,
-        .input_mux = &alc880_capture_source,
-    },
-    [ALC880_F1734] = {
-        .mixers = { alc880_f1734_mixer },
-        .init_verbs = { alc880_volume_init_verbs, alc880_pin_f1734_init_verbs },
-        .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
-        .dac_nids = alc880_f1734_dac_nids,
-        .hp_nid = 0x02,
-        .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
-        .channel_mode = alc880_2_jack_modes,
-        .input_mux = &alc880_capture_source,
-    },
-    [ALC880_ASUS] = {
-        .mixers = { alc880_asus_mixer },
-        .init_verbs = { alc880_volume_init_verbs, alc880_pin_asus_init_verbs,
-        alc880_gpio1_init_verbs },
-        .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
-        .dac_nids = alc880_asus_dac_nids,
-        .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
-        .channel_mode = alc880_asus_modes,
-        .input_mux = &alc880_capture_source,
-    },
-    [ALC880_ASUS_DIG] = {
-        .mixers = { alc880_asus_mixer },
-        .init_verbs = { alc880_volume_init_verbs, alc880_pin_asus_init_verbs,
-        alc880_gpio1_init_verbs },
-        .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
-        .dac_nids = alc880_asus_dac_nids,
-        .dig_out_nid = ALC880_DIGOUT_NID,
-        .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
-        .channel_mode = alc880_asus_modes,
-        .input_mux = &alc880_capture_source,
-    },
-    [ALC880_ASUS_DIG2] = {
-        .mixers = { alc880_asus_mixer },
-        .init_verbs = { alc880_volume_init_verbs, alc880_pin_asus_init_verbs,
-        alc880_gpio2_init_verbs }, /* use GPIO2 */
-        .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
-        .dac_nids = alc880_asus_dac_nids,
-        .dig_out_nid = ALC880_DIGOUT_NID,
-        .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
-        .channel_mode = alc880_asus_modes,
-        .input_mux = &alc880_capture_source,
-    },
-    [ALC880_ASUS_W1V] = {
-        .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
-        .init_verbs = { alc880_volume_init_verbs, alc880_pin_asus_init_verbs,
-        alc880_gpio1_init_verbs },
-        .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
-        .dac_nids = alc880_asus_dac_nids,
-        .dig_out_nid = ALC880_DIGOUT_NID,
-        .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
-        .channel_mode = alc880_asus_modes,
-        .input_mux = &alc880_capture_source,
-    },
-    [ALC880_UNIWILL_DIG] = {
-        .mixers = { alc880_asus_mixer, alc880_pcbeep_mixer },
-        .init_verbs = { alc880_volume_init_verbs, alc880_pin_asus_init_verbs },
-        .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
-        .dac_nids = alc880_asus_dac_nids,
-        .dig_out_nid = ALC880_DIGOUT_NID,
-        .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
-        .channel_mode = alc880_asus_modes,
-        .input_mux = &alc880_capture_source,
-    },
-    [ALC880_CLEVO] = {
-        .mixers = { alc880_three_stack_mixer },
-        .init_verbs = { alc880_volume_init_verbs,
-        alc880_pin_clevo_init_verbs },
-        .num_dacs = ARRAY_SIZE(alc880_dac_nids),
-        .dac_nids = alc880_dac_nids,
-        .hp_nid = 0x03,
-        .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
-        .channel_mode = alc880_threestack_modes,
-        .input_mux = &alc880_capture_source,
-    },
-    [ALC880_LG] = {
-        .mixers = { alc880_lg_mixer },
-        .init_verbs = { alc880_volume_init_verbs,
-        alc880_lg_init_verbs },
-        .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
-        .dac_nids = alc880_lg_dac_nids,
-        .dig_out_nid = ALC880_DIGOUT_NID,
-        .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
-        .channel_mode = alc880_lg_ch_modes,
-        .input_mux = &alc880_lg_capture_source,
-        .unsol_event = alc880_lg_unsol_event,
-        .init_hook = alc880_lg_automute,
-    },
-    [ALC880_LG_LW] = {
-        .mixers = { alc880_lg_lw_mixer },
-        .init_verbs = { alc880_volume_init_verbs,
-        alc880_lg_lw_init_verbs },
-        .num_dacs = 1,
-        .dac_nids = alc880_dac_nids,
-        .dig_out_nid = ALC880_DIGOUT_NID,
-        .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
-        .channel_mode = alc880_2_jack_modes,
-        .input_mux = &alc880_lg_lw_capture_source,
-        .unsol_event = alc880_lg_lw_unsol_event,
-        .init_hook = alc880_lg_lw_automute,
-    },
+        [ALC880_3ST] = {
+                .mixers = { alc880_three_stack_mixer },
+                .init_verbs = { alc880_volume_init_verbs, alc880_pin_3stack_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc880_dac_nids),
+                .dac_nids = alc880_dac_nids,
+                .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
+                .channel_mode = alc880_threestack_modes,
+                .need_dac_fix = 1,
+                .input_mux = &alc880_capture_source,
+        },
+        [ALC880_3ST_DIG] = {
+                .mixers = { alc880_three_stack_mixer },
+                .init_verbs = { alc880_volume_init_verbs, alc880_pin_3stack_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc880_dac_nids),
+                .dac_nids = alc880_dac_nids,
+                .dig_out_nid = ALC880_DIGOUT_NID,
+                .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
+                .channel_mode = alc880_threestack_modes,
+                .need_dac_fix = 1,
+                .input_mux = &alc880_capture_source,
+        },
+        [ALC880_TCL_S700] = {
+                .mixers = { alc880_tcl_s700_mixer },
+                .init_verbs = { alc880_volume_init_verbs,
+                                alc880_pin_tcl_S700_init_verbs,
+                                alc880_gpio2_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc880_dac_nids),
+                .dac_nids = alc880_dac_nids,
+                .hp_nid = 0x03,
+                .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
+                .channel_mode = alc880_2_jack_modes,
+                .input_mux = &alc880_capture_source,
+        },
+        [ALC880_5ST] = {
+                .mixers = { alc880_three_stack_mixer, alc880_five_stack_mixer},
+                .init_verbs = { alc880_volume_init_verbs, alc880_pin_5stack_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc880_dac_nids),
+                .dac_nids = alc880_dac_nids,
+                .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
+                .channel_mode = alc880_fivestack_modes,
+                .input_mux = &alc880_capture_source,
+        },
+        [ALC880_5ST_DIG] = {
+                .mixers = { alc880_three_stack_mixer, alc880_five_stack_mixer },
+                .init_verbs = { alc880_volume_init_verbs, alc880_pin_5stack_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc880_dac_nids),
+                .dac_nids = alc880_dac_nids,
+                .dig_out_nid = ALC880_DIGOUT_NID,
+                .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
+                .channel_mode = alc880_fivestack_modes,
+                .input_mux = &alc880_capture_source,
+        },
+        [ALC880_6ST] = {
+                .mixers = { alc880_six_stack_mixer },
+                .init_verbs = { alc880_volume_init_verbs, alc880_pin_6stack_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
+                .dac_nids = alc880_6st_dac_nids,
+                .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
+                .channel_mode = alc880_sixstack_modes,
+                .input_mux = &alc880_6stack_capture_source,
+        },
+        [ALC880_6ST_DIG] = {
+                .mixers = { alc880_six_stack_mixer },
+                .init_verbs = { alc880_volume_init_verbs, alc880_pin_6stack_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
+                .dac_nids = alc880_6st_dac_nids,
+                .dig_out_nid = ALC880_DIGOUT_NID,
+                .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
+                .channel_mode = alc880_sixstack_modes,
+                .input_mux = &alc880_6stack_capture_source,
+        },
+        [ALC880_W810] = {
+                .mixers = { alc880_w810_base_mixer },
+                .init_verbs = { alc880_volume_init_verbs, alc880_pin_w810_init_verbs,
+                                alc880_gpio2_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
+                .dac_nids = alc880_w810_dac_nids,
+                .dig_out_nid = ALC880_DIGOUT_NID,
+                .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
+                .channel_mode = alc880_w810_modes,
+                .input_mux = &alc880_capture_source,
+        },
+        [ALC880_Z71V] = {
+                .mixers = { alc880_z71v_mixer },
+                .init_verbs = { alc880_volume_init_verbs, alc880_pin_z71v_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
+                .dac_nids = alc880_z71v_dac_nids,
+                .dig_out_nid = ALC880_DIGOUT_NID,
+                .hp_nid = 0x03,
+                .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
+                .channel_mode = alc880_2_jack_modes,
+                .input_mux = &alc880_capture_source,
+        },
+        [ALC880_F1734] = {
+                .mixers = { alc880_f1734_mixer },
+                .init_verbs = { alc880_volume_init_verbs, alc880_pin_f1734_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
+                .dac_nids = alc880_f1734_dac_nids,
+                .hp_nid = 0x02,
+                .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
+                .channel_mode = alc880_2_jack_modes,
+                .input_mux = &alc880_capture_source,
+        },
+        [ALC880_ASUS] = {
+                .mixers = { alc880_asus_mixer },
+                .init_verbs = { alc880_volume_init_verbs, alc880_pin_asus_init_verbs,
+                                alc880_gpio1_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
+                .dac_nids = alc880_asus_dac_nids,
+                .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
+                .channel_mode = alc880_asus_modes,
+                .need_dac_fix = 1,
+                .input_mux = &alc880_capture_source,
+        },
+        [ALC880_ASUS_DIG] = {
+                .mixers = { alc880_asus_mixer },
+                .init_verbs = { alc880_volume_init_verbs, alc880_pin_asus_init_verbs,
+                                alc880_gpio1_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
+                .dac_nids = alc880_asus_dac_nids,
+                .dig_out_nid = ALC880_DIGOUT_NID,
+                .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
+                .channel_mode = alc880_asus_modes,
+                .need_dac_fix = 1,
+                .input_mux = &alc880_capture_source,
+        },
+        [ALC880_ASUS_DIG2] = {
+                .mixers = { alc880_asus_mixer },
+                .init_verbs = { alc880_volume_init_verbs, alc880_pin_asus_init_verbs,
+                                alc880_gpio2_init_verbs }, /* use GPIO2 */
+                .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
+                .dac_nids = alc880_asus_dac_nids,
+                .dig_out_nid = ALC880_DIGOUT_NID,
+                .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
+                .channel_mode = alc880_asus_modes,
+                .need_dac_fix = 1,
+                .input_mux = &alc880_capture_source,
+        },
+        [ALC880_ASUS_W1V] = {
+                .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
+                .init_verbs = { alc880_volume_init_verbs, alc880_pin_asus_init_verbs,
+                                alc880_gpio1_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
+                .dac_nids = alc880_asus_dac_nids,
+                .dig_out_nid = ALC880_DIGOUT_NID,
+                .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
+                .channel_mode = alc880_asus_modes,
+                .need_dac_fix = 1,
+                .input_mux = &alc880_capture_source,
+        },
+        [ALC880_UNIWILL_DIG] = {
+                .mixers = { alc880_asus_mixer, alc880_pcbeep_mixer },
+                .init_verbs = { alc880_volume_init_verbs,
+                                alc880_pin_asus_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
+                .dac_nids = alc880_asus_dac_nids,
+                .dig_out_nid = ALC880_DIGOUT_NID,
+                .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
+                .channel_mode = alc880_asus_modes,
+                .need_dac_fix = 1,
+                .input_mux = &alc880_capture_source,
+        },
+        [ALC880_UNIWILL] = {
+                .mixers = { alc880_uniwill_mixer },
+                .init_verbs = { alc880_volume_init_verbs,
+                                alc880_uniwill_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
+                .dac_nids = alc880_asus_dac_nids,
+                .dig_out_nid = ALC880_DIGOUT_NID,
+                .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
+                .channel_mode = alc880_threestack_modes,
+                .need_dac_fix = 1,
+                .input_mux = &alc880_capture_source,
+                .unsol_event = alc880_uniwill_unsol_event,
+                .init_hook = alc880_uniwill_automute,
+        },
+        [ALC880_UNIWILL_P53] = {
+                .mixers = { alc880_uniwill_p53_mixer },
+                .init_verbs = { alc880_volume_init_verbs,
+                                alc880_uniwill_p53_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
+                .dac_nids = alc880_asus_dac_nids,
+                .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
+                .channel_mode = alc880_w810_modes,
+                .input_mux = &alc880_capture_source,
+                .unsol_event = alc880_uniwill_p53_unsol_event,
+                .init_hook = alc880_uniwill_p53_hp_automute,
+        },
+        [ALC880_CLEVO] = {
+                .mixers = { alc880_three_stack_mixer },
+                .init_verbs = { alc880_volume_init_verbs,
+                                alc880_pin_clevo_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc880_dac_nids),
+                .dac_nids = alc880_dac_nids,
+                .hp_nid = 0x03,
+                .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
+                .channel_mode = alc880_threestack_modes,
+                .need_dac_fix = 1,
+                .input_mux = &alc880_capture_source,
+        },
+        [ALC880_LG] = {
+                .mixers = { alc880_lg_mixer },
+                .init_verbs = { alc880_volume_init_verbs,
+                                alc880_lg_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
+                .dac_nids = alc880_lg_dac_nids,
+                .dig_out_nid = ALC880_DIGOUT_NID,
+                .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
+                .channel_mode = alc880_lg_ch_modes,
+                .need_dac_fix = 1,
+                .input_mux = &alc880_lg_capture_source,
+                .unsol_event = alc880_lg_unsol_event,
+                .init_hook = alc880_lg_automute,
+        },
+        [ALC880_LG_LW] = {
+                .mixers = { alc880_lg_lw_mixer },
+                .init_verbs = { alc880_volume_init_verbs,
+                                alc880_lg_lw_init_verbs },
+                .num_dacs = 1, 
+                .dac_nids = alc880_dac_nids,
+                .dig_out_nid = ALC880_DIGOUT_NID,
+                .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
+                .channel_mode = alc880_2_jack_modes,
+                .input_mux = &alc880_lg_lw_capture_source,
+                .unsol_event = alc880_lg_lw_unsol_event,
+                .init_hook = alc880_lg_lw_automute,
+        },
 #ifdef CONFIG_SND_DEBUG
-    [ALC880_TEST] = {
-        .mixers = { alc880_test_mixer },
-        .init_verbs = { alc880_test_init_verbs },
-        .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
-        .dac_nids = alc880_test_dac_nids,
-        .dig_out_nid = ALC880_DIGOUT_NID,
-        .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
-        .channel_mode = alc880_test_modes,
-        .input_mux = &alc880_test_capture_source,
-    },
+        [ALC880_TEST] = {
+                .mixers = { alc880_test_mixer },
+                .init_verbs = { alc880_test_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
+                .dac_nids = alc880_test_dac_nids,
+                .dig_out_nid = ALC880_DIGOUT_NID,
+                .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
+                .channel_mode = alc880_test_modes,
+                .input_mux = &alc880_test_capture_source,
+        },
 #endif
 };
@@ -2398 +2690 @@
 
 enum {
-    ALC_CTL_WIDGET_VOL,
-    ALC_CTL_WIDGET_MUTE,
-    ALC_CTL_BIND_MUTE,
+        ALC_CTL_WIDGET_VOL,
+        ALC_CTL_WIDGET_MUTE,
+        ALC_CTL_BIND_MUTE,
 };
 static struct snd_kcontrol_new alc880_control_templates[] = {
-    HDA_CODEC_VOLUME(NULL, 0, 0, 0),
-    HDA_CODEC_MUTE(NULL, 0, 0, 0),
-    HDA_BIND_MUTE(NULL, 0, 0, 0),
+        HDA_CODEC_VOLUME(NULL, 0, 0, 0),
+        HDA_CODEC_MUTE(NULL, 0, 0, 0),
+        HDA_BIND_MUTE(NULL, 0, 0, 0),
 };
 
@@ -2411 +2703 @@
 static int add_control(struct alc_spec *spec, int type, const char *name, unsigned long val)
 {
-    struct snd_kcontrol_new *knew;
-
-    if (spec->num_kctl_used >= spec->num_kctl_alloc) {
-        int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC;
-
-        knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL); /* array + terminator */
-        if (! knew)
-            return -ENOMEM;
-        if (spec->kctl_alloc) {
-            memcpy(knew, spec->kctl_alloc, sizeof(*knew) * spec->num_kctl_alloc);
-            kfree(spec->kctl_alloc);
-        }
-        spec->kctl_alloc = knew;
-        spec->num_kctl_alloc = num;
-    }
-
-    knew = &spec->kctl_alloc[spec->num_kctl_used];
-    *knew = alc880_control_templates[type];
-    knew->name = kstrdup(name, GFP_KERNEL);
-    if (! knew->name)
-        return -ENOMEM;
-    knew->private_value = val;
-    spec->num_kctl_used++;
-    return 0;
+        struct snd_kcontrol_new *knew;
+
+        if (spec->num_kctl_used >= spec->num_kctl_alloc) {
+                int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC;
+
+                knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL); /* array + terminator */
+                if (! knew)
+                        return -ENOMEM;
+                if (spec->kctl_alloc) {
+                        memcpy(knew, spec->kctl_alloc, sizeof(*knew) * spec->num_kctl_alloc);
+                        kfree(spec->kctl_alloc);
+                }
+                spec->kctl_alloc = knew;
+                spec->num_kctl_alloc = num;
+        }
+
+        knew = &spec->kctl_alloc[spec->num_kctl_used];
+        *knew = alc880_control_templates[type];
+        knew->name = kstrdup(name, GFP_KERNEL);
+        if (! knew->name)
+                return -ENOMEM;
+        knew->private_value = val;
+        spec->num_kctl_used++;
+        return 0;
 }
 
@@ -2452 +2744 @@
 static int alc880_auto_fill_dac_nids(struct alc_spec *spec, const struct auto_pin_cfg *cfg)
 {
-    hda_nid_t nid;
-    int assigned[4];
-    int i, j;
-
-    memset(assigned, 0, sizeof(assigned));
-    spec->multiout.dac_nids = spec->private_dac_nids;
-
-    /* check the pins hardwired to audio widget */
-    for (i = 0; i < cfg->line_outs; i++) {
-        nid = cfg->line_out_pins[i];
-        if (alc880_is_fixed_pin(nid)) {
-            int idx = alc880_fixed_pin_idx(nid);
-            spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
-            assigned[idx] = 1;
-        }
-    }
-    /* left pins can be connect to any audio widget */
-    for (i = 0; i < cfg->line_outs; i++) {
-        nid = cfg->line_out_pins[i];
-        if (alc880_is_fixed_pin(nid))
-            continue;
-        /* search for an empty channel */
-        for (j = 0; j < cfg->line_outs; j++) {
-            if (! assigned[j]) {
-                spec->multiout.dac_nids[i] = alc880_idx_to_dac(j);
-                assigned[j] = 1;
-                break;
-            }
-        }
-    }
-    spec->multiout.num_dacs = cfg->line_outs;
-    return 0;
+        hda_nid_t nid;
+        int assigned[4];
+        int i, j;
+
+        memset(assigned, 0, sizeof(assigned));
+        spec->multiout.dac_nids = spec->private_dac_nids;
+
+        /* check the pins hardwired to audio widget */
+        for (i = 0; i < cfg->line_outs; i++) {
+                nid = cfg->line_out_pins[i];
+                if (alc880_is_fixed_pin(nid)) {
+                        int idx = alc880_fixed_pin_idx(nid);
+                        spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
+                        assigned[idx] = 1;
+                }
+        }
+        /* left pins can be connect to any audio widget */
+        for (i = 0; i < cfg->line_outs; i++) {
+                nid = cfg->line_out_pins[i];
+                if (alc880_is_fixed_pin(nid))
+                        continue;
+                /* search for an empty channel */
+                for (j = 0; j < cfg->line_outs; j++) {
+                        if (! assigned[j]) {
+                                spec->multiout.dac_nids[i] = alc880_idx_to_dac(j);
+                                assigned[j] = 1;
+                                break;
+                        }
+                }
+        }
+        spec->multiout.num_dacs = cfg->line_outs;
+        return 0;
 }
 
 /* add playback controls from the parsed DAC table */
 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
-                                             const struct auto_pin_cfg *cfg)
-{
-    char name[32];
-    static const char *chname[4] = { "Front", "Surround", NULL /*CLFE*/, "Side" };
-    hda_nid_t nid;
-    int i, err;
-
-    for (i = 0; i < cfg->line_outs; i++) {
-        if (! spec->multiout.dac_nids[i])
-            continue;
-        nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
-        if (i == 2) {
-            /* Center/LFE */
-            if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, "Center Playback Volume",
-                                   HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT))) < 0)
-                return err;
-            if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, "LFE Playback Volume",
-                                   HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT))) < 0)
-                return err;
-            if ((err = add_control(spec, ALC_CTL_BIND_MUTE, "Center Playback Switch",
-                                   HDA_COMPOSE_AMP_VAL(nid, 1, 2, HDA_INPUT))) < 0)
-                return err;
-            if ((err = add_control(spec, ALC_CTL_BIND_MUTE, "LFE Playback Switch",
-                                   HDA_COMPOSE_AMP_VAL(nid, 2, 2, HDA_INPUT))) < 0)
-                return err;
-        } else {
-            sprintf(name, "%s Playback Volume", chname[i]);
-            if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
-                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
-                return err;
-            sprintf(name, "%s Playback Switch", chname[i]);
-            if ((err = add_control(spec, ALC_CTL_BIND_MUTE, name,
-                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT))) < 0)
-                return err;
-        }
-    }
-    return 0;
+                                             const struct auto_pin_cfg *cfg)
+{
+        char name[32];
+        static const char *chname[4] = { "Front", "Surround", NULL /*CLFE*/, "Side" };
+        hda_nid_t nid;
+        int i, err;
+
+        for (i = 0; i < cfg->line_outs; i++) {
+                if (! spec->multiout.dac_nids[i])
+                        continue;
+                nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
+                if (i == 2) {
+                        /* Center/LFE */
+                        if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, "Center Playback Volume",
+                                               HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT))) < 0)
+                                return err;
+                        if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, "LFE Playback Volume",
+                                               HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT))) < 0)
+                                return err;
+                        if ((err = add_control(spec, ALC_CTL_BIND_MUTE, "Center Playback Switch",
+                                               HDA_COMPOSE_AMP_VAL(nid, 1, 2, HDA_INPUT))) < 0)
+                                return err;
+                        if ((err = add_control(spec, ALC_CTL_BIND_MUTE, "LFE Playback Switch",
+                                               HDA_COMPOSE_AMP_VAL(nid, 2, 2, HDA_INPUT))) < 0)
+                                return err;
+                } else {
+                        sprintf(name, "%s Playback Volume", chname[i]);
+                        if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
+                                               HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
+                                return err;
+                        sprintf(name, "%s Playback Switch", chname[i]);
+                        if ((err = add_control(spec, ALC_CTL_BIND_MUTE, name,
+                                               HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT))) < 0)
+                                return err;
+                }
+        }
+        return 0;
 }
 
 /* add playback controls for speaker and HP outputs */
 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
-                                        const char *pfx)
-{
-    hda_nid_t nid;
-    int err;
-    char name[32];
-
-    if (! pin)
-        return 0;
-
-    if (alc880_is_fixed_pin(pin)) {
-        nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
-        /* specify the DAC as the extra output */
-        if (! spec->multiout.hp_nid)
-            spec->multiout.hp_nid = nid;
-        else
-            spec->multiout.extra_out_nid[0] = nid;
-        /* control HP volume/switch on the output mixer amp */
-        nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
-        sprintf(name, "%s Playback Volume", pfx);
-        if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
-                               HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
-            return err;
-        sprintf(name, "%s Playback Switch", pfx);
-        if ((err = add_control(spec, ALC_CTL_BIND_MUTE, name,
-                               HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT))) < 0)
-            return err;
-    } else if (alc880_is_multi_pin(pin)) {
-        /* set manual connection */
-        /* we have only a switch on HP-out PIN */
-        sprintf(name, "%s Playback Switch", pfx);
-        if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
-                               HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT))) < 0)
-            return err;
-    }
-    return 0;
+                                        const char *pfx)
+{
+        hda_nid_t nid;
+        int err;
+        char name[32];
+
+        if (! pin)
+                return 0;
+
+        if (alc880_is_fixed_pin(pin)) {
+                nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
+                /* specify the DAC as the extra output */
+                if (! spec->multiout.hp_nid)
+                        spec->multiout.hp_nid = nid;
+                else
+                        spec->multiout.extra_out_nid[0] = nid;
+                /* control HP volume/switch on the output mixer amp */
+                nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
+                sprintf(name, "%s Playback Volume", pfx);
+                if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
+                                       HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
+                        return err;
+                sprintf(name, "%s Playback Switch", pfx);
+                if ((err = add_control(spec, ALC_CTL_BIND_MUTE, name,
+                                       HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT))) < 0)
+                        return err;
+        } else if (alc880_is_multi_pin(pin)) {
+                /* set manual connection */
+                /* we have only a switch on HP-out PIN */
+                sprintf(name, "%s Playback Switch", pfx);
+                if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
+                                       HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT))) < 0)
+                        return err;
+        }
+        return 0;
 }
 
 /* create input playback/capture controls for the given pin */
 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin, const char *ctlname,
-                            int idx, hda_nid_t mix_nid)
-{
-    char name[32];
-    int err;
-
-    sprintf(name, "%s Playback Volume", ctlname);
-    if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
-                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT))) < 0)
-        return err;
-    sprintf(name, "%s Playback Switch", ctlname);
-    if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
-                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT))) < 0)
-        return err;
-    return 0;
+                            int idx, hda_nid_t mix_nid)
+{
+        char name[32];
+        int err;
+
+        sprintf(name, "%s Playback Volume", ctlname);
+        if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
+                               HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT))) < 0)
+                return err;
+        sprintf(name, "%s Playback Switch", ctlname);
+        if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
+                               HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT))) < 0)
+                return err;
+        return 0;
 }
 
 /* create playback/capture controls for input pins */
 static int alc880_auto_create_analog_input_ctls(struct alc_spec *spec,
-                                                const struct auto_pin_cfg *cfg)
-{
-    struct hda_input_mux *imux = &spec->private_imux;
-    int i, err, idx;
-
-    for (i = 0; i < AUTO_PIN_LAST; i++) {
-        if (alc880_is_input_pin(cfg->input_pins[i])) {
-            idx = alc880_input_pin_idx(cfg->input_pins[i]);
-            err = new_analog_input(spec, cfg->input_pins[i],
-                                   auto_pin_cfg_labels[i],
-                                   idx, 0x0b);
-            if (err < 0)
-                return err;
-            imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
-            imux->items[imux->num_items].index = alc880_input_pin_idx(cfg->input_pins[i]);
-            imux->num_items++;
-        }
-    }
-    return 0;
+                                                const struct auto_pin_cfg *cfg)
+{
+        struct hda_input_mux *imux = &spec->private_imux;
+        int i, err, idx;
+
+        for (i = 0; i < AUTO_PIN_LAST; i++) {
+                if (alc880_is_input_pin(cfg->input_pins[i])) {
+                        idx = alc880_input_pin_idx(cfg->input_pins[i]);
+                        err = new_analog_input(spec, cfg->input_pins[i],
+                                               auto_pin_cfg_labels[i],
+                                               idx, 0x0b);
+                        if (err < 0)
+                                return err;
+                        imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
+                        imux->items[imux->num_items].index = alc880_input_pin_idx(cfg->input_pins[i]);
+                        imux->num_items++;
+                }
+        }
+        return 0;
 }
 
 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
-                                              hda_nid_t nid, int pin_type,
-                                              int dac_idx)
-{
-    /* set as output */
-    snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
-    snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
-    /* need the manual connection? */
-    if (alc880_is_multi_pin(nid)) {
-        struct alc_spec *spec = codec->spec;
-        int idx = alc880_multi_pin_idx(nid);
-        snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
-                            AC_VERB_SET_CONNECT_SEL,
-                            alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
-    }
+                                              hda_nid_t nid, int pin_type,
+                                              int dac_idx)
+{
+        /* set as output */
+        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
+        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
+        /* need the manual connection? */
+        if (alc880_is_multi_pin(nid)) {
+                struct alc_spec *spec = codec->spec;
+                int idx = alc880_multi_pin_idx(nid);
+                snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
+                                    AC_VERB_SET_CONNECT_SEL,
+                                    alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
+        }
 }
 
 static void alc880_auto_init_multi_out(struct hda_codec *codec)
 {
-    struct alc_spec *spec = codec->spec;
-    int i;
-
-    for (i = 0; i < spec->autocfg.line_outs; i++) {
-        hda_nid_t nid = spec->autocfg.line_out_pins[i];
-        alc880_auto_set_output_and_unmute(codec, nid, PIN_OUT, i);
-    }
+        struct alc_spec *spec = codec->spec;
+        int i;
+
+        for (i = 0; i < spec->autocfg.line_outs; i++) {
+                hda_nid_t nid = spec->autocfg.line_out_pins[i];
+                alc880_auto_set_output_and_unmute(codec, nid, PIN_OUT, i);
+        }
 }
 
 static void alc880_auto_init_extra_out(struct hda_codec *codec)
 {
-    struct alc_spec *spec = codec->spec;
-    hda_nid_t pin;
-
-    pin = spec->autocfg.speaker_pins[0];
-    if (pin) /* connect to front */
-        alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
-    pin = spec->autocfg.hp_pin;
-    if (pin) /* connect to front */
-        alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
+        struct alc_spec *spec = codec->spec;
+        hda_nid_t pin;
+
+        pin = spec->autocfg.speaker_pins[0];
+        if (pin) /* connect to front */
+                alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
+        pin = spec->autocfg.hp_pins[0];
+        if (pin) /* connect to front */
+                alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
 }
 
 static void alc880_auto_init_analog_input(struct hda_codec *codec)
 {
-    struct alc_spec *spec = codec->spec;
-    int i;
-
-    for (i = 0; i < AUTO_PIN_LAST; i++) {
-        hda_nid_t nid = spec->autocfg.input_pins[i];
-        if (alc880_is_input_pin(nid)) {
-            snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
-                                i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN);
-            if (nid != ALC880_PIN_CD_NID)
-                snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
-                                    AMP_OUT_MUTE);
-        }
-    }
+        struct alc_spec *spec = codec->spec;
+        int i;
+
+        for (i = 0; i < AUTO_PIN_LAST; i++) {
+                hda_nid_t nid = spec->autocfg.input_pins[i];
+                if (alc880_is_input_pin(nid)) {
+                        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
+                                            i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN);
+                        if (nid != ALC880_PIN_CD_NID)
+                                snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
+                                                    AMP_OUT_MUTE);
+                }
+        }
 }
 
@@ -2669 +2961 @@
 static int alc880_parse_auto_config(struct hda_codec *codec)
 {
-    struct alc_spec *spec = codec->spec;
-    int err;
-    static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
-
-    if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
-                                            alc880_ignore)) < 0)
-        return err;
-    if (! spec->autocfg.line_outs)
-        return 0; /* can't find valid BIOS pin config */
-
-    if ((err = alc880_auto_fill_dac_nids(spec, &spec->autocfg)) < 0 ||
-        (err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0 ||
-        (err = alc880_auto_create_extra_out(spec,
-                                            spec->autocfg.speaker_pins[0],
-                                            "Speaker")) < 0 ||
-        (err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pin,
-                                            "Headphone")) < 0 ||
-        (err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0)
-        return err;
-
-    spec->multiout.max_channels = spec->multiout.num_dacs * 2;
-
-    if (spec->autocfg.dig_out_pin)
-        spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
-    if (spec->autocfg.dig_in_pin)
-        spec->dig_in_nid = ALC880_DIGIN_NID;
-
-    if (spec->kctl_alloc)
-        spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
-
-    spec->init_verbs[spec->num_init_verbs++] = alc880_volume_init_verbs;
-
-    spec->input_mux = &spec->private_imux;
-
-    return 1;
+        struct alc_spec *spec = codec->spec;
+        int err;
+        static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
+
+        if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
+                                                alc880_ignore)) < 0)
+                return err;
+        if (! spec->autocfg.line_outs)
+                return 0; /* can't find valid BIOS pin config */
+
+        if ((err = alc880_auto_fill_dac_nids(spec, &spec->autocfg)) < 0 ||
+            (err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0 ||
+            (err = alc880_auto_create_extra_out(spec,
+                                                spec->autocfg.speaker_pins[0],
+                                                "Speaker")) < 0 ||
+            (err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
+                                                "Headphone")) < 0 ||
+            (err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0)
+                return err;
+
+        spec->multiout.max_channels = spec->multiout.num_dacs * 2;
+
+        if (spec->autocfg.dig_out_pin)
+                spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
+        if (spec->autocfg.dig_in_pin)
+                spec->dig_in_nid = ALC880_DIGIN_NID;
+
+        if (spec->kctl_alloc)
+                spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
+
+        spec->init_verbs[spec->num_init_verbs++] = alc880_volume_init_verbs;
+
+        spec->num_mux_defs = 1;
+        spec->input_mux = &spec->private_imux;
+
+        return 1;
 }
 
@@ -2709 +3002 @@
 static void alc880_auto_init(struct hda_codec *codec)
 {
-    alc880_auto_init_multi_out(codec);
-    alc880_auto_init_extra_out(codec);
-    alc880_auto_init_analog_input(codec);
+        alc880_auto_init_multi_out(codec);
+        alc880_auto_init_extra_out(codec);
+        alc880_auto_init_analog_input(codec);
 }
 
@@ -2720 +3013 @@
 static int patch_alc880(struct hda_codec *codec)
 {
-    struct alc_spec *spec;
-    int board_config;
-    int err;
-
-    spec = kzalloc(sizeof(*spec), GFP_KERNEL);
-    if (spec == NULL)
-        return -ENOMEM;
-
-    codec->spec = spec;
-
-    board_config = snd_hda_check_board_config(codec, alc880_cfg_tbl);
-    if (board_config < 0 || board_config >= ALC880_MODEL_LAST) {
-        printk(KERN_INFO "hda_codec: Unknown model for ALC880, trying auto-probe from BIOS...\n");
-        board_config = ALC880_AUTO;
-    }
-
-    if (board_config == ALC880_AUTO) {
-        /* automatic parse from the BIOS config */
-        err = alc880_parse_auto_config(codec);
-        if (err < 0) {
-            alc_free(codec);
-            return err;
-        } else if (! err) {
-            printk(KERN_INFO "hda_codec: Cannot set up configuration from BIOS.  Using 3-stack mode...\n");
-            board_config = ALC880_3ST;
-        }
-    }
-
-    if (board_config != ALC880_AUTO)
-        setup_preset(spec, &alc880_presets[board_config]);
-
-    spec->stream_name_analog = "ALC880 Analog";
-    spec->stream_analog_playback = &alc880_pcm_analog_playback;
-    spec->stream_analog_capture = &alc880_pcm_analog_capture;
-
-    spec->stream_name_digital = "ALC880 Digital";
-    spec->stream_digital_playback = &alc880_pcm_digital_playback;
-    spec->stream_digital_capture = &alc880_pcm_digital_capture;
-
-    if (! spec->adc_nids && spec->input_mux) {
-        /* check whether NID 0x07 is valid */
-        unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
-        wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; /* get type */
-        if (wcap != AC_WID_AUD_IN) {
-            spec->adc_nids = alc880_adc_nids_alt;
-            spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
-            spec->mixers[spec->num_mixers] = alc880_capture_alt_mixer;
-            spec->num_mixers++;
-        } else {
-            spec->adc_nids = alc880_adc_nids;
-            spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
-            spec->mixers[spec->num_mixers] = alc880_capture_mixer;
-            spec->num_mixers++;
-        }
-    }
-
-    codec->patch_ops = alc_patch_ops;
-    if (board_config == ALC880_AUTO)
-        spec->init_hook = alc880_auto_init;
-
-    return 0;
+        struct alc_spec *spec;
+        int board_config;
+        int err;
+
+        spec = kzalloc(sizeof(*spec), GFP_KERNEL);
+        if (spec == NULL)
+                return -ENOMEM;
+
+        codec->spec = spec;
+
+        board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
+                                                  alc880_models,
+                                                  alc880_cfg_tbl);
+        if (board_config < 0) {
+                printk(KERN_INFO "hda_codec: Unknown model for ALC880, "
+                       "trying auto-probe from BIOS...\n");
+                board_config = ALC880_AUTO;
+        }
+
+        if (board_config == ALC880_AUTO) {
+                /* automatic parse from the BIOS config */
+                err = alc880_parse_auto_config(codec);
+                if (err < 0) {
+                        alc_free(codec);
+                        return err;
+                } else if (! err) {
+                        printk(KERN_INFO
+                               "hda_codec: Cannot set up configuration "
+                               "from BIOS.  Using 3-stack mode...\n");
+                        board_config = ALC880_3ST;
+                }
+        }
+
+        if (board_config != ALC880_AUTO)
+                setup_preset(spec, &alc880_presets[board_config]);
+
+        spec->stream_name_analog = "ALC880 Analog";
+        spec->stream_analog_playback = &alc880_pcm_analog_playback;
+        spec->stream_analog_capture = &alc880_pcm_analog_capture;
+
+        spec->stream_name_digital = "ALC880 Digital";
+        spec->stream_digital_playback = &alc880_pcm_digital_playback;
+        spec->stream_digital_capture = &alc880_pcm_digital_capture;
+
+        if (! spec->adc_nids && spec->input_mux) {
+                /* check whether NID 0x07 is valid */
+                unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
+                wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; /* get type */
+                if (wcap != AC_WID_AUD_IN) {
+                        spec->adc_nids = alc880_adc_nids_alt;
+                        spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
+                        spec->mixers[spec->num_mixers] = alc880_capture_alt_mixer;
+                        spec->num_mixers++;
+                } else {
+                        spec->adc_nids = alc880_adc_nids;
+                        spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
+                        spec->mixers[spec->num_mixers] = alc880_capture_mixer;
+                        spec->num_mixers++;
+                }
+        }
+
+        codec->patch_ops = alc_patch_ops;
+        if (board_config == ALC880_AUTO)
+                spec->init_hook = alc880_auto_init;
+
+        return 0;
 }
 
@@ -2789 +3087 @@
 
 static hda_nid_t alc260_dac_nids[1] = {
-    /* front */
-    0x02,
+        /* front */
+        0x02,
 };
 
 static hda_nid_t alc260_adc_nids[1] = {
-    /* ADC0 */
-    0x04,
+        /* ADC0 */
+        0x04,
 };
 
 static hda_nid_t alc260_adc_nids_alt[1] = {
-    /* ADC1 */
-    0x05,
+        /* ADC1 */
+        0x05,
 };
 
 static hda_nid_t alc260_hp_adc_nids[2] = {
-    /* ADC1, 0 */
-    0x05, 0x04
+        /* ADC1, 0 */
+        0x05, 0x04
 };
 
@@ -2812 +3110 @@
  */
 static hda_nid_t alc260_dual_adc_nids[2] = {
-    /* ADC0, ADC1 */
-    0x04, 0x05
+        /* ADC0, ADC1 */
+        0x04, 0x05
 };
 
@@ -2820 +3118 @@
 
 static struct hda_input_mux alc260_capture_source = {
-    .num_items = 4,
-    .items = {
-        { "Mic", 0x0 },
-        { "Front Mic", 0x1 },
-        { "Line", 0x2 },
-        { "CD", 0x4 },
-    },
+        .num_items = 4,
+        .items = {
+                { "Mic", 0x0 },
+                { "Front Mic", 0x1 },
+                { "Line", 0x2 },
+                { "CD", 0x4 },
+        },
 };
 
 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
- * headphone jack and the internal CD lines.
- */
-static struct hda_input_mux alc260_fujitsu_capture_source = {
-    .num_items = 3,
-    .items = {
-        { "Mic/Line", 0x0 },
-        { "CD", 0x4 },
-        { "Headphone", 0x2 },
-    },
-};
-
-/* Acer TravelMate(/Extensa/Aspire) notebooks have similar configutation to
- * the Fujitsu S702x, but jacks are marked differently. We won't allow
- * retasking the Headphone jack, so it won't be available here.
- */
-static struct hda_input_mux alc260_acer_capture_source = {
-    .num_items = 3,
-    .items = {
-        { "Mic", 0x0 },
-        { "Line", 0x2 },
-        { "CD", 0x4 },
-    },
-};
-
+ * headphone jack and the internal CD lines since these are the only pins at
+ * which audio can appear.  For flexibility, also allow the option of
+ * recording the mixer output on the second ADC (ADC0 doesn't have a
+ * connection to the mixer output).
+ */
+static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
+        {
+                .num_items = 3,
+                .items = {
+                        { "Mic/Line", 0x0 },
+                        { "CD", 0x4 },
+                        { "Headphone", 0x2 },
+                },
+        },
+        {
+                .num_items = 4,
+                .items = {
+                        { "Mic/Line", 0x0 },
+                        { "CD", 0x4 },
+                        { "Headphone", 0x2 },
+                        { "Mixer", 0x5 },
+                },
+        },
+
+};
+
+/* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
+ * the Fujitsu S702x, but jacks are marked differently.
+ */
+static struct hda_input_mux alc260_acer_capture_sources[2] = {
+        {
+                .num_items = 4,
+                .items = {
+                        { "Mic", 0x0 },
+                        { "Line", 0x2 },
+                        { "CD", 0x4 },
+                        { "Headphone", 0x5 },
+                },
+        },
+        {
+                .num_items = 5,
+                .items = {
+                        { "Mic", 0x0 },
+                        { "Line", 0x2 },
+                        { "CD", 0x4 },
+                        { "Headphone", 0x6 },
+                        { "Mixer", 0x5 },
+                },
+        },
+};
 /*
  * This is just place-holder, so there's something for alc_build_pcms to look
@@ -2861 +3185 @@
  */
 static struct hda_channel_mode alc260_modes[1] = {
-    { 2, NULL },
+        { 2, NULL },
 };
 
@@ -2875 +3199 @@
 
 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
-    HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
-    HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
-    HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
-    {0} /* end */
-};
+        HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
+        {0} /* end */
+};      
 
 static struct snd_kcontrol_new alc260_input_mixer[] = {
-    HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
-    HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
-    HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
-    HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
-    HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
-    HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
-    HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
-    {0} /* end */
+        HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
+        HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
+        HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
+        HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
+        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
+        {0} /* end */
 };
 
 static struct snd_kcontrol_new alc260_pc_beep_mixer[] = {
-    HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x07, 0x05, HDA_INPUT),
-    HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x07, 0x05, HDA_INPUT),
-    {0} /* end */
+        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x07, 0x05, HDA_INPUT),
+        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x07, 0x05, HDA_INPUT),
+        {0} /* end */
 };
 
 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
-    HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
-    HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
-    HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
-    HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
-    HDA_CODEC_VOLUME_MONO("iSpeaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE_MONO("iSpeaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
-    {0} /* end */
-};
-
+        HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
+        HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
+        HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME_MONO("iSpeaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE_MONO("iSpeaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
+        {0} /* end */
+};
+
+/* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12, 
+ * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
+ */
 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
-    HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
-    ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
-    HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
-    HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
-    HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
-    ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
-    HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
-    HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
-    HDA_CODEC_VOLUME("Internal Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE("Internal Speaker Playback Switch", 0x09, 2, HDA_INPUT),
-    {0} /* end */
-};
-
+        HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
+        ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
+        HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
+        HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
+        ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
+        HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
+        HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
+        HDA_CODEC_VOLUME("Internal Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Internal Speaker Playback Switch", 0x09, 2, HDA_INPUT),
+        {0} /* end */
+};
+
+/* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
+ * versions of the ALC260 don't act on requests to enable mic bias from NID
+ * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
+ * datasheet doesn't mention this restriction.  At this stage it's not clear
+ * whether this behaviour is intentional or is a hardware bug in chip
+ * revisions available in early 2006.  Therefore for now allow the
+ * "Headphone Jack Mode" control to span all choices, but if it turns out
+ * that the lack of mic bias for this NID is intentional we could change the
+ * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
+ *
+ * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
+ * don't appear to make the mic bias available from the "line" jack, even
+ * though the NID used for this jack (0x14) can supply it.  The theory is
+ * that perhaps Acer have included blocking capacitors between the ALC260
+ * and the output jack.  If this turns out to be the case for all such
+ * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
+ * to ALC_PIN_DIR_INOUT_NOMICBIAS.
+ *
+ * The C20x Tablet series have a mono internal speaker which is controlled
+ * via the chip's Mono sum widget and pin complex, so include the necessary
+ * controls for such models.  On models without a "mono speaker" the control
+ * won't do anything.
+ */
 static struct snd_kcontrol_new alc260_acer_mixer[] = {
-    HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
-    HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
-    HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
-    HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
-    ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
-    HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
-    HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
-    ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
-    HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
-    HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
-    {0} /* end */
+        HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
+        ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
+        HDA_CODEC_VOLUME_MONO("Mono Speaker Playback Volume", 0x0a, 1, 0x0,
+                              HDA_OUTPUT),
+        HDA_BIND_MUTE_MONO("Mono Speaker Playback Switch", 0x0a, 1, 2,
+                           HDA_INPUT),
+        HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
+        HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
+        ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
+        HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
+        HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
+        ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
+        HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
+        HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
+        {0} /* end */
 };
 
 /* capture mixer elements */
 static struct snd_kcontrol_new alc260_capture_mixer[] = {
-    HDA_CODEC_VOLUME("Capture Volume", 0x04, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE("Capture Switch", 0x04, 0x0, HDA_INPUT),
-    HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x05, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x05, 0x0, HDA_INPUT),
-    {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        /* The multiple "Capture Source" controls confuse alsamixer
-         * So call somewhat different..
-         * FIXME: the controls appear in the "playback" view!
-         */
-        /* .name = "Capture Source", */
-        .name = "Input Source",
-        .count = 2,
-        .info = alc_mux_enum_info,
-        .get = alc_mux_enum_get,
-        .put = alc_mux_enum_put,
-    },
-    {0} /* end */
+        HDA_CODEC_VOLUME("Capture Volume", 0x04, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x04, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x05, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x05, 0x0, HDA_INPUT),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                /* The multiple "Capture Source" controls confuse alsamixer
+                 * So call somewhat different..
+                 * FIXME: the controls appear in the "playback" view!
+                 */
+                /* .name = "Capture Source", */
+                .name = "Input Source",
+                .count = 2,
+                .info = alc_mux_enum_info,
+                .get = alc_mux_enum_get,
+                .put = alc_mux_enum_put,
+        },
+        {0} /* end */
 };
 
 static struct snd_kcontrol_new alc260_capture_alt_mixer[] = {
-    HDA_CODEC_VOLUME("Capture Volume", 0x05, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE("Capture Switch", 0x05, 0x0, HDA_INPUT),
-    {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        /* The multiple "Capture Source" controls confuse alsamixer
-         * So call somewhat different..
-         * FIXME: the controls appear in the "playback" view!
-         */
-        /* .name = "Capture Source", */
-        .name = "Input Source",
-        .count = 1,
-        .info = alc_mux_enum_info,
-        .get = alc_mux_enum_get,
-        .put = alc_mux_enum_put,
-    },
-    {0} /* end */
+        HDA_CODEC_VOLUME("Capture Volume", 0x05, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x05, 0x0, HDA_INPUT),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                /* The multiple "Capture Source" controls confuse alsamixer
+                 * So call somewhat different..
+                 * FIXME: the controls appear in the "playback" view!
+                 */
+                /* .name = "Capture Source", */
+                .name = "Input Source",
+                .count = 1,
+                .info = alc_mux_enum_info,
+                .get = alc_mux_enum_get,
+                .put = alc_mux_enum_put,
+        },
+        {0} /* end */
 };
 
@@ -2991 +3346 @@
  */
 static struct hda_verb alc260_init_verbs[] = {
-    /* Line In pin widget for input */
-    {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
-    /* CD pin widget for input */
-    {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
-    /* Mic1 (rear panel) pin widget for input and vref at 80% */
-    {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
-    /* Mic2 (front panel) pin widget for input and vref at 80% */
-    {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
-    /* LINE-2 is used for line-out in rear */
-    {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    /* select line-out */
-    {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
-    /* LINE-OUT pin */
-    {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    /* enable HP */
-    {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
-    /* enable Mono */
-    {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    /* mute capture amp left and right */
-    {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    /* set connection select to line in (default select for this ADC) */
-    {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
-    /* mute capture amp left and right */
-    {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    /* set connection select to line in (default select for this ADC) */
-    {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
-    /* set vol=0 Line-Out mixer amp left and right */
-    {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    /* unmute pin widget amp left and right (no gain on this amp) */
-    {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    /* set vol=0 HP mixer amp left and right */
-    {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    /* unmute pin widget amp left and right (no gain on this amp) */
-    {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    /* set vol=0 Mono mixer amp left and right */
-    {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    /* unmute pin widget amp left and right (no gain on this amp) */
-    {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    /* unmute LINE-2 out pin */
-    {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 & Line In 2 = 0x03 */
-    /* mute CD */
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
-    /* mute Line In */
-    {0x07,  AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
-    /* mute Mic */
-    {0x07,  AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
-    /* mute Front out path */
-    {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
-    /* mute Headphone out path */
-    {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
-    /* mute Mono out path */
-    {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
-    {0}
+        /* Line In pin widget for input */
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        /* CD pin widget for input */
+        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        /* Mic1 (rear panel) pin widget for input and vref at 80% */
+        {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        /* Mic2 (front panel) pin widget for input and vref at 80% */
+        {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        /* LINE-2 is used for line-out in rear */
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        /* select line-out */
+        {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
+        /* LINE-OUT pin */
+        {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        /* enable HP */
+        {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        /* enable Mono */
+        {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        /* mute capture amp left and right */
+        {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        /* set connection select to line in (default select for this ADC) */
+        {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
+        /* mute capture amp left and right */
+        {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        /* set connection select to line in (default select for this ADC) */
+        {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
+        /* set vol=0 Line-Out mixer amp left and right */
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        /* unmute pin widget amp left and right (no gain on this amp) */
+        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        /* set vol=0 HP mixer amp left and right */
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        /* unmute pin widget amp left and right (no gain on this amp) */
+        {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        /* set vol=0 Mono mixer amp left and right */
+        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        /* unmute pin widget amp left and right (no gain on this amp) */
+        {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        /* unmute LINE-2 out pin */
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 & Line In 2 = 0x03 */
+        /* mute CD */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
+        /* mute Line In */
+        {0x07,  AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
+        /* mute Mic */
+        {0x07,  AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
+        /* mute Front out path */
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        /* mute Headphone out path */
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        /* mute Mono out path */
+        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        {0}
 };
 
 #if 0 /* should be identical with alc260_init_verbs? */
 static struct hda_verb alc260_hp_init_verbs[] = {
-    /* Headphone and output */
-    {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
-    /* mono output */
-    {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
-    /* Mic1 (rear panel) pin widget for input and vref at 80% */
-    {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
-    /* Mic2 (front panel) pin widget for input and vref at 80% */
-    {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
-    /* Line In pin widget for input */
-    {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
-    /* Line-2 pin widget for output */
-    {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
-    /* CD pin widget for input */
-    {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
-    /* unmute amp left and right */
-    {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
-    /* set connection select to line in (default select for this ADC) */
-    {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
-    /* unmute Line-Out mixer amp left and right (volume = 0) */
-    {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
-    /* mute pin widget amp left and right (no gain on this amp) */
-    {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
-    /* unmute HP mixer amp left and right (volume = 0) */
-    {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
-    /* mute pin widget amp left and right (no gain on this amp) */
-    {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
-    /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 & Line In 2 = 0x03 */
-    /* unmute CD */
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
-    /* unmute Line In */
-    {0x07,  AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
-    /* unmute Mic */
-    {0x07,  AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
-    /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
-    /* Unmute Front out path */
-    {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
-    {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
-    /* Unmute Headphone out path */
-    {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
-    {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
-    /* Unmute Mono out path */
-    {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
-    {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
-    {0}
+        /* Headphone and output */
+        {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
+        /* mono output */
+        {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
+        /* Mic1 (rear panel) pin widget for input and vref at 80% */
+        {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
+        /* Mic2 (front panel) pin widget for input and vref at 80% */
+        {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
+        /* Line In pin widget for input */
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
+        /* Line-2 pin widget for output */
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
+        /* CD pin widget for input */
+        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
+        /* unmute amp left and right */
+        {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
+        /* set connection select to line in (default select for this ADC) */
+        {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
+        /* unmute Line-Out mixer amp left and right (volume = 0) */
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
+        /* mute pin widget amp left and right (no gain on this amp) */
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
+        /* unmute HP mixer amp left and right (volume = 0) */
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
+        /* mute pin widget amp left and right (no gain on this amp) */
+        {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
+        /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 & Line In 2 = 0x03 */
+        /* unmute CD */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
+        /* unmute Line In */
+        {0x07,  AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
+        /* unmute Mic */
+        {0x07,  AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
+        /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
+        /* Unmute Front out path */
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
+        /* Unmute Headphone out path */
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
+        /* Unmute Mono out path */
+        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
+        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
+        {0}
 };
 #endif
 
 static struct hda_verb alc260_hp_3013_init_verbs[] = {
-    /* Line out and output */
-    {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
-    /* mono output */
-    {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
-    /* Mic1 (rear panel) pin widget for input and vref at 80% */
-    {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
-    /* Mic2 (front panel) pin widget for input and vref at 80% */
-    {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
-    /* Line In pin widget for input */
-    {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
-    /* Headphone pin widget for output */
-    {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
-    /* CD pin widget for input */
-    {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
-    /* unmute amp left and right */
-    {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
-    /* set connection select to line in (default select for this ADC) */
-    {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
-    /* unmute Line-Out mixer amp left and right (volume = 0) */
-    {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
-    /* mute pin widget amp left and right (no gain on this amp) */
-    {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
-    /* unmute HP mixer amp left and right (volume = 0) */
-    {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
-    /* mute pin widget amp left and right (no gain on this amp) */
-    {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
-    /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 & Line In 2 = 0x03 */
-    /* unmute CD */
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
-    /* unmute Line In */
-    {0x07,  AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
-    /* unmute Mic */
-    {0x07,  AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
-    /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
-    /* Unmute Front out path */
-    {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
-    {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
-    /* Unmute Headphone out path */
-    {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
-    {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
-    /* Unmute Mono out path */
-    {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
-    {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
-    {0}
+        /* Line out and output */
+        {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
+        /* mono output */
+        {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
+        /* Mic1 (rear panel) pin widget for input and vref at 80% */
+        {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
+        /* Mic2 (front panel) pin widget for input and vref at 80% */
+        {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
+        /* Line In pin widget for input */
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
+        /* Headphone pin widget for output */
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
+        /* CD pin widget for input */
+        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
+        /* unmute amp left and right */
+        {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
+        /* set connection select to line in (default select for this ADC) */
+        {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
+        /* unmute Line-Out mixer amp left and right (volume = 0) */
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
+        /* mute pin widget amp left and right (no gain on this amp) */
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
+        /* unmute HP mixer amp left and right (volume = 0) */
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
+        /* mute pin widget amp left and right (no gain on this amp) */
+        {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
+        /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 & Line In 2 = 0x03 */
+        /* unmute CD */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
+        /* unmute Line In */
+        {0x07,  AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
+        /* unmute Mic */
+        {0x07,  AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
+        /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
+        /* Unmute Front out path */
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
+        /* Unmute Headphone out path */
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
+        /* Unmute Mono out path */
+        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
+        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
+        {0}
 };
 
 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
- * laptops.
+ * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
+ * audio = 0x16, internal speaker = 0x10.
  */
 static struct hda_verb alc260_fujitsu_init_verbs[] = {
-    /* Disable all GPIOs */
-    {0x01, AC_VERB_SET_GPIO_MASK, 0},
-    /* Internal speaker is connected to headphone pin */
-    {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
-    /* Headphone/Line-out jack connects to Line1 pin; make it an output */
-    {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
-    {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
-    /* Ensure all other unused pins are disabled and muted. */
-    {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
-    {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
-    {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
-    {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
-    {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-
-    /* Disable digital (SPDIF) pins */
-    {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
-    {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
-
-    /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
-     * when acting as an output.
-     */
-    {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
-
-    /* Start with output sum widgets muted and their output gains at min */
-    {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
-    {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
-    {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
-    {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-
-    /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
-    {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    /* Unmute Line1 pin widget output buffer since it starts as an output.
-     * If the pin mode is changed by the user the pin mode control will
-     * take care of enabling the pin's input/output buffers as needed.
-     * Therefore there's no need to enable the input buffer at this
-     * stage.
-     */
-    {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    /* Unmute input buffer of pin widget used for Line-in (no equiv
-     * mixer ctrl)
-     */
-    {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-
-    /* Mute capture amp left and right */
-    {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    /* Set ADC connection select to match default mixer setting - line
-     * in (on mic1 pin)
-     */
-    {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
-
-    /* Do the same for the second ADC: mute capture input amp and
-     * set ADC connection to line in (on mic1 pin)
-     */
-    {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
-
-    /* Mute all inputs to mixer widget (even unconnected ones) */
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
-
-    {0}
+        /* Disable all GPIOs */
+        {0x01, AC_VERB_SET_GPIO_MASK, 0},
+        /* Internal speaker is connected to headphone pin */
+        {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        /* Headphone/Line-out jack connects to Line1 pin; make it an output */
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
+        {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        /* Ensure all other unused pins are disabled and muted. */
+        {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
+        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
+        {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
+        {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+
+        /* Disable digital (SPDIF) pins */
+        {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
+        {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
+
+        /* Ensure Line1 pin widget takes its input from the OUT1 sum bus 
+         * when acting as an output.
+         */
+        {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
+
+        /* Start with output sum widgets muted and their output gains at min */
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+
+        /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
+        {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        /* Unmute Line1 pin widget output buffer since it starts as an output.
+         * If the pin mode is changed by the user the pin mode control will
+         * take care of enabling the pin's input/output buffers as needed.
+         * Therefore there's no need to enable the input buffer at this
+         * stage.
+         */
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        /* Unmute input buffer of pin widget used for Line-in (no equiv 
+         * mixer ctrl)
+         */
+        {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+
+        /* Mute capture amp left and right */
+        {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        /* Set ADC connection select to match default mixer setting - line 
+         * in (on mic1 pin)
+         */
+        {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
+
+        /* Do the same for the second ADC: mute capture input amp and
+         * set ADC connection to line in (on mic1 pin)
+         */
+        {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
+
+        /* Mute all inputs to mixer widget (even unconnected ones) */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
+
+        {0}
 };
 
@@ -3233 +3589 @@
  */
 static struct hda_verb alc260_acer_init_verbs[] = {
-    /* On TravelMate laptops, GPIO 0 enables the internal speaker and
-     * the headphone jack.  Turn this on and rely on the standard mute
-     * methods whenever the user wants to turn these outputs off.
-     */
-    {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
-    {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
-    {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
-    /* Internal speaker/Headphone jack is connected to Line-out pin */
-    {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
-    /* Internal microphone/Mic jack is connected to Mic1 pin */
-    {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
-    /* Line In jack is connected to Line1 pin */
-    {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
-    /* Ensure all other unused pins are disabled and muted. */
-    {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
-    {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
-    {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
-    {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
-    {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    /* Disable digital (SPDIF) pins */
-    {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
-    {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
-
-    /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
-     * bus when acting as outputs.
-     */
-    {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
-    {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
-
-    /* Start with output sum widgets muted and their output gains at min */
-    {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
-    {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
-    {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
-    {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-
-    /* Unmute Line-out pin widget amp left and right (no equiv mixer ctrl) */
-    {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    /* Unmute Mic1 and Line1 pin widget input buffers since they start as
-     * inputs. If the pin mode is changed by the user the pin mode control
-     * will take care of enabling the pin's input/output buffers as needed.
-     * Therefore there's no need to enable the input buffer at this
-     * stage.
-     */
-    {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-
-    /* Mute capture amp left and right */
-    {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    /* Set ADC connection select to match default mixer setting - mic
-     * (on mic1 pin)
-     */
-    {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
-
-    /* Do similar with the second ADC: mute capture input amp and
-     * set ADC connection to line (on line1 pin)
-     */
-    {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
-
-    /* Mute all inputs to mixer widget (even unconnected ones) */
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
-
-    {0}
+        /* On TravelMate laptops, GPIO 0 enables the internal speaker and
+         * the headphone jack.  Turn this on and rely on the standard mute
+         * methods whenever the user wants to turn these outputs off.
+         */
+        {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
+        {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
+        {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
+        /* Internal speaker/Headphone jack is connected to Line-out pin */
+        {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        /* Internal microphone/Mic jack is connected to Mic1 pin */
+        {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
+        /* Line In jack is connected to Line1 pin */
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
+        {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        /* Ensure all other unused pins are disabled and muted. */
+        {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
+        {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
+        {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        /* Disable digital (SPDIF) pins */
+        {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
+        {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
+
+        /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum 
+         * bus when acting as outputs.
+         */
+        {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
+        {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
+
+        /* Start with output sum widgets muted and their output gains at min */
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+
+        /* Unmute Line-out pin widget amp left and right (no equiv mixer ctrl) */
+        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
+        {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        /* Unmute Mic1 and Line1 pin widget input buffers since they start as
+         * inputs. If the pin mode is changed by the user the pin mode control
+         * will take care of enabling the pin's input/output buffers as needed.
+         * Therefore there's no need to enable the input buffer at this
+         * stage.
+         */
+        {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+
+        /* Mute capture amp left and right */
+        {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        /* Set ADC connection select to match default mixer setting - mic
+         * (on mic1 pin)
+         */
+        {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
+
+        /* Do similar with the second ADC: mute capture input amp and
+         * set ADC connection to mic to match ALSA's default state.
+         */
+        {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
+
+        /* Mute all inputs to mixer widget (even unconnected ones) */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
+
+        {0}
 };
 
@@ -3318 +3676 @@
 #ifdef CONFIG_SND_DEBUG
 static hda_nid_t alc260_test_dac_nids[1] = {
-    0x02,
+        0x02,
 };
 static hda_nid_t alc260_test_adc_nids[2] = {
-    0x04, 0x05,
-};
-/* This is a bit messy since the two input muxes in the ALC260 have slight
- * variations in their signal assignments.  The ideal way to deal with this
- * is to extend alc_spec.input_mux to allow a different input MUX for each
- * ADC.  For the purposes of the test model it's sufficient to just list
- * both options for affected signal indices.  The separate input mux
- * functionality only needs to be considered if a model comes along which
- * actually uses signals 0x5, 0x6 and 0x7 for something which makes sense to
- * record.
- */
-static struct hda_input_mux alc260_test_capture_source = {
-    .num_items = 8,
-    .items = {
-        { "MIC1 pin", 0x0 },
-        { "MIC2 pin", 0x1 },
-        { "LINE1 pin", 0x2 },
-        { "LINE2 pin", 0x3 },
-        { "CD pin", 0x4 },
-        { "LINE-OUT pin (cap1), Mixer (cap2)", 0x5 },
-        { "HP-OUT pin (cap1), LINE-OUT pin (cap2)", 0x6 },
-        { "HP-OUT pin (cap2 only)", 0x7 },
-    },
+        0x04, 0x05,
+};
+/* For testing the ALC260, each input MUX needs its own definition since
+ * the signal assignments are different.  This assumes that the first ADC 
+ * is NID 0x04.
+ */
+static struct hda_input_mux alc260_test_capture_sources[2] = {
+        {
+                .num_items = 7,
+                .items = {
+                        { "MIC1 pin", 0x0 },
+                        { "MIC2 pin", 0x1 },
+                        { "LINE1 pin", 0x2 },
+                        { "LINE2 pin", 0x3 },
+                        { "CD pin", 0x4 },
+                        { "LINE-OUT pin", 0x5 },
+                        { "HP-OUT pin", 0x6 },
+                },
+        },
+        {
+                .num_items = 8,
+                .items = {
+                        { "MIC1 pin", 0x0 },
+                        { "MIC2 pin", 0x1 },
+                        { "LINE1 pin", 0x2 },
+                        { "LINE2 pin", 0x3 },
+                        { "CD pin", 0x4 },
+                        { "Mixer", 0x5 },
+                        { "LINE-OUT pin", 0x6 },
+                        { "HP-OUT pin", 0x7 },
+                },
+        },
 };
 static struct snd_kcontrol_new alc260_test_mixer[] = {
-    /* Output driver widgets */
-    HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
-    HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
-    HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
-
-    /* Modes for retasking pin widgets */
-    ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
-    ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
-    ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
-    ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
-    ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
-    ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
-
-    /* Loopback mixer controls */
-    HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
-    HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
-    HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
-    HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
-    HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
-    HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
-    HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
-    HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
-    HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
-    HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
-    HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
-    HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
-    HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
-    HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
-    HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
-    HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
-
-    /* Controls for GPIO pins, assuming they are configured as outputs */
-    ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
-    ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
-    ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
-    ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
-
-    /* Switches to allow the digital IO pins to be enabled.  The datasheet
-     * is ambigious as to which NID is which; testing on laptops which
-     * make this output available should provide clarification.
-     */
-    ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
-    ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
-
-    {0} /* end */
+        /* Output driver widgets */
+        HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
+
+        /* Modes for retasking pin widgets
+         * Note: the ALC260 doesn't seem to act on requests to enable mic
+         * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
+         * mention this restriction.  At this stage it's not clear whether
+         * this behaviour is intentional or is a hardware bug in chip
+         * revisions available at least up until early 2006.  Therefore for
+         * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
+         * choices, but if it turns out that the lack of mic bias for these
+         * NIDs is intentional we could change their modes from
+         * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
+         */
+        ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
+        ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
+        ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
+        ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
+        ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
+        ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
+
+        /* Loopback mixer controls */
+        HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
+        HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
+        HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
+        HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
+        HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
+        HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
+        HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
+        HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
+        HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
+        HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
+        HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
+        HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
+        HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
+        HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
+        HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
+        HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
+
+        /* Controls for GPIO pins, assuming they are configured as outputs */
+        ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
+        ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
+        ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
+        ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
+
+        /* Switches to allow the digital IO pins to be enabled.  The datasheet
+         * is ambigious as to which NID is which; testing on laptops which
+         * make this output available should provide clarification. 
+         */
+        ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
+        ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
+
+        {0} /* end */
 };
 static struct hda_verb alc260_test_init_verbs[] = {
-    /* Enable all GPIOs as outputs with an initial value of 0 */
-    {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
-    {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
-    {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
-
-    /* Enable retasking pins as output, initially without power amp */
-    {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-
-    /* Disable digital (SPDIF) pins initially, but users can enable
-     * them via a mixer switch.  In the case of SPDIF-out, this initverb
-     * payload also sets the generation to 0, output to be in "consumer"
-     * PCM format, copyright asserted, no pre-emphasis and no validity
-     * control.
-     */
-    {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
-    {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
-
-    /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
-     * OUT1 sum bus when acting as an output.
-     */
-    {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
-    {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
-    {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
-    {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
-
-    /* Start with output sum widgets muted and their output gains at min */
-    {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
-    {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
-    {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
-    {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-
-    /* Unmute retasking pin widget output buffers since the default
-     * state appears to be output.  As the pin mode is changed by the
-     * user the pin mode control will take care of enabling the pin's
-     * input/output buffers as needed.
-     */
-    {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    /* Also unmute the mono-out pin widget */
-    {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-
-    /* Mute capture amp left and right */
-    {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    /* Set ADC connection select to match default mixer setting (mic1
-     * pin)
-     */
-    {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
-
-    /* Do the same for the second ADC: mute capture input amp and
-     * set ADC connection to mic1 pin
-     */
-    {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
-
-    /* Mute all inputs to mixer widget (even unconnected ones) */
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
-
-    {0}
+        /* Enable all GPIOs as outputs with an initial value of 0 */
+        {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
+        {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
+        {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
+
+        /* Enable retasking pins as output, initially without power amp */
+        {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+
+        /* Disable digital (SPDIF) pins initially, but users can enable
+         * them via a mixer switch.  In the case of SPDIF-out, this initverb
+         * payload also sets the generation to 0, output to be in "consumer"
+         * PCM format, copyright asserted, no pre-emphasis and no validity
+         * control.
+         */
+        {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
+        {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
+
+        /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the 
+         * OUT1 sum bus when acting as an output.
+         */
+        {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
+        {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
+        {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
+        {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
+
+        /* Start with output sum widgets muted and their output gains at min */
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+
+        /* Unmute retasking pin widget output buffers since the default
+         * state appears to be output.  As the pin mode is changed by the
+         * user the pin mode control will take care of enabling the pin's
+         * input/output buffers as needed.
+         */
+        {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        /* Also unmute the mono-out pin widget */
+        {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+
+        /* Mute capture amp left and right */
+        {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        /* Set ADC connection select to match default mixer setting (mic1
+         * pin)
+         */
+        {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
+
+        /* Do the same for the second ADC: mute capture input amp and
+         * set ADC connection to mic1 pin
+         */
+        {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
+
+        /* Mute all inputs to mixer widget (even unconnected ones) */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
+
+        {0}
 };
 #endif
 
 static struct hda_pcm_stream alc260_pcm_analog_playback = {
-    .substreams = 1,
-    .channels_min = 2,
-    .channels_max = 2,
+        .substreams = 1,
+        .channels_min = 2,
+        .channels_max = 2,
 };
 
 static struct hda_pcm_stream alc260_pcm_analog_capture = {
-    .substreams = 1,
-    .channels_min = 2,
-    .channels_max = 2,
+        .substreams = 1,
+        .channels_min = 2,
+        .channels_max = 2,
 };
 
@@ -3498 +3875 @@
 
 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
-                                        const char *pfx)
-{
-    hda_nid_t nid_vol;
-    unsigned long vol_val, sw_val;
-    char name[32];
-    int err;
-
-    if (nid >= 0x0f && nid < 0x11) {
-        nid_vol = nid - 0x7;
-        vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
-        sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
-    } else if (nid == 0x11) {
-        nid_vol = nid - 0x7;
-        vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
-        sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
-    } else if (nid >= 0x12 && nid <= 0x15) {
-        nid_vol = 0x08;
-        vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
-        sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
-    } else
-        return 0; /* N/A */
-
-    sprintf(name, /*sizeof(name), */"%s Playback Volume", pfx);
-    if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, name, vol_val)) < 0)
-        return err;
-    sprintf(name, /*sizeof(name), */"%s Playback Switch", pfx);
-    if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, sw_val)) < 0)
-        return err;
-    return 1;
+                                        const char *pfx)
+{
+        hda_nid_t nid_vol;
+        unsigned long vol_val, sw_val;
+        char name[32];
+        int err;
+
+        if (nid >= 0x0f && nid < 0x11) {
+                nid_vol = nid - 0x7;
+                vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
+                sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
+        } else if (nid == 0x11) {
+                nid_vol = nid - 0x7;
+                vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
+                sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
+        } else if (nid >= 0x12 && nid <= 0x15) {
+                nid_vol = 0x08;
+                vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
+                sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
+        } else
+                return 0; /* N/A */
+        
+        sprintf(name, "%s Playback Volume", pfx);
+        if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, name, vol_val)) < 0)
+                return err;
+        sprintf(name, "%s Playback Switch", pfx);
+        if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, sw_val)) < 0)
+                return err;
+        return 1;
 }
 
 /* add playback controls from the parsed DAC table */
 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
-                                             const struct auto_pin_cfg *cfg)
-{
-    hda_nid_t nid;
-    int err;
-
-    spec->multiout.num_dacs = 1;
-    spec->multiout.dac_nids = spec->private_dac_nids;
-    spec->multiout.dac_nids[0] = 0x02;
-
-    nid = cfg->line_out_pins[0];
-    if (nid) {
-        err = alc260_add_playback_controls(spec, nid, "Front");
-        if (err < 0)
-            return err;
-    }
-
-    nid = cfg->speaker_pins[0];
-    if (nid) {
-        err = alc260_add_playback_controls(spec, nid, "Speaker");
-        if (err < 0)
-            return err;
-    }
-
-    nid = cfg->hp_pin;
-    if (nid) {
-        err = alc260_add_playback_controls(spec, nid, "Headphone");
-        if (err < 0)
-            return err;
-    }
-    return 0;
+                                             const struct auto_pin_cfg *cfg)
+{
+        hda_nid_t nid;
+        int err;
+
+        spec->multiout.num_dacs = 1;
+        spec->multiout.dac_nids = spec->private_dac_nids;
+        spec->multiout.dac_nids[0] = 0x02;
+
+        nid = cfg->line_out_pins[0];
+        if (nid) {
+                err = alc260_add_playback_controls(spec, nid, "Front");
+                if (err < 0)
+                        return err;
+        }
+
+        nid = cfg->speaker_pins[0];
+        if (nid) {
+                err = alc260_add_playback_controls(spec, nid, "Speaker");
+                if (err < 0)
+                        return err;
+        }
+
+        nid = cfg->hp_pins[0];
+        if (nid) {
+                err = alc260_add_playback_controls(spec, nid, "Headphone");
+                if (err < 0)
+                        return err;
+        }
+        return 0;       
 }
 
 /* create playback/capture controls for input pins */
 static int alc260_auto_create_analog_input_ctls(struct alc_spec *spec,
-                                                const struct auto_pin_cfg *cfg)
-{
-    struct hda_input_mux *imux = &spec->private_imux;
-    int i, err, idx;
-
-    for (i = 0; i < AUTO_PIN_LAST; i++) {
-        if (cfg->input_pins[i] >= 0x12) {
-            idx = cfg->input_pins[i] - 0x12;
-            err = new_analog_input(spec, cfg->input_pins[i],
-                                   auto_pin_cfg_labels[i], idx, 0x07);
-            if (err < 0)
-                return err;
-            imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
-            imux->items[imux->num_items].index = idx;
-            imux->num_items++;
-        }
-        if ((cfg->input_pins[i] >= 0x0f) && (cfg->input_pins[i] <= 0x10)){
-            idx = cfg->input_pins[i] - 0x09;
-            err = new_analog_input(spec, cfg->input_pins[i],
-                                   auto_pin_cfg_labels[i], idx, 0x07);
-            if (err < 0)
-                return err;
-            imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
-            imux->items[imux->num_items].index = idx;
-            imux->num_items++;
-        }
-    }
-    return 0;
+                                                const struct auto_pin_cfg *cfg)
+{
+        struct hda_input_mux *imux = &spec->private_imux;
+        int i, err, idx;
+
+        for (i = 0; i < AUTO_PIN_LAST; i++) {
+                if (cfg->input_pins[i] >= 0x12) {
+                        idx = cfg->input_pins[i] - 0x12;
+                        err = new_analog_input(spec, cfg->input_pins[i],
+                                               auto_pin_cfg_labels[i], idx, 0x07);
+                        if (err < 0)
+                                return err;
+                        imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
+                        imux->items[imux->num_items].index = idx;
+                        imux->num_items++;
+                }
+                if ((cfg->input_pins[i] >= 0x0f) && (cfg->input_pins[i] <= 0x10)){
+                        idx = cfg->input_pins[i] - 0x09;
+                        err = new_analog_input(spec, cfg->input_pins[i],
+                                               auto_pin_cfg_labels[i], idx, 0x07);
+                        if (err < 0)
+                                return err;
+                        imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
+                        imux->items[imux->num_items].index = idx;
+                        imux->num_items++;
+                }
+        }
+        return 0;
 }
 
 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
-                                              hda_nid_t nid, int pin_type,
-                                              int sel_idx)
-{
-    /* set as output */
-    snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
-    snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
-    /* need the manual connection? */
-    if (nid >= 0x12) {
-        int idx = nid - 0x12;
-        snd_hda_codec_write(codec, idx + 0x0b, 0,
-                            AC_VERB_SET_CONNECT_SEL, sel_idx);
-
-    }
+                                              hda_nid_t nid, int pin_type,
+                                              int sel_idx)
+{
+        /* set as output */
+        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
+        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
+        /* need the manual connection? */
+        if (nid >= 0x12) {
+                int idx = nid - 0x12;
+                snd_hda_codec_write(codec, idx + 0x0b, 0,
+                                    AC_VERB_SET_CONNECT_SEL, sel_idx);
+                                    
+        }
 }
 
 static void alc260_auto_init_multi_out(struct hda_codec *codec)
 {
-    struct alc_spec *spec = codec->spec;
-    hda_nid_t nid;
-
-    nid = spec->autocfg.line_out_pins[0];
-    if (nid)
-        alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
-
-    nid = spec->autocfg.speaker_pins[0];
-    if (nid)
-        alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
-
-    nid = spec->autocfg.hp_pin;
-    if (nid)
-        alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
-}
+        struct alc_spec *spec = codec->spec;
+        hda_nid_t nid;
+
+        nid = spec->autocfg.line_out_pins[0];   
+        if (nid)
+                alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
+        
+        nid = spec->autocfg.speaker_pins[0];
+        if (nid)
+                alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
+
+        nid = spec->autocfg.hp_pins[0];
+        if (nid)
+                alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
+}       
 
 #define ALC260_PIN_CD_NID               0x16
 static void alc260_auto_init_analog_input(struct hda_codec *codec)
 {
-    struct alc_spec *spec = codec->spec;
-    int i;
-
-    for (i = 0; i < AUTO_PIN_LAST; i++) {
-        hda_nid_t nid = spec->autocfg.input_pins[i];
-        if (nid >= 0x12) {
-            snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
-                                i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN);
-            if (nid != ALC260_PIN_CD_NID)
-                snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
-                                    AMP_OUT_MUTE);
-        }
-    }
+        struct alc_spec *spec = codec->spec;
+        int i;
+
+        for (i = 0; i < AUTO_PIN_LAST; i++) {
+                hda_nid_t nid = spec->autocfg.input_pins[i];
+                if (nid >= 0x12) {
+                        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
+                                            i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN);
+                        if (nid != ALC260_PIN_CD_NID)
+                                snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
+                                                    AMP_OUT_MUTE);
+                }
+        }
 }
 
@@ -3651 +4028 @@
  */
 static struct hda_verb alc260_volume_init_verbs[] = {
-    /*
-     * Unmute ADC0-1 and set the default input to mic-in
-     */
-    {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
-    {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
-    {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-
-    /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
-     * mixer widget
-     * Note: PASD motherboards uses the Line In 2 as the input for front panel
-     * mic (mic 2)
-     */
-    /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
-
-    /*
-     * Set up output mixers (0x08 - 0x0a)
-     */
-    /* set vol=0 to output mixers */
-    {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    /* set up input amps for analog loopback */
-    /* Amp Indices: DAC = 0, mixer = 1 */
-    {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-
-    {0}
+        /*
+         * Unmute ADC0-1 and set the default input to mic-in
+         */
+        {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        
+        /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
+         * mixer widget
+         * Note: PASD motherboards uses the Line In 2 as the input for front panel
+         * mic (mic 2)
+         */
+        /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
+
+        /*
+         * Set up output mixers (0x08 - 0x0a)
+         */
+        /* set vol=0 to output mixers */
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        /* set up input amps for analog loopback */
+        /* Amp Indices: DAC = 0, mixer = 1 */
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        
+        {0}
 };
 
 static int alc260_parse_auto_config(struct hda_codec *codec)
 {
-    struct alc_spec *spec = codec->spec;
-    unsigned int wcap;
-    int err;
-    static hda_nid_t alc260_ignore[] = { 0x17, 0 };
-
-    if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
-                                            alc260_ignore)) < 0)
-        return err;
-    if ((err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0)
-        return err;
-    if (! spec->kctl_alloc)
-        return 0; /* can't find valid BIOS pin config */
-    if ((err = alc260_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0)
-        return err;
-
-    spec->multiout.max_channels = 2;
-
-    if (spec->autocfg.dig_out_pin)
-        spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
-    if (spec->kctl_alloc)
-        spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
-
-    spec->init_verbs[spec->num_init_verbs++] = alc260_volume_init_verbs;
-
-    spec->input_mux = &spec->private_imux;
-
-    /* check whether NID 0x04 is valid */
-    wcap = get_wcaps(codec, 0x04);
-    wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; /* get type */
-    if (wcap != AC_WID_AUD_IN) {
-        spec->adc_nids = alc260_adc_nids_alt;
-        spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
-        spec->mixers[spec->num_mixers] = alc260_capture_alt_mixer;
-    } else {
-        spec->adc_nids = alc260_adc_nids;
-        spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
-        spec->mixers[spec->num_mixers] = alc260_capture_mixer;
-    }
-    spec->num_mixers++;
-
-    return 1;
+        struct alc_spec *spec = codec->spec;
+        unsigned int wcap;
+        int err;
+        static hda_nid_t alc260_ignore[] = { 0x17, 0 };
+
+        if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
+                                                alc260_ignore)) < 0)
+                return err;
+        if ((err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0)
+                return err;
+        if (! spec->kctl_alloc)
+                return 0; /* can't find valid BIOS pin config */
+        if ((err = alc260_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0)
+                return err;
+
+        spec->multiout.max_channels = 2;
+
+        if (spec->autocfg.dig_out_pin)
+                spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
+        if (spec->kctl_alloc)
+                spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
+
+        spec->init_verbs[spec->num_init_verbs++] = alc260_volume_init_verbs;
+
+        spec->num_mux_defs = 1;
+        spec->input_mux = &spec->private_imux;
+
+        /* check whether NID 0x04 is valid */
+        wcap = get_wcaps(codec, 0x04);
+        wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; /* get type */
+        if (wcap != AC_WID_AUD_IN) {
+                spec->adc_nids = alc260_adc_nids_alt;
+                spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
+                spec->mixers[spec->num_mixers] = alc260_capture_alt_mixer;
+        } else {
+                spec->adc_nids = alc260_adc_nids;
+                spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
+                spec->mixers[spec->num_mixers] = alc260_capture_mixer;
+        }
+        spec->num_mixers++;
+
+        return 1;
 }
 
@@ -3738 +4116 @@
 static void alc260_auto_init(struct hda_codec *codec)
 {
-    alc260_auto_init_multi_out(codec);
-    alc260_auto_init_analog_input(codec);
+        alc260_auto_init_multi_out(codec);
+        alc260_auto_init_analog_input(codec);
 }
 
@@ -3745 +4123 @@
  * ALC260 configurations
  */
-static struct hda_board_config alc260_cfg_tbl[] = {
-    { .modelname = "basic", .config = ALC260_BASIC },
-    { .pci_subvendor = 0x104d, .pci_subdevice = 0x81bb,
-    .config = ALC260_BASIC }, /* Sony VAIO */
-    { .pci_subvendor = 0x104d, .pci_subdevice = 0x81cc,
-    .config = ALC260_BASIC }, /* Sony VAIO VGN-S3HP */
-    { .pci_subvendor = 0x104d, .pci_subdevice = 0x81cd,
-    .config = ALC260_BASIC }, /* Sony VAIO */
-    { .pci_subvendor = 0x152d, .pci_subdevice = 0x0729,
-    .config = ALC260_BASIC }, /* CTL Travel Master U553W */
-    { .modelname = "hp", .config = ALC260_HP },
-    { .pci_subvendor = 0x103c, .pci_subdevice = 0x3010, .config = ALC260_HP },
-    { .pci_subvendor = 0x103c, .pci_subdevice = 0x3011, .config = ALC260_HP },
-    { .pci_subvendor = 0x103c, .pci_subdevice = 0x3012, .config = ALC260_HP_3013 },
-    { .pci_subvendor = 0x103c, .pci_subdevice = 0x3013, .config = ALC260_HP_3013 },
-    { .pci_subvendor = 0x103c, .pci_subdevice = 0x3014, .config = ALC260_HP },
-    { .pci_subvendor = 0x103c, .pci_subdevice = 0x3015, .config = ALC260_HP },
-    { .pci_subvendor = 0x103c, .pci_subdevice = 0x3016, .config = ALC260_HP },
-    { .modelname = "fujitsu", .config = ALC260_FUJITSU_S702X },
-    { .pci_subvendor = 0x10cf, .pci_subdevice = 0x1326, .config = ALC260_FUJITSU_S702X },
-    { .modelname = "acer", .config = ALC260_ACER },
-    { .pci_subvendor = 0x1025, .pci_subdevice = 0x008f, .config = ALC260_ACER },
+static const char *alc260_models[ALC260_MODEL_LAST] = {
+        [ALC260_BASIC]          = "basic",
+        [ALC260_HP]             = "hp",
+        [ALC260_HP_3013]        = "hp-3013",
+        [ALC260_FUJITSU_S702X]  = "fujitsu",
+        [ALC260_ACER]           = "acer",
 #ifdef CONFIG_SND_DEBUG
-    { .modelname = "test", .config = ALC260_TEST },
+        [ALC260_TEST]           = "test",
 #endif
-    { .modelname = "auto", .config = ALC260_AUTO },
-    {0}
+        [ALC260_AUTO]           = "auto",
+};
+
+static struct snd_pci_quirk alc260_cfg_tbl[] = {
+        SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
+        SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
+        SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
+        SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP),
+        SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_3013),
+        SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
+        SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
+        SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
+        SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
+        SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
+        SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
+        SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
+        SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
+        SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
+        {0}
 };
 
 static struct alc_config_preset alc260_presets[] = {
-    [ALC260_BASIC] = {
-        .mixers = { alc260_base_output_mixer,
-        alc260_input_mixer,
-        alc260_pc_beep_mixer,
-        alc260_capture_mixer },
-        .init_verbs = { alc260_init_verbs },
-        .num_dacs = ARRAY_SIZE(alc260_dac_nids),
-        .dac_nids = alc260_dac_nids,
-        .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
-        .adc_nids = alc260_adc_nids,
-        .num_channel_mode = ARRAY_SIZE(alc260_modes),
-        .channel_mode = alc260_modes,
-        .input_mux = &alc260_capture_source,
-    },
-    [ALC260_HP] = {
-        .mixers = { alc260_base_output_mixer,
-        alc260_input_mixer,
-        alc260_capture_alt_mixer },
-        .init_verbs = { alc260_init_verbs },
-        .num_dacs = ARRAY_SIZE(alc260_dac_nids),
-        .dac_nids = alc260_dac_nids,
-        .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids),
-        .adc_nids = alc260_hp_adc_nids,
-        .num_channel_mode = ARRAY_SIZE(alc260_modes),
-        .channel_mode = alc260_modes,
-        .input_mux = &alc260_capture_source,
-    },
-    [ALC260_HP_3013] = {
-        .mixers = { alc260_hp_3013_mixer,
-        alc260_input_mixer,
-        alc260_capture_alt_mixer },
-        .init_verbs = { alc260_hp_3013_init_verbs },
-        .num_dacs = ARRAY_SIZE(alc260_dac_nids),
-        .dac_nids = alc260_dac_nids,
-        .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids),
-        .adc_nids = alc260_hp_adc_nids,
-        .num_channel_mode = ARRAY_SIZE(alc260_modes),
-        .channel_mode = alc260_modes,
-        .input_mux = &alc260_capture_source,
-    },
-    [ALC260_FUJITSU_S702X] = {
-        .mixers = { alc260_fujitsu_mixer,
-        alc260_capture_mixer },
-        .init_verbs = { alc260_fujitsu_init_verbs },
-        .num_dacs = ARRAY_SIZE(alc260_dac_nids),
-        .dac_nids = alc260_dac_nids,
-        .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
-        .adc_nids = alc260_dual_adc_nids,
-        .num_channel_mode = ARRAY_SIZE(alc260_modes),
-        .channel_mode = alc260_modes,
-        .input_mux = &alc260_fujitsu_capture_source,
-    },
-    [ALC260_ACER] = {
-        .mixers = { alc260_acer_mixer,
-        alc260_capture_mixer },
-        .init_verbs = { alc260_acer_init_verbs },
-        .num_dacs = ARRAY_SIZE(alc260_dac_nids),
-        .dac_nids = alc260_dac_nids,
-        .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
-        .adc_nids = alc260_dual_adc_nids,
-        .num_channel_mode = ARRAY_SIZE(alc260_modes),
-        .channel_mode = alc260_modes,
-        .input_mux = &alc260_acer_capture_source,
-    },
+        [ALC260_BASIC] = {
+                .mixers = { alc260_base_output_mixer,
+                            alc260_input_mixer,
+                            alc260_pc_beep_mixer,
+                            alc260_capture_mixer },
+                .init_verbs = { alc260_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc260_dac_nids),
+                .dac_nids = alc260_dac_nids,
+                .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
+                .adc_nids = alc260_adc_nids,
+                .num_channel_mode = ARRAY_SIZE(alc260_modes),
+                .channel_mode = alc260_modes,
+                .input_mux = &alc260_capture_source,
+        },
+        [ALC260_HP] = {
+                .mixers = { alc260_base_output_mixer,
+                            alc260_input_mixer,
+                            alc260_capture_alt_mixer },
+                .init_verbs = { alc260_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc260_dac_nids),
+                .dac_nids = alc260_dac_nids,
+                .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids),
+                .adc_nids = alc260_hp_adc_nids,
+                .num_channel_mode = ARRAY_SIZE(alc260_modes),
+                .channel_mode = alc260_modes,
+                .input_mux = &alc260_capture_source,
+        },
+        [ALC260_HP_3013] = {
+                .mixers = { alc260_hp_3013_mixer,
+                            alc260_input_mixer,
+                            alc260_capture_alt_mixer },
+                .init_verbs = { alc260_hp_3013_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc260_dac_nids),
+                .dac_nids = alc260_dac_nids,
+                .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids),
+                .adc_nids = alc260_hp_adc_nids,
+                .num_channel_mode = ARRAY_SIZE(alc260_modes),
+                .channel_mode = alc260_modes,
+                .input_mux = &alc260_capture_source,
+        },
+        [ALC260_FUJITSU_S702X] = {
+                .mixers = { alc260_fujitsu_mixer,
+                            alc260_capture_mixer },
+                .init_verbs = { alc260_fujitsu_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc260_dac_nids),
+                .dac_nids = alc260_dac_nids,
+                .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
+                .adc_nids = alc260_dual_adc_nids,
+                .num_channel_mode = ARRAY_SIZE(alc260_modes),
+                .channel_mode = alc260_modes,
+                .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
+                .input_mux = alc260_fujitsu_capture_sources,
+        },
+        [ALC260_ACER] = {
+                .mixers = { alc260_acer_mixer,
+                            alc260_capture_mixer },
+                .init_verbs = { alc260_acer_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc260_dac_nids),
+                .dac_nids = alc260_dac_nids,
+                .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
+                .adc_nids = alc260_dual_adc_nids,
+                .num_channel_mode = ARRAY_SIZE(alc260_modes),
+                .channel_mode = alc260_modes,
+                .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
+                .input_mux = alc260_acer_capture_sources,
+        },
 #ifdef CONFIG_SND_DEBUG
-    [ALC260_TEST] = {
-        .mixers = { alc260_test_mixer,
-        alc260_capture_mixer },
-        .init_verbs = { alc260_test_init_verbs },
-        .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
-        .dac_nids = alc260_test_dac_nids,
-        .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
-        .adc_nids = alc260_test_adc_nids,
-        .num_channel_mode = ARRAY_SIZE(alc260_modes),
-        .channel_mode = alc260_modes,
-        .input_mux = &alc260_test_capture_source,
-    },
+        [ALC260_TEST] = {
+                .mixers = { alc260_test_mixer,
+                            alc260_capture_mixer },
+                .init_verbs = { alc260_test_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
+                .dac_nids = alc260_test_dac_nids,
+                .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
+                .adc_nids = alc260_test_adc_nids,
+                .num_channel_mode = ARRAY_SIZE(alc260_modes),
+                .channel_mode = alc260_modes,
+                .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
+                .input_mux = alc260_test_capture_sources,
+        },
 #endif
 };
@@ -3857 +4239 @@
 static int patch_alc260(struct hda_codec *codec)
 {
-    struct alc_spec *spec;
-    int err, board_config;
-
-    spec = kzalloc(sizeof(*spec), GFP_KERNEL);
-    if (spec == NULL)
-        return -ENOMEM;
-
-    codec->spec = spec;
-
-    board_config = snd_hda_check_board_config(codec, alc260_cfg_tbl);
-    if (board_config < 0 || board_config >= ALC260_MODEL_LAST) {
-        snd_printd(KERN_INFO "hda_codec: Unknown model for ALC260\n");
-        board_config = ALC260_AUTO;
-    }
-
-    if (board_config == ALC260_AUTO) {
-        /* automatic parse from the BIOS config */
-        err = alc260_parse_auto_config(codec);
-        if (err < 0) {
-            alc_free(codec);
-            return err;
-        } else if (! err) {
-            printk(KERN_INFO "hda_codec: Cannot set up configuration from BIOS.  Using base mode...\n");
-            board_config = ALC260_BASIC;
-        }
-    }
-
-    if (board_config != ALC260_AUTO)
-        setup_preset(spec, &alc260_presets[board_config]);
-
-    spec->stream_name_analog = "ALC260 Analog";
-    spec->stream_analog_playback = &alc260_pcm_analog_playback;
-    spec->stream_analog_capture = &alc260_pcm_analog_capture;
-
-    spec->stream_name_digital = "ALC260 Digital";
-    spec->stream_digital_playback = &alc260_pcm_digital_playback;
-    spec->stream_digital_capture = &alc260_pcm_digital_capture;
-
-    codec->patch_ops = alc_patch_ops;
-    if (board_config == ALC260_AUTO)
-        spec->init_hook = alc260_auto_init;
-
-    return 0;
+        struct alc_spec *spec;
+        int err, board_config;
+
+        spec = kzalloc(sizeof(*spec), GFP_KERNEL);
+        if (spec == NULL)
+                return -ENOMEM;
+
+        codec->spec = spec;
+
+        board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
+                                                  alc260_models,
+                                                  alc260_cfg_tbl);
+        if (board_config < 0) {
+                snd_printd(KERN_INFO "hda_codec: Unknown model for ALC260, "
+                           "trying auto-probe from BIOS...\n");
+                board_config = ALC260_AUTO;
+        }
+
+        if (board_config == ALC260_AUTO) {
+                /* automatic parse from the BIOS config */
+                err = alc260_parse_auto_config(codec);
+                if (err < 0) {
+                        alc_free(codec);
+                        return err;
+                } else if (! err) {
+                        printk(KERN_INFO
+                               "hda_codec: Cannot set up configuration "
+                               "from BIOS.  Using base mode...\n");
+                        board_config = ALC260_BASIC;
+                }
+        }
+
+        if (board_config != ALC260_AUTO)
+                setup_preset(spec, &alc260_presets[board_config]);
+
+        spec->stream_name_analog = "ALC260 Analog";
+        spec->stream_analog_playback = &alc260_pcm_analog_playback;
+        spec->stream_analog_capture = &alc260_pcm_analog_capture;
+
+        spec->stream_name_digital = "ALC260 Digital";
+        spec->stream_digital_playback = &alc260_pcm_digital_playback;
+        spec->stream_digital_capture = &alc260_pcm_digital_capture;
+
+        codec->patch_ops = alc_patch_ops;
+        if (board_config == ALC260_AUTO)
+                spec->init_hook = alc260_auto_init;
+
+        return 0;
 }
 
@@ -3918 +4305 @@
 
 static struct hda_channel_mode alc882_ch_modes[1] = {
-    { 8, NULL }
+        { 8, NULL }
 };
 
 static hda_nid_t alc882_dac_nids[4] = {
-    /* front, rear, clfe, rear_surr */
-    0x02, 0x03, 0x04, 0x05
+        /* front, rear, clfe, rear_surr */
+        0x02, 0x03, 0x04, 0x05
 };
 
@@ -3934 +4321 @@
 
 static struct hda_input_mux alc882_capture_source = {
-    .num_items = 4,
-    .items = {
-        { "Mic", 0x0 },
-        { "Front Mic", 0x1 },
-        { "Line", 0x2 },
-        { "CD", 0x4 },
-    },
-};
-
+        .num_items = 4,
+        .items = {
+                { "Mic", 0x0 },
+                { "Front Mic", 0x1 },
+                { "Line", 0x2 },
+                { "CD", 0x4 },
+        },
+};
 #define alc882_mux_enum_info alc_mux_enum_info
 #define alc882_mux_enum_get alc_mux_enum_get
@@ -3948 +4334 @@
 static int alc882_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
-    struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-    struct alc_spec *spec = codec->spec;
-    const struct hda_input_mux *imux = spec->input_mux;
-    unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
-    static hda_nid_t capture_mixers[3] = { 0x24, 0x23, 0x22 };
-    hda_nid_t nid = capture_mixers[adc_idx];
-    unsigned int *cur_val = &spec->cur_mux[adc_idx];
-    unsigned int i, idx;
-
-    idx = ucontrol->value.enumerated.item[0];
-    if (idx >= imux->num_items)
-        idx = imux->num_items - 1;
-    if (*cur_val == idx && ! codec->in_resume)
-        return 0;
-    for (i = 0; i < imux->num_items; i++) {
-        unsigned int v = (i == idx) ? 0x7000 : 0x7080;
-        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
-                            v | (imux->items[i].index << 8));
-    }
-    *cur_val = idx;
-    return 1;
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct alc_spec *spec = codec->spec;
+        const struct hda_input_mux *imux = spec->input_mux;
+        unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
+        static hda_nid_t capture_mixers[3] = { 0x24, 0x23, 0x22 };
+        hda_nid_t nid = capture_mixers[adc_idx];
+        unsigned int *cur_val = &spec->cur_mux[adc_idx];
+        unsigned int i, idx;
+
+        idx = ucontrol->value.enumerated.item[0];
+        if (idx >= imux->num_items)
+                idx = imux->num_items - 1;
+        if (*cur_val == idx && ! codec->in_resume)
+                return 0;
+        for (i = 0; i < imux->num_items; i++) {
+                unsigned int v = (i == idx) ? 0x7000 : 0x7080;
+                snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
+                                    v | (imux->items[i].index << 8));
+        }
+        *cur_val = idx;
+        return 1;
 }
 
@@ -3975 +4361 @@
  */
 static struct hda_verb alc882_sixstack_ch6_init[] = {
-    { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
-    { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
-    { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
-    { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
-    {0} /* end */
+        { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
+        { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
+        { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
+        { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
+        {0} /* end */
 };
 
@@ -3986 +4372 @@
  */
 static struct hda_verb alc882_sixstack_ch8_init[] = {
-    { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
-    { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
-    { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
-    { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
-    {0} /* end */
+        { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
+        { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
+        { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
+        { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
+        {0} /* end */
 };
 
 static struct hda_channel_mode alc882_sixstack_modes[2] = {
-    { 6, alc882_sixstack_ch6_init },
-    { 8, alc882_sixstack_ch8_init },
+        { 6, alc882_sixstack_ch6_init },
+        { 8, alc882_sixstack_ch8_init },
 };
 
@@ -4002 +4388 @@
  */
 static struct snd_kcontrol_new alc882_base_mixer[] = {
-    HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
-    HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
-    HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
-    HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
-    HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
-    HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
-    HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
-    HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
-    HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
-    HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
-    HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
-    HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
-    HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
-    HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
-    HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
-    HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
-    {0} /* end */
+        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
+        HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
+        HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
+        HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
+        HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
+        HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
+        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
+        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
+        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
+        {0} /* end */
 };
 
 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
-    {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "Channel Mode",
-        .info = alc_ch_mode_info,
-        .get = alc_ch_mode_get,
-        .put = alc_ch_mode_put,
-    },
-    {0} /* end */
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Channel Mode",
+                .info = alc_ch_mode_info,
+                .get = alc_ch_mode_get,
+                .put = alc_ch_mode_put,
+        },
+        {0} /* end */
 };
 
 static struct hda_verb alc882_init_verbs[] = {
-    /* Front mixer: unmute input/output amp left and right (volume = 0) */
-    {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
-    /* Rear mixer */
-    {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
-    /* CLFE mixer */
-    {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
-    /* Side mixer */
-    {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
-
-    /* Front Pin: output 0 (0x0c) */
-    {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
-    /* Rear Pin: output 1 (0x0d) */
-    {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
-    /* CLFE Pin: output 2 (0x0e) */
-    {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
-    /* Side Pin: output 3 (0x0f) */
-    {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
-    /* Mic (rear) pin: input vref at 80% */
-    {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
-    {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-    /* Front Mic pin: input vref at 80% */
-    {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
-    {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-    /* Line In pin: input */
-    {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
-    {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-    /* Line-2 In: Headphone output (output 0 - 0x0c) */
-    {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
-    {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
-    /* CD pin widget for input */
-    {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
-
-    /* FIXME: use matrix-type input source selection */
-    /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
-    /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
-    {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
-    {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
-    {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
-    /* Input mixer2 */
-    {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
-    {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
-    {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
-    /* Input mixer3 */
-    {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
-    {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
-    {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
-    /* ADC1: mute amp left and right */
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
-    /* ADC2: mute amp left and right */
-    {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
-    /* ADC3: mute amp left and right */
-    {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
-
-    {0}
-};
+        /* Front mixer: unmute input/output amp left and right (volume = 0) */
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        /* Rear mixer */
+        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        /* CLFE mixer */
+        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        /* Side mixer */
+        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+
+        /* Front Pin: output 0 (0x0c) */
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
+        /* Rear Pin: output 1 (0x0d) */
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
+        /* CLFE Pin: output 2 (0x0e) */
+        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
+        /* Side Pin: output 3 (0x0f) */
+        {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
+        /* Mic (rear) pin: input vref at 80% */
+        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        /* Front Mic pin: input vref at 80% */
+        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        /* Line In pin: input */
+        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        /* Line-2 In: Headphone output (output 0 - 0x0c) */
+        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
+        /* CD pin widget for input */
+        {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+
+        /* FIXME: use matrix-type input source selection */
+        /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
+        /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
+        /* Input mixer2 */
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
+        /* Input mixer3 */
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
+        /* ADC1: mute amp left and right */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
+        /* ADC2: mute amp left and right */
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
+        /* ADC3: mute amp left and right */
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
+
+        {0}
+};
+
+static struct hda_verb alc882_eapd_verbs[] = {
+        /* change to EAPD mode */
+        {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
+        {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
+        {0} 
+};
+
+
+/* Mac Pro test */
+static struct snd_kcontrol_new alc882_macpro_mixer[] = {
+        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
+        HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
+        HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
+        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x02, HDA_INPUT),
+        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x02, HDA_INPUT),
+        {0} /* end */
+};
+ 
+static struct hda_verb alc882_macpro_init_verbs[] = {
+        /* Front mixer: unmute input/output amp left and right (volume = 0) */
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        /* Front Pin: output 0 (0x0c) */
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
+        /* Front Mic pin: input vref at 80% */
+        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        /* Speaker:  output */
+        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
+        /* Headphone output (output 0 - 0x0c) */
+        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
+
+        /* FIXME: use matrix-type input source selection */
+        /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
+        /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
+        /* Input mixer2 */
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
+        /* Input mixer3 */
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
+        /* ADC1: mute amp left and right */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
+        /* ADC2: mute amp left and right */
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
+        /* ADC3: mute amp left and right */
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
+
+        {0}
+};
+static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
+{
+        unsigned int gpiostate, gpiomask, gpiodir;
+
+        gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
+                                       AC_VERB_GET_GPIO_DATA, 0);
+
+        if (!muted)
+                gpiostate |= (1 << pin);
+        else
+                gpiostate &= ~(1 << pin);
+
+        gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
+                                      AC_VERB_GET_GPIO_MASK, 0);
+        gpiomask |= (1 << pin);
+
+        gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
+                                     AC_VERB_GET_GPIO_DIRECTION, 0);
+        gpiodir |= (1 << pin);
+
+
+        snd_hda_codec_write(codec, codec->afg, 0,
+                            AC_VERB_SET_GPIO_MASK, gpiomask);
+        snd_hda_codec_write(codec, codec->afg, 0,
+                            AC_VERB_SET_GPIO_DIRECTION, gpiodir);
+
+        msleep(1);
+
+        snd_hda_codec_write(codec, codec->afg, 0,
+                            AC_VERB_SET_GPIO_DATA, gpiostate);
+}
+
 
 /*
@@ -4121 +4610 @@
  */
 static struct hda_verb alc882_auto_init_verbs[] = {
-    /*
-     * Unmute ADC0-2 and set the default input to mic-in
-     */
-    {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
-    {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
-    {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-
-    /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
-     * mixer widget
-     * Note: PASD motherboards uses the Line In 2 as the input for front panel
-     * mic (mic 2)
-     */
-    /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
-
-    /*
-     * Set up output mixers (0x0c - 0x0f)
-     */
-    /* set vol=0 to output mixers */
-    {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    /* set up input amps for analog loopback */
-    /* Amp Indices: DAC = 0, mixer = 1 */
-    {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-
-    /* FIXME: use matrix-type input source selection */
-    /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
-    /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
-    {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
-    {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
-    {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
-    {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
-    /* Input mixer2 */
-    {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
-    {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
-    {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
-    {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
-    /* Input mixer3 */
-    {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
-    {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
-    {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
-    {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
-
-    {0}
+        /*
+         * Unmute ADC0-2 and set the default input to mic-in
+         */
+        {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+
+        /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
+         * mixer widget
+         * Note: PASD motherboards uses the Line In 2 as the input for front panel
+         * mic (mic 2)
+         */
+        /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
+
+        /*
+         * Set up output mixers (0x0c - 0x0f)
+         */
+        /* set vol=0 to output mixers */
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        /* set up input amps for analog loopback */
+        /* Amp Indices: DAC = 0, mixer = 1 */
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+
+        /* FIXME: use matrix-type input source selection */
+        /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
+        /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
+        /* Input mixer2 */
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
+        /* Input mixer3 */
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
+
+        {0}
 };
 
 /* capture mixer elements */
 static struct snd_kcontrol_new alc882_capture_alt_mixer[] = {
-    HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
-    HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
-    {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        /* The multiple "Capture Source" controls confuse alsamixer
-         * So call somewhat different..
-         * FIXME: the controls appear in the "playback" view!
-         */
-        /* .name = "Capture Source", */
-        .name = "Input Source",
-        .count = 2,
-        .info = alc882_mux_enum_info,
-        .get = alc882_mux_enum_get,
-        .put = alc882_mux_enum_put,
-    },
-    {0} /* end */
+        HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                /* The multiple "Capture Source" controls confuse alsamixer
+                 * So call somewhat different..
+                 * FIXME: the controls appear in the "playback" view!
+                 */
+                /* .name = "Capture Source", */
+                .name = "Input Source",
+                .count = 2,
+                .info = alc882_mux_enum_info,
+                .get = alc882_mux_enum_get,
+                .put = alc882_mux_enum_put,
+        },
+        {0} /* end */
 };
 
 static struct snd_kcontrol_new alc882_capture_mixer[] = {
-    HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
-    HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x08, 0x0, HDA_INPUT),
-    HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x09, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x09, 0x0, HDA_INPUT),
-    {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        /* The multiple "Capture Source" controls confuse alsamixer
-         * So call somewhat different..
-         * FIXME: the controls appear in the "playback" view!
-         */
-        /* .name = "Capture Source", */
-        .name = "Input Source",
-        .count = 3,
-        .info = alc882_mux_enum_info,
-        .get = alc882_mux_enum_get,
-        .put = alc882_mux_enum_put,
-    },
-    {0} /* end */
+        HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x08, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x09, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x09, 0x0, HDA_INPUT),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                /* The multiple "Capture Source" controls confuse alsamixer
+                 * So call somewhat different..
+                 * FIXME: the controls appear in the "playback" view!
+                 */
+                /* .name = "Capture Source", */
+                .name = "Input Source",
+                .count = 3,
+                .info = alc882_mux_enum_info,
+                .get = alc882_mux_enum_get,
+                .put = alc882_mux_enum_put,
+        },
+        {0} /* end */
 };
 
@@ -4239 +4728 @@
  * configuration and preset
  */
-static struct hda_board_config alc882_cfg_tbl[] = {
-    { .modelname = "3stack-dig", .config = ALC882_3ST_DIG },
-    { .modelname = "6stack-dig", .config = ALC882_6ST_DIG },
-    { .pci_subvendor = 0x1462, .pci_subdevice = 0x6668, .config = ALC882_6ST_DIG }, /* MSI  */
-    { .pci_subvendor = 0x105b, .pci_subdevice = 0x6668, .config = ALC882_6ST_DIG }, /* Foxconn */
-    { .pci_subvendor = 0x1019, .pci_subdevice = 0x6668, .config = ALC882_6ST_DIG }, /* ECS */
-    { .modelname = "auto", .config = ALC882_AUTO },
-    {0}
+static const char *alc882_models[ALC882_MODEL_LAST] = {
+        [ALC882_3ST_DIG]        = "3stack-dig",
+        [ALC882_6ST_DIG]        = "6stack-dig",
+        [ALC882_ARIMA]          = "arima",
+        [ALC885_MACPRO]         = "macpro",
+        [ALC882_AUTO]           = "auto",
+};
+
+static struct snd_pci_quirk alc882_cfg_tbl[] = {
+        SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
+        SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
+        SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
+        SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA),
+        SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
+        {0}
 };
 
 static struct alc_config_preset alc882_presets[] = {
-    [ALC882_3ST_DIG] = {
-        .mixers = { alc882_base_mixer },
-        .init_verbs = { alc882_init_verbs },
-        .num_dacs = ARRAY_SIZE(alc882_dac_nids),
-        .dac_nids = alc882_dac_nids,
-        .dig_out_nid = ALC882_DIGOUT_NID,
-        .dig_in_nid = ALC882_DIGIN_NID,
-        .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
-        .channel_mode = alc882_ch_modes,
-        .input_mux = &alc882_capture_source,
-    },
-    [ALC882_6ST_DIG] = {
-        .mixers = { alc882_base_mixer, alc882_chmode_mixer },
-        .init_verbs = { alc882_init_verbs },
-        .num_dacs = ARRAY_SIZE(alc882_dac_nids),
-        .dac_nids = alc882_dac_nids,
-        .dig_out_nid = ALC882_DIGOUT_NID,
-        .dig_in_nid = ALC882_DIGIN_NID,
-        .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
-        .channel_mode = alc882_sixstack_modes,
-        .input_mux = &alc882_capture_source,
-    },
+        [ALC882_3ST_DIG] = {
+                .mixers = { alc882_base_mixer },
+                .init_verbs = { alc882_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc882_dac_nids),
+                .dac_nids = alc882_dac_nids,
+                .dig_out_nid = ALC882_DIGOUT_NID,
+                .dig_in_nid = ALC882_DIGIN_NID,
+                .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
+                .channel_mode = alc882_ch_modes,
+                .need_dac_fix = 1,
+                .input_mux = &alc882_capture_source,
+        },
+        [ALC882_6ST_DIG] = {
+                .mixers = { alc882_base_mixer, alc882_chmode_mixer },
+                .init_verbs = { alc882_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc882_dac_nids),
+                .dac_nids = alc882_dac_nids,
+                .dig_out_nid = ALC882_DIGOUT_NID,
+                .dig_in_nid = ALC882_DIGIN_NID,
+                .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
+                .channel_mode = alc882_sixstack_modes,
+                .input_mux = &alc882_capture_source,
+        },
+        [ALC882_ARIMA] = {
+                .mixers = { alc882_base_mixer, alc882_chmode_mixer },
+                .init_verbs = { alc882_init_verbs, alc882_eapd_verbs },
+                .num_dacs = ARRAY_SIZE(alc882_dac_nids),
+                .dac_nids = alc882_dac_nids,
+                .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
+                .channel_mode = alc882_sixstack_modes,
+                .input_mux = &alc882_capture_source,
+        },
+        [ALC885_MACPRO] = {
+                .mixers = { alc882_macpro_mixer },
+                .init_verbs = { alc882_macpro_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc882_dac_nids),
+                .dac_nids = alc882_dac_nids,
+                .dig_out_nid = ALC882_DIGOUT_NID,
+                .dig_in_nid = ALC882_DIGIN_NID,
+                .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
+                .channel_mode = alc882_ch_modes,
+                .input_mux = &alc882_capture_source,
+        },
 };
 
@@ -4279 +4796 @@
  */
 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
-                                              hda_nid_t nid, int pin_type,
-                                              int dac_idx)
-{
-    /* set as output */
-    struct alc_spec *spec = codec->spec;
-    int idx;
-
-    if (spec->multiout.dac_nids[dac_idx] == 0x25)
-        idx = 4;
-    else
-        idx = spec->multiout.dac_nids[dac_idx] - 2;
-
-    snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
-    snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
-    snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
+                                              hda_nid_t nid, int pin_type,
+                                              int dac_idx)
+{
+        /* set as output */
+        struct alc_spec *spec = codec->spec;
+        int idx; 
+        
+        if (spec->multiout.dac_nids[dac_idx] == 0x25)
+                idx = 4;
+        else
+                idx = spec->multiout.dac_nids[dac_idx] - 2;
+
+        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
+        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
+        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
 
 }
@@ -4299 +4816 @@
 static void alc882_auto_init_multi_out(struct hda_codec *codec)
 {
-    struct alc_spec *spec = codec->spec;
-    int i;
-
-    for (i = 0; i <= HDA_SIDE; i++) {
-        hda_nid_t nid = spec->autocfg.line_out_pins[i];
-        if (nid)
-            alc882_auto_set_output_and_unmute(codec, nid, PIN_OUT, i);
-    }
+        struct alc_spec *spec = codec->spec;
+        int i;
+
+        for (i = 0; i <= HDA_SIDE; i++) {
+                hda_nid_t nid = spec->autocfg.line_out_pins[i]; 
+                if (nid)
+                        alc882_auto_set_output_and_unmute(codec, nid, PIN_OUT, i);
+        }
 }
 
 static void alc882_auto_init_hp_out(struct hda_codec *codec)
 {
-    struct alc_spec *spec = codec->spec;
-    hda_nid_t pin;
-
-    pin = spec->autocfg.hp_pin;
-    if (pin) /* connect to front */
-        alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0); /* use dac 0 */
+        struct alc_spec *spec = codec->spec;
+        hda_nid_t pin;
+
+        pin = spec->autocfg.hp_pins[0];
+        if (pin) /* connect to front */
+                alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0); /* use dac 0 */
 }
 
@@ -4324 +4841 @@
 static void alc882_auto_init_analog_input(struct hda_codec *codec)
 {
-    struct alc_spec *spec = codec->spec;
-    int i;
-
-    for (i = 0; i < AUTO_PIN_LAST; i++) {
-        hda_nid_t nid = spec->autocfg.input_pins[i];
-        if (alc882_is_input_pin(nid)) {
-            snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
-                                i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN);
-            if (nid != ALC882_PIN_CD_NID)
-                snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
-                                    AMP_OUT_MUTE);
-        }
-    }
+        struct alc_spec *spec = codec->spec;
+        int i;
+
+        for (i = 0; i < AUTO_PIN_LAST; i++) {
+                hda_nid_t nid = spec->autocfg.input_pins[i];
+                if (alc882_is_input_pin(nid)) {
+                        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
+                                            i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN);
+                        if (nid != ALC882_PIN_CD_NID)
+                                snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
+                                                    AMP_OUT_MUTE);
+                }
+        }
 }
 
@@ -4342 +4859 @@
 static int alc882_parse_auto_config(struct hda_codec *codec)
 {
-    struct alc_spec *spec = codec->spec;
-    int err = alc880_parse_auto_config(codec);
-
-    if (err < 0)
-        return err;
-    else if (err > 0)
-        /* hack - override the init verbs */
-        spec->init_verbs[0] = alc882_auto_init_verbs;
-    return err;
+        struct alc_spec *spec = codec->spec;
+        int err = alc880_parse_auto_config(codec);
+
+        if (err < 0)
+                return err;
+        else if (err > 0)
+                /* hack - override the init verbs */
+                spec->init_verbs[0] = alc882_auto_init_verbs;
+        return err;
 }
 
@@ -4356 +4873 @@
 static void alc882_auto_init(struct hda_codec *codec)
 {
-    alc882_auto_init_multi_out(codec);
-    alc882_auto_init_hp_out(codec);
-    alc882_auto_init_analog_input(codec);
+        alc882_auto_init_multi_out(codec);
+        alc882_auto_init_hp_out(codec);
+        alc882_auto_init_analog_input(codec);
 }
 
 static int patch_alc882(struct hda_codec *codec)
 {
-    struct alc_spec *spec;
-    int err, board_config;
-
-    spec = kzalloc(sizeof(*spec), GFP_KERNEL);
-    if (spec == NULL)
-        return -ENOMEM;
-
-    codec->spec = spec;
-
-    board_config = snd_hda_check_board_config(codec, alc882_cfg_tbl);
-
-    if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
-        printk(KERN_INFO "hda_codec: Unknown model for ALC882, trying auto-probe from BIOS...\n");
-        board_config = ALC882_AUTO;
-    }
-
-    if (board_config == ALC882_AUTO) {
-        /* automatic parse from the BIOS config */
-        err = alc882_parse_auto_config(codec);
-        if (err < 0) {
-            alc_free(codec);
-            return err;
-        } else if (! err) {
-            printk(KERN_INFO "hda_codec: Cannot set up configuration from BIOS.  Using base mode...\n");
-            board_config = ALC882_3ST_DIG;
-        }
-    }
-
-    if (board_config != ALC882_AUTO)
-        setup_preset(spec, &alc882_presets[board_config]);
-
-    spec->stream_name_analog = "ALC882 Analog";
-    spec->stream_analog_playback = &alc882_pcm_analog_playback;
-    spec->stream_analog_capture = &alc882_pcm_analog_capture;
-
-    spec->stream_name_digital = "ALC882 Digital";
-    spec->stream_digital_playback = &alc882_pcm_digital_playback;
-    spec->stream_digital_capture = &alc882_pcm_digital_capture;
-
-    if (! spec->adc_nids && spec->input_mux) {
-        /* check whether NID 0x07 is valid */
-        unsigned int wcap = get_wcaps(codec, 0x07);
-        wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; /* get type */
-        if (wcap != AC_WID_AUD_IN) {
-            spec->adc_nids = alc882_adc_nids_alt;
-            spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids_alt);
-            spec->mixers[spec->num_mixers] = alc882_capture_alt_mixer;
-            spec->num_mixers++;
-        } else {
-            spec->adc_nids = alc882_adc_nids;
-            spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids);
-            spec->mixers[spec->num_mixers] = alc882_capture_mixer;
-            spec->num_mixers++;
-        }
-    }
-
-    codec->patch_ops = alc_patch_ops;
-    if (board_config == ALC882_AUTO)
-        spec->init_hook = alc882_auto_init;
-
-    return 0;
+        struct alc_spec *spec;
+        int err, board_config;
+
+        spec = kzalloc(sizeof(*spec), GFP_KERNEL);
+        if (spec == NULL)
+                return -ENOMEM;
+
+        codec->spec = spec;
+
+        board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
+                                                  alc882_models,
+                                                  alc882_cfg_tbl);
+
+        if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
+                printk(KERN_INFO "hda_codec: Unknown model for ALC882, "
+                       "trying auto-probe from BIOS...\n");
+                board_config = ALC882_AUTO;
+        }
+
+        if (board_config == ALC882_AUTO) {
+                /* automatic parse from the BIOS config */
+                err = alc882_parse_auto_config(codec);
+                if (err < 0) {
+                        alc_free(codec);
+                        return err;
+                } else if (! err) {
+                        printk(KERN_INFO
+                               "hda_codec: Cannot set up configuration "
+                               "from BIOS.  Using base mode...\n");
+                        board_config = ALC882_3ST_DIG;
+                }
+        }
+
+        if (board_config != ALC882_AUTO)
+                setup_preset(spec, &alc882_presets[board_config]);
+
+        if (board_config == ALC885_MACPRO) {
+                alc882_gpio_mute(codec, 0, 0);
+                alc882_gpio_mute(codec, 1, 0);
+        }
+
+        spec->stream_name_analog = "ALC882 Analog";
+        spec->stream_analog_playback = &alc882_pcm_analog_playback;
+        spec->stream_analog_capture = &alc882_pcm_analog_capture;
+
+        spec->stream_name_digital = "ALC882 Digital";
+        spec->stream_digital_playback = &alc882_pcm_digital_playback;
+        spec->stream_digital_capture = &alc882_pcm_digital_capture;
+
+        if (! spec->adc_nids && spec->input_mux) {
+                /* check whether NID 0x07 is valid */
+                unsigned int wcap = get_wcaps(codec, 0x07);
+                wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; /* get type */
+                if (wcap != AC_WID_AUD_IN) {
+                        spec->adc_nids = alc882_adc_nids_alt;
+                        spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids_alt);
+                        spec->mixers[spec->num_mixers] = alc882_capture_alt_mixer;
+                        spec->num_mixers++;
+                } else {
+                        spec->adc_nids = alc882_adc_nids;
+                        spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids);
+                        spec->mixers[spec->num_mixers] = alc882_capture_mixer;
+                        spec->num_mixers++;
+                }
+        }
+
+        codec->patch_ops = alc_patch_ops;
+        if (board_config == ALC882_AUTO)
+                spec->init_hook = alc882_auto_init;
+
+        return 0;
 }
 
@@ -4441 +4968 @@
 
 static hda_nid_t alc883_dac_nids[4] = {
-    /* front, rear, clfe, rear_surr */
-    0x02, 0x04, 0x03, 0x05
+        /* front, rear, clfe, rear_surr */
+        0x02, 0x04, 0x03, 0x05
 };
 
 static hda_nid_t alc883_adc_nids[2] = {
-    /* ADC1-2 */
-    0x08, 0x09,
+        /* ADC1-2 */
+        0x08, 0x09,
 };
 /* input MUX */
@@ -4453 +4980 @@
 
 static struct hda_input_mux alc883_capture_source = {
-    .num_items = 4,
-    .items = {
-        { "Mic", 0x0 },
-        { "Front Mic", 0x1 },
-        { "Line", 0x2 },
-        { "CD", 0x4 },
-    },
+        .num_items = 4,
+        .items = {
+                { "Mic", 0x0 },
+                { "Front Mic", 0x1 },
+                { "Line", 0x2 },
+                { "CD", 0x4 },
+        },
 };
 #define alc883_mux_enum_info alc_mux_enum_info
@@ -4465 +4992 @@
 
 static int alc883_mux_enum_put(struct snd_kcontrol *kcontrol,
-                               struct snd_ctl_elem_value *ucontrol)
-{
-    struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-    struct alc_spec *spec = codec->spec;
-    const struct hda_input_mux *imux = spec->input_mux;
-    unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
-    static hda_nid_t capture_mixers[3] = { 0x24, 0x23, 0x22 };
-    hda_nid_t nid = capture_mixers[adc_idx];
-    unsigned int *cur_val = &spec->cur_mux[adc_idx];
-    unsigned int i, idx;
-
-    idx = ucontrol->value.enumerated.item[0];
-    if (idx >= imux->num_items)
-        idx = imux->num_items - 1;
-    if (*cur_val == idx && ! codec->in_resume)
-        return 0;
-    for (i = 0; i < imux->num_items; i++) {
-        unsigned int v = (i == idx) ? 0x7000 : 0x7080;
-        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
-                            v | (imux->items[i].index << 8));
-    }
-    *cur_val = idx;
-    return 1;
+                               struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct alc_spec *spec = codec->spec;
+        const struct hda_input_mux *imux = spec->input_mux;
+        unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
+        static hda_nid_t capture_mixers[3] = { 0x24, 0x23, 0x22 };
+        hda_nid_t nid = capture_mixers[adc_idx];
+        unsigned int *cur_val = &spec->cur_mux[adc_idx];
+        unsigned int i, idx;
+
+        idx = ucontrol->value.enumerated.item[0];
+        if (idx >= imux->num_items)
+                idx = imux->num_items - 1;
+        if (*cur_val == idx && ! codec->in_resume)
+                return 0;
+        for (i = 0; i < imux->num_items; i++) {
+                unsigned int v = (i == idx) ? 0x7000 : 0x7080;
+                snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
+                                    v | (imux->items[i].index << 8));
+        }
+        *cur_val = idx;
+        return 1;
 }
 /*
@@ -4493 +5020 @@
  */
 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
-    { 2, NULL }
+        { 2, NULL }
 };
 
@@ -4500 +5027 @@
  */
 static struct hda_verb alc883_3ST_ch2_init[] = {
-    { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
-    { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
-    { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
-    { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
-    {0} /* end */
+        { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
+        { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
+        { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
+        { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
+        {0} /* end */
 };
 
@@ -4511 +5038 @@
  */
 static struct hda_verb alc883_3ST_ch6_init[] = {
-    { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
-    { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
-    { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
-    { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
-    { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
-    { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
-    {0} /* end */
+        { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
+        { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
+        { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
+        { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
+        { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
+        { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
+        {0} /* end */
 };
 
 static struct hda_channel_mode alc883_3ST_6ch_modes[2] = {
-    { 2, alc883_3ST_ch2_init },
-    { 6, alc883_3ST_ch6_init },
+        { 2, alc883_3ST_ch2_init },
+        { 6, alc883_3ST_ch6_init },
 };
 
@@ -4529 +5056 @@
  */
 static struct hda_verb alc883_sixstack_ch6_init[] = {
-    { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
-    { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
-    { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
-    { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
-    {0} /* end */
+        { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
+        { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
+        { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
+        { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
+        {0} /* end */
 };
 
@@ -4540 +5067 @@
  */
 static struct hda_verb alc883_sixstack_ch8_init[] = {
-    { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
-    { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
-    { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
-    { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
-    {0} /* end */
+        { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
+        { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
+        { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
+        { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
+        {0} /* end */
 };
 
 static struct hda_channel_mode alc883_sixstack_modes[2] = {
-    { 6, alc883_sixstack_ch6_init },
-    { 8, alc883_sixstack_ch8_init },
+        { 6, alc883_sixstack_ch6_init },
+        { 8, alc883_sixstack_ch8_init },
+};
+
+static struct hda_verb alc883_medion_eapd_verbs[] = {
+        /* eanable EAPD on medion laptop */
+        {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
+        {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
+        {0}
 };
 
@@ -4557 +5091 @@
 
 static struct snd_kcontrol_new alc883_base_mixer[] = {
-    HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
-    HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
-    HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
-    HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
-    HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
-    HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
-    HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
-    HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
-    HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
-    HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
-    HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
-    HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
-    HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
-    HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
-    HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
-    HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
-    HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
-    HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
-    {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        /* .name = "Capture Source", */
-        .name = "Input Source",
-        .count = 2,
-        .info = alc883_mux_enum_info,
-        .get = alc883_mux_enum_get,
-        .put = alc883_mux_enum_put,
-    },
-    {0} /* end */
+        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
+        HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
+        HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
+        HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
+        HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
+        HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
+        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
+        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
+        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
+        HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                /* .name = "Capture Source", */
+                .name = "Input Source",
+                .count = 2,
+                .info = alc883_mux_enum_info,
+                .get = alc883_mux_enum_get,
+                .put = alc883_mux_enum_put,
+        },
+        {0} /* end */
 };
 
 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
-    HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
-    HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
-    HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
-    HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
-    HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
-    HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
-    HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
-    HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
-    HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
-    HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
-    HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
-    HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
-    HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
-    {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        /* .name = "Capture Source", */
-        .name = "Input Source",
-        .count = 2,
-        .info = alc883_mux_enum_info,
-        .get = alc883_mux_enum_get,
-        .put = alc883_mux_enum_put,
-    },
-    {0} /* end */
+        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
+        HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
+        HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
+        HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
+        HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
+        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
+        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
+        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
+        HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                /* .name = "Capture Source", */
+                .name = "Input Source",
+                .count = 2,
+                .info = alc883_mux_enum_info,
+                .get = alc883_mux_enum_get,
+                .put = alc883_mux_enum_put,
+        },
+        {0} /* end */
 };
 
 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
-    HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
-    HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
-    HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
-    HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
-    HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
-    HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
-    HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
-    HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
-    HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
-    HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
-    HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
-    HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
-    HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
-    HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
-    HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
-    HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
-    HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
-    HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
-    {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        /* .name = "Capture Source", */
-        .name = "Input Source",
-        .count = 2,
-        .info = alc883_mux_enum_info,
-        .get = alc883_mux_enum_get,
-        .put = alc883_mux_enum_put,
-    },
-    {0} /* end */
-};
+        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
+        HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
+        HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
+        HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
+        HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
+        HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
+        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
+        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
+        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
+        HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                /* .name = "Capture Source", */
+                .name = "Input Source",
+                .count = 2,
+                .info = alc883_mux_enum_info,
+                .get = alc883_mux_enum_get,
+                .put = alc883_mux_enum_put,
+        },
+        {0} /* end */
+};
+
+static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
+        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Surround Playback Switch", 0x15, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x16, 1, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
+        HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
+        HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
+        HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
+        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
+        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
+        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
+        HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
+
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                /* .name = "Capture Source", */
+                .name = "Input Source",
+                .count = 1,
+                .info = alc883_mux_enum_info,
+                .get = alc883_mux_enum_get,
+                .put = alc883_mux_enum_put,
+        },
+        {0} /* end */
+};
+
+static struct snd_kcontrol_new alc883_tagra_mixer[] = {
+        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
+        HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
+        HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
+        HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
+        HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                /* .name = "Capture Source", */
+                .name = "Input Source",
+                .count = 2,
+                .info = alc883_mux_enum_info,
+                .get = alc883_mux_enum_get,
+                .put = alc883_mux_enum_put,
+        },
+        {0} /* end */
+};      
+
+static struct snd_kcontrol_new alc883_tagra_2ch_mixer[] = {
+        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
+        HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                /* .name = "Capture Source", */
+                .name = "Input Source",
+                .count = 2,
+                .info = alc883_mux_enum_info,
+                .get = alc883_mux_enum_get,
+                .put = alc883_mux_enum_put,
+        },
+        {0} /* end */
+};      
 
 static struct snd_kcontrol_new alc883_chmode_mixer[] = {
-    {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "Channel Mode",
-        .info = alc_ch_mode_info,
-        .get = alc_ch_mode_get,
-        .put = alc_ch_mode_put,
-    },
-    {0} /* end */
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Channel Mode",
+                .info = alc_ch_mode_info,
+                .get = alc_ch_mode_get,
+                .put = alc_ch_mode_put,
+        },
+        {0} /* end */
 };
 
 static struct hda_verb alc883_init_verbs[] = {
-    /* ADC1: mute amp left and right */
-    {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
-    /* ADC2: mute amp left and right */
-    {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
-    /* Front mixer: unmute input/output amp left and right (volume = 0) */
-    {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
-    /* Rear mixer */
-    {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
-    /* CLFE mixer */
-    {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
-    /* Side mixer */
-    {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
-
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
-
-    /* Front Pin: output 0 (0x0c) */
-    {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
-    /* Rear Pin: output 1 (0x0d) */
-    {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
-    /* CLFE Pin: output 2 (0x0e) */
-    {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
-    /* Side Pin: output 3 (0x0f) */
-    {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-    {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
-    /* Mic (rear) pin: input vref at 80% */
-    {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
-    {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-    /* Front Mic pin: input vref at 80% */
-    {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
-    {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-    /* Line In pin: input */
-    {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
-    {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-    /* Line-2 In: Headphone output (output 0 - 0x0c) */
-    {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
-    {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
-    /* CD pin widget for input */
-    {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
-
-    /* FIXME: use matrix-type input source selection */
-    /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
-    /* Input mixer2 */
-    {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
-    {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
-    /* Input mixer3 */
-    {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
-    {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
-    {0}
-};
+        /* ADC1: mute amp left and right */
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
+        /* ADC2: mute amp left and right */
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
+        /* Front mixer: unmute input/output amp left and right (volume = 0) */
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        /* Rear mixer */
+        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        /* CLFE mixer */
+        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        /* Side mixer */
+        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
+
+        /* Front Pin: output 0 (0x0c) */
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
+        /* Rear Pin: output 1 (0x0d) */
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
+        /* CLFE Pin: output 2 (0x0e) */
+        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
+        /* Side Pin: output 3 (0x0f) */
+        {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
+        /* Mic (rear) pin: input vref at 80% */
+        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        /* Front Mic pin: input vref at 80% */
+        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        /* Line In pin: input */
+        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        /* Line-2 In: Headphone output (output 0 - 0x0c) */
+        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
+        /* CD pin widget for input */
+        {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+
+        /* FIXME: use matrix-type input source selection */
+        /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
+        /* Input mixer2 */
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
+        /* Input mixer3 */
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
+        {0}
+};
+
+static struct hda_verb alc883_tagra_verbs[] = {
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        
+        {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
+        {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
+        {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
+
+        {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
+        {0x01, AC_VERB_SET_GPIO_MASK, 0x03}, 
+        {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03}, 
+        {0x01, AC_VERB_SET_GPIO_DATA, 0x03}, 
+
+        {0} /* end */
+};
+
+/* toggle speaker-output according to the hp-jack state */
+static void alc883_tagra_automute(struct hda_codec *codec)
+{
+        unsigned int present;
+
+        present = snd_hda_codec_read(codec, 0x14, 0,
+                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
+        snd_hda_codec_amp_update(codec, 0x1b, 0, HDA_OUTPUT, 0,
+                                 0x80, present ? 0x80 : 0);
+        snd_hda_codec_amp_update(codec, 0x1b, 1, HDA_OUTPUT, 0,
+                                 0x80, present ? 0x80 : 0);
+        snd_hda_codec_write(codec, 1, 0, AC_VERB_SET_GPIO_DATA, present ? 1 : 3);
+}
+
+static void alc883_tagra_unsol_event(struct hda_codec *codec, unsigned int res)
+{
+        if ((res >> 26) == ALC880_HP_EVENT)
+                alc883_tagra_automute(codec);
+}
 
 /*
@@ -4752 +5416 @@
  */
 static struct hda_verb alc883_auto_init_verbs[] = {
-    /*
-     * Unmute ADC0-2 and set the default input to mic-in
-     */
-    {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
-    {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
-    {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-
-    /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
-     * mixer widget
-     * Note: PASD motherboards uses the Line In 2 as the input for front panel
-     * mic (mic 2)
-     */
-    /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
-
-    /*
-     * Set up output mixers (0x0c - 0x0f)
-     */
-    /* set vol=0 to output mixers */
-    {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    /* set up input amps for analog loopback */
-    /* Amp Indices: DAC = 0, mixer = 1 */
-    {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-
-    /* FIXME: use matrix-type input source selection */
-    /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
-    /* Input mixer1 */
-    {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
-    //{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
-    {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
-    /* Input mixer2 */
-    {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
-    //{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
-    {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
-
-    {0}
+        /*
+         * Unmute ADC0-2 and set the default input to mic-in
+         */
+        {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+
+        /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
+         * mixer widget
+         * Note: PASD motherboards uses the Line In 2 as the input for front panel
+         * mic (mic 2)
+         */
+        /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
+
+        /*
+         * Set up output mixers (0x0c - 0x0f)
+         */
+        /* set vol=0 to output mixers */
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        /* set up input amps for analog loopback */
+        /* Amp Indices: DAC = 0, mixer = 1 */
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+
+        /* FIXME: use matrix-type input source selection */
+        /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
+        /* Input mixer1 */
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
+        //{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
+        /* Input mixer2 */
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
+        //{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
+
+        {0}
 };
 
 /* capture mixer elements */
 static struct snd_kcontrol_new alc883_capture_mixer[] = {
-    HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
-    HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
-    {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        /* The multiple "Capture Source" controls confuse alsamixer
-         * So call somewhat different..
-         * FIXME: the controls appear in the "playback" view!
-         */
-        /* .name = "Capture Source", */
-        .name = "Input Source",
-        .count = 2,
-        .info = alc882_mux_enum_info,
-        .get = alc882_mux_enum_get,
-        .put = alc882_mux_enum_put,
-    },
-    {0} /* end */
+        HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                /* The multiple "Capture Source" controls confuse alsamixer
+                 * So call somewhat different..
+                 * FIXME: the controls appear in the "playback" view!
+                 */
+                /* .name = "Capture Source", */
+                .name = "Input Source",
+                .count = 2,
+                .info = alc882_mux_enum_info,
+                .get = alc882_mux_enum_get,
+                .put = alc882_mux_enum_put,
+        },
+        {0} /* end */
 };
 
@@ -4842 +5506 @@
  * configuration and preset
  */
-static struct hda_board_config alc883_cfg_tbl[] = {
-    { .modelname = "3stack-dig", .config = ALC883_3ST_2ch_DIG },
-    { .modelname = "6stack-dig", .config = ALC883_6ST_DIG },
-    { .modelname = "6stack-dig-demo", .config = ALC888_DEMO_BOARD },
-    { .pci_subvendor = 0x1462, .pci_subdevice = 0x6668,
-    .config = ALC883_6ST_DIG }, /* MSI  */
-    { .pci_subvendor = 0x105b, .pci_subdevice = 0x6668,
-    .config = ALC883_6ST_DIG }, /* Foxconn */
-    { .pci_subvendor = 0x1019, .pci_subdevice = 0x6668,
-    .config = ALC883_3ST_6ch_DIG }, /* ECS to Intel*/
-    { .pci_subvendor = 0x108e, .pci_subdevice = 0x534d,
-    .config = ALC883_3ST_6ch },
-    { .modelname = "auto", .config = ALC883_AUTO },
-    {0}
+static const char *alc883_models[ALC883_MODEL_LAST] = {
+        [ALC883_3ST_2ch_DIG]    = "3stack-dig",
+        [ALC883_3ST_6ch_DIG]    = "3stack-6ch-dig",
+        [ALC883_3ST_6ch]        = "3stack-6ch",
+        [ALC883_6ST_DIG]        = "6stack-dig",
+        [ALC883_TARGA_DIG]      = "targa-dig",
+        [ALC883_TARGA_2ch_DIG]  = "targa-2ch-dig",
+        [ALC888_DEMO_BOARD]     = "6stack-dig-demo",
+        [ALC883_ACER]           = "acer",
+        [ALC883_MEDION]         = "medion",
+        [ALC883_LAPTOP_EAPD]    = "laptop-eapd",
+        [ALC883_AUTO]           = "auto",
+};
+
+static struct snd_pci_quirk alc883_cfg_tbl[] = {
+        SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC883_3ST_6ch_DIG),
+        SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
+        SND_PCI_QUIRK(0x1558, 0, "Clevo laptop", ALC883_LAPTOP_EAPD),
+        SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC883_6ST_DIG),
+        SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
+        SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
+        SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
+        SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
+        SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
+        SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
+        SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
+        SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
+        SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
+        SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
+        SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
+        SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
+        SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
+        SND_PCI_QUIRK(0x1025, 0, "Acer laptop", ALC883_ACER),
+        SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
+        SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
+        SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC883_3ST_6ch),
+        {0}
 };
 
 static struct alc_config_preset alc883_presets[] = {
-    [ALC883_3ST_2ch_DIG] = {
-        .mixers = { alc883_3ST_2ch_mixer },
-        .init_verbs = { alc883_init_verbs },
-        .num_dacs = ARRAY_SIZE(alc883_dac_nids),
-        .dac_nids = alc883_dac_nids,
-        .dig_out_nid = ALC883_DIGOUT_NID,
-        .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
-        .adc_nids = alc883_adc_nids,
-        .dig_in_nid = ALC883_DIGIN_NID,
-        .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
-        .channel_mode = alc883_3ST_2ch_modes,
-        .input_mux = &alc883_capture_source,
-    },
-    [ALC883_3ST_6ch_DIG] = {
-        .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
-        .init_verbs = { alc883_init_verbs },
-        .num_dacs = ARRAY_SIZE(alc883_dac_nids),
-        .dac_nids = alc883_dac_nids,
-        .dig_out_nid = ALC883_DIGOUT_NID,
-        .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
-        .adc_nids = alc883_adc_nids,
-        .dig_in_nid = ALC883_DIGIN_NID,
-        .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
-        .channel_mode = alc883_3ST_6ch_modes,
-        .input_mux = &alc883_capture_source,
-    },
-    [ALC883_3ST_6ch] = {
-        .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
-        .init_verbs = { alc883_init_verbs },
-        .num_dacs = ARRAY_SIZE(alc883_dac_nids),
-        .dac_nids = alc883_dac_nids,
-        .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
-        .adc_nids = alc883_adc_nids,
-        .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
-        .channel_mode = alc883_3ST_6ch_modes,
-        .input_mux = &alc883_capture_source,
-    },
-    [ALC883_6ST_DIG] = {
-        .mixers = { alc883_base_mixer, alc883_chmode_mixer },
-        .init_verbs = { alc883_init_verbs },
-        .num_dacs = ARRAY_SIZE(alc883_dac_nids),
-        .dac_nids = alc883_dac_nids,
-        .dig_out_nid = ALC883_DIGOUT_NID,
-        .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
-        .adc_nids = alc883_adc_nids,
-        .dig_in_nid = ALC883_DIGIN_NID,
-        .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
-        .channel_mode = alc883_sixstack_modes,
-        .input_mux = &alc883_capture_source,
-    },
-    [ALC888_DEMO_BOARD] = {
-        .mixers = { alc883_base_mixer, alc883_chmode_mixer },
-        .init_verbs = { alc883_init_verbs },
-        .num_dacs = ARRAY_SIZE(alc883_dac_nids),
-        .dac_nids = alc883_dac_nids,
-        .dig_out_nid = ALC883_DIGOUT_NID,
-        .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
-        .adc_nids = alc883_adc_nids,
-        .dig_in_nid = ALC883_DIGIN_NID,
-        .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
-        .channel_mode = alc883_sixstack_modes,
-        .input_mux = &alc883_capture_source,
-    },
+        [ALC883_3ST_2ch_DIG] = {
+                .mixers = { alc883_3ST_2ch_mixer },
+                .init_verbs = { alc883_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
+                .dac_nids = alc883_dac_nids,
+                .dig_out_nid = ALC883_DIGOUT_NID,
+                .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
+                .adc_nids = alc883_adc_nids,
+                .dig_in_nid = ALC883_DIGIN_NID,
+                .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
+                .channel_mode = alc883_3ST_2ch_modes,
+                .input_mux = &alc883_capture_source,
+        },
+        [ALC883_3ST_6ch_DIG] = {
+                .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
+                .init_verbs = { alc883_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
+                .dac_nids = alc883_dac_nids,
+                .dig_out_nid = ALC883_DIGOUT_NID,
+                .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
+                .adc_nids = alc883_adc_nids,
+                .dig_in_nid = ALC883_DIGIN_NID,
+                .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
+                .channel_mode = alc883_3ST_6ch_modes,
+                .need_dac_fix = 1,
+                .input_mux = &alc883_capture_source,
+        },      
+        [ALC883_3ST_6ch] = {
+                .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
+                .init_verbs = { alc883_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
+                .dac_nids = alc883_dac_nids,
+                .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
+                .adc_nids = alc883_adc_nids,
+                .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
+                .channel_mode = alc883_3ST_6ch_modes,
+                .need_dac_fix = 1,
+                .input_mux = &alc883_capture_source,
+        },      
+        [ALC883_6ST_DIG] = {
+                .mixers = { alc883_base_mixer, alc883_chmode_mixer },
+                .init_verbs = { alc883_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
+                .dac_nids = alc883_dac_nids,
+                .dig_out_nid = ALC883_DIGOUT_NID,
+                .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
+                .adc_nids = alc883_adc_nids,
+                .dig_in_nid = ALC883_DIGIN_NID,
+                .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
+                .channel_mode = alc883_sixstack_modes,
+                .input_mux = &alc883_capture_source,
+        },
+        [ALC883_TARGA_DIG] = {
+                .mixers = { alc883_tagra_mixer, alc883_chmode_mixer },
+                .init_verbs = { alc883_init_verbs, alc883_tagra_verbs},
+                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
+                .dac_nids = alc883_dac_nids,
+                .dig_out_nid = ALC883_DIGOUT_NID,
+                .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
+                .adc_nids = alc883_adc_nids,
+                .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
+                .channel_mode = alc883_3ST_6ch_modes,
+                .need_dac_fix = 1,
+                .input_mux = &alc883_capture_source,
+                .unsol_event = alc883_tagra_unsol_event,
+                .init_hook = alc883_tagra_automute,
+        },
+        [ALC883_TARGA_2ch_DIG] = {
+                .mixers = { alc883_tagra_2ch_mixer},
+                .init_verbs = { alc883_init_verbs, alc883_tagra_verbs},
+                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
+                .dac_nids = alc883_dac_nids,
+                .dig_out_nid = ALC883_DIGOUT_NID,
+                .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
+                .adc_nids = alc883_adc_nids,
+                .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
+                .channel_mode = alc883_3ST_2ch_modes,
+                .input_mux = &alc883_capture_source,
+                .unsol_event = alc883_tagra_unsol_event,
+                .init_hook = alc883_tagra_automute,
+        },
+        [ALC888_DEMO_BOARD] = {
+                .mixers = { alc883_base_mixer, alc883_chmode_mixer },
+                .init_verbs = { alc883_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
+                .dac_nids = alc883_dac_nids,
+                .dig_out_nid = ALC883_DIGOUT_NID,
+                .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
+                .adc_nids = alc883_adc_nids,
+                .dig_in_nid = ALC883_DIGIN_NID,
+                .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
+                .channel_mode = alc883_sixstack_modes,
+                .input_mux = &alc883_capture_source,
+        },
+        [ALC883_ACER] = {
+                .mixers = { alc883_base_mixer,
+                            alc883_chmode_mixer },
+                /* On TravelMate laptops, GPIO 0 enables the internal speaker
+                 * and the headphone jack.  Turn this on and rely on the
+                 * standard mute methods whenever the user wants to turn
+                 * these outputs off.
+                 */
+                .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
+                .dac_nids = alc883_dac_nids,
+                .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
+                .adc_nids = alc883_adc_nids,
+                .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
+                .channel_mode = alc883_3ST_2ch_modes,
+                .input_mux = &alc883_capture_source,
+        },
+        [ALC883_MEDION] = {
+                .mixers = { alc883_fivestack_mixer,
+                            alc883_chmode_mixer },
+                .init_verbs = { alc883_init_verbs,
+                                alc883_medion_eapd_verbs },
+                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
+                .dac_nids = alc883_dac_nids,
+                .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
+                .adc_nids = alc883_adc_nids,
+                .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
+                .channel_mode = alc883_sixstack_modes,
+                .input_mux = &alc883_capture_source,
+        },
+        [ALC883_LAPTOP_EAPD] = {
+                .mixers = { alc883_base_mixer,
+                            alc883_chmode_mixer },
+                .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
+                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
+                .dac_nids = alc883_dac_nids,
+                .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
+                .adc_nids = alc883_adc_nids,
+                .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
+                .channel_mode = alc883_3ST_2ch_modes,
+                .input_mux = &alc883_capture_source,
+        },
 };
 
@@ -4929 +5689 @@
  */
 static void alc883_auto_set_output_and_unmute(struct hda_codec *codec,
-                                              hda_nid_t nid, int pin_type,
-                                              int dac_idx)
-{
-    /* set as output */
-    struct alc_spec *spec = codec->spec;
-    int idx;
-
-    if (spec->multiout.dac_nids[dac_idx] == 0x25)
-        idx = 4;
-    else
-        idx = spec->multiout.dac_nids[dac_idx] - 2;
-
-    snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
-                        pin_type);
-    snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
-                        AMP_OUT_UNMUTE);
-    snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
+                                              hda_nid_t nid, int pin_type,
+                                              int dac_idx)
+{
+        /* set as output */
+        struct alc_spec *spec = codec->spec;
+        int idx; 
+        
+        if (spec->multiout.dac_nids[dac_idx] == 0x25)
+                idx = 4;
+        else
+                idx = spec->multiout.dac_nids[dac_idx] - 2;
+
+        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
+                            pin_type);
+        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
+                            AMP_OUT_UNMUTE);
+        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
 
 }
@@ -4951 +5711 @@
 static void alc883_auto_init_multi_out(struct hda_codec *codec)
 {
-    struct alc_spec *spec = codec->spec;
-    int i;
-
-    for (i = 0; i <= HDA_SIDE; i++) {
-        hda_nid_t nid = spec->autocfg.line_out_pins[i];
-        if (nid)
-            alc883_auto_set_output_and_unmute(codec, nid, PIN_OUT, i);
-    }
+        struct alc_spec *spec = codec->spec;
+        int i;
+
+        for (i = 0; i <= HDA_SIDE; i++) {
+                hda_nid_t nid = spec->autocfg.line_out_pins[i]; 
+                if (nid)
+                        alc883_auto_set_output_and_unmute(codec, nid, PIN_OUT, i);
+        }
 }
 
 static void alc883_auto_init_hp_out(struct hda_codec *codec)
 {
-    struct alc_spec *spec = codec->spec;
-    hda_nid_t pin;
-
-    pin = spec->autocfg.hp_pin;
-    if (pin) /* connect to front */
-        /* use dac 0 */
-        alc883_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
+        struct alc_spec *spec = codec->spec;
+        hda_nid_t pin;
+
+        pin = spec->autocfg.hp_pins[0];
+        if (pin) /* connect to front */
+                /* use dac 0 */
+                alc883_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
 }
 
@@ -4977 +5737 @@
 static void alc883_auto_init_analog_input(struct hda_codec *codec)
 {
-    struct alc_spec *spec = codec->spec;
-    int i;
-
-    for (i = 0; i < AUTO_PIN_LAST; i++) {
-        hda_nid_t nid = spec->autocfg.input_pins[i];
-        if (alc883_is_input_pin(nid)) {
-            snd_hda_codec_write(codec, nid, 0,
-                                AC_VERB_SET_PIN_WIDGET_CONTROL,
-                                (i <= AUTO_PIN_FRONT_MIC ?
-                                 PIN_VREF80 : PIN_IN));
-            if (nid != ALC883_PIN_CD_NID)
-                snd_hda_codec_write(codec, nid, 0,
-                                    AC_VERB_SET_AMP_GAIN_MUTE,
-                                    AMP_OUT_MUTE);
-        }
-    }
+        struct alc_spec *spec = codec->spec;
+        int i;
+
+        for (i = 0; i < AUTO_PIN_LAST; i++) {
+                hda_nid_t nid = spec->autocfg.input_pins[i];
+                if (alc883_is_input_pin(nid)) {
+                        snd_hda_codec_write(codec, nid, 0,
+                                            AC_VERB_SET_PIN_WIDGET_CONTROL,
+                                            (i <= AUTO_PIN_FRONT_MIC ?
+                                             PIN_VREF80 : PIN_IN));
+                        if (nid != ALC883_PIN_CD_NID)
+                                snd_hda_codec_write(codec, nid, 0,
+                                                    AC_VERB_SET_AMP_GAIN_MUTE,
+                                                    AMP_OUT_MUTE);
+                }
+        }
 }
 
@@ -4998 +5758 @@
 static int alc883_parse_auto_config(struct hda_codec *codec)
 {
-    struct alc_spec *spec = codec->spec;
-    int err = alc880_parse_auto_config(codec);
-
-    if (err < 0)
-        return err;
-    else if (err > 0)
-        /* hack - override the init verbs */
-        spec->init_verbs[0] = alc883_auto_init_verbs;
-    spec->mixers[spec->num_mixers] = alc883_capture_mixer;
-    spec->num_mixers++;
-    return err;
+        struct alc_spec *spec = codec->spec;
+        int err = alc880_parse_auto_config(codec);
+
+        if (err < 0)
+                return err;
+        else if (err > 0)
+                /* hack - override the init verbs */
+                spec->init_verbs[0] = alc883_auto_init_verbs;
+                spec->mixers[spec->num_mixers] = alc883_capture_mixer;
+                spec->num_mixers++;
+        return err;
 }
 
@@ -5014 +5774 @@
 static void alc883_auto_init(struct hda_codec *codec)
 {
-    alc883_auto_init_multi_out(codec);
-    alc883_auto_init_hp_out(codec);
-    alc883_auto_init_analog_input(codec);
+        alc883_auto_init_multi_out(codec);
+        alc883_auto_init_hp_out(codec);
+        alc883_auto_init_analog_input(codec);
 }
 
 static int patch_alc883(struct hda_codec *codec)
 {
-    struct alc_spec *spec;
-    int err, board_config;
-
-    spec = kzalloc(sizeof(*spec), GFP_KERNEL);
-    if (spec == NULL)
-        return -ENOMEM;
-
-    codec->spec = spec;
-
-    board_config = snd_hda_check_board_config(codec, alc883_cfg_tbl);
-    if (board_config < 0 || board_config >= ALC883_MODEL_LAST) {
-        printk(KERN_INFO "hda_codec: Unknown model for ALC883, "
-               "trying auto-probe from BIOS...\n");
-        board_config = ALC883_AUTO;
-    }
-
-    if (board_config == ALC883_AUTO) {
-        /* automatic parse from the BIOS config */
-        err = alc883_parse_auto_config(codec);
-        if (err < 0) {
-            alc_free(codec);
-            return err;
-        } else if (! err) {
-            printk(KERN_INFO
-                   "hda_codec: Cannot set up configuration "
-                   "from BIOS.  Using base mode...\n");
-            board_config = ALC883_3ST_2ch_DIG;
-        }
-    }
-
-    if (board_config != ALC883_AUTO)
-        setup_preset(spec, &alc883_presets[board_config]);
-
-    spec->stream_name_analog = "ALC883 Analog";
-    spec->stream_analog_playback = &alc883_pcm_analog_playback;
-    spec->stream_analog_capture = &alc883_pcm_analog_capture;
-
-    spec->stream_name_digital = "ALC883 Digital";
-    spec->stream_digital_playback = &alc883_pcm_digital_playback;
-    spec->stream_digital_capture = &alc883_pcm_digital_capture;
-
-    spec->adc_nids = alc883_adc_nids;
-    spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids);
-
-    codec->patch_ops = alc_patch_ops;
-    if (board_config == ALC883_AUTO)
-        spec->init_hook = alc883_auto_init;
-    return 0;
+        struct alc_spec *spec;
+        int err, board_config;
+
+        spec = kzalloc(sizeof(*spec), GFP_KERNEL);
+        if (spec == NULL)
+                return -ENOMEM;
+
+        codec->spec = spec;
+
+        board_config = snd_hda_check_board_config(codec, ALC883_MODEL_LAST,
+                                                  alc883_models,
+                                                  alc883_cfg_tbl);
+        if (board_config < 0) {
+                printk(KERN_INFO "hda_codec: Unknown model for ALC883, "
+                       "trying auto-probe from BIOS...\n");
+                board_config = ALC883_AUTO;
+        }
+
+        if (board_config == ALC883_AUTO) {
+                /* automatic parse from the BIOS config */
+                err = alc883_parse_auto_config(codec);
+                if (err < 0) {
+                        alc_free(codec);
+                        return err;
+                } else if (! err) {
+                        printk(KERN_INFO
+                               "hda_codec: Cannot set up configuration "
+                               "from BIOS.  Using base mode...\n");
+                        board_config = ALC883_3ST_2ch_DIG;
+                }
+        }
+
+        if (board_config != ALC883_AUTO)
+                setup_preset(spec, &alc883_presets[board_config]);
+
+        spec->stream_name_analog = "ALC883 Analog";
+        spec->stream_analog_playback = &alc883_pcm_analog_playback;
+        spec->stream_analog_capture = &alc883_pcm_analog_capture;
+
+        spec->stream_name_digital = "ALC883 Digital";
+        spec->stream_digital_playback = &alc883_pcm_digital_playback;
+        spec->stream_digital_capture = &alc883_pcm_digital_capture;
+
+        if (! spec->adc_nids && spec->input_mux) {
+                spec->adc_nids = alc883_adc_nids;
+                spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids);
+        }
+
+        codec->patch_ops = alc_patch_ops;
+        if (board_config == ALC883_AUTO)
+                spec->init_hook = alc883_auto_init;
+
+        return 0;
 }
 
@@ -5086 +5851 @@
 
 static struct snd_kcontrol_new alc262_base_mixer[] = {
-    HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
-    HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
-    HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
-    HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
-    HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
-    HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
-    HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
-    HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
-    /* HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
-     HDA_CODEC_MUTE("PC Beelp Playback Switch", 0x0b, 0x05, HDA_INPUT), */
-    HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
-    HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
-    {0} /* end */
+        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
+        HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
+        HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
+        HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
+        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
+        /* HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
+           HDA_CODEC_MUTE("PC Beelp Playback Switch", 0x0b, 0x05, HDA_INPUT), */
+        HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
+        {0} /* end */
+};
+
+static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
+        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
+        HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
+        HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
+        HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
+        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
+        /* HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
+           HDA_CODEC_MUTE("PC Beelp Playback Switch", 0x0b, 0x05, HDA_INPUT), */
+        /*HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),*/
+        HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
+        {0} /* end */
 };
 
 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
-    HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
-    HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
-
-    HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
-    HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
-    HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
-    HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
-    HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
-    HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
-    HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
-    HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
-    HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT),
-    HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
-    HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
-    {0} /* end */
+        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
+
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
+        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
+        HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
+        HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
+        HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
+        HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
+        HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
+        HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT),
+        HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
+        HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
+        {0} /* end */
 };
 
@@ -5134 +5917 @@
  */
 static struct hda_verb alc262_init_verbs[] = {
-    /*
-     * Unmute ADC0-2 and set the default input to mic-in
-     */
-    {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
-    {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
-    {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-
-    /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
-     * mixer widget
-     * Note: PASD motherboards uses the Line In 2 as the input for front panel
-     * mic (mic 2)
-     */
-    /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
-
-    /*
-     * Set up output mixers (0x0c - 0x0e)
-     */
-    /* set vol=0 to output mixers */
-    {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    /* set up input amps for analog loopback */
-    /* Amp Indices: DAC = 0, mixer = 1 */
-    {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-
-    {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
-    {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
-    {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
-    {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
-    {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
-    {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
-
-    {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
-    {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
-    {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
-    {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
-    {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
-
-    {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
-    {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
-
-    /* FIXME: use matrix-type input source selection */
-    /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
-    /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
-    {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
-    {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
-    {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
-    {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
-    /* Input mixer2 */
-    {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
-    {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
-    {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
-    {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
-    /* Input mixer3 */
-    {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
-    {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
-    {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
-    {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
-
-    {0}
-};
+        /*
+         * Unmute ADC0-2 and set the default input to mic-in
+         */
+        {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+
+        /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
+         * mixer widget
+         * Note: PASD motherboards uses the Line In 2 as the input for front panel
+         * mic (mic 2)
+         */
+        /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
+
+        /*
+         * Set up output mixers (0x0c - 0x0e)
+         */
+        /* set vol=0 to output mixers */
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        /* set up input amps for analog loopback */
+        /* Amp Indices: DAC = 0, mixer = 1 */
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
+        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
+        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
+        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
+        {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
+
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
+        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
+        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
+        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
+        
+        {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
+        
+        /* FIXME: use matrix-type input source selection */
+        /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
+        /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
+        /* Input mixer2 */
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
+        /* Input mixer3 */
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},      
+
+        {0}
+};
+
+static struct hda_verb alc262_hippo_unsol_verbs[] = {
+        {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0}
+};
+
+static struct hda_verb alc262_hippo1_unsol_verbs[] = {
+        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
+        {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
+
+        {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
+        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0}
+};
+
+/* mute/unmute internal speaker according to the hp jack and mute state */
+static void alc262_hippo_automute(struct hda_codec *codec, int force)
+{
+        struct alc_spec *spec = codec->spec;
+        unsigned int mute;
+
+        if (force || ! spec->sense_updated) {
+                unsigned int present;
+                /* need to execute and sync at first */
+                snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
+                present = snd_hda_codec_read(codec, 0x15, 0,
+                                         AC_VERB_GET_PIN_SENSE, 0);
+                spec->jack_present = (present & 0x80000000) != 0;
+                spec->sense_updated = 1;
+        }
+        if (spec->jack_present) {
+                /* mute internal speaker */
+                snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
+                                         0x80, 0x80);
+                snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
+                                         0x80, 0x80);
+        } else {
+                /* unmute internal speaker if necessary */
+                mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0);
+                snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
+                                         0x80, mute & 0x80);
+                mute = snd_hda_codec_amp_read(codec, 0x15, 1, HDA_OUTPUT, 0);
+                snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
+                                         0x80, mute & 0x80);
+        }
+}
+
+/* unsolicited event for HP jack sensing */
+static void alc262_hippo_unsol_event(struct hda_codec *codec,
+                                       unsigned int res)
+{
+        if ((res >> 26) != ALC880_HP_EVENT)
+                return;
+        alc262_hippo_automute(codec, 1);
+}
+
+static void alc262_hippo1_automute(struct hda_codec *codec, int force)
+{
+        struct alc_spec *spec = codec->spec;
+        unsigned int mute;
+
+        if (force || ! spec->sense_updated) {
+                unsigned int present;
+                /* need to execute and sync at first */
+                snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
+                present = snd_hda_codec_read(codec, 0x1b, 0,
+                                         AC_VERB_GET_PIN_SENSE, 0);
+                spec->jack_present = (present & 0x80000000) != 0;
+                spec->sense_updated = 1;
+        }
+        if (spec->jack_present) {
+                /* mute internal speaker */
+                snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
+                                         0x80, 0x80);
+                snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
+                                         0x80, 0x80);
+        } else {
+                /* unmute internal speaker if necessary */
+                mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
+                snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
+                                         0x80, mute & 0x80);
+                mute = snd_hda_codec_amp_read(codec, 0x1b, 1, HDA_OUTPUT, 0);
+                snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
+                                         0x80, mute & 0x80);
+        }
+}
+
+/* unsolicited event for HP jack sensing */
+static void alc262_hippo1_unsol_event(struct hda_codec *codec,
+                                       unsigned int res)
+{
+        if ((res >> 26) != ALC880_HP_EVENT)
+                return;
+        alc262_hippo1_automute(codec, 1);
+}
 
 /*
@@ -5217 +6097 @@
 
 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
-    {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
-    {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
-    {0}
+        {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0}
 };
 
 static struct hda_input_mux alc262_fujitsu_capture_source = {
-    .num_items = 2,
-    .items = {
-        { "Mic", 0x0 },
-        { "CD", 0x4 },
-    },
+        .num_items = 2,
+        .items = {
+                { "Mic", 0x0 },
+                { "CD", 0x4 },
+        },
 };
 
 static struct hda_input_mux alc262_HP_capture_source = {
-    .num_items = 5,
-    .items = {
-        { "Mic", 0x0 },
-        { "Front Mic", 0x3 },
-        { "Line", 0x2 },
-        { "CD", 0x4 },
-        { "AUX IN", 0x6 },
-    },
+        .num_items = 5,
+        .items = {
+                { "Mic", 0x0 },
+                { "Front Mic", 0x3 },
+                { "Line", 0x2 },
+                { "CD", 0x4 },
+                { "AUX IN", 0x6 },
+        },
 };
 
@@ -5244 +6124 @@
 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
 {
-    struct alc_spec *spec = codec->spec;
-    unsigned int mute;
-
-    if (force || ! spec->sense_updated) {
-        unsigned int present;
-        /* need to execute and sync at first */
-        snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
-        present = snd_hda_codec_read(codec, 0x14, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0);
-        spec->jack_present = (present & 0x80000000) != 0;
-        spec->sense_updated = 1;
-    }
-    if (spec->jack_present) {
-        /* mute internal speaker */
-        snd_hda_codec_amp_update(codec, 0x15, 0, HDA_OUTPUT, 0,
-                                 0x80, 0x80);
-        snd_hda_codec_amp_update(codec, 0x15, 1, HDA_OUTPUT, 0,
-                                 0x80, 0x80);
-    } else {
-        /* unmute internal speaker if necessary */
-        mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
-        snd_hda_codec_amp_update(codec, 0x15, 0, HDA_OUTPUT, 0,
-                                 0x80, mute & 0x80);
-        mute = snd_hda_codec_amp_read(codec, 0x14, 1, HDA_OUTPUT, 0);
-        snd_hda_codec_amp_update(codec, 0x15, 1, HDA_OUTPUT, 0,
-                                 0x80, mute & 0x80);
-    }
+        struct alc_spec *spec = codec->spec;
+        unsigned int mute;
+
+        if (force || ! spec->sense_updated) {
+                unsigned int present;
+                /* need to execute and sync at first */
+                snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
+                present = snd_hda_codec_read(codec, 0x14, 0,
+                                         AC_VERB_GET_PIN_SENSE, 0);
+                spec->jack_present = (present & 0x80000000) != 0;
+                spec->sense_updated = 1;
+        }
+        if (spec->jack_present) {
+                /* mute internal speaker */
+                snd_hda_codec_amp_update(codec, 0x15, 0, HDA_OUTPUT, 0,
+                                         0x80, 0x80);
+                snd_hda_codec_amp_update(codec, 0x15, 1, HDA_OUTPUT, 0,
+                                         0x80, 0x80);
+        } else {
+                /* unmute internal speaker if necessary */
+                mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
+                snd_hda_codec_amp_update(codec, 0x15, 0, HDA_OUTPUT, 0,
+                                         0x80, mute & 0x80);
+                mute = snd_hda_codec_amp_read(codec, 0x14, 1, HDA_OUTPUT, 0);
+                snd_hda_codec_amp_update(codec, 0x15, 1, HDA_OUTPUT, 0,
+                                         0x80, mute & 0x80);
+        }
 }
 
 /* unsolicited event for HP jack sensing */
 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
-                                       unsigned int res)
-{
-    if ((res >> 26) != ALC_HP_EVENT)
-        return;
-    alc262_fujitsu_automute(codec, 1);
+                                       unsigned int res)
+{
+        if ((res >> 26) != ALC_HP_EVENT)
+                return;
+        alc262_fujitsu_automute(codec, 1);
 }
 
 /* bind volumes of both NID 0x0c and 0x0d */
 static int alc262_fujitsu_master_vol_put(struct snd_kcontrol *kcontrol,
-                                         struct snd_ctl_elem_value *ucontrol)
-{
-    struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-    long *valp = ucontrol->value.integer.value;
-    int change;
-
-    change = snd_hda_codec_amp_update(codec, 0x0c, 0, HDA_OUTPUT, 0,
-                                      0x7f, valp[0] & 0x7f);
-    change |= snd_hda_codec_amp_update(codec, 0x0c, 1, HDA_OUTPUT, 0,
-                                       0x7f, valp[1] & 0x7f);
-    snd_hda_codec_amp_update(codec, 0x0d, 0, HDA_OUTPUT, 0,
-                             0x7f, valp[0] & 0x7f);
-    snd_hda_codec_amp_update(codec, 0x0d, 1, HDA_OUTPUT, 0,
-                             0x7f, valp[1] & 0x7f);
-    return change;
+                                         struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        long *valp = ucontrol->value.integer.value;
+        int change;
+
+        change = snd_hda_codec_amp_update(codec, 0x0c, 0, HDA_OUTPUT, 0,
+                                          0x7f, valp[0] & 0x7f);
+        change |= snd_hda_codec_amp_update(codec, 0x0c, 1, HDA_OUTPUT, 0,
+                                           0x7f, valp[1] & 0x7f);
+        snd_hda_codec_amp_update(codec, 0x0d, 0, HDA_OUTPUT, 0,
+                                 0x7f, valp[0] & 0x7f);
+        snd_hda_codec_amp_update(codec, 0x0d, 1, HDA_OUTPUT, 0,
+                                 0x7f, valp[1] & 0x7f);
+        return change;
 }
 
 /* bind hp and internal speaker mute (with plug check) */
 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
-                                        struct snd_ctl_elem_value *ucontrol)
-{
-    struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-    long *valp = ucontrol->value.integer.value;
-    int change;
-
-    change = snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
-                                      0x80, valp[0] ? 0 : 0x80);
-    change |= snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
-                                       0x80, valp[1] ? 0 : 0x80);
-    if (change || codec->in_resume)
-        alc262_fujitsu_automute(codec, codec->in_resume);
-    return change;
+                                         struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        long *valp = ucontrol->value.integer.value;
+        int change;
+
+        change = snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
+                                          0x80, valp[0] ? 0 : 0x80);
+        change |= snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
+                                           0x80, valp[1] ? 0 : 0x80);
+        if (change || codec->in_resume)
+                alc262_fujitsu_automute(codec, codec->in_resume);
+        return change;
 }
 
 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
-    {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "Master Playback Volume",
-        .info = snd_hda_mixer_amp_volume_info,
-        .get = snd_hda_mixer_amp_volume_get,
-        .put = alc262_fujitsu_master_vol_put,
-        .private_value = HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
-    },
-    {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "Master Playback Switch",
-        .info = snd_hda_mixer_amp_switch_info,
-        .get = snd_hda_mixer_amp_switch_get,
-        .put = alc262_fujitsu_master_sw_put,
-        .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
-    },
-    HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
-    HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
-    HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
-    HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
-    {0} /* end */
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Master Playback Volume",
+                .info = snd_hda_mixer_amp_volume_info,
+                .get = snd_hda_mixer_amp_volume_get,
+                .put = alc262_fujitsu_master_vol_put,
+                .tlv = { .c = snd_hda_mixer_amp_tlv },
+                .private_value = HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
+        },
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Master Playback Switch",
+                .info = snd_hda_mixer_amp_switch_info,
+                .get = snd_hda_mixer_amp_switch_get,
+                .put = alc262_fujitsu_master_sw_put,
+                .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
+        },
+        HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
+        HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
+        {0} /* end */
+};
+
+/* additional init verbs for Benq laptops */
+static struct hda_verb alc262_EAPD_verbs[] = {
+        {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
+        {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
+        {0}
 };
 
@@ -5346 +6234 @@
 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec, const struct auto_pin_cfg *cfg)
 {
-    hda_nid_t nid;
-    int err;
-
-    spec->multiout.num_dacs = 1;        /* only use one dac */
-    spec->multiout.dac_nids = spec->private_dac_nids;
-    spec->multiout.dac_nids[0] = 2;
-
-    nid = cfg->line_out_pins[0];
-    if (nid) {
-        if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, "Front Playback Volume",
-                               HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT))) < 0)
-            return err;
-        if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, "Front Playback Switch",
-                               HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
-            return err;
-    }
-
-    nid = cfg->speaker_pins[0];
-    if (nid) {
-        if (nid == 0x16) {
-            if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, "Speaker Playback Switch",
-                                   HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT))) < 0)
-                return err;
-        } else {
-            if (! cfg->line_out_pins[0])
-                if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, "Speaker Playback Volume",
-                                       HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT))) < 0)
-                    return err;
-            if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, "Speaker Playback Switch",
-                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
-                return err;
-        }
-    }
-    nid = cfg->hp_pin;
-    if (nid) {
-        /* spec->multiout.hp_nid = 2; */
-        if (nid == 0x16) {
-            if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, "Headphone Playback Volume",
-                                   HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT))) < 0)
-                return err;
-            if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, "Headphone Playback Switch",
-                                   HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT))) < 0)
-                return err;
-        } else {
-            if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, "Headphone Playback Switch",
-                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
-                return err;
-        }
-    }
-    return 0;
+        hda_nid_t nid;
+        int err;
+
+        spec->multiout.num_dacs = 1;    /* only use one dac */
+        spec->multiout.dac_nids = spec->private_dac_nids;
+        spec->multiout.dac_nids[0] = 2;
+
+        nid = cfg->line_out_pins[0];
+        if (nid) {
+                if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, "Front Playback Volume",
+                                       HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT))) < 0)
+                        return err;
+                if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, "Front Playback Switch",
+                                       HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
+                        return err;
+        }
+
+        nid = cfg->speaker_pins[0];
+        if (nid) {
+                if (nid == 0x16) {
+                        if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, "Speaker Playback Volume",
+                                               HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT))) < 0)
+                                return err;
+                        if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, "Speaker Playback Switch",
+                                               HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT))) < 0)
+                                return err;
+                } else {
+                        if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, "Speaker Playback Switch",
+                                               HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
+                                return err;
+                }
+        }
+        nid = cfg->hp_pins[0];
+        if (nid) {
+                /* spec->multiout.hp_nid = 2; */
+                if (nid == 0x16) {
+                        if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, "Headphone Playback Volume",
+                                               HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT))) < 0)
+                                return err;
+                        if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, "Headphone Playback Switch",
+                                               HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT))) < 0)
+                                return err;
+                } else {
+                        if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, "Headphone Playback Switch",
+                                               HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
+                                return err;
+                }
+        }
+        return 0;       
 }
 
@@ -5405 +6292 @@
  */
 static struct hda_verb alc262_volume_init_verbs[] = {
-    /*
-     * Unmute ADC0-2 and set the default input to mic-in
-     */
-    {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
-    {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
-    {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-
-    /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
-     * mixer widget
-     * Note: PASD motherboards uses the Line In 2 as the input for front panel
-     * mic (mic 2)
-     */
-    /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
-
-    /*
-     * Set up output mixers (0x0c - 0x0f)
-     */
-    /* set vol=0 to output mixers */
-    {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-
-    /* set up input amps for analog loopback */
-    /* Amp Indices: DAC = 0, mixer = 1 */
-    {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-
-    /* FIXME: use matrix-type input source selection */
-    /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
-    /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
-    {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
-    {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
-    {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
-    {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
-    /* Input mixer2 */
-    {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
-    {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
-    {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
-    {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
-    /* Input mixer3 */
-    {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
-    {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
-    {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
-    {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
-
-    {0}
+        /*
+         * Unmute ADC0-2 and set the default input to mic-in
+         */
+        {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+
+        /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
+         * mixer widget
+         * Note: PASD motherboards uses the Line In 2 as the input for front panel
+         * mic (mic 2)
+         */
+        /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
+
+        /*
+         * Set up output mixers (0x0c - 0x0f)
+         */
+        /* set vol=0 to output mixers */
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        
+        /* set up input amps for analog loopback */
+        /* Amp Indices: DAC = 0, mixer = 1 */
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+
+        /* FIXME: use matrix-type input source selection */
+        /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
+        /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
+        /* Input mixer2 */
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
+        /* Input mixer3 */
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
+
+        {0}
 };
 
 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
-    /*
-     * Unmute ADC0-2 and set the default input to mic-in
-     */
-    {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
-    {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
-    {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-
-    /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
-     * mixer widget
-     * Note: PASD motherboards uses the Line In 2 as the input for front panel
-     * mic (mic 2)
-     */
-    /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
-    {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(6)},
-
-    /*
-     * Set up output mixers (0x0c - 0x0e)
-     */
-    /* set vol=0 to output mixers */
-    {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-    {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-
-    /* set up input amps for analog loopback */
-    /* Amp Indices: DAC = 0, mixer = 1 */
-    {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-
-    {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
-    {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
-    {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
-
-    {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
-    {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
-
-    {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
-    {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
-
-    {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
-    {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
-    {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
-    {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
-    {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
-
-    {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
-    {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
-    {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
-    {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
-    {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
-    {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
-
-
-    /* FIXME: use matrix-type input source selection */
-    /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
-    /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
-    {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
-    {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
-    {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
-    {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
-    /* Input mixer2 */
-    {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
-    {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
-    {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
-    {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
-    /* Input mixer3 */
-    {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
-    {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
-    {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
-    {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
-
-    {0}
+        /*
+         * Unmute ADC0-2 and set the default input to mic-in
+         */
+        {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+
+        /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
+         * mixer widget
+         * Note: PASD motherboards uses the Line In 2 as the input for front panel
+         * mic (mic 2)
+         */
+        /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(6)},
+        
+        /*
+         * Set up output mixers (0x0c - 0x0e)
+         */
+        /* set vol=0 to output mixers */
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+
+        /* set up input amps for analog loopback */
+        /* Amp Indices: DAC = 0, mixer = 1 */
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+
+        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
+        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
+
+        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
+
+        {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
+
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
+        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
+        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
+        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
+        {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
+
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
+        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
+        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
+        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
+        {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
+        {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
+
+
+        /* FIXME: use matrix-type input source selection */
+        /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
+        /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
+        /* Input mixer2 */
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
+        /* Input mixer3 */
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
+
+        {0}
 };
 
@@ -5563 +6450 @@
 static int alc262_parse_auto_config(struct hda_codec *codec)
 {
-    struct alc_spec *spec = codec->spec;
-    int err;
-    static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
-
-    if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
-                                            alc262_ignore)) < 0)
-        return err;
-    if (! spec->autocfg.line_outs)
-        return 0; /* can't find valid BIOS pin config */
-    if ((err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0 ||
-        (err = alc262_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0)
-        return err;
-
-    spec->multiout.max_channels = spec->multiout.num_dacs * 2;
-
-    if (spec->autocfg.dig_out_pin)
-        spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
-    if (spec->autocfg.dig_in_pin)
-        spec->dig_in_nid = ALC262_DIGIN_NID;
-
-    if (spec->kctl_alloc)
-        spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
-
-    spec->init_verbs[spec->num_init_verbs++] = alc262_volume_init_verbs;
-    spec->input_mux = &spec->private_imux;
-
-    return 1;
+        struct alc_spec *spec = codec->spec;
+        int err;
+        static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
+
+        if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
+                                                alc262_ignore)) < 0)
+                return err;
+        if (! spec->autocfg.line_outs)
+                return 0; /* can't find valid BIOS pin config */
+        if ((err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0 ||
+            (err = alc262_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0)
+                return err;
+
+        spec->multiout.max_channels = spec->multiout.num_dacs * 2;
+
+        if (spec->autocfg.dig_out_pin)
+                spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
+        if (spec->autocfg.dig_in_pin)
+                spec->dig_in_nid = ALC262_DIGIN_NID;
+
+        if (spec->kctl_alloc)
+                spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
+
+        spec->init_verbs[spec->num_init_verbs++] = alc262_volume_init_verbs;
+        spec->num_mux_defs = 1;
+        spec->input_mux = &spec->private_imux;
+
+        return 1;
 }
 
@@ -5600 +6488 @@
 static void alc262_auto_init(struct hda_codec *codec)
 {
-    alc262_auto_init_multi_out(codec);
-    alc262_auto_init_hp_out(codec);
-    alc262_auto_init_analog_input(codec);
+        alc262_auto_init_multi_out(codec);
+        alc262_auto_init_hp_out(codec);
+        alc262_auto_init_analog_input(codec);
 }
 
@@ -5608 +6496 @@
  * configuration and preset
  */
-static struct hda_board_config alc262_cfg_tbl[] = {
-    { .modelname = "basic", .config = ALC262_BASIC },
-    { .modelname = "fujitsu", .config = ALC262_FUJITSU },
-    { .pci_subvendor = 0x10cf, .pci_subdevice = 0x1397,
-    .config = ALC262_FUJITSU },
-    { .pci_subvendor = 0x103c, .pci_subdevice = 0x208c,
-    .config = ALC262_HP_BPC }, /* xw4400 */
-    { .pci_subvendor = 0x103c, .pci_subdevice = 0x3014,
-    .config = ALC262_HP_BPC }, /* xw6400 */
-    { .pci_subvendor = 0x103c, .pci_subdevice = 0x3015,
-    .config = ALC262_HP_BPC }, /* xw8400 */
-    { .pci_subvendor = 0x103c, .pci_subdevice = 0x12fe,
-    .config = ALC262_HP_BPC }, /* xw9400 */
-    { .modelname = "auto", .config = ALC262_AUTO },
-    {0}
+static const char *alc262_models[ALC262_MODEL_LAST] = {
+        [ALC262_BASIC]          = "basic",
+        [ALC262_HIPPO]          = "hippo",
+        [ALC262_HIPPO_1]        = "hippo_1",
+        [ALC262_FUJITSU]        = "fujitsu",
+        [ALC262_HP_BPC]         = "hp-bpc",
+        [ALC262_BENQ_ED8]       = "benq",
+        [ALC262_AUTO]           = "auto",
+};
+
+static struct snd_pci_quirk alc262_cfg_tbl[] = {
+        SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
+        SND_PCI_QUIRK(0x103c, 0x12fe, "HP xw9400", ALC262_HP_BPC),
+        SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
+        SND_PCI_QUIRK(0x103c, 0x2801, "HP q954", ALC262_HP_BPC),
+        SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
+        SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
+        SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
+        SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
+        SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
+        SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
+        {0}
 };
 
 static struct alc_config_preset alc262_presets[] = {
-    [ALC262_BASIC] = {
-        .mixers = { alc262_base_mixer },
-        .init_verbs = { alc262_init_verbs },
-        .num_dacs = ARRAY_SIZE(alc262_dac_nids),
-        .dac_nids = alc262_dac_nids,
-        .hp_nid = 0x03,
-        .num_channel_mode = ARRAY_SIZE(alc262_modes),
-        .channel_mode = alc262_modes,
-        .input_mux = &alc262_capture_source,
-    },
-    [ALC262_FUJITSU] = {
-        .mixers = { alc262_fujitsu_mixer },
-        .init_verbs = { alc262_init_verbs, alc262_fujitsu_unsol_verbs },
-        .num_dacs = ARRAY_SIZE(alc262_dac_nids),
-        .dac_nids = alc262_dac_nids,
-        .hp_nid = 0x03,
-        .dig_out_nid = ALC262_DIGOUT_NID,
-        .num_channel_mode = ARRAY_SIZE(alc262_modes),
-        .channel_mode = alc262_modes,
-        .input_mux = &alc262_fujitsu_capture_source,
-        .unsol_event = alc262_fujitsu_unsol_event,
-    },
-    [ALC262_HP_BPC] = {
-        .mixers = { alc262_HP_BPC_mixer },
-        .init_verbs = { alc262_HP_BPC_init_verbs },
-        .num_dacs = ARRAY_SIZE(alc262_dac_nids),
-        .dac_nids = alc262_dac_nids,
-        .hp_nid = 0x03,
-        .num_channel_mode = ARRAY_SIZE(alc262_modes),
-        .channel_mode = alc262_modes,
-        .input_mux = &alc262_HP_capture_source,
-    },
+        [ALC262_BASIC] = {
+                .mixers = { alc262_base_mixer },
+                .init_verbs = { alc262_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc262_dac_nids),
+                .dac_nids = alc262_dac_nids,
+                .hp_nid = 0x03,
+                .num_channel_mode = ARRAY_SIZE(alc262_modes),
+                .channel_mode = alc262_modes,
+                .input_mux = &alc262_capture_source,
+        },
+        [ALC262_HIPPO] = {
+                .mixers = { alc262_base_mixer },
+                .init_verbs = { alc262_init_verbs, alc262_hippo_unsol_verbs},
+                .num_dacs = ARRAY_SIZE(alc262_dac_nids),
+                .dac_nids = alc262_dac_nids,
+                .hp_nid = 0x03,
+                .dig_out_nid = ALC262_DIGOUT_NID,
+                .num_channel_mode = ARRAY_SIZE(alc262_modes),
+                .channel_mode = alc262_modes,
+                .input_mux = &alc262_capture_source,
+                .unsol_event = alc262_hippo_unsol_event,
+        },
+        [ALC262_HIPPO_1] = {
+                .mixers = { alc262_hippo1_mixer },
+                .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
+                .num_dacs = ARRAY_SIZE(alc262_dac_nids),
+                .dac_nids = alc262_dac_nids,
+                .hp_nid = 0x02,
+                .dig_out_nid = ALC262_DIGOUT_NID,
+                .num_channel_mode = ARRAY_SIZE(alc262_modes),
+                .channel_mode = alc262_modes,
+                .input_mux = &alc262_capture_source,
+                .unsol_event = alc262_hippo1_unsol_event,
+        },
+        [ALC262_FUJITSU] = {
+                .mixers = { alc262_fujitsu_mixer },
+                .init_verbs = { alc262_init_verbs, alc262_fujitsu_unsol_verbs },
+                .num_dacs = ARRAY_SIZE(alc262_dac_nids),
+                .dac_nids = alc262_dac_nids,
+                .hp_nid = 0x03,
+                .dig_out_nid = ALC262_DIGOUT_NID,
+                .num_channel_mode = ARRAY_SIZE(alc262_modes),
+                .channel_mode = alc262_modes,
+                .input_mux = &alc262_fujitsu_capture_source,
+                .unsol_event = alc262_fujitsu_unsol_event,
+        },
+        [ALC262_HP_BPC] = {
+                .mixers = { alc262_HP_BPC_mixer },
+                .init_verbs = { alc262_HP_BPC_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc262_dac_nids),
+                .dac_nids = alc262_dac_nids,
+                .hp_nid = 0x03,
+                .num_channel_mode = ARRAY_SIZE(alc262_modes),
+                .channel_mode = alc262_modes,
+                .input_mux = &alc262_HP_capture_source,
+        },      
+        [ALC262_BENQ_ED8] = {
+                .mixers = { alc262_base_mixer },
+                .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
+                .num_dacs = ARRAY_SIZE(alc262_dac_nids),
+                .dac_nids = alc262_dac_nids,
+                .hp_nid = 0x03,
+                .num_channel_mode = ARRAY_SIZE(alc262_modes),
+                .channel_mode = alc262_modes,
+                .input_mux = &alc262_capture_source,
+        },              
 };
 
 static int patch_alc262(struct hda_codec *codec)
 {
-    struct alc_spec *spec;
-    int board_config;
-    int err;
-
-    spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
-    if (spec == NULL)
-        return -ENOMEM;
-
-    codec->spec = spec;
+        struct alc_spec *spec;
+        int board_config;
+        int err;
+
+        spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
+        if (spec == NULL)
+                return -ENOMEM;
+
+        codec->spec = spec;
 #if 0
-    /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is under-run */
-    {
-        int tmp;
-        snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
-        tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
-        snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
-        snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
-    }
+        /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is under-run */
+        {
+        int tmp;
+        snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
+        tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
+        snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
+        snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
+        }
 #endif
 
-    board_config = snd_hda_check_board_config(codec, alc262_cfg_tbl);
-
-    if (board_config < 0 || board_config >= ALC262_MODEL_LAST) {
-        printk(KERN_INFO "hda_codec: Unknown model for ALC262, trying auto-probe from BIOS...\n");
-        board_config = ALC262_AUTO;
-    }
-
-    if (board_config == ALC262_AUTO) {
-        /* automatic parse from the BIOS config */
-        err = alc262_parse_auto_config(codec);
-        if (err < 0) {
-            alc_free(codec);
-            return err;
-        } else if (! err) {
-            printk(KERN_INFO "hda_codec: Cannot set up configuration from BIOS.  Using base mode...\n");
-            board_config = ALC262_BASIC;
-        }
-    }
-
-    if (board_config != ALC262_AUTO)
-        setup_preset(spec, &alc262_presets[board_config]);
-
-    spec->stream_name_analog = "ALC262 Analog";
-    spec->stream_analog_playback = &alc262_pcm_analog_playback;
-    spec->stream_analog_capture = &alc262_pcm_analog_capture;
-
-    spec->stream_name_digital = "ALC262 Digital";
-    spec->stream_digital_playback = &alc262_pcm_digital_playback;
-    spec->stream_digital_capture = &alc262_pcm_digital_capture;
-
-    if (! spec->adc_nids && spec->input_mux) {
-        /* check whether NID 0x07 is valid */
-        unsigned int wcap = get_wcaps(codec, 0x07);
-
-        wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; /* get type */
-        if (wcap != AC_WID_AUD_IN) {
-            spec->adc_nids = alc262_adc_nids_alt;
-            spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids_alt);
-            spec->mixers[spec->num_mixers] = alc262_capture_alt_mixer;
-            spec->num_mixers++;
-        } else {
-            spec->adc_nids = alc262_adc_nids;
-            spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids);
-            spec->mixers[spec->num_mixers] = alc262_capture_mixer;
-            spec->num_mixers++;
-        }
-    }
-
-    codec->patch_ops = alc_patch_ops;
-    if (board_config == ALC262_AUTO)
-        spec->init_hook = alc262_auto_init;
-
-    return 0;
-}
-
+        board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
+                                                  alc262_models,
+                                                  alc262_cfg_tbl);
+        
+        if (board_config < 0) {
+                printk(KERN_INFO "hda_codec: Unknown model for ALC262, "
+                       "trying auto-probe from BIOS...\n");
+                board_config = ALC262_AUTO;
+        }
+
+        if (board_config == ALC262_AUTO) {
+                /* automatic parse from the BIOS config */
+                err = alc262_parse_auto_config(codec);
+                if (err < 0) {
+                        alc_free(codec);
+                        return err;
+                } else if (! err) {
+                        printk(KERN_INFO
+                               "hda_codec: Cannot set up configuration "
+                               "from BIOS.  Using base mode...\n");
+                        board_config = ALC262_BASIC;
+                }
+        }
+
+        if (board_config != ALC262_AUTO)
+                setup_preset(spec, &alc262_presets[board_config]);
+
+        spec->stream_name_analog = "ALC262 Analog";
+        spec->stream_analog_playback = &alc262_pcm_analog_playback;
+        spec->stream_analog_capture = &alc262_pcm_analog_capture;
+                
+        spec->stream_name_digital = "ALC262 Digital";
+        spec->stream_digital_playback = &alc262_pcm_digital_playback;
+        spec->stream_digital_capture = &alc262_pcm_digital_capture;
+
+        if (! spec->adc_nids && spec->input_mux) {
+                /* check whether NID 0x07 is valid */
+                unsigned int wcap = get_wcaps(codec, 0x07);
+
+                wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; /* get type */
+                if (wcap != AC_WID_AUD_IN) {
+                        spec->adc_nids = alc262_adc_nids_alt;
+                        spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids_alt);
+                        spec->mixers[spec->num_mixers] = alc262_capture_alt_mixer;
+                        spec->num_mixers++;
+                } else {
+                        spec->adc_nids = alc262_adc_nids;
+                        spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids);
+                        spec->mixers[spec->num_mixers] = alc262_capture_mixer;
+                        spec->num_mixers++;
+                }
+        }
+
+        codec->patch_ops = alc_patch_ops;
+        if (board_config == ALC262_AUTO)
+                spec->init_hook = alc262_auto_init;
+                
+        return 0;
+}
 
 /*
@@ -5747 +6680 @@
  */
 static struct hda_verb alc861_threestack_ch2_init[] = {
-    /* set pin widget 1Ah (line in) for input */
-    { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
-    /* set pin widget 18h (mic1/2) for input, for mic also enable the vref */
-    { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
-
-    { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
+        /* set pin widget 1Ah (line in) for input */
+        { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
+        /* set pin widget 18h (mic1/2) for input, for mic also enable the vref */
+        { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
+
+        { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
 #if 0
-    { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
-    { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
+        { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
+        { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
 #endif
-    {0} /* end */
+        {0} /* end */
 };
 /*
@@ -5764 +6697 @@
  */
 static struct hda_verb alc861_threestack_ch6_init[] = {
-    /* set pin widget 1Ah (line in) for output (Back Surround)*/
-    { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
-    /* set pin widget 18h (mic1) for output (CLFE)*/
-    { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
-
-    { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
-    { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
-
-    { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
+        /* set pin widget 1Ah (line in) for output (Back Surround)*/
+        { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
+        /* set pin widget 18h (mic1) for output (CLFE)*/
+        { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
+
+        { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
+        { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
+
+        { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
 #if 0
-    { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
-    { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
+        { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
+        { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
 #endif
-    {0} /* end */
+        {0} /* end */
 };
 
 static struct hda_channel_mode alc861_threestack_modes[2] = {
-    { 2, alc861_threestack_ch2_init },
-    { 6, alc861_threestack_ch6_init },
+        { 2, alc861_threestack_ch2_init },
+        { 6, alc861_threestack_ch6_init },
+};
+/* Set mic1 as input and unmute the mixer */
+static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
+        { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
+        { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
+        {0} /* end */
+};
+/* Set mic1 as output and mute mixer */
+static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
+        { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
+        { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
+        {0} /* end */
+};
+
+static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
+        { 2, alc861_uniwill_m31_ch2_init },
+        { 4, alc861_uniwill_m31_ch4_init },
+};
+
+/* Set mic1 and line-in as input and unmute the mixer */
+static struct hda_verb alc861_asus_ch2_init[] = {
+        /* set pin widget 1Ah (line in) for input */
+        { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
+        /* set pin widget 18h (mic1/2) for input, for mic also enable the vref */
+        { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
+
+        { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
+#if 0
+        { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
+        { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
+#endif
+        {0} /* end */
+};
+/* Set mic1 nad line-in as output and mute mixer */
+static struct hda_verb alc861_asus_ch6_init[] = {
+        /* set pin widget 1Ah (line in) for output (Back Surround)*/
+        { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
+        /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
+        /* set pin widget 18h (mic1) for output (CLFE)*/
+        { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
+        /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
+        { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
+        { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
+
+        { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
+#if 0
+        { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
+        { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
+#endif
+        {0} /* end */
+};
+
+static struct hda_channel_mode alc861_asus_modes[2] = {
+        { 2, alc861_asus_ch2_init },
+        { 6, alc861_asus_ch6_init },
 };
 
@@ -5788 +6776 @@
 
 static struct snd_kcontrol_new alc861_base_mixer[] = {
-    /* output mixer control */
-    HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
-
-    /*Input mixer control */
-    /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
-     HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
-    HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
-    HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
-    HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
-    HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
-    HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
-    HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
-    HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
-
-    /* Capture mixer control */
-    HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
-    {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "Capture Source",
-        .count = 1,
-        .info = alc_mux_enum_info,
-        .get = alc_mux_enum_get,
-        .put = alc_mux_enum_put,
-    },
-    {0} /* end */
+        /* output mixer control */
+        HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
+
+        /*Input mixer control */
+        /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
+           HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
+        HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
+        HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
+        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
+ 
+        /* Capture mixer control */
+        HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Capture Source",
+                .count = 1,
+                .info = alc_mux_enum_info,
+                .get = alc_mux_enum_get,
+                .put = alc_mux_enum_put,
+        },
+        {0} /* end */
 };
 
 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
-    /* output mixer control */
-    HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
-    HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
-    /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
-
-    /* Input mixer control */
-    /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
-     HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
-    HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
-    HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
-    HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
-    HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
-    HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
-    HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
-    HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
-
-    /* Capture mixer control */
-    HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
-    {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "Capture Source",
-        .count = 1,
-        .info = alc_mux_enum_info,
-        .get = alc_mux_enum_get,
-        .put = alc_mux_enum_put,
-    },
-    {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "Channel Mode",
-        .info = alc_ch_mode_info,
-        .get = alc_ch_mode_get,
-        .put = alc_ch_mode_put,
-        .private_value = ARRAY_SIZE(alc861_threestack_modes),
-    },
-    {0} /* end */
+        /* output mixer control */
+        HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
+        /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
+
+        /* Input mixer control */
+        /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
+           HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
+        HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
+        HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
+        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
+ 
+        /* Capture mixer control */
+        HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Capture Source",
+                .count = 1,
+                .info = alc_mux_enum_info,
+                .get = alc_mux_enum_get,
+                .put = alc_mux_enum_put,
+        },
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Channel Mode",
+                .info = alc_ch_mode_info,
+                .get = alc_ch_mode_get,
+                .put = alc_ch_mode_put,
+                .private_value = ARRAY_SIZE(alc861_threestack_modes),
+        },
+        {0} /* end */
+};
+
+static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
+        /* output mixer control */
+        HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
+        
+        /*Capture mixer control */
+        HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Capture Source",
+                .count = 1,
+                .info = alc_mux_enum_info,
+                .get = alc_mux_enum_get,
+                .put = alc_mux_enum_put,
+        },
+
+        {0} /* end */
+};      
+
+static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
+        /* output mixer control */
+        HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
+        /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
+
+        /* Input mixer control */
+        /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
+           HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
+        HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
+        HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
+        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
+ 
+        /* Capture mixer control */
+        HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Capture Source",
+                .count = 1,
+                .info = alc_mux_enum_info,
+                .get = alc_mux_enum_get,
+                .put = alc_mux_enum_put,
+        },
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Channel Mode",
+                .info = alc_ch_mode_info,
+                .get = alc_ch_mode_get,
+                .put = alc_ch_mode_put,
+                .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
+        },
+        {0} /* end */
+};                      
+
+static struct snd_kcontrol_new alc861_asus_mixer[] = {
+        /* output mixer control */
+        HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
+
+        /* Input mixer control */
+        HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
+        HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
+        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT), /* was HDA_INPUT (why?) */
+ 
+        /* Capture mixer control */
+        HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Capture Source",
+                .count = 1,
+                .info = alc_mux_enum_info,
+                .get = alc_mux_enum_get,
+                .put = alc_mux_enum_put,
+        },
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Channel Mode",
+                .info = alc_ch_mode_info,
+                .get = alc_ch_mode_get,
+                .put = alc_ch_mode_put,
+                .private_value = ARRAY_SIZE(alc861_asus_modes),
+        },
+        {0}
+};
+
+/* additional mixer */
+static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
+        HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x23, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("PC Beep Playback Switch", 0x23, 0x0, HDA_OUTPUT),
+        {0}
 };
 
@@ -5867 +6969 @@
  */
 static struct hda_verb alc861_base_init_verbs[] = {
-    /*
-     * Unmute ADC0 and set the default input to mic-in
-     */
-    /* port-A for surround (rear panel) */
-    { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
-    { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
-    /* port-B for mic-in (rear panel) with vref */
-    { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
-    /* port-C for line-in (rear panel) */
-    { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
-    /* port-D for Front */
-    { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
-    { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
-    /* port-E for HP out (front panel) */
-    { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
-    /* route front PCM to HP */
-    { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x01 },
-    /* port-F for mic-in (front panel) with vref */
-    { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
-    /* port-G for CLFE (rear panel) */
-    { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
-    { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
-    /* port-H for side (rear panel) */
-    { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
-    { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
-    /* CD-in */
-    { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
-    /* route front mic to ADC1*/
-    {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
-    {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-
-    /* Unmute DAC0~3 & spdif out*/
-    {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-
-    /* Unmute Mixer 14 (mic) 1c (Line in)*/
-    {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-
-    /* Unmute Stereo Mixer 15 */
-    {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
-    {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c          }, //Output 0~12 step
-
-    {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, // hp used DAC 3 (Front)
-    {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
-
-    {0}
+        /*
+         * Unmute ADC0 and set the default input to mic-in
+         */
+        /* port-A for surround (rear panel) */
+        { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
+        { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
+        /* port-B for mic-in (rear panel) with vref */
+        { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
+        /* port-C for line-in (rear panel) */
+        { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
+        /* port-D for Front */
+        { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
+        { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
+        /* port-E for HP out (front panel) */
+        { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
+        /* route front PCM to HP */
+        { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
+        /* port-F for mic-in (front panel) with vref */
+        { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
+        /* port-G for CLFE (rear panel) */
+        { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
+        { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
+        /* port-H for side (rear panel) */
+        { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
+        { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
+        /* CD-in */
+        { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
+        /* route front mic to ADC1*/
+        {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        
+        /* Unmute DAC0~3 & spdif out*/
+        {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        
+        /* Unmute Mixer 14 (mic) 1c (Line in)*/
+        {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        
+        /* Unmute Stereo Mixer 15 */
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c          }, //Output 0~12 step
+
+        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, // hp used DAC 3 (Front)
+        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
+
+        {0}
 };
 
 static struct hda_verb alc861_threestack_init_verbs[] = {
-    /*
-     * Unmute ADC0 and set the default input to mic-in
-     */
-    /* port-A for surround (rear panel) */
-    { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
-    /* port-B for mic-in (rear panel) with vref */
-    { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
-    /* port-C for line-in (rear panel) */
-    { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
-    /* port-D for Front */
-    { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
-    { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
-    /* port-E for HP out (front panel) */
-    { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
-    /* route front PCM to HP */
-    { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x01 },
-    /* port-F for mic-in (front panel) with vref */
-    { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
-    /* port-G for CLFE (rear panel) */
-    { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
-    /* port-H for side (rear panel) */
-    { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
-    /* CD-in */
-    { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
-    /* route front mic to ADC1*/
-    {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
-    {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    /* Unmute DAC0~3 & spdif out*/
-    {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-
-    /* Unmute Mixer 14 (mic) 1c (Line in)*/
-    {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-
-    /* Unmute Stereo Mixer 15 */
-    {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
-    {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c          }, //Output 0~12 step
-
-    {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, // hp used DAC 3 (Front)
-    {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
-    {0}
-};
+        /*
+         * Unmute ADC0 and set the default input to mic-in
+         */
+        /* port-A for surround (rear panel) */
+        { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
+        /* port-B for mic-in (rear panel) with vref */
+        { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
+        /* port-C for line-in (rear panel) */
+        { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
+        /* port-D for Front */
+        { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
+        { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
+        /* port-E for HP out (front panel) */
+        { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
+        /* route front PCM to HP */
+        { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
+        /* port-F for mic-in (front panel) with vref */
+        { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
+        /* port-G for CLFE (rear panel) */
+        { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
+        /* port-H for side (rear panel) */
+        { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
+        /* CD-in */
+        { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
+        /* route front mic to ADC1*/
+        {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        /* Unmute DAC0~3 & spdif out*/
+        {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        
+        /* Unmute Mixer 14 (mic) 1c (Line in)*/
+        {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        
+        /* Unmute Stereo Mixer 15 */
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c          }, //Output 0~12 step
+
+        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, // hp used DAC 3 (Front)
+        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
+        {0}
+};
+
+static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
+        /*
+         * Unmute ADC0 and set the default input to mic-in
+         */
+        /* port-A for surround (rear panel) */
+        { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
+        /* port-B for mic-in (rear panel) with vref */
+        { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
+        /* port-C for line-in (rear panel) */
+        { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
+        /* port-D for Front */
+        { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
+        { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
+        /* port-E for HP out (front panel) */
+        { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, // this has to be set to VREF80
+        /* route front PCM to HP */
+        { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
+        /* port-F for mic-in (front panel) with vref */
+        { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
+        /* port-G for CLFE (rear panel) */
+        { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
+        /* port-H for side (rear panel) */
+        { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
+        /* CD-in */
+        { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
+        /* route front mic to ADC1*/
+        {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        /* Unmute DAC0~3 & spdif out*/
+        {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        
+        /* Unmute Mixer 14 (mic) 1c (Line in)*/
+        {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        
+        /* Unmute Stereo Mixer 15 */
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c          }, //Output 0~12 step
+
+        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, // hp used DAC 3 (Front)
+        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
+        {0}
+};
+
+static struct hda_verb alc861_asus_init_verbs[] = {
+        /*
+         * Unmute ADC0 and set the default input to mic-in
+         */
+        /* port-A for surround (rear panel) | according to codec#0 this is the HP jack*/
+        { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
+        /* route front PCM to HP */
+        { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
+        /* port-B for mic-in (rear panel) with vref */
+        { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
+        /* port-C for line-in (rear panel) */
+        { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
+        /* port-D for Front */
+        { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
+        { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
+        /* port-E for HP out (front panel) */
+        { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, /* this has to be set to VREF80 */
+        /* route front PCM to HP */
+        { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
+        /* port-F for mic-in (front panel) with vref */
+        { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
+        /* port-G for CLFE (rear panel) */
+        { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
+        /* port-H for side (rear panel) */
+        { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
+        /* CD-in */
+        { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
+        /* route front mic to ADC1*/
+        {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        /* Unmute DAC0~3 & spdif out*/
+        {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        /* Unmute Mixer 14 (mic) 1c (Line in)*/
+        {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        
+        /* Unmute Stereo Mixer 15 */
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c          }, /* Output 0~12 step */
+
+        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, /* hp used DAC 3 (Front) */
+        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
+        {0}
+};
+
+/* additional init verbs for ASUS laptops */
+static struct hda_verb alc861_asus_laptop_init_verbs[] = {
+        { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
+        { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
+        {0}
+};
+
 /*
  * generic initialization of ADC, input mixers and output mixers
  */
 static struct hda_verb alc861_auto_init_verbs[] = {
-    /*
-     * Unmute ADC0 and set the default input to mic-in
-     */
-    //  {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
-    {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-
-    /* Unmute DAC0~3 & spdif out*/
-    {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-    {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-    {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-    {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-
-    /* Unmute Mixer 14 (mic) 1c (Line in)*/
-    {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-
-    /* Unmute Stereo Mixer 15 */
-    {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
-    {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
-
-    {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-    {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-    {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-
-    {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
-    {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
-    {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
-    {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-    {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
-    {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
-    {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
-
-    {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},      // set Mic 1
-
-    {0}
-};
+        /*
+         * Unmute ADC0 and set the default input to mic-in
+         */
+//      {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        
+        /* Unmute DAC0~3 & spdif out*/
+        {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        
+        /* Unmute Mixer 14 (mic) 1c (Line in)*/
+        {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        
+        /* Unmute Stereo Mixer 15 */
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
+
+        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+
+        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},    
+        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},            
+        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},    
+        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},    
+
+        {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},  // set Mic 1
+
+        {0}
+};
+
+static struct hda_verb alc861_toshiba_init_verbs[] = {
+        {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
+        
+        {0}
+};
+
+/* toggle speaker-output according to the hp-jack state */
+static void alc861_toshiba_automute(struct hda_codec *codec)
+{
+        unsigned int present;
+
+        present = snd_hda_codec_read(codec, 0x0f, 0,
+                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
+        snd_hda_codec_amp_update(codec, 0x16, 0, HDA_INPUT, 0,
+                                 0x80, present ? 0x80 : 0);
+        snd_hda_codec_amp_update(codec, 0x16, 1, HDA_INPUT, 0,
+                                 0x80, present ? 0x80 : 0);
+        snd_hda_codec_amp_update(codec, 0x1a, 0, HDA_INPUT, 3,
+                                 0x80, present ? 0 : 0x80);
+        snd_hda_codec_amp_update(codec, 0x1a, 1, HDA_INPUT, 3,
+                                 0x80, present ? 0 : 0x80);
+}
+
+static void alc861_toshiba_unsol_event(struct hda_codec *codec,
+                                       unsigned int res)
+{
+        /* Looks like the unsol event is incompatible with the standard
+         * definition.  6bit tag is placed at 26 bit!
+         */
+        if ((res >> 26) == ALC880_HP_EVENT)
+                alc861_toshiba_automute(codec);
+}
 
 /* pcm configuration: identiacal with ALC880 */
@@ -6052 +7316 @@
 
 static struct hda_channel_mode alc861_8ch_modes[1] = {
-    { 8, NULL }
+        { 8, NULL }
 };
 
 static hda_nid_t alc861_dac_nids[4] = {
-    /* front, surround, clfe, side */
-    0x03, 0x06, 0x05, 0x04
+        /* front, surround, clfe, side */
+        0x03, 0x06, 0x05, 0x04
 };
 
 static hda_nid_t alc660_dac_nids[3] = {
-    /* front, clfe, surround */
-    0x03, 0x05, 0x06
+        /* front, clfe, surround */
+        0x03, 0x05, 0x06
 };
 
 static hda_nid_t alc861_adc_nids[1] = {
-    /* ADC0-2 */
-    0x08,
+        /* ADC0-2 */
+        0x08,
 };
 
 static struct hda_input_mux alc861_capture_source = {
-    .num_items = 5,
-    .items = {
-        { "Mic", 0x0 },
-        { "Front Mic", 0x3 },
-        { "Line", 0x1 },
-        { "CD", 0x4 },
-        { "Mixer", 0x5 },
-    },
+        .num_items = 5,
+        .items = {
+                { "Mic", 0x0 },
+                { "Front Mic", 0x3 },
+                { "Line", 0x1 },
+                { "CD", 0x4 },
+                { "Mixer", 0x5 },
+        },
 };
 
@@ -6084 +7348 @@
 static int alc861_auto_fill_dac_nids(struct alc_spec *spec, const struct auto_pin_cfg *cfg)
 {
-    int i;
-    hda_nid_t nid;
-
-    spec->multiout.dac_nids = spec->private_dac_nids;
-    for (i = 0; i < cfg->line_outs; i++) {
-        nid = cfg->line_out_pins[i];
-        if (nid) {
-            if (i >= ARRAY_SIZE(alc861_dac_nids))
-                continue;
-            spec->multiout.dac_nids[i] = alc861_dac_nids[i];
-        }
-    }
-    spec->multiout.num_dacs = cfg->line_outs;
-    return 0;
+        int i;
+        hda_nid_t nid;
+
+        spec->multiout.dac_nids = spec->private_dac_nids;
+        for (i = 0; i < cfg->line_outs; i++) {
+                nid = cfg->line_out_pins[i];
+                if (nid) {
+                        if (i >= ARRAY_SIZE(alc861_dac_nids))
+                                continue;
+                        spec->multiout.dac_nids[i] = alc861_dac_nids[i];
+                }
+        }
+        spec->multiout.num_dacs = cfg->line_outs;
+        return 0;
 }
 
 /* add playback controls from the parsed DAC table */
 static int alc861_auto_create_multi_out_ctls(struct alc_spec *spec,
-                                             const struct auto_pin_cfg *cfg)
-{
-    char name[32];
-    static const char *chname[4] = { "Front", "Surround", NULL /*CLFE*/, "Side" };
-    hda_nid_t nid;
-    int i, idx, err;
-
-    for (i = 0; i < cfg->line_outs; i++) {
-        nid = spec->multiout.dac_nids[i];
-        if (! nid)
-            continue;
-        if (nid == 0x05) {
-            /* Center/LFE */
-            if ((err = add_control(spec, ALC_CTL_BIND_MUTE, "Center Playback Switch",
-                                   HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT))) < 0)
-                return err;
-            if ((err = add_control(spec, ALC_CTL_BIND_MUTE, "LFE Playback Switch",
-                                   HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT))) < 0)
-                return err;
-        } else {
-            for (idx = 0; idx < ARRAY_SIZE(alc861_dac_nids) - 1; idx++)
-                if (nid == alc861_dac_nids[idx])
-                    break;
-            sprintf(name, "%s Playback Switch", chname[idx]);
-            if ((err = add_control(spec, ALC_CTL_BIND_MUTE, name,
-                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
-                return err;
-        }
-    }
-    return 0;
+                                             const struct auto_pin_cfg *cfg)
+{
+        char name[32];
+        static const char *chname[4] = { "Front", "Surround", NULL /*CLFE*/, "Side" };
+        hda_nid_t nid;
+        int i, idx, err;
+
+        for (i = 0; i < cfg->line_outs; i++) {
+                nid = spec->multiout.dac_nids[i];
+                if (! nid)
+                        continue;
+                if (nid == 0x05) {
+                        /* Center/LFE */
+                        if ((err = add_control(spec, ALC_CTL_BIND_MUTE, "Center Playback Switch",
+                                               HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT))) < 0)
+                                return err;
+                        if ((err = add_control(spec, ALC_CTL_BIND_MUTE, "LFE Playback Switch",
+                                               HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT))) < 0)
+                                return err;
+                } else {
+                        for (idx = 0; idx < ARRAY_SIZE(alc861_dac_nids) - 1; idx++)
+                                if (nid == alc861_dac_nids[idx])
+                                        break;
+                        sprintf(name, "%s Playback Switch", chname[idx]);
+                        if ((err = add_control(spec, ALC_CTL_BIND_MUTE, name,
+                                               HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
+                                return err;
+                }
+        }
+        return 0;
 }
 
 static int alc861_auto_create_hp_ctls(struct alc_spec *spec, hda_nid_t pin)
 {
-    int err;
-    hda_nid_t nid;
-
-    if (! pin)
-        return 0;
-
-    if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
-        nid = 0x03;
-        if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, "Headphone Playback Switch",
-                               HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
-            return err;
-        spec->multiout.hp_nid = nid;
-    }
-    return 0;
+        int err;
+        hda_nid_t nid;
+
+        if (! pin)
+                return 0;
+
+        if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
+                nid = 0x03;
+                if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, "Headphone Playback Switch",
+                                       HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
+                        return err;
+                spec->multiout.hp_nid = nid;
+        }
+        return 0;
 }
 
@@ -6155 +7419 @@
 static int alc861_auto_create_analog_input_ctls(struct alc_spec *spec, const struct auto_pin_cfg *cfg)
 {
-    struct hda_input_mux *imux = &spec->private_imux;
-    int i, err, idx, idx1;
-
-    for (i = 0; i < AUTO_PIN_LAST; i++) {
-        switch(cfg->input_pins[i]) {
-        case 0x0c:
-            idx1 = 1;
-            idx = 2;    // Line In
-            break;
-        case 0x0f:
-            idx1 = 2;
-            idx = 2;    // Line In
-            break;
-        case 0x0d:
-            idx1 = 0;
-            idx = 1;    // Mic In
-            break;
-        case 0x10:
-            idx1 = 3;
-            idx = 1;    // Mic In
-            break;
-        case 0x11:
-            idx1 = 4;
-            idx = 0;    // CD
-            break;
-        default:
-            continue;
-        }
-
-        err = new_analog_input(spec, cfg->input_pins[i],
-                               auto_pin_cfg_labels[i], idx, 0x15);
-        if (err < 0)
-            return err;
-
-        imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
-        imux->items[imux->num_items].index = idx1;
-        imux->num_items++;
-    }
-    return 0;
+        struct hda_input_mux *imux = &spec->private_imux;
+        int i, err, idx, idx1;
+
+        for (i = 0; i < AUTO_PIN_LAST; i++) {
+                switch(cfg->input_pins[i]) {
+                case 0x0c:
+                        idx1 = 1;
+                        idx = 2;        // Line In
+                        break;
+                case 0x0f:
+                        idx1 = 2;
+                        idx = 2;        // Line In
+                        break;
+                case 0x0d:
+                        idx1 = 0;
+                        idx = 1;        // Mic In 
+                        break;
+                case 0x10:      
+                        idx1 = 3;
+                        idx = 1;        // Mic In 
+                        break;
+                case 0x11:
+                        idx1 = 4;
+                        idx = 0;        // CD
+                        break;
+                default:
+                        continue;
+                }
+
+                err = new_analog_input(spec, cfg->input_pins[i],
+                                       auto_pin_cfg_labels[i], idx, 0x15);
+                if (err < 0)
+                        return err;
+
+                imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
+                imux->items[imux->num_items].index = idx1;
+                imux->num_items++;      
+        }
+        return 0;
 }
 
 static struct snd_kcontrol_new alc861_capture_mixer[] = {
-    HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
-
-    {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        /* The multiple "Capture Source" controls confuse alsamixer
-         * So call somewhat different..
-         *FIXME: the controls appear in the "playback" view!
-         */
-        /* .name = "Capture Source", */
-        .name = "Input Source",
-        .count = 1,
-        .info = alc_mux_enum_info,
-        .get = alc_mux_enum_get,
-        .put = alc_mux_enum_put,
-    },
-    {0} /* end */
+        HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
+
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                /* The multiple "Capture Source" controls confuse alsamixer
+                 * So call somewhat different..
+                 *FIXME: the controls appear in the "playback" view!
+                 */
+                /* .name = "Capture Source", */
+                .name = "Input Source",
+                .count = 1,
+                .info = alc_mux_enum_info,
+                .get = alc_mux_enum_get,
+                .put = alc_mux_enum_put,
+        },
+        {0} /* end */
 };
 
 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec, hda_nid_t nid,
-                                              int pin_type, int dac_idx)
-{
-    /* set as output */
-
-    snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
-    snd_hda_codec_write(codec, dac_idx, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
+                                              int pin_type, int dac_idx)
+{
+        /* set as output */
+
+        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
+        snd_hda_codec_write(codec, dac_idx, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
 
 }
@@ -6228 +7492 @@
 static void alc861_auto_init_multi_out(struct hda_codec *codec)
 {
-    struct alc_spec *spec = codec->spec;
-    int i;
-
-    for (i = 0; i < spec->autocfg.line_outs; i++) {
-        hda_nid_t nid = spec->autocfg.line_out_pins[i];
-        if (nid)
-            alc861_auto_set_output_and_unmute(codec, nid, PIN_OUT, spec->multiout.dac_nids[i]);
-    }
+        struct alc_spec *spec = codec->spec;
+        int i;
+
+        for (i = 0; i < spec->autocfg.line_outs; i++) {
+                hda_nid_t nid = spec->autocfg.line_out_pins[i];
+                if (nid)
+                        alc861_auto_set_output_and_unmute(codec, nid, PIN_OUT, spec->multiout.dac_nids[i]);
+        }
 }
 
 static void alc861_auto_init_hp_out(struct hda_codec *codec)
 {
-    struct alc_spec *spec = codec->spec;
-    hda_nid_t pin;
-
-    pin = spec->autocfg.hp_pin;
-    if (pin) /* connect to front */
-        alc861_auto_set_output_and_unmute(codec, pin, PIN_HP, spec->multiout.dac_nids[0]);
+        struct alc_spec *spec = codec->spec;
+        hda_nid_t pin;
+
+        pin = spec->autocfg.hp_pins[0];
+        if (pin) /* connect to front */
+                alc861_auto_set_output_and_unmute(codec, pin, PIN_HP, spec->multiout.dac_nids[0]);
 }
 
 static void alc861_auto_init_analog_input(struct hda_codec *codec)
 {
-    struct alc_spec *spec = codec->spec;
-    int i;
-
-    for (i = 0; i < AUTO_PIN_LAST; i++) {
-        hda_nid_t nid = spec->autocfg.input_pins[i];
-        if ((nid>=0x0c) && (nid <=0x11)) {
-            snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
-                                i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN);
-        }
-    }
+        struct alc_spec *spec = codec->spec;
+        int i;
+
+        for (i = 0; i < AUTO_PIN_LAST; i++) {
+                hda_nid_t nid = spec->autocfg.input_pins[i];
+                if ((nid>=0x0c) && (nid <=0x11)) {
+                        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
+                                            i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN);
+                }
+        }
 }
 
@@ -6266 +7530 @@
 static int alc861_parse_auto_config(struct hda_codec *codec)
 {
-    struct alc_spec *spec = codec->spec;
-    int err;
-    static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
-
-    if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
-                                            alc861_ignore)) < 0)
-        return err;
-    if (! spec->autocfg.line_outs)
-        return 0; /* can't find valid BIOS pin config */
-
-    if ((err = alc861_auto_fill_dac_nids(spec, &spec->autocfg)) < 0 ||
-        (err = alc861_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0 ||
-        (err = alc861_auto_create_hp_ctls(spec, spec->autocfg.hp_pin)) < 0 ||
-        (err = alc861_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0)
-        return err;
-
-    spec->multiout.max_channels = spec->multiout.num_dacs * 2;
-
-    if (spec->autocfg.dig_out_pin)
-        spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
-
-    if (spec->kctl_alloc)
-        spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
-
-    spec->init_verbs[spec->num_init_verbs++] = alc861_auto_init_verbs;
-
-    spec->input_mux = &spec->private_imux;
-
-    spec->adc_nids = alc861_adc_nids;
-    spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
-    spec->mixers[spec->num_mixers] = alc861_capture_mixer;
-    spec->num_mixers++;
-
-    return 1;
+        struct alc_spec *spec = codec->spec;
+        int err;
+        static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
+
+        if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
+                                                alc861_ignore)) < 0)
+                return err;
+        if (! spec->autocfg.line_outs)
+                return 0; /* can't find valid BIOS pin config */
+
+        if ((err = alc861_auto_fill_dac_nids(spec, &spec->autocfg)) < 0 ||
+            (err = alc861_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0 ||
+            (err = alc861_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0])) < 0 ||
+            (err = alc861_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0)
+                return err;
+
+        spec->multiout.max_channels = spec->multiout.num_dacs * 2;
+
+        if (spec->autocfg.dig_out_pin)
+                spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
+
+        if (spec->kctl_alloc)
+                spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
+
+        spec->init_verbs[spec->num_init_verbs++] = alc861_auto_init_verbs;
+
+        spec->num_mux_defs = 1;
+        spec->input_mux = &spec->private_imux;
+
+        spec->adc_nids = alc861_adc_nids;
+        spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
+        spec->mixers[spec->num_mixers] = alc861_capture_mixer;
+        spec->num_mixers++;
+
+        return 1;
 }
 
@@ -6305 +7570 @@
 static void alc861_auto_init(struct hda_codec *codec)
 {
-    alc861_auto_init_multi_out(codec);
-    alc861_auto_init_hp_out(codec);
-    alc861_auto_init_analog_input(codec);
-
+        alc861_auto_init_multi_out(codec);
+        alc861_auto_init_hp_out(codec);
+        alc861_auto_init_analog_input(codec);
 }
 
@@ -6315 +7579 @@
  * configuration and preset
  */
-static struct hda_board_config alc861_cfg_tbl[] = {
-    { .modelname = "3stack", .config = ALC861_3ST },
-    { .pci_subvendor = 0x8086, .pci_subdevice = 0xd600,
-    .config = ALC861_3ST },
-    { .pci_subvendor = 0x1043, .pci_subdevice = 0x81e7,
-    .config = ALC660_3ST },
-    { .modelname = "3stack-dig", .config = ALC861_3ST_DIG },
-    { .modelname = "6stack-dig", .config = ALC861_6ST_DIG },
-    { .modelname = "auto", .config = ALC861_AUTO },
-    {0}
+static const char *alc861_models[ALC861_MODEL_LAST] = {
+        [ALC861_3ST]            = "3stack",
+        [ALC660_3ST]            = "3stack-660",
+        [ALC861_3ST_DIG]        = "3stack-dig",
+        [ALC861_6ST_DIG]        = "6stack-dig",
+        [ALC861_UNIWILL_M31]    = "uniwill-m31",
+        [ALC861_TOSHIBA]        = "toshiba",
+        [ALC861_ASUS]           = "asus",
+        [ALC861_ASUS_LAPTOP]    = "asus-laptop",
+        [ALC861_AUTO]           = "auto",
+};
+
+static struct snd_pci_quirk alc861_cfg_tbl[] = {
+    SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
+        SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
+        SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
+        SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
+        SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660_3ST),
+        SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
+        SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA),
+        SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
+        SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
+        {0}
 };
 
 static struct alc_config_preset alc861_presets[] = {
-    [ALC861_3ST] = {
-        .mixers = { alc861_3ST_mixer },
-        .init_verbs = { alc861_threestack_init_verbs },
-        .num_dacs = ARRAY_SIZE(alc861_dac_nids),
-        .dac_nids = alc861_dac_nids,
-        .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
-        .channel_mode = alc861_threestack_modes,
-        .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
-        .adc_nids = alc861_adc_nids,
-        .input_mux = &alc861_capture_source,
-    },
-    [ALC861_3ST_DIG] = {
-        .mixers = { alc861_base_mixer },
-        .init_verbs = { alc861_threestack_init_verbs },
-        .num_dacs = ARRAY_SIZE(alc861_dac_nids),
-        .dac_nids = alc861_dac_nids,
-        .dig_out_nid = ALC861_DIGOUT_NID,
-        .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
-        .channel_mode = alc861_threestack_modes,
-        .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
-        .adc_nids = alc861_adc_nids,
-        .input_mux = &alc861_capture_source,
-    },
-    [ALC861_6ST_DIG] = {
-        .mixers = { alc861_base_mixer },
-        .init_verbs = { alc861_base_init_verbs },
-        .num_dacs = ARRAY_SIZE(alc861_dac_nids),
-        .dac_nids = alc861_dac_nids,
-        .dig_out_nid = ALC861_DIGOUT_NID,
-        .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
-        .channel_mode = alc861_8ch_modes,
-        .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
-        .adc_nids = alc861_adc_nids,
-        .input_mux = &alc861_capture_source,
-    },
-    [ALC660_3ST] = {
-        .mixers = { alc861_3ST_mixer },
-        .init_verbs = { alc861_threestack_init_verbs },
-        .num_dacs = ARRAY_SIZE(alc660_dac_nids),
-        .dac_nids = alc660_dac_nids,
-        .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
-        .channel_mode = alc861_threestack_modes,
-        .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
-        .adc_nids = alc861_adc_nids,
-        .input_mux = &alc861_capture_source,
-    },
+        [ALC861_3ST] = {
+                .mixers = { alc861_3ST_mixer },
+                .init_verbs = { alc861_threestack_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc861_dac_nids),
+                .dac_nids = alc861_dac_nids,
+                .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
+                .channel_mode = alc861_threestack_modes,
+                .need_dac_fix = 1,
+                .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
+                .adc_nids = alc861_adc_nids,
+                .input_mux = &alc861_capture_source,
+        },
+        [ALC861_3ST_DIG] = {
+                .mixers = { alc861_base_mixer },
+                .init_verbs = { alc861_threestack_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc861_dac_nids),
+                .dac_nids = alc861_dac_nids,
+                .dig_out_nid = ALC861_DIGOUT_NID,
+                .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
+                .channel_mode = alc861_threestack_modes,
+                .need_dac_fix = 1,
+                .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
+                .adc_nids = alc861_adc_nids,
+                .input_mux = &alc861_capture_source,
+        },
+        [ALC861_6ST_DIG] = {
+                .mixers = { alc861_base_mixer },
+                .init_verbs = { alc861_base_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc861_dac_nids),
+                .dac_nids = alc861_dac_nids,
+                .dig_out_nid = ALC861_DIGOUT_NID,
+                .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
+                .channel_mode = alc861_8ch_modes,
+                .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
+                .adc_nids = alc861_adc_nids,
+                .input_mux = &alc861_capture_source,
+        },
+        [ALC660_3ST] = {
+                .mixers = { alc861_3ST_mixer },
+                .init_verbs = { alc861_threestack_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc660_dac_nids),
+                .dac_nids = alc660_dac_nids,
+                .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
+                .channel_mode = alc861_threestack_modes,
+                .need_dac_fix = 1,
+                .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
+                .adc_nids = alc861_adc_nids,
+                .input_mux = &alc861_capture_source,
+        },
+        [ALC861_UNIWILL_M31] = {
+                .mixers = { alc861_uniwill_m31_mixer },
+                .init_verbs = { alc861_uniwill_m31_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc861_dac_nids),
+                .dac_nids = alc861_dac_nids,
+                .dig_out_nid = ALC861_DIGOUT_NID,
+                .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
+                .channel_mode = alc861_uniwill_m31_modes,
+                .need_dac_fix = 1,
+                .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
+                .adc_nids = alc861_adc_nids,
+                .input_mux = &alc861_capture_source,
+        },
+        [ALC861_TOSHIBA] = {
+                .mixers = { alc861_toshiba_mixer },
+                .init_verbs = { alc861_base_init_verbs, alc861_toshiba_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc861_dac_nids),
+                .dac_nids = alc861_dac_nids,
+                .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
+                .channel_mode = alc883_3ST_2ch_modes,
+                .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
+                .adc_nids = alc861_adc_nids,
+                .input_mux = &alc861_capture_source,
+                .unsol_event = alc861_toshiba_unsol_event,
+                .init_hook = alc861_toshiba_automute,
+        },
+        [ALC861_ASUS] = {
+                .mixers = { alc861_asus_mixer },
+                .init_verbs = { alc861_asus_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc861_dac_nids),
+                .dac_nids = alc861_dac_nids,
+                .dig_out_nid = ALC861_DIGOUT_NID,
+                .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
+                .channel_mode = alc861_asus_modes,
+                .need_dac_fix = 1,
+                .hp_nid = 0x06,
+                .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
+                .adc_nids = alc861_adc_nids,
+                .input_mux = &alc861_capture_source,
+        },
+        [ALC861_ASUS_LAPTOP] = {
+                .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
+                .init_verbs = { alc861_asus_init_verbs,
+                                alc861_asus_laptop_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc861_dac_nids),
+                .dac_nids = alc861_dac_nids,
+                .dig_out_nid = ALC861_DIGOUT_NID,
+                .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
+                .channel_mode = alc883_3ST_2ch_modes,
+                .need_dac_fix = 1,
+                .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
+                .adc_nids = alc861_adc_nids,
+                .input_mux = &alc861_capture_source,
+        },
 };
 
@@ -6379 +7713 @@
 static int patch_alc861(struct hda_codec *codec)
 {
-    struct alc_spec *spec;
-    int board_config;
-    int err;
-
-    spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
-    if (spec == NULL)
-        return -ENOMEM;
-
-    codec->spec = spec;
-
-    board_config = snd_hda_check_board_config(codec, alc861_cfg_tbl);
-    if (board_config < 0 || board_config >= ALC861_MODEL_LAST) {
-        printk(KERN_INFO "hda_codec: Unknown model for ALC861, trying auto-probe from BIOS...\n");
-        board_config = ALC861_AUTO;
-    }
-
-    if (board_config == ALC861_AUTO) {
-        /* automatic parse from the BIOS config */
-        err = alc861_parse_auto_config(codec);
-        if (err < 0) {
-            alc_free(codec);
-            return err;
-        } else if (! err) {
-            printk(KERN_INFO "hda_codec: Cannot set up configuration from BIOS.  Using base mode...\n");
-            board_config = ALC861_3ST_DIG;
-        }
-    }
-
-    if (board_config != ALC861_AUTO)
-        setup_preset(spec, &alc861_presets[board_config]);
-
-    spec->stream_name_analog = "ALC861 Analog";
-    spec->stream_analog_playback = &alc861_pcm_analog_playback;
-    spec->stream_analog_capture = &alc861_pcm_analog_capture;
-
-    spec->stream_name_digital = "ALC861 Digital";
-    spec->stream_digital_playback = &alc861_pcm_digital_playback;
-    spec->stream_digital_capture = &alc861_pcm_digital_capture;
-
-    codec->patch_ops = alc_patch_ops;
-    if (board_config == ALC861_AUTO)
-        spec->init_hook = alc861_auto_init;
-
-    return 0;
+        struct alc_spec *spec;
+        int board_config;
+        int err;
+
+        spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
+        if (spec == NULL)
+                return -ENOMEM;
+
+        codec->spec = spec;     
+
+        board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
+                                                  alc861_models,
+                                                  alc861_cfg_tbl);
+
+        if (board_config < 0) {
+                printk(KERN_INFO "hda_codec: Unknown model for ALC861, "
+                       "trying auto-probe from BIOS...\n");
+                board_config = ALC861_AUTO;
+        }
+
+        if (board_config == ALC861_AUTO) {
+                /* automatic parse from the BIOS config */
+                err = alc861_parse_auto_config(codec);
+                if (err < 0) {
+                        alc_free(codec);
+                        return err;
+                } else if (! err) {
+                        printk(KERN_INFO
+                               "hda_codec: Cannot set up configuration "
+                               "from BIOS.  Using base mode...\n");
+                   board_config = ALC861_3ST_DIG;
+                }
+        }
+
+        if (board_config != ALC861_AUTO)
+                setup_preset(spec, &alc861_presets[board_config]);
+
+        spec->stream_name_analog = "ALC861 Analog";
+        spec->stream_analog_playback = &alc861_pcm_analog_playback;
+        spec->stream_analog_capture = &alc861_pcm_analog_capture;
+
+        spec->stream_name_digital = "ALC861 Digital";
+        spec->stream_digital_playback = &alc861_pcm_digital_playback;
+        spec->stream_digital_capture = &alc861_pcm_digital_capture;
+
+        codec->patch_ops = alc_patch_ops;
+        if (board_config == ALC861_AUTO)
+                spec->init_hook = alc861_auto_init;
+                
+        return 0;
 }
 
@@ -6429 +7769 @@
  */
 struct hda_codec_preset snd_hda_preset_realtek[] = {
-    { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
-    { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
-    { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
-    { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
-    { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc883 },
-    { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
-    { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc883 },
-    { .id = 0x10ec0861, .rev = 0x100300, .name = "ALC861",
-    .patch = patch_alc861 },
-    { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
-    .patch = patch_alc861 },
-    {0} /* terminator */
-};
+        { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
+        { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
+        { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
+        { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
+        { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc883 },
+        { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
+        { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc883 },
+        { .id = 0x10ec0861, .rev = 0x100300, .name = "ALC861",
+          .patch = patch_alc861 },
+        { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
+          .patch = patch_alc861 },
+        { .id = 0x10ec0660, .name = "ALC660", .patch = patch_alc861 },
+        {0} /* terminator */
+};

GPL/trunk/alsa-kernel/pci/hda/patch_sigmatel.c

@@ -37 +37 @@
 #define NUM_CONTROL_ALLOC       32
 #define STAC_HP_EVENT           0x37
-#define STAC_UNSOL_ENABLE       (AC_USRSP_EN | STAC_HP_EVENT)
-
-#define STAC_REF                0
-#define STAC_D945GTP3           1
-#define STAC_D945GTP5           2
-#define STAC_MACMINI            3
-#define STAC_D965_2112          4
-#define STAC_D965_284B          5
-#define STAC_922X_MODELS        6       /* number of 922x models */
+
+#define PCI_VENDOR_ID_DELL              0x1028
+
+enum {
+        STAC_REF,
+        STAC_9200_MODELS
+};
+
+enum {
+        STAC_9205_REF,
+        STAC_9205_MODELS
+};
+
+enum {
+        STAC_D945_REF,
+        STAC_D945GTP3,
+        STAC_D945GTP5,
+        STAC_MACMINI,
+        STAC_922X_MODELS
+};
+
+enum {
+        STAC_D965_REF,
+        STAC_D965_3ST,
+        STAC_D965_5ST,
+        STAC_927X_MODELS
+};
 
 struct sigmatel_spec {
@@ -54 +72 @@
         unsigned int surr_switch: 1;
         unsigned int line_switch: 1;
-        unsigned int mic_switch: 1;
-        unsigned int alt_switch: 1;
-        unsigned int hp_detect: 1;
-        unsigned int gpio_mute: 1;
+        unsigned int mic_switch: 1;
+        unsigned int alt_switch: 1;
+        unsigned int hp_detect: 1;
+        unsigned int gpio_mute: 1;
 
         /* playback */
-        struct hda_multi_out multiout;
-        hda_nid_t dac_nids[5];
+        struct hda_multi_out multiout;
+        hda_nid_t dac_nids[5];
 
         /* capture */
@@ -68 +86 @@
         hda_nid_t *mux_nids;
         unsigned int num_muxes;
+        hda_nid_t *dmic_nids;
+        unsigned int num_dmics;
+        hda_nid_t dmux_nid;
         hda_nid_t dig_in_nid;
 
@@ -74 +95 @@
         unsigned int num_pins;
         unsigned int *pin_configs;
+        unsigned int *bios_pin_configs;
 
         /* codec specific stuff */
@@ -80 +102 @@
 
         /* capture source */
-        struct hda_input_mux *input_mux;
-        unsigned int cur_mux[3];
+        struct hda_input_mux *dinput_mux;
+        unsigned int cur_dmux;
+        struct hda_input_mux *input_mux;
+        unsigned int cur_mux[3];
 
         /* i/o switches */
@@ -92 +116 @@
         unsigned int num_kctl_alloc, num_kctl_used;
         struct snd_kcontrol_new *kctl_alloc;
+        struct hda_input_mux private_dimux;
         struct hda_input_mux private_imux;
 };
@@ -111 +136 @@
 };
 
-static hda_nid_t stac9227_adc_nids[2] = {
-        0x07, 0x08,
-};
-
-#if 0
-static hda_nid_t d965_2112_dac_nids[3] = {
-        0x02, 0x03, 0x05,
-};
-#endif
-
 static hda_nid_t stac922x_mux_nids[2] = {
-    0x12, 0x13,
-};
-
-static hda_nid_t stac9227_mux_nids[2] = {
-        0x15, 0x16,
+        0x12, 0x13,
 };
 
 static hda_nid_t stac927x_adc_nids[3] = {
-    0x07, 0x08, 0x09
+        0x07, 0x08, 0x09
 };
 
 static hda_nid_t stac927x_mux_nids[3] = {
-    0x15, 0x16, 0x17
+        0x15, 0x16, 0x17
+};
+
+static hda_nid_t stac9205_adc_nids[2] = {
+        0x12, 0x13
+};
+
+static hda_nid_t stac9205_mux_nids[2] = {
+        0x19, 0x1a
+};
+
+static hda_nid_t stac9205_dmic_nids[3] = {
+        0x17, 0x18, 0
 };
 
 static hda_nid_t stac9200_pin_nids[8] = {
-        0x08, 0x09, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12,
+        0x08, 0x09, 0x0d, 0x0e, 
+        0x0f, 0x10, 0x11, 0x12,
 };
 
@@ -147 +171 @@
 
 static hda_nid_t stac927x_pin_nids[14] = {
-    0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
-    0x0f, 0x10, 0x11, 0x12, 0x13,
-    0x14, 0x21, 0x22, 0x23,
-};
+        0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
+        0x0f, 0x10, 0x11, 0x12, 0x13,
+        0x14, 0x21, 0x22, 0x23,
+};
+
+static hda_nid_t stac9205_pin_nids[12] = {
+        0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
+        0x0f, 0x14, 0x16, 0x17, 0x18,
+        0x21, 0x22,
+        
+};
+
+static int stac92xx_dmux_enum_info(struct snd_kcontrol *kcontrol,
+                                   struct snd_ctl_elem_info *uinfo)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct sigmatel_spec *spec = codec->spec;
+        return snd_hda_input_mux_info(spec->dinput_mux, uinfo);
+}
+
+static int stac92xx_dmux_enum_get(struct snd_kcontrol *kcontrol,
+                                  struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct sigmatel_spec *spec = codec->spec;
+
+        ucontrol->value.enumerated.item[0] = spec->cur_dmux;
+        return 0;
+}
+
+static int stac92xx_dmux_enum_put(struct snd_kcontrol *kcontrol,
+                                  struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct sigmatel_spec *spec = codec->spec;
+
+        return snd_hda_input_mux_put(codec, spec->dinput_mux, ucontrol,
+                                     spec->dmux_nid, &spec->cur_dmux);
+}
 
 static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
@@ -186 +245 @@
 
 static struct hda_verb stac922x_core_init[] = {
-        /* set master volume and direct control */
-    { 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
-    {0}
-};
-
-static struct hda_verb stac9227_core_init[] = {
-        /* set master volume and direct control */
+        /* set master volume and direct control */      
         { 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
+        {0}
+};
+
+static struct hda_verb d965_core_init[] = {
+        /* set master volume and direct control */      
+        { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
         /* unmute node 0x1b */
         { 0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
-        {0}
-};
-
-static struct hda_verb d965_2112_core_init[] = {
-        /* set master volume and direct control */
-        { 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
-        /* unmute node 0x1b */
-        { 0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
-        /* select node 0x03 as DAC */
+        /* select node 0x03 as DAC */   
         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
         {0}
@@ -210 +261 @@
 
 static struct hda_verb stac927x_core_init[] = {
-    /* set master volume and direct control */
-    { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
-    {0}
+        /* set master volume and direct control */      
+        { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
+        {0}
+};
+
+static struct hda_verb stac9205_core_init[] = {
+        /* set master volume and direct control */      
+        { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
+        {0}
 };
 
@@ -263 +320 @@
 };
 
-static snd_kcontrol_new_t stac927x_mixer[] = {
-    {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "Input Source",
-        .count = 1,
-        .info = stac92xx_mux_enum_info,
-        .get = stac92xx_mux_enum_get,
-        .put = stac92xx_mux_enum_put,
-    },
-    HDA_CODEC_VOLUME("InMux Capture Volume", 0x15, 0x0, HDA_OUTPUT),
-    HDA_CODEC_VOLUME("InVol Capture Volume", 0x18, 0x0, HDA_INPUT),
-    HDA_CODEC_MUTE("ADCMux Capture Switch", 0x1b, 0x0, HDA_OUTPUT),
-    {0} /* end */
+static struct snd_kcontrol_new stac927x_mixer[] = {
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Input Source",
+                .count = 1,
+                .info = stac92xx_mux_enum_info,
+                .get = stac92xx_mux_enum_get,
+                .put = stac92xx_mux_enum_put,
+        },
+        HDA_CODEC_VOLUME("InMux Capture Volume", 0x15, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("InVol Capture Volume", 0x18, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("ADCMux Capture Switch", 0x1b, 0x0, HDA_OUTPUT),
+        {0} /* end */
+};
+
+static struct snd_kcontrol_new stac9205_mixer[] = {
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Digital Input Source",
+                .count = 1,
+                .info = stac92xx_dmux_enum_info,
+                .get = stac92xx_dmux_enum_get,
+                .put = stac92xx_dmux_enum_put,
+        },
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Input Source",
+                .count = 1,
+                .info = stac92xx_mux_enum_info,
+                .get = stac92xx_mux_enum_get,
+                .put = stac92xx_mux_enum_put,
+        },
+        HDA_CODEC_VOLUME("InMux Capture Volume", 0x19, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("InVol Capture Volume", 0x1b, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("ADCMux Capture Switch", 0x1d, 0x0, HDA_OUTPUT),
+        {0} /* end */
 };
 
@@ -304 +384 @@
                         return err;
         }
-        return 0;
+        return 0;       
 }
 
@@ -312 +392 @@
 };
 
-static unsigned int *stac9200_brd_tbl[] = {
-        ref9200_pin_configs,
-};
-
-static struct hda_board_config stac9200_cfg_tbl[] = {
-        { .modelname = "ref",
-          .pci_subvendor = PCI_VENDOR_ID_INTEL,
-          .pci_subdevice = 0x2668,      /* DFI LanParty */
-          .config = STAC_REF },
+static unsigned int *stac9200_brd_tbl[STAC_9200_MODELS] = {
+        [STAC_REF] = ref9200_pin_configs,
+};
+
+static const char *stac9200_models[STAC_9200_MODELS] = {
+        [STAC_REF] = "ref",
+};
+
+static struct snd_pci_quirk stac9200_cfg_tbl[] = {
+        /* SigmaTel reference board */
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
+                      "DFI LanParty", STAC_REF),
+        /* Dell laptops have BIOS problem */
+        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01b5,
+                      "Dell Inspiron 630m", STAC_REF),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c2,
+                      "Dell Latitude D620", STAC_REF),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cb,
+                      "Dell Latitude 120L", STAC_REF),
         {0} /* terminator */
 };
@@ -331 +421 @@
 
 static unsigned int d945gtp3_pin_configs[10] = {
-    0x0221401f, 0x01a19022, 0x01813021, 0x01014010,
-    0x40000100, 0x40000100, 0x40000100, 0x40000100,
-    0x02a19120, 0x40000100,
+        0x0221401f, 0x01a19022, 0x01813021, 0x01014010,
+        0x40000100, 0x40000100, 0x40000100, 0x40000100,
+        0x02a19120, 0x40000100,
 };
 
 static unsigned int d945gtp5_pin_configs[10] = {
-    0x0221401f, 0x01011012, 0x01813024, 0x01014010,
-    0x01a19021, 0x01016011, 0x01452130, 0x40000100,
-    0x02a19320, 0x40000100,
-};
-
-static unsigned int d965_2112_pin_configs[10] = {
-        0x0221401f, 0x40000100, 0x40000100, 0x01014011,
-        0x01a19021, 0x01813024, 0x01452130, 0x40000100,
+        0x0221401f, 0x01011012, 0x01813024, 0x01014010,
+        0x01a19021, 0x01016011, 0x01452130, 0x40000100,
         0x02a19320, 0x40000100,
 };
 
 static unsigned int *stac922x_brd_tbl[STAC_922X_MODELS] = {
-        [STAC_REF] =    ref922x_pin_configs,
+        [STAC_D945_REF] = ref922x_pin_configs,
         [STAC_D945GTP3] = d945gtp3_pin_configs,
         [STAC_D945GTP5] = d945gtp5_pin_configs,
-        [STAC_D965_2112] = d965_2112_pin_configs,
-};
-
-static struct hda_board_config stac922x_cfg_tbl[] = {
-        { .modelname = "ref",
-          .pci_subvendor = PCI_VENDOR_ID_INTEL,
-          .pci_subdevice = 0x2668,      /* DFI LanParty */
-          .config = STAC_REF },         /* SigmaTel reference board */
-        { .pci_subvendor = PCI_VENDOR_ID_INTEL,
-          .pci_subdevice = 0x0101,
-          .config = STAC_D945GTP3 },    /* Intel D945GTP - 3 Stack */
-          { .pci_subvendor = PCI_VENDOR_ID_INTEL,
-          .pci_subdevice = 0x0202,
-          .config = STAC_D945GTP3 },    /* Intel D945GNT - 3 Stack, 9221 A1 */
-          { .pci_subvendor = PCI_VENDOR_ID_INTEL,
-          .pci_subdevice = 0x0b0b,
-          .config = STAC_D945GTP3 },    /* Intel D945PSN - 3 Stack, 9221 A1 */
-          { .pci_subvendor = PCI_VENDOR_ID_INTEL,
-          .pci_subdevice = 0x0404,
-          .config = STAC_D945GTP5 },    /* Intel D945GTP - 5 Stack */
-        { .pci_subvendor = PCI_VENDOR_ID_INTEL,
-          .pci_subdevice = 0x0303,
-          .config = STAC_D945GTP5 },    /* Intel D945GNT - 5 Stack */
-        { .pci_subvendor = PCI_VENDOR_ID_INTEL,
-          .pci_subdevice = 0x0013,
-          .config = STAC_D945GTP5 },    /* Intel D955XBK - 5 Stack */
-        { .pci_subvendor = PCI_VENDOR_ID_INTEL,
-          .pci_subdevice = 0x0417,
-          .config = STAC_D945GTP5 },    /* Intel D975XBK - 5 Stack */
-          { .pci_subvendor = 0x8384,
-          .pci_subdevice = 0x7680,
-          .config = STAC_MACMINI },     /* Apple Mac Mini (early 2006) */
-          { .pci_subvendor = PCI_VENDOR_ID_INTEL,
-          .pci_subdevice = 0x2112,
-          .config = STAC_D965_2112 },
-        { .pci_subvendor = PCI_VENDOR_ID_INTEL,
-          .pci_subdevice = 0x284b,
-          .config = STAC_D965_284B },
+        [STAC_MACMINI] = d945gtp5_pin_configs,
+};
+
+static const char *stac922x_models[STAC_922X_MODELS] = {
+        [STAC_D945_REF] = "ref",
+        [STAC_D945GTP5] = "5stack",
+        [STAC_D945GTP3] = "3stack",
+        [STAC_MACMINI]  = "macmini",
+};
+
+static struct snd_pci_quirk stac922x_cfg_tbl[] = {
+        /* SigmaTel reference board */
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
+                      "DFI LanParty", STAC_D945_REF),
+        /* Intel 945G based systems */
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101,
+                      "Intel D945G", STAC_D945GTP3),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0202,
+                      "Intel D945G", STAC_D945GTP3),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0606,
+                      "Intel D945G", STAC_D945GTP3),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0601,
+                      "Intel D945G", STAC_D945GTP3),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0111,
+                      "Intel D945G", STAC_D945GTP3),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1115,
+                      "Intel D945G", STAC_D945GTP3),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1116,
+                      "Intel D945G", STAC_D945GTP3),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1117,
+                      "Intel D945G", STAC_D945GTP3),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1118,
+                      "Intel D945G", STAC_D945GTP3),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1119,
+                      "Intel D945G", STAC_D945GTP3),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x8826,
+                      "Intel D945G", STAC_D945GTP3),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5049,
+                      "Intel D945G", STAC_D945GTP3),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5055,
+                      "Intel D945G", STAC_D945GTP3),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5048,
+                      "Intel D945G", STAC_D945GTP3),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0110,
+                      "Intel D945G", STAC_D945GTP3),
+        /* Intel D945G 5-stack systems */
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0404,
+                      "Intel D945G", STAC_D945GTP5),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0303,
+                      "Intel D945G", STAC_D945GTP5),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0013,
+                      "Intel D945G", STAC_D945GTP5),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0417,
+                      "Intel D945G", STAC_D945GTP5),
+        /* Intel 945P based systems */
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0b0b,
+                      "Intel D945P", STAC_D945GTP3),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0112,
+                      "Intel D945P", STAC_D945GTP3),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0d0d,
+                      "Intel D945P", STAC_D945GTP3),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0909,
+                      "Intel D945P", STAC_D945GTP3),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0505,
+                      "Intel D945P", STAC_D945GTP3),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707,
+                      "Intel D945P", STAC_D945GTP5),
+        /* other systems  */
+        /* Apple Mac Mini (early 2006) */
+        SND_PCI_QUIRK(0x8384, 0x7680,
+                      "Mac Mini", STAC_MACMINI),
         {0} /* terminator */
 };
 
 static unsigned int ref927x_pin_configs[14] = {
-    0x01813122, 0x01a19021, 0x01014010, 0x01016011,
-    0x01012012, 0x01011014, 0x40000100, 0x40000100,
-    0x40000100, 0x40000100, 0x40000100, 0x01441030,
-    0x01c41030, 0x40000100,
-};
-
-static unsigned int *stac927x_brd_tbl[] = {
-    ref927x_pin_configs,
-};
-
-static struct hda_board_config stac927x_cfg_tbl[] = {
-    { .modelname = "ref",
-    .pci_subvendor = PCI_VENDOR_ID_INTEL,
-    .pci_subdevice = 0x2668,      /* DFI LanParty */
-    .config = STAC_REF },         /* SigmaTel reference board */
-    {0} /* terminator */
-};
+        0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
+        0x01a19040, 0x01011012, 0x01016011, 0x0101201f, 
+        0x183301f0, 0x18a001f0, 0x18a001f0, 0x01442070,
+        0x01c42190, 0x40000100,
+};
+
+static unsigned int d965_3st_pin_configs[14] = {
+        0x0221401f, 0x02a19120, 0x40000100, 0x01014011,
+        0x01a19021, 0x01813024, 0x40000100, 0x40000100,
+        0x40000100, 0x40000100, 0x40000100, 0x40000100,
+        0x40000100, 0x40000100
+};
+
+static unsigned int d965_5st_pin_configs[14] = {
+        0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
+        0x01a19040, 0x01011012, 0x01016011, 0x40000100,
+        0x40000100, 0x40000100, 0x40000100, 0x01442070,
+        0x40000100, 0x40000100
+};
+
+static unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = {
+        [STAC_D965_REF] = ref927x_pin_configs,
+        [STAC_D965_3ST] = d965_3st_pin_configs,
+        [STAC_D965_5ST] = d965_5st_pin_configs,
+};
+
+static const char *stac927x_models[STAC_927X_MODELS] = {
+        [STAC_D965_REF] = "ref",
+        [STAC_D965_3ST] = "3stack",
+        [STAC_D965_5ST] = "5stack",
+};
+
+static struct snd_pci_quirk stac927x_cfg_tbl[] = {
+        /* SigmaTel reference board */
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
+                      "DFI LanParty", STAC_D965_REF),
+         /* Intel 946 based systems */
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST),
+        /* 965 based 3 stack systems */
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2116, "Intel D965", STAC_D965_3ST),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2115, "Intel D965", STAC_D965_3ST),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2114, "Intel D965", STAC_D965_3ST),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2113, "Intel D965", STAC_D965_3ST),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2112, "Intel D965", STAC_D965_3ST),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2111, "Intel D965", STAC_D965_3ST),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2110, "Intel D965", STAC_D965_3ST),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2009, "Intel D965", STAC_D965_3ST),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2008, "Intel D965", STAC_D965_3ST),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2007, "Intel D965", STAC_D965_3ST),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2006, "Intel D965", STAC_D965_3ST),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2005, "Intel D965", STAC_D965_3ST),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2004, "Intel D965", STAC_D965_3ST),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2003, "Intel D965", STAC_D965_3ST),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2002, "Intel D965", STAC_D965_3ST),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2001, "Intel D965", STAC_D965_3ST),
+        /* 965 based 5 stack systems */
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2301, "Intel D965", STAC_D965_5ST),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2302, "Intel D965", STAC_D965_5ST),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2303, "Intel D965", STAC_D965_5ST),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2304, "Intel D965", STAC_D965_5ST),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2305, "Intel D965", STAC_D965_5ST),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2501, "Intel D965", STAC_D965_5ST),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2502, "Intel D965", STAC_D965_5ST),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2503, "Intel D965", STAC_D965_5ST),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2504, "Intel D965", STAC_D965_5ST),
+        {0} /* terminator */
+};
+
+static unsigned int ref9205_pin_configs[12] = {
+        0x40000100, 0x40000100, 0x01016011, 0x01014010,
+        0x01813122, 0x01a19021, 0x40000100, 0x40000100,
+        0x90a000f0, 0x90a000f0, 0x01441030, 0x01c41030
+};
+
+static unsigned int *stac9205_brd_tbl[STAC_9205_MODELS] = {
+        ref9205_pin_configs,
+};
+
+static const char *stac9205_models[STAC_9205_MODELS] = {
+        [STAC_9205_REF] = "ref",
+};
+
+static struct snd_pci_quirk stac9205_cfg_tbl[] = {
+        /* SigmaTel reference board */
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
+                      "DFI LanParty", STAC_9205_REF),
+        {0} /* terminator */
+};
+
+static int stac92xx_save_bios_config_regs(struct hda_codec *codec)
+{
+        int i;
+        struct sigmatel_spec *spec = codec->spec;
+        
+        if (! spec->bios_pin_configs) {
+                spec->bios_pin_configs = kcalloc(spec->num_pins,
+                                                 sizeof(*spec->bios_pin_configs), GFP_KERNEL);
+                if (! spec->bios_pin_configs)
+                        return -ENOMEM;
+        }
+        
+        for (i = 0; i < spec->num_pins; i++) {
+                hda_nid_t nid = spec->pin_nids[i];
+                unsigned int pin_cfg;
+                
+                pin_cfg = snd_hda_codec_read(codec, nid, 0, 
+                        AC_VERB_GET_CONFIG_DEFAULT, 0x00);      
+                snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x bios pin config %8.8x\n",
+                                        nid, pin_cfg);
+                spec->bios_pin_configs[i] = pin_cfg;
+        }
+        
+        return 0;
+}
 
 static void stac92xx_set_config_regs(struct hda_codec *codec)
@@ -418 +633 @@
         unsigned int pin_cfg;
 
-        for (i=0; i < spec->num_pins; i++) {
+        if (! spec->pin_nids || ! spec->pin_configs)
+                return;
+
+        for (i = 0; i < spec->num_pins; i++) {
                 snd_hda_codec_write(codec, spec->pin_nids[i], 0,
                                     AC_VERB_SET_CONFIG_DEFAULT_BYTES_0,
@@ -433 +651 @@
                 pin_cfg = snd_hda_codec_read(codec, spec->pin_nids[i], 0,
                                              AC_VERB_GET_CONFIG_DEFAULT,
-                                             0x00);
+                                             0x00);     
                 snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x pin config %8.8x\n", spec->pin_nids[i], pin_cfg);
         }
@@ -544 +762 @@
 
 static struct hda_pcm_stream stac92xx_pcm_analog_alt_playback = {
-    .substreams = 1,
-    .channels_min = 2,
-    .channels_max = 2,
-    .nid = 0x06, /* NID to query formats and rates */
-    .ops = {
-        .open = stac92xx_playback_pcm_open,
-        .prepare = stac92xx_playback_pcm_prepare,
-        .cleanup = stac92xx_playback_pcm_cleanup
-    },
+        .substreams = 1,
+        .channels_min = 2,
+        .channels_max = 2,
+        .nid = 0x06, /* NID to query formats and rates */
+        .ops = {
+                .open = stac92xx_playback_pcm_open,
+                .prepare = stac92xx_playback_pcm_prepare,
+                .cleanup = stac92xx_playback_pcm_cleanup
+        },
 };
 
@@ -558 +776 @@
         .substreams = 2,
         .channels_min = 2,
-        .channels_max = 2,
-        /* NID is set in stac92xx_build_pcms */
+        .channels_max = 2,
+        /* NID is set in stac92xx_build_pcms */
         .ops = {
                 .prepare = stac92xx_capture_pcm_prepare,
@@ -577 +795 @@
         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback;
         info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture;
-        info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
-
-        if (spec->alt_switch) {
-            codec->num_pcms++;
-            info++;
-            info->name = "STAC92xx Analog Alt";
-            info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_alt_playback;
-        }
+        info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
+
+        if (spec->alt_switch) {
+                codec->num_pcms++;
+                info++;
+                info->name = "STAC92xx Analog Alt";
+                info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_alt_playback;
+        }
+
         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
                 codec->num_pcms++;
@@ -604 +823 @@
 static unsigned int stac92xx_get_vref(struct hda_codec *codec, hda_nid_t nid)
 {
-    unsigned int pincap = snd_hda_param_read(codec, nid,
-                                             AC_PAR_PIN_CAP);
-    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;
+        unsigned int pincap = snd_hda_param_read(codec, nid,
+                                                 AC_PAR_PIN_CAP);
+        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;
 }
 
@@ -654 +873 @@
 
         if (val)
-            stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
-        else {
-            unsigned int pinctl = AC_PINCTL_IN_EN;
-            if (io_idx) /* set VREF for mic */
-                pinctl |= stac92xx_get_vref(codec, nid);
-            stac92xx_auto_set_pinctl(codec, nid, pinctl);
-        }
-
+                stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
+        else {
+                unsigned int pinctl = AC_PINCTL_IN_EN;
+                if (io_idx) /* set VREF for mic */
+                        pinctl |= stac92xx_get_vref(codec, nid);
+                stac92xx_auto_set_pinctl(codec, nid, pinctl);
+        }
         return 1;
 }
@@ -773 +991 @@
  */
 /* fill in the dac_nids table from the parsed pin configuration */
-static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec, const struct auto_pin_cfg *cfg)
+static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec,
+                                       const struct auto_pin_cfg *cfg)
 {
         struct sigmatel_spec *spec = codec->spec;
@@ -786 +1005 @@
         }
 
-        spec->multiout.num_dacs = cfg->line_outs;
-
+        spec->multiout.num_dacs = cfg->line_outs;
+
+        return 0;
+}
+
+/* create volume control/switch for the given prefx type */
+static int create_controls(struct sigmatel_spec *spec, const char *pfx, hda_nid_t nid, int chs)
+{
+        char name[32];
+        int err;
+
+        sprintf(name, "%s Playback Volume", pfx);
+        err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL, name,
+                                   HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
+        if (err < 0)
+                return err;
+        sprintf(name, "%s Playback Switch", pfx);
+        err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE, name,
+                                   HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
+        if (err < 0)
+                return err;
         return 0;
 }
 
 /* add playback controls from the parsed DAC table */
-static int stac92xx_auto_create_multi_out_ctls(struct sigmatel_spec *spec, const struct auto_pin_cfg *cfg)
-{
-        char name[32];
-        static const char *chname[4] = { "Front", "Surround", NULL /*CLFE*/, "Side" };
+static int stac92xx_auto_create_multi_out_ctls(struct sigmatel_spec *spec,
+                                               const struct auto_pin_cfg *cfg)
+{
+        static const char *chname[4] = {
+                "Front", "Surround", NULL /*CLFE*/, "Side"
+        };
         hda_nid_t nid;
         int i, err;
@@ -807 +1047 @@
                 if (i == 2) {
                         /* Center/LFE */
-                        if ((err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL, "Center Playback Volume",
-                                               HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT))) < 0)
+                        err = create_controls(spec, "Center", nid, 1);
+                        if (err < 0)
                                 return err;
-                        if ((err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL, "LFE Playback Volume",
-                                               HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT))) < 0)
-                                return err;
-                        if ((err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE, "Center Playback Switch",
-                                               HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT))) < 0)
-                                return err;
-                        if ((err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE, "LFE Playback Switch",
-                                               HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT))) < 0)
+                        err = create_controls(spec, "LFE", nid, 2);
+                        if (err < 0)
                                 return err;
                 } else {
-                        sprintf(name, "%s Playback Volume", chname[i]);
-                        if ((err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL, name,
-                                               HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
-                                return err;
-                        sprintf(name, "%s Playback Switch", chname[i]);
-                        if ((err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE, name,
-                                               HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
+                        err = create_controls(spec, chname[i], nid, 3);
+                        if (err < 0)
                                 return err;
                 }
@@ -842 +1071 @@
 }
 
-/* add playback controls for HP output */
-static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec, struct auto_pin_cfg *cfg)
-{
-        struct sigmatel_spec *spec = codec->spec;
-        hda_nid_t pin = cfg->hp_pin;
+static int check_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
+{
+        int i;
+
+        for (i = 0; i < spec->multiout.num_dacs; i++) {
+                if (spec->multiout.dac_nids[i] == nid)
+                        return 1;
+        }
+        if (spec->multiout.hp_nid == nid)
+                return 1;
+        return 0;
+}
+
+static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
+{
+        if (!spec->multiout.hp_nid)
+                spec->multiout.hp_nid = nid;
+        else if (spec->multiout.num_dacs > 4) {
+                printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid);
+                return 1;
+        } else {
+                spec->multiout.dac_nids[spec->multiout.num_dacs] = nid;
+                spec->multiout.num_dacs++;
+        }
+        return 0;
+}
+
+/* add playback controls for Speaker and HP outputs */
+static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec,
+                                        struct auto_pin_cfg *cfg)
+{
+        struct sigmatel_spec *spec = codec->spec;
         hda_nid_t nid;
-        int i, err;
-        unsigned int wid_caps;
-
-        if (! pin)
-                return 0;
-
-        wid_caps = get_wcaps(codec, pin);
-        if (wid_caps & AC_WCAP_UNSOL_CAP) {
-                /* Enable unsolicited responses on the HP widget */
-                snd_hda_codec_write(codec, pin, 0,
-                                AC_VERB_SET_UNSOLICITED_ENABLE,
-                                    STAC_UNSOL_ENABLE);
-                spec->hp_detect = 1;
-        }
-
-        nid = snd_hda_codec_read(codec, pin, 0, AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
-        for (i = 0; i < cfg->line_outs; i++) {
-                if (! spec->multiout.dac_nids[i])
+        int i, old_num_dacs, err;
+
+        old_num_dacs = spec->multiout.num_dacs;
+        for (i = 0; i < cfg->hp_outs; i++) {
+                unsigned int wid_caps = get_wcaps(codec, cfg->hp_pins[i]);
+                if (wid_caps & AC_WCAP_UNSOL_CAP)
+                        spec->hp_detect = 1;
+                nid = snd_hda_codec_read(codec, cfg->hp_pins[i], 0,
+                                         AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
+                if (check_in_dac_nids(spec, nid))
+                        nid = 0;
+                if (! nid)
                         continue;
-                if (spec->multiout.dac_nids[i] == nid)
-                        return 0;
-        }
-
-        spec->multiout.hp_nid = nid;
-
-        /* control HP volume/switch on the output mixer amp */
-        if ((err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL, "Headphone Playback Volume",
-                                        HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
-                return err;
-        if ((err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE, "Headphone Playback Switch",
-                                        HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
-                return err;
+                add_spec_dacs(spec, nid);
+        }
+        for (i = 0; i < cfg->speaker_outs; i++) {
+                nid = snd_hda_codec_read(codec, cfg->speaker_pins[0], 0,
+                                         AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
+                if (check_in_dac_nids(spec, nid))
+                        nid = 0;
+                if (check_in_dac_nids(spec, nid))
+                        nid = 0;
+                if (! nid)
+                        continue;
+                add_spec_dacs(spec, nid);
+        }
+
+        for (i = old_num_dacs; i < spec->multiout.num_dacs; i++) {
+                static const char *pfxs[] = {
+                        "Speaker", "External Speaker", "Speaker2",
+                };
+                err = create_controls(spec, pfxs[i - old_num_dacs],
+                                      spec->multiout.dac_nids[i], 3);
+                if (err < 0)
+                        return err;
+        }
+        if (spec->multiout.hp_nid) {
+                const char *pfx;
+                if (old_num_dacs == spec->multiout.num_dacs)
+                        pfx = "Master";
+                else
+                        pfx = "Headphone";
+                err = create_controls(spec, pfx, spec->multiout.hp_nid, 3);
+                if (err < 0)
+                        return err;
+        }
+
+        return 0;
+}
+
+/* labels for dmic mux inputs */
+static const char *stac92xx_dmic_labels[5] = {
+        "Analog Inputs", "Digital Mic 1", "Digital Mic 2",
+        "Digital Mic 3", "Digital Mic 4"
+};
+
+/* create playback/capture controls for input pins on dmic capable codecs */
+static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
+                                                const struct auto_pin_cfg *cfg)
+{
+        struct sigmatel_spec *spec = codec->spec;
+        struct hda_input_mux *dimux = &spec->private_dimux;
+        hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
+        int i, j;
+
+        dimux->items[dimux->num_items].label = stac92xx_dmic_labels[0];
+        dimux->items[dimux->num_items].index = 0;
+        dimux->num_items++;
+
+        for (i = 0; i < spec->num_dmics; i++) {
+                int index;
+                int num_cons;
+                unsigned int def_conf;
+
+                def_conf = snd_hda_codec_read(codec,
+                                              spec->dmic_nids[i],
+                                              0,
+                                              AC_VERB_GET_CONFIG_DEFAULT,
+                                              0);
+                if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
+                        continue;
+
+                num_cons = snd_hda_get_connections(codec,
+                                spec->dmux_nid,
+                                con_lst,
+                                HDA_MAX_NUM_INPUTS);
+                for (j = 0; j < num_cons; j++)
+                        if (con_lst[j] == spec->dmic_nids[i]) {
+                                index = j;
+                                goto found;
+                        }
+                continue;
+found:
+                dimux->items[dimux->num_items].label =
+                        stac92xx_dmic_labels[dimux->num_items];
+                dimux->items[dimux->num_items].index = index;
+                dimux->num_items++;
+        }
 
         return 0;
@@ -893 +1215 @@
 
         for (i = 0; i < AUTO_PIN_LAST; i++) {
-                int index = -1;
-                if (cfg->input_pins[i]) {
-                        imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
-
-                        for (j=0; j<spec->num_muxes; j++) {
-                                int num_cons = snd_hda_get_connections(codec, spec->mux_nids[j], con_lst, HDA_MAX_NUM_INPUTS);
-                                for (k=0; k<num_cons; k++)
-                                        if (con_lst[k] == cfg->input_pins[i]) {
-                                                index = k;
-                                                break;
-                                        }
-                                if (index >= 0)
-                                        break;
-                        }
-                        imux->items[imux->num_items].index = index;
-                        imux->num_items++;
+                int index;
+
+                if (!cfg->input_pins[i])
+                        continue;
+                index = -1;
+                for (j = 0; j < spec->num_muxes; j++) {
+                        int num_cons;
+                        num_cons = snd_hda_get_connections(codec,
+                                                           spec->mux_nids[j],
+                                                           con_lst,
+                                                           HDA_MAX_NUM_INPUTS);
+                        for (k = 0; k < num_cons; k++)
+                                if (con_lst[k] == cfg->input_pins[i]) {
+                                        index = k;
+                                        goto found;
+                                }
                 }
-        }
-        if (imux->num_items == 1) {
-            /*
-             * Set the current input for the muxes.
-             * The STAC9221 has two input muxes with identical source
-             * NID lists.  Hopefully this won't get confused.
-             */
-            for (i = 0; i < spec->num_muxes; i++) {
-                snd_hda_codec_write(codec, spec->mux_nids[i], 0,
-                                    AC_VERB_SET_CONNECT_SEL,
-                                    imux->items[0].index);
-            }
-        }
+                continue;
+        found:
+                imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
+                imux->items[imux->num_items].index = index;
+                imux->num_items++;
+        }
+
+        if (imux->num_items == 1) {
+                /*
+                 * Set the current input for the muxes.
+                 * The STAC9221 has two input muxes with identical source
+                 * NID lists.  Hopefully this won't get confused.
+                 */
+                for (i = 0; i < spec->num_muxes; i++) {
+                        snd_hda_codec_write(codec, spec->mux_nids[i], 0,
+                                            AC_VERB_SET_CONNECT_SEL,
+                                            imux->items[0].index);
+                }
+        }
 
         return 0;
@@ -941 +1269 @@
 {
         struct sigmatel_spec *spec = codec->spec;
-        hda_nid_t pin;
-
-        pin = spec->autocfg.hp_pin;
-        if (pin) /* connect to front */
-                stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
+        int i;
+
+        for (i = 0; i < spec->autocfg.hp_outs; i++) {
+                hda_nid_t pin;
+                pin = spec->autocfg.hp_pins[i];
+                if (pin) /* connect to front */
+                        stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
+        }
+        for (i = 0; i < spec->autocfg.speaker_outs; i++) {
+                hda_nid_t pin;
+                pin = spec->autocfg.speaker_pins[i];
+                if (pin) /* connect to front */
+                        stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN);
+        }
 }
 
@@ -953 +1290 @@
         int err;
 
-        if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
-            return err;
-        if (! spec->autocfg.line_outs)
-            return 0; /* can't find valid pin config */
-
-        if ((err = stac92xx_add_dyn_out_pins(codec, &spec->autocfg)) < 0)
-            return err;
-
-        if (spec->multiout.num_dacs == 0)
-            if ((err = stac92xx_auto_fill_dac_nids(codec, &spec->autocfg)) < 0)
-                return err;
+        if ((err = snd_hda_parse_pin_def_config(codec,
+                                                &spec->autocfg,
+                                                spec->dmic_nids)) < 0)
+                return err;
+        if (! spec->autocfg.line_outs)
+                return 0; /* can't find valid pin config */
+
+        if ((err = stac92xx_add_dyn_out_pins(codec, &spec->autocfg)) < 0)
+                return err;
+        if (spec->multiout.num_dacs == 0)
+                if ((err = stac92xx_auto_fill_dac_nids(codec, &spec->autocfg)) < 0)
+                        return err;
 
         if ((err = stac92xx_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0 ||
@@ -970 +1308 @@
                 return err;
 
+        if (spec->num_dmics > 0)
+                if ((err = stac92xx_auto_create_dmic_input_ctls(codec,
+                                                &spec->autocfg)) < 0)
+                        return err;
+
         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
         if (spec->multiout.max_channels > 2)
                 spec->surr_switch = 1;
 
-        if (spec->autocfg.dig_out_pin)
-            spec->multiout.dig_out_nid = dig_out;
-        if (spec->autocfg.dig_in_pin)
-            spec->dig_in_nid = dig_in;
+        if (spec->autocfg.dig_out_pin)
+                spec->multiout.dig_out_nid = dig_out;
+        if (spec->autocfg.dig_in_pin)
+                spec->dig_in_nid = dig_in;
 
         if (spec->kctl_alloc)
@@ -983 +1326 @@
 
         spec->input_mux = &spec->private_imux;
+        spec->dinput_mux = &spec->private_dimux;
 
         return 1;
@@ -989 +1333 @@
 /* add playback controls for HP output */
 static int stac9200_auto_create_hp_ctls(struct hda_codec *codec,
-                                        struct auto_pin_cfg *cfg)
-{
-    struct sigmatel_spec *spec = codec->spec;
-    hda_nid_t pin = cfg->hp_pin;
-    unsigned int wid_caps;
-
-    if (! pin)
-        return 0;
-
-    wid_caps = get_wcaps(codec, pin);
-    if (wid_caps & AC_WCAP_UNSOL_CAP) {
-        /* Enable unsolicited responses on the HP widget */
-        snd_hda_codec_write(codec, pin, 0,
-                            AC_VERB_SET_UNSOLICITED_ENABLE,
-                            STAC_UNSOL_ENABLE);
-        spec->hp_detect = 1;
-    }
-
-    return 0;
+                                        struct auto_pin_cfg *cfg)
+{
+        struct sigmatel_spec *spec = codec->spec;
+        hda_nid_t pin = cfg->hp_pins[0];
+        unsigned int wid_caps;
+
+        if (! pin)
+                return 0;
+
+        wid_caps = get_wcaps(codec, pin);
+        if (wid_caps & AC_WCAP_UNSOL_CAP)
+                spec->hp_detect = 1;
+
+        return 0;
+}
+
+/* add playback controls for LFE output */
+static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec,
+                                        struct auto_pin_cfg *cfg)
+{
+        struct sigmatel_spec *spec = codec->spec;
+        int err;
+        hda_nid_t lfe_pin = 0x0;
+        int i;
+
+        /*
+         * search speaker outs and line outs for a mono speaker pin
+         * with an amp.  If one is found, add LFE controls
+         * for it.
+         */
+        for (i = 0; i < spec->autocfg.speaker_outs && lfe_pin == 0x0; i++) {
+                hda_nid_t pin = spec->autocfg.speaker_pins[i];
+                unsigned long wcaps = get_wcaps(codec, pin);
+                wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
+                if (wcaps == AC_WCAP_OUT_AMP)
+                        /* found a mono speaker with an amp, must be lfe */
+                        lfe_pin = pin;
+        }
+
+        /* if speaker_outs is 0, then speakers may be in line_outs */
+        if (lfe_pin == 0 && spec->autocfg.speaker_outs == 0) {
+                for (i = 0; i < spec->autocfg.line_outs && lfe_pin == 0x0; i++) {
+                        hda_nid_t pin = spec->autocfg.line_out_pins[i];
+                        unsigned long cfg;
+                        cfg = snd_hda_codec_read(codec, pin, 0,
+                                                 AC_VERB_GET_CONFIG_DEFAULT,
+                                                 0x00);
+                        if (get_defcfg_device(cfg) == AC_JACK_SPEAKER) {
+                                unsigned long wcaps = get_wcaps(codec, pin);
+                                wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
+                                if (wcaps == AC_WCAP_OUT_AMP)
+                                        /* found a mono speaker with an amp,
+                                           must be lfe */
+                                        lfe_pin = pin;
+                        }
+                }
+        }
+
+        if (lfe_pin) {
+                err = create_controls(spec, "LFE", lfe_pin, 1);
+                if (err < 0)
+                        return err;
+        }
+
+        return 0;
 }
 
@@ -1021 +1411 @@
                 return err;
 
-        if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0)
-            return err;
-
-        if (spec->autocfg.dig_out_pin)
-            spec->multiout.dig_out_nid = 0x05;
-        if (spec->autocfg.dig_in_pin)
-            spec->dig_in_nid = 0x04;
+        if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0)
+                return err;
+
+        if ((err = stac9200_auto_create_lfe_ctls(codec, &spec->autocfg)) < 0)
+                return err;
+
+        if (spec->autocfg.dig_out_pin)
+                spec->multiout.dig_out_nid = 0x05;
+        if (spec->autocfg.dig_in_pin)
+                spec->dig_in_nid = 0x04;
 
         if (spec->kctl_alloc)
@@ -1033 +1426 @@
 
         spec->input_mux = &spec->private_imux;
-
-        return 1;
+        spec->dinput_mux = &spec->private_dimux;
+
+        return 1;
 }
 
@@ -1076 +1470 @@
 }
 
+static void enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
+                              unsigned int event)
+{
+        if (get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP)
+                snd_hda_codec_write(codec, nid, 0,
+                                    AC_VERB_SET_UNSOLICITED_ENABLE,
+                                    (AC_USRSP_EN | event));
+}
+
 static int stac92xx_init(struct hda_codec *codec)
 {
-    struct sigmatel_spec *spec = codec->spec;
-    struct auto_pin_cfg *cfg = &spec->autocfg;
-    int i;
-
-    snd_hda_sequence_write(codec, spec->init);
-
-    /* set up pins */
-    if (spec->hp_detect) {
-        /* fake event to set up pins */
-        codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
-    } else {
-        stac92xx_auto_init_multi_out(codec);
-        stac92xx_auto_init_hp_out(codec);
-    }
-    for (i = 0; i < AUTO_PIN_LAST; i++) {
-        hda_nid_t nid = cfg->input_pins[i];
-        if (nid) {
-            unsigned int pinctl = AC_PINCTL_IN_EN;
-            if (i == AUTO_PIN_MIC || i == AUTO_PIN_FRONT_MIC)
-                pinctl |= stac92xx_get_vref(codec, nid);
-            stac92xx_auto_set_pinctl(codec, nid, pinctl);
-        }
-    }
-    if (cfg->dig_out_pin)
-        stac92xx_auto_set_pinctl(codec, cfg->dig_out_pin,
-                                 AC_PINCTL_OUT_EN);
-    if (cfg->dig_in_pin)
-        stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin,
-                                 AC_PINCTL_IN_EN);
-    if (spec->gpio_mute) {
-        stac922x_gpio_mute(codec, 0, 0);
-        stac922x_gpio_mute(codec, 1, 0);
-    }
-
-    return 0;
+        struct sigmatel_spec *spec = codec->spec;
+        struct auto_pin_cfg *cfg = &spec->autocfg;
+        int i;
+
+        snd_hda_sequence_write(codec, spec->init);
+
+        /* set up pins */
+        if (spec->hp_detect) {
+                /* Enable unsolicited responses on the HP widget */
+                for (i = 0; i < cfg->hp_outs; i++)
+                        enable_pin_detect(codec, cfg->hp_pins[i],
+                                          STAC_HP_EVENT);
+                stac92xx_auto_init_hp_out(codec);
+                /* fake event to set up pins */
+                codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
+        } else {
+                stac92xx_auto_init_multi_out(codec);
+                stac92xx_auto_init_hp_out(codec);
+        }
+        for (i = 0; i < AUTO_PIN_LAST; i++) {
+                hda_nid_t nid = cfg->input_pins[i];
+                if (nid) {
+                        unsigned int pinctl = AC_PINCTL_IN_EN;
+                        if (i == AUTO_PIN_MIC || i == AUTO_PIN_FRONT_MIC)
+                                pinctl |= stac92xx_get_vref(codec, nid);
+                        stac92xx_auto_set_pinctl(codec, nid, pinctl);
+                }
+        }
+        if (spec->num_dmics > 0)
+                for (i = 0; i < spec->num_dmics; i++)
+                        stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i],
+                                                 AC_PINCTL_IN_EN);
+
+        if (cfg->dig_out_pin)
+                stac92xx_auto_set_pinctl(codec, cfg->dig_out_pin,
+                                         AC_PINCTL_OUT_EN);
+        if (cfg->dig_in_pin)
+                stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin,
+                                         AC_PINCTL_IN_EN);
+
+        if (spec->gpio_mute) {
+                stac922x_gpio_mute(codec, 0, 0);
+                stac922x_gpio_mute(codec, 1, 0);
+        }
+
+        return 0;
 }
 
@@ -1129 +1543 @@
         }
 
+        if (spec->bios_pin_configs)
+                kfree(spec->bios_pin_configs);
+
         kfree(spec);
 }
@@ -1137 +1554 @@
         unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
                         0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
+        if (flag == AC_PINCTL_OUT_EN && (pin_ctl & AC_PINCTL_IN_EN))
+                return;
         snd_hda_codec_write(codec, nid, 0,
                         AC_VERB_SET_PIN_WIDGET_CONTROL,
@@ -1152 +1571 @@
 }
 
-static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
+static int get_pin_presence(struct hda_codec *codec, hda_nid_t nid)
+{
+        if (!nid)
+                return 0;
+        if (snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PIN_SENSE, 0x00)
+            & (1 << 31))
+                return 1;
+        return 0;
+}
+
+static void stac92xx_hp_detect(struct hda_codec *codec, unsigned int res)
 {
         struct sigmatel_spec *spec = codec->spec;
@@ -1158 +1587 @@
         int i, presence;
 
-        if ((res >> 26) != STAC_HP_EVENT)
-                return;
-
-        presence = snd_hda_codec_read(codec, cfg->hp_pin, 0,
-                        AC_VERB_GET_PIN_SENSE, 0x00) >> 31;
+        presence = 0;
+        for (i = 0; i < cfg->hp_outs; i++) {
+                presence = get_pin_presence(codec, cfg->hp_pins[i]);
+                if (presence)
+                        break;
+        }
 
         if (presence) {
@@ -1169 +1599 @@
                         stac92xx_reset_pinctl(codec, cfg->line_out_pins[i],
                                                 AC_PINCTL_OUT_EN);
-                stac92xx_set_pinctl(codec, cfg->hp_pin, AC_PINCTL_OUT_EN);
+                for (i = 0; i < cfg->speaker_outs; i++)
+                        stac92xx_reset_pinctl(codec, cfg->speaker_pins[i],
+                                                AC_PINCTL_OUT_EN);
         } else {
                 /* enable lineouts, disable hp */
@@ -1175 +1607 @@
                         stac92xx_set_pinctl(codec, cfg->line_out_pins[i],
                                                 AC_PINCTL_OUT_EN);
-                stac92xx_reset_pinctl(codec, cfg->hp_pin, AC_PINCTL_OUT_EN);
+                for (i = 0; i < cfg->speaker_outs; i++)
+                        stac92xx_set_pinctl(codec, cfg->speaker_pins[i],
+                                                AC_PINCTL_OUT_EN);
+        }
+} 
+
+static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
+{
+        switch (res >> 26) {
+        case STAC_HP_EVENT:
+                stac92xx_hp_detect(codec, res);
+                break;
         }
 }
@@ -1186 +1629 @@
 
         stac92xx_init(codec);
+        stac92xx_set_config_regs(codec);
         for (i = 0; i < spec->num_mixers; i++)
                 snd_hda_resume_ctls(codec, spec->mixers[i]);
@@ -1218 +1662 @@
 
         codec->spec = spec;
-        spec->board_config = snd_hda_check_board_config(codec, stac9200_cfg_tbl);
-        if (spec->board_config < 0)
-                snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9200, using BIOS defaults\n");
-        else {
-                spec->num_pins = 8;
-                spec->pin_nids = stac9200_pin_nids;
+        spec->num_pins = 8;
+        spec->pin_nids = stac9200_pin_nids;
+        spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS,
+                                                        stac9200_models,
+                                                        stac9200_cfg_tbl);
+        if (spec->board_config < 0) {
+                snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9200, using BIOS defaults\n");
+                err = stac92xx_save_bios_config_regs(codec);
+                if (err < 0) {
+                        stac92xx_free(codec);
+                        return err;
+                }
+                spec->pin_configs = spec->bios_pin_configs;
+        } else {
                 spec->pin_configs = stac9200_brd_tbl[spec->board_config];
                 stac92xx_set_config_regs(codec);
@@ -1234 +1686 @@
         spec->mux_nids = stac9200_mux_nids;
         spec->num_muxes = 1;
+        spec->num_dmics = 0;
 
         spec->init = stac9200_core_init;
@@ -1259 +1712 @@
 
         codec->spec = spec;
-        spec->board_config = snd_hda_check_board_config(codec, stac922x_cfg_tbl);
-        if (spec->board_config < 0)
-            snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC922x, using BIOS defaults\n");
-        else if (stac922x_brd_tbl[spec->board_config] != NULL) {
-                spec->num_pins = 10;
-                spec->pin_nids = stac922x_pin_nids;
+        spec->num_pins = 10;
+        spec->pin_nids = stac922x_pin_nids;
+        spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS,
+                                                        stac922x_models,
+                                                        stac922x_cfg_tbl);
+        if (spec->board_config < 0) {
+                snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC922x, "
+                        "using BIOS defaults\n");
+                err = stac92xx_save_bios_config_regs(codec);
+                if (err < 0) {
+                        stac92xx_free(codec);
+                        return err;
+                }
+                spec->pin_configs = spec->bios_pin_configs;
+        } else if (stac922x_brd_tbl[spec->board_config] != NULL) {
                 spec->pin_configs = stac922x_brd_tbl[spec->board_config];
                 stac92xx_set_config_regs(codec);
@@ -1272 +1734 @@
         spec->mux_nids = stac922x_mux_nids;
         spec->num_muxes = 2;
+        spec->num_dmics = 0;
 
         spec->init = stac922x_core_init;
@@ -1277 +1740 @@
 
         spec->multiout.dac_nids = spec->dac_nids;
-
-        switch (spec->board_config) {
-        case STAC_D965_2112:
-                spec->adc_nids = stac9227_adc_nids;
-                spec->mux_nids = stac9227_mux_nids;
-#if 0
-                spec->multiout.dac_nids = d965_2112_dac_nids;
-                spec->multiout.num_dacs = ARRAY_SIZE(d965_2112_dac_nids);
-#endif
-                spec->init = d965_2112_core_init;
+        
+        err = stac92xx_parse_auto_config(codec, 0x08, 0x09);
+        if (err < 0) {
+                stac92xx_free(codec);
+                return err;
+        }
+
+        if (spec->board_config == STAC_MACMINI)
+                spec->gpio_mute = 1;
+
+        codec->patch_ops = stac92xx_patch_ops;
+
+        return 0;
+}
+
+static int patch_stac927x(struct hda_codec *codec)
+{
+        struct sigmatel_spec *spec;
+        int err;
+
+        spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
+        if (spec == NULL)
+                return -ENOMEM;
+
+        codec->spec = spec;
+        spec->num_pins = 14;
+        spec->pin_nids = stac927x_pin_nids;
+        spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS,
+                                                        stac927x_models,
+                                                        stac927x_cfg_tbl);
+        if (spec->board_config < 0) {
+                snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC927x, using BIOS defaults\n");
+                err = stac92xx_save_bios_config_regs(codec);
+                if (err < 0) {
+                        stac92xx_free(codec);
+                        return err;
+                }
+                spec->pin_configs = spec->bios_pin_configs;
+        } else if (stac927x_brd_tbl[spec->board_config] != NULL) {
+                spec->pin_configs = stac927x_brd_tbl[spec->board_config];
+                stac92xx_set_config_regs(codec);
+        }
+
+        switch (spec->board_config) {
+        case STAC_D965_3ST:
+                spec->adc_nids = stac927x_adc_nids;
+                spec->mux_nids = stac927x_mux_nids;
+                spec->num_muxes = 3;
+                spec->num_dmics = 0;
+                spec->init = d965_core_init;
                 spec->mixer = stac9227_mixer;
                 break;
-        case STAC_D965_284B:
-                spec->adc_nids = stac9227_adc_nids;
-                spec->mux_nids = stac9227_mux_nids;
-                spec->init = stac9227_core_init;
+        case STAC_D965_5ST:
+                spec->adc_nids = stac927x_adc_nids;
+                spec->mux_nids = stac927x_mux_nids;
+                spec->num_muxes = 3;
+                spec->num_dmics = 0;
+                spec->init = d965_core_init;
                 spec->mixer = stac9227_mixer;
                 break;
-        }
-        err = stac92xx_parse_auto_config(codec, 0x08, 0x09);
-        if (err < 0) {
-            stac92xx_free(codec);
-            return err;
-        }
-
-        if (spec->board_config == STAC_MACMINI)
-                spec->gpio_mute = 1;
-        codec->patch_ops = stac92xx_patch_ops;
-
-        return 0;
-}
-
-static int patch_stac927x(struct hda_codec *codec)
-{
-    struct sigmatel_spec *spec;
-    int err;
-
-    spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
-    if (spec == NULL)
-        return -ENOMEM;
-
-    codec->spec = spec;
-    spec->board_config = snd_hda_check_board_config(codec, stac927x_cfg_tbl);
-    if (spec->board_config < 0)
-        snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC927x, using BIOS defaults\n");
-    else {
-        spec->num_pins = 14;
-        spec->pin_nids = stac927x_pin_nids;
-        spec->pin_configs = stac927x_brd_tbl[spec->board_config];
-        stac92xx_set_config_regs(codec);
-    }
-
-    spec->adc_nids = stac927x_adc_nids;
-    spec->mux_nids = stac927x_mux_nids;
-    spec->num_muxes = 3;
-
-    spec->init = stac927x_core_init;
-    spec->mixer = stac927x_mixer;
-
-    spec->multiout.dac_nids = spec->dac_nids;
-
-                 err = stac92xx_parse_auto_config(codec, 0x1e, 0x20);
-        if (err < 0) {
+        default:
+                spec->adc_nids = stac927x_adc_nids;
+                spec->mux_nids = stac927x_mux_nids;
+                spec->num_muxes = 3;
+                spec->num_dmics = 0;
+                spec->init = stac927x_core_init;
+                spec->mixer = stac927x_mixer;
+        }
+
+        spec->multiout.dac_nids = spec->dac_nids;
+
+        err = stac92xx_parse_auto_config(codec, 0x1e, 0x20);
+        if (err < 0) {
                 stac92xx_free(codec);
                 return err;
@@ -1349 +1822 @@
 }
 
+static int patch_stac9205(struct hda_codec *codec)
+{
+        struct sigmatel_spec *spec;
+        int err;
+
+        spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
+        if (spec == NULL)
+                return -ENOMEM;
+
+        codec->spec = spec;
+        spec->num_pins = 14;
+        spec->pin_nids = stac9205_pin_nids;
+        spec->board_config = snd_hda_check_board_config(codec, STAC_9205_MODELS,
+                                                        stac9205_models,
+                                                        stac9205_cfg_tbl);
+        if (spec->board_config < 0) {
+                snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9205, using BIOS defaults\n");
+                err = stac92xx_save_bios_config_regs(codec);
+                if (err < 0) {
+                        stac92xx_free(codec);
+                        return err;
+                }
+                spec->pin_configs = spec->bios_pin_configs;
+        } else {
+                spec->pin_configs = stac9205_brd_tbl[spec->board_config];
+                stac92xx_set_config_regs(codec);
+        }
+
+        spec->adc_nids = stac9205_adc_nids;
+        spec->mux_nids = stac9205_mux_nids;
+        spec->num_muxes = 2;
+        spec->dmic_nids = stac9205_dmic_nids;
+        spec->num_dmics = 2;
+        spec->dmux_nid = 0x1d;
+
+        spec->init = stac9205_core_init;
+        spec->mixer = stac9205_mixer;
+
+        spec->multiout.dac_nids = spec->dac_nids;
+
+        err = stac92xx_parse_auto_config(codec, 0x1f, 0x20);
+        if (err < 0) {
+                stac92xx_free(codec);
+                return err;
+        }
+
+        codec->patch_ops = stac92xx_patch_ops;
+
+        return 0;
+}
+
 /*
- * STAC 7661(?) hack
+ * STAC9872 hack
  */
 
-/* static config for Sony VAIO FE550G */
+/* static config for Sony VAIO FE550G and Sony VAIO AR */
 static hda_nid_t vaio_dacs[] = { 0x2 };
-#define VAIO_HP_DAC     0x5
+#define VAIO_HP_DAC     0x5
 static hda_nid_t vaio_adcs[] = { 0x8 /*,0x6*/ };
 static hda_nid_t vaio_mux_nids[] = { 0x15 };
 
 static struct hda_input_mux vaio_mux = {
-    .num_items = 2,
-    .items = {
-        /* { "HP", 0x0 }, */
-        { "Line", 0x1 },
-        { "Mic", 0x2 },
-        { "PCM", 0x3 },
-    }
+        .num_items = 2,
+        .items = {
+                /* { "HP", 0x0 }, */
+                { "Line", 0x1 },
+                { "Mic", 0x2 },
+                { "PCM", 0x3 },
+        }
 };
 
 static struct hda_verb vaio_init[] = {
-    {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
-    {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
-    {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
-    {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
-    {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
-    {0x15, AC_VERB_SET_CONNECT_SEL, 0x2}, /* mic-sel: 0a,0d,14,02 */
-    {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
-    {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
-    {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
-    {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
-    {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
-    {0}
+        {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
+        {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
+        {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
+        {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
+        {0x15, AC_VERB_SET_CONNECT_SEL, 0x2}, /* mic-sel: 0a,0d,14,02 */
+        {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
+        {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
+        {0}
+};
+
+static struct hda_verb vaio_ar_init[] = {
+        {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
+        {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
+        {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
+        {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
+/*      {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },*/ /* Optical Out */
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
+        {0x15, AC_VERB_SET_CONNECT_SEL, 0x2}, /* mic-sel: 0a,0d,14,02 */
+        {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
+        {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
+/*      {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},*/ /* Optical Out */
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
+        {0}
 };
 
 /* bind volumes of both NID 0x02 and 0x05 */
 static int vaio_master_vol_put(struct snd_kcontrol *kcontrol,
-                               struct snd_ctl_elem_value *ucontrol)
-{
-    struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-    long *valp = ucontrol->value.integer.value;
-    int change;
-
-    change = snd_hda_codec_amp_update(codec, 0x02, 0, HDA_OUTPUT, 0,
-                                      0x7f, valp[0] & 0x7f);
-    change |= snd_hda_codec_amp_update(codec, 0x02, 1, HDA_OUTPUT, 0,
-                                       0x7f, valp[1] & 0x7f);
-    snd_hda_codec_amp_update(codec, 0x05, 0, HDA_OUTPUT, 0,
-                             0x7f, valp[0] & 0x7f);
-    snd_hda_codec_amp_update(codec, 0x05, 1, HDA_OUTPUT, 0,
-                             0x7f, valp[1] & 0x7f);
-    return change;
+                               struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        long *valp = ucontrol->value.integer.value;
+        int change;
+
+        change = snd_hda_codec_amp_update(codec, 0x02, 0, HDA_OUTPUT, 0,
+                                          0x7f, valp[0] & 0x7f);
+        change |= snd_hda_codec_amp_update(codec, 0x02, 1, HDA_OUTPUT, 0,
+                                           0x7f, valp[1] & 0x7f);
+        snd_hda_codec_amp_update(codec, 0x05, 0, HDA_OUTPUT, 0,
+                                 0x7f, valp[0] & 0x7f);
+        snd_hda_codec_amp_update(codec, 0x05, 1, HDA_OUTPUT, 0,
+                                 0x7f, valp[1] & 0x7f);
+        return change;
 }
 
 /* bind volumes of both NID 0x02 and 0x05 */
 static int vaio_master_sw_put(struct snd_kcontrol *kcontrol,
-                              struct snd_ctl_elem_value *ucontrol)
-{
-    struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-    long *valp = ucontrol->value.integer.value;
-    int change;
-
-    change = snd_hda_codec_amp_update(codec, 0x02, 0, HDA_OUTPUT, 0,
-                                      0x80, (valp[0] ? 0 : 0x80));
-    change |= snd_hda_codec_amp_update(codec, 0x02, 1, HDA_OUTPUT, 0,
-                                       0x80, (valp[1] ? 0 : 0x80));
-    snd_hda_codec_amp_update(codec, 0x05, 0, HDA_OUTPUT, 0,
-                             0x80, (valp[0] ? 0 : 0x80));
-    snd_hda_codec_amp_update(codec, 0x05, 1, HDA_OUTPUT, 0,
-                             0x80, (valp[1] ? 0 : 0x80));
-    return change;
+                              struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        long *valp = ucontrol->value.integer.value;
+        int change;
+
+        change = snd_hda_codec_amp_update(codec, 0x02, 0, HDA_OUTPUT, 0,
+                                          0x80, (valp[0] ? 0 : 0x80));
+        change |= snd_hda_codec_amp_update(codec, 0x02, 1, HDA_OUTPUT, 0,
+                                           0x80, (valp[1] ? 0 : 0x80));
+        snd_hda_codec_amp_update(codec, 0x05, 0, HDA_OUTPUT, 0,
+                                 0x80, (valp[0] ? 0 : 0x80));
+        snd_hda_codec_amp_update(codec, 0x05, 1, HDA_OUTPUT, 0,
+                                 0x80, (valp[1] ? 0 : 0x80));
+        return change;
 }
 
 static struct snd_kcontrol_new vaio_mixer[] = {
-    {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "Master Playback Volume",
-        .info = snd_hda_mixer_amp_volume_info,
-        .get = snd_hda_mixer_amp_volume_get,
-        .put = vaio_master_vol_put,
-        .private_value = HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
-    },
-    {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "Master Playback Switch",
-        .info = snd_hda_mixer_amp_switch_info,
-        .get = snd_hda_mixer_amp_switch_get,
-        .put = vaio_master_sw_put,
-        .private_value = HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
-    },
-    /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
-    HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
-    HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
-    {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "Capture Source",
-        .count = 1,
-        .info = stac92xx_mux_enum_info,
-        .get = stac92xx_mux_enum_get,
-        .put = stac92xx_mux_enum_put,
-    },
-    {0}
-};
-
-static struct hda_codec_ops stac7661_patch_ops = {
-    .build_controls = stac92xx_build_controls,
-    .build_pcms = stac92xx_build_pcms,
-    .init = stac92xx_init,
-    .free = stac92xx_free,
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Master Playback Volume",
+                .info = snd_hda_mixer_amp_volume_info,
+                .get = snd_hda_mixer_amp_volume_get,
+                .put = vaio_master_vol_put,
+                .tlv = { .c = snd_hda_mixer_amp_tlv },
+                .private_value = HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
+        },
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Master Playback Switch",
+                .info = snd_hda_mixer_amp_switch_info,
+                .get = snd_hda_mixer_amp_switch_get,
+                .put = vaio_master_sw_put,
+                .private_value = HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
+        },
+        /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
+        HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Capture Source",
+                .count = 1,
+                .info = stac92xx_mux_enum_info,
+                .get = stac92xx_mux_enum_get,
+                .put = stac92xx_mux_enum_put,
+        },
+        {0}
+};
+
+static struct snd_kcontrol_new vaio_ar_mixer[] = {
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Master Playback Volume",
+                .info = snd_hda_mixer_amp_volume_info,
+                .get = snd_hda_mixer_amp_volume_get,
+                .put = vaio_master_vol_put,
+                .private_value = HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
+        },
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Master Playback Switch",
+                .info = snd_hda_mixer_amp_switch_info,
+                .get = snd_hda_mixer_amp_switch_get,
+                .put = vaio_master_sw_put,
+                .private_value = HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
+        },
+        /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
+        HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
+        /*HDA_CODEC_MUTE("Optical Out Switch", 0x10, 0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Optical Out Volume", 0x10, 0, HDA_OUTPUT),*/
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Capture Source",
+                .count = 1,
+                .info = stac92xx_mux_enum_info,
+                .get = stac92xx_mux_enum_get,
+                .put = stac92xx_mux_enum_put,
+        },
+        {0}
+};
+
+static struct hda_codec_ops stac9872_patch_ops = {
+        .build_controls = stac92xx_build_controls,
+        .build_pcms = stac92xx_build_pcms,
+        .init = stac92xx_init,
+        .free = stac92xx_free,
 #ifdef CONFIG_PM
-    .resume = stac92xx_resume,
+        .resume = stac92xx_resume,
 #endif
 };
 
-enum { STAC7661_VAIO };
-
-static struct hda_board_config stac7661_cfg_tbl[] = {
-    { .modelname = "vaio", .config = STAC7661_VAIO },
-    { .pci_subvendor = 0x104d, .pci_subdevice = 0x81e6,
-    .config = STAC7661_VAIO },
-    { .pci_subvendor = 0x104d, .pci_subdevice = 0x81ef,
-    .config = STAC7661_VAIO },
-    {0}
-};
-
-static int patch_stac7661(struct hda_codec *codec)
-{
-    struct sigmatel_spec *spec;
-    int board_config;
-
-    board_config = snd_hda_check_board_config(codec, stac7661_cfg_tbl);
-    if (board_config < 0)
-        /* unknown config, let generic-parser do its job... */
-        return snd_hda_parse_generic_codec(codec);
-
-    spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
-    if (spec == NULL)
-        return -ENOMEM;
-
-    codec->spec = spec;
-    switch (board_config) {
-    case STAC7661_VAIO:
-        spec->mixer = vaio_mixer;
-        spec->init = vaio_init;
-        spec->multiout.max_channels = 2;
-        spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
-        spec->multiout.dac_nids = vaio_dacs;
-        spec->multiout.hp_nid = VAIO_HP_DAC;
-        spec->num_adcs = ARRAY_SIZE(vaio_adcs);
-        spec->adc_nids = vaio_adcs;
-        spec->input_mux = &vaio_mux;
-        spec->mux_nids = vaio_mux_nids;
-        break;
-    }
-
-    codec->patch_ops = stac7661_patch_ops;
-    return 0;
-}
-
-
-         /*
+enum { /* FE and SZ series. id=0x83847661 and subsys=0x104D0700 or 104D1000. */
+       CXD9872RD_VAIO,
+       /* Unknown. id=0x83847662 and subsys=0x104D1200 or 104D1000. */
+       STAC9872AK_VAIO, 
+       /* Unknown. id=0x83847661 and subsys=0x104D1200. */
+       STAC9872K_VAIO,
+       /* AR Series. id=0x83847664 and subsys=104D1300 */
+       CXD9872AKD_VAIO,
+       STAC_9872_MODELS,
+};
+
+static const char *stac9872_models[STAC_9872_MODELS] = {
+        [CXD9872RD_VAIO]        = "vaio",
+        [CXD9872AKD_VAIO]       = "vaio-ar",
+};
+
+static struct snd_pci_quirk stac9872_cfg_tbl[] = {
+        SND_PCI_QUIRK(0x104d, 0x81e6, "Sony VAIO F/S", CXD9872RD_VAIO),
+        SND_PCI_QUIRK(0x104d, 0x81ef, "Sony VAIO F/S", CXD9872RD_VAIO),
+        SND_PCI_QUIRK(0x104d, 0x81fd, "Sony VAIO AR", CXD9872AKD_VAIO),
+        {0}
+};
+
+static int patch_stac9872(struct hda_codec *codec)
+{
+        struct sigmatel_spec *spec;
+        int board_config;
+
+        board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS,
+                                                  stac9872_models,
+                                                  stac9872_cfg_tbl);
+        if (board_config < 0)
+                /* unknown config, let generic-parser do its job... */
+                return snd_hda_parse_generic_codec(codec);
+        
+        spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
+        if (spec == NULL)
+                return -ENOMEM;
+
+        codec->spec = spec;
+        switch (board_config) {
+        case CXD9872RD_VAIO:
+        case STAC9872AK_VAIO:
+        case STAC9872K_VAIO:
+                spec->mixer = vaio_mixer;
+                spec->init = vaio_init;
+                spec->multiout.max_channels = 2;
+                spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
+                spec->multiout.dac_nids = vaio_dacs;
+                spec->multiout.hp_nid = VAIO_HP_DAC;
+                spec->num_adcs = ARRAY_SIZE(vaio_adcs);
+                spec->adc_nids = vaio_adcs;
+                spec->input_mux = &vaio_mux;
+                spec->mux_nids = vaio_mux_nids;
+                break;
+        
+        case CXD9872AKD_VAIO:
+                spec->mixer = vaio_ar_mixer;
+                spec->init = vaio_ar_init;
+                spec->multiout.max_channels = 2;
+                spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
+                spec->multiout.dac_nids = vaio_dacs;
+                spec->multiout.hp_nid = VAIO_HP_DAC;
+                spec->num_adcs = ARRAY_SIZE(vaio_adcs);
+                spec->adc_nids = vaio_adcs;
+                spec->input_mux = &vaio_mux;
+                spec->mux_nids = vaio_mux_nids;
+                break;
+        }
+
+        codec->patch_ops = stac9872_patch_ops;
+        return 0;
+}
+
+
+/*
  * patch entries
  */
@@ -1515 +2119 @@
         { .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 },
         { .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x },
-        { .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x },
-        { .id = 0x83847618, .name = "STAC9227", .patch = patch_stac922x },
-        { .id = 0x83847619, .name = "STAC9227", .patch = patch_stac922x },
-        { .id = 0x83847616, .name = "STAC9228", .patch = patch_stac922x },
-        { .id = 0x83847617, .name = "STAC9228", .patch = patch_stac922x },
-        { .id = 0x83847614, .name = "STAC9229", .patch = patch_stac922x },
-        { .id = 0x83847615, .name = "STAC9229", .patch = patch_stac922x },
+        { .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x },
         { .id = 0x83847880, .name = "STAC9220 A2", .patch = patch_stac922x },
         { .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x },
         { .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x },
-        { .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x },
-        { .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x },
-        { .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x },
-        { .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x },
-        { .id = 0x83847623, .name = "STAC9273D", .patch = patch_stac927x },
-        { .id = 0x83847624, .name = "STAC9272X", .patch = patch_stac927x },
-        { .id = 0x83847625, .name = "STAC9272D", .patch = patch_stac927x },
-        { .id = 0x83847626, .name = "STAC9271X", .patch = patch_stac927x },
-        { .id = 0x83847627, .name = "STAC9271D", .patch = patch_stac927x },
-        { .id = 0x83847628, .name = "STAC9274X5NH", .patch = patch_stac927x },
-        { .id = 0x83847629, .name = "STAC9274D5NH", .patch = patch_stac927x },
-        { .id = 0x83847661, .name = "STAC7661", .patch = patch_stac7661 },
+        { .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x },
+        { .id = 0x83847618, .name = "STAC9227", .patch = patch_stac927x },
+        { .id = 0x83847619, .name = "STAC9227", .patch = patch_stac927x },
+        { .id = 0x83847616, .name = "STAC9228", .patch = patch_stac927x },
+        { .id = 0x83847617, .name = "STAC9228", .patch = patch_stac927x },
+        { .id = 0x83847614, .name = "STAC9229", .patch = patch_stac927x },
+        { .id = 0x83847615, .name = "STAC9229", .patch = patch_stac927x },
+        { .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x },
+        { .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x },
+        { .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x },
+        { .id = 0x83847623, .name = "STAC9273D", .patch = patch_stac927x },
+        { .id = 0x83847624, .name = "STAC9272X", .patch = patch_stac927x },
+        { .id = 0x83847625, .name = "STAC9272D", .patch = patch_stac927x },
+        { .id = 0x83847626, .name = "STAC9271X", .patch = patch_stac927x },
+        { .id = 0x83847627, .name = "STAC9271D", .patch = patch_stac927x },
+        { .id = 0x83847628, .name = "STAC9274X5NH", .patch = patch_stac927x },
+        { .id = 0x83847629, .name = "STAC9274D5NH", .patch = patch_stac927x },
+        /* The following does not take into account .id=0x83847661 when subsys =
+         * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are
+         * currently not fully supported.
+         */
+        { .id = 0x83847661, .name = "CXD9872RD/K", .patch = patch_stac9872 },
+        { .id = 0x83847662, .name = "STAC9872AK", .patch = patch_stac9872 },
+        { .id = 0x83847664, .name = "CXD9872AKD", .patch = patch_stac9872 },
+        { .id = 0x838476a0, .name = "STAC9205", .patch = patch_stac9205 },
+        { .id = 0x838476a1, .name = "STAC9205D", .patch = patch_stac9205 },
+        { .id = 0x838476a2, .name = "STAC9204", .patch = patch_stac9205 },
+        { .id = 0x838476a3, .name = "STAC9204D", .patch = patch_stac9205 },
+        { .id = 0x838476a4, .name = "STAC9255", .patch = patch_stac9205 },
+        { .id = 0x838476a5, .name = "STAC9255D", .patch = patch_stac9205 },
+        { .id = 0x838476a6, .name = "STAC9254", .patch = patch_stac9205 },
+        { .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 },
         {0} /* terminator */
 };

GPL/trunk/alsa-kernel/pci/intel8x0.c

@@ -2294 +2294 @@
     /* put logic to right state */
     /* first clear status bits */
-#if 1 // noone do it. wtf? //vladest 06.10.2003 13:51
     status = ICH_RCS | ICH_MCINT | ICH_POINT | ICH_PIINT;
     if (chip->device_type == DEVICE_NFORCE)
@@ -2300 +2299 @@
     cnt = igetdword(chip, ICHREG(GLOB_STA));
     iputdword(chip, ICHREG(GLOB_STA), cnt & status);
-#endif
-    // hmm. at least we should try
-    //iputdword(chip, ICHREG(GLOB_CNT), igetdword(chip, ICHREG(GLOB_CNT)) & ~ICH_AC97COLD);
     /* ACLink on, 2 channels */
     cnt = igetdword(chip, ICHREG(GLOB_CNT));
-    // added by vladest
     //    cnt &= ~ICH_ACLINK;
     cnt &= ~(ICH_ACLINK | ICH_PCM_246_MASK);
-#ifdef CONFIG_SND_AC97_POWER_SAVE
+#if 0
+    //def CONFIG_SND_AC97_POWER_SAVE
     /* do cold reset - the full ac97 powerdown may leave the controller
      * in a warm state but actually it cannot communicate with the codec.
@@ -2319 +2315 @@
 #else
     cnt |= (cnt & ICH_AC97COLD) == 0 ? ICH_AC97COLD : ICH_AC97WARM;
-
-    //  ??? 25.03.2004 by vladest  cnt &= ~(ICH_ACLINK | ICH_PCM_246_MASK);
-    // FIXME!!! cmi drivers didnt uses ICH_PCM_246_MASK
     /* finish cold or do warm reset */
 #ifdef DEBUG
@@ -2327 +2320 @@
 #endif
     iputdword(chip, ICHREG(GLOB_CNT), cnt);
-//    mdelay(500); //vladest 06.10.2003 15:08
+    mdelay(500); //vladest 06.10.2003 15:08
     end_time = (jiffies + (HZ / 4)) + 1;
     i = 0;