Changeset 464

Timestamp:

Oct 8, 2009, 10:35:00 AM (16 years ago)

Author:

Paul Smedley

Message:

Update ALSA kernel to 1.0.21 level

Location:

GPL/trunk/alsa-kernel

Files:

• core/control.c (modified) (5 diffs)
• core/info.c (modified) (1 diff)
• core/init.c (modified) (6 diffs)
• core/memalloc.c (modified) (2 diffs)
• core/misc.c (modified) (2 diffs)
• core/oss/pcm_oss.c (modified) (2 diffs)
• core/pcm_lib.c (modified) (22 diffs)
• core/pcm_memory.c (modified) (2 diffs)
• core/pcm_native.c (modified) (18 diffs)
• core/rawmidi.c (modified) (1 diff)
• core/seq/oss/seq_oss_midi.c (modified) (2 diffs)
• core/seq/seq_midi.c (modified) (3 diffs)
• core/seq/seq_midi_event.c (modified) (1 diff)
• core/vmaster.c (modified) (2 diffs)
• include/sound/ac97_codec.h (modified) (2 diffs)
• include/sound/asound.h (modified) (2 diffs)
• include/sound/config.h (modified) (1 diff)
• include/sound/core.h (modified) (6 diffs)
• include/sound/memalloc.h (modified) (3 diffs)
• include/sound/pcm.h (modified) (5 diffs)
• include/sound/soc-dapm.h (modified) (6 diffs)
• include/sound/soc.h (modified) (9 diffs)
• include/sound/tlv.h (modified) (2 diffs)
• include/sound/ymfpci.h (modified) (1 diff)
• isa/cmi8330.c (modified) (20 diffs)
• isa/es1688/es1688.c (modified) (1 diff)
• isa/gus/gus_pcm.c (modified) (2 diffs)
• isa/gus/gusextreme.c (modified) (1 diff)
• pci/ac97/ac97_patch.c (modified) (1 diff)
• pci/ali5451/ali5451.c (modified) (5 diffs)
• pci/atiixp.c (modified) (1 diff)
• pci/au88x0/au8810.c (modified) (1 diff)
• pci/au88x0/au8820.c (modified) (1 diff)
• pci/au88x0/au8830.c (modified) (1 diff)
• pci/au88x0/au88x0_core.c (modified) (3 diffs)
• pci/bt87x.c (modified) (3 diffs)
• pci/ca0106/ca0106_main.c (modified) (3 diffs)
• pci/ca0106/ca0106_mixer.c (modified) (4 diffs)
• pci/cmipci.c (modified) (1 diff)
• pci/cs4281.c (modified) (1 diff)
• pci/cs46xx/cs46xx.c (modified) (1 diff)
• pci/emu10k1/emu10k1.c (modified) (1 diff)
• pci/emu10k1/emu10k1x.c (modified) (2 diffs)
• pci/emu10k1/emupcm.c (modified) (1 diff)
• pci/emu10k1/p16v.c (modified) (1 diff)
• pci/ens1370.c (modified) (1 diff)
• pci/es1938.c (modified) (1 diff)
• pci/hda/hda_beep.h (modified) (1 diff)
• pci/hda/hda_codec.c (modified) (35 diffs)
• pci/hda/hda_codec.h (modified) (7 diffs)
• pci/hda/hda_generic.c (modified) (2 diffs)
• pci/hda/hda_hwdep.c (modified) (13 diffs)
• pci/hda/hda_intel.c (modified) (56 diffs)
• pci/hda/hda_local.h (modified) (2 diffs)
• pci/hda/hda_proc.c (modified) (3 diffs)
• pci/hda/patch_analog.c (modified) (19 diffs)
• pci/hda/patch_atihdmi.c (modified) (1 diff)
• pci/hda/patch_cmedia.c (modified) (1 diff)
• pci/hda/patch_conexant.c (modified) (7 diffs)
• pci/hda/patch_realtek.c (modified) (286 diffs)
• pci/hda/patch_sigmatel.c (modified) (133 diffs)
• pci/hda/patch_via.c (modified) (29 diffs)
• pci/intel8x0.c (modified) (5 diffs)
• pci/korg1212/korg1212.c (modified) (2 diffs)
• pci/nm256/nm256.c (modified) (1 diff)
• pci/rme96.c (modified) (1 diff)
• pci/rme9652/hdsp.c (modified) (9 diffs)
• pci/rme9652/hdspm.c (modified) (3 diffs)
• pci/sonicvibes.c (modified) (1 diff)
• pci/via82xx.c (modified) (4 diffs)
• pci/ymfpci/ymfpci.c (modified) (1 diff)
• pci/ymfpci/ymfpci_main.c (modified) (4 diffs)

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

@@ -421 +421 @@
 
 /**
- * snd_ctl_remove_unlocked_id - remove the unlocked control of the given id and release it
+ * snd_ctl_remove_user_ctl - remove and release the unlocked user control
  * @file: active control handle
  * @id: the control id to remove
@@ -430 +430 @@
  * Returns 0 if successful, or a negative error code on failure.
  */
-static int snd_ctl_remove_unlocked_id(struct snd_ctl_file * file,
-                                      struct snd_ctl_elem_id *id)
+static int snd_ctl_remove_user_ctl(struct snd_ctl_file * file,
+                                   struct snd_ctl_elem_id *id)
 {
         struct snd_card *card = file->card;
@@ -440 +440 @@
         kctl = snd_ctl_find_id(card, id);
         if (kctl == NULL) {
-                up_write(&card->controls_rwsem);
-                return -ENOENT;
+                ret = -ENOENT;
+                goto error;
+        }
+        if (!(kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_USER)) {
+                ret = -EINVAL;
+                goto error;
         }
         for (idx = 0; idx < kctl->count; idx++)
                 if (kctl->vd[idx].owner != NULL && kctl->vd[idx].owner != file) {
-                        up_write(&card->controls_rwsem);
-                        return -EBUSY;
+                        ret = -EBUSY;
+                        goto error;
                 }
         ret = snd_ctl_remove(card, kctl);
+        if (ret < 0)
+                goto error;
+        card->user_ctl_count--;
+error:
         up_write(&card->controls_rwsem);
         return ret;
@@ -958 +966 @@
         if (card->user_ctl_count >= MAX_USER_CONTROLS)
                 return -ENOMEM;
-        if (info->count > 1024)
+        if (info->count < 1)
                 return -EINVAL;
         access = info->access == 0 ? SNDRV_CTL_ELEM_ACCESS_READWRITE :
@@ -1059 +1067 @@
 {
         struct snd_ctl_elem_id id;
-        int err;
 
         if (copy_from_user(&id, _id, sizeof(id)))
                 return -EFAULT;
-        err = snd_ctl_remove_unlocked_id(file, &id);
-        if (! err) {
-                struct snd_card *card = file->card;
-                down_write(&card->controls_rwsem);
-                card->user_ctl_count--;
-                up_write(&card->controls_rwsem);
-        }
-        return err;
+        return snd_ctl_remove_user_ctl(file, &id);
 }
 

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

@@ -89 +89 @@
 
         nsize = PAGE_ALIGN(nsize);
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 22) || \
+        defined(CONFIG_SND_DEBUG_MEMORY)
         nbuf = kmalloc(nsize, GFP_KERNEL);
+        if (!nbuf)
+                return -ENOMEM;
+        memcpy(nbuf, buffer->buffer, buffer->len);
+        kfree(buffer->buffer);
+#else   
+        nbuf = krealloc(buffer->buffer, nsize, GFP_KERNEL);
         if (! nbuf)
                 return -ENOMEM;
-
-        memcpy(nbuf, buffer->buffer, buffer->len);
-        kfree(buffer->buffer);
+#endif
+
         buffer->buffer = nbuf;
         buffer->len = nsize;

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

@@ -165 +165 @@
         if (!card)
                 return -ENOMEM;
-        if (xid) {
-                if (!snd_info_check_reserved_words(xid)) {
-                        snd_printk(KERN_ERR
-                                   "given id string '%s' is reserved.\n", xid);
-                        err = -EBUSY;
-                        goto __error;
-                }
+        if (xid)
                 strlcpy(card->id, xid, sizeof(card->id));
-        }
         err = 0;
         mutex_lock(&snd_card_mutex);
@@ -516 +509 @@
 EXPORT_SYMBOL(snd_card_free);
 
-static void choose_default_id(struct snd_card *card)
+static void snd_card_set_id_no_lock(struct snd_card *card, const char *nid)
 {
         int i, len, idx_flag = 0, loops = SNDRV_CARDS;
-        char *id, *spos;
-
-        id = spos = card->shortname;
-        while (*id != '\0') {
-                if (*id == ' ')
-                        spos = id + 1;
-                id++;
+        const char *spos, *src;
+        char *id;
+        
+        if (nid == NULL) {
+                id = card->shortname;
+                spos = src = id;
+                while (*id != '\0') {
+                        if (*id == ' ')
+                                spos = id + 1;
+                        id++;
+                }
+        } else {
+                spos = src = nid;
         }
         id = card->id;
@@ -531 +530 @@
                 spos++;
         if (isdigit(*spos))
-                *id++ = isalpha(card->shortname[0]) ? card->shortname[0] : 'D';
+                *id++ = isalpha(src[0]) ? src[0] : 'D';
         while (*spos != '\0' && (size_t)(id - card->id) < sizeof(card->id) - 1) {
                 if (isalnum(*spos))
@@ -546 +545 @@
         while (1) {
                 if (loops-- == 0) {
-                        snd_printk(KERN_ERR "unable to choose default card id (%s)\n", id);
+                        snd_printk(KERN_ERR "unable to set card id (%s)\n", id);
                         strcpy(card->id, card->proc_root->name);
                         return;
@@ -572 +571 @@
                         if ((size_t)len <= sizeof(card->id) - 2)
                                 spos++;
-                        *spos++ = '_';
-                        *spos++ = '1';
-                        *spos++ = '\0';
+                        *(char *)spos++ = '_';
+                        *(char *)spos++ = '1';
+                        *(char *)spos++ = '\0';
                         idx_flag++;
                 }
         }
 }
+
+/**
+ *  snd_card_set_id - set card identification name
+ *  @card: soundcard structure
+ *  @nid: new identification string
+ *
+ *  This function sets the card identification and checks for name
+ *  collisions.
+ */
+void snd_card_set_id(struct snd_card *card, const char *nid)
+{
+        /* check if user specified own card->id */
+        if (card->id[0] != '\0')
+                return;
+        mutex_lock(&snd_card_mutex);
+        snd_card_set_id_no_lock(card, nid);
+        mutex_unlock(&snd_card_mutex);
+}
+EXPORT_SYMBOL(snd_card_set_id);
 
 #ifndef CONFIG_SYSFS_DEPRECATED
@@ -673 +691 @@
                 return 0;
         }
-        if (card->id[0] == '\0')
-                choose_default_id(card);
+        snd_card_set_id_no_lock(card, card->id[0] == '\0' ? NULL : card->id);
         snd_cards[card->number] = card;
         mutex_unlock(&snd_card_mutex);

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

@@ -236 +236 @@
                 dmab->area = snd_malloc_dev_pages(device, size, &dmab->addr);
                 break;
+#endif
+#ifdef CONFIG_SND_DMA_SGBUF
         case SNDRV_DMA_TYPE_DEV_SG:
                 snd_malloc_sgbuf_pages(device, size, dmab, NULL);
@@ -306 +308 @@
                 snd_free_dev_pages(dmab->dev.dev, dmab->bytes, dmab->area, dmab->addr);
                 break;
+#endif
+#ifdef CONFIG_SND_DMA_SGBUF
         case SNDRV_DMA_TYPE_DEV_SG:
                 snd_free_sgbuf_pages(dmab);

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

@@ -25 +25 @@
 #include <sound/core.h>
 
+#ifdef CONFIG_SND_DEBUG
+
+#ifdef CONFIG_SND_DEBUG_VERBOSE
+#define DEFAULT_DEBUG_LEVEL     2
+#else
+#define DEFAULT_DEBUG_LEVEL     1
+#endif
+
+static int debug = DEFAULT_DEBUG_LEVEL;
+module_param(debug, int, 0644);
+MODULE_PARM_DESC(debug, "Debug level (0 = disable)");
+
+#endif /* CONFIG_SND_DEBUG */
+
 void release_and_free_resource(struct resource *res)
 {
@@ -36 +50 @@
 
 #ifdef CONFIG_SND_VERBOSE_PRINTK
-void snd_verbose_printk(const char *file, int line, const char *format, ...)
+/* strip the leading path if the given path is absolute */
+static const char *sanity_file_name(const char *path)
+{
+        if (*path == '/')
+                return strrchr(path, '/') + 1;
+        else
+                return path;
+}
+
+/* print file and line with a certain printk prefix */
+static int print_snd_pfx(unsigned int level, const char *path, int line,
+                         const char *format)
+{
+        const char *file = sanity_file_name(path);
+        char tmp[] = "<0>";
+        const char *pfx = level ? KERN_DEBUG : KERN_DEFAULT;
+        int ret = 0;
+
+        if (format[0] == '<' && format[2] == '>') {
+                tmp[1] = format[1];
+                pfx = tmp;
+                ret = 1;
+        }
+        printk("%sALSA %s:%d: ", pfx, file, line);
+        return ret;
+}
+#else
+#define print_snd_pfx(level, path, line, format)        0
+#endif
+
+#if defined(CONFIG_SND_DEBUG) || defined(CONFIG_SND_VERBOSE_PRINTK)
+void __snd_printk(unsigned int level, const char *path, int line,
+                  const char *format, ...)
 {
         va_list args;
         
-        if (format[0] == '<' && format[1] >= '0' && format[1] <= '7' && format[2] == '>') {
-                char tmp[] = "<0>";
-                tmp[1] = format[1];
-                printk("%sALSA %s:%d: ", tmp, file, line);
-                format += 3;
-        } else {
-                printk("ALSA %s:%d: ", file, line);
-        }
+#ifdef CONFIG_SND_DEBUG 
+        if (debug < level)
+                return;
+#endif
         va_start(args, format);
+        if (print_snd_pfx(level, path, line, format))
+                format += 3; /* skip the printk level-prefix */
         vprintk(format, args);
         va_end(args);
 }
-
-EXPORT_SYMBOL(snd_verbose_printk);
-#endif
-
-#if defined(CONFIG_SND_DEBUG) && defined(CONFIG_SND_VERBOSE_PRINTK)
-void snd_verbose_printd(const char *file, int line, const char *format, ...)
-{
-        va_list args;
-        
-        if (format[0] == '<' && format[1] >= '0' && format[1] <= '7' && format[2] == '>') {
-                char tmp[] = "<0>";
-                tmp[1] = format[1];
-                printk("%sALSA %s:%d: ", tmp, file, line);
-                format += 3;
-        } else {
-                printk(KERN_DEBUG "ALSA %s:%d: ", file, line);
-        }
-        va_start(args, format);
-        vprintk(format, args);
-        va_end(args);
-
-}
-
-EXPORT_SYMBOL(snd_verbose_printd);
+EXPORT_SYMBOL_GPL(__snd_printk);
 #endif
 

GPL/trunk/alsa-kernel/core/oss/pcm_oss.c

@@ -32 +32 @@
 #include <linux/vmalloc.h>
 #include <linux/moduleparam.h>
+#include <linux/math64.h>
 #include <linux/string.h>
 #include <sound/core.h>
@@ -626 +627 @@
         {
                 u64 bsize = (u64)runtime->oss.buffer_bytes * (u64)bytes;
-                u32 rem;
-                div64_32(&bsize, buffer_size, &rem);
-                return (long)bsize;
+                return div_u64(bsize, buffer_size);
         }
 #endif

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

@@ -23 +23 @@
 #include <linux/slab.h>
 #include <linux/time.h>
+#include <linux/math64.h>
 #include <sound/core.h>
 #include <sound/control.h>
@@ -127 +128 @@
 
 #ifdef CONFIG_SND_PCM_XRUN_DEBUG
-#define xrun_debug(substream)   ((substream)->pstr->xrun_debug)
+#define xrun_debug(substream, mask)     ((substream)->pstr->xrun_debug & (mask))
 #else
-#define xrun_debug(substream)   0
+#define xrun_debug(substream, mask)     0
 #endif
 
-#define dump_stack_on_xrun(substream) do {      \
-                if (xrun_debug(substream) > 1)  \
-                        dump_stack();           \
+#define dump_stack_on_xrun(substream) do {              \
+                if (xrun_debug(substream, 2))           \
+                        dump_stack();                   \
         } while (0)
 
+static void pcm_debug_name(struct snd_pcm_substream *substream,
+                           char *name, size_t len)
+{
+        snprintf(name, len, "pcmC%dD%d%c:%d",
+                 substream->pcm->card->number,
+                 substream->pcm->device,
+                 substream->stream ? 'c' : 'p',
+                 substream->number);
+}
+
 static void xrun(struct snd_pcm_substream *substream)
 {
+        struct snd_pcm_runtime *runtime = substream->runtime;
+
+        if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE)
+                snd_pcm_gettime(runtime, (struct timespec *)&runtime->status->tstamp);
         snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
-        if (xrun_debug(substream)) {
-                snd_printd(KERN_DEBUG "XRUN: pcmC%dD%d%c\n",
-                           substream->pcm->card->number,
-                           substream->pcm->device,
-                           substream->stream ? 'c' : 'p');
+        if (xrun_debug(substream, 1)) {
+                char name[16];
+                pcm_debug_name(substream, name, sizeof(name));
+                snd_printd(KERN_DEBUG "XRUN: %s\n", name);
                 dump_stack_on_xrun(substream);
         }
@@ -155 +169 @@
         snd_pcm_uframes_t pos;
 
-        if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE)
-                snd_pcm_gettime(runtime, (struct timespec *)&runtime->status->tstamp);
         pos = substream->ops->pointer(substream);
         if (pos == SNDRV_PCM_POS_XRUN)
@@ -162 +174 @@
         if (pos >= runtime->buffer_size) {
                 if (printk_ratelimit()) {
-                        snd_printd(KERN_ERR  "BUG: stream = %i, pos = 0x%lx, "
+                        char name[16];
+                        pcm_debug_name(substream, name, sizeof(name));
+                        snd_printd(KERN_ERR  "BUG: %s, pos = 0x%lx, "
                                    "buffer size = 0x%lx, period size = 0x%lx\n",
-                                   substream->stream, pos, runtime->buffer_size,
+                                   name, pos, runtime->buffer_size,
                                    runtime->period_size);
                 }
@@ -184 +198 @@
         if (avail > runtime->avail_max)
                 runtime->avail_max = avail;
-        if (avail >= runtime->stop_threshold) {
-                if (substream->runtime->status->state == SNDRV_PCM_STATE_DRAINING)
+        if (runtime->status->state == SNDRV_PCM_STATE_DRAINING) {
+                if (avail >= runtime->buffer_size) {
                         snd_pcm_drain_done(substream);
-                else
+                        return -EPIPE;
+                }
+        } else {
+                if (avail >= runtime->stop_threshold) {
                         xrun(substream);
-                return -EPIPE;
+                        return -EPIPE;
+                }
         }
         if (avail >= runtime->control->avail_min)
@@ -199 +217 @@
 #define hw_ptr_error(substream, fmt, args...)                           \
         do {                                                            \
-                if (xrun_debug(substream)) {                            \
+                if (xrun_debug(substream, 1)) {                         \
                         if (printk_ratelimit()) {                       \
                                 snd_printd("PCM: " fmt, ##args);        \
@@ -223 +241 @@
                 return -EPIPE;
         }
+        if (xrun_debug(substream, 8)) {
+                char name[16];
+                pcm_debug_name(substream, name, sizeof(name));
+                snd_printd("period_update: %s: pos=0x%x/0x%x/0x%x, "
+                           "hwptr=0x%lx, hw_base=0x%lx, hw_intr=0x%lx\n",
+                           name, (unsigned int)pos,
+                           (unsigned int)runtime->period_size,
+                           (unsigned int)runtime->buffer_size,
+                           (unsigned long)old_hw_ptr,
+                           (unsigned long)runtime->hw_ptr_base,
+                           (unsigned long)runtime->hw_ptr_interrupt);
+        }
         hw_base = runtime->hw_ptr_base;
         new_hw_ptr = hw_base + pos;
@@ -234 +264 @@
         }
         if (delta < 0) {
-                delta += runtime->buffer_size;
+                if (runtime->periods == 1 || new_hw_ptr < old_hw_ptr)
+                        delta += runtime->buffer_size;
                 if (delta < 0) {
                         hw_ptr_error(substream, 
@@ -241 +272 @@
                                      substream->stream, (long)pos,
                                      (long)hw_ptr_interrupt);
+#if 1
+                        /* simply skipping the hwptr update seems more
+                         * robust in some cases, e.g. on VMware with
+                         * inaccurate timer source
+                         */
+                        return 0; /* skip this update */
+#else
                         /* rebase to interrupt position */
                         hw_base = new_hw_ptr = hw_ptr_interrupt;
@@ -246 +284 @@
                         hw_base -= hw_base % runtime->buffer_size;
                         delta = 0;
+#endif
                 } else {
                         hw_base += runtime->buffer_size;
@@ -253 +292 @@
                 }
         }
+
+        /* Do jiffies check only in xrun_debug mode */
+        if (!xrun_debug(substream, 4))
+                goto no_jiffies_check;
+
         /* Skip the jiffies check for hardwares with BATCH flag.
          * Such hardware usually just increases the position at each IRQ,
@@ -260 +304 @@
                 goto no_jiffies_check;
         hdelta = new_hw_ptr - old_hw_ptr;
+        if (hdelta < runtime->delay)
+                goto no_jiffies_check;
+        hdelta -= runtime->delay;
         jdelta = jiffies - runtime->hw_ptr_jiffies;
         if (((hdelta * HZ) / runtime->rate) > jdelta + HZ/100) {
@@ -293 +340 @@
                         new_hw_ptr - new_hw_ptr % runtime->period_size;
         }
+        runtime->hw_ptr_interrupt = hw_ptr_interrupt;
+
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
             runtime->silence_size > 0)
                 snd_pcm_playback_silence(substream, new_hw_ptr);
 
+        if (runtime->status->hw_ptr == new_hw_ptr)
+                return 0;
+
         runtime->hw_ptr_base = hw_base;
         runtime->status->hw_ptr = new_hw_ptr;
         runtime->hw_ptr_jiffies = jiffies;
-        runtime->hw_ptr_interrupt = hw_ptr_interrupt;
+        if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE)
+                snd_pcm_gettime(runtime, (struct timespec *)&runtime->status->tstamp);
 
         return snd_pcm_update_hw_ptr_post(substream, runtime);
@@ -320 +373 @@
                 return -EPIPE;
         }
+        if (xrun_debug(substream, 16)) {
+                char name[16];
+                pcm_debug_name(substream, name, sizeof(name));
+                snd_printd("hw_update: %s: pos=0x%x/0x%x/0x%x, "
+                           "hwptr=0x%lx, hw_base=0x%lx, hw_intr=0x%lx\n",
+                           name, (unsigned int)pos,
+                           (unsigned int)runtime->period_size,
+                           (unsigned int)runtime->buffer_size,
+                           (unsigned long)old_hw_ptr,
+                           (unsigned long)runtime->hw_ptr_base,
+                           (unsigned long)runtime->hw_ptr_interrupt);
+        }
+
         hw_base = runtime->hw_ptr_base;
         new_hw_ptr = hw_base + pos;
@@ -340 +406 @@
                 new_hw_ptr = hw_base + pos;
         }
+        /* Do jiffies check only in xrun_debug mode */
+        if (!xrun_debug(substream, 4))
+                goto no_jiffies_check;
+        if (delta < runtime->delay)
+                goto no_jiffies_check;
+        delta -= runtime->delay;
         if (((delta * HZ) / runtime->rate) > jdelta + HZ/100) {
                 hw_ptr_error(substream,
@@ -349 +421 @@
                 return 0;
         }
+ no_jiffies_check:
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
             runtime->silence_size > 0)
                 snd_pcm_playback_silence(substream, new_hw_ptr);
 
+        if (runtime->status->hw_ptr == new_hw_ptr)
+                return 0;
+
         runtime->hw_ptr_base = hw_base;
         runtime->status->hw_ptr = new_hw_ptr;
         runtime->hw_ptr_jiffies = jiffies;
+        if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE)
+                snd_pcm_gettime(runtime, (struct timespec *)&runtime->status->tstamp);
 
         return snd_pcm_update_hw_ptr_post(substream, runtime);
@@ -449 +527 @@
                 return UINT_MAX;
         }
-        div64_32(&n, c, r);
+        n = div_u64_rem(n, c, r);
         if (n >= UINT_MAX) {
                 *r = 0;
@@ -873 +951 @@
 {
         unsigned int k;
-        int changed = 0;
+        struct snd_interval list_range;
 
         if (!count) {
@@ -879 +957 @@
                 return -EINVAL;
         }
+        snd_interval_any(&list_range);
+        list_range.min = UINT_MAX;
+        list_range.max = 0;
         for (k = 0; k < count; k++) {
                 if (mask && !(mask & (1 << k)))
                         continue;
-                if (i->min == list[k] && !i->openmin)
-                        goto _l1;
-                if (i->min < list[k]) {
-                        i->min = list[k];
-                        i->openmin = 0;
-                        changed = 1;
-                        goto _l1;
-                }
+                if (!snd_interval_test(i, list[k]))
+                        continue;
+                list_range.min = min(list_range.min, list[k]);
+                list_range.max = max(list_range.max, list[k]);
         }
-        i->empty = 1;
-        return -EINVAL;
- _l1:
-        for (k = count; k-- > 0;) {
-                if (mask && !(mask & (1 << k)))
-                        continue;
-                if (i->max == list[k] && !i->openmax)
-                        goto _l2;
-                if (i->max > list[k]) {
-                        i->max = list[k];
-                        i->openmax = 0;
-                        changed = 1;
-                        goto _l2;
-                }
-        }
-        i->empty = 1;
-        return -EINVAL;
- _l2:
-        if (snd_interval_checkempty(i)) {
-                i->empty = 1;
-                return -EINVAL;
-        }
-        return changed;
+        return snd_interval_refine(i, &list_range);
 }
 
@@ -1482 +1537 @@
         else
                 runtime->status->hw_ptr = 0;
-        runtime->hw_ptr_jiffies = jiffies;
         snd_pcm_stream_unlock_irqrestore(substream, flags);
         return 0;
@@ -1522 +1576 @@
 }
 
+static int snd_pcm_lib_ioctl_fifo_size(struct snd_pcm_substream *substream,
+                                       void *arg)
+{
+        struct snd_pcm_hw_params *params = arg;
+        snd_pcm_format_t format;
+        int channels, width;
+
+        params->fifo_size = substream->runtime->hw.fifo_size;
+        if (!(substream->runtime->hw.info & SNDRV_PCM_INFO_FIFO_IN_FRAMES)) {
+                format = params_format(params);
+                channels = params_channels(params);
+                width = snd_pcm_format_physical_width(format);
+                params->fifo_size /= width * channels;
+        }
+        return 0;
+}
+
 /**
  * snd_pcm_lib_ioctl - a generic PCM ioctl callback
@@ -1543 +1614 @@
         case SNDRV_PCM_IOCTL1_CHANNEL_INFO:
                 return snd_pcm_lib_ioctl_channel_info(substream, arg);
+        case SNDRV_PCM_IOCTL1_FIFO_SIZE:
+                return snd_pcm_lib_ioctl_fifo_size(substream, arg);
         }
         return -ENXIO;

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

@@ -305 +305 @@
 EXPORT_SYMBOL(snd_pcm_lib_preallocate_pages_for_all);
 
+#ifdef CONFIG_SND_DMA_SGBUF
 /**
  * snd_pcm_sgbuf_ops_page - get the page struct at the given offset
@@ -350 +351 @@
 }
 EXPORT_SYMBOL(snd_pcm_sgbuf_get_chunk_size);
+#endif /* CONFIG_SND_DMA_SGBUF */
 
 /**

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

@@ -324 +324 @@
         hw = &substream->runtime->hw;
         if (!params->info)
-                params->info = hw->info;
-        if (!params->fifo_size)
-                params->fifo_size = hw->fifo_size;
+                params->info = hw->info & ~SNDRV_PCM_INFO_FIFO_IN_FRAMES;
+        if (!params->fifo_size) {
+                if (snd_mask_min(&params->masks[SNDRV_PCM_HW_PARAM_FORMAT]) ==
+                    snd_mask_max(&params->masks[SNDRV_PCM_HW_PARAM_FORMAT]) &&
+                    snd_mask_min(&params->masks[SNDRV_PCM_HW_PARAM_CHANNELS]) ==
+                    snd_mask_max(&params->masks[SNDRV_PCM_HW_PARAM_CHANNELS])) {
+                        changed = substream->ops->ioctl(substream,
+                                        SNDRV_PCM_IOCTL1_FIFO_SIZE, params);
+                        if (changed < 0)
+                                return changed;
+                }
+        }
         params->rmask = 0;
         return 0;
@@ -599 +608 @@
                 status->avail = snd_pcm_playback_avail(runtime);
                 if (runtime->status->state == SNDRV_PCM_STATE_RUNNING ||
-                    runtime->status->state == SNDRV_PCM_STATE_DRAINING)
+                    runtime->status->state == SNDRV_PCM_STATE_DRAINING) {
                         status->delay = runtime->buffer_size - status->avail;
-                else
+                        status->delay += runtime->delay;
+                } else
                         status->delay = 0;
         } else {
                 status->avail = snd_pcm_capture_avail(runtime);
                 if (runtime->status->state == SNDRV_PCM_STATE_RUNNING)
-                        status->delay = status->avail;
+                        status->delay = status->avail + runtime->delay;
                 else
                         status->delay = 0;
@@ -860 +870 @@
         struct snd_pcm_runtime *runtime = substream->runtime;
         snd_pcm_trigger_tstamp(substream);
+        runtime->hw_ptr_jiffies = jiffies;
         runtime->status->state = state;
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
@@ -973 +984 @@
         if (substream->runtime->trigger_master != substream)
                 return 0;
+        /* The jiffies check in snd_pcm_update_hw_ptr*() is done by
+         * a delta betwen the current jiffies, this gives a large enough
+         * delta, effectively to skip the check once.
+         */
+        substream->runtime->hw_ptr_jiffies = jiffies - HZ * 1000;
         return substream->ops->trigger(substream,
                                        push ? SNDRV_PCM_TRIGGER_PAUSE_PUSH :
@@ -1339 +1355 @@
 static int snd_pcm_pre_drain_init(struct snd_pcm_substream *substream, int state)
 {
-        if (substream->f_flags & O_NONBLOCK)
-                return -EAGAIN;
         substream->runtime->trigger_master = substream;
         return 0;
@@ -1388 +1402 @@
         struct snd_pcm_substream *substream;
         wait_queue_t wait;
-        snd_pcm_uframes_t stop_threshold;
 };
 
@@ -1400 +1413 @@
  * (capture only) state.
  */
-static int snd_pcm_drain(struct snd_pcm_substream *substream)
+static int snd_pcm_drain(struct snd_pcm_substream *substream,
+                         struct file *file)
 {
         struct snd_card *card;
@@ -1407 +1421 @@
         int result = 0;
         int i, num_drecs;
+        int nonblock = 0;
         struct drain_rec *drec, drec_tmp, *d;
 
@@ -1423 +1438 @@
                 }
         }
+
+        if (file) {
+                if (file->f_flags & O_NONBLOCK)
+                        nonblock = 1;
+        } else if (substream->f_flags & O_NONBLOCK)
+                nonblock = 1;
+
+        if (nonblock)
+                goto lock; /* no need to allocate waitqueues */
 
         /* allocate temporary record for drain sync */
@@ -1445 +1469 @@
                         init_waitqueue_entry(&d->wait, current);
                         add_wait_queue(&runtime->sleep, &d->wait);
-                        /* stop_threshold fixup to avoid endless loop when
-                         * stop_threshold > buffer_size
-                         */
-                        d->stop_threshold = runtime->stop_threshold;
-                        if (runtime->stop_threshold > runtime->buffer_size)
-                                runtime->stop_threshold = runtime->buffer_size;
                 }
         }
         up_read(&snd_pcm_link_rwsem);
 
+ lock:
         snd_pcm_stream_lock_irq(substream);
         /* resume pause */
@@ -1462 +1481 @@
         /* pre-start/stop - all running streams are changed to DRAINING state */
         result = snd_pcm_action(&snd_pcm_action_drain_init, substream, 0);
-        if (result < 0) {
-                snd_pcm_stream_unlock_irq(substream);
-                goto _error;
+        if (result < 0)
+                goto unlock;
+        /* in non-blocking, we don't wait in ioctl but let caller poll */
+        if (nonblock) {
+                result = -EAGAIN;
+                goto unlock;
         }
 
@@ -1500 +1522 @@
         }
 
+ unlock:
         snd_pcm_stream_unlock_irq(substream);
 
- _error:
-        for (i = 0; i < num_drecs; i++) {
-                d = &drec[i];
-                runtime = d->substream->runtime;
-                remove_wait_queue(&runtime->sleep, &d->wait);
-                runtime->stop_threshold = d->stop_threshold;
-        }
-
-        if (drec != &drec_tmp)
-                kfree(drec);
+        if (!nonblock) {
+                for (i = 0; i < num_drecs; i++) {
+                        d = &drec[i];
+                        runtime = d->substream->runtime;
+                        remove_wait_queue(&runtime->sleep, &d->wait);
+                }
+                if (drec != &drec_tmp)
+                        kfree(drec);
+        }
         snd_power_unlock(card);
 
@@ -2215 +2237 @@
                 ret = -EPIPE;
                 goto __end;
+        case SNDRV_PCM_STATE_SUSPENDED:
+                ret = -ESTRPIPE;
+                goto __end;
         default:
                 ret = -EBADFD;
@@ -2259 +2284 @@
         case SNDRV_PCM_STATE_XRUN:
                 ret = -EPIPE;
+                goto __end;
+        case SNDRV_PCM_STATE_SUSPENDED:
+                ret = -ESTRPIPE;
                 goto __end;
         default:
@@ -2306 +2334 @@
                 ret = -EPIPE;
                 goto __end;
+        case SNDRV_PCM_STATE_SUSPENDED:
+                ret = -ESTRPIPE;
+                goto __end;
         default:
                 ret = -EBADFD;
@@ -2351 +2382 @@
         case SNDRV_PCM_STATE_XRUN:
                 ret = -EPIPE;
+                goto __end;
+        case SNDRV_PCM_STATE_SUSPENDED:
+                ret = -ESTRPIPE;
                 goto __end;
         default:
@@ -2427 +2461 @@
                 else
                         n = snd_pcm_capture_avail(runtime);
+                n += runtime->delay;
                 break;
         case SNDRV_PCM_STATE_XRUN:
@@ -2550 +2585 @@
 #endif
         case SNDRV_PCM_IOCTL_DRAIN:
-                return snd_pcm_drain(substream);
+                return snd_pcm_drain(substream, file);
         case SNDRV_PCM_IOCTL_DROP:
                 return snd_pcm_drop(substream);

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

@@ -283 +283 @@
         substream->opened = 1;
         if (substream->use_count++ == 0)
-                substream->active_sensing = 1;
+                substream->active_sensing = 0;
         if (mode & SNDRV_RAWMIDI_LFLG_APPEND)
                 substream->append = 1;

GPL/trunk/alsa-kernel/core/seq/oss/seq_oss_midi.c

@@ -21 +21 @@
  */
 
+#include <sound/asoundef.h>
 #include "seq_oss_midi.h"
 #include "seq_oss_readq.h"
@@ -477 +478 @@
                 if (dp->seq_mode == SNDRV_SEQ_OSS_MODE_SYNTH) {
                         ev.type = SNDRV_SEQ_EVENT_SENSING;
-                        snd_seq_oss_dispatch(dp, &ev, 0, 0); /* active sensing */
+                        snd_seq_oss_dispatch(dp, &ev, 0, 0);
                 }
                 for (c = 0; c < 16; c++) {
                         ev.type = SNDRV_SEQ_EVENT_CONTROLLER;
                         ev.data.control.channel = c;
-                        ev.data.control.param = 123;
-                        snd_seq_oss_dispatch(dp, &ev, 0, 0); /* all notes off */
+                        ev.data.control.param = MIDI_CTL_ALL_NOTES_OFF;
+                        snd_seq_oss_dispatch(dp, &ev, 0, 0);
                         if (dp->seq_mode == SNDRV_SEQ_OSS_MODE_MUSIC) {
-                                ev.data.control.param = 121;
-                                snd_seq_oss_dispatch(dp, &ev, 0, 0); /* reset all controllers */
+                                ev.data.control.param =
+                                        MIDI_CTL_RESET_CONTROLLERS;
+                                snd_seq_oss_dispatch(dp, &ev, 0, 0);
                                 ev.type = SNDRV_SEQ_EVENT_PITCHBEND;
                                 ev.data.control.value = 0;
-                                snd_seq_oss_dispatch(dp, &ev, 0, 0); /* bender off */
+                                snd_seq_oss_dispatch(dp, &ev, 0, 0);
                         }
                 }

GPL/trunk/alsa-kernel/core/seq/seq_midi.c

@@ -121 +121 @@
         runtime = substream->runtime;
         if ((tmp = runtime->avail) < count) {
-                snd_printd("warning, output event was lost (count = %i, available = %i)\n", count, tmp);
+                if (printk_ratelimit())
+                        snd_printk(KERN_ERR "MIDI output buffer overrun\n");
                 return -ENOMEM;
         }
@@ -237 +238 @@
         params.avail_min = 1;
         params.buffer_size = output_buffer_size;
+        params.no_active_sensing = 1;
         if ((err = snd_rawmidi_output_params(msynth->output_rfile.output, &params)) < 0) {
                 snd_rawmidi_kernel_release(&msynth->output_rfile);
@@ -249 +251 @@
 {
         struct seq_midisynth *msynth = private_data;
-        unsigned char buf = 0xff; /* MIDI reset */
 
         if (snd_BUG_ON(!msynth->output_rfile.output))
                 return -EINVAL;
-        /* sending single MIDI reset message to shut the device up */
-        snd_rawmidi_kernel_write(msynth->output_rfile.output, &buf, 1);
         snd_rawmidi_drain_output(msynth->output_rfile.output);
         return snd_rawmidi_kernel_release(&msynth->output_rfile);

GPL/trunk/alsa-kernel/core/seq/seq_midi_event.c

@@ -505 +505 @@
                 return -ENOMEM;
         cmd = MIDI_CMD_CONTROL|(ev->data.control.channel & 0x0f);
-        bytes[0] = ev->data.control.param & 0x007f;
-        bytes[1] = (ev->data.control.param & 0x3f80) >> 7;
-        bytes[2] = ev->data.control.value & 0x007f;
-        bytes[3] = (ev->data.control.value & 0x3f80) >> 7;
+        bytes[0] = (ev->data.control.param & 0x3f80) >> 7;
+        bytes[1] = ev->data.control.param & 0x007f;
+        bytes[2] = (ev->data.control.value & 0x3f80) >> 7;
+        bytes[3] = ev->data.control.value & 0x007f;
         if (cmd != dev->lastcmd && !dev->nostat) {
                 if (count < 9)

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

@@ -354 +354 @@
  * The optional argument @tlv can be used to specify the TLV information
  * for dB scale of the master control.  It should be a single element
- * with #SNDRV_CTL_TLVT_DB_SCALE type, and should be the max 0dB.
+ * with #SNDRV_CTL_TLVT_DB_SCALE, #SNDRV_CTL_TLV_DB_MINMAX or
+ * #SNDRV_CTL_TLVT_DB_MINMAX_MUTE type, and should be the max 0dB.
  */
 struct snd_kcontrol *snd_ctl_make_virtual_master(char *name,
@@ -385 +386 @@
 
         /* additional (constant) TLV read */
-        if (tlv && tlv[0] == SNDRV_CTL_TLVT_DB_SCALE) {
+        if (tlv &&
+            (tlv[0] == SNDRV_CTL_TLVT_DB_SCALE ||
+             tlv[0] == SNDRV_CTL_TLVT_DB_MINMAX ||
+             tlv[0] == SNDRV_CTL_TLVT_DB_MINMAX_MUTE)) {
                 kctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_TLV_READ;
                 memcpy(master->tlv, tlv, sizeof(master->tlv));

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

@@ -32 +32 @@
 #include "control.h"
 #include "info.h"
+
+/* maximum number of devices on the AC97 bus */
+#define AC97_BUS_MAX_DEVICES    4
 
 /*
@@ -650 +653 @@
 extern struct bus_type ac97_bus_type;
 
+/* AC97 platform_data adding function */
+static inline void snd_ac97_dev_add_pdata(struct snd_ac97 *ac97, void *data)
+{
+        ac97->dev.platform_data = data;
+}
+
 #endif /* __SOUND_AC97_CODEC_H */

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

@@ -162 +162 @@
  *****************************************************************************/
 
-#define SNDRV_PCM_VERSION               SNDRV_PROTOCOL_VERSION(2, 0, 9)
+#define SNDRV_PCM_VERSION               SNDRV_PROTOCOL_VERSION(2, 0, 10)
 
 typedef unsigned long snd_pcm_uframes_t;
@@ -279 +279 @@
 #define SNDRV_PCM_INFO_JOINT_DUPLEX     0x00200000      /* playback and capture stream are somewhat correlated */
 #define SNDRV_PCM_INFO_SYNC_START       0x00400000      /* pcm support some kind of sync go */
+#define SNDRV_PCM_INFO_FIFO_IN_FRAMES   0x80000000      /* internal kernel flag - FIFO size is in frames */
 
 typedef int __bitwise snd_pcm_state_t;

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

@@ -85 +85 @@
 #define CONFIG_SND_DEBUG_DETECT
 #define CONFIG_SND_DEBUG_VERBOSE
+#define CONFIG_SND_DMA_SGBUF
 #define CONFIG_SND_HDA_CODEC_ANALOG
 #define CONFIG_SND_HDA_CODEC_ATIHDMI

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

@@ -324 +324 @@
                     struct snd_card **card_ret);
 
-static inline __deprecated
-struct snd_card *snd_card_new(int idx, const char *id,
-                              struct module *module, int extra_size)
-{
-        struct snd_card *card;
-        if (snd_card_create(idx, id, module, extra_size, &card) < 0)
-                return NULL;
-        return card;
-}
-
 int snd_card_disconnect(struct snd_card *card);
 int snd_card_free(struct snd_card *card);
 int snd_card_free_when_closed(struct snd_card *card);
+void snd_card_set_id(struct snd_card *card, const char *id);
 int snd_card_register(struct snd_card *card);
 int snd_card_info_init(void);
@@ -373 +364 @@
 void release_and_free_resource(struct resource *res);
 
-#ifdef CONFIG_SND_VERBOSE_PRINTK
-void snd_verbose_printk(const char *file, int line, const char *format, ...)
-     __attribute__ ((format (printf, 3, 4)));
-#endif
-#if defined(CONFIG_SND_DEBUG) && defined(CONFIG_SND_VERBOSE_PRINTK)
-void snd_verbose_printd(const char *file, int line, const char *format, ...)
-     __attribute__ ((format (printf, 3, 4)));
-#endif
-
 /* --- */
 
-#ifdef CONFIG_SND_VERBOSE_PRINTK
+#if defined(CONFIG_SND_DEBUG) || defined(CONFIG_SND_VERBOSE_PRINTK)
+void __snd_printk(unsigned int level, const char *file, int line,
+                  const char *format, ...)
+     __attribute__ ((format (printf, 4, 5)));
+#else
+#ifndef TARGET_OS2
+#define __snd_printk(level, file, line, format, args...) \
+        printk(format, ##args)
+#else
+#define __snd_printk printk
+#endif /* nothing */
+#endif
+
 /**
  * snd_printk - printk wrapper
@@ -392 +386 @@
  * when configured with CONFIG_SND_VERBOSE_PRINTK.
  */
+#ifndef TARGET_OS2
 #define snd_printk(fmt, args...) \
-        snd_verbose_printk(__FILE__, __LINE__, fmt ,##args)
-#else
-#ifndef TARGET_OS2
-#define snd_printk(fmt, args...) \
-        printk(fmt ,##args)
+        __snd_printk(0, __FILE__, __LINE__, fmt, ##args)
 #else
 #define snd_printk printk
 #endif
-#endif
 
 #ifdef CONFIG_SND_DEBUG
-
-#ifdef CONFIG_SND_VERBOSE_PRINTK
 /**
  * snd_printd - debug printk
@@ -414 +402 @@
  */
 #define snd_printd(fmt, args...) \
-        snd_verbose_printd(__FILE__, __LINE__, fmt ,##args)
-#else
-#define snd_printd(fmt, args...) \
-        printk(fmt ,##args)
-#endif
+        __snd_printk(1, __FILE__, __LINE__, fmt, ##args)
 
 /**
@@ -478 +462 @@
  */
 #ifndef TARGET_OS2
-#define snd_printdd(format, args...) snd_printk(format, ##args)
+#define snd_printdd(format, args...) \
+        __snd_printk(2, __FILE__, __LINE__, format, ##args)
 #else
 #define snd_printdd snd_printk
@@ -484 +469 @@
 #else
 #ifndef TARGET_OS2
-#define snd_printdd(format, args...) /* nothing */
+#define snd_printdd(format, args...)    do { } while (0)
 #else
 #define snd_printdd 1 ? (void)0 : (void)((int (*)(char *, ...)) NULL)

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

@@ -48 +48 @@
 #define SNDRV_DMA_TYPE_CONTINUOUS       1       /* continuous no-DMA memory */
 #define SNDRV_DMA_TYPE_DEV              2       /* generic device continuous */
+#ifdef CONFIG_SND_DMA_SGBUF
 #define SNDRV_DMA_TYPE_DEV_SG           3       /* generic device SG-buffer */
+#else
+#define SNDRV_DMA_TYPE_DEV_SG   SNDRV_DMA_TYPE_DEV /* no SG-buf support */
+#endif
 
 /*
@@ -61 +65 @@
 };
 
+#ifdef CONFIG_SND_DMA_SGBUF
 /*
  * Scatter-Gather generic device pages
@@ -108 +113 @@
         return sgbuf->table[offset >> PAGE_SHIFT].buf + offset % PAGE_SIZE;
 }
+#endif /* CONFIG_SND_DMA_SGBUF */
 
 /* allocate/release a buffer */

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

@@ -99 +99 @@
 #define SNDRV_PCM_IOCTL1_CHANNEL_INFO   2
 #define SNDRV_PCM_IOCTL1_GSTATE         3
+#define SNDRV_PCM_IOCTL1_FIFO_SIZE      4
 
 #define SNDRV_PCM_TRIGGER_STOP          0
@@ -271 +272 @@
         snd_pcm_uframes_t hw_ptr_interrupt; /* Position at interrupt time */
         unsigned long hw_ptr_jiffies;   /* Time when hw_ptr is updated */
+        snd_pcm_sframes_t delay;        /* extra delay; typically FIFO size */
 
         /* -- HW params -- */
@@ -490 +492 @@
 void snd_pcm_vma_notify_data(void *client, void *data);
 int snd_pcm_mmap_data(struct snd_pcm_substream *substream, struct file *file, struct vm_area_struct *area);
-
-#if BITS_PER_LONG >= 64
-
-static inline void div64_32(u_int64_t *n, u_int32_t div, u_int32_t *rem)
-{
-        *rem = *n % div;
-        *n /= div;
-}
-
-#elif defined(i386)
-
-static inline void div64_32(u_int64_t *n, u_int32_t div, u_int32_t *rem)
-{
-        u_int32_t low, high;
-        low = *n & 0xffffffff;
-        high = *n >> 32;
-        if (high) {
-                u_int32_t high1 = high % div;
-                high /= div;
-                asm("divl %2":"=a" (low), "=d" (*rem):"rm" (div), "a" (low), "d" (high1));
-                *n = (u_int64_t)high << 32 | low;
-        } else {
-                *n = low / div;
-                *rem = low % div;
-        }
-}
-#else
-
-static inline void divl(u_int32_t high, u_int32_t low,
-                        u_int32_t div,
-                        u_int32_t *q, u_int32_t *r)
-{
-        u_int64_t n = (u_int64_t)high << 32 | low;
-        u_int64_t d = (u_int64_t)div << 31;
-        u_int32_t q1 = 0;
-        int c = 32;
-        while (n > 0xffffffffU) {
-                q1 <<= 1;
-                if (n >= d) {
-                        n -= d;
-                        q1 |= 1;
-                }
-                d >>= 1;
-                c--;
-        }
-        q1 <<= c;
-        if (n) {
-                low = n;
-                *q = q1 | (low / div);
-                *r = low % div;
-        } else {
-                *r = 0;
-                *q = q1;
-        }
-        return;
-}
-
-static inline void div64_32(u_int64_t *n, u_int32_t div, u_int32_t *rem)
-{
-        u_int32_t low, high;
-        low = *n & 0xffffffff;
-        high = *n >> 32;
-        if (high) {
-                u_int32_t high1 = high % div;
-                u_int32_t low1 = low;
-                high /= div;
-                divl(high1, low1, div, &low, rem);
-                *n = (u_int64_t)high << 32 | low;
-        } else {
-                *n = low / div;
-                *rem = low % div;
-        }
-}
-#endif
 
 /*
@@ -992 +920 @@
 int snd_pcm_lib_free_pages(struct snd_pcm_substream *substream);
 
+#ifdef CONFIG_SND_DMA_SGBUF
 /*
  * SG-buffer handling
@@ -1016 +945 @@
 unsigned int snd_pcm_sgbuf_get_chunk_size(struct snd_pcm_substream *substream,
                                           unsigned int ofs, unsigned int size);
+
+#else /* !SND_DMA_SGBUF */
+/*
+ * fake using a continuous buffer
+ */
+static inline dma_addr_t
+snd_pcm_sgbuf_get_addr(struct snd_pcm_substream *substream, unsigned int ofs)
+{
+        return substream->runtime->dma_addr + ofs;
+}
+
+static inline void *
+snd_pcm_sgbuf_get_ptr(struct snd_pcm_substream *substream, unsigned int ofs)
+{
+        return substream->runtime->dma_area + ofs;
+}
+
+#define snd_pcm_sgbuf_ops_page  NULL
+
+#define snd_pcm_sgbuf_get_chunk_size(subs, ofs, size)   (size)
+
+#endif /* SND_DMA_SGBUF */
 
 /* handle mmap counter - PCM mmap callback should handle this counter properly */

GPL/trunk/alsa-kernel/include/sound/soc-dapm.h

@@ -138 +138 @@
 
 /* stream domain */
+#define SND_SOC_DAPM_AIF_IN(wname, stname, wslot, wreg, wshift, winvert) \
+{       .id = snd_soc_dapm_aif_in, .name = wname, .sname = stname, \
+        .reg = wreg, .shift = wshift, .invert = winvert }
+#define SND_SOC_DAPM_AIF_OUT(wname, stname, wslot, wreg, wshift, winvert) \
+{       .id = snd_soc_dapm_aif_out, .name = wname, .sname = stname, \
+        .reg = wreg, .shift = wshift, .invert = winvert }
 #define SND_SOC_DAPM_DAC(wname, stname, wreg, wshift, winvert) \
 {       .id = snd_soc_dapm_dac, .name = wname, .sname = stname, .reg = wreg, \
         .shift = wshift, .invert = winvert}
+#define SND_SOC_DAPM_DAC_E(wname, stname, wreg, wshift, winvert, \
+                           wevent, wflags)                              \
+{       .id = snd_soc_dapm_dac, .name = wname, .sname = stname, .reg = wreg, \
+        .shift = wshift, .invert = winvert, \
+        .event = wevent, .event_flags = wflags}
 #define SND_SOC_DAPM_ADC(wname, stname, wreg, wshift, winvert) \
 {       .id = snd_soc_dapm_adc, .name = wname, .sname = stname, .reg = wreg, \
         .shift = wshift, .invert = winvert}
-
-/* generic register modifier widget */
+#define SND_SOC_DAPM_ADC_E(wname, stname, wreg, wshift, winvert, \
+                           wevent, wflags)                              \
+{       .id = snd_soc_dapm_adc, .name = wname, .sname = stname, .reg = wreg, \
+        .shift = wshift, .invert = winvert, \
+        .event = wevent, .event_flags = wflags}
+
+/* generic widgets */
 #define SND_SOC_DAPM_REG(wid, wname, wreg, wshift, wmask, won_val, woff_val) \
 {       .id = wid, .name = wname, .kcontrols = NULL, .num_kcontrols = 0, \
@@ -151 +167 @@
         .on_val = won_val, .off_val = woff_val, .event = dapm_reg_event, \
         .event_flags = SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD}
+#define SND_SOC_DAPM_SUPPLY(wname, wreg, wshift, winvert, wevent, wflags) \
+{       .id = snd_soc_dapm_supply, .name = wname, .reg = wreg,  \
+        .shift = wshift, .invert = winvert, .event = wevent, \
+        .event_flags = wflags}
 
 /* dapm kcontrol types */
@@ -266 +286 @@
 int snd_soc_dapm_stream_event(struct snd_soc_codec *codec, char *stream,
         int event);
-int snd_soc_dapm_set_bias_level(struct snd_soc_device *socdev,
-        enum snd_soc_bias_level level);
+void snd_soc_dapm_shutdown(struct snd_soc_device *socdev);
 
 /* dapm sys fs - used by the core */
 int snd_soc_dapm_sys_add(struct device *dev);
+void snd_soc_dapm_debugfs_init(struct snd_soc_codec *codec);
 
 /* dapm audio pin control and status */
@@ -299 +319 @@
         snd_soc_dapm_pre,                       /* machine specific pre widget - exec first */
         snd_soc_dapm_post,                      /* machine specific post widget - exec last */
+        snd_soc_dapm_supply,            /* power/clock supply */
+        snd_soc_dapm_aif_in,            /* audio interface input */
+        snd_soc_dapm_aif_out,           /* audio interface output */
 };
 
@@ -358 +381 @@
         unsigned char pmdown:1;                 /* waiting for timeout */
 
+        int (*power_check)(struct snd_soc_dapm_widget *w);
+
         /* external events */
         unsigned short event_flags;             /* flags to specify event types */
@@ -369 +394 @@
         struct list_head sources;
         struct list_head sinks;
+
+        /* used during DAPM updates */
+        struct list_head power_list;
 };
 

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

@@ -119 +119 @@
         .get = xhandler_get, .put = xhandler_put, \
         .private_value = SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert) }
+#define SOC_DOUBLE_EXT(xname, xreg, shift_left, shift_right, xmax, xinvert,\
+         xhandler_get, xhandler_put) \
+{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
+        .info = snd_soc_info_volsw, \
+        .get = xhandler_get, .put = xhandler_put, \
+        .private_value = (unsigned long)&(struct soc_mixer_control) \
+                {.reg = xreg, .shift = shift_left, .rshift = shift_right, \
+                 .max = xmax, .invert = xinvert} }
 #define SOC_SINGLE_EXT_TLV(xname, xreg, xshift, xmax, xinvert,\
          xhandler_get, xhandler_put, tlv_array) \
@@ -128 +136 @@
         .get = xhandler_get, .put = xhandler_put, \
         .private_value = SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert) }
+#define SOC_DOUBLE_EXT_TLV(xname, xreg, shift_left, shift_right, xmax, xinvert,\
+         xhandler_get, xhandler_put, tlv_array) \
+{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
+        .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
+                 SNDRV_CTL_ELEM_ACCESS_READWRITE, \
+        .tlv.p = (tlv_array), \
+        .info = snd_soc_info_volsw, \
+        .get = xhandler_get, .put = xhandler_put, \
+        .private_value = (unsigned long)&(struct soc_mixer_control) \
+                {.reg = xreg, .shift = shift_left, .rshift = shift_right, \
+                .max = xmax, .invert = xinvert} }
+#define SOC_DOUBLE_R_EXT_TLV(xname, reg_left, reg_right, xshift, xmax, xinvert,\
+         xhandler_get, xhandler_put, tlv_array) \
+{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
+        .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
+                 SNDRV_CTL_ELEM_ACCESS_READWRITE, \
+        .tlv.p = (tlv_array), \
+        .info = snd_soc_info_volsw_2r, \
+        .get = xhandler_get, .put = xhandler_put, \
+        .private_value = (unsigned long)&(struct soc_mixer_control) \
+                {.reg = reg_left, .rreg = reg_right, .shift = xshift, \
+                .max = xmax, .invert = xinvert} }
 #define SOC_SINGLE_BOOL_EXT(xname, xdata, xhandler_get, xhandler_put) \
 {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
@@ -180 +210 @@
 extern struct snd_ac97_bus_ops soc_ac97_ops;
 
+enum snd_soc_control_type {
+        SND_SOC_CUSTOM,
+        SND_SOC_I2C,
+        SND_SOC_SPI,
+};
+
 int snd_soc_register_platform(struct snd_soc_platform *platform);
 void snd_soc_unregister_platform(struct snd_soc_platform *platform);
 int snd_soc_register_codec(struct snd_soc_codec *codec);
 void snd_soc_unregister_codec(struct snd_soc_codec *codec);
+int snd_soc_codec_volatile_register(struct snd_soc_codec *codec, int reg);
+int snd_soc_codec_set_cache_io(struct snd_soc_codec *codec,
+                               int addr_bits, int data_bits,
+                               enum snd_soc_control_type control);
+
+#ifdef CONFIG_PM
+int snd_soc_suspend_device(struct device *dev);
+int snd_soc_resume_device(struct device *dev);
+#endif
 
 /* pcm <-> DAI connect */
@@ -207 +252 @@
 #endif
 
-/* codec IO */
-#define snd_soc_read(codec, reg) codec->read(codec, reg)
-#define snd_soc_write(codec, reg, value) codec->write(codec, reg, value)
-
 /* codec register bit access */
 int snd_soc_update_bits(struct snd_soc_codec *codec, unsigned short reg,
-                                unsigned short mask, unsigned short value);
+                                unsigned int mask, unsigned int value);
 int snd_soc_test_bits(struct snd_soc_codec *codec, unsigned short reg,
-                                unsigned short mask, unsigned short value);
+                                unsigned int mask, unsigned int value);
 
 int snd_soc_new_ac97_codec(struct snd_soc_codec *codec,
@@ -332 +373 @@
         struct mutex mutex;
         struct device *dev;
+        struct snd_soc_device *socdev;
 
         struct list_head list;
@@ -352 +394 @@
         int (*display_register)(struct snd_soc_codec *, char *,
                                 size_t, unsigned int);
+        int (*volatile_register)(unsigned int);
+        int (*readable_register)(unsigned int);
         hw_write_t hw_write;
-        hw_read_t hw_read;
+        unsigned int (*hw_read)(struct snd_soc_codec *, unsigned int);
         void *reg_cache;
         short reg_cache_size;
@@ -373 +417 @@
         struct dentry *debugfs_reg;
         struct dentry *debugfs_pop_time;
+        struct dentry *debugfs_dapm;
 #endif
 };
@@ -417 +462 @@
         /* codec/machine specific init - e.g. add machine controls */
         int (*init)(struct snd_soc_codec *codec);
+
+        /* Symmetry requirements */
+        unsigned int symmetric_rates:1;
+
+        /* Symmetry data - only valid if symmetry is being enforced */
+        unsigned int rate;
 
         /* DAI pcm */
@@ -491 +542 @@
 };
 
+/* codec IO */
+static inline unsigned int snd_soc_read(struct snd_soc_codec *codec,
+                                        unsigned int reg)
+{
+        return codec->read(codec, reg);
+}
+
+static inline unsigned int snd_soc_write(struct snd_soc_codec *codec,
+                                         unsigned int reg, unsigned int val)
+{
+        return codec->write(codec, reg, val);
+}
+
 #include <sound/soc-dai.h>
 

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

@@ -36 +36 @@
 #define SNDRV_CTL_TLVT_DB_LINEAR 2      /* linear volume */
 #define SNDRV_CTL_TLVT_DB_RANGE 3       /* dB range container */
+#define SNDRV_CTL_TLVT_DB_MINMAX 4      /* dB scale with min/max */
+#define SNDRV_CTL_TLVT_DB_MINMAX_MUTE 5 /* dB scale with min/max with mute */
 
 #define TLV_DB_SCALE_ITEM(min, step, mute)                      \
@@ -42 +44 @@
 #define DECLARE_TLV_DB_SCALE(name, min, step, mute) \
         unsigned int name[] = { TLV_DB_SCALE_ITEM(min, step, mute) }
+
+/* dB scale specified with min/max values instead of step */
+#define TLV_DB_MINMAX_ITEM(min_dB, max_dB)                      \
+        SNDRV_CTL_TLVT_DB_MINMAX, 2 * sizeof(unsigned int),     \
+        (min_dB), (max_dB)
+#define TLV_DB_MINMAX_MUTE_ITEM(min_dB, max_dB)                 \
+        SNDRV_CTL_TLVT_DB_MINMAX_MUTE, 2 * sizeof(unsigned int),        \
+        (min_dB), (max_dB)
+#define DECLARE_TLV_DB_MINMAX(name, min_dB, max_dB) \
+        unsigned int name[] = { TLV_DB_MINMAX_ITEM(min_dB, max_dB) }
+#define DECLARE_TLV_DB_MINMAX_MUTE(name, min_dB, max_dB) \
+        unsigned int name[] = { TLV_DB_MINMAX_MUTE_ITEM(min_dB, max_dB) }
 
 /* linear volume between min_dB and max_dB (.01dB unit) */

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

@@ -332 +332 @@
         struct snd_rawmidi *rawmidi;
         struct snd_timer *timer;
+        unsigned int timer_ticks;
 
         struct pci_dev *pci;

GPL/trunk/alsa-kernel/isa/cmi8330.c

@@ -1 +1 @@
 /*
- *  Driver for C-Media's CMI8330 soundcards.
+ *  Driver for C-Media's CMI8330 and CMI8329 soundcards.
  *  Copyright (c) by George Talusan <gstalusan@uwaterloo.ca>
  *    http://www.undergrad.math.uwaterloo.ca/~gstalusa
@@ -36 +36 @@
  *  This card has two mixers and two PCM devices.  I've cheesed it such
  *  that recording and playback can be done through the same device.
- *  The driver "magically" routes the capturing to the CMI8330 codec,
+ *  The driver "magically" routes the capturing to the AD1848 codec,
  *  and playback to the SB16 codec.  This allows for full-duplex mode
  *  to some extent.
@@ -65 +65 @@
  */
 MODULE_AUTHOR("George Talusan <gstalusan@uwaterloo.ca>");
-MODULE_DESCRIPTION("C-Media CMI8330");
+MODULE_DESCRIPTION("C-Media CMI8330/CMI8329");
 MODULE_LICENSE("GPL");
 MODULE_SUPPORTED_DEVICE("{{C-Media,CMI8330,isapnp:{CMI0001,@@@0001,@X@0001}}}");
@@ -87 +87 @@
 
 module_param_array(index, int, NULL, 0444);
-MODULE_PARM_DESC(index, "Index value for CMI8330 soundcard.");
+MODULE_PARM_DESC(index, "Index value for CMI8330/CMI8329 soundcard.");
 module_param_array(id, charp, NULL, 0444);
-MODULE_PARM_DESC(id, "ID string  for CMI8330 soundcard.");
+MODULE_PARM_DESC(id, "ID string  for CMI8330/CMI8329 soundcard.");
 module_param_array(enable, bool, NULL, 0444);
-MODULE_PARM_DESC(enable, "Enable CMI8330 soundcard.");
+MODULE_PARM_DESC(enable, "Enable CMI8330/CMI8329 soundcard.");
 #ifdef CONFIG_PNP
 module_param_array(isapnp, bool, NULL, 0444);
@@ -98 +98 @@
 
 module_param_array(sbport, long, NULL, 0444);
-MODULE_PARM_DESC(sbport, "Port # for CMI8330 SB driver.");
+MODULE_PARM_DESC(sbport, "Port # for CMI8330/CMI8329 SB driver.");
 module_param_array(sbirq, int, NULL, 0444);
-MODULE_PARM_DESC(sbirq, "IRQ # for CMI8330 SB driver.");
+MODULE_PARM_DESC(sbirq, "IRQ # for CMI8330/CMI8329 SB driver.");
 module_param_array(sbdma8, int, NULL, 0444);
-MODULE_PARM_DESC(sbdma8, "DMA8 for CMI8330 SB driver.");
+MODULE_PARM_DESC(sbdma8, "DMA8 for CMI8330/CMI8329 SB driver.");
 module_param_array(sbdma16, int, NULL, 0444);
-MODULE_PARM_DESC(sbdma16, "DMA16 for CMI8330 SB driver.");
+MODULE_PARM_DESC(sbdma16, "DMA16 for CMI8330/CMI8329 SB driver.");
 
 module_param_array(wssport, long, NULL, 0444);
-MODULE_PARM_DESC(wssport, "Port # for CMI8330 WSS driver.");
+MODULE_PARM_DESC(wssport, "Port # for CMI8330/CMI8329 WSS driver.");
 module_param_array(wssirq, int, NULL, 0444);
-MODULE_PARM_DESC(wssirq, "IRQ # for CMI8330 WSS driver.");
+MODULE_PARM_DESC(wssirq, "IRQ # for CMI8330/CMI8329 WSS driver.");
 module_param_array(wssdma, int, NULL, 0444);
-MODULE_PARM_DESC(wssdma, "DMA for CMI8330 WSS driver.");
+MODULE_PARM_DESC(wssdma, "DMA for CMI8330/CMI8329 WSS driver.");
 
 module_param_array(fmport, long, NULL, 0444);
-MODULE_PARM_DESC(fmport, "FM port # for CMI8330 driver.");
+MODULE_PARM_DESC(fmport, "FM port # for CMI8330/CMI8329 driver.");
 module_param_array(mpuport, long, NULL, 0444);
-MODULE_PARM_DESC(mpuport, "MPU-401 port # for CMI8330 driver.");
+MODULE_PARM_DESC(mpuport, "MPU-401 port # for CMI8330/CMI8329 driver.");
 module_param_array(mpuirq, int, NULL, 0444);
-MODULE_PARM_DESC(mpuirq, "IRQ # for CMI8330 MPU-401 port.");
+MODULE_PARM_DESC(mpuirq, "IRQ # for CMI8330/CMI8329 MPU-401 port.");
 #ifdef CONFIG_PNP
 static int isa_registered;
@@ -157 +157 @@
 typedef int (*snd_pcm_open_callback_t)(struct snd_pcm_substream *);
 
+enum card_type {
+        CMI8330,
+        CMI8329
+};
+
 struct snd_cmi8330 {
 #ifdef CONFIG_PNP
@@ -173 +178 @@
                 void *private_data; /* sb or wss */
         } streams[2];
+
+        enum card_type type;
 };
 
@@ -178 +185 @@
 
 static struct pnp_card_device_id snd_cmi8330_pnpids[] = {
+        { .id = "CMI0001", .devs = { { "@X@0001" }, { "@@@0001" }, { "@H@0001" }, { "A@@0001" } } },
         { .id = "CMI0001", .devs = { { "@@@0001" }, { "@X@0001" }, { "@H@0001" } } },
         { .id = "" }
@@ -305 +313 @@
         int err;
 
-        strcpy(card->mixername, "CMI8330/C3D");
+        strcpy(card->mixername, (acard->type == CMI8329) ? "CMI8329" : "CMI8330/C3D");
 
         for (idx = 0; idx < ARRAY_SIZE(snd_cmi8330_controls); idx++) {
@@ -330 +338 @@
         int err;
 
+        /* CMI8329 has a device with ID A@@0001, CMI8330 does not */
+        acard->type = (id->devs[3].id[0]) ? CMI8329 : CMI8330;
+
         acard->cap = pnp_request_card_device(card, id->devs[0].id, NULL);
         if (acard->cap == NULL)
@@ -339 +350 @@
 
         acard->mpu = pnp_request_card_device(card, id->devs[2].id, NULL);
-        if (acard->play == NULL)
+        if (acard->mpu == NULL)
                 return -EBUSY;
 
@@ -346 +357 @@
         err = pnp_activate_dev(pdev);
         if (err < 0) {
-                snd_printk(KERN_ERR "CMI8330/C3D PnP configure failure\n");
+                snd_printk(KERN_ERR "AD1848 PnP configure failure\n");
                 return -EBUSY;
         }
@@ -352 +363 @@
         wssdma[dev] = pnp_dma(pdev, 0);
         wssirq[dev] = pnp_irq(pdev, 0);
-        fmport[dev] = pnp_port_start(pdev, 1);
+        if (pnp_port_start(pdev, 1))
+                fmport[dev] = pnp_port_start(pdev, 1);
 
         /* allocate SB16 resources */
@@ -359 +371 @@
         err = pnp_activate_dev(pdev);
         if (err < 0) {
-                snd_printk(KERN_ERR "CMI8330/C3D (SB16) PnP configure failure\n");
+                snd_printk(KERN_ERR "SB16 PnP configure failure\n");
                 return -EBUSY;
         }
@@ -366 +378 @@
         sbdma16[dev] = pnp_dma(pdev, 1);
         sbirq[dev] = pnp_irq(pdev, 0);
+        /* On CMI8239, the OPL3 port might be present in SB16 PnP resources */
+        if (fmport[dev] == SNDRV_AUTO_PORT) {
+                if (pnp_port_start(pdev, 1))
+                        fmport[dev] = pnp_port_start(pdev, 1);
+                else
+                        fmport[dev] = 0x388;    /* Or hardwired */
+        }
 
         /* allocate MPU-401 resources */
@@ -371 +390 @@
 
         err = pnp_activate_dev(pdev);
-        if (err < 0) {
-                snd_printk(KERN_ERR
-                           "CMI8330/C3D (MPU-401) PnP configure failure\n");
-                return -EBUSY;
-        }
-        mpuport[dev] = pnp_port_start(pdev, 0);
-        mpuirq[dev] = pnp_irq(pdev, 0);
+        if (err < 0)
+                snd_printk(KERN_ERR "MPU-401 PnP configure failure: will be disabled\n");
+        else {
+                mpuport[dev] = pnp_port_start(pdev, 0);
+                mpuirq[dev] = pnp_irq(pdev, 0);
+        }
         return 0;
 }
@@ -431 +449 @@
         };
 
-        if ((err = snd_pcm_new(card, "CMI8330", 0, 1, 1, &pcm)) < 0)
-                return err;
-        strcpy(pcm->name, "CMI8330");
+        if ((err = snd_pcm_new(card, (chip->type == CMI8329) ? "CMI8329" : "CMI8330", 0, 1, 1, &pcm)) < 0)
+                return err;
+        strcpy(pcm->name, (chip->type == CMI8329) ? "CMI8329" : "CMI8330");
         pcm->private_data = chip;
         
@@ -528 +546 @@
                              WSS_HW_DETECT, 0, &acard->wss);
         if (err < 0) {
-                snd_printk(KERN_ERR PFX "(CMI8330) device busy??\n");
+                snd_printk(KERN_ERR PFX "AD1848 device busy??\n");
                 return err;
         }
         if (acard->wss->hardware != WSS_HW_CMI8330) {
-                snd_printk(KERN_ERR PFX "(CMI8330) not found during probe\n");
+                snd_printk(KERN_ERR PFX "AD1848 not found during probe\n");
                 return -ENODEV;
         }
@@ -542 +560 @@
                                     sbdma16[dev],
                                     SB_HW_AUTO, &acard->sb)) < 0) {
-                snd_printk(KERN_ERR PFX "(SB16) device busy??\n");
+                snd_printk(KERN_ERR PFX "SB16 device busy??\n");
                 return err;
         }
         if (acard->sb->hardware != SB_HW_16) {
-                snd_printk(KERN_ERR PFX "(SB16) not found during probe\n");
+                snd_printk(KERN_ERR PFX "SB16 not found during probe\n");
                 return err;
         }
@@ -586 +604 @@
         }
 
-        strcpy(card->driver, "CMI8330/C3D");
-        strcpy(card->shortname, "C-Media CMI8330/C3D");
+        strcpy(card->driver, (acard->type == CMI8329) ? "CMI8329" : "CMI8330/C3D");
+        strcpy(card->shortname, (acard->type == CMI8329) ? "C-Media CMI8329" : "C-Media CMI8330/C3D");
         sprintf(card->longname, "%s at 0x%lx, irq %d, dma %d",
                 card->shortname,

GPL/trunk/alsa-kernel/isa/es1688/es1688.c

@@ -194 +194 @@
         .match          = snd_es1688_match,
         .probe          = snd_es1688_probe,
-        .remove         = snd_es1688_remove,
+        .remove         = __devexit_p(snd_es1688_remove),
 #if 0   /* FIXME */
         .suspend        = snd_es1688_suspend,

GPL/trunk/alsa-kernel/isa/gus/gus_pcm.c

@@ -796 +796 @@
                         continue;
                 /* load real volume - better precision */
-                spin_lock_irqsave(&gus->reg_lock, flags);
+                spin_lock(&gus->reg_lock);
                 snd_gf1_select_voice(gus, pvoice->number);
                 snd_gf1_ctrl_stop(gus, SNDRV_GF1_VB_VOLUME_CONTROL);
@@ -802 +802 @@
                 snd_gf1_write16(gus, SNDRV_GF1_VW_VOLUME, vol);
                 pcmp->final_volume = 1;
-                spin_unlock_irqrestore(&gus->reg_lock, flags);
+                spin_unlock(&gus->reg_lock);
         }
         spin_unlock_irqrestore(&gus->voice_alloc, flags);

GPL/trunk/alsa-kernel/isa/gus/gusextreme.c

@@ -349 +349 @@
         .match          = snd_gusextreme_match,
         .probe          = snd_gusextreme_probe,
-        .remove         = snd_gusextreme_remove,
+        .remove         = __devexit_p(snd_gusextreme_remove),
 #if 0   /* FIXME */
         .suspend        = snd_gusextreme_suspend,

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

@@ -959 +959 @@
 
 static const struct snd_kcontrol_new snd_ac97_sigmatel_4speaker =
-AC97_SINGLE("Sigmatel 4-Speaker Stereo Playback Switch", AC97_SIGMATEL_DAC2INVERT, 2, 1, 0);
-
+AC97_SINGLE("Sigmatel 4-Speaker Stereo Playback Switch",
+                AC97_SIGMATEL_DAC2INVERT, 2, 1, 0);
+
+/* "Sigmatel " removed due to excessive name length: */
 static const struct snd_kcontrol_new snd_ac97_sigmatel_phaseinvert =
-AC97_SINGLE("Sigmatel Surround Phase Inversion Playback Switch", AC97_SIGMATEL_DAC2INVERT, 3, 1, 0);
+AC97_SINGLE("Surround Phase Inversion Playback Switch",
+                AC97_SIGMATEL_DAC2INVERT, 3, 1, 0);
 
 static const struct snd_kcontrol_new snd_ac97_sigmatel_controls[] = {

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

@@ -319 +319 @@
         
         end_time = jiffies + msecs_to_jiffies(250);
-        do {
+
+        for (;;) {
                 res = snd_ali_5451_peek(codec,port);
                 if (!(res & 0x8000))
                         return 0;
+                if (!time_after_eq(end_time, jiffies))
+                        break;
                 schedule_timeout_uninterruptible(1);
-        } while (time_after_eq(end_time, jiffies));
+        }
+
         snd_ali_5451_poke(codec, port, res & ~0x8000);
         snd_printdd("ali_codec_ready: codec is not ready.\n ");
@@ -336 +340 @@
         
         dwChk1 = snd_ali_5451_peek(codec, ALI_STIMER);
-        dwChk2 = snd_ali_5451_peek(codec, ALI_STIMER);
-
         end_time = jiffies + msecs_to_jiffies(250);
-        do {
+
+        for (;;) {
                 dwChk2 = snd_ali_5451_peek(codec, ALI_STIMER);
                 if (dwChk2 != dwChk1)
                         return 0;
+                if (!time_after_eq(end_time, jiffies))
+                        break;
                 schedule_timeout_uninterruptible(1);
-        } while (time_after_eq(end_time, jiffies));
+        }
+
         snd_printk(KERN_ERR "ali_stimer_read: stimer is not ready.\n");
         return -EIO;
@@ -481 +487 @@
 }
 
-#ifdef CODEC_RESET
-
-static int snd_ali_reset_codec(struct snd_ali *codec)
-{
-        struct pci_dev *pci_dev;
-        unsigned char bVal;
-        unsigned int   dwVal;
-        unsigned short wCount, wReg;
-
-        pci_dev = codec->pci_m1533;
-        
-        pci_read_config_dword(pci_dev, 0x7c, &dwVal);
-        pci_write_config_dword(pci_dev, 0x7c, dwVal | 0x08000000);
-        udelay(5000);
-        pci_read_config_dword(pci_dev, 0x7c, &dwVal);
-        pci_write_config_dword(pci_dev, 0x7c, dwVal & 0xf7ffffff);
-        udelay(5000);
-
-        bVal = inb(ALI_REG(codec,ALI_SCTRL));
-        bVal |= 0x02;
-        outb(ALI_REG(codec,ALI_SCTRL),bVal);
-        udelay(5000);
-        bVal = inb(ALI_REG(codec,ALI_SCTRL));
-        bVal &= 0xfd;
-        outb(ALI_REG(codec,ALI_SCTRL),bVal);
-        udelay(15000);
-
-        wCount = 200;
-        while (wCount--) {
-                wReg = snd_ali_codec_read(codec->ac97, AC97_POWERDOWN);
-                if ((wReg & 0x000f) == 0x000f)
-                        return 0;
-                udelay(5000);
-        }
-        return -1;
-}
-
-#endif
-
 /*
  *  ALI 5451 Controller
@@ -563 +530 @@
         outl(gc, ALI_REG(codec, ALI_GC_CIR));
 }
-
-#if 0 /* not used */
-static void snd_ali_enable_voice_irq(struct snd_ali *codec,
-                                     unsigned int channel)
-{
-        unsigned int mask;
-        struct snd_ali_channel_control *pchregs = &(codec->chregs);
-
-        snd_ali_printk("enable_voice_irq channel=%d\n",channel);
-        
-        mask = 1 << (channel & 0x1f);
-        pchregs->data.ainten  = inl(ALI_REG(codec, pchregs->regs.ainten));
-        pchregs->data.ainten |= mask;
-        outl(pchregs->data.ainten, ALI_REG(codec, pchregs->regs.ainten));
-}
-#endif
 
 static void snd_ali_disable_voice_irq(struct snd_ali *codec,
@@ -679 +630 @@
         }
 }
-
-#if 0 /* not used */
-static void snd_ali_start_voice(struct snd_ali *codec, unsigned int channel)
-{
-        unsigned int mask = 1 << (channel & 0x1f);
-        
-        snd_ali_printk("start_voice: channel=%d\n",channel);
-        outl(mask, ALI_REG(codec,codec->chregs.regs.start));
-}
-#endif
 
 static void snd_ali_stop_voice(struct snd_ali *codec, unsigned int channel)

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

@@ -288 +288 @@
  */
 static struct pci_device_id snd_atiixp_ids[] = {
-        { 0x1002, 0x4341, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, /* SB200 */
-        { 0x1002, 0x4361, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, /* SB300 */
-        { 0x1002, 0x4370, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, /* SB400 */
-        { 0x1002, 0x4382, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, /* SB600 */
+        { PCI_VDEVICE(ATI, 0x4341), 0 }, /* SB200 */
+        { PCI_VDEVICE(ATI, 0x4361), 0 }, /* SB300 */
+        { PCI_VDEVICE(ATI, 0x4370), 0 }, /* SB400 */
+        { PCI_VDEVICE(ATI, 0x4382), 0 }, /* SB600 */
         { 0, }
 };

GPL/trunk/alsa-kernel/pci/au88x0/au8810.c

@@ -2 +2 @@
 #include "au88x0.h"
 static struct pci_device_id snd_vortex_ids[] = {
-        {PCI_VENDOR_ID_AUREAL, PCI_DEVICE_ID_AUREAL_ADVANTAGE,
-         PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1,},
+        {PCI_VDEVICE(AUREAL, PCI_DEVICE_ID_AUREAL_ADVANTAGE), 1,},
         {0,}
 };

GPL/trunk/alsa-kernel/pci/au88x0/au8820.c

@@ -2 +2 @@
 #include "au88x0.h"
 static struct pci_device_id snd_vortex_ids[] = {
-        {PCI_VENDOR_ID_AUREAL, PCI_DEVICE_ID_AUREAL_VORTEX_1,
-         PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0,},
+        {PCI_VDEVICE(AUREAL, PCI_DEVICE_ID_AUREAL_VORTEX_1), 0,},
         {0,}
 };

GPL/trunk/alsa-kernel/pci/au88x0/au8830.c

@@ -2 +2 @@
 #include "au88x0.h"
 static struct pci_device_id snd_vortex_ids[] = {
-        {PCI_VENDOR_ID_AUREAL, PCI_DEVICE_ID_AUREAL_VORTEX_2,
-         PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0,},
+        {PCI_VDEVICE(AUREAL, PCI_DEVICE_ID_AUREAL_VORTEX_2), 0,},
         {0,}
 };

GPL/trunk/alsa-kernel/pci/au88x0/au88x0_core.c

@@ -1256 +1256 @@
 
         temp = hwread(vortex->mmio, VORTEX_ADBDMA_STAT + (adbdma << 2));
-        temp = (dma->period_virt * dma->period_bytes) + (temp & POS_MASK);
-        return (temp);
+        temp = (dma->period_virt * dma->period_bytes) + (temp & (dma->period_bytes - 1));
+        return temp;
 }
 
@@ -1505 +1505 @@
 
         temp = hwread(vortex->mmio, VORTEX_WTDMA_STAT + (wtdma << 2));
-        //temp = (temp & POS_MASK) + (((temp>>WT_SUBBUF_SHIFT) & WT_SUBBUF_MASK)*(dma->cfg0&POS_MASK));
-        temp = (temp & POS_MASK) + ((dma->period_virt) * (dma->period_bytes));
+        temp = (dma->period_virt * dma->period_bytes) + (temp & (dma->period_bytes - 1));
         return temp;
 }
@@ -2442 +2441 @@
                 for (i = 0; i < NR_ADB; i++) {
                         if (vortex->dma_adb[i].fifo_status == FIFO_START) {
-                                if (vortex_adbdma_bufshift(vortex, i)) ;
+                                if (!vortex_adbdma_bufshift(vortex, i))
+                                        continue;
                                 spin_unlock(&vortex->lock);
                                 snd_pcm_period_elapsed(vortex->dma_adb[i].

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

@@ -355 +355 @@
                 SNDRV_PCM_INFO_INTERLEAVED |
                 SNDRV_PCM_INFO_BLOCK_TRANSFER |
-                SNDRV_PCM_INFO_MMAP_VALID,
+                SNDRV_PCM_INFO_MMAP_VALID |
+                SNDRV_PCM_INFO_BATCH,
         .formats = SNDRV_PCM_FMTBIT_S16_LE,
         .rates = 0, /* set at runtime */
@@ -371 +372 @@
                 SNDRV_PCM_INFO_INTERLEAVED |
                 SNDRV_PCM_INFO_BLOCK_TRANSFER |
-                SNDRV_PCM_INFO_MMAP_VALID,
+                SNDRV_PCM_INFO_MMAP_VALID |
+                SNDRV_PCM_INFO_BATCH,
         .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S8,
         .rates = SNDRV_PCM_RATE_KNOT,
@@ -814 +816 @@
         /* Voodoo TV 200 */
         BT_DEVICE(PCI_DEVICE_ID_BROOKTREE_878, 0x121a, 0x3000, GENERIC),
+        /* Askey Computer Corp. MagicTView'99 */
+        BT_DEVICE(PCI_DEVICE_ID_BROOKTREE_878, 0x144f, 0x3000, GENERIC),
         /* AVerMedia Studio No. 103, 203, ...? */
         BT_DEVICE(PCI_DEVICE_ID_BROOKTREE_878, 0x1461, 0x0003, AVPHONE98),

GPL/trunk/alsa-kernel/pci/ca0106/ca0106_main.c

@@ -326 +326 @@
         .channels_min =         2,
         .channels_max =         2,
-        .buffer_bytes_max =     ((65536 - 64) * 8),
+        .buffer_bytes_max =     65536 - 128,
         .period_bytes_min =     64,
-        .period_bytes_max =     (65536 - 64),
+        .period_bytes_max =     32768 - 64,
         .periods_min =          2,
         .periods_max =          2,
@@ -1320 +1320 @@
 
         pcm->info_flags = 0;
-        pcm->dev_subclass = SNDRV_PCM_SUBCLASS_GENERIC_MIX;
         strcpy(pcm->name, "CA0106");
 
@@ -1882 +1881 @@
 // PCI IDs
 static struct pci_device_id snd_ca0106_ids[] = {
-        { 0x1102, 0x0007, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },    /* Audigy LS or Live 24bit */
+        { PCI_VDEVICE(CREATIVE, 0x0007), 0 },   /* Audigy LS or Live 24bit */
         { 0, }
 };

GPL/trunk/alsa-kernel/pci/ca0106/ca0106_mixer.c

@@ -740 +740 @@
 
 static __devinitdata
-DECLARE_TLV_DB_SCALE(snd_ca0106_master_db_scale, -6375, 50, 1);
+DECLARE_TLV_DB_SCALE(snd_ca0106_master_db_scale, -6375, 25, 1);
 
 static char *slave_vols[] __devinitdata = {
@@ -801 +801 @@
                 "External Amplifier",
                 "Sigmatel 4-Speaker Stereo Playback Switch",
-                "Sigmatel Surround Phase Inversion Playback ",
+                "Surround Phase Inversion Playback Switch",
                 NULL
         };
@@ -842 +842 @@
         if (!vmaster)
                 return -ENOMEM;
+        err = snd_ctl_add(card, vmaster);
+        if (err < 0)
+                return err;
         add_slaves(card, vmaster, slave_vols);
 
@@ -849 +852 @@
                 if (!vmaster)
                         return -ENOMEM;
+                err = snd_ctl_add(card, vmaster);
+                if (err < 0)
+                        return err;
                 add_slaves(card, vmaster, slave_sws);
         }
+
+        strcpy(card->mixername, "CA0106");
         return 0;
 }

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

@@ -2814 +2814 @@
 
 static struct pci_device_id snd_cmipci_ids[] = {
-        {PCI_VENDOR_ID_CMEDIA, PCI_DEVICE_ID_CMEDIA_CM8338A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
-        {PCI_VENDOR_ID_CMEDIA, PCI_DEVICE_ID_CMEDIA_CM8338B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
-        {PCI_VENDOR_ID_CMEDIA, PCI_DEVICE_ID_CMEDIA_CM8738, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
-        {PCI_VENDOR_ID_CMEDIA, PCI_DEVICE_ID_CMEDIA_CM8738B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
-        {PCI_VENDOR_ID_AL, PCI_DEVICE_ID_CMEDIA_CM8738, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
+        {PCI_VDEVICE(CMEDIA, PCI_DEVICE_ID_CMEDIA_CM8338A), 0},
+        {PCI_VDEVICE(CMEDIA, PCI_DEVICE_ID_CMEDIA_CM8338B), 0},
+        {PCI_VDEVICE(CMEDIA, PCI_DEVICE_ID_CMEDIA_CM8738), 0},
+        {PCI_VDEVICE(CMEDIA, PCI_DEVICE_ID_CMEDIA_CM8738B), 0},
+        {PCI_VDEVICE(AL, PCI_DEVICE_ID_CMEDIA_CM8738), 0},
         {0,},
 };

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

@@ -496 +496 @@
 
 static struct pci_device_id snd_cs4281_ids[] = {
-        { 0x1013, 0x6005, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },   /* CS4281 */
+        { PCI_VDEVICE(CIRRUS, 0x6005), 0, },    /* CS4281 */
         { 0, }
 };

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

@@ -69 +69 @@
 
 static struct pci_device_id snd_cs46xx_ids[] = {
-        { 0x1013, 0x6001, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },   /* CS4280 */
-        { 0x1013, 0x6003, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },   /* CS4612 */
-        { 0x1013, 0x6004, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },   /* CS4615 */
+        { PCI_VDEVICE(CIRRUS, 0x6001), 0, },   /* CS4280 */
+        { PCI_VDEVICE(CIRRUS, 0x6003), 0, },   /* CS4612 */
+        { PCI_VDEVICE(CIRRUS, 0x6004), 0, },   /* CS4615 */
         { 0, }
 };

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

@@ -84 +84 @@
  */
 static struct pci_device_id snd_emu10k1_ids[] = {
-        { 0x1102, 0x0002, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },    /* EMU10K1 */
-        { 0x1102, 0x0004, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 },    /* Audigy */
-        { 0x1102, 0x0008, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 },    /* Audigy 2 Value SB0400 */
+        { PCI_VDEVICE(CREATIVE, 0x0002), 0 },   /* EMU10K1 */
+        { PCI_VDEVICE(CREATIVE, 0x0004), 1 },   /* Audigy */
+        { PCI_VDEVICE(CREATIVE, 0x0008), 1 },   /* Audigy 2 Value SB0400 */
         { 0, }
 };

GPL/trunk/alsa-kernel/pci/emu10k1/emu10k1x.c

@@ -859 +859 @@
 
         pcm->info_flags = 0;
-        pcm->dev_subclass = SNDRV_PCM_SUBCLASS_GENERIC_MIX;
         switch(device) {
         case 0:
@@ -1613 +1612 @@
 // PCI IDs
 static struct pci_device_id snd_emu10k1x_ids[] = {
-        { 0x1102, 0x0006, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },    /* Dell OEM version (EMU10K1) */
+        { PCI_VDEVICE(CREATIVE, 0x0006), 0 },   /* Dell OEM version (EMU10K1) */
         { 0, }
 };

GPL/trunk/alsa-kernel/pci/emu10k1/emupcm.c

@@ -1737 +1737 @@
         .period_bytes_min =     1024,
         .period_bytes_max =     (128*1024),
-        .periods_min =          1,
+        .periods_min =          2,
         .periods_max =          1024,
         .fifo_size =            0,

GPL/trunk/alsa-kernel/pci/emu10k1/p16v.c

@@ -645 +645 @@
         int capture=1;
   
-        /* snd_printk("KERN_DEBUG snd_p16v_pcm called. device=%d\n", device); */
+        /* snd_printk(KERN_DEBUG "snd_p16v_pcm called. device=%d\n", device); */
         emu->p16v_device_offset = device;
         if (rpcm)

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

@@ -446 +446 @@
 static struct pci_device_id snd_audiopci_ids[] = {
 #ifdef CHIP1370
-        { 0x1274, 0x5000, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },   /* ES1370 */
+        { PCI_VDEVICE(ENSONIQ, 0x5000), 0, },   /* ES1370 */
 #endif
 #ifdef CHIP1371
-        { 0x1274, 0x1371, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },   /* ES1371 */
-        { 0x1274, 0x5880, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },   /* ES1373 - CT5880 */
-        { 0x1102, 0x8938, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },   /* Ectiva EV1938 */
+        { PCI_VDEVICE(ENSONIQ, 0x1371), 0, },   /* ES1371 */
+        { PCI_VDEVICE(ENSONIQ, 0x5880), 0, },   /* ES1373 - CT5880 */
+        { PCI_VDEVICE(ECTIVA, 0x8938), 0, },    /* Ectiva EV1938 */
 #endif
         { 0, }

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

@@ -245 +245 @@
 
 static struct pci_device_id snd_es1938_ids[] = {
-        { 0x125d, 0x1969, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },   /* Solo-1 */
+        { PCI_VDEVICE(ESS, 0x1969), 0, },   /* Solo-1 */
         { 0, }
 };

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

@@ -31 +31 @@
         char phys[32];
         int tone;
-        int nid;
-        int enabled;
+        hda_nid_t nid;
+        unsigned int enabled:1;
+        unsigned int linear_tone:1;     /* linear tone for IDT/STAC codec */
         struct work_struct beep_work; /* scheduled task for beep event */
 };

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

@@ -45 +45 @@
 static struct hda_vendor_id hda_vendor_ids[] = {
         { 0x1002, "ATI" },
+        { 0x1013, "Cirrus Logic" },
         { 0x1057, "Motorola" },
         { 0x1095, "Silicon Image" },
         { 0x10de, "Nvidia" },
         { 0x10ec, "Realtek" },
+        { 0x1102, "Creative" },
         { 0x1106, "VIA" },
         { 0x111d, "IDT" },
@@ -150 +152 @@
         u32 val;
 
-        val = (u32)(codec->addr & 0x0f) << 28;
+        if ((codec->addr & ~0xf) || (direct & ~1) || (nid & ~0x7f) ||
+            (verb & ~0xfff) || (parm & ~0xffff)) {
+                printk(KERN_ERR "hda-codec: out of range cmd %x:%x:%x:%x:%x\n",
+                       codec->addr, direct, nid, verb, parm);
+                return ~0;
+        }
+
+        val = (u32)codec->addr << 28;
         val |= (u32)direct << 27;
         val |= (u32)nid << 20;
@@ -156 +165 @@
         val |= parm;
         return val;
+}
+
+/*
+ * Send and receive a verb
+ */
+static int codec_exec_verb(struct hda_codec *codec, unsigned int cmd,
+                           unsigned int *res)
+{
+        struct hda_bus *bus = codec->bus;
+        int err;
+
+        if (cmd == ~0)
+                return -1;
+
+        if (res)
+                *res = -1;
+ again:
+        snd_hda_power_up(codec);
+        mutex_lock(&bus->cmd_mutex);
+        err = bus->ops.command(bus, cmd);
+        if (!err && res)
+                *res = bus->ops.get_response(bus, codec->addr);
+        mutex_unlock(&bus->cmd_mutex);
+        snd_hda_power_down(codec);
+        if (res && *res == -1 && bus->rirb_error) {
+                if (bus->response_reset) {
+                        snd_printd("hda_codec: resetting BUS due to "
+                                   "fatal communication error\n");
+                        bus->ops.bus_reset(bus);
+                }
+                goto again;
+        }
+        /* clear reset-flag when the communication gets recovered */
+        if (!err)
+                bus->response_reset = 0;
+        return err;
 }
 
@@ -174 +219 @@
                                 unsigned int verb, unsigned int parm)
 {
-        struct hda_bus *bus = codec->bus;
+        unsigned cmd = make_codec_cmd(codec, nid, direct, verb, parm);
         unsigned int res;
-
-        res = make_codec_cmd(codec, nid, direct, verb, parm);
-        snd_hda_power_up(codec);
-        mutex_lock(&bus->cmd_mutex);
-        if (!bus->ops.command(bus, res))
-                res = bus->ops.get_response(bus);
-        else
-                res = (unsigned int)-1;
-        mutex_unlock(&bus->cmd_mutex);
-        snd_hda_power_down(codec);
+        codec_exec_verb(codec, cmd, &res);
         return res;
 }
@@ -205 +241 @@
                          unsigned int verb, unsigned int parm)
 {
-        struct hda_bus *bus = codec->bus;
+        unsigned int cmd = make_codec_cmd(codec, nid, direct, verb, parm);
         unsigned int res;
-        int err;
-
-        res = make_codec_cmd(codec, nid, direct, verb, parm);
-        snd_hda_power_up(codec);
-        mutex_lock(&bus->cmd_mutex);
-        err = bus->ops.command(bus, res);
-        mutex_unlock(&bus->cmd_mutex);
-        snd_hda_power_down(codec);
-        return err;
+        return codec_exec_verb(codec, cmd,
+                               codec->bus->sync_write ? &res : NULL);
 }
 EXPORT_SYMBOL_HDA(snd_hda_codec_write);
@@ -274 +303 @@
         int i, conn_len, conns;
         unsigned int shift, num_elems, mask;
+        unsigned int wcaps;
         hda_nid_t prev_nid;
 
         if (snd_BUG_ON(!conn_list || max_conns <= 0))
                 return -EINVAL;
+
+        wcaps = get_wcaps(codec, nid);
+        if (!(wcaps & AC_WCAP_CONN_LIST) &&
+            get_wcaps_type(wcaps) != AC_WID_VOL_KNB) {
+                snd_printk(KERN_WARNING "hda_codec: "
+                           "connection list not available for 0x%x\n", nid);
+                return -EINVAL;
+        }
 
         parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
@@ -299 +337 @@
                 parm = snd_hda_codec_read(codec, nid, 0,
                                           AC_VERB_GET_CONNECT_LIST, 0);
+                if (parm == -1 && codec->bus->rirb_error)
+                        return -EIO;
                 conn_list[0] = parm & mask;
                 return 1;
@@ -310 +350 @@
                 hda_nid_t val, n;
 
-                if (i % num_elems == 0)
+                if (i % num_elems == 0) {
                         parm = snd_hda_codec_read(codec, nid, 0,
                                                   AC_VERB_GET_CONNECT_LIST, i);
+                        if (parm == -1 && codec->bus->rirb_error)
+                                return -EIO;
+                }
                 range_val = !!(parm & (1 << (shift-1))); /* ranges */
                 val = parm & mask;
+                if (val == 0) {
+                        snd_printk(KERN_WARNING "hda_codec: "
+                                   "invalid CONNECT_LIST verb %x[%i]:%x\n",
+                                    nid, i, parm);
+                        return 0;
+                }
                 parm >>= shift;
                 if (range_val) {
@@ -618 +667 @@
         const char *vendor = NULL;
         u16 vendor_id = codec->vendor_id >> 16;
-        char tmp[16], name[32];
+        char tmp[16];
+
+        if (codec->vendor_name)
+                goto get_chip_name;
 
         for (c = hda_vendor_ids; c->id; c++) {
@@ -630 +682 @@
                 vendor = tmp;
         }
+        codec->vendor_name = kstrdup(vendor, GFP_KERNEL);
+        if (!codec->vendor_name)
+                return -ENOMEM;
+
+ get_chip_name:
+        if (codec->chip_name)
+                return 0;
+
         if (codec->preset && codec->preset->name)
-                snprintf(name, sizeof(name), "%s %s", vendor,
-                         codec->preset->name);
-        else
-                snprintf(name, sizeof(name), "%s ID %x", vendor,
-                         codec->vendor_id & 0xffff);
-        codec->name = kstrdup(name, GFP_KERNEL);
-        if (!codec->name)
+                codec->chip_name = kstrdup(codec->preset->name, GFP_KERNEL);
+        else {
+                sprintf(tmp, "ID %x", codec->vendor_id & 0xffff);
+                codec->chip_name = kstrdup(tmp, GFP_KERNEL);
+        }
+        if (!codec->chip_name)
                 return -ENOMEM;
         return 0;
@@ -698 +757 @@
                 struct hda_pincfg *pin;
                 unsigned int wcaps = get_wcaps(codec, nid);
-                unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
-                                AC_WCAP_TYPE_SHIFT;
+                unsigned int wid_type = get_wcaps_type(wcaps);
                 if (wid_type != AC_WID_PIN)
                         continue;
@@ -843 +901 @@
         free_hda_cache(&codec->amp_cache);
         free_hda_cache(&codec->cmd_cache);
-        kfree(codec->name);
+        kfree(codec->vendor_name);
+        kfree(codec->chip_name);
         kfree(codec->modelname);
         kfree(codec->wcaps);
@@ -861 +920 @@
  */
 int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr,
-                                    int do_init, struct hda_codec **codecp)
+                                    struct hda_codec **codecp)
 {
         struct hda_codec *codec;
@@ -948 +1007 @@
                                            AC_VERB_GET_SUBSYSTEM_ID, 0);
         }
-        if (bus->modelname)
-                codec->modelname = kstrdup(bus->modelname, GFP_KERNEL);
 
         /* power-up all before initialization */
@@ -956 +1013 @@
                             AC_PWRST_D0);
 
-        if (do_init) {
-                err = snd_hda_codec_configure(codec);
-                if (err < 0)
-                        goto error;
-        }
         snd_hda_codec_proc_new(codec);
 
@@ -984 +1036 @@
 
         codec->preset = find_codec_preset(codec);
-        if (!codec->name) {
+        if (!codec->vendor_name || !codec->chip_name) {
                 err = get_codec_name(codec);
                 if (err < 0)
@@ -991 +1043 @@
         /* audio codec should override the mixer name */
         if (codec->afg || !*codec->bus->card->mixername)
-                strlcpy(codec->bus->card->mixername, codec->name,
-                        sizeof(codec->bus->card->mixername));
+                snprintf(codec->bus->card->mixername,
+                         sizeof(codec->bus->card->mixername),
+                         "%s %s", codec->vendor_name, codec->chip_name);
 
         if (is_generic_config(codec)) {
@@ -1013 +1066 @@
         return err;
 }
+EXPORT_SYMBOL_HDA(snd_hda_codec_configure);
 
 /**
@@ -1060 +1114 @@
 #define HDA_HASH_KEY(nid,dir,idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
 #define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
+#define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
+#define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
 #define INFO_AMP_CAPS   (1<<0)
 #define INFO_AMP_VOL(ch)        (1 << (1 + (ch)))
@@ -1150 +1206 @@
 EXPORT_SYMBOL_HDA(snd_hda_override_amp_caps);
 
-u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
+static unsigned int
+query_caps_hash(struct hda_codec *codec, hda_nid_t nid, u32 key,
+                unsigned int (*func)(struct hda_codec *, hda_nid_t))
 {
         struct hda_amp_info *info;
 
-        info = get_alloc_amp_hash(codec, HDA_HASH_PINCAP_KEY(nid));
+        info = get_alloc_amp_hash(codec, key);
         if (!info)
                 return 0;
         if (!info->head.val) {
-                info->amp_caps = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
                 info->head.val |= INFO_AMP_CAPS;
+                info->amp_caps = func(codec, nid);
         }
         return info->amp_caps;
+}
+
+static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid)
+{
+        return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
+}
+
+u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
+{
+        return query_caps_hash(codec, nid, HDA_HASH_PINCAP_KEY(nid),
+                               read_pin_cap);
 }
 EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps);
@@ -1437 +1506 @@
         id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
         id.index = idx;
+        if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
+                return NULL;
         strcpy(id.name, name);
         return snd_ctl_find_id(codec->bus->card, &id);
@@ -2247 +2318 @@
                               int direct, unsigned int verb, unsigned int parm)
 {
-        struct hda_bus *bus = codec->bus;
-        unsigned int res;
-        int err;
-
-        res = make_codec_cmd(codec, nid, direct, verb, parm);
-        snd_hda_power_up(codec);
-        mutex_lock(&bus->cmd_mutex);
-        err = bus->ops.command(bus, res);
-        if (!err) {
-                struct hda_cache_head *c;
-                u32 key;
-                /* parm may contain the verb stuff for get/set amp */
-                verb = verb | (parm >> 8);
-                parm &= 0xff;
-                key = build_cmd_cache_key(nid, verb);
-                c = get_alloc_hash(&codec->cmd_cache, key);
-                if (c)
-                        c->val = parm;
-        }
-        mutex_unlock(&bus->cmd_mutex);
-        snd_hda_power_down(codec);
-        return err;
+        int err = snd_hda_codec_write(codec, nid, direct, verb, parm);
+        struct hda_cache_head *c;
+        u32 key;
+
+        if (err < 0)
+                return err;
+        /* parm may contain the verb stuff for get/set amp */
+        verb = verb | (parm >> 8);
+        parm &= 0xff;
+        key = build_cmd_cache_key(nid, verb);
+        mutex_lock(&codec->bus->cmd_mutex);
+        c = get_alloc_hash(&codec->cmd_cache, key);
+        if (c)
+                c->val = parm;
+        mutex_unlock(&codec->bus->cmd_mutex);
+        return 0;
 }
 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
@@ -2316 +2381 @@
         int i;
 
-        snd_hda_codec_write(codec, fg, 0, AC_VERB_SET_POWER_STATE,
+        /* this delay seems necessary to avoid click noise at power-down */
+        if (power_state == AC_PWRST_D3)
+                msleep(100);
+        snd_hda_codec_read(codec, fg, 0, AC_VERB_SET_POWER_STATE,
                             power_state);
-        msleep(10); /* partial workaround for "azx_get_response timeout" */
+        /* partial workaround for "azx_get_response timeout" */
+        if (power_state == AC_PWRST_D0)
+                msleep(10);
 
         nid = codec->start_nid;
@@ -2324 +2394 @@
                 unsigned int wcaps = get_wcaps(codec, nid);
                 if (wcaps & AC_WCAP_POWER) {
-                        unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
-                                AC_WCAP_TYPE_SHIFT;
-                        if (wid_type == AC_WID_PIN) {
+                        unsigned int wid_type = get_wcaps_type(wcaps);
+                        if (power_state == AC_PWRST_D3 &&
+                            wid_type == AC_WID_PIN) {
                                 unsigned int pincap;
                                 /*
@@ -2338 +2408 @@
                                                 AC_VERB_GET_EAPD_BTLENABLE, 0);
                                         eapd &= 0x02;
-                                        if (power_state == AC_PWRST_D3 && eapd)
+                                        if (eapd)
                                                 continue;
                                 }
@@ -2532 +2602 @@
         case 24:
         case 32:
-                if (maxbps >= 32)
+                if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
                         val |= 0x40;
                 else if (maxbps >= 24)
@@ -2549 +2619 @@
 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
 
+static unsigned int get_pcm_param(struct hda_codec *codec, hda_nid_t nid)
+{
+        unsigned int val = 0;
+        if (nid != codec->afg &&
+            (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))
+                val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
+        if (!val || val == -1)
+                val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
+        if (!val || val == -1)
+                return 0;
+        return val;
+}
+
+static unsigned int query_pcm_param(struct hda_codec *codec, hda_nid_t nid)
+{
+        return query_caps_hash(codec, nid, HDA_HASH_PARPCM_KEY(nid),
+                               get_pcm_param);
+}
+
+static unsigned int get_stream_param(struct hda_codec *codec, hda_nid_t nid)
+{
+        unsigned int streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
+        if (!streams || streams == -1)
+                streams = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
+        if (!streams || streams == -1)
+                return 0;
+        return streams;
+}
+
+static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
+{
+        return query_caps_hash(codec, nid, HDA_HASH_PARSTR_KEY(nid),
+                               get_stream_param);
+}
+
 /**
  * snd_hda_query_supported_pcm - query the supported PCM rates and formats
@@ -2567 +2672 @@
         unsigned int i, val, wcaps;
 
-        val = 0;
         wcaps = get_wcaps(codec, nid);
-        if (nid != codec->afg && (wcaps & AC_WCAP_FORMAT_OVRD)) {
-                val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
-                if (val == -1)
-                        return -EIO;
-        }
-        if (!val)
-                val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
+        val = query_pcm_param(codec, nid);
 
         if (ratesp) {
@@ -2597 +2695 @@
                 unsigned int streams, bps;
 
-                streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
-                if (streams == -1)
+                streams = query_stream_param(codec, nid);
+                if (!streams)
                         return -EIO;
-                if (!streams) {
-                        streams = snd_hda_param_read(codec, codec->afg,
-                                                     AC_PAR_STREAM);
-                        if (streams == -1)
-                                return -EIO;
-                }
 
                 bps = 0;
@@ -2637 +2729 @@
                         }
                 }
-                else if (streams == AC_SUPFMT_FLOAT32) {
-                        /* should be exclusive */
+                if (streams & AC_SUPFMT_FLOAT32) {
                         formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
-                        bps = 32;
-                } else if (streams == AC_SUPFMT_AC3) {
+                        if (!bps)
+                                bps = 32;
+                }
+                if (streams == AC_SUPFMT_AC3) {
                         /* should be exclusive */
                         /* temporary hack: we have still no proper support
@@ -2679 +2772 @@
         unsigned int val = 0, rate, stream;
 
-        if (nid != codec->afg &&
-            (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) {
-                val = snd_hda_param_read(codec, nid, AC_PAR_PCM);
-                if (val == -1)
-                        return 0;
-        }
-        if (!val) {
-                val = snd_hda_param_read(codec, codec->afg, AC_PAR_PCM);
-                if (val == -1)
-                        return 0;
-        }
+        val = query_pcm_param(codec, nid);
+        if (!val)
+                return 0;
 
         rate = format & 0xff00;
@@ -2701 +2786 @@
                 return 0;
 
-        stream = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
-        if (stream == -1)
-                return 0;
-        if (!stream && nid != codec->afg)
-                stream = snd_hda_param_read(codec, codec->afg, AC_PAR_STREAM);
-        if (!stream || stream == -1)
+        stream = query_stream_param(codec, nid);
+        if (!stream)
                 return 0;
 
@@ -3425 +3506 @@
                 mutex_lock(&codec->spdif_mutex);
                 if (mout->share_spdif) {
-                        runtime->hw.rates &= mout->spdif_rates;
-                        runtime->hw.formats &= mout->spdif_formats;
-                        if (mout->spdif_maxbps < hinfo->maxbps)
-                                hinfo->maxbps = mout->spdif_maxbps;
+                        if ((runtime->hw.rates & mout->spdif_rates) &&
+                            (runtime->hw.formats & mout->spdif_formats)) {
+                                runtime->hw.rates &= mout->spdif_rates;
+                                runtime->hw.formats &= mout->spdif_formats;
+                                if (mout->spdif_maxbps < hinfo->maxbps)
+                                        hinfo->maxbps = mout->spdif_maxbps;
+                        } else {
+                                mout->share_spdif = 0;
+                                /* FIXME: need notify? */
+                        }
                 }
                 mutex_unlock(&codec->spdif_mutex);
@@ -3598 +3685 @@
         for (nid = codec->start_nid; nid < end_nid; nid++) {
                 unsigned int wid_caps = get_wcaps(codec, nid);
-                unsigned int wid_type =
-                        (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
+                unsigned int wid_type = get_wcaps_type(wid_caps);
                 unsigned int def_conf;
                 short assoc, loc;
@@ -3840 +3926 @@
  * snd_hda_suspend - suspend the codecs
  * @bus: the HDA bus
- * @state: suspsend state
  *
  * Returns 0 if successful.
  */
-int snd_hda_suspend(struct hda_bus *bus, pm_message_t state)
+int snd_hda_suspend(struct hda_bus *bus)
 {
         struct hda_codec *codec;

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

@@ -569 +569 @@
         int (*command)(struct hda_bus *bus, unsigned int cmd);
         /* get a response from the last command */
-        unsigned int (*get_response)(struct hda_bus *bus);
+        unsigned int (*get_response)(struct hda_bus *bus, unsigned int addr);
         /* free the private data */
         void (*private_free)(struct hda_bus *);
@@ -575 +575 @@
         int (*attach_pcm)(struct hda_bus *bus, struct hda_codec *codec,
                           struct hda_pcm *pcm);
+        /* reset bus for retry verb */
+        void (*bus_reset)(struct hda_bus *bus);
 #ifdef CONFIG_SND_HDA_POWER_SAVE
         /* notify power-up/down from codec to controller */
@@ -627 +629 @@
         /* misc op flags */
         unsigned int needs_damn_long_delay :1;
+        unsigned int allow_bus_reset:1; /* allow bus reset at fatal error */
+        unsigned int sync_write:1;      /* sync after verb write */
+        /* status for codec/controller */
         unsigned int shutdown :1;       /* being unloaded */
+        unsigned int rirb_error:1;      /* error in codec communication */
+        unsigned int response_reset:1;  /* controller was reset */
+        unsigned int in_reset:1;        /* during reset operation */
 };
 
@@ -752 +760 @@
         const struct hda_codec_preset *preset;
         struct module *owner;
-        const char *name;       /* codec name */
+        const char *vendor_name;        /* codec vendor name */
+        const char *chip_name;          /* codec chip name */
         const char *modelname;  /* model name for preset */
 
@@ -830 +839 @@
                     struct hda_bus **busp);
 int snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr,
-                      int do_init, struct hda_codec **codecp);
+                      struct hda_codec **codecp);
+int snd_hda_codec_configure(struct hda_codec *codec);
 
 /*
@@ -914 +924 @@
  */
 #ifdef CONFIG_PM
-int snd_hda_suspend(struct hda_bus *bus, pm_message_t state);
+int snd_hda_suspend(struct hda_bus *bus);
 int snd_hda_resume(struct hda_bus *bus);
 #endif
@@ -938 +948 @@
 #endif
 
+#ifdef CONFIG_SND_HDA_PATCH_LOADER
+/*
+ * patch firmware
+ */
+int snd_hda_load_patch(struct hda_bus *bus, const char *patch);
+#endif
+
 /*
  * Codec modularization

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

@@ -122 +122 @@
                 return -ENOMEM;
         node->nid = nid;
-        nconns = snd_hda_get_connections(codec, nid, conn_list,
-                                         HDA_MAX_CONNECTIONS);
-        if (nconns < 0) {
-                kfree(node);
-                return nconns;
+        node->wid_caps = get_wcaps(codec, nid);
+        node->type = get_wcaps_type(node->wid_caps);
+        if (node->wid_caps & AC_WCAP_CONN_LIST) {
+                nconns = snd_hda_get_connections(codec, nid, conn_list,
+                                                 HDA_MAX_CONNECTIONS);
+                if (nconns < 0) {
+                        kfree(node);
+                        return nconns;
+                }
+        } else {
+                nconns = 0;
         }
         if (nconns <= ARRAY_SIZE(node->slist))
@@ -141 +147 @@
         memcpy(node->conn_list, conn_list, nconns * sizeof(hda_nid_t));
         node->nconns = nconns;
-        node->wid_caps = get_wcaps(codec, nid);
-        node->type = (node->wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
 
         if (node->type == AC_WID_PIN) {

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

@@ -25 +25 @@
 #include <linux/mutex.h>
 #include <linux/ctype.h>
+#include <linux/firmware.h>
 #include <sound/core.h>
 #include "hda_codec.h"
@@ -243 +244 @@
 CODEC_INFO_SHOW(afg);
 CODEC_INFO_SHOW(mfg);
-CODEC_INFO_STR_SHOW(name);
+CODEC_INFO_STR_SHOW(vendor_name);
+CODEC_INFO_STR_SHOW(chip_name);
 CODEC_INFO_STR_SHOW(modelname);
 
@@ -276 +278 @@
 CODEC_INFO_STORE(subsystem_id);
 CODEC_INFO_STORE(revision_id);
-CODEC_INFO_STR_STORE(name);
+CODEC_INFO_STR_STORE(vendor_name);
+CODEC_INFO_STR_STORE(chip_name);
 CODEC_INFO_STR_STORE(modelname);
 
@@ -311 +314 @@
 }
 
-static ssize_t init_verbs_store(struct device *dev,
-                                struct device_attribute *attr,
-                                const char *buf, size_t count)
-{
-        struct snd_hwdep *hwdep = dev_get_drvdata(dev);
-        struct hda_codec *codec = hwdep->private_data;
+static int parse_init_verbs(struct hda_codec *codec, const char *buf)
+{
         struct hda_verb *v;
         int nid, verb, param;
@@ -330 +329 @@
         v->verb = verb;
         v->param = param;
+        return 0;
+}
+
+static ssize_t init_verbs_store(struct device *dev,
+                                struct device_attribute *attr,
+                                const char *buf, size_t count)
+{
+        struct snd_hwdep *hwdep = dev_get_drvdata(dev);
+        struct hda_codec *codec = hwdep->private_data;
+        int err = parse_init_verbs(codec, buf);
+        if (err < 0)
+                return err;
         return count;
 }
@@ -375 +386 @@
 #define MAX_HINTS       1024
 
-static ssize_t hints_store(struct device *dev,
-                           struct device_attribute *attr,
-                           const char *buf, size_t count)
-{
-        struct snd_hwdep *hwdep = dev_get_drvdata(dev);
-        struct hda_codec *codec = hwdep->private_data;
+static int parse_hints(struct hda_codec *codec, const char *buf)
+{
         char *key, *val;
         struct hda_hint *hint;
@@ -387 +394 @@
                 buf++;
         if (!*buf || *buf == '#' || *buf == '\n')
-                return count;
+                return 0;
         if (*buf == '=')
                 return -EINVAL;
@@ -410 +417 @@
                 hint->key = key;
                 hint->val = val;
-                return count;
+                return 0;
         }
         /* allocate a new hint entry */
@@ -423 +430 @@
         hint->key = key;
         hint->val = val;
+        return 0;
+}
+
+static ssize_t hints_store(struct device *dev,
+                           struct device_attribute *attr,
+                           const char *buf, size_t count)
+{
+        struct snd_hwdep *hwdep = dev_get_drvdata(dev);
+        struct hda_codec *codec = hwdep->private_data;
+        int err = parse_hints(codec, buf);
+        if (err < 0)
+                return err;
         return count;
 }
@@ -468 +487 @@
 #define MAX_PIN_CONFIGS         32
 
-static ssize_t user_pin_configs_store(struct device *dev,
-                                      struct device_attribute *attr,
-                                      const char *buf, size_t count)
-{
-        struct snd_hwdep *hwdep = dev_get_drvdata(dev);
-        struct hda_codec *codec = hwdep->private_data;
+static int parse_user_pin_configs(struct hda_codec *codec, const char *buf)
+{
         int nid, cfg;
-        int err;
 
         if (sscanf(buf, "%i %i", &nid, &cfg) != 2)
@@ -481 +495 @@
         if (!nid)
                 return -EINVAL;
-        err = snd_hda_add_pincfg(codec, &codec->user_pins, nid, cfg);
+        return snd_hda_add_pincfg(codec, &codec->user_pins, nid, cfg);
+}
+
+static ssize_t user_pin_configs_store(struct device *dev,
+                                      struct device_attribute *attr,
+                                      const char *buf, size_t count)
+{
+        struct snd_hwdep *hwdep = dev_get_drvdata(dev);
+        struct hda_codec *codec = hwdep->private_data;
+        int err = parse_user_pin_configs(codec, buf);
         if (err < 0)
                 return err;
@@ -500 +523 @@
         CODEC_ATTR_RO(afg),
         CODEC_ATTR_RO(mfg),
-        CODEC_ATTR_RW(name),
+        CODEC_ATTR_RW(vendor_name),
+        CODEC_ATTR_RW(chip_name),
         CODEC_ATTR_RW(modelname),
         CODEC_ATTR_RW(init_verbs),
@@ -551 +575 @@
 
 #endif /* CONFIG_SND_HDA_RECONFIG */
+
+#ifdef CONFIG_SND_HDA_PATCH_LOADER
+
+/* parser mode */
+enum {
+        LINE_MODE_NONE,
+        LINE_MODE_CODEC,
+        LINE_MODE_MODEL,
+        LINE_MODE_PINCFG,
+        LINE_MODE_VERB,
+        LINE_MODE_HINT,
+        NUM_LINE_MODES,
+};
+
+static inline int strmatch(const char *a, const char *b)
+{
+        return strnicmp(a, b, strlen(b)) == 0;
+}
+
+/* parse the contents after the line "[codec]"
+ * accept only the line with three numbers, and assign the current codec
+ */
+static void parse_codec_mode(char *buf, struct hda_bus *bus,
+                             struct hda_codec **codecp)
+{
+        unsigned int vendorid, subid, caddr;
+        struct hda_codec *codec;
+
+        *codecp = NULL;
+        if (sscanf(buf, "%i %i %i", &vendorid, &subid, &caddr) == 3) {
+                list_for_each_entry(codec, &bus->codec_list, list) {
+                        if (codec->addr == caddr) {
+                                *codecp = codec;
+                                break;
+                        }
+                }
+        }
+}
+
+/* parse the contents after the other command tags, [pincfg], [verb],
+ * [hint] and [model]
+ * just pass to the sysfs helper (only when any codec was specified)
+ */
+static void parse_pincfg_mode(char *buf, struct hda_bus *bus,
+                              struct hda_codec **codecp)
+{
+        if (!*codecp)
+                return;
+        parse_user_pin_configs(*codecp, buf);
+}
+
+static void parse_verb_mode(char *buf, struct hda_bus *bus,
+                            struct hda_codec **codecp)
+{
+        if (!*codecp)
+                return;
+        parse_init_verbs(*codecp, buf);
+}
+
+static void parse_hint_mode(char *buf, struct hda_bus *bus,
+                            struct hda_codec **codecp)
+{
+        if (!*codecp)
+                return;
+        parse_hints(*codecp, buf);
+}
+
+static void parse_model_mode(char *buf, struct hda_bus *bus,
+                             struct hda_codec **codecp)
+{
+        if (!*codecp)
+                return;
+        kfree((*codecp)->modelname);
+        (*codecp)->modelname = kstrdup(buf, GFP_KERNEL);
+}
+
+struct hda_patch_item {
+        const char *tag;
+        void (*parser)(char *buf, struct hda_bus *bus, struct hda_codec **retc);
+};
+
+static struct hda_patch_item patch_items[NUM_LINE_MODES] = {
+        [LINE_MODE_CODEC] = { "[codec]", parse_codec_mode },
+        [LINE_MODE_MODEL] = { "[model]", parse_model_mode },
+        [LINE_MODE_VERB] = { "[verb]", parse_verb_mode },
+        [LINE_MODE_PINCFG] = { "[pincfg]", parse_pincfg_mode },
+        [LINE_MODE_HINT] = { "[hint]", parse_hint_mode },
+};
+
+/* check the line starting with '[' -- change the parser mode accodingly */
+static int parse_line_mode(char *buf, struct hda_bus *bus)
+{
+        int i;
+        for (i = 0; i < ARRAY_SIZE(patch_items); i++) {
+                if (!patch_items[i].tag)
+                        continue;
+                if (strmatch(buf, patch_items[i].tag))
+                        return i;
+        }
+        return LINE_MODE_NONE;
+}
+
+/* copy one line from the buffer in fw, and update the fields in fw
+ * return zero if it reaches to the end of the buffer, or non-zero
+ * if successfully copied a line
+ *
+ * the spaces at the beginning and the end of the line are stripped
+ */
+static int get_line_from_fw(char *buf, int size, struct firmware *fw)
+{
+        int len;
+        const char *p = fw->data;
+        while (isspace(*p) && fw->size) {
+                p++;
+                fw->size--;
+        }
+        if (!fw->size)
+                return 0;
+        if (size < fw->size)
+                size = fw->size;
+
+        for (len = 0; len < fw->size; len++) {
+                if (!*p)
+                        break;
+                if (*p == '\n') {
+                        p++;
+                        len++;
+                        break;
+                }
+                if (len < size)
+                        *buf++ = *p++;
+        }
+        *buf = 0;
+        fw->size -= len;
+        fw->data = p;
+        remove_trail_spaces(buf);
+        return 1;
+}
+
+/*
+ * load a "patch" firmware file and parse it
+ */
+int snd_hda_load_patch(struct hda_bus *bus, const char *patch)
+{
+        int err;
+        const struct firmware *fw;
+        struct firmware tmp;
+        char buf[128];
+        struct hda_codec *codec;
+        int line_mode;
+        struct device *dev = bus->card->dev;
+
+        if (snd_BUG_ON(!dev))
+                return -ENODEV;
+        err = request_firmware(&fw, patch, dev);
+        if (err < 0) {
+                printk(KERN_ERR "hda-codec: Cannot load the patch '%s'\n",
+                       patch);
+                return err;
+        }
+
+        tmp = *fw;
+        line_mode = LINE_MODE_NONE;
+        codec = NULL;
+        while (get_line_from_fw(buf, sizeof(buf) - 1, &tmp)) {
+                if (!*buf || *buf == '#' || *buf == '\n')
+                        continue;
+                if (*buf == '[')
+                        line_mode = parse_line_mode(buf, bus);
+                else if (patch_items[line_mode].parser)
+                        patch_items[line_mode].parser(buf, bus, &codec);
+        }
+        release_firmware(fw);
+        return 0;
+}
+EXPORT_SYMBOL_HDA(snd_hda_load_patch);
+#endif /* CONFIG_SND_HDA_PATCH_LOADER */

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

@@ -67 +67 @@
 static int single_cmd;
 static int enable_msi;
+#ifdef CONFIG_SND_HDA_PATCH_LOADER
+static char *patch[SNDRV_CARDS];
+#endif
 
 module_param_array(index, int, NULL, 0444);
@@ -90 +93 @@
 module_param(enable_msi, int, 0444);
 MODULE_PARM_DESC(enable_msi, "Enable Message Signaled Interrupt (MSI)");
+#ifdef CONFIG_SND_HDA_PATCH_LOADER
+module_param_array(patch, charp, NULL, 0444);
+MODULE_PARM_DESC(patch, "Patch file for Intel HD audio interface.");
+#endif
 
 #ifdef CONFIG_SND_HDA_POWER_SAVE
@@ -134 +141 @@
 MODULE_DESCRIPTION("Intel HDA driver");
 
+#ifdef CONFIG_SND_VERBOSE_PRINTK
+#define SFX     /* nop */
+#else
 #define SFX     "hda-intel: "
-
+#endif
 
 /*
@@ -141 +151 @@
  */
 #define ICH6_REG_GCAP                   0x00
+#define   ICH6_GCAP_64OK        (1 << 0)   /* 64bit address support */
+#define   ICH6_GCAP_NSDO        (3 << 1)   /* # of serial data out signals */
+#define   ICH6_GCAP_BSS         (31 << 3)  /* # of bidirectional streams */
+#define   ICH6_GCAP_ISS         (15 << 8)  /* # of input streams */
+#define   ICH6_GCAP_OSS         (15 << 12) /* # of output streams */
 #define ICH6_REG_VMIN                   0x02
 #define ICH6_REG_VMAJ                   0x03
@@ -146 +161 @@
 #define ICH6_REG_INPAY                  0x06
 #define ICH6_REG_GCTL                   0x08
+#define   ICH6_GCTL_RESET       (1 << 0)   /* controller reset */
+#define   ICH6_GCTL_FCNTRL      (1 << 1)   /* flush control */
+#define   ICH6_GCTL_UNSOL       (1 << 8)   /* accept unsol. response enable */
 #define ICH6_REG_WAKEEN                 0x0c
 #define ICH6_REG_STATESTS               0x0e
 #define ICH6_REG_GSTS                   0x10
+#define   ICH6_GSTS_FSTS        (1 << 1)   /* flush status */
 #define ICH6_REG_INTCTL                 0x20
 #define ICH6_REG_INTSTS                 0x24
@@ -156 +175 @@
 #define ICH6_REG_CORBUBASE              0x44
 #define ICH6_REG_CORBWP                 0x48
-#define ICH6_REG_CORBRP                 0x4A
+#define ICH6_REG_CORBRP                 0x4a
+#define   ICH6_CORBRP_RST       (1 << 15)  /* read pointer reset */
 #define ICH6_REG_CORBCTL                0x4c
+#define   ICH6_CORBCTL_RUN      (1 << 1)   /* enable DMA */
+#define   ICH6_CORBCTL_CMEIE    (1 << 0)   /* enable memory error irq */
 #define ICH6_REG_CORBSTS                0x4d
+#define   ICH6_CORBSTS_CMEI     (1 << 0)   /* memory error indication */
 #define ICH6_REG_CORBSIZE               0x4e
 
@@ -164 +187 @@
 #define ICH6_REG_RIRBUBASE              0x54
 #define ICH6_REG_RIRBWP                 0x58
+#define   ICH6_RIRBWP_RST       (1 << 15)  /* write pointer reset */
 #define ICH6_REG_RINTCNT                0x5a
 #define ICH6_REG_RIRBCTL                0x5c
+#define   ICH6_RBCTL_IRQ_EN     (1 << 0)   /* enable IRQ */
+#define   ICH6_RBCTL_DMA_EN     (1 << 1)   /* enable DMA */
+#define   ICH6_RBCTL_OVERRUN_EN (1 << 2)   /* enable overrun irq */
 #define ICH6_REG_RIRBSTS                0x5d
+#define   ICH6_RBSTS_IRQ        (1 << 0)   /* response irq */
+#define   ICH6_RBSTS_OVERRUN    (1 << 2)   /* overrun irq */
 #define ICH6_REG_RIRBSIZE               0x5e
 
@@ -237 +266 @@
 /* STATESTS int mask: S3,SD2,SD1,SD0 */
 #define AZX_MAX_CODECS          4
-#define STATESTS_INT_MASK       0x0f
+#define STATESTS_INT_MASK       ((1 << AZX_MAX_CODECS) - 1)
 
 /* SD_CTL bits */
@@ -263 +292 @@
 #define ICH6_INT_GLOBAL_EN      0x80000000 /* global interrupt enable bit */
 
-/* GCTL unsolicited response enable bit */
-#define ICH6_GCTL_UREN          (1<<8)
-
-/* GCTL reset bit */
-#define ICH6_GCTL_RESET         (1<<0)
-
-/* CORB/RIRB control, read/write pointer */
-#define ICH6_RBCTL_DMA_EN       0x02    /* enable DMA */
-#define ICH6_RBCTL_IRQ_EN       0x01    /* enable IRQ */
-#define ICH6_RBRWP_CLR          0x8000  /* read/write pointer clear */
 /* below are so far hardcoded - should read registers in future */
 #define ICH6_MAX_CORB_ENTRIES   256
@@ -367 +386 @@
         /* for RIRB */
         unsigned short rp, wp;  /* read/write pointers */
-        int cmds;               /* number of pending requests */
-        u32 res;                /* last read value */
+        int cmds[AZX_MAX_CODECS];       /* number of pending requests */
+        u32 res[AZX_MAX_CODECS];        /* last read value */
 };
 
@@ -428 +447 @@
 
         /* for debugging */
-        unsigned int last_cmd;  /* last issued command (to sync) */
+        unsigned int last_cmd[AZX_MAX_CODECS];
 
         /* for pending irqs */
@@ -523 +542 @@
 static void azx_init_cmd_io(struct azx *chip)
 {
+        spin_lock_irq(&chip->reg_lock);
         /* CORB set up */
         chip->corb.addr = chip->rb.addr;
@@ -534 +554 @@
         azx_writew(chip, CORBWP, 0);
         /* reset the corb hw read pointer */
-        azx_writew(chip, CORBRP, ICH6_RBRWP_CLR);
+        azx_writew(chip, CORBRP, ICH6_CORBRP_RST);
         /* enable corb dma */
-        azx_writeb(chip, CORBCTL, ICH6_RBCTL_DMA_EN);
+        azx_writeb(chip, CORBCTL, ICH6_CORBCTL_RUN);
 
         /* RIRB set up */
         chip->rirb.addr = chip->rb.addr + 2048;
         chip->rirb.buf = (u32 *)(chip->rb.area + 2048);
+        chip->rirb.wp = chip->rirb.rp = 0;
+        memset(chip->rirb.cmds, 0, sizeof(chip->rirb.cmds));
         azx_writel(chip, RIRBLBASE, (u32)chip->rirb.addr);
         azx_writel(chip, RIRBUBASE, upper_32_bits(chip->rirb.addr));
@@ -547 +569 @@
         azx_writeb(chip, RIRBSIZE, 0x02);
         /* reset the rirb hw write pointer */
-        azx_writew(chip, RIRBWP, ICH6_RBRWP_CLR);
+        azx_writew(chip, RIRBWP, ICH6_RIRBWP_RST);
         /* set N=1, get RIRB response interrupt for new entry */
         azx_writew(chip, RINTCNT, 1);
         /* enable rirb dma and response irq */
         azx_writeb(chip, RIRBCTL, ICH6_RBCTL_DMA_EN | ICH6_RBCTL_IRQ_EN);
-        chip->rirb.rp = chip->rirb.cmds = 0;
+        spin_unlock_irq(&chip->reg_lock);
 }
 
 static void azx_free_cmd_io(struct azx *chip)
 {
+        spin_lock_irq(&chip->reg_lock);
         /* disable ringbuffer DMAs */
         azx_writeb(chip, RIRBCTL, 0);
         azx_writeb(chip, CORBCTL, 0);
+        spin_unlock_irq(&chip->reg_lock);
+}
+
+static unsigned int azx_command_addr(u32 cmd)
+{
+        unsigned int addr = cmd >> 28;
+
+        if (addr >= AZX_MAX_CODECS) {
+                snd_BUG();
+                addr = 0;
+        }
+
+        return addr;
+}
+
+static unsigned int azx_response_addr(u32 res)
+{
+        unsigned int addr = res & 0xf;
+
+        if (addr >= AZX_MAX_CODECS) {
+                snd_BUG();
+                addr = 0;
+        }
+
+        return addr;
 }
 
@@ -566 +614 @@
 {
         struct azx *chip = bus->private_data;
+        unsigned int addr = azx_command_addr(val);
         unsigned int wp;
+
+        spin_lock_irq(&chip->reg_lock);
 
         /* add command to corb */
@@ -573 +624 @@
         wp %= ICH6_MAX_CORB_ENTRIES;
 
-        spin_lock_irq(&chip->reg_lock);
-        chip->rirb.cmds++;
+        chip->rirb.cmds[addr]++;
         chip->corb.buf[wp] = cpu_to_le32(val);
         azx_writel(chip, CORBWP, wp);
+
         spin_unlock_irq(&chip->reg_lock);
 
@@ -588 +639 @@
 {
         unsigned int rp, wp;
+        unsigned int addr;
         u32 res, res_ex;
 
@@ -594 +646 @@
                 return;
         chip->rirb.wp = wp;
-                
+
         while (chip->rirb.rp != wp) {
                 chip->rirb.rp++;
@@ -602 +654 @@
                 res_ex = le32_to_cpu(chip->rirb.buf[rp + 1]);
                 res = le32_to_cpu(chip->rirb.buf[rp]);
+                addr = azx_response_addr(res_ex);
                 if (res_ex & ICH6_RIRB_EX_UNSOL_EV)
                         snd_hda_queue_unsol_event(chip->bus, res, res_ex);
-                else if (chip->rirb.cmds) {
-                        chip->rirb.res = res;
+                else if (chip->rirb.cmds[addr]) {
+                        chip->rirb.res[addr] = res;
                         smp_wmb();
-                        chip->rirb.cmds--;
-                }
+                        chip->rirb.cmds[addr]--;
+                } else
+                        snd_printk(KERN_ERR SFX "spurious response %#x:%#x, "
+                                   "last cmd=%#08x\n",
+                                   res, res_ex,
+                                   chip->last_cmd[addr]);
         }
 }
 
 /* receive a response */
-static unsigned int azx_rirb_get_response(struct hda_bus *bus)
+static unsigned int azx_rirb_get_response(struct hda_bus *bus,
+                                          unsigned int addr)
 {
         struct azx *chip = bus->private_data;
@@ -629 +687 @@
                         spin_unlock_irq(&chip->reg_lock);
                 }
-                if (!chip->rirb.cmds) {
+                if (!chip->rirb.cmds[addr]) {
                         smp_rmb();
-                        return chip->rirb.res; /* the last value */
+                        bus->rirb_error = 0;
+                        return chip->rirb.res[addr]; /* the last value */
                 }
                 if (time_after(jiffies, timeout))
@@ -655 +714 @@
 #endif
         if (chip->msi) {
-                snd_printk(KERN_WARNING "hda_intel: No response from codec, "
-                           "disabling MSI: last cmd=0x%08x\n", chip->last_cmd);
+                snd_printk(KERN_WARNING SFX "No response from codec, "
+                           "disabling MSI: last cmd=0x%08x\n",
+                           chip->last_cmd[addr]);
                 free_irq(chip->irq, chip);
                 chip->irq = -1;
                 pci_disable_msi(chip->pci);
                 chip->msi = 0;
-                if (azx_acquire_irq(chip, 1) < 0)
+                if (azx_acquire_irq(chip, 1) < 0) {
+                        bus->rirb_error = 1;
                         return -1;
+                }
                 goto again;
         }
 
         if (!chip->polling_mode) {
-                snd_printk(KERN_WARNING "hda_intel: azx_get_response timeout, "
+                snd_printk(KERN_WARNING SFX "azx_get_response timeout, "
                            "switching to polling mode: last cmd=0x%08x\n",
-                           chip->last_cmd);
+                           chip->last_cmd[addr]);
                 chip->polling_mode = 1;
                 goto again;
@@ -682 +744 @@
         }
 
+        /* a fatal communication error; need either to reset or to fallback
+         * to the single_cmd mode
+         */
+        bus->rirb_error = 1;
+        if (bus->allow_bus_reset && !bus->response_reset && !bus->in_reset) {
+                bus->response_reset = 1;
+                return -1; /* give a chance to retry */
+        }
+
         snd_printk(KERN_ERR "hda_intel: azx_get_response timeout, "
                    "switching to single_cmd mode: last cmd=0x%08x\n",
-                   chip->last_cmd);
-        chip->rirb.rp = azx_readb(chip, RIRBWP);
-        chip->rirb.cmds = 0;
-        /* switch to single_cmd mode */
+                   chip->last_cmd[addr]);
         chip->single_cmd = 1;
+        bus->response_reset = 0;
+        /* re-initialize CORB/RIRB */
         azx_free_cmd_io(chip);
+        azx_init_cmd_io(chip);
         return -1;
 }
@@ -703 +774 @@
  */
 
+/* receive a response */
+static int azx_single_wait_for_response(struct azx *chip, unsigned int addr)
+{
+        int timeout = 50;
+
+        while (timeout--) {
+                /* check IRV busy bit */
+                if (azx_readw(chip, IRS) & ICH6_IRS_VALID) {
+                        /* reuse rirb.res as the response return value */
+                        chip->rirb.res[addr] = azx_readl(chip, IR);
+                        return 0;
+                }
+                udelay(1);
+        }
+        if (printk_ratelimit())
+                snd_printd(SFX "get_response timeout: IRS=0x%x\n",
+                           azx_readw(chip, IRS));
+        chip->rirb.res[addr] = -1;
+        return -EIO;
+}
+
 /* send a command */
 static int azx_single_send_cmd(struct hda_bus *bus, u32 val)
 {
         struct azx *chip = bus->private_data;
+        unsigned int addr = azx_command_addr(val);
         int timeout = 50;
 
+        bus->rirb_error = 0;
         while (timeout--) {
                 /* check ICB busy bit */
@@ -718 +812 @@
                         azx_writew(chip, IRS, azx_readw(chip, IRS) |
                                    ICH6_IRS_BUSY);
-                        return 0;
+                        return azx_single_wait_for_response(chip, addr);
                 }
                 udelay(1);
@@ -729 +823 @@
 
 /* receive a response */
-static unsigned int azx_single_get_response(struct hda_bus *bus)
+static unsigned int azx_single_get_response(struct hda_bus *bus,
+                                            unsigned int addr)
 {
         struct azx *chip = bus->private_data;
-        int timeout = 50;
-
-        while (timeout--) {
-                /* check IRV busy bit */
-                if (azx_readw(chip, IRS) & ICH6_IRS_VALID)
-                        return azx_readl(chip, IR);
-                udelay(1);
-        }
-        if (printk_ratelimit())
-                snd_printd(SFX "get_response timeout: IRS=0x%x\n",
-                           azx_readw(chip, IRS));
-        return (unsigned int)-1;
+        return chip->rirb.res[addr];
 }
 
@@ -758 +842 @@
         struct azx *chip = bus->private_data;
 
-        chip->last_cmd = val;
+        chip->last_cmd[azx_command_addr(val)] = val;
         if (chip->single_cmd)
                 return azx_single_send_cmd(bus, val);
@@ -766 +850 @@
 
 /* get a response */
-static unsigned int azx_get_response(struct hda_bus *bus)
+static unsigned int azx_get_response(struct hda_bus *bus,
+                                     unsigned int addr)
 {
         struct azx *chip = bus->private_data;
         if (chip->single_cmd)
-                return azx_single_get_response(bus);
+                return azx_single_get_response(bus, addr);
         else
-                return azx_rirb_get_response(bus);
+                return azx_rirb_get_response(bus, addr);
 }
 
@@ -811 +896 @@
         /* check to see if controller is ready */
         if (!azx_readb(chip, GCTL)) {
-                snd_printd("azx_reset: controller not ready!\n");
+                snd_printd(SFX "azx_reset: controller not ready!\n");
                 return -EBUSY;
         }
 
         /* Accept unsolicited responses */
-        azx_writel(chip, GCTL, azx_readl(chip, GCTL) | ICH6_GCTL_UREN);
+        azx_writel(chip, GCTL, azx_readl(chip, GCTL) | ICH6_GCTL_UNSOL);
 
         /* detect codecs */
         if (!chip->codec_mask) {
                 chip->codec_mask = azx_readw(chip, STATESTS);
-                snd_printdd("codec_mask = 0x%x\n", chip->codec_mask);
+                snd_printdd(SFX "codec_mask = 0x%x\n", chip->codec_mask);
         }
 
@@ -931 +1016 @@
 
         /* initialize the codec command I/O */
-        if (!chip->single_cmd)
-                azx_init_cmd_io(chip);
+        azx_init_cmd_io(chip);
 
         /* program the position buffer */
@@ -989 +1073 @@
                 pci_read_config_word(chip->pci, INTEL_SCH_HDA_DEVC, &snoop);
                 if (snoop & INTEL_SCH_HDA_DEVC_NOSNOOP) {
-                        pci_write_config_word(chip->pci, INTEL_SCH_HDA_DEVC, \
+                        pci_write_config_word(chip->pci, INTEL_SCH_HDA_DEVC,
                                 snoop & (~INTEL_SCH_HDA_DEVC_NOSNOOP));
                         pci_read_config_word(chip->pci,
                                 INTEL_SCH_HDA_DEVC, &snoop);
-                        snd_printdd("HDA snoop disabled, enabling ... %s\n",\
-                                (snoop & INTEL_SCH_HDA_DEVC_NOSNOOP) \
+                        snd_printdd(SFX "HDA snoop disabled, enabling ... %s\n",
+                                (snoop & INTEL_SCH_HDA_DEVC_NOSNOOP)
                                 ? "Failed" : "OK");
                 }
@@ -1048 +1132 @@
         status = azx_readb(chip, RIRBSTS);
         if (status & RIRB_INT_MASK) {
-                if (!chip->single_cmd && (status & RIRB_INT_RESPONSE))
+                if (status & RIRB_INT_RESPONSE)
                         azx_update_rirb(chip);
                 azx_writeb(chip, RIRBSTS, RIRB_INT_MASK);
@@ -1140 +1224 @@
                 pos_adj = frames_to_bytes(runtime, pos_adj);
                 if (pos_adj >= period_bytes) {
-                        snd_printk(KERN_WARNING "Too big adjustment %d\n",
+                        snd_printk(KERN_WARNING SFX "Too big adjustment %d\n",
                                    bdl_pos_adj[chip->dev_index]);
                         pos_adj = 0;
@@ -1164 +1248 @@
 
  error:
-        snd_printk(KERN_ERR "Too many BDL entries: buffer=%d, period=%d\n",
+        snd_printk(KERN_ERR SFX "Too many BDL entries: buffer=%d, period=%d\n",
                    azx_dev->bufsize, period_bytes);
         return -EINVAL;
@@ -1251 +1335 @@
         unsigned int res;
 
+        mutex_lock(&chip->bus->cmd_mutex);
         chip->probing = 1;
         azx_send_cmd(chip->bus, cmd);
-        res = azx_get_response(chip->bus);
+        res = azx_get_response(chip->bus, addr);
         chip->probing = 0;
+        mutex_unlock(&chip->bus->cmd_mutex);
         if (res == -1)
                 return -EIO;
-        snd_printdd("hda_intel: codec #%d probed OK\n", addr);
+        snd_printdd(SFX "codec #%d probed OK\n", addr);
         return 0;
 }
@@ -1264 +1350 @@
                                  struct hda_pcm *cpcm);
 static void azx_stop_chip(struct azx *chip);
+
+static void azx_bus_reset(struct hda_bus *bus)
+{
+        struct azx *chip = bus->private_data;
+
+        bus->in_reset = 1;
+        azx_stop_chip(chip);
+        azx_init_chip(chip);
+#ifdef CONFIG_PM
+        if (chip->initialized) {
+                int i;
+
+                for (i = 0; i < AZX_MAX_PCMS; i++)
+                        snd_pcm_suspend_all(chip->pcm[i]);
+                snd_hda_suspend(chip->bus);
+                snd_hda_resume(chip->bus);
+        }
+#endif
+        bus->in_reset = 0;
+}
 
 /*
@@ -1274 +1380 @@
 };
 
-static int __devinit azx_codec_create(struct azx *chip, const char *model,
-                                      int no_init)
+static int __devinit azx_codec_create(struct azx *chip, const char *model)
 {
         struct hda_bus_template bus_temp;
@@ -1288 +1393 @@
         bus_temp.ops.get_response = azx_get_response;
         bus_temp.ops.attach_pcm = azx_attach_pcm_stream;
+        bus_temp.ops.bus_reset = azx_bus_reset;
 #ifdef CONFIG_SND_HDA_POWER_SAVE
         bus_temp.power_save = &power_save;
@@ -1312 +1418 @@
                                  * that don't exist
                                  */
-                                snd_printk(KERN_WARNING
-                                           "hda_intel: Codec #%d probe error; "
+                                snd_printk(KERN_WARNING SFX
+                                           "Codec #%d probe error; "
                                            "disabling it...\n", c);
                                 chip->codec_mask &= ~(1 << c);
@@ -1333 +1439 @@
                 if ((chip->codec_mask & (1 << c)) & chip->codec_probe_mask) {
                         struct hda_codec *codec;
-                        err = snd_hda_codec_new(chip->bus, c, !no_init, &codec);
+                        err = snd_hda_codec_new(chip->bus, c, &codec);
                         if (err < 0)
                                 continue;
@@ -1343 +1449 @@
                 return -ENXIO;
         }
-
+        return 0;
+}
+
+/* configure each codec instance */
+static int __devinit azx_codec_configure(struct azx *chip)
+{
+        struct hda_codec *codec;
+        list_for_each_entry(codec, &chip->bus->codec_list, list, struct hda_codec) {
+                snd_hda_codec_configure(codec);
+        }
         return 0;
 }
@@ -1441 +1556 @@
                 return err;
         }
+        snd_pcm_limit_hw_rates(runtime);
+        /* sanity check */
+        if (snd_BUG_ON(!runtime->hw.channels_min) ||
+            snd_BUG_ON(!runtime->hw.channels_max) ||
+            snd_BUG_ON(!runtime->hw.formats) ||
+            snd_BUG_ON(!runtime->hw.rates)) {
+                azx_release_device(azx_dev);
+                hinfo->ops.close(hinfo, apcm->codec, substream);
+                snd_hda_power_down(apcm->codec);
+                mutex_unlock(&chip->open_mutex);
+                return -EINVAL;
+        }
         spin_lock_irqsave(&chip->reg_lock, flags);
         azx_dev->substream = substream;
@@ -1449 +1576 @@
         snd_pcm_set_sync(substream);
         mutex_unlock(&chip->open_mutex);
-
         return 0;
 }
@@ -1529 +1655 @@
         period_bytes = snd_pcm_lib_period_bytes(substream);
 
-        snd_printdd("azx_pcm_prepare: bufsize=0x%x, format=0x%x\n",
+        snd_printdd(SFX "azx_pcm_prepare: bufsize=0x%x, format=0x%x\n",
                     bufsize, format_val);
 
@@ -1872 +1998 @@
         if (err < 0)
                 return err;
-        strcpy(pcm->name, cpcm->name);
+        strlcpy(pcm->name, cpcm->name, sizeof(pcm->name));
         apcm = kzalloc(sizeof(*apcm), GFP_KERNEL);
         if (apcm == NULL)
@@ -2017 +2143 @@
                 snd_pcm_suspend_all(chip->pcm[i]);
         if (chip->initialized)
-                snd_hda_suspend(chip->bus, state);
+                snd_hda_suspend(chip->bus);
         azx_stop_chip(chip);
         if (chip->irq >= 0) {
@@ -2188 +2314 @@
         SND_PCI_QUIRK(0x17c0, 0x4085, "Medion MD96630", 0x01),
         /* forced codec slots */
+        SND_PCI_QUIRK(0x1043, 0x1262, "ASUS W5Fm", 0x103),
         SND_PCI_QUIRK(0x1046, 0x1262, "ASUS W5F", 0x103),
         {0}
@@ -2219 +2346 @@
 }
 
+/*
+ * white-list for enable_msi
+ */
+static struct snd_pci_quirk msi_white_list[] __devinitdata = {
+        SND_PCI_QUIRK(0x103c, 0x3607, "HP Compa CQ40", 1),
+        {0}
+};
+
+static void __devinit check_msi(struct azx *chip)
+{
+        const struct snd_pci_quirk *q;
+
+        chip->msi = enable_msi;
+        if (chip->msi)
+                return;
+        q = snd_pci_quirk_lookup(chip->pci, msi_white_list);
+        if (q) {
+                printk(KERN_INFO
+                       "hda_intel: msi for device %04x:%04x set to %d\n",
+                       q->subvendor, q->subdevice, q->value);
+                chip->msi = q->value;
+        }
+}
+
 
 /*
@@ -2253 +2404 @@
         chip->irq = -1;
         chip->driver_type = driver_type;
-        chip->msi = enable_msi;
+        check_msi(chip);
         chip->dev_index = dev;
         INIT_WORK(&chip->irq_pending_work, azx_irq_pending_work);
@@ -2311 +2462 @@
 
         gcap = azx_readw(chip, GCAP);
-        snd_printdd("chipset global capabilities = 0x%x\n", gcap);
-
-        /* ATI chips seems buggy about 64bit DMA addresses */
-        if (chip->driver_type == AZX_DRIVER_ATI)
-                gcap &= ~0x01;
+        snd_printdd(SFX "chipset global capabilities = 0x%x\n", gcap);
+
+        /* disable SB600 64bit support for safety */
+        if ((chip->driver_type == AZX_DRIVER_ATI) ||
+            (chip->driver_type == AZX_DRIVER_ATIHDMI)) {
+                struct pci_dev *p_smbus;
+                p_smbus = pci_get_device(PCI_VENDOR_ID_ATI,
+                                         PCI_DEVICE_ID_ATI_SBX00_SMBUS,
+                                         NULL);
+                if (p_smbus) {
+                        if (snd_pci_revision(p_smbus) < 0x30)
+                                gcap &= ~ICH6_GCAP_64OK;
+                        pci_dev_put(p_smbus);
+                }
+        }
 
         /* allow 64bit DMA address if supported by H/W */
-        if ((gcap & 0x01) && !pci_set_dma_mask(pci, DMA_BIT_MASK(64)))
+        if ((gcap & ICH6_GCAP_64OK) && !pci_set_dma_mask(pci, DMA_BIT_MASK(64)))
                 pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(64));
         else {
@@ -2355 +2516 @@
                                 GFP_KERNEL);
         if (!chip->azx_dev) {
-                snd_printk(KERN_ERR "cannot malloc azx_dev\n");
+                snd_printk(KERN_ERR SFX "cannot malloc azx_dev\n");
                 goto errout;
         }
@@ -2378 +2539 @@
         }
         /* allocate CORB/RIRB */
-        if (!chip->single_cmd) {
-                err = azx_alloc_cmd_io(chip);
-                if (err < 0)
-                        goto errout;
-        }
+        err = azx_alloc_cmd_io(chip);
+        if (err < 0)
+                goto errout;
 
         /* initialize streams */
@@ -2405 +2564 @@
 
         strcpy(card->driver, "HDA-Intel");
-        strcpy(card->shortname, driver_short_names[chip->driver_type]);
-        sprintf(card->longname, "%s at 0x%lx irq %i",
-                card->shortname, chip->addr, chip->irq);
+        strlcpy(card->shortname, driver_short_names[chip->driver_type],
+                sizeof(card->shortname));
+        snprintf(card->longname, sizeof(card->longname),
+                 "%s at 0x%lx irq %i",
+                 card->shortname, chip->addr, chip->irq);
 
         *rchip = chip;
@@ -2451 +2612 @@
         }
 
+        /* set this here since it's referred in snd_hda_load_patch() */
+        snd_card_set_dev(card, &pci->dev);
+
         err = azx_create(card, pci, dev, pci_id->driver_data, &chip);
         if (err < 0)
@@ -2457 +2621 @@
 
         /* create codec instances */
-        err = azx_codec_create(chip, model[dev], probe_only[dev]);
+        err = azx_codec_create(chip, model[dev]);
         if (err < 0)
                 goto out_free;
+#ifdef CONFIG_SND_HDA_PATCH_LOADER
+        if (patch[dev]) {
+                snd_printk(KERN_ERR SFX "Applying patch firmware '%s'\n",
+                           patch[dev]);
+                err = snd_hda_load_patch(chip->bus, patch[dev]);
+                if (err < 0)
+                        goto out_free;
+        }
+#endif
+        if (!probe_only[dev]) {
+                err = azx_codec_configure(chip);
+                if (err < 0)
+                        goto out_free;
+        }
 
         /* create PCM streams */
@@ -2470 +2648 @@
         if (err < 0)
                 goto out_free;
-
-        snd_card_set_dev(card, &pci->dev);
 
         err = snd_card_register(card);
@@ -2560 +2736 @@
         /* Teradici */
         { PCI_DEVICE(0x6549, 0x1200), .driver_data = AZX_DRIVER_TERA },
-        /* AMD Generic, PCI class code and Vendor ID for HD Audio */
+        /* Creative X-Fi (CA0110-IBG) */
+#if !defined(CONFIG_SND_CTXFI) && !defined(CONFIG_SND_CTXFI_MODULE)
+        /* the following entry conflicts with snd-ctxfi driver,
+         * as ctxfi driver mutates from HD-audio to native mode with
+         * a special command sequence.
+         */
+        { PCI_DEVICE(PCI_VENDOR_ID_CREATIVE, PCI_ANY_ID),
+          .class = PCI_CLASS_MULTIMEDIA_HD_AUDIO << 8,
+          .class_mask = 0xffffff,
+          .driver_data = AZX_DRIVER_GENERIC },
+#else
+        /* this entry seems still valid -- i.e. without emu20kx chip */
+        { PCI_DEVICE(0x1102, 0x0009), .driver_data = AZX_DRIVER_GENERIC },
+#endif
+        /* AMD/ATI Generic, PCI class code and Vendor ID for HD Audio */
         { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_ANY_ID),
+          .class = PCI_CLASS_MULTIMEDIA_HD_AUDIO << 8,
+          .class_mask = 0xffffff,
+          .driver_data = AZX_DRIVER_GENERIC },
+        { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_ANY_ID),
           .class = PCI_CLASS_MULTIMEDIA_HD_AUDIO << 8,
           .class_mask = 0xffffff,

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

@@ -100 +100 @@
                         unsigned int *tlv, const char **slaves);
 int snd_hda_codec_reset(struct hda_codec *codec);
-int snd_hda_codec_configure(struct hda_codec *codec);
 
 /* amp value bits */
@@ -409 +408 @@
 }
 
+/* get the widget type from widget capability bits */
+#define get_wcaps_type(wcaps) (((wcaps) & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT)
+
+static inline unsigned int get_wcaps_channels(u32 wcaps)
+{
+        unsigned int chans;
+
+        chans = (wcaps & AC_WCAP_CHAN_CNT_EXT) >> 13;
+        chans = ((chans << 1) | 1) + 1;
+
+        return chans;
+}
+
 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction);
 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,

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

@@ -467 +467 @@
         int i, nodes;
 
-        snd_iprintf(buffer, "Codec: %s\n",
-                    codec->name ? codec->name : "Not Set");
+        snd_iprintf(buffer, "Codec: ");
+        if (codec->vendor_name && codec->chip_name)
+                snd_iprintf(buffer, "%s %s\n",
+                            codec->vendor_name, codec->chip_name);
+        else
+                snd_iprintf(buffer, "Not Set\n");
         snd_iprintf(buffer, "Address: %d\n", codec->addr);
         snd_iprintf(buffer, "Function Id: 0x%x\n", codec->function_id);
@@ -505 +509 @@
                         snd_hda_param_read(codec, nid,
                                            AC_PAR_AUDIO_WIDGET_CAP);
-                unsigned int wid_type =
-                        (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
+                unsigned int wid_type = get_wcaps_type(wid_caps);
                 hda_nid_t conn[HDA_MAX_CONNECTIONS];
                 int conn_len = 0;
@@ -513 +516 @@
                             get_wid_type_name(wid_type), wid_caps);
                 if (wid_caps & AC_WCAP_STEREO) {
-                        unsigned int chans;
-                        chans = (wid_caps & AC_WCAP_CHAN_CNT_EXT) >> 13;
-                        chans = ((chans << 1) | 1) + 1;
+                        unsigned int chans = get_wcaps_channels(wid_caps);
                         if (chans == 2)
                                 snd_iprintf(buffer, " Stereo");

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

@@ -73 +73 @@
 
         unsigned int jack_present :1;
+        unsigned int inv_jack_detect:1;
 
 #ifdef CONFIG_SND_HDA_POWER_SAVE
@@ -670 +671 @@
 };
 
-static struct snd_kcontrol_new ad1986a_laptop_eapd_mixers[] = {
+static struct snd_kcontrol_new ad1986a_laptop_master_mixers[] = {
         HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol),
         HDA_BIND_SW("Master Playback Switch", &ad1986a_laptop_master_sw),
-        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, 0, HDA_OUTPUT),
-        HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x17, 0, 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("Mic Boost", 0x0f, 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 */
-};
-
-static struct snd_kcontrol_new ad1986a_samsung_mixers[] = {
-        HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol),
-        HDA_BIND_SW("Master Playback Switch", &ad1986a_laptop_master_sw),
+        {0} /* end */
+};
+
+static struct snd_kcontrol_new ad1986a_laptop_eapd_mixers[] = {
         HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT),
         HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT),
@@ -728 +703 @@
 };
 
+static struct snd_kcontrol_new ad1986a_laptop_intmic_mixers[] = {
+        HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x17, 0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x17, 0, HDA_OUTPUT),
+        {0} /* end */
+};
+
 /* re-connect the mic boost input according to the jack sensing */
 static void ad1986a_automic(struct hda_codec *codec)
@@ -777 +758 @@
 
         present = snd_hda_codec_read(codec, 0x1a, 0, AC_VERB_GET_PIN_SENSE, 0);
-        /* Lenovo N100 seems to report the reversed bit for HP jack-sensing */
-        spec->jack_present = !(present & 0x80000000);
+        spec->jack_present = !!(present & 0x80000000);
+        if (spec->inv_jack_detect)
+                spec->jack_present = !spec->jack_present;
         ad1986a_update_hp(codec);
 }
@@ -817 +799 @@
 }
 
-static struct snd_kcontrol_new ad1986a_laptop_automute_mixers[] = {
+static struct snd_kcontrol_new ad1986a_automute_master_mixers[] = {
         HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol),
         {
@@ -827 +809 @@
                 .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("Mic Boost", 0x0f, 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 */
-};
+        {0} /* end */
+};
+
 
 /*
@@ -982 +941 @@
 };
 
+static void ad1986a_samsung_p50_unsol_event(struct hda_codec *codec,
+                                            unsigned int res)
+{
+        switch (res >> 26) {
+        case AD1986A_HP_EVENT:
+                ad1986a_hp_automute(codec);
+                break;
+        case AD1986A_MIC_EVENT:
+                ad1986a_automic(codec);
+                break;
+        }
+}
+
+static int ad1986a_samsung_p50_init(struct hda_codec *codec)
+{
+        ad198x_init(codec);
+        ad1986a_hp_automute(codec);
+        ad1986a_automic(codec);
+        return 0;
+}
+
 
 /* models */
@@ -992 +972 @@
         AD1986A_ULTRA,
         AD1986A_SAMSUNG,
+        AD1986A_SAMSUNG_P50,
         AD1986A_MODELS
 };
@@ -1003 +984 @@
         [AD1986A_ULTRA]         = "ultra",
         [AD1986A_SAMSUNG]       = "samsung",
+        [AD1986A_SAMSUNG_P50]   = "samsung-p50",
 };
 
@@ -1025 +1007 @@
         SND_PCI_QUIRK(0x144d, 0xb03c, "Samsung R55", AD1986A_3STACK),
         SND_PCI_QUIRK(0x144d, 0xc01e, "FSC V2060", AD1986A_LAPTOP),
+        SND_PCI_QUIRK(0x144d, 0xc024, "Samsung P50", AD1986A_SAMSUNG_P50),
         SND_PCI_QUIRK(0x144d, 0xc027, "Samsung Q1", AD1986A_ULTRA),
         SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc000, "Samsung", AD1986A_SAMSUNG),
@@ -1112 +1095 @@
                 break;
         case AD1986A_LAPTOP_EAPD:
-                spec->mixers[0] = ad1986a_laptop_eapd_mixers;
+                spec->num_mixers = 3;
+                spec->mixers[0] = ad1986a_laptop_master_mixers;
+                spec->mixers[1] = ad1986a_laptop_eapd_mixers;
+                spec->mixers[2] = ad1986a_laptop_intmic_mixers;
                 spec->num_init_verbs = 2;
                 spec->init_verbs[1] = ad1986a_eapd_init_verbs;
@@ -1123 +1109 @@
                 break;
         case AD1986A_SAMSUNG:
-                spec->mixers[0] = ad1986a_samsung_mixers;
+                spec->num_mixers = 2;
+                spec->mixers[0] = ad1986a_laptop_master_mixers;
+                spec->mixers[1] = ad1986a_laptop_eapd_mixers;
                 spec->num_init_verbs = 3;
                 spec->init_verbs[1] = ad1986a_eapd_init_verbs;
@@ -1136 +1124 @@
                 codec->patch_ops.init = ad1986a_automic_init;
                 break;
+        case AD1986A_SAMSUNG_P50:
+                spec->num_mixers = 2;
+                spec->mixers[0] = ad1986a_automute_master_mixers;
+                spec->mixers[1] = ad1986a_laptop_eapd_mixers;
+                spec->num_init_verbs = 4;
+                spec->init_verbs[1] = ad1986a_eapd_init_verbs;
+                spec->init_verbs[2] = ad1986a_automic_verbs;
+                spec->init_verbs[3] = ad1986a_hp_init_verbs;
+                spec->multiout.max_channels = 2;
+                spec->multiout.num_dacs = 1;
+                spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
+                if (!is_jack_available(codec, 0x25))
+                        spec->multiout.dig_out_nid = 0;
+                spec->input_mux = &ad1986a_automic_capture_source;
+                codec->patch_ops.unsol_event = ad1986a_samsung_p50_unsol_event;
+                codec->patch_ops.init = ad1986a_samsung_p50_init;
+                break;
         case AD1986A_LAPTOP_AUTOMUTE:
-                spec->mixers[0] = ad1986a_laptop_automute_mixers;
+                spec->num_mixers = 3;
+                spec->mixers[0] = ad1986a_automute_master_mixers;
+                spec->mixers[1] = ad1986a_laptop_eapd_mixers;
+                spec->mixers[2] = ad1986a_laptop_intmic_mixers;
                 spec->num_init_verbs = 3;
                 spec->init_verbs[1] = ad1986a_eapd_init_verbs;
@@ -1149 +1157 @@
                 codec->patch_ops.unsol_event = ad1986a_hp_unsol_event;
                 codec->patch_ops.init = ad1986a_hp_init;
+                /* Lenovo N100 seems to report the reversed bit
+                 * for HP jack-sensing
+                 */
+                spec->inv_jack_detect = 1;
                 break;
         case AD1986A_ULTRA:
@@ -2971 +2983 @@
                                                   ad1988_models, ad1988_cfg_tbl);
         if (board_config < 0) {
-                printk(KERN_INFO "hda_codec: Unknown model for AD1988, trying auto-probe from BIOS...\n");
+                printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
+                       codec->chip_name);
                 board_config = AD1988_AUTO;
         }
@@ -3735 +3748 @@
 };
 
+static int ad1884a_mobile_master_sw_put(struct snd_kcontrol *kcontrol,
+                                        struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        int ret = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
+        int mute = (!ucontrol->value.integer.value[0] &&
+                    !ucontrol->value.integer.value[1]);
+        /* toggle GPIO1 according to the mute state */
+        snd_hda_codec_write_cache(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
+                            mute ? 0x02 : 0x0);
+        return ret;
+}
+
 static struct snd_kcontrol_new ad1884a_mobile_mixers[] = {
         HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
-        HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),
+        /*HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, 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 = ad1884a_mobile_master_sw_put,
+                .private_value = HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
+        },
         HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
         HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
@@ -3803 +3837 @@
         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-        /* Port-F pin */
-        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        /* Port-F (int speaker) pin */
+        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        /* required for compaq 6530s/6531s speaker output */
+        {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
         /* Port-C pin - internal mic-in */
         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
@@ -3858 +3894 @@
         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT},
         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_MIC_EVENT},
+        /* allow to touch GPIO1 (for mute control) */
+        {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
+        {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
+        {0x01, AC_VERB_SET_GPIO_DATA, 0x02}, /* first muted */
         {0} /* end */
 };
@@ -3967 +4007 @@
         SND_PCI_QUIRK(0x103c, 0x3056, "HP", AD1884A_MOBILE),
         SND_PCI_QUIRK_MASK(0x103c, 0xfff0, 0x3070, "HP", AD1884A_MOBILE),
+        SND_PCI_QUIRK_MASK(0x103c, 0xfff0, 0x30d0, "HP laptop", AD1884A_LAPTOP),
         SND_PCI_QUIRK_MASK(0x103c, 0xfff0, 0x30e0, "HP laptop", AD1884A_LAPTOP),
         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3600, "HP laptop", AD1884A_LAPTOP),
+        SND_PCI_QUIRK_MASK(0x103c, 0xfff0, 0x7010, "HP laptop", AD1884A_MOBILE),
         SND_PCI_QUIRK(0x17aa, 0x20ac, "Thinkpad X300", AD1884A_THINKPAD),
         {0}

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

@@ -142 +142 @@
          */
         chans = get_wcaps(codec, CVT_NID);
-        chans = (chans & AC_WCAP_CHAN_CNT_EXT) >> 13;
-        chans = ((chans << 1) | 1) + 1;
+        chans = get_wcaps_channels(chans);
         info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = chans;
 

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

@@ -636 +636 @@
                                                         cmi9880_cfg_tbl);
         if (spec->board_config < 0) {
-                snd_printdd(KERN_INFO "hda_codec: Unknown model for CMI9880\n");
+                snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
+                            codec->chip_name);
                 spec->board_config = CMI_AUTO; /* try everything */
         }

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

@@ -109 +109 @@
         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 
+        unsigned int dell_automute;
+        unsigned int port_d_mode;
 };
 
@@ -350 +352 @@
 }
 
-#ifdef CONFIG_SND_JACK
+#ifdef CONFIG_SND_HDA_INPUT_JACK
 static void conexant_free_jack_priv(struct snd_jack *jack)
 {
@@ -464 +466 @@
 static void conexant_free(struct hda_codec *codec)
 {
-#ifdef CONFIG_SND_JACK
+#ifdef CONFIG_SND_HDA_INPUT_JACK
         struct conexant_spec *spec = codec->spec;
         if (spec->jacks.list) {
@@ -1849 +1851 @@
 static struct snd_pci_quirk cxt5051_cfg_tbl[] = {
         SND_PCI_QUIRK(0x103c, 0x30cf, "HP DV6736", CXT5051_HP_DV6736),
+        SND_PCI_QUIRK(0x103c, 0x360b, "Compaq Presario CQ60", CXT5051_HP),
         SND_PCI_QUIRK(0x14f1, 0x0101, "Conexant Reference board",
                       CXT5051_LAPTOP),
@@ -1908 +1911 @@
 }
 
+/* Conexant 5066 specific */
+
+static hda_nid_t cxt5066_dac_nids[1] = { 0x10 };
+static hda_nid_t cxt5066_adc_nids[3] = { 0x14, 0x15, 0x16 };
+static hda_nid_t cxt5066_capsrc_nids[1] = { 0x17 };
+#define CXT5066_SPDIF_OUT       0x21
+
+static struct hda_channel_mode cxt5066_modes[1] = {
+        { 2, NULL },
+};
+
+static void cxt5066_update_speaker(struct hda_codec *codec)
+{
+        struct conexant_spec *spec = codec->spec;
+        unsigned int pinctl;
+
+        snd_printdd("CXT5066: update speaker, hp_present=%d\n",
+                spec->hp_present);
+
+        /* Port A (HP) */
+        pinctl = ((spec->hp_present & 1) && spec->cur_eapd) ? PIN_HP : 0;
+        snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
+                        pinctl);
+
+        /* Port D (HP/LO) */
+        pinctl = ((spec->hp_present & 2) && spec->cur_eapd)
+                ? spec->port_d_mode : 0;
+        snd_hda_codec_write(codec, 0x1c, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
+                        pinctl);
+
+        /* CLASS_D AMP */
+        pinctl = (!spec->hp_present && spec->cur_eapd) ? PIN_OUT : 0;
+        snd_hda_codec_write(codec, 0x1f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
+                        pinctl);
+
+        if (spec->dell_automute) {
+                /* DELL AIO Port Rule: PortA > PortD > IntSpk */
+                pinctl = (!(spec->hp_present & 1) && spec->cur_eapd)
+                        ? PIN_OUT : 0;
+                snd_hda_codec_write(codec, 0x1c, 0,
+                        AC_VERB_SET_PIN_WIDGET_CONTROL, pinctl);
+        }
+}
+
+/* turn on/off EAPD (+ mute HP) as a master switch */
+static int cxt5066_hp_master_sw_put(struct snd_kcontrol *kcontrol,
+                                    struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+
+        if (!cxt_eapd_put(kcontrol, ucontrol))
+                return 0;
+
+        cxt5066_update_speaker(codec);
+        return 1;
+}
+
+/* toggle input of built-in and mic jack appropriately */
+static void cxt5066_automic(struct hda_codec *codec)
+{
+        static struct hda_verb ext_mic_present[] = {
+                /* enable external mic, port B */
+                {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+
+                /* switch to external mic input */
+                {0x17, AC_VERB_SET_CONNECT_SEL, 0},
+
+                /* disable internal mic, port C */
+                {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
+                {0}
+        };
+        static struct hda_verb ext_mic_absent[] = {
+                /* enable internal mic, port C */
+                {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+
+                /* switch to internal mic input */
+                {0x17, AC_VERB_SET_CONNECT_SEL, 1},
+
+                /* disable external mic, port B */
+                {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
+                {0}
+        };
+        unsigned int present;
+
+        present = snd_hda_codec_read(codec, 0x1a, 0,
+                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
+        if (present) {
+                snd_printdd("CXT5066: external microphone detected\n");
+                snd_hda_sequence_write(codec, ext_mic_present);
+        } else {
+                snd_printdd("CXT5066: external microphone absent\n");
+                snd_hda_sequence_write(codec, ext_mic_absent);
+        }
+}
+
+/* mute internal speaker if HP is plugged */
+static void cxt5066_hp_automute(struct hda_codec *codec)
+{
+        struct conexant_spec *spec = codec->spec;
+        unsigned int portA, portD;
+
+        /* Port A */
+        portA = snd_hda_codec_read(codec, 0x19, 0, AC_VERB_GET_PIN_SENSE, 0)
+                & AC_PINSENSE_PRESENCE;
+
+        /* Port D */
+        portD = (snd_hda_codec_read(codec, 0x1c, 0, AC_VERB_GET_PIN_SENSE, 0)
+                & AC_PINSENSE_PRESENCE) << 1;
+
+        spec->hp_present = !!(portA | portD);
+        snd_printdd("CXT5066: hp automute portA=%x portD=%x present=%d\n",
+                portA, portD, spec->hp_present);
+        cxt5066_update_speaker(codec);
+}
+
+/* unsolicited event for jack sensing */
+static void cxt5066_unsol_event(struct hda_codec *codec, unsigned int res)
+{
+        snd_printdd("CXT5066: unsol event %x (%x)\n", res, res >> 26);
+        switch (res >> 26) {
+        case CONEXANT_HP_EVENT:
+                cxt5066_hp_automute(codec);
+                break;
+        case CONEXANT_MIC_EVENT:
+                cxt5066_automic(codec);
+                break;
+        }
+}
+
+static const struct hda_input_mux cxt5066_analog_mic_boost = {
+        .num_items = 5,
+        .items = {
+                { "0dB",  0 },
+                { "10dB", 1 },
+                { "20dB", 2 },
+                { "30dB", 3 },
+                { "40dB", 4 },
+        },
+};
+
+static int cxt5066_mic_boost_mux_enum_info(struct snd_kcontrol *kcontrol,
+                                           struct snd_ctl_elem_info *uinfo)
+{
+        return snd_hda_input_mux_info(&cxt5066_analog_mic_boost, uinfo);
+}
+
+static int cxt5066_mic_boost_mux_enum_get(struct snd_kcontrol *kcontrol,
+                                          struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        int val;
+
+        val = snd_hda_codec_read(codec, 0x17, 0,
+                AC_VERB_GET_AMP_GAIN_MUTE, AC_AMP_GET_OUTPUT);
+
+        ucontrol->value.enumerated.item[0] = val & AC_AMP_GAIN;
+        return 0;
+}
+
+static int cxt5066_mic_boost_mux_enum_put(struct snd_kcontrol *kcontrol,
+                                          struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        const struct hda_input_mux *imux = &cxt5066_analog_mic_boost;
+        unsigned int idx;
+
+        if (!imux->num_items)
+                return 0;
+        idx = ucontrol->value.enumerated.item[0];
+        if (idx >= imux->num_items)
+                idx = imux->num_items - 1;
+
+        snd_hda_codec_write_cache(codec, 0x17, 0,
+                AC_VERB_SET_AMP_GAIN_MUTE,
+                AC_AMP_SET_RIGHT | AC_AMP_SET_LEFT | AC_AMP_SET_OUTPUT |
+                        imux->items[idx].index);
+
+        return 1;
+}
+
+static struct hda_input_mux cxt5066_capture_source = {
+        .num_items = 4,
+        .items = {
+                { "Mic B", 0 },
+                { "Mic C", 1 },
+                { "Mic E", 2 },
+                { "Mic F", 3 },
+        },
+};
+
+static struct hda_bind_ctls cxt5066_bind_capture_vol_others = {
+        .ops = &snd_hda_bind_vol,
+        .values = {
+                HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_INPUT),
+                HDA_COMPOSE_AMP_VAL(0x14, 3, 2, HDA_INPUT),
+                0
+        },
+};
+
+static struct hda_bind_ctls cxt5066_bind_capture_sw_others = {
+        .ops = &snd_hda_bind_sw,
+        .values = {
+                HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_INPUT),
+                HDA_COMPOSE_AMP_VAL(0x14, 3, 2, HDA_INPUT),
+                0
+        },
+};
+
+static struct snd_kcontrol_new cxt5066_mixer_master[] = {
+        HDA_CODEC_VOLUME("Master Playback Volume", 0x10, 0x00, HDA_OUTPUT),
+        {0}
+};
+
+static struct snd_kcontrol_new cxt5066_mixer_master_olpc[] = {
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Master Playback Volume",
+                .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 },
+                /* offset by 28 volume steps to limit minimum gain to -46dB */
+                .private_value =
+                        HDA_COMPOSE_AMP_VAL_OFS(0x10, 3, 0, HDA_OUTPUT, 28),
+        },
+        {0}
+};
+
+static struct snd_kcontrol_new cxt5066_mixers[] = {
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Master Playback Switch",
+                .info = cxt_eapd_info,
+                .get = cxt_eapd_get,
+                .put = cxt5066_hp_master_sw_put,
+                .private_value = 0x1d,
+        },
+
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Analog Mic Boost Capture Enum",
+                .info = cxt5066_mic_boost_mux_enum_info,
+                .get = cxt5066_mic_boost_mux_enum_get,
+                .put = cxt5066_mic_boost_mux_enum_put,
+        },
+
+        HDA_BIND_VOL("Capture Volume", &cxt5066_bind_capture_vol_others),
+        HDA_BIND_SW("Capture Switch", &cxt5066_bind_capture_sw_others),
+        {0}
+};
+
+static struct hda_verb cxt5066_init_verbs[] = {
+        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, /* Port B */
+        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, /* Port C */
+        {0x1e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* Port F */
+        {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* Port E */
+
+        /* Speakers  */
+        {0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x1f, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC1 */
+
+        /* HP, Amp  */
+        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x19, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC1 */
+
+        {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x1c, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC1 */
+
+        /* DAC1 */
+        {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+
+        /* Node 14 connections: 0x17 0x18 0x23 0x24 0x27 */
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x50},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2) | 0x50},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
+
+        /* no digital microphone support yet */
+        {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
+
+        /* Audio input selector */
+        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x3},
+
+        /* SPDIF route: PCM */
+        {0x20, AC_VERB_SET_CONNECT_SEL, 0x0},
+        {0x22, AC_VERB_SET_CONNECT_SEL, 0x0},
+
+        {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x22, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+
+        /* EAPD */
+        {0x1d, AC_VERB_SET_EAPD_BTLENABLE, 0x2}, /* default on */
+
+        /* not handling these yet */
+        {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, 0},
+        {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, 0},
+        {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, 0},
+        {0x1c, AC_VERB_SET_UNSOLICITED_ENABLE, 0},
+        {0x1d, AC_VERB_SET_UNSOLICITED_ENABLE, 0},
+        {0x1e, AC_VERB_SET_UNSOLICITED_ENABLE, 0},
+        {0x20, AC_VERB_SET_UNSOLICITED_ENABLE, 0},
+        {0x22, AC_VERB_SET_UNSOLICITED_ENABLE, 0},
+        {0} /* end */
+};
+
+static struct hda_verb cxt5066_init_verbs_olpc[] = {
+        /* Port A: headphones */
+        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x19, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC1 */
+
+        /* Port B: external microphone */
+        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+
+        /* Port C: internal microphone */
+        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+
+        /* Port D: unused */
+        {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
+
+        /* Port E: unused, but has primary EAPD */
+        {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
+        {0x1d, AC_VERB_SET_EAPD_BTLENABLE, 0x2}, /* default on */
+
+        /* Port F: unused */
+        {0x1e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
+
+        /* Port G: internal speakers */
+        {0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x1f, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC1 */
+
+        /* DAC1 */
+        {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+
+        /* DAC2: unused */
+        {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x50},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
+        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
+        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
+
+        /* Disable digital microphone port */
+        {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
+
+        /* Audio input selectors */
+        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x3},
+        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
+
+        /* Disable SPDIF */
+        {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
+        {0x22, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
+
+        /* enable unsolicited events for Port A and B */
+        {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_HP_EVENT},
+        {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_MIC_EVENT},
+        {0} /* end */
+};
+
+static struct hda_verb cxt5066_init_verbs_portd_lo[] = {
+        {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0} /* end */
+};
+
+/* initialize jack-sensing, too */
+static int cxt5066_init(struct hda_codec *codec)
+{
+        snd_printdd("CXT5066: init\n");
+        conexant_init(codec);
+        if (codec->patch_ops.unsol_event) {
+                cxt5066_hp_automute(codec);
+                cxt5066_automic(codec);
+        }
+        return 0;
+}
+
+enum {
+        CXT5066_LAPTOP,                 /* Laptops w/ EAPD support */
+        CXT5066_DELL_LAPTOP,    /* Dell Laptop */
+        CXT5066_OLPC_XO_1_5,    /* OLPC XO 1.5 */
+        CXT5066_MODELS
+};
+
+static const char *cxt5066_models[CXT5066_MODELS] = {
+        [CXT5066_LAPTOP]                = "laptop",
+        [CXT5066_DELL_LAPTOP]   = "dell-laptop",
+        [CXT5066_OLPC_XO_1_5]   = "olpc-xo-1_5",
+};
+
+static struct snd_pci_quirk cxt5066_cfg_tbl[] = {
+        SND_PCI_QUIRK(0x14f1, 0x0101, "Conexant Reference board",
+                      CXT5066_LAPTOP),
+        SND_PCI_QUIRK(0x1028, 0x02f5, "Dell",
+                      CXT5066_DELL_LAPTOP),
+        {0}
+};
+
+static int patch_cxt5066(struct hda_codec *codec)
+{
+        struct conexant_spec *spec;
+        int board_config;
+
+        spec = kzalloc(sizeof(*spec), GFP_KERNEL);
+        if (!spec)
+                return -ENOMEM;
+        codec->spec = spec;
+
+        codec->patch_ops = conexant_patch_ops;
+        codec->patch_ops.init = cxt5066_init;
+
+        spec->dell_automute = 0;
+        spec->multiout.max_channels = 2;
+        spec->multiout.num_dacs = ARRAY_SIZE(cxt5066_dac_nids);
+        spec->multiout.dac_nids = cxt5066_dac_nids;
+        spec->multiout.dig_out_nid = CXT5066_SPDIF_OUT;
+        spec->num_adc_nids = 1;
+        spec->adc_nids = cxt5066_adc_nids;
+        spec->capsrc_nids = cxt5066_capsrc_nids;
+        spec->input_mux = &cxt5066_capture_source;
+
+        spec->port_d_mode = PIN_HP;
+
+        spec->num_init_verbs = 1;
+        spec->init_verbs[0] = cxt5066_init_verbs;
+        spec->num_channel_mode = ARRAY_SIZE(cxt5066_modes);
+        spec->channel_mode = cxt5066_modes;
+        spec->cur_adc = 0;
+        spec->cur_adc_idx = 0;
+
+        board_config = snd_hda_check_board_config(codec, CXT5066_MODELS,
+                                                  cxt5066_models, cxt5066_cfg_tbl);
+        switch (board_config) {
+        default:
+        case CXT5066_LAPTOP:
+                spec->mixers[spec->num_mixers++] = cxt5066_mixer_master;
+                spec->mixers[spec->num_mixers++] = cxt5066_mixers;
+                break;
+        case CXT5066_DELL_LAPTOP:
+                spec->mixers[spec->num_mixers++] = cxt5066_mixer_master;
+                spec->mixers[spec->num_mixers++] = cxt5066_mixers;
+
+                spec->port_d_mode = PIN_OUT;
+                spec->init_verbs[spec->num_init_verbs] = cxt5066_init_verbs_portd_lo;
+                spec->num_init_verbs++;
+                spec->dell_automute = 1;
+                break;
+        case CXT5066_OLPC_XO_1_5:
+                codec->patch_ops.unsol_event = cxt5066_unsol_event;
+                spec->init_verbs[0] = cxt5066_init_verbs_olpc;
+                spec->mixers[spec->num_mixers++] = cxt5066_mixer_master_olpc;
+                spec->mixers[spec->num_mixers++] = cxt5066_mixers;
+                spec->port_d_mode = 0;
+
+                /* no S/PDIF out */
+                spec->multiout.dig_out_nid = 0;
+
+                /* input source automatically selected */
+                spec->input_mux = NULL;
+                break;
+        }
+
+        return 0;
+}
 
 /*
@@ -1919 +2396 @@
         { .id = 0x14f15051, .name = "CX20561 (Hermosa)",
           .patch = patch_cxt5051 },
+        { .id = 0x14f15066, .name = "CX20582 (Pebble)",
+          .patch = patch_cxt5066 },
         {0} /* terminator */
 };
@@ -1925 +2404 @@
 MODULE_ALIAS("snd-hda-codec-id:14f15047");
 MODULE_ALIAS("snd-hda-codec-id:14f15051");
+MODULE_ALIAS("snd-hda-codec-id:14f15066");
 
 MODULE_LICENSE("GPL");

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

@@ -191 +191 @@
         ALC272_DELL,
         ALC272_DELL_ZM1,
+        ALC272_SAMSUNG_NC10,
         ALC662_AUTO,
         ALC662_MODEL_LAST,
@@ -206 +207 @@
         ALC885_MACPRO,
         ALC885_MBP3,
+        ALC885_MB5,
         ALC885_IMAC24,
-        ALC882_AUTO,
-        ALC882_MODEL_LAST,
-};
-
-/* ALC883 models */
-enum {
         ALC883_3ST_2ch_DIG,
         ALC883_3ST_6ch_DIG,
@@ -219 +215 @@
         ALC883_TARGA_DIG,
         ALC883_TARGA_2ch_DIG,
+        ALC883_TARGA_8ch_DIG,
         ALC883_ACER,
         ALC883_ACER_ASPIRE,
         ALC888_ACER_ASPIRE_4930G,
+        ALC888_ACER_ASPIRE_6530G,
+        ALC888_ACER_ASPIRE_8930G,
+        ALC888_ACER_ASPIRE_7730G,
         ALC883_MEDION,
         ALC883_MEDION_MD2,
@@ -237 +237 @@
         ALC888_FUJITSU_XA3530,
         ALC883_3ST_6ch_INTEL,
+        ALC889A_INTEL,
+        ALC889_INTEL,
         ALC888_ASUS_M90V,
         ALC888_ASUS_EEE1601,
+        ALC889A_MB31,
         ALC1200_ASUS_P5Q,
-        ALC883_AUTO,
-        ALC883_MODEL_LAST,
-};
-
-/* styles of capture selection */
-enum {
-        CAPT_MUX = 0,   /* only mux based */
-        CAPT_MIX,       /* only mixer based */
-        CAPT_1MUX_MIX,  /* first mux and other mixers */
+        ALC883_SONY_VAIO_TT,
+        ALC882_AUTO,
+        ALC882_MODEL_LAST,
 };
 
 /* for GPIO Poll */
 #define GPIO_MASK       0x03
+
+/* extra amp-initialization sequence types */
+enum {
+        ALC_INIT_NONE,
+        ALC_INIT_DEFAULT,
+        ALC_INIT_GPIO1,
+        ALC_INIT_GPIO2,
+        ALC_INIT_GPIO3,
+};
+
+struct alc_mic_route {
+        hda_nid_t pin;
+        unsigned char mux_idx;
+        unsigned char amix_idx;
+};
+
+#define MUX_IDX_UNDEF   ((unsigned char)-1)
 
 struct alc_spec {
@@ -267 +281 @@
         unsigned int num_init_verbs;
 
-        char *stream_name_analog;       /* analog PCM stream */
+        char stream_name_analog[32];    /* analog PCM stream */
         struct hda_pcm_stream *stream_analog_playback;
         struct hda_pcm_stream *stream_analog_capture;
@@ -273 +287 @@
         struct hda_pcm_stream *stream_analog_alt_capture;
 
-        char *stream_name_digital;      /* digital PCM stream */
+        char stream_name_digital[32];   /* digital PCM stream */
         struct hda_pcm_stream *stream_digital_playback;
         struct hda_pcm_stream *stream_digital_capture;
@@ -291 +305 @@
         hda_nid_t *capsrc_nids;
         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
-        int capture_style;              /* capture style (CAPT_*) */
 
         /* capture source */
@@ -297 +310 @@
         const struct hda_input_mux *input_mux;
         unsigned int cur_mux[3];
+        struct alc_mic_route ext_mic;
+        struct alc_mic_route int_mic;
 
         /* channel model */
@@ -302 +317 @@
         int num_channel_mode;
         int need_dac_fix;
+        int const_channel_count;
+        int ext_channel_count;
 
         /* PCM information */
@@ -311 +328 @@
         struct hda_input_mux private_imux[3];
         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
+        hda_nid_t private_adc_nids[AUTO_CFG_MAX_OUTS];
+        hda_nid_t private_capsrc_nids[AUTO_CFG_MAX_OUTS];
 
         /* hooks */
@@ -320 +339 @@
         unsigned int jack_present: 1;
         unsigned int master_sw: 1;
+        unsigned int auto_mic:1;
 
         /* other flags */
         unsigned int no_analog :1; /* digital I/O only */
+        int init_amp;
 
         /* for virtual master */
@@ -356 +377 @@
         const struct hda_channel_mode *channel_mode;
         int need_dac_fix;
+        int const_channel_count;
         unsigned int num_mux_defs;
         const struct hda_input_mux *input_mux;
         void (*unsol_event)(struct hda_codec *, unsigned int);
+        void (*setup)(struct hda_codec *);
         void (*init_hook)(struct hda_codec *);
 #ifdef CONFIG_SND_HDA_POWER_SAVE
@@ -401 +424 @@
         hda_nid_t nid = spec->capsrc_nids ?
                 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
+        unsigned int type;
 
         mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
         imux = &spec->input_mux[mux_idx];
 
-        if (spec->capture_style &&
-            !(spec->capture_style == CAPT_1MUX_MIX && !adc_idx)) {
+        type = get_wcaps_type(get_wcaps(codec, nid));
+        if (type == AC_WID_AUD_MIX) {
                 /* Matrix-mixer style (e.g. ALC882) */
                 unsigned int *cur_val = &spec->cur_mux[adc_idx];
@@ -450 +474 @@
         return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
                                    spec->num_channel_mode,
-                                   spec->multiout.max_channels);
+                                   spec->ext_channel_count);
 }
 
@@ -460 +484 @@
         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;
+                                      &spec->ext_channel_count);
+        if (err >= 0 && !spec->const_channel_count) {
+                spec->multiout.max_channels = spec->ext_channel_count;
+                if (spec->need_dac_fix)
+                        spec->multiout.num_dacs = spec->multiout.max_channels / 2;
+        }
         return err;
 }
@@ -544 +571 @@
         /* 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))
+        while (i <= alc_pin_mode_max(dir) && alc_pin_mode_values[i] != pinctl)
                 i++;
         *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
@@ -777 +804 @@
                 if (pincap & AC_PINCAP_VREF_80)
                         val = PIN_VREF80;
+                else if (pincap & AC_PINCAP_VREF_50)
+                        val = PIN_VREF50;
+                else if (pincap & AC_PINCAP_VREF_100)
+                        val = PIN_VREF100;
+                else if (pincap & AC_PINCAP_VREF_GRD)
+                        val = PIN_VREFGRD;
         }
         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
@@ -821 +854 @@
  * set up from the preset table
  */
-static void setup_preset(struct alc_spec *spec,
+static void setup_preset(struct hda_codec *codec,
                          const struct alc_config_preset *preset)
 {
+        struct alc_spec *spec = codec->spec;
         int i;
 
@@ -836 +870 @@
         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->const_channel_count = preset->const_channel_count;
+
+        if (preset->const_channel_count)
+                spec->multiout.max_channels = preset->const_channel_count;
+        else
+                spec->multiout.max_channels = spec->channel_mode[0].channels;
+        spec->ext_channel_count = spec->channel_mode[0].channels;
 
         spec->multiout.num_dacs = preset->num_dacs;
@@ -860 +899 @@
         spec->loopback.amplist = preset->loopbacks;
 #endif
+
+        if (preset->setup)
+                preset->setup(codec);
 }
 
@@ -916 +958 @@
 }
 
-static void alc_sku_automute(struct hda_codec *codec)
+static void alc_automute_pin(struct hda_codec *codec)
 {
         struct alc_spec *spec = codec->spec;
-        unsigned int present;
-        unsigned int hp_nid = spec->autocfg.hp_pins[0];
-        unsigned int sp_nid = spec->autocfg.speaker_pins[0];
-
-        /* need to execute and sync at first */
-        snd_hda_codec_read(codec, hp_nid, 0, AC_VERB_SET_PIN_SENSE, 0);
-        present = snd_hda_codec_read(codec, hp_nid, 0,
+        unsigned int present, pincap;
+        unsigned int nid = spec->autocfg.hp_pins[0];
+        int i;
+
+        pincap = snd_hda_query_pin_caps(codec, nid);
+        if (pincap & AC_PINCAP_TRIG_REQ) /* need trigger? */
+                snd_hda_codec_read(codec, nid, 0, AC_VERB_SET_PIN_SENSE, 0);
+        present = snd_hda_codec_read(codec, nid, 0,
                                      AC_VERB_GET_PIN_SENSE, 0);
-        spec->jack_present = (present & 0x80000000) != 0;
-        snd_hda_codec_write(codec, sp_nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
-                            spec->jack_present ? 0 : PIN_OUT);
-}
-
-#if 0 /* it's broken in some acses -- temporarily disabled */
+        spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
+        for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
+                nid = spec->autocfg.speaker_pins[i];
+                if (!nid)
+                        break;
+                snd_hda_codec_write(codec, nid, 0,
+                                    AC_VERB_SET_PIN_WIDGET_CONTROL,
+                                    spec->jack_present ? 0 : PIN_OUT);
+        }
+}
+
+static int get_connection_index(struct hda_codec *codec, hda_nid_t mux,
+                                hda_nid_t nid)
+{
+        hda_nid_t conn[HDA_MAX_NUM_INPUTS];
+        int i, nums;
+
+        nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
+        for (i = 0; i < nums; i++)
+                if (conn[i] == nid)
+                        return i;
+        return -1;
+}
+
 static void alc_mic_automute(struct hda_codec *codec)
 {
         struct alc_spec *spec = codec->spec;
-        unsigned int present;
-        unsigned int mic_nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
-        unsigned int fmic_nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
-        unsigned int mix_nid = spec->capsrc_nids[0];
-        unsigned int capsrc_idx_mic, capsrc_idx_fmic;
-
-        capsrc_idx_mic = mic_nid - 0x18;
-        capsrc_idx_fmic = fmic_nid - 0x18;
-        present = snd_hda_codec_read(codec, mic_nid, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-        snd_hda_codec_write(codec, mix_nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
-                    0x7000 | (capsrc_idx_mic << 8) | (present ? 0 : 0x80));
-        snd_hda_codec_write(codec, mix_nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
-                    0x7000 | (capsrc_idx_fmic << 8) | (present ? 0x80 : 0));
-        snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, capsrc_idx_fmic,
-                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
-}
-#else
-#define alc_mic_automute(codec) do {} while(0) /* NOP */
-#endif /* disabled */
+        struct alc_mic_route *dead, *alive;
+        unsigned int present, type;
+        hda_nid_t cap_nid;
+
+        if (!spec->auto_mic)
+                return;
+        if (!spec->int_mic.pin || !spec->ext_mic.pin)
+                return;
+        if (snd_BUG_ON(!spec->adc_nids))
+                return;
+
+        cap_nid = spec->capsrc_nids ? spec->capsrc_nids[0] : spec->adc_nids[0];
+
+        present = snd_hda_codec_read(codec, spec->ext_mic.pin, 0,
+                                     AC_VERB_GET_PIN_SENSE, 0);
+        present &= AC_PINSENSE_PRESENCE;
+        if (present) {
+                alive = &spec->ext_mic;
+                dead = &spec->int_mic;
+        } else {
+                alive = &spec->int_mic;
+                dead = &spec->ext_mic;
+        }
+
+        type = get_wcaps_type(get_wcaps(codec, cap_nid));
+        if (type == AC_WID_AUD_MIX) {
+                /* Matrix-mixer style (e.g. ALC882) */
+                snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
+                                         alive->mux_idx,
+                                         HDA_AMP_MUTE, 0);
+                snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
+                                         dead->mux_idx,
+                                         HDA_AMP_MUTE, HDA_AMP_MUTE);
+        } else {
+                /* MUX style (e.g. ALC880) */
+                snd_hda_codec_write_cache(codec, cap_nid, 0,
+                                          AC_VERB_SET_CONNECT_SEL,
+                                          alive->mux_idx);
+        }
+
+        /* FIXME: analog mixer */
+}
 
 /* unsolicited event for HP jack sensing */
@@ -964 +1047 @@
         else
                 res >>= 26;
-        if (res == ALC880_HP_EVENT)
-                alc_sku_automute(codec);
-
-        if (res == ALC880_MIC_EVENT)
+        switch (res) {
+        case ALC880_HP_EVENT:
+                alc_automute_pin(codec);
+                break;
+        case ALC880_MIC_EVENT:
                 alc_mic_automute(codec);
+                break;
+        }
 }
 
 static void alc_inithook(struct hda_codec *codec)
 {
-        alc_sku_automute(codec);
+        alc_automute_pin(codec);
         alc_mic_automute(codec);
 }
@@ -995 +1081 @@
 }
 
-/* 32-bit subsystem ID for BIOS loading in HD Audio codec.
- *      31 ~ 16 :       Manufacture ID
- *      15 ~ 8  :       SKU ID
- *      7  ~ 0  :       Assembly ID
- *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
- */
-static void alc_subsystem_id(struct hda_codec *codec,
-                             unsigned int porta, unsigned int porte,
-                             unsigned int portd)
-{
-        unsigned int ass, tmp, i;
-        unsigned nid;
-        struct alc_spec *spec = codec->spec;
-
-        ass = codec->subsystem_id & 0xffff;
-        if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
-                goto do_sku;
-
-        /*
-         * 31~30        : port conetcivity
-         * 29~21        : reserve
-         * 20           : PCBEEP input
-         * 19~16        : Check sum (15:1)
-         * 15~1         : Custom
-         * 0            : override
-        */
-        nid = 0x1d;
-        if (codec->vendor_id == 0x10ec0260)
-                nid = 0x17;
-        ass = snd_hda_codec_get_pincfg(codec, nid);
-        if (!(ass & 1) && !(ass & 0x100000))
-                return;
-        if ((ass >> 30) != 1)   /* no physical connection */
-                return;
-
-        /* check sum */
-        tmp = 0;
-        for (i = 1; i < 16; i++) {
-                if ((ass >> i) & 1)
-                        tmp++;
-        }
-        if (((ass >> 16) & 0xf) != tmp)
-                return;
-do_sku:
-        /*
-         * 0 : override
-         * 1 :  Swap Jack
-         * 2 : 0 --> Desktop, 1 --> Laptop
-         * 3~5 : External Amplifier control
-         * 7~6 : Reserved
-        */
-        tmp = (ass & 0x38) >> 3;        /* external Amp control */
-        switch (tmp) {
-        case 1:
+static void alc889_coef_init(struct hda_codec *codec)
+{
+        unsigned int tmp;
+
+        snd_hda_codec_write(codec, 0x20, 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, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
+        snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
+}
+
+static void alc_auto_init_amp(struct hda_codec *codec, int type)
+{
+        unsigned int tmp;
+
+        switch (type) {
+        case ALC_INIT_GPIO1:
                 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
                 break;
-        case 3:
+        case ALC_INIT_GPIO2:
                 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
                 break;
-        case 7:
+        case ALC_INIT_GPIO3:
                 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
                 break;
-        case 5: /* set EAPD output high */
+        case ALC_INIT_DEFAULT:
                 switch (codec->vendor_id) {
                 case 0x10ec0260:
@@ -1100 +1148 @@
                 case 0x10ec0887:
                 case 0x10ec0889:
-                        snd_hda_codec_write(codec, 0x20, 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, 0x20, 0,
-                                            AC_VERB_SET_COEF_INDEX, 7);
-                        snd_hda_codec_write(codec, 0x20, 0,
-                                            AC_VERB_SET_PROC_COEF,
-                                            tmp | 0x2010);
+                        alc889_coef_init(codec);
                         break;
                 case 0x10ec0888:
-                        /*alc888_coef_init(codec);*/ /* called in alc_init() */
+                        alc888_coef_init(codec);
                         break;
                 case 0x10ec0267:
@@ -1126 +1166 @@
                         break;
                 }
-        default:
+                break;
+        }
+}
+
+static void alc_init_auto_hp(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        if (!spec->autocfg.hp_pins[0])
+                return;
+
+        if (!spec->autocfg.speaker_pins[0]) {
+                if (spec->autocfg.line_out_pins[0] &&
+                    spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
+                        spec->autocfg.speaker_pins[0] =
+                                spec->autocfg.line_out_pins[0];
+                else
+                        return;
+        }
+
+        snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
+                    spec->autocfg.hp_pins[0]);
+        snd_hda_codec_write_cache(codec, spec->autocfg.hp_pins[0], 0,
+                                  AC_VERB_SET_UNSOLICITED_ENABLE,
+                                  AC_USRSP_EN | ALC880_HP_EVENT);
+        spec->unsol_event = alc_sku_unsol_event;
+}
+
+static void alc_init_auto_mic(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+        struct auto_pin_cfg *cfg = &spec->autocfg;
+        hda_nid_t fixed, ext;
+        int i;
+
+        /* there must be only two mic inputs exclusively */
+        for (i = AUTO_PIN_LINE; i < AUTO_PIN_LAST; i++)
+                if (cfg->input_pins[i])
+                        return;
+
+        fixed = ext = 0;
+        for (i = AUTO_PIN_MIC; i <= AUTO_PIN_FRONT_MIC; i++) {
+                hda_nid_t nid = cfg->input_pins[i];
+                unsigned int defcfg;
+                if (!nid)
+                        return;
+                defcfg = snd_hda_codec_get_pincfg(codec, nid);
+                switch (get_defcfg_connect(defcfg)) {
+                case AC_JACK_PORT_FIXED:
+                        if (fixed)
+                                return; /* already occupied */
+                        fixed = nid;
+                        break;
+                case AC_JACK_PORT_COMPLEX:
+                        if (ext)
+                                return; /* already occupied */
+                        ext = nid;
+                        break;
+                default:
+                        return; /* invalid entry */
+                }
+        }
+        if (!(get_wcaps(codec, ext) & AC_WCAP_UNSOL_CAP))
+                return; /* no unsol support */
+        snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x\n",
+                    ext, fixed);
+        spec->ext_mic.pin = ext;
+        spec->int_mic.pin = fixed;
+        spec->ext_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
+        spec->int_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
+        spec->auto_mic = 1;
+        snd_hda_codec_write_cache(codec, spec->ext_mic.pin, 0,
+                                  AC_VERB_SET_UNSOLICITED_ENABLE,
+                                  AC_USRSP_EN | ALC880_MIC_EVENT);
+        spec->unsol_event = alc_sku_unsol_event;
+}
+
+/* check subsystem ID and set up device-specific initialization;
+ * return 1 if initialized, 0 if invalid SSID
+ */
+/* 32-bit subsystem ID for BIOS loading in HD Audio codec.
+ *      31 ~ 16 :       Manufacture ID
+ *      15 ~ 8  :       SKU ID
+ *      7  ~ 0  :       Assembly ID
+ *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
+ */
+static int alc_subsystem_id(struct hda_codec *codec,
+                            hda_nid_t porta, hda_nid_t porte,
+                            hda_nid_t portd)
+{
+        unsigned int ass, tmp, i;
+        unsigned nid;
+        struct alc_spec *spec = codec->spec;
+
+        ass = codec->subsystem_id & 0xffff;
+        if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
+                goto do_sku;
+
+        /* invalid SSID, check the special NID pin defcfg instead */
+        /*
+         * 31~30        : port connectivity
+         * 29~21        : reserve
+         * 20           : PCBEEP input
+         * 19~16        : Check sum (15:1)
+         * 15~1         : Custom
+         * 0            : override
+        */
+        nid = 0x1d;
+        if (codec->vendor_id == 0x10ec0260)
+                nid = 0x17;
+        ass = snd_hda_codec_get_pincfg(codec, nid);
+        snd_printd("realtek: No valid SSID, "
+                   "checking pincfg 0x%08x for NID 0x%x\n",
+                   ass, nid);
+        if (!(ass & 1) && !(ass & 0x100000))
+                return 0;
+        if ((ass >> 30) != 1)   /* no physical connection */
+                return 0;
+
+        /* check sum */
+        tmp = 0;
+        for (i = 1; i < 16; i++) {
+                if ((ass >> i) & 1)
+                        tmp++;
+        }
+        if (((ass >> 16) & 0xf) != tmp)
+                return 0;
+do_sku:
+        snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
+                   ass & 0xffff, codec->vendor_id);
+        /*
+         * 0 : override
+         * 1 :  Swap Jack
+         * 2 : 0 --> Desktop, 1 --> Laptop
+         * 3~5 : External Amplifier control
+         * 7~6 : Reserved
+        */
+        tmp = (ass & 0x38) >> 3;        /* external Amp control */
+        switch (tmp) {
+        case 1:
+                spec->init_amp = ALC_INIT_GPIO1;
+                break;
+        case 3:
+                spec->init_amp = ALC_INIT_GPIO2;
+                break;
+        case 7:
+                spec->init_amp = ALC_INIT_GPIO3;
+                break;
+        case 5:
+                spec->init_amp = ALC_INIT_DEFAULT;
                 break;
         }
@@ -1134 +1323 @@
          */
         if (!(ass & 0x8000))
-                return;
+                return 1;
         /*
          * 10~8 : Jack location
@@ -1142 +1331 @@
          *              when the external headphone out jack is plugged"
          */
-        if (!spec->autocfg.speaker_pins[0]) {
-                if (spec->autocfg.line_out_pins[0])
-                        spec->autocfg.speaker_pins[0] =
-                                spec->autocfg.line_out_pins[0];
-                else
-                        return;
-        }
-
         if (!spec->autocfg.hp_pins[0]) {
                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
@@ -1159 +1340 @@
                         spec->autocfg.hp_pins[0] = portd;
                 else
-                        return;
+                        return 1;
         }
-        if (spec->autocfg.hp_pins[0])
-                snd_hda_codec_write(codec, spec->autocfg.hp_pins[0], 0,
-                        AC_VERB_SET_UNSOLICITED_ENABLE,
-                        AC_USRSP_EN | ALC880_HP_EVENT);
-
-#if 0 /* it's broken in some acses -- temporarily disabled */
-        if (spec->autocfg.input_pins[AUTO_PIN_MIC] &&
-                spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC])
-                snd_hda_codec_write(codec,
-                        spec->autocfg.input_pins[AUTO_PIN_MIC], 0,
-                        AC_VERB_SET_UNSOLICITED_ENABLE,
-                        AC_USRSP_EN | ALC880_MIC_EVENT);
-#endif /* disabled */
-
-        spec->unsol_event = alc_sku_unsol_event;
+
+        alc_init_auto_hp(codec);
+        alc_init_auto_mic(codec);
+        return 1;
+}
+
+static void alc_ssid_check(struct hda_codec *codec,
+                           hda_nid_t porta, hda_nid_t porte, hda_nid_t portd)
+{
+        if (!alc_subsystem_id(codec, porta, porte, portd)) {
+                struct alc_spec *spec = codec->spec;
+                snd_printd("realtek: "
+                           "Enable default setup for auto mode as fallback\n");
+                spec->init_amp = ALC_INIT_DEFAULT;
+                alc_init_auto_hp(codec);
+                alc_init_auto_mic(codec);
+        }
 }
 
@@ -1310 +1493 @@
 };
 
-static void alc888_fujitsu_xa3530_automute(struct hda_codec *codec)
-{
-        unsigned int present;
-        unsigned int bits;
-        /* Line out presence */
-        present = snd_hda_codec_read(codec, 0x17, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-        /* HP out presence */
-        present = present || snd_hda_codec_read(codec, 0x1b, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-        bits = present ? HDA_AMP_MUTE : 0;
+static void alc_automute_amp(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+        unsigned int val, mute, pincap;
+        hda_nid_t nid;
+        int i;
+
+        spec->jack_present = 0;
+        for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) {
+                nid = spec->autocfg.hp_pins[i];
+                if (!nid)
+                        break;
+                pincap = snd_hda_query_pin_caps(codec, nid);
+                if (pincap & AC_PINCAP_TRIG_REQ) /* need trigger? */
+                        snd_hda_codec_read(codec, nid, 0,
+                                           AC_VERB_SET_PIN_SENSE, 0);
+                val = snd_hda_codec_read(codec, nid, 0,
+                                         AC_VERB_GET_PIN_SENSE, 0);
+                if (val & AC_PINSENSE_PRESENCE) {
+                        spec->jack_present = 1;
+                        break;
+                }
+        }
+
+        mute = spec->jack_present ? HDA_AMP_MUTE : 0;
         /* Toggle internal speakers muting */
-        snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
-                                 HDA_AMP_MUTE, bits);
-        /* Toggle internal bass muting */
-        snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
-                                 HDA_AMP_MUTE, bits);
-}
-
-static void alc888_fujitsu_xa3530_unsol_event(struct hda_codec *codec,
-                unsigned int res)
-{
-        if (res >> 26 == ALC880_HP_EVENT)
-                alc888_fujitsu_xa3530_automute(codec);
-}
-
+        for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
+                nid = spec->autocfg.speaker_pins[i];
+                if (!nid)
+                        break;
+                snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
+                                         HDA_AMP_MUTE, mute);
+        }
+}
+
+static void alc_automute_amp_unsol_event(struct hda_codec *codec,
+                                         unsigned int res)
+{
+        if (codec->vendor_id == 0x10ec0880)
+                res >>= 28;
+        else
+                res >>= 26;
+        if (res == ALC880_HP_EVENT)
+                alc_automute_amp(codec);
+}
+
+static void alc889_automute_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        spec->autocfg.hp_pins[0] = 0x15;
+        spec->autocfg.speaker_pins[0] = 0x14;
+        spec->autocfg.speaker_pins[1] = 0x16;
+        spec->autocfg.speaker_pins[2] = 0x17;
+        spec->autocfg.speaker_pins[3] = 0x19;
+        spec->autocfg.speaker_pins[4] = 0x1a;
+}
+
+static void alc889_intel_init_hook(struct hda_codec *codec)
+{
+        alc889_coef_init(codec);
+        alc_automute_amp(codec);
+}
+
+static void alc888_fujitsu_xa3530_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        spec->autocfg.hp_pins[0] = 0x17; /* line-out */
+        spec->autocfg.hp_pins[1] = 0x1b; /* hp */
+        spec->autocfg.speaker_pins[0] = 0x14; /* speaker */
+        spec->autocfg.speaker_pins[1] = 0x15; /* bass */
+}
 
 /*
@@ -1359 +1589 @@
 };
 
+/*
+ * ALC888 Acer Aspire 6530G model
+ */
+
+static struct hda_verb alc888_acer_aspire_6530g_verbs[] = {
+/* Bias voltage on for external mic port */
+        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN | PIN_VREF80},
+/* Front Mic: set to PIN_IN (empty by default) */
+        {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+/* Unselect Front Mic by default in input mixer 3 */
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
+/* Enable unsolicited event for HP jack */
+        {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
+/* Enable speaker output */
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+/* Enable headphone output */
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0}
+};
+
+/*
+ * ALC889 Acer Aspire 8930G model
+ */
+
+static struct hda_verb alc889_acer_aspire_8930g_verbs[] = {
+/* Front Mic: set to PIN_IN (empty by default) */
+        {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+/* Unselect Front Mic by default in input mixer 3 */
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
+/* Enable unsolicited event for HP jack */
+        {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
+/* Connect Internal Front to Front */
+        {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},
+/* Connect Internal Rear to Rear */
+        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
+/* Connect Internal CLFE to CLFE */
+        {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},
+/* Connect HP out to Front */
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
+/* Enable all DACs */
+/*  DAC DISABLE/MUTE 1? */
+/*  setting bits 1-5 disables DAC nids 0x02-0x06 apparently. Init=0x38 */
+        {0x20, AC_VERB_SET_COEF_INDEX, 0x03},
+        {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
+/*  DAC DISABLE/MUTE 2? */
+/*  some bit here disables the other DACs. Init=0x4900 */
+        {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
+        {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
+/* Enable amplifiers */
+        {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
+        {0x15, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
+/* DMIC fix
+ * This laptop has a stereo digital microphone. The mics are only 1cm apart
+ * which makes the stereo useless. However, either the mic or the ALC889
+ * makes the signal become a difference/sum signal instead of standard
+ * stereo, which is annoying. So instead we flip this bit which makes the
+ * codec replicate the sum signal to both channels, turning it into a
+ * normal mono mic.
+ */
+/*  DMIC_CONTROL? Init value = 0x0001 */
+        {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
+        {0x20, AC_VERB_SET_PROC_COEF, 0x0003},
+        {0}
+};
+
 static struct hda_input_mux alc888_2_capture_sources[2] = {
         /* Front mic only available on one ADC */
@@ -1376 +1682 @@
                         { "Line", 0x2 },
                         { "CD", 0x4 },
+                },
+        }
+};
+
+static struct hda_input_mux alc888_acer_aspire_6530_sources[2] = {
+        /* Interal mic only available on one ADC */
+        {
+                .num_items = 5,
+                .items = {
+                        { "Ext Mic", 0x0 },
+                        { "Line In", 0x2 },
+                        { "CD", 0x4 },
+                        { "Input Mix", 0xa },
+                        { "Int Mic", 0xb },
+                },
+        },
+        {
+                .num_items = 4,
+                .items = {
+                        { "Ext Mic", 0x0 },
+                        { "Line In", 0x2 },
+                        { "CD", 0x4 },
+                        { "Input Mix", 0xa },
+                },
+        }
+};
+
+static struct hda_input_mux alc889_capture_sources[3] = {
+        /* Digital mic only available on first "ADC" */
+        {
+                .num_items = 5,
+                .items = {
+                        { "Mic", 0x0 },
+                        { "Line", 0x2 },
+                        { "CD", 0x4 },
+                        { "Front Mic", 0xb },
+                        { "Input Mix", 0xa },
+                },
+        },
+        {
+                .num_items = 4,
+                .items = {
+                        { "Mic", 0x0 },
+                        { "Line", 0x2 },
+                        { "CD", 0x4 },
+                        { "Input Mix", 0xa },
+                },
+        },
+        {
+                .num_items = 4,
+                .items = {
+                        { "Mic", 0x0 },
+                        { "Line", 0x2 },
+                        { "CD", 0x4 },
+                        { "Input Mix", 0xa },
                 },
         }
@@ -1402 +1763 @@
 };
 
-static void alc888_acer_aspire_4930g_automute(struct hda_codec *codec)
-{
-        unsigned int present;
-        unsigned int bits;
-        present = snd_hda_codec_read(codec, 0x15, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-        bits = present ? HDA_AMP_MUTE : 0;
-        snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
-                                 HDA_AMP_MUTE, bits);
-}
-
-static void alc888_acer_aspire_4930g_unsol_event(struct hda_codec *codec,
-                unsigned int res)
-{
-        if (res >> 26 == ALC880_HP_EVENT)
-                alc888_acer_aspire_4930g_automute(codec);
+static void alc888_acer_aspire_4930g_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        spec->autocfg.hp_pins[0] = 0x15;
+        spec->autocfg.speaker_pins[0] = 0x14;
+}
+
+static void alc888_acer_aspire_6530g_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        spec->autocfg.hp_pins[0] = 0x15;
+        spec->autocfg.speaker_pins[0] = 0x14;
+        spec->autocfg.speaker_pins[1] = 0x16;
+        spec->autocfg.speaker_pins[2] = 0x17;
+}
+
+static void alc889_acer_aspire_8930g_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        spec->autocfg.hp_pins[0] = 0x15;
+        spec->autocfg.speaker_pins[0] = 0x14;
+        spec->autocfg.speaker_pins[1] = 0x16;
+        spec->autocfg.speaker_pins[2] = 0x1b;
 }
 
@@ -2385 +2756 @@
 };
 
-/* toggle speaker-output according to the hp-jack state */
-static void alc880_uniwill_hp_automute(struct hda_codec *codec)
-{
-        unsigned int present;
-        unsigned char bits;
-
-        present = snd_hda_codec_read(codec, 0x14, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-        bits = present ? HDA_AMP_MUTE : 0;
-        snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
-                                 HDA_AMP_MUTE, bits);
-        snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
-                                 HDA_AMP_MUTE, bits);
-}
-
 /* auto-toggle front mic */
 static void alc880_uniwill_mic_automute(struct hda_codec *codec)
@@ -2412 +2768 @@
 }
 
-static void alc880_uniwill_automute(struct hda_codec *codec)
-{
-        alc880_uniwill_hp_automute(codec);
+static void alc880_uniwill_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        spec->autocfg.hp_pins[0] = 0x14;
+        spec->autocfg.speaker_pins[0] = 0x15;
+        spec->autocfg.speaker_pins[0] = 0x16;
+}
+
+static void alc880_uniwill_init_hook(struct hda_codec *codec)
+{
+        alc_automute_amp(codec);
         alc880_uniwill_mic_automute(codec);
 }
@@ -2425 +2790 @@
          */
         switch (res >> 28) {
-        case ALC880_HP_EVENT:
-                alc880_uniwill_hp_automute(codec);
-                break;
         case ALC880_MIC_EVENT:
                 alc880_uniwill_mic_automute(codec);
                 break;
+        default:
+                alc_automute_amp_unsol_event(codec, res);
+                break;
         }
 }
 
-static void alc880_uniwill_p53_hp_automute(struct hda_codec *codec)
-{
-        unsigned int present;
-        unsigned char bits;
-
-        present = snd_hda_codec_read(codec, 0x14, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-        bits = present ? HDA_AMP_MUTE : 0;
-        snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, HDA_AMP_MUTE, bits);
+static void alc880_uniwill_p53_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        spec->autocfg.hp_pins[0] = 0x14;
+        spec->autocfg.speaker_pins[0] = 0x15;
 }
 
@@ -2464 +2826 @@
          * 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);
+        else
+                alc_automute_amp_unsol_event(codec, res);
 }
 
@@ -2537 +2899 @@
 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
+#define alc880_gpio3_init_verbs alc_gpio3_init_verbs
 
 /* Clevo m520g init */
@@ -2699 +3062 @@
         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
         /* jack sense */
-        {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
+        {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
         {0}
 };
 
 /* toggle speaker-output according to the hp-jack state */
-static void alc880_lg_automute(struct hda_codec *codec)
-{
-        unsigned int present;
-        unsigned char bits;
-
-        present = snd_hda_codec_read(codec, 0x1b, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-        bits = present ? HDA_AMP_MUTE : 0;
-        snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
-                                 HDA_AMP_MUTE, bits);
-}
-
-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);
+static void alc880_lg_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        spec->autocfg.hp_pins[0] = 0x1b;
+        spec->autocfg.speaker_pins[0] = 0x17;
 }
 
@@ -2796 +3146 @@
         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
         /* jack sense */
-        {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
+        {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
         {0}
 };
 
 /* toggle speaker-output according to the hp-jack state */
-static void alc880_lg_lw_automute(struct hda_codec *codec)
-{
-        unsigned int present;
-        unsigned char bits;
-
-        present = snd_hda_codec_read(codec, 0x1b, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-        bits = present ? HDA_AMP_MUTE : 0;
-        snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
-                                 HDA_AMP_MUTE, bits);
-}
-
-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);
+static void alc880_lg_lw_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        spec->autocfg.hp_pins[0] = 0x1b;
+        spec->autocfg.speaker_pins[0] = 0x14;
 }
 
@@ -2866 +3203 @@
 static void alc880_medion_rim_automute(struct hda_codec *codec)
 {
-        unsigned int present;
-        unsigned char bits;
-
-        present = snd_hda_codec_read(codec, 0x14, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0)
-                & AC_PINSENSE_PRESENCE;
-        bits = present ? HDA_AMP_MUTE : 0;
-        snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
-                                 HDA_AMP_MUTE, bits);
-        if (present)
+        struct alc_spec *spec = codec->spec;
+        alc_automute_amp(codec);
+        /* toggle EAPD */
+        if (spec->jack_present)
                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
         else
@@ -2889 +3220 @@
         if ((res >> 28) == ALC880_HP_EVENT)
                 alc880_medion_rim_automute(codec);
+}
+
+static void alc880_medion_rim_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        spec->autocfg.hp_pins[0] = 0x14;
+        spec->autocfg.speaker_pins[0] = 0x1b;
 }
 
@@ -2919 +3258 @@
 
         alc_fix_pll(codec);
-        if (codec->vendor_id == 0x10ec0888)
-                alc888_coef_init(codec);
+        alc_auto_init_amp(codec, spec->init_amp);
 
         for (i = 0; i < spec->num_init_verbs; i++)
@@ -3122 +3460 @@
                 goto skip_analog;
 
+        snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
+                 "%s Analog", codec->chip_name);
         info->name = spec->stream_name_analog;
+        
         if (spec->stream_analog_playback) {
                 if (snd_BUG_ON(!spec->multiout.dac_nids))
@@ -3148 +3489 @@
         /* SPDIF for stream index #1 */
         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
+                snprintf(spec->stream_name_digital,
+                         sizeof(spec->stream_name_digital),
+                         "%s Digital", codec->chip_name);
                 codec->num_pcms = 2;
                 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
@@ -3750 +4094 @@
                 .input_mux = &alc880_f1734_capture_source,
                 .unsol_event = alc880_uniwill_p53_unsol_event,
-                .init_hook = alc880_uniwill_p53_hp_automute,
+                .setup = alc880_uniwill_p53_setup,
+                .init_hook = alc_automute_amp,
         },
         [ALC880_ASUS] = {
@@ -3827 +4172 @@
                 .input_mux = &alc880_capture_source,
                 .unsol_event = alc880_uniwill_unsol_event,
-                .init_hook = alc880_uniwill_automute,
+                .setup = alc880_uniwill_setup,
+                .init_hook = alc880_uniwill_init_hook,
         },
         [ALC880_UNIWILL_P53] = {
@@ -3839 +4185 @@
                 .input_mux = &alc880_capture_source,
                 .unsol_event = alc880_uniwill_p53_unsol_event,
-                .init_hook = alc880_uniwill_p53_hp_automute,
+                .setup = alc880_uniwill_p53_setup,
+                .init_hook = alc_automute_amp,
         },
         [ALC880_FUJITSU] = {
@@ -3853 +4200 @@
                 .input_mux = &alc880_capture_source,
                 .unsol_event = alc880_uniwill_p53_unsol_event,
-                .init_hook = alc880_uniwill_p53_hp_automute,
+                .setup = alc880_uniwill_p53_setup,
+                .init_hook = alc_automute_amp,
         },
         [ALC880_CLEVO] = {
@@ -3878 +4226 @@
                 .need_dac_fix = 1,
                 .input_mux = &alc880_lg_capture_source,
-                .unsol_event = alc880_lg_unsol_event,
-                .init_hook = alc880_lg_automute,
+                .unsol_event = alc_automute_amp_unsol_event,
+                .setup = alc880_lg_setup,
+                .init_hook = alc_automute_amp,
 #ifdef CONFIG_SND_HDA_POWER_SAVE
                 .loopbacks = alc880_lg_loopbacks,
@@ -3894 +4243 @@
                 .channel_mode = alc880_lg_lw_modes,
                 .input_mux = &alc880_lg_lw_capture_source,
-                .unsol_event = alc880_lg_lw_unsol_event,
-                .init_hook = alc880_lg_lw_automute,
+                .unsol_event = alc_automute_amp_unsol_event,
+                .setup = alc880_lg_lw_setup,
+                .init_hook = alc_automute_amp,
         },
         [ALC880_MEDION_RIM] = {
@@ -3909 +4259 @@
                 .input_mux = &alc880_medion_rim_capture_source,
                 .unsol_event = alc880_medion_rim_unsol_event,
+                .setup = alc880_medion_rim_setup,
                 .init_hook = alc880_medion_rim_automute,
         },
@@ -3962 +4313 @@
 #define alc880_is_multi_pin(nid)        ((nid) >= 0x18)
 #define alc880_multi_pin_idx(nid)       ((nid) - 0x18)
-#define alc880_is_input_pin(nid)        ((nid) >= 0x18)
-#define alc880_input_pin_idx(nid)       ((nid) - 0x18)
 #define alc880_idx_to_dac(nid)          ((nid) + 0x02)
 #define alc880_dac_to_idx(nid)          ((nid) - 0x02)
@@ -4051 +4400 @@
                                 return err;
                 } else {
-                        sprintf(name, "%s Playback Volume", chname[i]);
+                        const char *pfx;
+                        if (cfg->line_outs == 1 &&
+                            cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
+                                pfx = "Speaker";
+                        else
+                                pfx = chname[i];
+                        sprintf(name, "%s Playback Volume", pfx);
                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
@@ -4057 +4412 @@
                         if (err < 0)
                                 return err;
-                        sprintf(name, "%s Playback Switch", chname[i]);
+                        sprintf(name, "%s Playback Switch", pfx);
                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2,
@@ -4131 +4486 @@
 }
 
+static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
+{
+        unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
+        return (pincap & AC_PINCAP_IN) != 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)
-{
+static int alc_auto_create_input_ctls(struct hda_codec *codec,
+                                      const struct auto_pin_cfg *cfg,
+                                      hda_nid_t mixer,
+                                      hda_nid_t cap1, hda_nid_t cap2)
+{
+        struct alc_spec *spec = codec->spec;
         struct hda_input_mux *imux = &spec->private_imux[0];
         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;
+                hda_nid_t pin;
+
+                pin = cfg->input_pins[i];
+                if (!alc_is_input_pin(codec, pin))
+                        continue;
+
+                if (mixer) {
+                        idx = get_connection_index(codec, mixer, pin);
+                        if (idx >= 0) {
+                                err = new_analog_input(spec, pin,
+                                                       auto_pin_cfg_labels[i],
+                                                       idx, mixer);
+                                if (err < 0)
+                                        return err;
+                        }
+                }
+
+                if (!cap1)
+                        continue;
+                idx = get_connection_index(codec, cap1, pin);
+                if (idx < 0 && cap2)
+                        idx = get_connection_index(codec, cap2, pin);
+                if (idx >= 0) {
                         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->items[imux->num_items].index = idx;
                         imux->num_items++;
                 }
         }
         return 0;
+}
+
+static int alc880_auto_create_input_ctls(struct hda_codec *codec,
+                                                const struct auto_pin_cfg *cfg)
+{
+        return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x08, 0x09);
 }
 
@@ -4194 +4579 @@
         int i;
 
-        alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
         for (i = 0; i < spec->autocfg.line_outs; i++) {
                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
@@ -4222 +4606 @@
         for (i = 0; i < AUTO_PIN_LAST; i++) {
                 hda_nid_t nid = spec->autocfg.input_pins[i];
-                if (alc880_is_input_pin(nid)) {
+                if (alc_is_input_pin(codec, nid)) {
                         alc_set_input_pin(codec, nid, i);
                         if (nid != ALC880_PIN_CD_NID &&
@@ -4265 +4649 @@
         if (err < 0)
                 return err;
-        err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
+        err = alc880_auto_create_input_ctls(codec, &spec->autocfg);
         if (err < 0)
                 return err;
@@ -4299 +4683 @@
         spec->input_mux = &spec->private_imux[0];
 
+        alc_ssid_check(codec, 0x15, 0x1b, 0x14);
+
         return 1;
 }
@@ -4313 +4699 @@
 }
 
-static void set_capture_mixer(struct alc_spec *spec)
-{
+/* check the ADC/MUX contains all input pins; some ADC/MUX contains only
+ * one of two digital mic pins, e.g. on ALC272
+ */
+static void fixup_automic_adc(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+        int i;
+
+        for (i = 0; i < spec->num_adc_nids; i++) {
+                hda_nid_t cap = spec->capsrc_nids ?
+                        spec->capsrc_nids[i] : spec->adc_nids[i];
+                int iidx, eidx;
+
+                iidx = get_connection_index(codec, cap, spec->int_mic.pin);
+                if (iidx < 0)
+                        continue;
+                eidx = get_connection_index(codec, cap, spec->ext_mic.pin);
+                if (eidx < 0)
+                        continue;
+                spec->int_mic.mux_idx = iidx;
+                spec->ext_mic.mux_idx = eidx;
+                if (spec->capsrc_nids)
+                        spec->capsrc_nids += i;
+                spec->adc_nids += i;
+                spec->num_adc_nids = 1;
+                return;
+        }
+        snd_printd(KERN_INFO "hda_codec: %s: "
+                   "No ADC/MUX containing both 0x%x and 0x%x pins\n",
+                   codec->chip_name, spec->int_mic.pin, spec->ext_mic.pin);
+        spec->auto_mic = 0; /* disable auto-mic to be sure */
+}
+
+static void set_capture_mixer(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
         static struct snd_kcontrol_new *caps[2][3] = {
                 { alc_capture_mixer_nosrc1,
@@ -4325 +4745 @@
         if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) {
                 int mux;
-                if (spec->input_mux && spec->input_mux->num_items > 1)
+                if (spec->auto_mic) {
+                        mux = 0;
+                        fixup_automic_adc(codec);
+                } else if (spec->input_mux && spec->input_mux->num_items > 1)
                         mux = 1;
                 else
@@ -4356 +4779 @@
                                                   alc880_cfg_tbl);
         if (board_config < 0) {
-                printk(KERN_INFO "hda_codec: Unknown model for ALC880, "
-                       "trying auto-probe from BIOS...\n");
+                printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
+                       codec->chip_name);
                 board_config = ALC880_AUTO;
         }
@@ -4382 +4805 @@
 
         if (board_config != ALC880_AUTO)
-                setup_preset(spec, &alc880_presets[board_config]);
-
-        spec->stream_name_analog = "ALC880 Analog";
+                setup_preset(codec, &alc880_presets[board_config]);
+
         spec->stream_analog_playback = &alc880_pcm_analog_playback;
         spec->stream_analog_capture = &alc880_pcm_analog_capture;
         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
 
-        spec->stream_name_digital = "ALC880 Digital";
         spec->stream_digital_playback = &alc880_pcm_digital_playback;
         spec->stream_digital_capture = &alc880_pcm_digital_capture;
@@ -4397 +4818 @@
                 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
                 /* get type */
-                wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
+                wcap = get_wcaps_type(wcap);
                 if (wcap != AC_WID_AUD_IN) {
                         spec->adc_nids = alc880_adc_nids_alt;
@@ -4406 +4827 @@
                 }
         }
-        set_capture_mixer(spec);
+        set_capture_mixer(codec);
         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
 
@@ -5598 +6019 @@
         nid = cfg->line_out_pins[0];
         if (nid) {
-                err = alc260_add_playback_controls(spec, nid, "Front", &vols);
+                const char *pfx;
+                if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
+                        pfx = "Master";
+                else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
+                        pfx = "Speaker";
+                else
+                        pfx = "Front";
+                err = alc260_add_playback_controls(spec, nid, pfx, &vols);
                 if (err < 0)
                         return err;
@@ -5621 +6049 @@
 
 /* create playback/capture controls for input pins */
-static int alc260_auto_create_analog_input_ctls(struct alc_spec *spec,
+static int alc260_auto_create_input_ctls(struct hda_codec *codec,
                                                 const struct auto_pin_cfg *cfg)
 {
-        struct hda_input_mux *imux = &spec->private_imux[0];
-        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;
+        return alc_auto_create_input_ctls(codec, cfg, 0x07, 0x04, 0x05);
 }
 
@@ -5674 +6073 @@
         hda_nid_t nid;
 
-        alc_subsystem_id(codec, 0x10, 0x15, 0x0f);
         nid = spec->autocfg.line_out_pins[0];
         if (nid) {
@@ -5768 +6166 @@
         if (!spec->kctls.list)
                 return 0; /* can't find valid BIOS pin config */
-        err = alc260_auto_create_analog_input_ctls(spec, &spec->autocfg);
+        err = alc260_auto_create_input_ctls(codec, &spec->autocfg);
         if (err < 0)
                 return err;
@@ -5783 +6181 @@
         spec->num_mux_defs = 1;
         spec->input_mux = &spec->private_imux[0];
+
+        alc_ssid_check(codec, 0x10, 0x15, 0x0f);
 
         return 1;
@@ -6001 +6401 @@
                                                   alc260_cfg_tbl);
         if (board_config < 0) {
-                snd_printd(KERN_INFO "hda_codec: Unknown model for ALC260, "
-                           "trying auto-probe from BIOS...\n");
+                snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
+                           codec->chip_name);
                 board_config = ALC260_AUTO;
         }
@@ -6027 +6427 @@
 
         if (board_config != ALC260_AUTO)
-                setup_preset(spec, &alc260_presets[board_config]);
-
-        spec->stream_name_analog = "ALC260 Analog";
+                setup_preset(codec, &alc260_presets[board_config]);
+
         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;
@@ -6040 +6438 @@
                 /* check whether NID 0x04 is valid */
                 unsigned int wcap = get_wcaps(codec, 0x04);
-                wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
+                wcap = get_wcaps_type(wcap);
                 /* get type */
                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
@@ -6050 +6448 @@
                 }
         }
-        set_capture_mixer(spec);
+        set_capture_mixer(codec);
         set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
 
@@ -6069 +6467 @@
 
 /*
- * ALC882 support
+ * ALC882/883/885/888/889 support
  *
  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
@@ -6081 +6479 @@
 #define ALC882_DIGOUT_NID       0x06
 #define ALC882_DIGIN_NID        0x0a
+#define ALC883_DIGOUT_NID       ALC882_DIGOUT_NID
+#define ALC883_DIGIN_NID        ALC882_DIGIN_NID
+#define ALC1200_DIGOUT_NID      0x10
+
 
 static struct hda_channel_mode alc882_ch_modes[1] = {
@@ -6086 +6488 @@
 };
 
+/* DACs */
 static hda_nid_t alc882_dac_nids[4] = {
         /* front, rear, clfe, rear_surr */
         0x02, 0x03, 0x04, 0x05
 };
-
-/* identical with ALC880 */
+#define alc883_dac_nids         alc882_dac_nids
+
+/* ADCs */
 #define alc882_adc_nids         alc880_adc_nids
 #define alc882_adc_nids_alt     alc880_adc_nids_alt
+#define alc883_adc_nids         alc882_adc_nids_alt
+static hda_nid_t alc883_adc_nids_alt[1] = { 0x08 };
+static hda_nid_t alc883_adc_nids_rev[2] = { 0x09, 0x08 };
+#define alc889_adc_nids         alc880_adc_nids
 
 static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
 static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
+#define alc883_capsrc_nids      alc882_capsrc_nids_alt
+static hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 };
+#define alc889_capsrc_nids      alc882_capsrc_nids
 
 /* input MUX */
@@ -6110 +6521 @@
         },
 };
+
+#define alc883_capture_source   alc882_capture_source
+
+static struct hda_input_mux alc889_capture_source = {
+        .num_items = 3,
+        .items = {
+                { "Front Mic", 0x0 },
+                { "Mic", 0x3 },
+                { "Line", 0x2 },
+        },
+};
+
+static struct hda_input_mux mb5_capture_source = {
+        .num_items = 3,
+        .items = {
+                { "Mic", 0x1 },
+                { "Line", 0x2 },
+                { "CD", 0x4 },
+        },
+};
+
+static struct hda_input_mux alc883_3stack_6ch_intel = {
+        .num_items = 4,
+        .items = {
+                { "Mic", 0x1 },
+                { "Front Mic", 0x0 },
+                { "Line", 0x2 },
+                { "CD", 0x4 },
+        },
+};
+
+static struct hda_input_mux alc883_lenovo_101e_capture_source = {
+        .num_items = 2,
+        .items = {
+                { "Mic", 0x1 },
+                { "Line", 0x2 },
+        },
+};
+
+static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
+        .num_items = 4,
+        .items = {
+                { "Mic", 0x0 },
+                { "iMic", 0x1 },
+                { "Line", 0x2 },
+                { "CD", 0x4 },
+        },
+};
+
+static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
+        .num_items = 2,
+        .items = {
+                { "Mic", 0x0 },
+                { "Int Mic", 0x1 },
+        },
+};
+
+static struct hda_input_mux alc883_lenovo_sky_capture_source = {
+        .num_items = 3,
+        .items = {
+                { "Mic", 0x0 },
+                { "Front Mic", 0x1 },
+                { "Line", 0x4 },
+        },
+};
+
+static struct hda_input_mux alc883_asus_eee1601_capture_source = {
+        .num_items = 2,
+        .items = {
+                { "Mic", 0x0 },
+                { "Line", 0x2 },
+        },
+};
+
+static struct hda_input_mux alc889A_mb31_capture_source = {
+        .num_items = 2,
+        .items = {
+                { "Mic", 0x0 },
+                /* Front Mic (0x01) unused */
+                { "Line", 0x2 },
+                /* Line 2 (0x03) unused */
+                /* CD (0x04) unsused? */
+        },
+};
+
+/*
+ * 2ch mode
+ */
+static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
+        { 2, NULL }
+};
+
 /*
  * 2ch mode
@@ -6118 +6621 @@
         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
+        {0} /* end */
+};
+
+/*
+ * 4ch mode
+ */
+static struct hda_verb alc882_3ST_ch4_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_OUT },
+        { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
+        { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
         {0} /* end */
 };
@@ -6134 +6649 @@
 };
 
-static struct hda_channel_mode alc882_3ST_6ch_modes[2] = {
+static struct hda_channel_mode alc882_3ST_6ch_modes[3] = {
         { 2, alc882_3ST_ch2_init },
+        { 4, alc882_3ST_ch4_init },
         { 6, alc882_3ST_ch6_init },
 };
+
+#define alc883_3ST_6ch_modes    alc882_3ST_6ch_modes
 
 /*
@@ -6167 +6685 @@
 
 /*
- * macbook pro ALC885 can switch LineIn to LineOut without loosing Mic
+ * macbook pro ALC885 can switch LineIn to LineOut without losing Mic
  */
 
@@ -6195 +6713 @@
         { 2, alc885_mbp_ch2_init },
         { 6, alc885_mbp_ch6_init },
+};
+
+/*
+ * 2ch
+ * Speakers/Woofer/HP = Front
+ * LineIn = Input
+ */
+static struct hda_verb alc885_mb5_ch2_init[] = {
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0} /* end */
+};
+
+/*
+ * 6ch mode
+ * Speakers/HP = Front
+ * Woofer = LFE
+ * LineIn = Surround
+ */
+static struct hda_verb alc885_mb5_ch6_init[] = {
+        {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},
+        {0} /* end */
+};
+
+static struct hda_channel_mode alc885_mb5_6ch_modes[2] = {
+        { 2, alc885_mb5_ch2_init },
+        { 6, alc885_mb5_ch6_init },
+};
+
+
+/*
+ * 2ch mode
+ */
+static struct hda_verb alc883_4ST_ch2_init[] = {
+        { 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 },
+        { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
+        { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
+        {0} /* end */
+};
+
+/*
+ * 4ch mode
+ */
+static struct hda_verb alc883_4ST_ch4_init[] = {
+        { 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 },
+        { 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 */
+};
+
+/*
+ * 6ch mode
+ */
+static struct hda_verb alc883_4ST_ch6_init[] = {
+        { 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_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 */
+};
+
+/*
+ * 8ch mode
+ */
+static struct hda_verb alc883_4ST_ch8_init[] = {
+        { 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 },
+        { 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_4ST_8ch_modes[4] = {
+        { 2, alc883_4ST_ch2_init },
+        { 4, alc883_4ST_ch4_init },
+        { 6, alc883_4ST_ch6_init },
+        { 8, alc883_4ST_ch8_init },
+};
+
+
+/*
+ * 2ch mode
+ */
+static struct hda_verb alc883_3ST_ch2_intel_init[] = {
+        { 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 },
+        {0} /* end */
+};
+
+/*
+ * 4ch mode
+ */
+static struct hda_verb alc883_3ST_ch4_intel_init[] = {
+        { 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 },
+        { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
+        {0} /* end */
+};
+
+/*
+ * 6ch mode
+ */
+static struct hda_verb alc883_3ST_ch6_intel_init[] = {
+        { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
+        { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
+        { 0x19, 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_intel_modes[3] = {
+        { 2, alc883_3ST_ch2_intel_init },
+        { 4, alc883_3ST_ch4_intel_init },
+        { 6, alc883_3ST_ch6_intel_init },
+};
+
+/*
+ * 2ch mode
+ */
+static struct hda_verb alc889_ch2_intel_init[] = {
+        { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
+        { 0x19, AC_VERB_SET_CONNECT_SEL, 0x00 },
+        { 0x16, AC_VERB_SET_CONNECT_SEL, 0x00 },
+        { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00 },
+        { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
+        { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
+        {0} /* end */
+};
+
+/*
+ * 6ch mode
+ */
+static struct hda_verb alc889_ch6_intel_init[] = {
+        { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
+        { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
+        { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
+        { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
+        { 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 alc889_ch8_intel_init[] = {
+        { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
+        { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
+        { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
+        { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
+        { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x03 },
+        { 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 alc889_8ch_intel_modes[3] = {
+        { 2, alc889_ch2_intel_init },
+        { 6, alc889_ch6_intel_init },
+        { 8, alc889_ch8_intel_init },
+};
+
+/*
+ * 6ch mode
+ */
+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 */
+};
+
+/*
+ * 8ch mode
+ */
+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 */
+};
+
+static struct hda_channel_mode alc883_sixstack_modes[2] = {
+        { 6, alc883_sixstack_ch6_init },
+        { 8, alc883_sixstack_ch8_init },
 };
 
@@ -6239 +6968 @@
         {0} /* end */
 };
+
+static struct snd_kcontrol_new alc885_mb5_mixer[] = {
+        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
+        HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
+        HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
+        HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
+        HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
+        HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
+        HDA_CODEC_VOLUME("HP Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
+        HDA_BIND_MUTE   ("HP Playback Switch", 0x0f, 0x02, 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, 0x01, HDA_INPUT),
+        HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
+        HDA_CODEC_VOLUME("Line Boost", 0x15, 0x00, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Boost", 0x19, 0x00, HDA_INPUT),
+        {0} /* end */
+};
+
 static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
@@ -6314 +7062 @@
 };
 
-static struct hda_verb alc882_init_verbs[] = {
+static struct hda_verb alc882_base_init_verbs[] = {
         /* Front mixer: unmute input/output amp left and right (volume = 0) */
         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
@@ -6331 +7079 @@
         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+
+        /* mute analog input loopbacks */
+        {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)},
 
         /* Front Pin: output 0 (0x0c) */
@@ -6366 +7121 @@
         /* 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)},
@@ -6381 +7131 @@
         {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)},
@@ -6394 +7141 @@
 };
 
+static struct hda_verb alc882_adc1_init_verbs[] = {
+        /* 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)},
+        /* ADC1: mute amp left and right */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0}
+};
+
 static struct hda_verb alc882_eapd_verbs[] = {
         /* change to EAPD mode */
@@ -6400 +7159 @@
         {0}
 };
+
+static struct hda_verb alc889_eapd_verbs[] = {
+        {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
+        {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
+        {0}
+};
+
+static struct hda_verb alc_hp15_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 alc885_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)},
+
+        /* mute analog input loopbacks */
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
+        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
+
+        /* Front HP Pin: output 0 (0x0c) */
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
+        /* 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) */
+        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x19, 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% */
+        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        /* Front Mic pin: input vref at 80% */
+        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x18, 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},
+
+        /* Mixer elements: 0x18, , 0x1a, 0x1b */
+        /* Input mixer1 */
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
+        /* Input mixer2 */
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
+        /* Input mixer3 */
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
+        /* ADC2: mute amp left and right */
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        /* ADC3: mute amp left and right */
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+
+        {0}
+};
+
+static struct hda_verb alc885_init_input_verbs[] = {
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
+        {0}
+};
+
+
+/* Unmute Selector 24h and set the default input to front mic */
+static struct hda_verb alc889_init_input_verbs[] = {
+        {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0}
+};
+
+
+#define alc883_init_verbs       alc882_base_init_verbs
 
 /* Mac Pro test */
@@ -6463 +7326 @@
         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
 
+        {0}
+};
+
+/* Macbook 5,1 */
+static struct hda_verb alc885_mb5_init_verbs[] = {
+        /* DACs */
+        {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {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},
+        /* Front mixer */
+        {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)},
+        /* Surround 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)},
+        /* LFE 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)},
+        /* HP 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 (0x0c) */
+        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
+        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
+        /* LFE Pin (0x0e) */
+        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
+        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
+        /* HP Pin (0x0f) */
+        {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, 0x03},
+        /* 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 */
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {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)},
         {0}
 };
@@ -6555 +7467 @@
 
 /* Toggle speaker-output according to the hp-jack state */
-static void alc885_imac24_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_stereo(codec, 0x18, HDA_OUTPUT, 0,
-                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
-        snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
-                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
-}
-
-/* Processes unsolicited events. */
-static void alc885_imac24_unsol_event(struct hda_codec *codec,
-                                      unsigned int res)
-{
-        /* Headphone insertion or removal. */
-        if ((res >> 26) == ALC880_HP_EVENT)
-                alc885_imac24_automute(codec);
-}
-
-static void alc885_mbp3_automute(struct hda_codec *codec)
-{
-        unsigned int present;
-
-        present = snd_hda_codec_read(codec, 0x15, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-        snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
-                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
-        snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
-                                 HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
-
-}
-static void alc885_mbp3_unsol_event(struct hda_codec *codec,
-                                    unsigned int res)
-{
-        /* Headphone insertion or removal. */
-        if ((res >> 26) == ALC880_HP_EVENT)
-                alc885_mbp3_automute(codec);
+static void alc885_imac24_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        spec->autocfg.hp_pins[0] = 0x14;
+        spec->autocfg.speaker_pins[0] = 0x18;
+        spec->autocfg.speaker_pins[1] = 0x1a;
+}
+
+static void alc885_mbp3_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        spec->autocfg.hp_pins[0] = 0x15;
+        spec->autocfg.speaker_pins[0] = 0x14;
 }
 
@@ -6609 +7497 @@
 
         {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 */
 };
@@ -6618 +7503 @@
 static void alc882_targa_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_stereo(codec, 0x1b, HDA_OUTPUT, 0,
-                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
+        struct alc_spec *spec = codec->spec;
+        alc_automute_amp(codec);
         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
-                                  present ? 1 : 3);
+                                  spec->jack_present ? 1 : 3);
+}
+
+static void alc882_targa_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        spec->autocfg.hp_pins[0] = 0x14;
+        spec->autocfg.speaker_pins[0] = 0x1b;
 }
 
 static void alc882_targa_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 26 bit!
-         */
-        if (((res >> 26) == ALC880_HP_EVENT)) {
+        if ((res >> 26) == ALC880_HP_EVENT)
                 alc882_targa_automute(codec);
-        }
 }
 
@@ -6717 +7602 @@
 {
         alc885_macpro_init_hook(codec);
-        alc885_imac24_automute(codec);
+        alc_automute_amp(codec);
 }
 
@@ -6723 +7608 @@
  * generic initialization of ADC, input mixers and output mixers
  */
-static struct hda_verb alc882_auto_init_verbs[] = {
+static struct hda_verb alc883_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)},
@@ -6769 +7652 @@
         /* 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))},
@@ -6788 +7666 @@
 };
 
+/* 2ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:front) */
+static struct hda_verb alc889A_mb31_ch2_init[] = {
+        {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
+        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
+        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
+        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
+        {0} /* end */
+};
+
+/* 4ch mode (Speaker:front, Subwoofer:CLFE, Line:CLFE, Headphones:front) */
+static struct hda_verb alc889A_mb31_ch4_init[] = {
+        {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
+        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
+        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
+        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
+        {0} /* end */
+};
+
+/* 5ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:rear) */
+static struct hda_verb alc889A_mb31_ch5_init[] = {
+        {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as rear */
+        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
+        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
+        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
+        {0} /* end */
+};
+
+/* 6ch mode (Speaker:front, Subwoofer:off, Line:CLFE, Headphones:Rear) */
+static struct hda_verb alc889A_mb31_ch6_init[] = {
+        {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as front */
+        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Subwoofer off */
+        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
+        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
+        {0} /* end */
+};
+
+static struct hda_channel_mode alc889A_mb31_6ch_modes[4] = {
+        { 2, alc889A_mb31_ch2_init },
+        { 4, alc889A_mb31_ch4_init },
+        { 5, alc889A_mb31_ch5_init },
+        { 6, alc889A_mb31_ch6_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}
+};
+
+#define alc883_base_mixer       alc882_base_mixer
+
+static struct snd_kcontrol_new alc883_mitac_mixer[] = {
+        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 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", 0x15, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, 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_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
+        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
+        {0} /* end */
+};
+
+static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
+        HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
+        HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
+        HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
+        {0} /* end */
+};
+
+static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
+        HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
+        HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
+        HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
+        {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_VOLUME("Mic Boost", 0x18, 0, 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_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
+        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
+        {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_VOLUME("Mic Boost", 0x18, 0, 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_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
+        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
+        {0} /* end */
+};
+
+static struct snd_kcontrol_new alc883_3ST_6ch_intel_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", 0x15, 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, 0x1, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
+        HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
+        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
+        {0} /* end */
+};
+
+static struct snd_kcontrol_new alc885_8ch_intel_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("Speaker Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Speaker Playback Switch", 0x0f, 2, HDA_INPUT),
+        HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
+        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, 0x3, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Boost", 0x1b, 0, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
+        HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
+        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
+        {0} /* end */
+};
+
+static struct snd_kcontrol_new alc883_fivestack_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_VOLUME("Mic Boost", 0x18, 0, 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_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
+        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
+        {0} /* end */
+};
+
+static struct snd_kcontrol_new alc883_targa_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_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
+        {0} /* end */
+};
+
+static struct snd_kcontrol_new alc883_targa_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_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
+        HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
+        HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
+        {0} /* end */
+};
+
+static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
+        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
+        HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
+        {0} /* end */
+};
+
+static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
+        HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
+        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("iMic Playback Volume", 0x0b, 0x1, HDA_INPUT),
+        HDA_CODEC_MUTE("iMic Playback Switch", 0x0b, 0x1, HDA_INPUT),
+        {0} /* end */
+};
+
+static struct snd_kcontrol_new alc883_medion_md2_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", 0x15, 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("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
+        HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
+        {0} /* end */
+};
+
+static struct snd_kcontrol_new alc883_acer_aspire_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", 0x14, 0x0, HDA_OUTPUT),
+        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_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
+        {0} /* end */
+};
+
+static struct snd_kcontrol_new alc888_acer_aspire_6530_mixer[] = {
+        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME("LFE Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("LFE Playback Switch", 0x0f, 2, 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("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
+        {0} /* end */
+};
+
+static struct snd_kcontrol_new alc888_lenovo_sky_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", 0x0e, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 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("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_VOLUME("Mic Boost", 0x18, 0, 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_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
+        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
+        {0} /* end */
+};
+
+static struct snd_kcontrol_new alc889A_mb31_mixer[] = {
+        /* Output mixers */
+        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
+        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
+        HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
+        HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
+        HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x00,
+                HDA_OUTPUT),
+        HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x02, HDA_INPUT),
+        HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x00, HDA_OUTPUT),
+        HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x02, HDA_INPUT),
+        /* Output switches */
+        HDA_CODEC_MUTE("Enable Speaker", 0x14, 0x00, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Enable Headphones", 0x15, 0x00, HDA_OUTPUT),
+        HDA_CODEC_MUTE_MONO("Enable LFE", 0x16, 2, 0x00, HDA_OUTPUT),
+        /* Boost mixers */
+        HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
+        HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
+        /* Input mixers */
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
+        HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
+        HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
+        {0} /* end */
+};
+
+static struct snd_kcontrol_new alc883_vaiott_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", 0x15, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
+        {0} /* end */
+};
+
+static struct hda_bind_ctls alc883_bind_cap_vol = {
+        .ops = &snd_hda_bind_vol,
+        .values = {
+                HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
+                HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
+                0
+        },
+};
+
+static struct hda_bind_ctls alc883_bind_cap_switch = {
+        .ops = &snd_hda_bind_sw,
+        .values = {
+                HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
+                HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
+                0
+        },
+};
+
+static struct snd_kcontrol_new alc883_asus_eee1601_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", 0x14, 0x0, HDA_OUTPUT),
+        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_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
+        {0} /* end */
+};
+
+static struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = {
+        HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
+        HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                /* .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 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 */
+};
+
+/* toggle speaker-output according to the hp-jack state */
+static void alc883_mitac_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        spec->autocfg.hp_pins[0] = 0x15;
+        spec->autocfg.speaker_pins[0] = 0x14;
+        spec->autocfg.speaker_pins[1] = 0x17;
+}
+
+/* auto-toggle front mic */
+/*
+static void alc883_mitac_mic_automute(struct hda_codec *codec)
+{
+        unsigned int present;
+        unsigned char bits;
+
+        present = snd_hda_codec_read(codec, 0x18, 0,
+                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
+        bits = present ? HDA_AMP_MUTE : 0;
+        snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
+}
+*/
+
+static struct hda_verb alc883_mitac_verbs[] = {
+        /* HP */
+        {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        /* Subwoofer */
+        {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
+        {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+
+        /* enable unsolicited event */
+        {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
+        /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
+
+        {0} /* end */
+};
+
+static struct hda_verb alc883_clevo_m720_verbs[] = {
+        /* HP */
+        {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        /* Int speaker */
+        {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+
+        /* enable unsolicited event */
+        {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
+        {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
+
+        {0} /* end */
+};
+
+static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
+        /* HP */
+        {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        /* Subwoofer */
+        {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+
+        /* enable unsolicited event */
+        {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
+
+        {0} /* end */
+};
+
+static struct hda_verb alc883_targa_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},
+
+/* Connect Line-Out side jack (SPDIF) to Side */
+        {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},
+/* Connect Mic jack to CLFE */
+        {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},
+/* Connect Line-in jack to Surround */
+        {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},
+/* Connect HP out jack to Front */
+        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
+
+        {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
+
+        {0} /* end */
+};
+
+static struct hda_verb alc883_lenovo_101e_verbs[] = {
+        {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
+        {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
+        {0} /* end */
+};
+
+static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
+        {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0} /* end */
+};
+
+static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
+        {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
+        {0} /* end */
+};
+
+static struct hda_verb alc883_haier_w66_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_OUT},
+
+        {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
+        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0} /* end */
+};
+
+static struct hda_verb alc888_lenovo_sky_verbs[] = {
+        {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)},
+        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
+        {0} /* end */
+};
+
+static struct hda_verb alc888_6st_dell_verbs[] = {
+        {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
+        {0}
+};
+
+static struct hda_verb alc883_vaiott_verbs[] = {
+        /* HP */
+        {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+
+        /* enable unsolicited event */
+        {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
+
+        {0} /* end */
+};
+
+static void alc888_3st_hp_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        spec->autocfg.hp_pins[0] = 0x1b;
+        spec->autocfg.speaker_pins[0] = 0x14;
+        spec->autocfg.speaker_pins[1] = 0x16;
+        spec->autocfg.speaker_pins[2] = 0x18;
+}
+
+static struct hda_verb alc888_3st_hp_verbs[] = {
+        {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Front: output 0 (0x0c) */
+        {0x16, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Rear : output 1 (0x0d) */
+        {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},  /* CLFE : output 2 (0x0e) */
+        {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
+        {0} /* end */
+};
+
+/*
+ * 2ch mode
+ */
+static struct hda_verb alc888_3st_hp_2ch_init[] = {
+        { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
+        { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
+        { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
+        { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
+        {0} /* end */
+};
+
+/*
+ * 4ch mode
+ */
+static struct hda_verb alc888_3st_hp_4ch_init[] = {
+        { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
+        { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
+        { 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, 0x01 },
+        {0} /* end */
+};
+
+/*
+ * 6ch mode
+ */
+static struct hda_verb alc888_3st_hp_6ch_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 },
+        { 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, 0x01 },
+        {0} /* end */
+};
+
+static struct hda_channel_mode alc888_3st_hp_modes[3] = {
+        { 2, alc888_3st_hp_2ch_init },
+        { 4, alc888_3st_hp_4ch_init },
+        { 6, alc888_3st_hp_6ch_init },
+};
+
+/* toggle front-jack and RCA according to the hp-jack state */
+static void alc888_lenovo_ms7195_front_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_stereo(codec, 0x14, HDA_OUTPUT, 0,
+                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
+        snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
+                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
+}
+
+/* toggle RCA according to the front-jack state */
+static void alc888_lenovo_ms7195_rca_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_stereo(codec, 0x15, HDA_OUTPUT, 0,
+                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
+}
+
+static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
+                                             unsigned int res)
+{
+        if ((res >> 26) == ALC880_HP_EVENT)
+                alc888_lenovo_ms7195_front_automute(codec);
+        if ((res >> 26) == ALC880_FRONT_EVENT)
+                alc888_lenovo_ms7195_rca_automute(codec);
+}
+
+static struct hda_verb alc883_medion_md2_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},
+
+        {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
+        {0} /* end */
+};
+
+/* toggle speaker-output according to the hp-jack state */
+static void alc883_medion_md2_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        spec->autocfg.hp_pins[0] = 0x14;
+        spec->autocfg.speaker_pins[0] = 0x15;
+}
+
+/* toggle speaker-output according to the hp-jack state */
+#define alc883_targa_init_hook          alc882_targa_init_hook
+#define alc883_targa_unsol_event        alc882_targa_unsol_event
+
+static void alc883_clevo_m720_mic_automute(struct hda_codec *codec)
+{
+        unsigned int present;
+
+        present = snd_hda_codec_read(codec, 0x18, 0,
+                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
+        snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
+                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
+}
+
+static void alc883_clevo_m720_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        spec->autocfg.hp_pins[0] = 0x15;
+        spec->autocfg.speaker_pins[0] = 0x14;
+}
+
+static void alc883_clevo_m720_init_hook(struct hda_codec *codec)
+{
+        alc_automute_amp(codec);
+        alc883_clevo_m720_mic_automute(codec);
+}
+
+static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
+                                           unsigned int res)
+{
+        switch (res >> 26) {
+        case ALC880_MIC_EVENT:
+                alc883_clevo_m720_mic_automute(codec);
+                break;
+        default:
+                alc_automute_amp_unsol_event(codec, res);
+                break;
+        }
+}
+
+/* toggle speaker-output according to the hp-jack state */
+static void alc883_2ch_fujitsu_pi2515_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        spec->autocfg.hp_pins[0] = 0x14;
+        spec->autocfg.speaker_pins[0] = 0x15;
+}
+
+static void alc883_haier_w66_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        spec->autocfg.hp_pins[0] = 0x1b;
+        spec->autocfg.speaker_pins[0] = 0x14;
+}
+
+static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
+{
+        unsigned int present;
+        unsigned char bits;
+
+        present = snd_hda_codec_read(codec, 0x14, 0, AC_VERB_GET_PIN_SENSE, 0)
+                & AC_PINSENSE_PRESENCE;
+        bits = present ? HDA_AMP_MUTE : 0;
+        snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
+                                 HDA_AMP_MUTE, bits);
+}
+
+static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
+{
+        unsigned int present;
+        unsigned char bits;
+
+        present = snd_hda_codec_read(codec, 0x1b, 0,
+                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
+        bits = present ? HDA_AMP_MUTE : 0;
+        snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
+                                 HDA_AMP_MUTE, bits);
+        snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
+                                 HDA_AMP_MUTE, bits);
+}
+
+static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
+                                           unsigned int res)
+{
+        if ((res >> 26) == ALC880_HP_EVENT)
+                alc883_lenovo_101e_all_automute(codec);
+        if ((res >> 26) == ALC880_FRONT_EVENT)
+                alc883_lenovo_101e_ispeaker_automute(codec);
+}
+
+/* toggle speaker-output according to the hp-jack state */
+static void alc883_acer_aspire_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        spec->autocfg.hp_pins[0] = 0x14;
+        spec->autocfg.speaker_pins[0] = 0x15;
+        spec->autocfg.speaker_pins[1] = 0x16;
+}
+
+static struct hda_verb alc883_acer_eapd_verbs[] = {
+        /* HP Pin: output 0 (0x0c) */
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
+        /* Front Pin: output 0 (0x0c) */
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
+        /* eanable EAPD on medion laptop */
+        {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
+        {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
+        /* enable unsolicited event */
+        {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
+        {0}
+};
+
+static struct hda_verb alc888_acer_aspire_7730G_verbs[] = {
+        {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
+        {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
+        {0} /* end */
+};
+
+static void alc888_6st_dell_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        spec->autocfg.hp_pins[0] = 0x1b;
+        spec->autocfg.speaker_pins[0] = 0x14;
+        spec->autocfg.speaker_pins[1] = 0x15;
+        spec->autocfg.speaker_pins[2] = 0x16;
+        spec->autocfg.speaker_pins[3] = 0x17;
+}
+
+static void alc888_lenovo_sky_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        spec->autocfg.hp_pins[0] = 0x1b;
+        spec->autocfg.speaker_pins[0] = 0x14;
+        spec->autocfg.speaker_pins[1] = 0x15;
+        spec->autocfg.speaker_pins[2] = 0x16;
+        spec->autocfg.speaker_pins[3] = 0x17;
+        spec->autocfg.speaker_pins[4] = 0x1a;
+}
+
+static void alc883_vaiott_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        spec->autocfg.hp_pins[0] = 0x15;
+        spec->autocfg.speaker_pins[0] = 0x14;
+        spec->autocfg.speaker_pins[1] = 0x17;
+}
+
+static struct hda_verb alc888_asus_m90v_verbs[] = {
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        /* enable unsolicited event */
+        {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
+        {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
+        {0} /* end */
+};
+
+static void alc883_mode2_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        spec->autocfg.hp_pins[0] = 0x1b;
+        spec->autocfg.speaker_pins[0] = 0x14;
+        spec->autocfg.speaker_pins[1] = 0x15;
+        spec->autocfg.speaker_pins[2] = 0x16;
+        spec->ext_mic.pin = 0x18;
+        spec->int_mic.pin = 0x19;
+        spec->ext_mic.mux_idx = 0;
+        spec->int_mic.mux_idx = 1;
+        spec->auto_mic = 1;
+}
+
+static struct hda_verb alc888_asus_eee1601_verbs[] = {
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
+        {0x20, AC_VERB_SET_PROC_COEF,  0x0838},
+        /* enable unsolicited event */
+        {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
+        {0} /* end */
+};
+
+static void alc883_eee1601_inithook(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        spec->autocfg.hp_pins[0] = 0x14;
+        spec->autocfg.speaker_pins[0] = 0x1b;
+        alc_automute_pin(codec);
+}
+
+static struct hda_verb alc889A_mb31_verbs[] = {
+        /* Init rear pin (used as headphone output) */
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},    /* Apple Headphones */
+        {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},           /* Connect to front */
+        {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
+        /* Init line pin (used as output in 4ch and 6ch mode) */
+        {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},           /* Connect to CLFE */
+        /* Init line 2 pin (used as headphone out by default) */
+        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},  /* Use as input */
+        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Mute output */
+        {0} /* end */
+};
+
+/* Mute speakers according to the headphone jack state */
+static void alc889A_mb31_automute(struct hda_codec *codec)
+{
+        unsigned int present;
+
+        /* Mute only in 2ch or 4ch mode */
+        if (snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_CONNECT_SEL, 0)
+            == 0x00) {
+                present = snd_hda_codec_read(codec, 0x15, 0,
+                        AC_VERB_GET_PIN_SENSE, 0) & AC_PINSENSE_PRESENCE;
+                snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
+                        HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
+                snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
+                        HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
+        }
+}
+
+static void alc889A_mb31_unsol_event(struct hda_codec *codec, unsigned int res)
+{
+        if ((res >> 26) == ALC880_HP_EVENT)
+                alc889A_mb31_automute(codec);
+}
+
+
 #ifdef CONFIG_SND_HDA_POWER_SAVE
 #define alc882_loopbacks        alc880_loopbacks
 #endif
 
-/* pcm configuration: identiacal with ALC880 */
+/* pcm configuration: identical with ALC880 */
 #define alc882_pcm_analog_playback      alc880_pcm_analog_playback
 #define alc882_pcm_analog_capture       alc880_pcm_analog_capture
 #define alc882_pcm_digital_playback     alc880_pcm_digital_playback
 #define alc882_pcm_digital_capture      alc880_pcm_digital_capture
+
+static hda_nid_t alc883_slave_dig_outs[] = {
+        ALC1200_DIGOUT_NID, 0,
+};
+
+static hda_nid_t alc1200_slave_dig_outs[] = {
+        ALC883_DIGOUT_NID, 0,
+};
 
 /*
@@ -6810 +8639 @@
         [ALC882_ASUS_A7M]       = "asus-a7m",
         [ALC885_MACPRO]         = "macpro",
+        [ALC885_MB5]            = "mb5",
         [ALC885_MBP3]           = "mbp3",
         [ALC885_IMAC24]         = "imac24",
+        [ALC883_3ST_2ch_DIG]    = "3stack-2ch-dig",
+        [ALC883_3ST_6ch_DIG]    = "3stack-6ch-dig",
+        [ALC883_3ST_6ch]        = "3stack-6ch",
+        [ALC883_6ST_DIG]        = "alc883-6stack-dig",
+        [ALC883_TARGA_DIG]      = "targa-dig",
+        [ALC883_TARGA_2ch_DIG]  = "targa-2ch-dig",
+        [ALC883_TARGA_8ch_DIG]  = "targa-8ch-dig",
+        [ALC883_ACER]           = "acer",
+        [ALC883_ACER_ASPIRE]    = "acer-aspire",
+        [ALC888_ACER_ASPIRE_4930G]      = "acer-aspire-4930g",
+        [ALC888_ACER_ASPIRE_6530G]      = "acer-aspire-6530g",
+        [ALC888_ACER_ASPIRE_8930G]      = "acer-aspire-8930g",
+        [ALC888_ACER_ASPIRE_7730G]      = "acer-aspire-7730g",
+        [ALC883_MEDION]         = "medion",
+        [ALC883_MEDION_MD2]     = "medion-md2",
+        [ALC883_LAPTOP_EAPD]    = "laptop-eapd",
+        [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
+        [ALC883_LENOVO_NB0763]  = "lenovo-nb0763",
+        [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
+        [ALC888_LENOVO_SKY] = "lenovo-sky",
+        [ALC883_HAIER_W66]      = "haier-w66",
+        [ALC888_3ST_HP]         = "3stack-hp",
+        [ALC888_6ST_DELL]       = "6stack-dell",
+        [ALC883_MITAC]          = "mitac",
+        [ALC883_CLEVO_M720]     = "clevo-m720",
+        [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
+        [ALC888_FUJITSU_XA3530] = "fujitsu-xa3530",
+        [ALC883_3ST_6ch_INTEL]  = "3stack-6ch-intel",
+        [ALC889A_INTEL]         = "intel-alc889a",
+        [ALC889_INTEL]          = "intel-x58",
+        [ALC1200_ASUS_P5Q]      = "asus-p5q",
+        [ALC889A_MB31]          = "mb31",
+        [ALC883_SONY_VAIO_TT]   = "sony-vaio-tt",
         [ALC882_AUTO]           = "auto",
 };
@@ -6817 +8680 @@
 static struct snd_pci_quirk alc882_cfg_tbl[] = {
         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
+
+        SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
+        SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE),
+        SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_ACER_ASPIRE),
+        SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
+        SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
+        SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
+        SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
+                ALC888_ACER_ASPIRE_4930G),
+        SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
+                ALC888_ACER_ASPIRE_4930G),
+        SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
+                ALC888_ACER_ASPIRE_8930G),
+        SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
+                ALC888_ACER_ASPIRE_8930G),
+        SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC882_AUTO),
+        SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC882_AUTO),
+        SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
+                ALC888_ACER_ASPIRE_6530G),
+        SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
+                ALC888_ACER_ASPIRE_6530G),
+        SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
+                ALC888_ACER_ASPIRE_7730G),
+        /* default Acer -- disabled as it causes more problems.
+         *    model=auto should work fine now
+         */
+        /* SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER), */
+
+        SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
+
+        SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
+        SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
+        SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
+        SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
+        SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP),
+        SND_PCI_QUIRK(0x103c, 0x2a72, "HP Educ.ar", ALC888_3ST_HP),
+
         SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
         SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
+        SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
         SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
         SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
+        SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
+        SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG),
+        SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),
+        SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
+
+        SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC883_SONY_VAIO_TT),
+        SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
+        SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC),
+        SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
+        SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
+        SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
+        SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
+
+        SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
+        SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
+        SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
         SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
+        SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC883_TARGA_2ch_DIG),
         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
-        SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA),
+        SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
+        SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
+        SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
+        SND_PCI_QUIRK(0x1462, 0x3ef9, "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, 0x3fcc, "MSI", ALC883_TARGA_DIG),
+        SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
+        SND_PCI_QUIRK(0x1462, 0x42cd, "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, 0x6510, "MSI GX620", ALC883_TARGA_8ch_DIG),
+        SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
+        SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
+        SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
+        SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG),
+        SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
+        SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
+        SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
+        SND_PCI_QUIRK(0x1462, 0x7350, "MSI", ALC883_6ST_DIG),
+        SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
+        SND_PCI_QUIRK(0x1462, 0xaa08, "MSI", ALC883_TARGA_2ch_DIG),
+
+        SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
+        SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
+        SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
+        SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD),
+        SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
+        /* SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA), */
+        SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
+        SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1100, "FSC AMILO Xi/Pi25xx",
+                      ALC883_FUJITSU_PI2515),
+        SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1130, "Fujitsu AMILO Xa35xx",
+                ALC888_FUJITSU_XA3530),
+        SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
+        SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
+        SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
+        SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
+        SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
+        SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2),
+        SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG),
+        SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
+        SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
+
+        SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
+        SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
+        SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
+        SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_INTEL),
+        SND_PCI_QUIRK(0x8086, 0x0021, "Intel IbexPeak", ALC889A_INTEL),
+        SND_PCI_QUIRK(0x8086, 0x3b56, "Intel IbexPeak", ALC889A_INTEL),
+        SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC883_3ST_6ch),
+
         {0}
+};
+
+/* codec SSID table for Intel Mac */
+static struct snd_pci_quirk alc882_ssid_cfg_tbl[] = {
+        SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC885_MBP3),
+        SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC885_MBP3),
+        SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC885_MBP3),
+        SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_MACPRO),
+        SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_IMAC24),
+        SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_IMAC24),
+        SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC885_MBP3),
+        SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889A_MB31),
+        SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC885_MBP3),
+        SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_IMAC24),
+        SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC885_MB5),
+        /* FIXME: HP jack sense seems not working for MBP 5,1, so apparently
+         * no perfect solution yet
+         */
+        SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC885_MB5),
+        {0} /* terminator */
 };
 
@@ -6834 +8824 @@
         [ALC882_3ST_DIG] = {
                 .mixers = { alc882_base_mixer },
-                .init_verbs = { alc882_init_verbs },
+                .init_verbs = { alc882_base_init_verbs,
+                                alc882_adc1_init_verbs },
                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
                 .dac_nids = alc882_dac_nids,
@@ -6846 +8837 @@
         [ALC882_6ST_DIG] = {
                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
-                .init_verbs = { alc882_init_verbs },
+                .init_verbs = { alc882_base_init_verbs,
+                                alc882_adc1_init_verbs },
                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
                 .dac_nids = alc882_dac_nids,
@@ -6857 +8849 @@
         [ALC882_ARIMA] = {
                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
-                .init_verbs = { alc882_init_verbs, alc882_eapd_verbs },
+                .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
+                                alc882_eapd_verbs },
                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
                 .dac_nids = alc882_dac_nids,
@@ -6866 +8859 @@
         [ALC882_W2JC] = {
                 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
-                .init_verbs = { alc882_init_verbs, alc882_eapd_verbs,
-                                alc880_gpio1_init_verbs },
+                .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
+                                alc882_eapd_verbs, alc880_gpio1_init_verbs },
                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
                 .dac_nids = alc882_dac_nids,
@@ -6887 +8880 @@
                 .dig_out_nid = ALC882_DIGOUT_NID,
                 .dig_in_nid = ALC882_DIGIN_NID,
-                .unsol_event = alc885_mbp3_unsol_event,
-                .init_hook = alc885_mbp3_automute,
+                .unsol_event = alc_automute_amp_unsol_event,
+                .setup = alc885_mbp3_setup,
+                .init_hook = alc_automute_amp,
+        },
+        [ALC885_MB5] = {
+                .mixers = { alc885_mb5_mixer, alc882_chmode_mixer },
+                .init_verbs = { alc885_mb5_init_verbs,
+                                alc880_gpio1_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc882_dac_nids),
+                .dac_nids = alc882_dac_nids,
+                .channel_mode = alc885_mb5_6ch_modes,
+                .num_channel_mode = ARRAY_SIZE(alc885_mb5_6ch_modes),
+                .input_mux = &mb5_capture_source,
+                .dig_out_nid = ALC882_DIGOUT_NID,
+                .dig_in_nid = ALC882_DIGIN_NID,
         },
         [ALC885_MACPRO] = {
@@ -6912 +8918 @@
                 .channel_mode = alc882_ch_modes,
                 .input_mux = &alc882_capture_source,
-                .unsol_event = alc885_imac24_unsol_event,
+                .unsol_event = alc_automute_amp_unsol_event,
+                .setup = alc885_imac24_setup,
                 .init_hook = alc885_imac24_init_hook,
         },
         [ALC882_TARGA] = {
                 .mixers = { alc882_targa_mixer, alc882_chmode_mixer },
-                .init_verbs = { alc882_init_verbs, alc882_targa_verbs},
+                .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
+                                alc880_gpio3_init_verbs, alc882_targa_verbs},
                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
                 .dac_nids = alc882_dac_nids,
@@ -6929 +8937 @@
                 .input_mux = &alc882_capture_source,
                 .unsol_event = alc882_targa_unsol_event,
+                .setup = alc882_targa_setup,
                 .init_hook = alc882_targa_automute,
         },
         [ALC882_ASUS_A7J] = {
                 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer },
-                .init_verbs = { alc882_init_verbs, alc882_asus_a7j_verbs},
+                .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
+                                alc882_asus_a7j_verbs},
                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
                 .dac_nids = alc882_dac_nids,
@@ -6947 +8957 @@
         [ALC882_ASUS_A7M] = {
                 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
-                .init_verbs = { alc882_init_verbs, alc882_eapd_verbs,
-                                alc880_gpio1_init_verbs,
+                .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
+                                alc882_eapd_verbs, alc880_gpio1_init_verbs,
                                 alc882_asus_a7m_verbs },
                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
@@ -6958 +8968 @@
                 .input_mux = &alc882_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,
+                .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,
+                .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_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_INTEL] = {
+                .mixers = { alc883_3ST_6ch_intel_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,
+                .dig_in_nid = ALC883_DIGIN_NID,
+                .slave_dig_outs = alc883_slave_dig_outs,
+                .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
+                .channel_mode = alc883_3ST_6ch_intel_modes,
+                .need_dac_fix = 1,
+                .input_mux = &alc883_3stack_6ch_intel,
+        },
+        [ALC889A_INTEL] = {
+                .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
+                .init_verbs = { alc885_init_verbs, alc885_init_input_verbs,
+                                alc_hp15_unsol_verbs },
+                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
+                .dac_nids = alc883_dac_nids,
+                .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
+                .adc_nids = alc889_adc_nids,
+                .dig_out_nid = ALC883_DIGOUT_NID,
+                .dig_in_nid = ALC883_DIGIN_NID,
+                .slave_dig_outs = alc883_slave_dig_outs,
+                .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
+                .channel_mode = alc889_8ch_intel_modes,
+                .capsrc_nids = alc889_capsrc_nids,
+                .input_mux = &alc889_capture_source,
+                .setup = alc889_automute_setup,
+                .init_hook = alc_automute_amp,
+                .unsol_event = alc_automute_amp_unsol_event,
+                .need_dac_fix = 1,
+        },
+        [ALC889_INTEL] = {
+                .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
+                .init_verbs = { alc885_init_verbs, alc889_init_input_verbs,
+                                alc889_eapd_verbs, alc_hp15_unsol_verbs},
+                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
+                .dac_nids = alc883_dac_nids,
+                .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
+                .adc_nids = alc889_adc_nids,
+                .dig_out_nid = ALC883_DIGOUT_NID,
+                .dig_in_nid = ALC883_DIGIN_NID,
+                .slave_dig_outs = alc883_slave_dig_outs,
+                .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
+                .channel_mode = alc889_8ch_intel_modes,
+                .capsrc_nids = alc889_capsrc_nids,
+                .input_mux = &alc889_capture_source,
+                .setup = alc889_automute_setup,
+                .init_hook = alc889_intel_init_hook,
+                .unsol_event = alc_automute_amp_unsol_event,
+                .need_dac_fix = 1,
+        },
+        [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,
+                .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_targa_mixer, alc883_chmode_mixer },
+                .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
+                                alc883_targa_verbs},
+                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
+                .dac_nids = alc883_dac_nids,
+                .dig_out_nid = ALC883_DIGOUT_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,
+                .unsol_event = alc883_targa_unsol_event,
+                .setup = alc882_targa_setup,
+                .init_hook = alc882_targa_automute,
+        },
+        [ALC883_TARGA_2ch_DIG] = {
+                .mixers = { alc883_targa_2ch_mixer},
+                .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
+                                alc883_targa_verbs},
+                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
+                .dac_nids = alc883_dac_nids,
+                .adc_nids = alc883_adc_nids_alt,
+                .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
+                .dig_out_nid = ALC883_DIGOUT_NID,
+                .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
+                .channel_mode = alc883_3ST_2ch_modes,
+                .input_mux = &alc883_capture_source,
+                .unsol_event = alc883_targa_unsol_event,
+                .setup = alc882_targa_setup,
+                .init_hook = alc882_targa_automute,
+        },
+        [ALC883_TARGA_8ch_DIG] = {
+                .mixers = { alc883_base_mixer, alc883_chmode_mixer },
+                .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
+                                alc883_targa_verbs },
+                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
+                .dac_nids = alc883_dac_nids,
+                .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
+                .adc_nids = alc883_adc_nids_rev,
+                .capsrc_nids = alc883_capsrc_nids_rev,
+                .dig_out_nid = ALC883_DIGOUT_NID,
+                .dig_in_nid = ALC883_DIGIN_NID,
+                .num_channel_mode = ARRAY_SIZE(alc883_4ST_8ch_modes),
+                .channel_mode = alc883_4ST_8ch_modes,
+                .need_dac_fix = 1,
+                .input_mux = &alc883_capture_source,
+                .unsol_event = alc883_targa_unsol_event,
+                .setup = alc882_targa_setup,
+                .init_hook = alc882_targa_automute,
+        },
+        [ALC883_ACER] = {
+                .mixers = { alc883_base_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_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
+                .channel_mode = alc883_3ST_2ch_modes,
+                .input_mux = &alc883_capture_source,
+        },
+        [ALC883_ACER_ASPIRE] = {
+                .mixers = { alc883_acer_aspire_mixer },
+                .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
+                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
+                .dac_nids = alc883_dac_nids,
+                .dig_out_nid = ALC883_DIGOUT_NID,
+                .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
+                .channel_mode = alc883_3ST_2ch_modes,
+                .input_mux = &alc883_capture_source,
+                .unsol_event = alc_automute_amp_unsol_event,
+                .setup = alc883_acer_aspire_setup,
+                .init_hook = alc_automute_amp,
+        },
+        [ALC888_ACER_ASPIRE_4930G] = {
+                .mixers = { alc888_base_mixer,
+                                alc883_chmode_mixer },
+                .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
+                                alc888_acer_aspire_4930g_verbs },
+                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
+                .dac_nids = alc883_dac_nids,
+                .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
+                .adc_nids = alc883_adc_nids_rev,
+                .capsrc_nids = alc883_capsrc_nids_rev,
+                .dig_out_nid = ALC883_DIGOUT_NID,
+                .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
+                .channel_mode = alc883_3ST_6ch_modes,
+                .need_dac_fix = 1,
+                .num_mux_defs =
+                        ARRAY_SIZE(alc888_2_capture_sources),
+                .input_mux = alc888_2_capture_sources,
+                .unsol_event = alc_automute_amp_unsol_event,
+                .setup = alc888_acer_aspire_4930g_setup,
+                .init_hook = alc_automute_amp,
+        },
+        [ALC888_ACER_ASPIRE_6530G] = {
+                .mixers = { alc888_acer_aspire_6530_mixer },
+                .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
+                                alc888_acer_aspire_6530g_verbs },
+                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
+                .dac_nids = alc883_dac_nids,
+                .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
+                .adc_nids = alc883_adc_nids_rev,
+                .capsrc_nids = alc883_capsrc_nids_rev,
+                .dig_out_nid = ALC883_DIGOUT_NID,
+                .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
+                .channel_mode = alc883_3ST_2ch_modes,
+                .num_mux_defs =
+                        ARRAY_SIZE(alc888_2_capture_sources),
+                .input_mux = alc888_acer_aspire_6530_sources,
+                .unsol_event = alc_automute_amp_unsol_event,
+                .setup = alc888_acer_aspire_6530g_setup,
+                .init_hook = alc_automute_amp,
+        },
+        [ALC888_ACER_ASPIRE_8930G] = {
+                .mixers = { alc888_base_mixer,
+                                alc883_chmode_mixer },
+                .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
+                                alc889_acer_aspire_8930g_verbs },
+                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
+                .dac_nids = alc883_dac_nids,
+                .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
+                .adc_nids = alc889_adc_nids,
+                .capsrc_nids = alc889_capsrc_nids,
+                .dig_out_nid = ALC883_DIGOUT_NID,
+                .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
+                .channel_mode = alc883_3ST_6ch_modes,
+                .need_dac_fix = 1,
+                .const_channel_count = 6,
+                .num_mux_defs =
+                        ARRAY_SIZE(alc889_capture_sources),
+                .input_mux = alc889_capture_sources,
+                .unsol_event = alc_automute_amp_unsol_event,
+                .setup = alc889_acer_aspire_8930g_setup,
+                .init_hook = alc_automute_amp,
+        },
+        [ALC888_ACER_ASPIRE_7730G] = {
+                .mixers = { alc883_3ST_6ch_mixer,
+                                alc883_chmode_mixer },
+                .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
+                                alc888_acer_aspire_7730G_verbs },
+                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
+                .dac_nids = alc883_dac_nids,
+                .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
+                .adc_nids = alc883_adc_nids_rev,
+                .capsrc_nids = alc883_capsrc_nids_rev,
+                .dig_out_nid = ALC883_DIGOUT_NID,
+                .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
+                .channel_mode = alc883_3ST_6ch_modes,
+                .need_dac_fix = 1,
+                .const_channel_count = 6,
+                .input_mux = &alc883_capture_source,
+                .unsol_event = alc_automute_amp_unsol_event,
+                .setup = alc888_acer_aspire_6530g_setup,
+                .init_hook = alc_automute_amp,
+        },
+        [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,
+                .adc_nids = alc883_adc_nids_alt,
+                .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
+                .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
+                .channel_mode = alc883_sixstack_modes,
+                .input_mux = &alc883_capture_source,
+        },
+        [ALC883_MEDION_MD2] = {
+                .mixers = { alc883_medion_md2_mixer},
+                .init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs},
+                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
+                .dac_nids = alc883_dac_nids,
+                .dig_out_nid = ALC883_DIGOUT_NID,
+                .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
+                .channel_mode = alc883_3ST_2ch_modes,
+                .input_mux = &alc883_capture_source,
+                .unsol_event = alc_automute_amp_unsol_event,
+                .setup = alc883_medion_md2_setup,
+                .init_hook = alc_automute_amp,
+        },
+        [ALC883_LAPTOP_EAPD] = {
+                .mixers = { alc883_base_mixer },
+                .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
+                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
+                .dac_nids = alc883_dac_nids,
+                .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
+                .channel_mode = alc883_3ST_2ch_modes,
+                .input_mux = &alc883_capture_source,
+        },
+        [ALC883_CLEVO_M720] = {
+                .mixers = { alc883_clevo_m720_mixer },
+                .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
+                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
+                .dac_nids = alc883_dac_nids,
+                .dig_out_nid = ALC883_DIGOUT_NID,
+                .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
+                .channel_mode = alc883_3ST_2ch_modes,
+                .input_mux = &alc883_capture_source,
+                .unsol_event = alc883_clevo_m720_unsol_event,
+                .setup = alc883_clevo_m720_setup,
+                .init_hook = alc883_clevo_m720_init_hook,
+        },
+        [ALC883_LENOVO_101E_2ch] = {
+                .mixers = { alc883_lenovo_101e_2ch_mixer},
+                .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
+                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
+                .dac_nids = alc883_dac_nids,
+                .adc_nids = alc883_adc_nids_alt,
+                .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
+                .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
+                .channel_mode = alc883_3ST_2ch_modes,
+                .input_mux = &alc883_lenovo_101e_capture_source,
+                .unsol_event = alc883_lenovo_101e_unsol_event,
+                .init_hook = alc883_lenovo_101e_all_automute,
+        },
+        [ALC883_LENOVO_NB0763] = {
+                .mixers = { alc883_lenovo_nb0763_mixer },
+                .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
+                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
+                .dac_nids = alc883_dac_nids,
+                .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
+                .channel_mode = alc883_3ST_2ch_modes,
+                .need_dac_fix = 1,
+                .input_mux = &alc883_lenovo_nb0763_capture_source,
+                .unsol_event = alc_automute_amp_unsol_event,
+                .setup = alc883_medion_md2_setup,
+                .init_hook = alc_automute_amp,
+        },
+        [ALC888_LENOVO_MS7195_DIG] = {
+                .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
+                .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
+                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
+                .dac_nids = alc883_dac_nids,
+                .dig_out_nid = ALC883_DIGOUT_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,
+                .unsol_event = alc883_lenovo_ms7195_unsol_event,
+                .init_hook = alc888_lenovo_ms7195_front_automute,
+        },
+        [ALC883_HAIER_W66] = {
+                .mixers = { alc883_targa_2ch_mixer},
+                .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
+                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
+                .dac_nids = alc883_dac_nids,
+                .dig_out_nid = ALC883_DIGOUT_NID,
+                .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
+                .channel_mode = alc883_3ST_2ch_modes,
+                .input_mux = &alc883_capture_source,
+                .unsol_event = alc_automute_amp_unsol_event,
+                .setup = alc883_haier_w66_setup,
+                .init_hook = alc_automute_amp,
+        },
+        [ALC888_3ST_HP] = {
+                .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
+                .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
+                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
+                .dac_nids = alc883_dac_nids,
+                .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
+                .channel_mode = alc888_3st_hp_modes,
+                .need_dac_fix = 1,
+                .input_mux = &alc883_capture_source,
+                .unsol_event = alc_automute_amp_unsol_event,
+                .setup = alc888_3st_hp_setup,
+                .init_hook = alc_automute_amp,
+        },
+        [ALC888_6ST_DELL] = {
+                .mixers = { alc883_base_mixer, alc883_chmode_mixer },
+                .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
+                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
+                .dac_nids = alc883_dac_nids,
+                .dig_out_nid = ALC883_DIGOUT_NID,
+                .dig_in_nid = ALC883_DIGIN_NID,
+                .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
+                .channel_mode = alc883_sixstack_modes,
+                .input_mux = &alc883_capture_source,
+                .unsol_event = alc_automute_amp_unsol_event,
+                .setup = alc888_6st_dell_setup,
+                .init_hook = alc_automute_amp,
+        },
+        [ALC883_MITAC] = {
+                .mixers = { alc883_mitac_mixer },
+                .init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
+                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
+                .dac_nids = alc883_dac_nids,
+                .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
+                .channel_mode = alc883_3ST_2ch_modes,
+                .input_mux = &alc883_capture_source,
+                .unsol_event = alc_automute_amp_unsol_event,
+                .setup = alc883_mitac_setup,
+                .init_hook = alc_automute_amp,
+        },
+        [ALC883_FUJITSU_PI2515] = {
+                .mixers = { alc883_2ch_fujitsu_pi2515_mixer },
+                .init_verbs = { alc883_init_verbs,
+                                alc883_2ch_fujitsu_pi2515_verbs},
+                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
+                .dac_nids = alc883_dac_nids,
+                .dig_out_nid = ALC883_DIGOUT_NID,
+                .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
+                .channel_mode = alc883_3ST_2ch_modes,
+                .input_mux = &alc883_fujitsu_pi2515_capture_source,
+                .unsol_event = alc_automute_amp_unsol_event,
+                .setup = alc883_2ch_fujitsu_pi2515_setup,
+                .init_hook = alc_automute_amp,
+        },
+        [ALC888_FUJITSU_XA3530] = {
+                .mixers = { alc888_base_mixer, alc883_chmode_mixer },
+                .init_verbs = { alc883_init_verbs,
+                        alc888_fujitsu_xa3530_verbs },
+                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
+                .dac_nids = alc883_dac_nids,
+                .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
+                .adc_nids = alc883_adc_nids_rev,
+                .capsrc_nids = alc883_capsrc_nids_rev,
+                .dig_out_nid = ALC883_DIGOUT_NID,
+                .num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes),
+                .channel_mode = alc888_4ST_8ch_intel_modes,
+                .num_mux_defs =
+                        ARRAY_SIZE(alc888_2_capture_sources),
+                .input_mux = alc888_2_capture_sources,
+                .unsol_event = alc_automute_amp_unsol_event,
+                .setup = alc888_fujitsu_xa3530_setup,
+                .init_hook = alc_automute_amp,
+        },
+        [ALC888_LENOVO_SKY] = {
+                .mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
+                .init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
+                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
+                .dac_nids = alc883_dac_nids,
+                .dig_out_nid = ALC883_DIGOUT_NID,
+                .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
+                .channel_mode = alc883_sixstack_modes,
+                .need_dac_fix = 1,
+                .input_mux = &alc883_lenovo_sky_capture_source,
+                .unsol_event = alc_automute_amp_unsol_event,
+                .setup = alc888_lenovo_sky_setup,
+                .init_hook = alc_automute_amp,
+        },
+        [ALC888_ASUS_M90V] = {
+                .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
+                .init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
+                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
+                .dac_nids = alc883_dac_nids,
+                .dig_out_nid = ALC883_DIGOUT_NID,
+                .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_fujitsu_pi2515_capture_source,
+                .unsol_event = alc_sku_unsol_event,
+                .setup = alc883_mode2_setup,
+                .init_hook = alc_inithook,
+        },
+        [ALC888_ASUS_EEE1601] = {
+                .mixers = { alc883_asus_eee1601_mixer },
+                .cap_mixer = alc883_asus_eee1601_cap_mixer,
+                .init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
+                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
+                .dac_nids = alc883_dac_nids,
+                .dig_out_nid = ALC883_DIGOUT_NID,
+                .dig_in_nid = ALC883_DIGIN_NID,
+                .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
+                .channel_mode = alc883_3ST_2ch_modes,
+                .need_dac_fix = 1,
+                .input_mux = &alc883_asus_eee1601_capture_source,
+                .unsol_event = alc_sku_unsol_event,
+                .init_hook = alc883_eee1601_inithook,
+        },
+        [ALC1200_ASUS_P5Q] = {
+                .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 = ALC1200_DIGOUT_NID,
+                .dig_in_nid = ALC883_DIGIN_NID,
+                .slave_dig_outs = alc1200_slave_dig_outs,
+                .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
+                .channel_mode = alc883_sixstack_modes,
+                .input_mux = &alc883_capture_source,
+        },
+        [ALC889A_MB31] = {
+                .mixers = { alc889A_mb31_mixer, alc883_chmode_mixer},
+                .init_verbs = { alc883_init_verbs, alc889A_mb31_verbs,
+                        alc880_gpio1_init_verbs },
+                .adc_nids = alc883_adc_nids,
+                .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
+                .dac_nids = alc883_dac_nids,
+                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
+                .channel_mode = alc889A_mb31_6ch_modes,
+                .num_channel_mode = ARRAY_SIZE(alc889A_mb31_6ch_modes),
+                .input_mux = &alc889A_mb31_capture_source,
+                .dig_out_nid = ALC883_DIGOUT_NID,
+                .unsol_event = alc889A_mb31_unsol_event,
+                .init_hook = alc889A_mb31_automute,
+        },
+        [ALC883_SONY_VAIO_TT] = {
+                .mixers = { alc883_vaiott_mixer },
+                .init_verbs = { alc883_init_verbs, alc883_vaiott_verbs },
+                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
+                .dac_nids = alc883_dac_nids,
+                .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
+                .channel_mode = alc883_3ST_2ch_modes,
+                .input_mux = &alc883_capture_source,
+                .unsol_event = alc_automute_amp_unsol_event,
+                .setup = alc883_vaiott_setup,
+                .init_hook = alc_automute_amp,
+        },
 };
 
@@ -6987 +9508 @@
  * BIOS auto configuration
  */
+static int alc882_auto_create_input_ctls(struct hda_codec *codec,
+                                                const struct auto_pin_cfg *cfg)
+{
+        return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x23, 0x22);
+}
+
 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
                                               hda_nid_t nid, int pin_type,
@@ -7009 +9536 @@
         int i;
 
-        alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
         for (i = 0; i <= HDA_SIDE; i++) {
                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
@@ -7033 +9559 @@
 }
 
-#define alc882_is_input_pin(nid)        alc880_is_input_pin(nid)
-#define ALC882_PIN_CD_NID               ALC880_PIN_CD_NID
-
 static void alc882_auto_init_analog_input(struct hda_codec *codec)
 {
@@ -7045 +9568 @@
                 if (!nid)
                         continue;
-                alc_set_input_pin(codec, nid, AUTO_PIN_FRONT_MIC /*i*/);
+                alc_set_input_pin(codec, nid, i);
                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
                         snd_hda_codec_write(codec, nid, 0,
@@ -7131 +9654 @@
 {
         struct alc_spec *spec = codec->spec;
-        int err = alc880_parse_auto_config(codec);
-
+        static hda_nid_t alc882_ignore[] = { 0x1d, 0 };
+        int i, err;
+
+        err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
+                                           alc882_ignore);
         if (err < 0)
                 return err;
-        else if (!err)
-                return 0; /* no config found */
+        if (!spec->autocfg.line_outs)
+                return 0; /* can't find valid BIOS pin config */
+
+        err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
+        if (err < 0)
+                return err;
+        err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
+        if (err < 0)
+                return err;
+        err = alc880_auto_create_extra_out(spec,
+                                           spec->autocfg.speaker_pins[0],
+                                           "Speaker");
+        if (err < 0)
+                return err;
+        err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
+                                           "Headphone");
+        if (err < 0)
+                return err;
+        err = alc882_auto_create_input_ctls(codec, &spec->autocfg);
+        if (err < 0)
+                return err;
+
+        spec->multiout.max_channels = spec->multiout.num_dacs * 2;
+
+        /* check multiple SPDIF-out (for recent codecs) */
+        for (i = 0; i < spec->autocfg.dig_outs; i++) {
+                hda_nid_t dig_nid;
+                err = snd_hda_get_connections(codec,
+                                              spec->autocfg.dig_out_pins[i],
+                                              &dig_nid, 1);
+                if (err < 0)
+                        continue;
+                if (!i)
+                        spec->multiout.dig_out_nid = dig_nid;
+                else {
+                        spec->multiout.slave_dig_outs = spec->slave_dig_outs;
+                        spec->slave_dig_outs[i - 1] = dig_nid;
+                        if (i == ARRAY_SIZE(spec->slave_dig_outs) - 1)
+                                break;
+                }
+        }
+        if (spec->autocfg.dig_in_pin)
+                spec->dig_in_nid = ALC880_DIGIN_NID;
+
+        if (spec->kctls.list)
+                add_mixer(spec, spec->kctls.list);
+
+        add_verb(spec, alc883_auto_init_verbs);
+        /* if ADC 0x07 is available, initialize it, too */
+        if (get_wcaps_type(get_wcaps(codec, 0x07)) == AC_WID_AUD_IN)
+                add_verb(spec, alc882_adc1_init_verbs);
+
+        spec->num_mux_defs = 1;
+        spec->input_mux = &spec->private_imux[0];
+
+        alc_ssid_check(codec, 0x15, 0x1b, 0x14);
 
         err = alc_auto_add_mic_boost(codec);
         if (err < 0)
                 return err;
-
-        /* hack - override the init verbs */
-        spec->init_verbs[0] = alc882_auto_init_verbs;
 
         return 1; /* config found */
@@ -7160 +9737 @@
 }
 
-static int patch_alc883(struct hda_codec *codec); /* called in patch_alc882() */
-
 static int patch_alc882(struct hda_codec *codec)
 {
@@ -7173 +9748 @@
         codec->spec = spec;
 
+        switch (codec->vendor_id) {
+        case 0x10ec0882:
+        case 0x10ec0885:
+                break;
+        default:
+                /* ALC883 and variants */
+                alc_fix_pll_init(codec, 0x20, 0x0a, 10);
+                break;
+        }
+
         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)
+                board_config = snd_hda_check_board_codec_sid_config(codec,
+                        ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
+
         if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
-                /* Pick up systems that don't supply PCI SSID */
-                switch (codec->subsystem_id) {
-                case 0x106b0c00: /* Mac Pro */
-                        board_config = ALC885_MACPRO;
-                        break;
-                case 0x106b1000: /* iMac 24 */
-                case 0x106b2800: /* AppleTV */
-                case 0x106b3e00: /* iMac 24 Aluminium */
-                        board_config = ALC885_IMAC24;
-                        break;
-                case 0x106b00a0: /* MacBookPro3,1 - Another revision */
-                case 0x106b00a1: /* Macbook (might be wrong - PCI SSID?) */
-                case 0x106b00a4: /* MacbookPro4,1 */
-                case 0x106b2c00: /* Macbook Pro rev3 */
-                case 0x106b3600: /* Macbook 3.1 */
-                case 0x106b3800: /* MacbookPro4,1 - latter revision */
-                        board_config = ALC885_MBP3;
-                        break;
-                default:
-                        /* ALC889A is handled better as ALC888-compatible */
-                        if (codec->revision_id == 0x100101 ||
-                            codec->revision_id == 0x100103) {
-                                alc_free(codec);
-                                return patch_alc883(codec);
-                        }
-                        printk(KERN_INFO "hda_codec: Unknown model for ALC882, "
-                                         "trying auto-probe from BIOS...\n");
-                        board_config = ALC882_AUTO;
-                }
+                printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
+                       codec->chip_name);
+                board_config = ALC882_AUTO;
         }
 
@@ -7232 +9795 @@
 
         if (board_config != ALC882_AUTO)
-                setup_preset(spec, &alc882_presets[board_config]);
-
-        if (codec->vendor_id == 0x10ec0885) {
-                spec->stream_name_analog = "ALC885 Analog";
-                spec->stream_name_digital = "ALC885 Digital";
-        } else {
-                spec->stream_name_analog = "ALC882 Analog";
-                spec->stream_name_digital = "ALC882 Digital";
-        }
+                setup_preset(codec, &alc882_presets[board_config]);
 
         spec->stream_analog_playback = &alc882_pcm_analog_playback;
@@ -7251 +9806 @@
         spec->stream_digital_capture = &alc882_pcm_digital_capture;
 
-        spec->capture_style = CAPT_MIX; /* matrix-style capture */
+        if (codec->vendor_id == 0x10ec0888)
+                spec->init_amp = ALC_INIT_DEFAULT; /* always initialize */
+
         if (!spec->adc_nids && spec->input_mux) {
-                /* check whether NID 0x07 is valid */
-                unsigned int wcap = get_wcaps(codec, 0x07);
-                /* get type */
-                wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
-                if (wcap != AC_WID_AUD_IN) {
-                        spec->adc_nids = alc882_adc_nids_alt;
-                        spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids_alt);
-                        spec->capsrc_nids = alc882_capsrc_nids_alt;
-                } else {
-                        spec->adc_nids = alc882_adc_nids;
-                        spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids);
-                        spec->capsrc_nids = alc882_capsrc_nids;
+                int i;
+                spec->num_adc_nids = 0;
+                for (i = 0; i < ARRAY_SIZE(alc882_adc_nids); i++) {
+                        hda_nid_t cap;
+                        hda_nid_t nid = alc882_adc_nids[i];
+                        unsigned int wcap = get_wcaps(codec, nid);
+                        /* get type */
+                        wcap = get_wcaps_type(wcap);
+                        if (wcap != AC_WID_AUD_IN)
+                                continue;
+                        spec->private_adc_nids[spec->num_adc_nids] = nid;
+                        err = snd_hda_get_connections(codec, nid, &cap, 1);
+                        if (err < 0)
+                                continue;
+                        spec->private_capsrc_nids[spec->num_adc_nids] = cap;
+                        spec->num_adc_nids++;
                 }
+                spec->adc_nids = spec->private_adc_nids;
+                spec->capsrc_nids = spec->private_capsrc_nids;
         }
-        set_capture_mixer(spec);
+
+        set_capture_mixer(codec);
         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
 
@@ -7284 +9848 @@
 }
 
-/*
- * ALC883 support
- *
- * ALC883 is almost identical with ALC880 but has cleaner and more flexible
- * configuration.  Each pin widget can choose any input DACs and a mixer.
- * Each ADC is connected from a mixer of all inputs.  This makes possible
- * 6-channel independent captures.
- *
- * In addition, an independent DAC for the multi-playback (not used in this
- * driver yet).
- */
-#define ALC883_DIGOUT_NID       0x06
-#define ALC883_DIGIN_NID        0x0a
-
-#define ALC1200_DIGOUT_NID      0x10
-
-static hda_nid_t alc883_dac_nids[4] = {
-        /* front, rear, clfe, rear_surr */
-        0x02, 0x03, 0x04, 0x05
-};
-
-static hda_nid_t alc883_adc_nids[2] = {
-        /* ADC1-2 */
-        0x08, 0x09,
-};
-
-static hda_nid_t alc883_adc_nids_alt[1] = {
-        /* ADC1 */
-        0x08,
-};
-
-static hda_nid_t alc883_adc_nids_rev[2] = {
-        /* ADC2-1 */
-        0x09, 0x08
-};
-
-#define alc889_adc_nids         alc880_adc_nids
-
-static hda_nid_t alc883_capsrc_nids[2] = { 0x23, 0x22 };
-
-static hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 };
-
-#define alc889_capsrc_nids      alc882_capsrc_nids
-
-/* input MUX */
-/* FIXME: should be a matrix-type input source selection */
-
-static struct hda_input_mux alc883_capture_source = {
-        .num_items = 4,
-        .items = {
-                { "Mic", 0x0 },
-                { "Front Mic", 0x1 },
-                { "Line", 0x2 },
-                { "CD", 0x4 },
-        },
-};
-
-static struct hda_input_mux alc883_3stack_6ch_intel = {
-        .num_items = 4,
-        .items = {
-                { "Mic", 0x1 },
-                { "Front Mic", 0x0 },
-                { "Line", 0x2 },
-                { "CD", 0x4 },
-        },
-};
-
-static struct hda_input_mux alc883_lenovo_101e_capture_source = {
-        .num_items = 2,
-        .items = {
-                { "Mic", 0x1 },
-                { "Line", 0x2 },
-        },
-};
-
-static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
-        .num_items = 4,
-        .items = {
-                { "Mic", 0x0 },
-                { "iMic", 0x1 },
-                { "Line", 0x2 },
-                { "CD", 0x4 },
-        },
-};
-
-static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
-        .num_items = 2,
-        .items = {
-                { "Mic", 0x0 },
-                { "Int Mic", 0x1 },
-        },
-};
-
-static struct hda_input_mux alc883_lenovo_sky_capture_source = {
-        .num_items = 3,
-        .items = {
-                { "Mic", 0x0 },
-                { "Front Mic", 0x1 },
-                { "Line", 0x4 },
-        },
-};
-
-static struct hda_input_mux alc883_asus_eee1601_capture_source = {
-        .num_items = 2,
-        .items = {
-                { "Mic", 0x0 },
-                { "Line", 0x2 },
-        },
-};
-
-/*
- * 2ch mode
- */
-static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
-        { 2, NULL }
-};
-
-/*
- * 2ch mode
- */
-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 */
-};
-
-/*
- * 4ch mode
- */
-static struct hda_verb alc883_3ST_ch4_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_OUT },
-        { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
-        { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
-        {0} /* end */
-};
-
-/*
- * 6ch mode
- */
-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 */
-};
-
-static struct hda_channel_mode alc883_3ST_6ch_modes[3] = {
-        { 2, alc883_3ST_ch2_init },
-        { 4, alc883_3ST_ch4_init },
-        { 6, alc883_3ST_ch6_init },
-};
-
-/*
- * 2ch mode
- */
-static struct hda_verb alc883_3ST_ch2_intel_init[] = {
-        { 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 },
-        {0} /* end */
-};
-
-/*
- * 4ch mode
- */
-static struct hda_verb alc883_3ST_ch4_intel_init[] = {
-        { 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 },
-        { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
-        {0} /* end */
-};
-
-/*
- * 6ch mode
- */
-static struct hda_verb alc883_3ST_ch6_intel_init[] = {
-        { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
-        { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
-        { 0x19, 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_intel_modes[3] = {
-        { 2, alc883_3ST_ch2_intel_init },
-        { 4, alc883_3ST_ch4_intel_init },
-        { 6, alc883_3ST_ch6_intel_init },
-};
-
-/*
- * 6ch mode
- */
-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 */
-};
-
-/*
- * 8ch mode
- */
-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 */
-};
-
-static struct hda_channel_mode alc883_sixstack_modes[2] = {
-        { 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}
-};
-
-/* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
- *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
- */
-
-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_VOLUME("Mic Boost", 0x18, 0, 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_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
-        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
-        {0} /* end */
-};
-
-static struct snd_kcontrol_new alc883_mitac_mixer[] = {
-        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
-        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 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", 0x15, 0x0, HDA_OUTPUT),
-        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
-        HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, 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_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
-        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
-        {0} /* end */
-};
-
-static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
-        HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
-        HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
-        HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
-        HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
-        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
-        HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
-        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
-        HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
-        HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
-        HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
-        {0} /* end */
-};
-
-static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
-        HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
-        HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
-        HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
-        HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
-        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
-        HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
-        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
-        HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
-        HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
-        HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
-        {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_VOLUME("Mic Boost", 0x18, 0, 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_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
-        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
-        {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_VOLUME("Mic Boost", 0x18, 0, 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_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
-        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
-        {0} /* end */
-};
-
-static struct snd_kcontrol_new alc883_3ST_6ch_intel_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", 0x15, 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, 0x1, HDA_INPUT),
-        HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
-        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
-        HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
-        HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
-        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
-        {0} /* end */
-};
-
-static struct snd_kcontrol_new alc883_fivestack_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_VOLUME("Mic Boost", 0x18, 0, 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_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
-        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
-        {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_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
-        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
-        {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_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
-        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
-        HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
-        HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
-        HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
-        {0} /* end */
-};
-
-static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
-        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
-        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
-        HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
-        HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
-        HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
-        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
-        HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
-        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
-        {0} /* end */
-};
-
-static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
-        HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
-        HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
-        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("iMic Playback Volume", 0x0b, 0x1, HDA_INPUT),
-        HDA_CODEC_MUTE("iMic Playback Switch", 0x0b, 0x1, HDA_INPUT),
-        {0} /* end */
-};
-
-static struct snd_kcontrol_new alc883_medion_md2_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", 0x15, 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("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
-        HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
-        {0} /* end */
-};
-
-static struct snd_kcontrol_new alc883_acer_aspire_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", 0x14, 0x0, HDA_OUTPUT),
-        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_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
-        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
-        {0} /* end */
-};
-
-static struct snd_kcontrol_new alc888_lenovo_sky_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", 0x0e, 0x0, HDA_OUTPUT),
-        HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 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("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_MUTE("iSpeaker Playback Switch", 0x1a, 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_VOLUME("Mic Boost", 0x18, 0, 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_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
-        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
-        {0} /* end */
-};
-
-static struct hda_bind_ctls alc883_bind_cap_vol = {
-        .ops = &snd_hda_bind_vol,
-        .values = {
-                HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
-                HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
-                0
-        },
-};
-
-static struct hda_bind_ctls alc883_bind_cap_switch = {
-        .ops = &snd_hda_bind_sw,
-        .values = {
-                HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
-                HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
-                0
-        },
-};
-
-static struct snd_kcontrol_new alc883_asus_eee1601_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", 0x14, 0x0, HDA_OUTPUT),
-        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_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
-        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
-        {0} /* end */
-};
-
-static struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = {
-        HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
-        HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
-        {
-                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-                /* .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 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 */
-};
-
-static struct hda_verb alc883_init_verbs[] = {
-        /* ADC1: mute amp left and right */
-        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(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)},
-
-        /* mute analog input loopbacks */
-        {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)},
-
-        /* 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_MUTE(1)},
-        {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(1)},
-        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
-        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
-        {0}
-};
-
-/* toggle speaker-output according to the hp-jack state */
-static void alc883_mitac_hp_automute(struct hda_codec *codec)
-{
-        unsigned int present;
-
-        present = snd_hda_codec_read(codec, 0x15, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-        snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
-                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
-        snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
-                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
-}
-
-/* auto-toggle front mic */
-/*
-static void alc883_mitac_mic_automute(struct hda_codec *codec)
-{
-        unsigned int present;
-        unsigned char bits;
-
-        present = snd_hda_codec_read(codec, 0x18, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-        bits = present ? HDA_AMP_MUTE : 0;
-        snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
-}
-*/
-
-static void alc883_mitac_automute(struct hda_codec *codec)
-{
-        alc883_mitac_hp_automute(codec);
-        /* alc883_mitac_mic_automute(codec); */
-}
-
-static void alc883_mitac_unsol_event(struct hda_codec *codec,
-                                           unsigned int res)
-{
-        switch (res >> 26) {
-        case ALC880_HP_EVENT:
-                alc883_mitac_hp_automute(codec);
-                break;
-        case ALC880_MIC_EVENT:
-                /* alc883_mitac_mic_automute(codec); */
-                break;
-        }
-}
-
-static struct hda_verb alc883_mitac_verbs[] = {
-        /* HP */
-        {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
-        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
-        /* Subwoofer */
-        {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
-        {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-
-        /* enable unsolicited event */
-        {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
-        /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
-
-        {0} /* end */
-};
-
-static struct hda_verb alc883_clevo_m720_verbs[] = {
-        /* HP */
-        {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
-        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
-        /* Int speaker */
-        {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
-        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-
-        /* enable unsolicited event */
-        {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
-        {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
-
-        {0} /* end */
-};
-
-static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
-        /* HP */
-        {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
-        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
-        /* Subwoofer */
-        {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
-        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-
-        /* enable unsolicited event */
-        {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
-
-        {0} /* end */
-};
-
-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 */
-};
-
-static struct hda_verb alc883_lenovo_101e_verbs[] = {
-        {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
-        {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
-        {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
-        {0} /* end */
-};
-
-static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
-        {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
-        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
-        {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
-        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
-        {0} /* end */
-};
-
-static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
-        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-        {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
-        {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
-        {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
-        {0} /* end */
-};
-
-static struct hda_verb alc883_haier_w66_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_OUT},
-
-        {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
-        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
-        {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
-        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
-        {0} /* end */
-};
-
-static struct hda_verb alc888_lenovo_sky_verbs[] = {
-        {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)},
-        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-        {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
-        {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
-        {0} /* end */
-};
-
-static struct hda_verb alc888_6st_dell_verbs[] = {
-        {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
-        {0}
-};
-
-static void alc888_3st_hp_front_automute(struct hda_codec *codec)
-{
-        unsigned int present, bits;
-
-        present = snd_hda_codec_read(codec, 0x1b, 0,
-                        AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-        bits = present ? HDA_AMP_MUTE : 0;
-        snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
-                                 HDA_AMP_MUTE, bits);
-        snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
-                                 HDA_AMP_MUTE, bits);
-        snd_hda_codec_amp_stereo(codec, 0x18, HDA_OUTPUT, 0,
-                                 HDA_AMP_MUTE, bits);
-}
-
-static void alc888_3st_hp_unsol_event(struct hda_codec *codec,
-                                      unsigned int res)
-{
-        switch (res >> 26) {
-        case ALC880_HP_EVENT:
-                alc888_3st_hp_front_automute(codec);
-                break;
-        }
-}
-
-static struct hda_verb alc888_3st_hp_verbs[] = {
-        {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Front: output 0 (0x0c) */
-        {0x16, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Rear : output 1 (0x0d) */
-        {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},  /* CLFE : output 2 (0x0e) */
-        {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
-        {0} /* end */
-};
-
-/*
- * 2ch mode
- */
-static struct hda_verb alc888_3st_hp_2ch_init[] = {
-        { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
-        { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
-        { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
-        { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
-        {0} /* end */
-};
-
-/*
- * 4ch mode
- */
-static struct hda_verb alc888_3st_hp_4ch_init[] = {
-        { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
-        { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
-        { 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, 0x01 },
-        {0} /* end */
-};
-
-/*
- * 6ch mode
- */
-static struct hda_verb alc888_3st_hp_6ch_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 },
-        { 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, 0x01 },
-        {0} /* end */
-};
-
-static struct hda_channel_mode alc888_3st_hp_modes[3] = {
-        { 2, alc888_3st_hp_2ch_init },
-        { 4, alc888_3st_hp_4ch_init },
-        { 6, alc888_3st_hp_6ch_init },
-};
-
-/* toggle front-jack and RCA according to the hp-jack state */
-static void alc888_lenovo_ms7195_front_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_stereo(codec, 0x14, HDA_OUTPUT, 0,
-                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
-        snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
-                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
-}
-
-/* toggle RCA according to the front-jack state */
-static void alc888_lenovo_ms7195_rca_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_stereo(codec, 0x15, HDA_OUTPUT, 0,
-                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
-}
-
-static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
-                                             unsigned int res)
-{
-        if ((res >> 26) == ALC880_HP_EVENT)
-                alc888_lenovo_ms7195_front_automute(codec);
-        if ((res >> 26) == ALC880_FRONT_EVENT)
-                alc888_lenovo_ms7195_rca_automute(codec);
-}
-
-static struct hda_verb alc883_medion_md2_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},
-
-        {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
-        {0} /* end */
-};
-
-/* toggle speaker-output according to the hp-jack state */
-static void alc883_medion_md2_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_stereo(codec, 0x15, HDA_OUTPUT, 0,
-                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
-}
-
-static void alc883_medion_md2_unsol_event(struct hda_codec *codec,
-                                          unsigned int res)
-{
-        if ((res >> 26) == ALC880_HP_EVENT)
-                alc883_medion_md2_automute(codec);
-}
-
-/* toggle speaker-output according to the hp-jack state */
-static void alc883_tagra_automute(struct hda_codec *codec)
-{
-        unsigned int present;
-        unsigned char bits;
-
-        present = snd_hda_codec_read(codec, 0x14, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-        bits = present ? HDA_AMP_MUTE : 0;
-        snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
-                                 HDA_AMP_MUTE, bits);
-        snd_hda_codec_write_cache(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);
-}
-
-/* toggle speaker-output according to the hp-jack state */
-static void alc883_clevo_m720_hp_automute(struct hda_codec *codec)
-{
-        unsigned int present;
-        unsigned char bits;
-
-        present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0)
-                & AC_PINSENSE_PRESENCE;
-        bits = present ? HDA_AMP_MUTE : 0;
-        snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
-                                 HDA_AMP_MUTE, bits);
-}
-
-static void alc883_clevo_m720_mic_automute(struct hda_codec *codec)
-{
-        unsigned int present;
-
-        present = snd_hda_codec_read(codec, 0x18, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-        snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
-                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
-}
-
-static void alc883_clevo_m720_automute(struct hda_codec *codec)
-{
-        alc883_clevo_m720_hp_automute(codec);
-        alc883_clevo_m720_mic_automute(codec);
-}
-
-static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
-                                           unsigned int res)
-{
-        switch (res >> 26) {
-        case ALC880_HP_EVENT:
-                alc883_clevo_m720_hp_automute(codec);
-                break;
-        case ALC880_MIC_EVENT:
-                alc883_clevo_m720_mic_automute(codec);
-                break;
-        }
-}
-
-/* toggle speaker-output according to the hp-jack state */
-static void alc883_2ch_fujitsu_pi2515_automute(struct hda_codec *codec)
-{
-        unsigned int present;
-        unsigned char bits;
-
-        present = snd_hda_codec_read(codec, 0x14, 0, AC_VERB_GET_PIN_SENSE, 0)
-                & AC_PINSENSE_PRESENCE;
-        bits = present ? HDA_AMP_MUTE : 0;
-        snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
-                                 HDA_AMP_MUTE, bits);
-}
-
-static void alc883_2ch_fujitsu_pi2515_unsol_event(struct hda_codec *codec,
-                                                  unsigned int res)
-{
-        if ((res >> 26) == ALC880_HP_EVENT)
-                alc883_2ch_fujitsu_pi2515_automute(codec);
-}
-
-static void alc883_haier_w66_automute(struct hda_codec *codec)
-{
-        unsigned int present;
-        unsigned char bits;
-
-        present = snd_hda_codec_read(codec, 0x1b, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-        bits = present ? 0x80 : 0;
-        snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
-                                 0x80, bits);
-}
-
-static void alc883_haier_w66_unsol_event(struct hda_codec *codec,
-                                         unsigned int res)
-{
-        if ((res >> 26) == ALC880_HP_EVENT)
-                alc883_haier_w66_automute(codec);
-}
-
-static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
-{
-        unsigned int present;
-        unsigned char bits;
-
-        present = snd_hda_codec_read(codec, 0x14, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-        bits = present ? HDA_AMP_MUTE : 0;
-        snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
-                                 HDA_AMP_MUTE, bits);
-}
-
-static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
-{
-        unsigned int present;
-        unsigned char bits;
-
-        present = snd_hda_codec_read(codec, 0x1b, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-        bits = present ? HDA_AMP_MUTE : 0;
-        snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
-                                 HDA_AMP_MUTE, bits);
-        snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
-                                 HDA_AMP_MUTE, bits);
-}
-
-static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
-                                           unsigned int res)
-{
-        if ((res >> 26) == ALC880_HP_EVENT)
-                alc883_lenovo_101e_all_automute(codec);
-        if ((res >> 26) == ALC880_FRONT_EVENT)
-                alc883_lenovo_101e_ispeaker_automute(codec);
-}
-
-/* toggle speaker-output according to the hp-jack state */
-static void alc883_acer_aspire_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_stereo(codec, 0x15, HDA_OUTPUT, 0,
-                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
-        snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
-                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
-}
-
-static void alc883_acer_aspire_unsol_event(struct hda_codec *codec,
-                                           unsigned int res)
-{
-        if ((res >> 26) == ALC880_HP_EVENT)
-                alc883_acer_aspire_automute(codec);
-}
-
-static struct hda_verb alc883_acer_eapd_verbs[] = {
-        /* HP Pin: output 0 (0x0c) */
-        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
-        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-        {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
-        /* Front Pin: output 0 (0x0c) */
-        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-        {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
-        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-        {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
-        /* eanable EAPD on medion laptop */
-        {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
-        {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
-        /* enable unsolicited event */
-        {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
-        {0}
-};
-
-static void alc888_6st_dell_front_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_stereo(codec, 0x14, HDA_OUTPUT, 0,
-                                HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
-        snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
-                                HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
-        snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
-                                HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
-        snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
-                                HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
-}
-
-static void alc888_6st_dell_unsol_event(struct hda_codec *codec,
-                                             unsigned int res)
-{
-        switch (res >> 26) {
-        case ALC880_HP_EVENT:
-                /* printk(KERN_DEBUG "hp_event\n"); */
-                alc888_6st_dell_front_automute(codec);
-                break;
-        }
-}
-
-static void alc888_lenovo_sky_front_automute(struct hda_codec *codec)
-{
-        unsigned int mute;
-        unsigned int present;
-
-        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);
-        present = (present & 0x80000000) != 0;
-        if (present) {
-                /* mute internal speaker */
-                snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
-                                         HDA_AMP_MUTE, HDA_AMP_MUTE);
-                snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
-                                         HDA_AMP_MUTE, HDA_AMP_MUTE);
-                snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
-                                         HDA_AMP_MUTE, HDA_AMP_MUTE);
-                snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
-                                         HDA_AMP_MUTE, HDA_AMP_MUTE);
-                snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
-                                         HDA_AMP_MUTE, HDA_AMP_MUTE);
-        } else {
-                /* unmute internal speaker if necessary */
-                mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
-                snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
-                                         HDA_AMP_MUTE, mute);
-                snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
-                                         HDA_AMP_MUTE, mute);
-                snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
-                                         HDA_AMP_MUTE, mute);
-                snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
-                                         HDA_AMP_MUTE, mute);
-                snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
-                                         HDA_AMP_MUTE, mute);
-        }
-}
-
-static void alc883_lenovo_sky_unsol_event(struct hda_codec *codec,
-                                             unsigned int res)
-{
-        if ((res >> 26) == ALC880_HP_EVENT)
-                alc888_lenovo_sky_front_automute(codec);
-}
-
-/*
- * generic initialization of ADC, input mixers and output mixers
- */
-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)},
-
-        /* Mute 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_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)},
-
-        /*
-         * 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)}, */
-        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
-
-        {0}
-};
-
-static struct hda_verb alc888_asus_m90v_verbs[] = {
-        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-        /* enable unsolicited event */
-        {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
-        {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
-        {0} /* end */
-};
-
-static void alc883_nb_mic_automute(struct hda_codec *codec)
-{
-        unsigned int present;
-
-        present = snd_hda_codec_read(codec, 0x18, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-        snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
-                            0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
-        snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
-                            0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
-}
-
-static void alc883_M90V_speaker_automute(struct hda_codec *codec)
-{
-        unsigned int present;
-        unsigned char bits;
-
-        present = snd_hda_codec_read(codec, 0x1b, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0)
-                & AC_PINSENSE_PRESENCE;
-        bits = present ? 0 : PIN_OUT;
-        snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
-                            bits);
-        snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
-                            bits);
-        snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
-                            bits);
-}
-
-static void alc883_mode2_unsol_event(struct hda_codec *codec,
-                                           unsigned int res)
-{
-        switch (res >> 26) {
-        case ALC880_HP_EVENT:
-                alc883_M90V_speaker_automute(codec);
-                break;
-        case ALC880_MIC_EVENT:
-                alc883_nb_mic_automute(codec);
-                break;
-        }
-}
-
-static void alc883_mode2_inithook(struct hda_codec *codec)
-{
-        alc883_M90V_speaker_automute(codec);
-        alc883_nb_mic_automute(codec);
-}
-
-static struct hda_verb alc888_asus_eee1601_verbs[] = {
-        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
-        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
-        {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
-        {0x20, AC_VERB_SET_PROC_COEF,  0x0838},
-        /* enable unsolicited event */
-        {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
-        {0} /* end */
-};
-
-static void alc883_eee1601_speaker_automute(struct hda_codec *codec)
-{
-        unsigned int present;
-        unsigned char bits;
-
-        present = snd_hda_codec_read(codec, 0x14, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0)
-                & AC_PINSENSE_PRESENCE;
-        bits = present ? 0 : PIN_OUT;
-        snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
-                            bits);
-}
-
-static void alc883_eee1601_unsol_event(struct hda_codec *codec,
-                                           unsigned int res)
-{
-        switch (res >> 26) {
-        case ALC880_HP_EVENT:
-                alc883_eee1601_speaker_automute(codec);
-                break;
-        }
-}
-
-static void alc883_eee1601_inithook(struct hda_codec *codec)
-{
-        alc883_eee1601_speaker_automute(codec);
-}
-
-#ifdef CONFIG_SND_HDA_POWER_SAVE
-#define alc883_loopbacks        alc880_loopbacks
-#endif
-
-/* pcm configuration: identiacal with ALC880 */
-#define alc883_pcm_analog_playback      alc880_pcm_analog_playback
-#define alc883_pcm_analog_capture       alc880_pcm_analog_capture
-#define alc883_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
-#define alc883_pcm_digital_playback     alc880_pcm_digital_playback
-#define alc883_pcm_digital_capture      alc880_pcm_digital_capture
-
-/*
- * configuration and preset
- */
-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",
-        [ALC883_ACER]           = "acer",
-        [ALC883_ACER_ASPIRE]    = "acer-aspire",
-        [ALC888_ACER_ASPIRE_4930G]      = "acer-aspire-4930g",
-        [ALC883_MEDION]         = "medion",
-        [ALC883_MEDION_MD2]     = "medion-md2",
-        [ALC883_LAPTOP_EAPD]    = "laptop-eapd",
-        [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
-        [ALC883_LENOVO_NB0763]  = "lenovo-nb0763",
-        [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
-        [ALC888_LENOVO_SKY] = "lenovo-sky",
-        [ALC883_HAIER_W66]      = "haier-w66",
-        [ALC888_3ST_HP]         = "3stack-hp",
-        [ALC888_6ST_DELL]       = "6stack-dell",
-        [ALC883_MITAC]          = "mitac",
-        [ALC883_CLEVO_M720]     = "clevo-m720",
-        [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
-        [ALC888_FUJITSU_XA3530] = "fujitsu-xa3530",
-        [ALC883_3ST_6ch_INTEL]  = "3stack-6ch-intel",
-        [ALC1200_ASUS_P5Q]      = "asus-p5q",
-        [ALC883_AUTO]           = "auto",
-};
-
-static struct snd_pci_quirk alc883_cfg_tbl[] = {
-        SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC883_3ST_6ch_DIG),
-        SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
-        SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE),
-        SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_ACER_ASPIRE),
-        SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
-        SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
-        SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
-        SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
-                ALC888_ACER_ASPIRE_4930G),
-        SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
-                ALC888_ACER_ASPIRE_4930G),
-        SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC883_AUTO),
-        SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC883_AUTO),
-        SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
-                ALC888_ACER_ASPIRE_4930G),
-        SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
-                ALC888_ACER_ASPIRE_4930G),
-        /* default Acer */
-        SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER),
-        SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
-        SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
-        SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
-        SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
-        SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
-        SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP),
-        SND_PCI_QUIRK(0x103c, 0x2a72, "HP Educ.ar", ALC888_3ST_HP),
-        SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
-        SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
-        SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG),
-        SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),
-        SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
-        SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
-        SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC883_6ST_DIG),
-        SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC),
-        SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
-        SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
-        SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
-        SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
-        SND_PCI_QUIRK(0x1458, 0xa002, "MSI", ALC883_6ST_DIG),
-        SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
-        SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
-        SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
-        SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC883_TARGA_2ch_DIG),
-        SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
-        SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
-        SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
-        SND_PCI_QUIRK(0x1462, 0x3ef9, "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, 0x3fcc, "MSI", ALC883_TARGA_DIG),
-        SND_PCI_QUIRK(0x1462, 0x3fdf, "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, 0x6668, "MSI", ALC883_6ST_DIG),
-        SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
-        SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
-        SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG),
-        SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
-        SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
-        SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
-        SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
-        SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
-        SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
-        SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
-        SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD),
-        SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
-        SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
-        SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1100, "FSC AMILO Xi/Pi25xx",
-                      ALC883_FUJITSU_PI2515),
-        SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1130, "Fujitsu AMILO Xa35xx",
-                ALC888_FUJITSU_XA3530),
-        SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
-        SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
-        SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
-        SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
-        SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
-        SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2),
-        SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG),
-        SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
-        SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
-        SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
-        SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
-        SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
-        SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC883_3ST_6ch_INTEL),
-        SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC883_3ST_6ch),
-        {0}
-};
-
-static hda_nid_t alc883_slave_dig_outs[] = {
-        ALC1200_DIGOUT_NID, 0,
-};
-
-static hda_nid_t alc1200_slave_dig_outs[] = {
-        ALC883_DIGOUT_NID, 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,
-                .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,
-                .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_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_INTEL] = {
-                .mixers = { alc883_3ST_6ch_intel_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,
-                .dig_in_nid = ALC883_DIGIN_NID,
-                .slave_dig_outs = alc883_slave_dig_outs,
-                .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
-                .channel_mode = alc883_3ST_6ch_intel_modes,
-                .need_dac_fix = 1,
-                .input_mux = &alc883_3stack_6ch_intel,
-        },
-        [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,
-                .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_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,
-                .adc_nids = alc883_adc_nids_alt,
-                .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
-                .dig_out_nid = ALC883_DIGOUT_NID,
-                .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,
-        },
-        [ALC883_ACER] = {
-                .mixers = { alc883_base_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_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
-                .channel_mode = alc883_3ST_2ch_modes,
-                .input_mux = &alc883_capture_source,
-        },
-        [ALC883_ACER_ASPIRE] = {
-                .mixers = { alc883_acer_aspire_mixer },
-                .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
-                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
-                .dac_nids = alc883_dac_nids,
-                .dig_out_nid = ALC883_DIGOUT_NID,
-                .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
-                .channel_mode = alc883_3ST_2ch_modes,
-                .input_mux = &alc883_capture_source,
-                .unsol_event = alc883_acer_aspire_unsol_event,
-                .init_hook = alc883_acer_aspire_automute,
-        },
-        [ALC888_ACER_ASPIRE_4930G] = {
-                .mixers = { alc888_base_mixer,
-                                alc883_chmode_mixer },
-                .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
-                                alc888_acer_aspire_4930g_verbs },
-                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
-                .dac_nids = alc883_dac_nids,
-                .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
-                .adc_nids = alc883_adc_nids_rev,
-                .capsrc_nids = alc883_capsrc_nids_rev,
-                .dig_out_nid = ALC883_DIGOUT_NID,
-                .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
-                .channel_mode = alc883_3ST_6ch_modes,
-                .need_dac_fix = 1,
-                .num_mux_defs =
-                        ARRAY_SIZE(alc888_2_capture_sources),
-                .input_mux = alc888_2_capture_sources,
-                .unsol_event = alc888_acer_aspire_4930g_unsol_event,
-                .init_hook = alc888_acer_aspire_4930g_automute,
-        },
-        [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,
-                .adc_nids = alc883_adc_nids_alt,
-                .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
-                .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
-                .channel_mode = alc883_sixstack_modes,
-                .input_mux = &alc883_capture_source,
-        },
-        [ALC883_MEDION_MD2] = {
-                .mixers = { alc883_medion_md2_mixer},
-                .init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs},
-                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
-                .dac_nids = alc883_dac_nids,
-                .dig_out_nid = ALC883_DIGOUT_NID,
-                .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
-                .channel_mode = alc883_3ST_2ch_modes,
-                .input_mux = &alc883_capture_source,
-                .unsol_event = alc883_medion_md2_unsol_event,
-                .init_hook = alc883_medion_md2_automute,
-        },
-        [ALC883_LAPTOP_EAPD] = {
-                .mixers = { alc883_base_mixer },
-                .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
-                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
-                .dac_nids = alc883_dac_nids,
-                .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
-                .channel_mode = alc883_3ST_2ch_modes,
-                .input_mux = &alc883_capture_source,
-        },
-        [ALC883_CLEVO_M720] = {
-                .mixers = { alc883_clevo_m720_mixer },
-                .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
-                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
-                .dac_nids = alc883_dac_nids,
-                .dig_out_nid = ALC883_DIGOUT_NID,
-                .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
-                .channel_mode = alc883_3ST_2ch_modes,
-                .input_mux = &alc883_capture_source,
-                .unsol_event = alc883_clevo_m720_unsol_event,
-                .init_hook = alc883_clevo_m720_automute,
-        },
-        [ALC883_LENOVO_101E_2ch] = {
-                .mixers = { alc883_lenovo_101e_2ch_mixer},
-                .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
-                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
-                .dac_nids = alc883_dac_nids,
-                .adc_nids = alc883_adc_nids_alt,
-                .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
-                .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
-                .channel_mode = alc883_3ST_2ch_modes,
-                .input_mux = &alc883_lenovo_101e_capture_source,
-                .unsol_event = alc883_lenovo_101e_unsol_event,
-                .init_hook = alc883_lenovo_101e_all_automute,
-        },
-        [ALC883_LENOVO_NB0763] = {
-                .mixers = { alc883_lenovo_nb0763_mixer },
-                .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
-                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
-                .dac_nids = alc883_dac_nids,
-                .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
-                .channel_mode = alc883_3ST_2ch_modes,
-                .need_dac_fix = 1,
-                .input_mux = &alc883_lenovo_nb0763_capture_source,
-                .unsol_event = alc883_medion_md2_unsol_event,
-                .init_hook = alc883_medion_md2_automute,
-        },
-        [ALC888_LENOVO_MS7195_DIG] = {
-                .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
-                .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
-                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
-                .dac_nids = alc883_dac_nids,
-                .dig_out_nid = ALC883_DIGOUT_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,
-                .unsol_event = alc883_lenovo_ms7195_unsol_event,
-                .init_hook = alc888_lenovo_ms7195_front_automute,
-        },
-        [ALC883_HAIER_W66] = {
-                .mixers = { alc883_tagra_2ch_mixer},
-                .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
-                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
-                .dac_nids = alc883_dac_nids,
-                .dig_out_nid = ALC883_DIGOUT_NID,
-                .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
-                .channel_mode = alc883_3ST_2ch_modes,
-                .input_mux = &alc883_capture_source,
-                .unsol_event = alc883_haier_w66_unsol_event,
-                .init_hook = alc883_haier_w66_automute,
-        },
-        [ALC888_3ST_HP] = {
-                .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
-                .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
-                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
-                .dac_nids = alc883_dac_nids,
-                .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
-                .channel_mode = alc888_3st_hp_modes,
-                .need_dac_fix = 1,
-                .input_mux = &alc883_capture_source,
-                .unsol_event = alc888_3st_hp_unsol_event,
-                .init_hook = alc888_3st_hp_front_automute,
-        },
-        [ALC888_6ST_DELL] = {
-                .mixers = { alc883_base_mixer, alc883_chmode_mixer },
-                .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
-                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
-                .dac_nids = alc883_dac_nids,
-                .dig_out_nid = ALC883_DIGOUT_NID,
-                .dig_in_nid = ALC883_DIGIN_NID,
-                .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
-                .channel_mode = alc883_sixstack_modes,
-                .input_mux = &alc883_capture_source,
-                .unsol_event = alc888_6st_dell_unsol_event,
-                .init_hook = alc888_6st_dell_front_automute,
-        },
-        [ALC883_MITAC] = {
-                .mixers = { alc883_mitac_mixer },
-                .init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
-                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
-                .dac_nids = alc883_dac_nids,
-                .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
-                .channel_mode = alc883_3ST_2ch_modes,
-                .input_mux = &alc883_capture_source,
-                .unsol_event = alc883_mitac_unsol_event,
-                .init_hook = alc883_mitac_automute,
-        },
-        [ALC883_FUJITSU_PI2515] = {
-                .mixers = { alc883_2ch_fujitsu_pi2515_mixer },
-                .init_verbs = { alc883_init_verbs,
-                                alc883_2ch_fujitsu_pi2515_verbs},
-                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
-                .dac_nids = alc883_dac_nids,
-                .dig_out_nid = ALC883_DIGOUT_NID,
-                .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
-                .channel_mode = alc883_3ST_2ch_modes,
-                .input_mux = &alc883_fujitsu_pi2515_capture_source,
-                .unsol_event = alc883_2ch_fujitsu_pi2515_unsol_event,
-                .init_hook = alc883_2ch_fujitsu_pi2515_automute,
-        },
-        [ALC888_FUJITSU_XA3530] = {
-                .mixers = { alc888_base_mixer, alc883_chmode_mixer },
-                .init_verbs = { alc883_init_verbs,
-                        alc888_fujitsu_xa3530_verbs },
-                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
-                .dac_nids = alc883_dac_nids,
-                .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
-                .adc_nids = alc883_adc_nids_rev,
-                .capsrc_nids = alc883_capsrc_nids_rev,
-                .dig_out_nid = ALC883_DIGOUT_NID,
-                .num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes),
-                .channel_mode = alc888_4ST_8ch_intel_modes,
-                .num_mux_defs =
-                        ARRAY_SIZE(alc888_2_capture_sources),
-                .input_mux = alc888_2_capture_sources,
-                .unsol_event = alc888_fujitsu_xa3530_unsol_event,
-                .init_hook = alc888_fujitsu_xa3530_automute,
-        },
-        [ALC888_LENOVO_SKY] = {
-                .mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
-                .init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
-                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
-                .dac_nids = alc883_dac_nids,
-                .dig_out_nid = ALC883_DIGOUT_NID,
-                .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
-                .channel_mode = alc883_sixstack_modes,
-                .need_dac_fix = 1,
-                .input_mux = &alc883_lenovo_sky_capture_source,
-                .unsol_event = alc883_lenovo_sky_unsol_event,
-                .init_hook = alc888_lenovo_sky_front_automute,
-        },
-        [ALC888_ASUS_M90V] = {
-                .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
-                .init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
-                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
-                .dac_nids = alc883_dac_nids,
-                .dig_out_nid = ALC883_DIGOUT_NID,
-                .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_fujitsu_pi2515_capture_source,
-                .unsol_event = alc883_mode2_unsol_event,
-                .init_hook = alc883_mode2_inithook,
-        },
-        [ALC888_ASUS_EEE1601] = {
-                .mixers = { alc883_asus_eee1601_mixer },
-                .cap_mixer = alc883_asus_eee1601_cap_mixer,
-                .init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
-                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
-                .dac_nids = alc883_dac_nids,
-                .dig_out_nid = ALC883_DIGOUT_NID,
-                .dig_in_nid = ALC883_DIGIN_NID,
-                .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
-                .channel_mode = alc883_3ST_2ch_modes,
-                .need_dac_fix = 1,
-                .input_mux = &alc883_asus_eee1601_capture_source,
-                .unsol_event = alc883_eee1601_unsol_event,
-                .init_hook = alc883_eee1601_inithook,
-        },
-        [ALC1200_ASUS_P5Q] = {
-                .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 = ALC1200_DIGOUT_NID,
-                .dig_in_nid = ALC883_DIGIN_NID,
-                .slave_dig_outs = alc1200_slave_dig_outs,
-                .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
-                .channel_mode = alc883_sixstack_modes,
-                .input_mux = &alc883_capture_source,
-        },
-};
-
-
-/*
- * BIOS auto configuration
- */
-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;
-
-        alc_set_pin_output(codec, nid, pin_type);
-        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_CONNECT_SEL, idx);
-
-}
-
-static void alc883_auto_init_multi_out(struct hda_codec *codec)
-{
-        struct alc_spec *spec = codec->spec;
-        int i;
-
-        alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
-        for (i = 0; i <= HDA_SIDE; i++) {
-                hda_nid_t nid = spec->autocfg.line_out_pins[i];
-                int pin_type = get_pin_type(spec->autocfg.line_out_type);
-                if (nid)
-                        alc883_auto_set_output_and_unmute(codec, nid, pin_type,
-                                                          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_pins[0];
-        if (pin) /* connect to front */
-                /* use dac 0 */
-                alc883_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
-        pin = spec->autocfg.speaker_pins[0];
-        if (pin)
-                alc883_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
-}
-
-#define alc883_is_input_pin(nid)        alc880_is_input_pin(nid)
-#define ALC883_PIN_CD_NID               ALC880_PIN_CD_NID
-
-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)) {
-                        alc_set_input_pin(codec, nid, i);
-                        if (nid != ALC883_PIN_CD_NID &&
-                            (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
-                                snd_hda_codec_write(codec, nid, 0,
-                                                    AC_VERB_SET_AMP_GAIN_MUTE,
-                                                    AMP_OUT_MUTE);
-                }
-        }
-}
-
-#define alc883_auto_init_input_src      alc882_auto_init_input_src
-
-/* almost identical with ALC880 parser... */
-static int alc883_parse_auto_config(struct hda_codec *codec)
-{
-        struct alc_spec *spec = codec->spec;
-        int err = alc880_parse_auto_config(codec);
-        struct auto_pin_cfg *cfg = &spec->autocfg;
-        int i;
-
-        if (err < 0)
-                return err;
-        else if (!err)
-                return 0; /* no config found */
-
-        err = alc_auto_add_mic_boost(codec);
-        if (err < 0)
-                return err;
-
-        /* hack - override the init verbs */
-        spec->init_verbs[0] = alc883_auto_init_verbs;
-
-        /* setup input_mux for ALC889 */
-        if (codec->vendor_id == 0x10ec0889) {
-                /* digital-mic input pin is excluded in alc880_auto_create..()
-                 * because it's under 0x18
-                 */
-                if (cfg->input_pins[AUTO_PIN_MIC] == 0x12 ||
-                    cfg->input_pins[AUTO_PIN_FRONT_MIC] == 0x12) {
-                        struct hda_input_mux *imux = &spec->private_imux[0];
-                        for (i = 1; i < 3; i++)
-                                memcpy(&spec->private_imux[i],
-                                       &spec->private_imux[0],
-                                       sizeof(spec->private_imux[0]));
-                        imux->items[imux->num_items].label = "Int DMic";
-                        imux->items[imux->num_items].index = 0x0b;
-                        imux->num_items++;
-                        spec->num_mux_defs = 3;
-                        spec->input_mux = spec->private_imux;
-                }
-        }
-
-        return 1; /* config found */
-}
-
-/* additional initialization for auto-configuration model */
-static void alc883_auto_init(struct hda_codec *codec)
-{
-        struct alc_spec *spec = codec->spec;
-        alc883_auto_init_multi_out(codec);
-        alc883_auto_init_hp_out(codec);
-        alc883_auto_init_analog_input(codec);
-        alc883_auto_init_input_src(codec);
-        if (spec->unsol_event)
-                alc_inithook(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;
-
-        alc_fix_pll_init(codec, 0x20, 0x0a, 10);
-
-        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;
-                }
-        }
-
-        err = snd_hda_attach_beep_device(codec, 0x1);
-        if (err < 0) {
-                alc_free(codec);
-                return err;
-        }
-
-        if (board_config != ALC883_AUTO)
-                setup_preset(spec, &alc883_presets[board_config]);
-
-        switch (codec->vendor_id) {
-        case 0x10ec0888:
-                if (codec->revision_id == 0x100101) {
-                        spec->stream_name_analog = "ALC1200 Analog";
-                        spec->stream_name_digital = "ALC1200 Digital";
-                } else {
-                        spec->stream_name_analog = "ALC888 Analog";
-                        spec->stream_name_digital = "ALC888 Digital";
-                }
-                if (!spec->num_adc_nids) {
-                        spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids);
-                        spec->adc_nids = alc883_adc_nids;
-                }
-                if (!spec->capsrc_nids)
-                        spec->capsrc_nids = alc883_capsrc_nids;
-                spec->capture_style = CAPT_MIX; /* matrix-style capture */
-                break;
-        case 0x10ec0889:
-                spec->stream_name_analog = "ALC889 Analog";
-                spec->stream_name_digital = "ALC889 Digital";
-                if (!spec->num_adc_nids) {
-                        spec->num_adc_nids = ARRAY_SIZE(alc889_adc_nids);
-                        spec->adc_nids = alc889_adc_nids;
-                }
-                if (!spec->capsrc_nids)
-                        spec->capsrc_nids = alc889_capsrc_nids;
-                spec->capture_style = CAPT_1MUX_MIX; /* 1mux/Nmix-style
-                                                        capture */
-                break;
-        default:
-                spec->stream_name_analog = "ALC883 Analog";
-                spec->stream_name_digital = "ALC883 Digital";
-                if (!spec->num_adc_nids) {
-                        spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids);
-                        spec->adc_nids = alc883_adc_nids;
-                }
-                if (!spec->capsrc_nids)
-                        spec->capsrc_nids = alc883_capsrc_nids;
-                spec->capture_style = CAPT_MIX; /* matrix-style capture */
-                break;
-        }
-
-        spec->stream_analog_playback = &alc883_pcm_analog_playback;
-        spec->stream_analog_capture = &alc883_pcm_analog_capture;
-        spec->stream_analog_alt_capture = &alc883_pcm_analog_alt_capture;
-
-        spec->stream_digital_playback = &alc883_pcm_digital_playback;
-        spec->stream_digital_capture = &alc883_pcm_digital_capture;
-
-        if (!spec->cap_mixer)
-                set_capture_mixer(spec);
-        set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
-
-        spec->vmaster_nid = 0x0c;
-
-        codec->patch_ops = alc_patch_ops;
-        if (board_config == ALC883_AUTO)
-                spec->init_hook = alc883_auto_init;
-
-#ifdef CONFIG_SND_HDA_POWER_SAVE
-        if (!spec->loopback.amplist)
-                spec->loopback.amplist = alc883_loopbacks;
-#endif
-        codec->proc_widget_hook = print_realtek_coef;
-
-        return 0;
-}
 
 /*
@@ -9408 +9892 @@
 };
 
-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("Mic Boost", 0x18, 0, 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("Front Mic Boost", 0x19, 0, HDA_INPUT),
-        /*HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),*/
-        HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
-        {0} /* end */
-};
-
 /* update HP, line and mono-out pins according to the master switch */
 static void alc262_hp_master_update(struct hda_codec *codec)
@@ -9481 +9947 @@
 }
 
-static int alc262_hp_master_sw_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;
-        *ucontrol->value.integer.value = spec->master_sw;
-        return 0;
-}
+#define alc262_hp_master_sw_get         alc260_hp_master_sw_get
 
 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
@@ -9504 +9963 @@
 }
 
+#define ALC262_HP_MASTER_SWITCH                                 \
+        {                                                       \
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
+                .name = "Master Playback Switch",               \
+                .info = snd_ctl_boolean_mono_info,              \
+                .get = alc262_hp_master_sw_get,                 \
+                .put = alc262_hp_master_sw_put,                 \
+        }
+
 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
-        {
-                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-                .name = "Master Playback Switch",
-                .info = snd_ctl_boolean_mono_info,
-                .get = alc262_hp_master_sw_get,
-                .put = alc262_hp_master_sw_put,
-        },
+        ALC262_HP_MASTER_SWITCH,
         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
@@ -9535 +9997 @@
 
 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
-        {
-                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-                .name = "Master Playback Switch",
-                .info = snd_ctl_boolean_mono_info,
-                .get = alc262_hp_master_sw_get,
-                .put = alc262_hp_master_sw_put,
-        },
+        ALC262_HP_MASTER_SWITCH,
         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
@@ -9568 +10024 @@
 
 /* mute/unmute internal speaker according to the hp jack and mute state */
-static void alc262_hp_t5735_automute(struct hda_codec *codec, int force)
+static void alc262_hp_t5735_setup(struct hda_codec *codec)
 {
         struct alc_spec *spec = codec->spec;
 
-        if (force || !spec->sense_updated) {
-                unsigned int present;
-                present = snd_hda_codec_read(codec, 0x15, 0,
-                                             AC_VERB_GET_PIN_SENSE, 0);
-                spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
-                spec->sense_updated = 1;
-        }
-        snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0, HDA_AMP_MUTE,
-                                 spec->jack_present ? HDA_AMP_MUTE : 0);
-}
-
-static void alc262_hp_t5735_unsol_event(struct hda_codec *codec,
-                                        unsigned int res)
-{
-        if ((res >> 26) != ALC880_HP_EVENT)
-                return;
-        alc262_hp_t5735_automute(codec, 1);
-}
-
-static void alc262_hp_t5735_init_hook(struct hda_codec *codec)
-{
-        alc262_hp_t5735_automute(codec, 1);
+        spec->autocfg.hp_pins[0] = 0x15;
+        spec->autocfg.speaker_pins[0] = 0x0c; /* HACK: not actually a pin */
 }
 
@@ -9646 +10082 @@
 };
 
-/* bind hp and internal speaker mute (with plug check) */
-static int alc262_sony_master_sw_put(struct snd_kcontrol *kcontrol,
-                                     struct snd_ctl_elem_value *ucontrol)
+/* bind hp and internal speaker mute (with plug check) as master switch */
+static void alc262_hippo_master_update(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+        hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
+        hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
+        hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
+        unsigned int mute;
+
+        /* HP */
+        mute = spec->master_sw ? 0 : HDA_AMP_MUTE;
+        snd_hda_codec_amp_stereo(codec, hp_nid, HDA_OUTPUT, 0,
+                                 HDA_AMP_MUTE, mute);
+        /* mute internal speaker per jack sense */
+        if (spec->jack_present)
+                mute = HDA_AMP_MUTE;
+        if (line_nid)
+                snd_hda_codec_amp_stereo(codec, line_nid, HDA_OUTPUT, 0,
+                                         HDA_AMP_MUTE, mute);
+        if (speaker_nid && speaker_nid != line_nid)
+                snd_hda_codec_amp_stereo(codec, speaker_nid, HDA_OUTPUT, 0,
+                                         HDA_AMP_MUTE, mute);
+}
+
+#define alc262_hippo_master_sw_get      alc262_hp_master_sw_get
+
+static int alc262_hippo_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 hp mute */
-        change = snd_hda_codec_amp_update(codec, 0x15, 0, HDA_OUTPUT, 0,
-                                          HDA_AMP_MUTE,
-                                          valp[0] ? 0 : HDA_AMP_MUTE);
-        change |= snd_hda_codec_amp_update(codec, 0x15, 1, HDA_OUTPUT, 0,
-                                           HDA_AMP_MUTE,
-                                           valp[1] ? 0 : HDA_AMP_MUTE);
-        if (change) {
-                /* change speaker according to HP jack state */
-                struct alc_spec *spec = codec->spec;
-                unsigned int mute;
-                if (spec->jack_present)
-                        mute = HDA_AMP_MUTE;
-                else
-                        mute = snd_hda_codec_amp_read(codec, 0x15, 0,
-                                                      HDA_OUTPUT, 0);
-                snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
-                                         HDA_AMP_MUTE, mute);
+        struct alc_spec *spec = codec->spec;
+        int val = !!*ucontrol->value.integer.value;
+
+        if (val == spec->master_sw)
+                return 0;
+        spec->master_sw = val;
+        alc262_hippo_master_update(codec);
+        return 1;
+}
+
+#define ALC262_HIPPO_MASTER_SWITCH                              \
+        {                                                       \
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
+                .name = "Master Playback Switch",               \
+                .info = snd_ctl_boolean_mono_info,              \
+                .get = alc262_hippo_master_sw_get,              \
+                .put = alc262_hippo_master_sw_put,              \
         }
-        return change;
-}
+
+static struct snd_kcontrol_new alc262_hippo_mixer[] = {
+        ALC262_HIPPO_MASTER_SWITCH,
+        HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 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("Mic Boost", 0x18, 0, 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("Front Mic Boost", 0x19, 0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
+        {0} /* end */
+};
+
+static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
+        HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
+        ALC262_HIPPO_MASTER_SWITCH,
+        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("Mic Boost", 0x18, 0, 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("Front Mic Boost", 0x19, 0, HDA_INPUT),
+        {0} /* end */
+};
+
+/* mute/unmute internal speaker according to the hp jack and mute state */
+static void alc262_hippo_automute(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+        hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
+        unsigned int present;
+
+        /* need to execute and sync at first */
+        snd_hda_codec_read(codec, hp_nid, 0, AC_VERB_SET_PIN_SENSE, 0);
+        present = snd_hda_codec_read(codec, hp_nid, 0,
+                                     AC_VERB_GET_PIN_SENSE, 0);
+        spec->jack_present = (present & 0x80000000) != 0;
+        alc262_hippo_master_update(codec);
+}
+
+static void alc262_hippo_unsol_event(struct hda_codec *codec, unsigned int res)
+{
+        if ((res >> 26) != ALC880_HP_EVENT)
+                return;
+        alc262_hippo_automute(codec);
+}
+
+static void alc262_hippo_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        spec->autocfg.hp_pins[0] = 0x15;
+        spec->autocfg.speaker_pins[0] = 0x14;
+}
+
+static void alc262_hippo1_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        spec->autocfg.hp_pins[0] = 0x1b;
+        spec->autocfg.speaker_pins[0] = 0x14;
+}
+
 
 static struct snd_kcontrol_new alc262_sony_mixer[] = {
         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, 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_sony_master_sw_put,
-                .private_value = HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
-        },
+        ALC262_HIPPO_MASTER_SWITCH,
         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
@@ -9694 +10214 @@
 
 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
-        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
-        HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
+        ALC262_HIPPO_MASTER_SWITCH,
         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
@@ -9736 +10256 @@
 
 /* unsolicited event for HP jack sensing */
-static void alc262_tyan_automute(struct hda_codec *codec)
-{
-        unsigned int mute;
-        unsigned int present;
-
-        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);
-        present = (present & 0x80000000) != 0;
-        if (present) {
-                /* mute line output on ATX panel */
-                snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
-                                         HDA_AMP_MUTE, HDA_AMP_MUTE);
-        } else {
-                /* unmute line output if necessary */
-                mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
-                snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
-                                         HDA_AMP_MUTE, mute);
-        }
-}
-
-static void alc262_tyan_unsol_event(struct hda_codec *codec,
-                                       unsigned int res)
-{
-        if ((res >> 26) != ALC880_HP_EVENT)
-                return;
-        alc262_tyan_automute(codec);
-}
+static void alc262_tyan_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        spec->autocfg.hp_pins[0] = 0x1b;
+        spec->autocfg.speaker_pins[0] = 0x15;
+}
+
 
 #define alc262_capture_mixer            alc882_capture_mixer
@@ -9853 +10353 @@
 };
 
-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},
@@ -9877 +10371 @@
         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
         {0}
-};
-
-static struct hda_input_mux alc262_dmic_capture_source = {
-        .num_items = 2,
-        .items = {
-                { "Int DMic", 0x9 },
-                { "Mic", 0x0 },
-        },
 };
 
@@ -9908 +10394 @@
 };
 
-static void alc262_dmic_automute(struct hda_codec *codec)
-{
-        unsigned int present;
-
-        present = snd_hda_codec_read(codec, 0x18, 0,
-                                        AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-        snd_hda_codec_write(codec, 0x22, 0,
-                                AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x09);
-}
-
-/* toggle speaker-output according to the hp-jack state */
-static void alc262_toshiba_s06_speaker_automute(struct hda_codec *codec)
-{
-        unsigned int present;
-        unsigned char bits;
-
-        present = snd_hda_codec_read(codec, 0x15, 0,
-                                        AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-        bits = present ? 0 : PIN_OUT;
-        snd_hda_codec_write(codec, 0x14, 0,
-                                        AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
-}
-
-
-
-/* unsolicited event for HP jack sensing */
-static void alc262_toshiba_s06_unsol_event(struct hda_codec *codec,
-                                       unsigned int res)
-{
-        if ((res >> 26) == ALC880_HP_EVENT)
-                alc262_toshiba_s06_speaker_automute(codec);
-        if ((res >> 26) == ALC880_MIC_EVENT)
-                alc262_dmic_automute(codec);
-
-}
-
-static void alc262_toshiba_s06_init_hook(struct hda_codec *codec)
-{
-        alc262_toshiba_s06_speaker_automute(codec);
-        alc262_dmic_automute(codec);
-}
-
-/* mute/unmute internal speaker according to the hp jack and mute state */
-static void alc262_hippo_automute(struct hda_codec *codec)
+static void alc262_toshiba_s06_setup(struct hda_codec *codec)
 {
         struct alc_spec *spec = codec->spec;
-        unsigned int mute;
-        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;
-        if (spec->jack_present) {
-                /* mute internal speaker */
-                snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
-                                         HDA_AMP_MUTE, HDA_AMP_MUTE);
-        } else {
-                /* unmute internal speaker if necessary */
-                mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0);
-                snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
-                                         HDA_AMP_MUTE, mute);
-        }
-}
-
-/* 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);
-}
-
-static void alc262_hippo1_automute(struct hda_codec *codec)
-{
-        unsigned int mute;
-        unsigned int present;
-
-        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);
-        present = (present & 0x80000000) != 0;
-        if (present) {
-                /* mute internal speaker */
-                snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
-                                         HDA_AMP_MUTE, HDA_AMP_MUTE);
-        } else {
-                /* unmute internal speaker if necessary */
-                mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
-                snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
-                                         HDA_AMP_MUTE, mute);
-        }
-}
-
-/* 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);
+
+        spec->autocfg.hp_pins[0] = 0x15;
+        spec->autocfg.speaker_pins[0] = 0x14;
+        spec->ext_mic.pin = 0x18;
+        spec->ext_mic.mux_idx = 0;
+        spec->int_mic.pin = 0x12;
+        spec->int_mic.mux_idx = 9;
+        spec->auto_mic = 1;
 }
 
@@ -10199 +10593 @@
 }
 
+static int amp_stereo_mute_update(struct hda_codec *codec, hda_nid_t nid,
+                                  int dir, int idx, long *valp)
+{
+        int i, change = 0;
+
+        for (i = 0; i < 2; i++, valp++)
+                change |= snd_hda_codec_amp_update(codec, nid, i, dir, idx,
+                                                   HDA_AMP_MUTE,
+                                                   *valp ? 0 : HDA_AMP_MUTE);
+        return change;
+}
+
 /* bind hp and internal speaker mute (with plug check) */
 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
@@ -10207 +10613 @@
         int change;
 
-        change = snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
-                                                 HDA_AMP_MUTE,
-                                                 valp ? 0 : HDA_AMP_MUTE);
-        change |= snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
-                                                 HDA_AMP_MUTE,
-                                                 valp ? 0 : HDA_AMP_MUTE);
-
+        change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
+        change |= amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
         if (change)
                 alc262_fujitsu_automute(codec, 0);
@@ -10248 +10649 @@
         int change;
 
-        change = snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
-                                                 HDA_AMP_MUTE,
-                                                 valp ? 0 : HDA_AMP_MUTE);
-
+        change = amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
         if (change)
                 alc262_lenovo_3000_automute(codec, 0);
@@ -10280 +10678 @@
 static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
-        {
-                .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_sony_master_sw_put,
-                .private_value = HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
-        },
+        ALC262_HIPPO_MASTER_SWITCH,
         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
@@ -10431 +10822 @@
 };
 
+/* We use two mixers depending on the output pin; 0x16 is a mono output
+ * and thus it's bound with a different mixer.
+ * This function returns which mixer amp should be used.
+ */
+static int alc262_check_volbit(hda_nid_t nid)
+{
+        if (!nid)
+                return 0;
+        else if (nid == 0x16)
+                return 2;
+        else
+                return 1;
+}
+
+static int alc262_add_out_vol_ctl(struct alc_spec *spec, hda_nid_t nid,
+                                  const char *pfx, int *vbits)
+{
+        char name[32];
+        unsigned long val;
+        int vbit;
+
+        vbit = alc262_check_volbit(nid);
+        if (!vbit)
+                return 0;
+        if (*vbits & vbit) /* a volume control for this mixer already there */
+                return 0;
+        *vbits |= vbit;
+        snprintf(name, sizeof(name), "%s Playback Volume", pfx);
+        if (vbit == 2)
+                val = HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT);
+        else
+                val = HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT);
+        return add_control(spec, ALC_CTL_WIDGET_VOL, name, val);
+}
+
+static int alc262_add_out_sw_ctl(struct alc_spec *spec, hda_nid_t nid,
+                                 const char *pfx)
+{
+        char name[32];
+        unsigned long val;
+
+        if (!nid)
+                return 0;
+        snprintf(name, sizeof(name), "%s Playback Switch", pfx);
+        if (nid == 0x16)
+                val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
+        else
+                val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
+        return add_control(spec, ALC_CTL_WIDGET_MUTE, name, val);
+}
+
 /* add playback controls from the parsed DAC table */
 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
                                              const struct auto_pin_cfg *cfg)
 {
-        hda_nid_t nid;
+        const char *pfx;
+        int vbits;
         int err;
 
@@ -10442 +10885 @@
         spec->multiout.dac_nids[0] = 2;
 
-        nid = cfg->line_out_pins[0];
-        if (nid) {
-                err = add_control(spec, ALC_CTL_WIDGET_VOL,
-                                  "Front Playback Volume",
-                                  HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT));
-                if (err < 0)
-                        return err;
-                err = add_control(spec, ALC_CTL_WIDGET_MUTE,
-                                  "Front Playback Switch",
-                                  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
-                if (err < 0)
-                        return err;
-        }
-
-        nid = cfg->speaker_pins[0];
-        if (nid) {
-                if (nid == 0x16) {
-                        err = add_control(spec, ALC_CTL_WIDGET_VOL,
-                                          "Speaker Playback Volume",
-                                          HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
-                                                              HDA_OUTPUT));
-                        if (err < 0)
-                                return err;
-                        err = add_control(spec, ALC_CTL_WIDGET_MUTE,
-                                          "Speaker Playback Switch",
-                                          HDA_COMPOSE_AMP_VAL(nid, 2, 0,
-                                                              HDA_OUTPUT));
-                        if (err < 0)
-                                return err;
-                } else {
-                        err = add_control(spec, ALC_CTL_WIDGET_MUTE,
-                                          "Speaker Playback Switch",
-                                          HDA_COMPOSE_AMP_VAL(nid, 3, 0,
-                                                              HDA_OUTPUT));
-                        if (err < 0)
-                                return err;
-                }
-        }
-        nid = cfg->hp_pins[0];
-        if (nid) {
-                /* spec->multiout.hp_nid = 2; */
-                if (nid == 0x16) {
-                        err = add_control(spec, ALC_CTL_WIDGET_VOL,
-                                          "Headphone Playback Volume",
-                                          HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
-                                                              HDA_OUTPUT));
-                        if (err < 0)
-                                return err;
-                        err = add_control(spec, ALC_CTL_WIDGET_MUTE,
-                                          "Headphone Playback Switch",
-                                          HDA_COMPOSE_AMP_VAL(nid, 2, 0,
-                                                              HDA_OUTPUT));
-                        if (err < 0)
-                                return err;
-                } else {
-                        err = add_control(spec, ALC_CTL_WIDGET_MUTE,
-                                          "Headphone Playback Switch",
-                                          HDA_COMPOSE_AMP_VAL(nid, 3, 0,
-                                                              HDA_OUTPUT));
-                        if (err < 0)
-                                return err;
-                }
-        }
+        if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
+                pfx = "Master";
+        else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
+                pfx = "Speaker";
+        else
+                pfx = "Front";
+        err = alc262_add_out_sw_ctl(spec, cfg->line_out_pins[0], pfx);
+        if (err < 0)
+                return err;
+        err = alc262_add_out_sw_ctl(spec, cfg->speaker_pins[0], "Speaker");
+        if (err < 0)
+                return err;
+        err = alc262_add_out_sw_ctl(spec, cfg->hp_pins[0], "Headphone");
+        if (err < 0)
+                return err;
+
+        vbits = alc262_check_volbit(cfg->line_out_pins[0]) |
+                alc262_check_volbit(cfg->speaker_pins[0]) |
+                alc262_check_volbit(cfg->hp_pins[0]);
+        if (vbits == 1 || vbits == 2)
+                pfx = "Master"; /* only one mixer is used */
+        else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
+                pfx = "Speaker";
+        else
+                pfx = "Front";
+        vbits = 0;
+        err = alc262_add_out_vol_ctl(spec, cfg->line_out_pins[0], pfx, &vbits);
+        if (err < 0)
+                return err;
+        err = alc262_add_out_vol_ctl(spec, cfg->speaker_pins[0], "Speaker",
+                                     &vbits);
+        if (err < 0)
+                return err;
+        err = alc262_add_out_vol_ctl(spec, cfg->hp_pins[0], "Headphone",
+                                     &vbits);
+        if (err < 0)
+                return err;
         return 0;
 }
 
-/* identical with ALC880 */
-#define alc262_auto_create_analog_input_ctls \
-        alc880_auto_create_analog_input_ctls
+#define alc262_auto_create_input_ctls \
+        alc880_auto_create_input_ctls
 
 /*
@@ -10634 +11050 @@
         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
 
-        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
-        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
+        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
@@ -10643 +11059 @@
 
         /* 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 */
+        /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 0b, 12 */
+        /* Input mixer1: only unmute Mic */
         {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))},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 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))},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 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))},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
 
         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
@@ -10783 +11214 @@
 #endif
 
-/* pcm configuration: identiacal with ALC880 */
+/* pcm configuration: identical with ALC880 */
 #define alc262_pcm_analog_playback      alc880_pcm_analog_playback
 #define alc262_pcm_analog_capture       alc880_pcm_analog_capture
@@ -10813 +11244 @@
         if (err < 0)
                 return err;
-        err = alc262_auto_create_analog_input_ctls(spec, &spec->autocfg);
+        err = alc262_auto_create_input_ctls(codec, &spec->autocfg);
         if (err < 0)
                 return err;
@@ -10837 +11268 @@
         if (err < 0)
                 return err;
+
+        alc_ssid_check(codec, 0x15, 0x14, 0x1b);
 
         return 1;
@@ -10910 +11343 @@
         SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
         SND_PCI_QUIRK(0x104d, 0x9016, "Sony VAIO", ALC262_AUTO), /* dig-only */
+        SND_PCI_QUIRK(0x104d, 0x9025, "Sony VAIO Z21MN", ALC262_TOSHIBA_S06),
         SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO",
                            ALC262_SONY_ASSAMD),
@@ -10940 +11374 @@
         },
         [ALC262_HIPPO] = {
-                .mixers = { alc262_base_mixer },
-                .init_verbs = { alc262_init_verbs, alc262_hippo_unsol_verbs},
+                .mixers = { alc262_hippo_mixer },
+                .init_verbs = { alc262_init_verbs, alc_hp15_unsol_verbs},
                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
                 .dac_nids = alc262_dac_nids,
@@ -10950 +11384 @@
                 .input_mux = &alc262_capture_source,
                 .unsol_event = alc262_hippo_unsol_event,
+                .setup = alc262_hippo_setup,
                 .init_hook = alc262_hippo_automute,
         },
@@ -10962 +11397 @@
                 .channel_mode = alc262_modes,
                 .input_mux = &alc262_capture_source,
-                .unsol_event = alc262_hippo1_unsol_event,
-                .init_hook = alc262_hippo1_automute,
+                .unsol_event = alc262_hippo_unsol_event,
+                .setup = alc262_hippo1_setup,
+                .init_hook = alc262_hippo_automute,
         },
         [ALC262_FUJITSU] = {
@@ -11025 +11461 @@
                 .channel_mode = alc262_modes,
                 .input_mux = &alc262_capture_source,
-                .unsol_event = alc262_hp_t5735_unsol_event,
-                .init_hook = alc262_hp_t5735_init_hook,
+                .unsol_event = alc_automute_amp_unsol_event,
+                .setup = alc262_hp_t5735_setup,
+                .init_hook = alc_automute_amp,
         },
         [ALC262_HP_RP5700] = {
@@ -11057 +11494 @@
                 .input_mux = &alc262_capture_source,
                 .unsol_event = alc262_hippo_unsol_event,
+                .setup = alc262_hippo_setup,
                 .init_hook = alc262_hippo_automute,
         },
         [ALC262_BENQ_T31] = {
                 .mixers = { alc262_benq_t31_mixer },
-                .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs, alc262_hippo_unsol_verbs },
+                .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs,
+                                alc_hp15_unsol_verbs },
                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
                 .dac_nids = alc262_dac_nids,
@@ -11069 +11508 @@
                 .input_mux = &alc262_capture_source,
                 .unsol_event = alc262_hippo_unsol_event,
+                .setup = alc262_hippo_setup,
                 .init_hook = alc262_hippo_automute,
         },
@@ -11117 +11557 @@
                 .dac_nids = alc262_dac_nids,
                 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */
+                .num_adc_nids = 1, /* single ADC */
                 .dig_out_nid = ALC262_DIGOUT_NID,
                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
                 .channel_mode = alc262_modes,
-                .input_mux = &alc262_dmic_capture_source,
-                .unsol_event = alc262_toshiba_s06_unsol_event,
-                .init_hook = alc262_toshiba_s06_init_hook,
+                .unsol_event = alc_sku_unsol_event,
+                .setup = alc262_toshiba_s06_setup,
+                .init_hook = alc_inithook,
         },
         [ALC262_TOSHIBA_RX1] = {
@@ -11134 +11575 @@
                 .input_mux = &alc262_capture_source,
                 .unsol_event = alc262_hippo_unsol_event,
+                .setup = alc262_hippo_setup,
                 .init_hook = alc262_hippo_automute,
         },
@@ -11146 +11588 @@
                 .channel_mode = alc262_modes,
                 .input_mux = &alc262_capture_source,
-                .unsol_event = alc262_tyan_unsol_event,
-                .init_hook = alc262_tyan_automute,
+                .unsol_event = alc_automute_amp_unsol_event,
+                .setup = alc262_tyan_setup,
+                .init_hook = alc_automute_amp,
         },
 };
@@ -11182 +11625 @@
 
         if (board_config < 0) {
-                printk(KERN_INFO "hda_codec: Unknown model for ALC262, "
-                       "trying auto-probe from BIOS...\n");
+                printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
+                       codec->chip_name);
                 board_config = ALC262_AUTO;
         }
@@ -11210 +11653 @@
 
         if (board_config != ALC262_AUTO)
-                setup_preset(spec, &alc262_presets[board_config]);
-
-        spec->stream_name_analog = "ALC262 Analog";
+                setup_preset(codec, &alc262_presets[board_config]);
+
         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;
 
-        spec->capture_style = CAPT_MIX;
         if (!spec->adc_nids && spec->input_mux) {
-                /* check whether NID 0x07 is valid */
-                unsigned int wcap = get_wcaps(codec, 0x07);
-
-                /* get type */
-                wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
-                if (wcap != AC_WID_AUD_IN) {
-                        spec->adc_nids = alc262_adc_nids_alt;
-                        spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids_alt);
-                        spec->capsrc_nids = alc262_capsrc_nids_alt;
+                int i;
+                /* check whether the digital-mic has to be supported */
+                for (i = 0; i < spec->input_mux->num_items; i++) {
+                        if (spec->input_mux->items[i].index >= 9)
+                                break;
+                }
+                if (i < spec->input_mux->num_items) {
+                        /* use only ADC0 */
+                        spec->adc_nids = alc262_dmic_adc_nids;
+                        spec->num_adc_nids = 1;
+                        spec->capsrc_nids = alc262_dmic_capsrc_nids;
                 } else {
-                        spec->adc_nids = alc262_adc_nids;
-                        spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids);
-                        spec->capsrc_nids = alc262_capsrc_nids;
+                        /* all analog inputs */
+                        /* check whether NID 0x07 is valid */
+                        unsigned int wcap = get_wcaps(codec, 0x07);
+
+                        /* get type */
+                        wcap = get_wcaps_type(wcap);
+                        if (wcap != AC_WID_AUD_IN) {
+                                spec->adc_nids = alc262_adc_nids_alt;
+                                spec->num_adc_nids =
+                                        ARRAY_SIZE(alc262_adc_nids_alt);
+                                spec->capsrc_nids = alc262_capsrc_nids_alt;
+                        } else {
+                                spec->adc_nids = alc262_adc_nids;
+                                spec->num_adc_nids =
+                                        ARRAY_SIZE(alc262_adc_nids);
+                                spec->capsrc_nids = alc262_capsrc_nids;
+                        }
                 }
         }
         if (!spec->cap_mixer && !spec->no_analog)
-                set_capture_mixer(spec);
+                set_capture_mixer(codec);
         if (!spec->no_analog)
                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
@@ -11291 +11747 @@
 };
 
+static struct snd_kcontrol_new alc268_toshiba_mixer[] = {
+        /* output mixer control */
+        HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
+        ALC262_HIPPO_MASTER_SWITCH,
+        HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
+        {0}
+};
+
 /* bind Beep switches of both NID 0x0f and 0x10 */
 static struct hda_bind_ctls alc268_bind_beep_sw = {
@@ -11314 +11781 @@
 
 /* Toshiba specific */
-#define alc268_toshiba_automute alc262_hippo_automute
-
 static struct hda_verb alc268_toshiba_verbs[] = {
         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
         {0} /* end */
-};
-
-static struct hda_input_mux alc268_acer_lc_capture_source = {
-        .num_items = 2,
-        .items = {
-                { "i-Mic", 0x6 },
-                { "E-Mic", 0x0 },
-        },
 };
 
@@ -11370 +11827 @@
         int change;
 
-        change = snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
-                                          HDA_AMP_MUTE,
-                                          valp[0] ? 0 : HDA_AMP_MUTE);
-        change |= snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
-                                           HDA_AMP_MUTE,
-                                           valp[1] ? 0 : HDA_AMP_MUTE);
+        change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
         if (change)
                 alc268_acer_automute(codec, 0);
@@ -11451 +11903 @@
 
 /* unsolicited event for HP jack sensing */
-static void alc268_toshiba_unsol_event(struct hda_codec *codec,
-                                       unsigned int res)
-{
-        if ((res >> 26) != ALC880_HP_EVENT)
-                return;
-        alc268_toshiba_automute(codec);
-}
+#define alc268_toshiba_unsol_event      alc262_hippo_unsol_event
+#define alc268_toshiba_setup            alc262_hippo_setup
+#define alc268_toshiba_automute         alc262_hippo_automute
 
 static void alc268_acer_unsol_event(struct hda_codec *codec,
@@ -11487 +11935 @@
 }
 
-
-static void alc268_acer_mic_automute(struct hda_codec *codec)
-{
-        unsigned int present;
-
-        present = snd_hda_codec_read(codec, 0x18, 0,
-                                AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-        snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_CONNECT_SEL,
-                            present ? 0x0 : 0x6);
-}
-
 static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
                                     unsigned int res)
 {
-        if ((res >> 26) == ALC880_HP_EVENT)
+        switch (res >> 26) {
+        case ALC880_HP_EVENT:
                 alc268_aspire_one_speaker_automute(codec);
-        if ((res >> 26) == ALC880_MIC_EVENT)
-                alc268_acer_mic_automute(codec);
+                break;
+        case ALC880_MIC_EVENT:
+                alc_mic_automute(codec);
+                break;
+        }
+}
+
+static void alc268_acer_lc_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+        spec->ext_mic.pin = 0x18;
+        spec->ext_mic.mux_idx = 0;
+        spec->int_mic.pin = 0x12;
+        spec->int_mic.mux_idx = 6;
+        spec->auto_mic = 1;
 }
 
@@ -11510 +11961 @@
 {
         alc268_aspire_one_speaker_automute(codec);
-        alc268_acer_mic_automute(codec);
+        alc_mic_automute(codec);
 }
 
@@ -11528 +11979 @@
         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
+        {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
         {0}
 };
 
 /* mute/unmute internal speaker according to the hp jack and mute state */
-static void alc268_dell_automute(struct hda_codec *codec)
-{
-        unsigned int present;
-        unsigned int mute;
-
-        present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0);
-        if (present & 0x80000000)
-                mute = HDA_AMP_MUTE;
-        else
-                mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0);
-        snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
-                                 HDA_AMP_MUTE, mute);
-}
-
-static void alc268_dell_unsol_event(struct hda_codec *codec,
-                                    unsigned int res)
-{
-        if ((res >> 26) != ALC880_HP_EVENT)
-                return;
-        alc268_dell_automute(codec);
-}
-
-#define alc268_dell_init_hook   alc268_dell_automute
+static void alc268_dell_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        spec->autocfg.hp_pins[0] = 0x15;
+        spec->autocfg.speaker_pins[0] = 0x14;
+        spec->ext_mic.pin = 0x18;
+        spec->ext_mic.mux_idx = 0;
+        spec->int_mic.pin = 0x19;
+        spec->int_mic.mux_idx = 1;
+        spec->auto_mic = 1;
+}
 
 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
@@ -11574 +12015 @@
 };
 
-static void alc267_quanta_il1_hp_automute(struct hda_codec *codec)
-{
-        unsigned int present;
-
-        present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0)
-                & AC_PINSENSE_PRESENCE;
-        snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
-                            present ? 0 : PIN_OUT);
-}
-
-static void alc267_quanta_il1_mic_automute(struct hda_codec *codec)
-{
-        unsigned int present;
-
-        present = snd_hda_codec_read(codec, 0x18, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-        snd_hda_codec_write(codec, 0x23, 0,
-                            AC_VERB_SET_CONNECT_SEL,
-                            present ? 0x00 : 0x01);
-}
-
-static void alc267_quanta_il1_automute(struct hda_codec *codec)
-{
-        alc267_quanta_il1_hp_automute(codec);
-        alc267_quanta_il1_mic_automute(codec);
-}
-
-static void alc267_quanta_il1_unsol_event(struct hda_codec *codec,
-                                           unsigned int res)
-{
-        switch (res >> 26) {
-        case ALC880_HP_EVENT:
-                alc267_quanta_il1_hp_automute(codec);
-                break;
-        case ALC880_MIC_EVENT:
-                alc267_quanta_il1_mic_automute(codec);
-                break;
-        }
+static void alc267_quanta_il1_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+        spec->autocfg.hp_pins[0] = 0x15;
+        spec->autocfg.speaker_pins[0] = 0x14;
+        spec->ext_mic.pin = 0x18;
+        spec->ext_mic.mux_idx = 0;
+        spec->int_mic.pin = 0x19;
+        spec->int_mic.mux_idx = 1;
+        spec->auto_mic = 1;
 }
 
@@ -11691 +12104 @@
 };
 
+static struct snd_kcontrol_new alc268_capture_nosrc_mixer[] = {
+        HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
+        {0} /* end */
+};
+
 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
-        {
-                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-                /* The multiple "Capture Source" controls confuse alsamixer
-                 * So call somewhat different..
-                 */
-                /* .name = "Capture Source", */
-                .name = "Input Source",
-                .count = 1,
-                .info = alc_mux_enum_info,
-                .get = alc_mux_enum_get,
-                .put = alc_mux_enum_put,
-        },
+        _DEFINE_CAPSRC(1),
         {0} /* end */
 };
@@ -11714 +12122 @@
         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
-        {
-                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-                /* The multiple "Capture Source" controls confuse alsamixer
-                 * So call somewhat different..
-                 */
-                /* .name = "Capture Source", */
-                .name = "Input Source",
-                .count = 2,
-                .info = alc_mux_enum_info,
-                .get = alc_mux_enum_get,
-                .put = alc_mux_enum_put,
-        },
+        _DEFINE_CAPSRC(2),
         {0} /* end */
 };
@@ -11812 +12209 @@
 {
         char name[32];
+        hda_nid_t dac;
         int err;
 
         sprintf(name, "%s Playback Volume", ctlname);
-        if (nid == 0x14) {
+        switch (nid) {
+        case 0x14:
+        case 0x16:
+                dac = 0x02;
+                break;
+        case 0x15:
+                dac = 0x03;
+                break;
+        default:
+                return 0;
+        }
+        if (spec->multiout.dac_nids[0] != dac &&
+            spec->multiout.dac_nids[1] != dac) {
                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
-                                  HDA_COMPOSE_AMP_VAL(0x02, 3, idx,
+                                  HDA_COMPOSE_AMP_VAL(dac, 3, idx,
                                                       HDA_OUTPUT));
                 if (err < 0)
                         return err;
-        } else if (nid == 0x15) {
-                err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
-                                  HDA_COMPOSE_AMP_VAL(0x03, 3, idx,
-                                                      HDA_OUTPUT));
-                if (err < 0)
-                        return err;
-        } else
-                return -1;
+                spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
+        }
+
         sprintf(name, "%s Playback Switch", ctlname);
-        err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
+        if (nid != 0x16)
+                err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
+        else /* mono */
+                err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
+                          HDA_COMPOSE_AMP_VAL(nid, 2, idx, HDA_OUTPUT));
         if (err < 0)
                 return err;
@@ -11844 +12253 @@
         int err;
 
-        spec->multiout.num_dacs = 2;    /* only use one dac */
         spec->multiout.dac_nids = spec->private_dac_nids;
-        spec->multiout.dac_nids[0] = 2;
-        spec->multiout.dac_nids[1] = 3;
 
         nid = cfg->line_out_pins[0];
-        if (nid)
-                alc268_new_analog_output(spec, nid, "Front", 0);
+        if (nid) {
+                const char *name;
+                if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
+                        name = "Speaker";
+                else
+                        name = "Front";
+                err = alc268_new_analog_output(spec, nid, name, 0);
+                if (err < 0)
+                        return err;
+        }
 
         nid = cfg->speaker_pins[0];
@@ -11860 +12274 @@
                 if (err < 0)
                         return err;
+        } else {
+                err = alc268_new_analog_output(spec, nid, "Speaker", 0);
+                if (err < 0)
+                        return err;
         }
         nid = cfg->hp_pins[0];
-        if (nid)
-                alc268_new_analog_output(spec, nid, "Headphone", 0);
+        if (nid) {
+                err = alc268_new_analog_output(spec, nid, "Headphone", 0);
+                if (err < 0)
+                        return err;
+        }
 
         nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
@@ -11869 +12290 @@
                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
                                   "Mono Playback Switch",
-                                  HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_INPUT));
+                                  HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT));
                 if (err < 0)
                         return err;
@@ -11877 +12298 @@
 
 /* create playback/capture controls for input pins */
-static int alc268_auto_create_analog_input_ctls(struct alc_spec *spec,
+static int alc268_auto_create_input_ctls(struct hda_codec *codec,
                                                 const struct auto_pin_cfg *cfg)
 {
-        struct hda_input_mux *imux = &spec->private_imux[0];
-        int i, idx1;
-
-        for (i = 0; i < AUTO_PIN_LAST; i++) {
-                switch(cfg->input_pins[i]) {
-                case 0x18:
-                        idx1 = 0;       /* Mic 1 */
-                        break;
-                case 0x19:
-                        idx1 = 1;       /* Mic 2 */
-                        break;
-                case 0x1a:
-                        idx1 = 2;       /* Line In */
-                        break;
-                case 0x1c:
-                        idx1 = 3;       /* CD */
-                        break;
-                case 0x12:
-                case 0x13:
-                        idx1 = 6;       /* digital mics */
-                        break;
-                default:
-                        continue;
-                }
-                imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
-                imux->items[imux->num_items].index = idx1;
-                imux->num_items++;
-        }
-        return 0;
+        return alc_auto_create_input_ctls(codec, cfg, 0, 0x23, 0x24);
 }
 
@@ -11955 +12348 @@
 }
 
-/* pcm configuration: identiacal with ALC880 */
+/* pcm configuration: identical with ALC880 */
 #define alc268_pcm_analog_playback      alc880_pcm_analog_playback
 #define alc268_pcm_analog_capture       alc880_pcm_analog_capture
@@ -11985 +12378 @@
         if (err < 0)
                 return err;
-        err = alc268_auto_create_analog_input_ctls(spec, &spec->autocfg);
+        err = alc268_auto_create_input_ctls(codec, &spec->autocfg);
         if (err < 0)
                 return err;
@@ -12004 +12397 @@
 
         add_verb(spec, alc268_volume_init_verbs);
-        spec->num_mux_defs = 1;
+        spec->num_mux_defs = 2;
         spec->input_mux = &spec->private_imux[0];
 
@@ -12010 +12403 @@
         if (err < 0)
                 return err;
+
+        alc_ssid_check(codec, 0x15, 0x1b, 0x14);
 
         return 1;
@@ -12058 +12453 @@
         SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
         SND_PCI_QUIRK(0x1028, 0x02b0, "Dell Inspiron Mini9", ALC268_DELL),
-        SND_PCI_QUIRK(0x103c, 0x30cc, "TOSHIBA", ALC268_TOSHIBA),
+        SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3000, "HP TX25xx series",
+                           ALC268_TOSHIBA),
         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
-        SND_PCI_QUIRK(0x1179, 0xff10, "TOSHIBA A205", ALC268_TOSHIBA),
-        SND_PCI_QUIRK(0x1179, 0xff50, "TOSHIBA A305", ALC268_TOSHIBA),
-        SND_PCI_QUIRK(0x1179, 0xff64, "TOSHIBA L305", ALC268_TOSHIBA),
+        SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
         SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
         SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
         SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
-        SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
+        SND_PCI_QUIRK(0x1854, 0x1775, "LG R510", ALC268_DELL),
+        {0}
+};
+
+/* Toshiba laptops have no unique PCI SSID but only codec SSID */
+static struct snd_pci_quirk alc268_ssid_cfg_tbl[] = {
+        SND_PCI_QUIRK(0x1179, 0xff0a, "TOSHIBA X-200", ALC268_AUTO),
+        SND_PCI_QUIRK(0x1179, 0xff0e, "TOSHIBA X-200 HDMI", ALC268_AUTO),
+        SND_PCI_QUIRK_MASK(0x1179, 0xff00, 0xff00, "TOSHIBA A/Lx05",
+                           ALC268_TOSHIBA),
         {0}
 };
@@ -12072 +12475 @@
 static struct alc_config_preset alc268_presets[] = {
         [ALC267_QUANTA_IL1] = {
-                .mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer },
+                .mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer,
+                            alc268_capture_nosrc_mixer },
                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
                                 alc267_quanta_il1_verbs },
@@ -12082 +12486 @@
                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
                 .channel_mode = alc268_modes,
-                .input_mux = &alc268_capture_source,
-                .unsol_event = alc267_quanta_il1_unsol_event,
-                .init_hook = alc267_quanta_il1_automute,
+                .unsol_event = alc_sku_unsol_event,
+                .setup = alc267_quanta_il1_setup,
+                .init_hook = alc_inithook,
         },
         [ALC268_3ST] = {
@@ -12102 +12506 @@
         },
         [ALC268_TOSHIBA] = {
-                .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
+                .mixers = { alc268_toshiba_mixer, alc268_capture_alt_mixer,
                             alc268_beep_mixer },
                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
@@ -12116 +12520 @@
                 .input_mux = &alc268_capture_source,
                 .unsol_event = alc268_toshiba_unsol_event,
+                .setup = alc268_toshiba_setup,
                 .init_hook = alc268_toshiba_automute,
         },
         [ALC268_ACER] = {
-                .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
+                .mixers = { alc268_acer_mixer, alc268_capture_nosrc_mixer,
                             alc268_beep_mixer },
                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
@@ -12155 +12560 @@
                 .mixers = { alc268_acer_aspire_one_mixer,
                             alc268_beep_mixer,
-                            alc268_capture_alt_mixer },
+                            alc268_capture_nosrc_mixer },
                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
                                 alc268_acer_aspire_one_verbs },
@@ -12166 +12571 @@
                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
                 .channel_mode = alc268_modes,
-                .input_mux = &alc268_acer_lc_capture_source,
                 .unsol_event = alc268_acer_lc_unsol_event,
+                .setup = alc268_acer_lc_setup,
                 .init_hook = alc268_acer_lc_init_hook,
         },
         [ALC268_DELL] = {
-                .mixers = { alc268_dell_mixer, alc268_beep_mixer },
+                .mixers = { alc268_dell_mixer, alc268_beep_mixer,
+                            alc268_capture_nosrc_mixer },
                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
                                 alc268_dell_verbs },
                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
                 .dac_nids = alc268_dac_nids,
+                .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
+                .adc_nids = alc268_adc_nids_alt,
+                .capsrc_nids = alc268_capsrc_nids,
                 .hp_nid = 0x02,
                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
                 .channel_mode = alc268_modes,
-                .unsol_event = alc268_dell_unsol_event,
-                .init_hook = alc268_dell_init_hook,
-                .input_mux = &alc268_capture_source,
+                .unsol_event = alc_sku_unsol_event,
+                .setup = alc268_dell_setup,
+                .init_hook = alc_inithook,
         },
         [ALC268_ZEPTO] = {
@@ -12198 +12607 @@
                 .channel_mode = alc268_modes,
                 .input_mux = &alc268_capture_source,
-                .unsol_event = alc268_toshiba_unsol_event,
-                .init_hook = alc268_toshiba_automute
+                .setup = alc268_toshiba_setup,
+                .init_hook = alc268_toshiba_automute,
         },
 #ifdef CONFIG_SND_DEBUG
@@ -12236 +12645 @@
                                                   alc268_cfg_tbl);
 
+        if (board_config < 0 || board_config >= ALC268_MODEL_LAST)
+                board_config = snd_hda_check_board_codec_sid_config(codec,
+                        ALC882_MODEL_LAST, alc268_models, alc268_ssid_cfg_tbl);
+
         if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
-                printk(KERN_INFO "hda_codec: Unknown model for ALC268, "
-                       "trying auto-probe from BIOS...\n");
+                printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
+                       codec->chip_name);
                 board_config = ALC268_AUTO;
         }
@@ -12257 +12670 @@
 
         if (board_config != ALC268_AUTO)
-                setup_preset(spec, &alc268_presets[board_config]);
-
-        if (codec->vendor_id == 0x10ec0267) {
-                spec->stream_name_analog = "ALC267 Analog";
-                spec->stream_name_digital = "ALC267 Digital";
-        } else {
-                spec->stream_name_analog = "ALC268 Analog";
-                spec->stream_name_digital = "ALC268 Digital";
-        }
+                setup_preset(codec, &alc268_presets[board_config]);
 
         spec->stream_analog_playback = &alc268_pcm_analog_playback;
@@ -12302 +12707 @@
 
                 /* get type */
-                wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
-                if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
+                wcap = get_wcaps_type(wcap);
+                if (spec->auto_mic ||
+                    wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
                         spec->adc_nids = alc268_adc_nids_alt;
                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
-                        add_mixer(spec, alc268_capture_alt_mixer);
+                        if (spec->auto_mic || spec->input_mux->num_items == 1)
+                                add_mixer(spec, alc268_capture_nosrc_mixer);
+                        else
+                                add_mixer(spec, alc268_capture_alt_mixer);
                 } else {
                         spec->adc_nids = alc268_adc_nids;
@@ -12317 +12726 @@
                         snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
                                 0, AC_VERB_SET_CONNECT_SEL,
+                                i < spec->num_mux_defs ?
+                                spec->input_mux[i].items[0].index :
                                 spec->input_mux->items[0].index);
         }
@@ -12350 +12761 @@
  *       not a mux!
  */
-
-static struct hda_input_mux alc269_eeepc_dmic_capture_source = {
-        .num_items = 2,
-        .items = {
-                { "i-Mic", 0x5 },
-                { "e-Mic", 0x0 },
-        },
-};
-
-static struct hda_input_mux alc269_eeepc_amic_capture_source = {
-        .num_items = 2,
-        .items = {
-                { "i-Mic", 0x1 },
-                { "e-Mic", 0x0 },
-        },
-};
 
 #define alc269_modes            alc260_modes
@@ -12429 +12824 @@
 };
 
-/* bind volumes of both NID 0x0c and 0x0d */
-static struct hda_bind_ctls alc269_epc_bind_vol = {
-        .ops = &snd_hda_bind_vol,
-        .values = {
-                HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
-                HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
-                0
-        },
-};
-
 static struct snd_kcontrol_new alc269_eeepc_mixer[] = {
-        HDA_CODEC_MUTE("iSpeaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
-        HDA_BIND_VOL("LineOut Playback Volume", &alc269_epc_bind_vol),
-        HDA_CODEC_MUTE("LineOut Playback Switch", 0x15, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
         {0} /* end */
 };
@@ -12455 +12841 @@
 
 /* FSC amilo */
-static struct snd_kcontrol_new alc269_fujitsu_mixer[] = {
-        HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
-        HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
-        HDA_BIND_VOL("PCM Playback Volume", &alc269_epc_bind_vol),
-        {0} /* end */
-};
+#define alc269_fujitsu_mixer    alc269_eeepc_mixer
 
 static struct hda_verb alc269_quanta_fl1_verbs[] = {
@@ -12542 +12923 @@
 }
 
-static void alc269_quanta_fl1_mic_automute(struct hda_codec *codec)
-{
-        unsigned int present;
-
-        present = snd_hda_codec_read(codec, 0x18, 0,
-                                AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-        snd_hda_codec_write(codec, 0x23, 0,
-                            AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x1);
-}
-
 static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
 {
@@ -12578 +12949 @@
                                     unsigned int res)
 {
-        if ((res >> 26) == ALC880_HP_EVENT)
+        switch (res >> 26) {
+        case ALC880_HP_EVENT:
                 alc269_quanta_fl1_speaker_automute(codec);
-        if ((res >> 26) == ALC880_MIC_EVENT)
-                alc269_quanta_fl1_mic_automute(codec);
+                break;
+        case ALC880_MIC_EVENT:
+                alc_mic_automute(codec);
+                break;
+        }
 }
 
@@ -12593 +12968 @@
 }
 
+static void alc269_quanta_fl1_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+        spec->ext_mic.pin = 0x18;
+        spec->ext_mic.mux_idx = 0;
+        spec->int_mic.pin = 0x19;
+        spec->int_mic.mux_idx = 1;
+        spec->auto_mic = 1;
+}
+
 static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
 {
         alc269_quanta_fl1_speaker_automute(codec);
-        alc269_quanta_fl1_mic_automute(codec);
+        alc_mic_automute(codec);
 }
 
@@ -12641 +13026 @@
 }
 
-static void alc269_eeepc_dmic_automute(struct hda_codec *codec)
-{
-        unsigned int present;
-
-        present = snd_hda_codec_read(codec, 0x18, 0,
-                                AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-        snd_hda_codec_write(codec, 0x23, 0,
-                                AC_VERB_SET_CONNECT_SEL,  (present ? 0 : 5));
-}
-
-static void alc269_eeepc_amic_automute(struct hda_codec *codec)
-{
-        unsigned int present;
-
-        present = snd_hda_codec_read(codec, 0x18, 0,
-                                AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-        snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
-                                0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
-        snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
-                                0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
-}
-
 /* unsolicited event for HP jack sensing */
-static void alc269_eeepc_dmic_unsol_event(struct hda_codec *codec,
+static void alc269_eeepc_unsol_event(struct hda_codec *codec,
                                      unsigned int res)
 {
-        if ((res >> 26) == ALC880_HP_EVENT)
+        switch (res >> 26) {
+        case ALC880_HP_EVENT:
                 alc269_speaker_automute(codec);
-
-        if ((res >> 26) == ALC880_MIC_EVENT)
-                alc269_eeepc_dmic_automute(codec);
-}
-
-static void alc269_eeepc_dmic_inithook(struct hda_codec *codec)
+                break;
+        case ALC880_MIC_EVENT:
+                alc_mic_automute(codec);
+                break;
+        }
+}
+
+static void alc269_eeepc_dmic_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+        spec->ext_mic.pin = 0x18;
+        spec->ext_mic.mux_idx = 0;
+        spec->int_mic.pin = 0x12;
+        spec->int_mic.mux_idx = 5;
+        spec->auto_mic = 1;
+}
+
+static void alc269_eeepc_amic_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+        spec->ext_mic.pin = 0x18;
+        spec->ext_mic.mux_idx = 0;
+        spec->int_mic.pin = 0x19;
+        spec->int_mic.mux_idx = 1;
+        spec->auto_mic = 1;
+}
+
+static void alc269_eeepc_inithook(struct hda_codec *codec)
 {
         alc269_speaker_automute(codec);
-        alc269_eeepc_dmic_automute(codec);
-}
-
-/* unsolicited event for HP jack sensing */
-static void alc269_eeepc_amic_unsol_event(struct hda_codec *codec,
-                                     unsigned int res)
-{
-        if ((res >> 26) == ALC880_HP_EVENT)
-                alc269_speaker_automute(codec);
-
-        if ((res >> 26) == ALC880_MIC_EVENT)
-                alc269_eeepc_amic_automute(codec);
-}
-
-static void alc269_eeepc_amic_inithook(struct hda_codec *codec)
-{
-        alc269_speaker_automute(codec);
-        alc269_eeepc_amic_automute(codec);
+        alc_mic_automute(codec);
 }
 
@@ -12767 +13136 @@
 };
 
-/* add playback controls from the parsed DAC table */
-static int alc269_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) {
-                err = add_control(spec, ALC_CTL_WIDGET_VOL,
-                                  "Front Playback Volume",
-                                  HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT));
-                if (err < 0)
-                        return err;
-                err = add_control(spec, ALC_CTL_WIDGET_MUTE,
-                                  "Front Playback Switch",
-                                  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
-                if (err < 0)
-                        return err;
-        }
-
-        nid = cfg->speaker_pins[0];
-        if (nid) {
-                if (!cfg->line_out_pins[0]) {
-                        err = add_control(spec, ALC_CTL_WIDGET_VOL,
-                                          "Speaker Playback Volume",
-                                          HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
-                                                              HDA_OUTPUT));
-                        if (err < 0)
-                                return err;
-                }
-                if (nid == 0x16) {
-                        err = add_control(spec, ALC_CTL_WIDGET_MUTE,
-                                          "Speaker Playback Switch",
-                                          HDA_COMPOSE_AMP_VAL(nid, 2, 0,
-                                                              HDA_OUTPUT));
-                        if (err < 0)
-                                return err;
-                } else {
-                        err = add_control(spec, ALC_CTL_WIDGET_MUTE,
-                                          "Speaker Playback Switch",
-                                          HDA_COMPOSE_AMP_VAL(nid, 3, 0,
-                                                              HDA_OUTPUT));
-                        if (err < 0)
-                                return err;
-                }
-        }
-        nid = cfg->hp_pins[0];
-        if (nid) {
-                /* spec->multiout.hp_nid = 2; */
-                if (!cfg->line_out_pins[0] && !cfg->speaker_pins[0]) {
-                        err = add_control(spec, ALC_CTL_WIDGET_VOL,
-                                          "Headphone Playback Volume",
-                                          HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
-                                                              HDA_OUTPUT));
-                        if (err < 0)
-                                return err;
-                }
-                if (nid == 0x16) {
-                        err = add_control(spec, ALC_CTL_WIDGET_MUTE,
-                                          "Headphone Playback Switch",
-                                          HDA_COMPOSE_AMP_VAL(nid, 2, 0,
-                                                              HDA_OUTPUT));
-                        if (err < 0)
-                                return err;
-                } else {
-                        err = add_control(spec, ALC_CTL_WIDGET_MUTE,
-                                          "Headphone Playback Switch",
-                                          HDA_COMPOSE_AMP_VAL(nid, 3, 0,
-                                                              HDA_OUTPUT));
-                        if (err < 0)
-                                return err;
-                }
-        }
-        return 0;
-}
-
-static int alc269_auto_create_analog_input_ctls(struct alc_spec *spec,
-                                                const struct auto_pin_cfg *cfg)
-{
-        int err;
-
-        err = alc880_auto_create_analog_input_ctls(spec, cfg);
-        if (err < 0)
-                return err;
-        /* digital-mic input pin is excluded in alc880_auto_create..()
-         * because it's under 0x18
-         */
-        if (cfg->input_pins[AUTO_PIN_MIC] == 0x12 ||
-            cfg->input_pins[AUTO_PIN_FRONT_MIC] == 0x12) {
-                struct hda_input_mux *imux = &spec->private_imux[0];
-                imux->items[imux->num_items].label = "Int Mic";
-                imux->items[imux->num_items].index = 0x05;
-                imux->num_items++;
-        }
-        return 0;
-}
+#define alc269_auto_create_multi_out_ctls \
+        alc268_auto_create_multi_out_ctls
+#define alc269_auto_create_input_ctls \
+        alc268_auto_create_input_ctls
 
 #ifdef CONFIG_SND_HDA_POWER_SAVE
@@ -12873 +13145 @@
 #endif
 
-/* pcm configuration: identiacal with ALC880 */
+/* pcm configuration: identical with ALC880 */
 #define alc269_pcm_analog_playback      alc880_pcm_analog_playback
 #define alc269_pcm_analog_capture       alc880_pcm_analog_capture
@@ -12917 +13189 @@
         if (err < 0)
                 return err;
-        err = alc269_auto_create_analog_input_ctls(spec, &spec->autocfg);
+        err = alc269_auto_create_input_ctls(codec, &spec->autocfg);
         if (err < 0)
                 return err;
@@ -12942 +13214 @@
 
         if (!spec->cap_mixer && !spec->no_analog)
-                set_capture_mixer(spec);
+                set_capture_mixer(codec);
+
+        alc_ssid_check(codec, 0x15, 0x1b, 0x14);
 
         return 1;
@@ -13016 +13290 @@
                 .input_mux = &alc269_capture_source,
                 .unsol_event = alc269_quanta_fl1_unsol_event,
+                .setup = alc269_quanta_fl1_setup,
                 .init_hook = alc269_quanta_fl1_init_hook,
         },
@@ -13028 +13303 @@
                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
                 .channel_mode = alc269_modes,
-                .input_mux = &alc269_eeepc_amic_capture_source,
-                .unsol_event = alc269_eeepc_amic_unsol_event,
-                .init_hook = alc269_eeepc_amic_inithook,
+                .unsol_event = alc269_eeepc_unsol_event,
+                .setup = alc269_eeepc_amic_setup,
+                .init_hook = alc269_eeepc_inithook,
         },
         [ALC269_ASUS_EEEPC_P901] = {
@@ -13042 +13317 @@
                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
                 .channel_mode = alc269_modes,
-                .input_mux = &alc269_eeepc_dmic_capture_source,
-                .unsol_event = alc269_eeepc_dmic_unsol_event,
-                .init_hook = alc269_eeepc_dmic_inithook,
+                .unsol_event = alc269_eeepc_unsol_event,
+                .setup = alc269_eeepc_dmic_setup,
+                .init_hook = alc269_eeepc_inithook,
         },
         [ALC269_FUJITSU] = {
@@ -13056 +13331 @@
                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
                 .channel_mode = alc269_modes,
-                .input_mux = &alc269_eeepc_dmic_capture_source,
-                .unsol_event = alc269_eeepc_dmic_unsol_event,
-                .init_hook = alc269_eeepc_dmic_inithook,
+                .unsol_event = alc269_eeepc_unsol_event,
+                .setup = alc269_eeepc_dmic_setup,
+                .init_hook = alc269_eeepc_inithook,
         },
         [ALC269_LIFEBOOK] = {
@@ -13093 +13368 @@
 
         if (board_config < 0) {
-                printk(KERN_INFO "hda_codec: Unknown model for ALC269, "
-                       "trying auto-probe from BIOS...\n");
+                printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
+                       codec->chip_name);
                 board_config = ALC269_AUTO;
         }
@@ -13119 +13394 @@
 
         if (board_config != ALC269_AUTO)
-                setup_preset(spec, &alc269_presets[board_config]);
-
-        spec->stream_name_analog = "ALC269 Analog";
+                setup_preset(codec, &alc269_presets[board_config]);
+
         if (codec->subsystem_id == 0x17aa3bf8) {
                 /* Due to a hardware problem on Lenovo Ideadpad, we need to
@@ -13132 +13406 @@
                 spec->stream_analog_capture = &alc269_pcm_analog_capture;
         }
-        spec->stream_name_digital = "ALC269 Digital";
         spec->stream_digital_playback = &alc269_pcm_digital_playback;
         spec->stream_digital_capture = &alc269_pcm_digital_capture;
@@ -13140 +13413 @@
         spec->capsrc_nids = alc269_capsrc_nids;
         if (!spec->cap_mixer)
-                set_capture_mixer(spec);
+                set_capture_mixer(codec);
         set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
+
+        spec->vmaster_nid = 0x02;
 
         codec->patch_ops = alc_patch_ops;
@@ -13282 +13557 @@
         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
+
         {0} /* end */
 };
@@ -13687 +13963 @@
         {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)},
+        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(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)},
+        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
+        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(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)},
+        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
+        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
 
         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},  /* set Mic 1 */
@@ -13736 +14012 @@
 }
 
-/* pcm configuration: identiacal with ALC880 */
+/* pcm configuration: identical with ALC880 */
 #define alc861_pcm_analog_playback      alc880_pcm_analog_playback
 #define alc861_pcm_analog_capture       alc880_pcm_analog_capture
@@ -13775 +14051 @@
 };
 
+static hda_nid_t alc861_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
+{
+        struct alc_spec *spec = codec->spec;
+        hda_nid_t mix, srcs[5];
+        int i, j, num;
+
+        if (snd_hda_get_connections(codec, pin, &mix, 1) != 1)
+                return 0;
+        num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
+        if (num < 0)
+                return 0;
+        for (i = 0; i < num; i++) {
+                unsigned int type;
+                type = get_wcaps_type(get_wcaps(codec, srcs[i]));
+                if (type != AC_WID_AUD_OUT)
+                        continue;
+                for (j = 0; j < spec->multiout.num_dacs; j++)
+                        if (spec->multiout.dac_nids[j] == srcs[i])
+                                break;
+                if (j >= spec->multiout.num_dacs)
+                        return srcs[i];
+        }
+        return 0;
+}
+
 /* fill in the dac_nids table from the parsed pin configuration */
-static int alc861_auto_fill_dac_nids(struct alc_spec *spec,
+static int alc861_auto_fill_dac_nids(struct hda_codec *codec,
                                      const struct auto_pin_cfg *cfg)
 {
+        struct alc_spec *spec = codec->spec;
         int i;
-        hda_nid_t nid;
+        hda_nid_t nid, dac;
 
         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];
-                }
+                dac = alc861_look_for_dac(codec, nid);
+                if (!dac)
+                        continue;
+                spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
         }
-        spec->multiout.num_dacs = cfg->line_outs;
         return 0;
 }
 
+static int alc861_create_out_sw(struct hda_codec *codec, const char *pfx,
+                                hda_nid_t nid, unsigned int chs)
+{
+        char name[32];
+        snprintf(name, sizeof(name), "%s Playback Switch", pfx);
+        return add_control(codec->spec, ALC_CTL_WIDGET_MUTE, name,
+                           HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
+}
+
 /* add playback controls from the parsed DAC table */
-static int alc861_auto_create_multi_out_ctls(struct alc_spec *spec,
+static int alc861_auto_create_multi_out_ctls(struct hda_codec *codec,
                                              const struct auto_pin_cfg *cfg)
 {
-        char name[32];
+        struct alc_spec *spec = codec->spec;
         static const char *chname[4] = {
                 "Front", "Surround", NULL /*CLFE*/, "Side"
         };
         hda_nid_t nid;
-        int i, idx, err;
+        int i, err;
+
+        if (cfg->line_outs == 1) {
+                const char *pfx = NULL;
+                if (!cfg->hp_outs)
+                        pfx = "Master";
+                else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
+                        pfx = "Speaker";
+                if (pfx) {
+                        nid = spec->multiout.dac_nids[0];
+                        return alc861_create_out_sw(codec, pfx, nid, 3);
+                }
+        }
 
         for (i = 0; i < cfg->line_outs; i++) {
@@ -13810 +14131 @@
                 if (!nid)
                         continue;
-                if (nid == 0x05) {
+                if (i == 2) {
                         /* Center/LFE */
-                        err = add_control(spec, ALC_CTL_BIND_MUTE,
-                                          "Center Playback Switch",
-                                          HDA_COMPOSE_AMP_VAL(nid, 1, 0,
-                                                              HDA_OUTPUT));
+                        err = alc861_create_out_sw(codec, "Center", nid, 1);
                         if (err < 0)
                                 return err;
-                        err = add_control(spec, ALC_CTL_BIND_MUTE,
-                                          "LFE Playback Switch",
-                                          HDA_COMPOSE_AMP_VAL(nid, 2, 0,
-                                                              HDA_OUTPUT));
+                        err = alc861_create_out_sw(codec, "LFE", nid, 2);
                         if (err < 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]);
-                        err = add_control(spec, ALC_CTL_BIND_MUTE, name,
-                                          HDA_COMPOSE_AMP_VAL(nid, 3, 0,
-                                                              HDA_OUTPUT));
+                        err = alc861_create_out_sw(codec, chname[i], nid, 3);
                         if (err < 0)
                                 return err;
@@ -13840 +14148 @@
 }
 
-static int alc861_auto_create_hp_ctls(struct alc_spec *spec, hda_nid_t pin)
-{
+static int alc861_auto_create_hp_ctls(struct hda_codec *codec, hda_nid_t pin)
+{
+        struct alc_spec *spec = codec->spec;
         int err;
         hda_nid_t nid;
@@ -13849 +14158 @@
 
         if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
-                nid = 0x03;
-                err = add_control(spec, ALC_CTL_WIDGET_MUTE,
-                                  "Headphone Playback Switch",
-                                  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
-                if (err < 0)
-                        return err;
-                spec->multiout.hp_nid = nid;
+                nid = alc861_look_for_dac(codec, pin);
+                if (nid) {
+                        err = alc861_create_out_sw(codec, "Headphone", nid, 3);
+                        if (err < 0)
+                                return err;
+                        spec->multiout.hp_nid = nid;
+                }
         }
         return 0;
@@ -13861 +14170 @@
 
 /* create playback/capture controls for input pins */
-static int alc861_auto_create_analog_input_ctls(struct alc_spec *spec,
+static int alc861_auto_create_input_ctls(struct hda_codec *codec,
                                                 const struct auto_pin_cfg *cfg)
 {
-        struct hda_input_mux *imux = &spec->private_imux[0];
-        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;
+        return alc_auto_create_input_ctls(codec, cfg, 0x15, 0x08, 0);
 }
 
 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
                                               hda_nid_t nid,
-                                              int pin_type, int dac_idx)
-{
+                                              int pin_type, hda_nid_t dac)
+{
+        hda_nid_t mix, srcs[5];
+        int i, num;
+
         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,
+        snd_hda_codec_write(codec, dac, 0, AC_VERB_SET_AMP_GAIN_MUTE,
                             AMP_OUT_UNMUTE);
+        if (snd_hda_get_connections(codec, nid, &mix, 1) != 1)
+                return;
+        num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
+        if (num < 0)
+                return;
+        for (i = 0; i < num; i++) {
+                unsigned int mute;
+                if (srcs[i] == dac || srcs[i] == 0x15)
+                        mute = AMP_IN_UNMUTE(i);
+                else
+                        mute = AMP_IN_MUTE(i);
+                snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
+                                    mute);
+        }
 }
 
@@ -13920 +14208 @@
         int i;
 
-        alc_subsystem_id(codec, 0x0e, 0x0f, 0x0b);
         for (i = 0; i < spec->autocfg.line_outs; i++) {
                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
@@ -13936 +14223 @@
 
         pin = spec->autocfg.hp_pins[0];
-        if (pin) /* connect to front */
+        if (pin)
                 alc861_auto_set_output_and_unmute(codec, pin, PIN_HP,
-                                                  spec->multiout.dac_nids[0]);
+                                                  spec->multiout.hp_nid);
         pin = spec->autocfg.speaker_pins[0];
         if (pin)
-                alc861_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
+                alc861_auto_set_output_and_unmute(codec, pin, PIN_OUT,
+                                                  spec->multiout.dac_nids[0]);
 }
 
@@ -13973 +14261 @@
                 return 0; /* can't find valid BIOS pin config */
 
-        err = alc861_auto_fill_dac_nids(spec, &spec->autocfg);
+        err = alc861_auto_fill_dac_nids(codec, &spec->autocfg);
         if (err < 0)
                 return err;
-        err = alc861_auto_create_multi_out_ctls(spec, &spec->autocfg);
+        err = alc861_auto_create_multi_out_ctls(codec, &spec->autocfg);
         if (err < 0)
                 return err;
-        err = alc861_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
+        err = alc861_auto_create_hp_ctls(codec, spec->autocfg.hp_pins[0]);
         if (err < 0)
                 return err;
-        err = alc861_auto_create_analog_input_ctls(spec, &spec->autocfg);
+        err = alc861_auto_create_input_ctls(codec, &spec->autocfg);
         if (err < 0)
                 return err;
@@ -14001 +14289 @@
         spec->adc_nids = alc861_adc_nids;
         spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
-        set_capture_mixer(spec);
+        set_capture_mixer(codec);
+
+        alc_ssid_check(codec, 0x0e, 0x0f, 0x0b);
 
         return 1;
@@ -14192 +14482 @@
 
         if (board_config < 0) {
-                printk(KERN_INFO "hda_codec: Unknown model for ALC861, "
-                       "trying auto-probe from BIOS...\n");
+                printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
+                       codec->chip_name);
                 board_config = ALC861_AUTO;
         }
@@ -14218 +14508 @@
 
         if (board_config != ALC861_AUTO)
-                setup_preset(spec, &alc861_presets[board_config]);
-
-        spec->stream_name_analog = "ALC861 Analog";
+                setup_preset(codec, &alc861_presets[board_config]);
+
         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;
@@ -14260 +14548 @@
 /* dac_nids for ALC660vd are in a different order - according to
  * Realtek's driver.
- * This should probably tesult in a different mixer for 6stack models
+ * This should probably result in a different mixer for 6stack models
  * of ALC660vd codecs, but for now there is only 3stack mixer
  * - and it is the same as in 861vd.
@@ -14611 +14899 @@
 };
 
-/* toggle speaker-output according to the hp-jack state */
-static void alc861vd_lenovo_hp_automute(struct hda_codec *codec)
-{
-        unsigned int present;
-        unsigned char bits;
-
-        present = snd_hda_codec_read(codec, 0x1b, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-        bits = present ? HDA_AMP_MUTE : 0;
-        snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
-                                 HDA_AMP_MUTE, bits);
-}
-
 static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
 {
@@ -14636 +14911 @@
 }
 
-static void alc861vd_lenovo_automute(struct hda_codec *codec)
-{
-        alc861vd_lenovo_hp_automute(codec);
+static void alc861vd_lenovo_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+        spec->autocfg.hp_pins[0] = 0x1b;
+        spec->autocfg.speaker_pins[0] = 0x14;
+}
+
+static void alc861vd_lenovo_init_hook(struct hda_codec *codec)
+{
+        alc_automute_amp(codec);
         alc861vd_lenovo_mic_automute(codec);
 }
@@ -14646 +14928 @@
 {
         switch (res >> 26) {
-        case ALC880_HP_EVENT:
-                alc861vd_lenovo_hp_automute(codec);
-                break;
         case ALC880_MIC_EVENT:
                 alc861vd_lenovo_mic_automute(codec);
+                break;
+        default:
+                alc_automute_amp_unsol_event(codec, res);
                 break;
         }
@@ -14701 +14983 @@
 
 /* toggle speaker-output according to the hp-jack state */
-static void alc861vd_dallas_automute(struct hda_codec *codec)
-{
-        unsigned int present;
-
-        present = snd_hda_codec_read(codec, 0x15, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-        snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
-                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
-}
-
-static void alc861vd_dallas_unsol_event(struct hda_codec *codec, unsigned int res)
-{
-        if ((res >> 26) == ALC880_HP_EVENT)
-                alc861vd_dallas_automute(codec);
+static void alc861vd_dallas_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        spec->autocfg.hp_pins[0] = 0x15;
+        spec->autocfg.speaker_pins[0] = 0x14;
 }
 
@@ -14721 +14995 @@
 #endif
 
-/* pcm configuration: identiacal with ALC880 */
+/* pcm configuration: identical with ALC880 */
 #define alc861vd_pcm_analog_playback    alc880_pcm_analog_playback
 #define alc861vd_pcm_analog_capture     alc880_pcm_analog_capture
@@ -14753 +15027 @@
         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
         /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
-        SND_PCI_QUIRK(0x1179, 0xff01, "DALLAS", ALC861VD_DALLAS),
+        SND_PCI_QUIRK(0x1179, 0xff01, "Toshiba A135", ALC861VD_LENOVO),
         SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
@@ -14828 +15102 @@
                 .input_mux = &alc861vd_capture_source,
                 .unsol_event = alc861vd_lenovo_unsol_event,
-                .init_hook = alc861vd_lenovo_automute,
+                .setup = alc861vd_lenovo_setup,
+                .init_hook = alc861vd_lenovo_init_hook,
         },
         [ALC861VD_DALLAS] = {
@@ -14838 +15113 @@
                 .channel_mode = alc861vd_3stack_2ch_modes,
                 .input_mux = &alc861vd_dallas_capture_source,
-                .unsol_event = alc861vd_dallas_unsol_event,
-                .init_hook = alc861vd_dallas_automute,
+                .unsol_event = alc_automute_amp_unsol_event,
+                .setup = alc861vd_dallas_setup,
+                .init_hook = alc_automute_amp,
         },
         [ALC861VD_HP] = {
@@ -14850 +15126 @@
                 .channel_mode = alc861vd_3stack_2ch_modes,
                 .input_mux = &alc861vd_hp_capture_source,
-                .unsol_event = alc861vd_dallas_unsol_event,
-                .init_hook = alc861vd_dallas_automute,
+                .unsol_event = alc_automute_amp_unsol_event,
+                .setup = alc861vd_dallas_setup,
+                .init_hook = alc_automute_amp,
         },
         [ALC660VD_ASUS_V1S] = {
@@ -14866 +15143 @@
                 .input_mux = &alc861vd_capture_source,
                 .unsol_event = alc861vd_lenovo_unsol_event,
-                .init_hook = alc861vd_lenovo_automute,
+                .setup = alc861vd_lenovo_setup,
+                .init_hook = alc861vd_lenovo_init_hook,
         },
 };
@@ -14873 +15151 @@
  * BIOS auto configuration
  */
+static int alc861vd_auto_create_input_ctls(struct hda_codec *codec,
+                                                const struct auto_pin_cfg *cfg)
+{
+        return alc_auto_create_input_ctls(codec, cfg, 0x15, 0x09, 0);
+}
+
+
 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
                                 hda_nid_t nid, int pin_type, int dac_idx)
@@ -14884 +15169 @@
         int i;
 
-        alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
         for (i = 0; i <= HDA_SIDE; i++) {
                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
@@ -14901 +15185 @@
 
         pin = spec->autocfg.hp_pins[0];
-        if (pin) /* connect to front and  use dac 0 */
+        if (pin) /* connect to front and use dac 0 */
                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
         pin = spec->autocfg.speaker_pins[0];
@@ -14908 +15192 @@
 }
 
-#define alc861vd_is_input_pin(nid)      alc880_is_input_pin(nid)
 #define ALC861VD_PIN_CD_NID             ALC880_PIN_CD_NID
 
@@ -14918 +15201 @@
         for (i = 0; i < AUTO_PIN_LAST; i++) {
                 hda_nid_t nid = spec->autocfg.input_pins[i];
-                if (alc861vd_is_input_pin(nid)) {
+                if (alc_is_input_pin(codec, nid)) {
                         alc_set_input_pin(codec, nid, i);
                         if (nid != ALC861VD_PIN_CD_NID &&
@@ -14982 +15265 @@
                                 return err;
                 } else {
-                        sprintf(name, "%s Playback Volume", chname[i]);
+                        const char *pfx;
+                        if (cfg->line_outs == 1 &&
+                            cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
+                                if (!cfg->hp_pins)
+                                        pfx = "Speaker";
+                                else
+                                        pfx = "PCM";
+                        } else
+                                pfx = chname[i];
+                        sprintf(name, "%s Playback Volume", pfx);
                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
                                           HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
@@ -14988 +15280 @@
                         if (err < 0)
                                 return err;
-                        sprintf(name, "%s Playback Switch", chname[i]);
+                        if (cfg->line_outs == 1 &&
+                            cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
+                                pfx = "Speaker";
+                        sprintf(name, "%s Playback Switch", pfx);
                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
                                           HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
@@ -15081 +15376 @@
         if (err < 0)
                 return err;
-        err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
+        err = alc861vd_auto_create_input_ctls(codec, &spec->autocfg);
         if (err < 0)
                 return err;
@@ -15101 +15396 @@
         if (err < 0)
                 return err;
+
+        alc_ssid_check(codec, 0x15, 0x1b, 0x14);
 
         return 1;
@@ -15133 +15430 @@
 
         if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
-                printk(KERN_INFO "hda_codec: Unknown model for ALC660VD/"
-                        "ALC861VD, trying auto-probe from BIOS...\n");
+                printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
+                       codec->chip_name);
                 board_config = ALC861VD_AUTO;
         }
@@ -15159 +15456 @@
 
         if (board_config != ALC861VD_AUTO)
-                setup_preset(spec, &alc861vd_presets[board_config]);
+                setup_preset(codec, &alc861vd_presets[board_config]);
 
         if (codec->vendor_id == 0x10ec0660) {
-                spec->stream_name_analog = "ALC660-VD Analog";
-                spec->stream_name_digital = "ALC660-VD Digital";
                 /* always turn on EAPD */
                 add_verb(spec, alc660vd_eapd_verbs);
-        } else {
-                spec->stream_name_analog = "ALC861VD Analog";
-                spec->stream_name_digital = "ALC861VD Digital";
         }
 
@@ -15177 +15469 @@
         spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
 
-        spec->adc_nids = alc861vd_adc_nids;
-        spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
-        spec->capsrc_nids = alc861vd_capsrc_nids;
-        spec->capture_style = CAPT_MIX;
-
-        set_capture_mixer(spec);
+        if (!spec->adc_nids) {
+                spec->adc_nids = alc861vd_adc_nids;
+                spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
+        }
+        if (!spec->capsrc_nids)
+                spec->capsrc_nids = alc861vd_capsrc_nids;
+
+        set_capture_mixer(codec);
         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
 
@@ -15223 +15517 @@
 };
 
-static hda_nid_t alc662_adc_nids[1] = {
+static hda_nid_t alc662_adc_nids[2] = {
         /* ADC1-2 */
-        0x09,
+        0x09, 0x08
 };
 
@@ -15233 +15527 @@
 };
 
-static hda_nid_t alc662_capsrc_nids[1] = { 0x22 };
+static hda_nid_t alc662_capsrc_nids[2] = { 0x22, 0x23 };
 static hda_nid_t alc272_capsrc_nids[1] = { 0x23 };
 
@@ -15257 +15551 @@
 };
 
-static struct hda_input_mux alc662_eeepc_capture_source = {
-        .num_items = 2,
-        .items = {
-                { "i-Mic", 0x1 },
-                { "e-Mic", 0x0 },
-        },
-};
-
 static struct hda_input_mux alc663_capture_source = {
         .num_items = 3,
@@ -15274 +15560 @@
 };
 
-static struct hda_input_mux alc663_m51va_capture_source = {
-        .num_items = 2,
+#if 0 /* set to 1 for testing other input sources below */
+static struct hda_input_mux alc272_nc10_capture_source = {
+        .num_items = 16,
         .items = {
-                { "Ext-Mic", 0x0 },
-                { "D-Mic", 0x9 },
-        },
-};
+                { "Autoselect Mic", 0x0 },
+                { "Internal Mic", 0x1 },
+                { "In-0x02", 0x2 },
+                { "In-0x03", 0x3 },
+                { "In-0x04", 0x4 },
+                { "In-0x05", 0x5 },
+                { "In-0x06", 0x6 },
+                { "In-0x07", 0x7 },
+                { "In-0x08", 0x8 },
+                { "In-0x09", 0x9 },
+                { "In-0x0a", 0x0a },
+                { "In-0x0b", 0x0b },
+                { "In-0x0c", 0x0c },
+                { "In-0x0d", 0x0d },
+                { "In-0x0e", 0x0e },
+                { "In-0x0f", 0x0f },
+        },
+};
+#endif
 
 /*
@@ -15421 +15723 @@
 
 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
-        HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
-
-        HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT),
-        HDA_CODEC_MUTE("Line-Out Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
+        ALC262_HIPPO_MASTER_SWITCH,
 
         HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT),
@@ -15437 +15737 @@
 
 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
-        HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT),
-        HDA_CODEC_MUTE("Line-Out Playback Switch", 0x14, 0x0, HDA_OUTPUT),
+        ALC262_HIPPO_MASTER_SWITCH,
+        HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
-        HDA_BIND_MUTE("Surround Playback Switch", 0x03, 2, HDA_INPUT),
         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
-        HDA_BIND_MUTE_MONO("Center Playback Switch", 0x04, 1, 2, HDA_INPUT),
-        HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x04, 2, 2, HDA_INPUT),
-        HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
         HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
@@ -15933 +16229 @@
 }
 
-static void alc662_eeepc_mic_automute(struct hda_codec *codec)
-{
-        unsigned int present;
-
-        present = snd_hda_codec_read(codec, 0x18, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-        snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
-                            0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
-        snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
-                            0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
-        snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
-                            0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
-        snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
-                            0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
-}
-
 /* unsolicited event for HP jack sensing */
 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
                                      unsigned int res)
 {
-        if ((res >> 26) == ALC880_HP_EVENT)
-                alc262_hippo1_automute( codec );
-
         if ((res >> 26) == ALC880_MIC_EVENT)
-                alc662_eeepc_mic_automute(codec);
+                alc_mic_automute(codec);
+        else
+                alc262_hippo_unsol_event(codec, res);
+}
+
+static void alc662_eeepc_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        alc262_hippo1_setup(codec);
+        spec->ext_mic.pin = 0x18;
+        spec->ext_mic.mux_idx = 0;
+        spec->int_mic.pin = 0x19;
+        spec->int_mic.mux_idx = 1;
+        spec->auto_mic = 1;
 }
 
 static void alc662_eeepc_inithook(struct hda_codec *codec)
 {
-        alc262_hippo1_automute( codec );
-        alc662_eeepc_mic_automute(codec);
-}
-
-static void alc662_eeepc_ep20_automute(struct hda_codec *codec)
-{
-        unsigned int mute;
-        unsigned int present;
-
-        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);
-        present = (present & 0x80000000) != 0;
-        if (present) {
-                /* mute internal speaker */
-                snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
-                                        HDA_AMP_MUTE, HDA_AMP_MUTE);
-        } else {
-                /* unmute internal speaker if necessary */
-                mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
-                snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
-                                        HDA_AMP_MUTE, mute);
-        }
-}
-
-/* unsolicited event for HP jack sensing */
-static void alc662_eeepc_ep20_unsol_event(struct hda_codec *codec,
-                                          unsigned int res)
-{
-        if ((res >> 26) == ALC880_HP_EVENT)
-                alc662_eeepc_ep20_automute(codec);
-}
-
-static void alc662_eeepc_ep20_inithook(struct hda_codec *codec)
-{
-        alc662_eeepc_ep20_automute(codec);
-}
+        alc262_hippo_automute(codec);
+        alc_mic_automute(codec);
+}
+
+static void alc662_eeepc_ep20_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        spec->autocfg.hp_pins[0] = 0x14;
+        spec->autocfg.speaker_pins[0] = 0x1b;
+}
+
+#define alc662_eeepc_ep20_inithook      alc262_hippo_master_update
 
 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
@@ -16110 +16377 @@
 }
 
-static void alc663_m51va_mic_automute(struct hda_codec *codec)
-{
-        unsigned int present;
-
-        present = snd_hda_codec_read(codec, 0x18, 0,
-                        AC_VERB_GET_PIN_SENSE, 0)
-                        & AC_PINSENSE_PRESENCE;
-        snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
-                        0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
-        snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
-                        0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
-        snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
-                        0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
-        snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
-                        0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
-}
-
 static void alc663_m51va_unsol_event(struct hda_codec *codec,
                                            unsigned int res)
@@ -16135 +16385 @@
                 break;
         case ALC880_MIC_EVENT:
-                alc663_m51va_mic_automute(codec);
+                alc_mic_automute(codec);
                 break;
         }
 }
 
+static void alc663_m51va_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+        spec->ext_mic.pin = 0x18;
+        spec->ext_mic.mux_idx = 0;
+        spec->int_mic.pin = 0x12;
+        spec->int_mic.mux_idx = 1;
+        spec->auto_mic = 1;
+}
+
 static void alc663_m51va_inithook(struct hda_codec *codec)
 {
         alc663_m51va_speaker_automute(codec);
-        alc663_m51va_mic_automute(codec);
+        alc_mic_automute(codec);
 }
 
 /* ***************** Mode1 ******************************/
-static void alc663_mode1_unsol_event(struct hda_codec *codec,
-                                           unsigned int res)
-{
-        switch (res >> 26) {
-        case ALC880_HP_EVENT:
-                alc663_m51va_speaker_automute(codec);
-                break;
-        case ALC880_MIC_EVENT:
-                alc662_eeepc_mic_automute(codec);
-                break;
-        }
-}
-
-static void alc663_mode1_inithook(struct hda_codec *codec)
-{
-        alc663_m51va_speaker_automute(codec);
-        alc662_eeepc_mic_automute(codec);
-}
+#define alc663_mode1_unsol_event        alc663_m51va_unsol_event
+#define alc663_mode1_setup              alc663_m51va_setup
+#define alc663_mode1_inithook           alc663_m51va_inithook
+
 /* ***************** Mode2 ******************************/
 static void alc662_mode2_unsol_event(struct hda_codec *codec,
@@ -16174 +16420 @@
                 break;
         case ALC880_MIC_EVENT:
-                alc662_eeepc_mic_automute(codec);
+                alc_mic_automute(codec);
                 break;
         }
 }
 
+#define alc662_mode2_setup      alc663_m51va_setup
+
 static void alc662_mode2_inithook(struct hda_codec *codec)
 {
         alc662_f5z_speaker_automute(codec);
-        alc662_eeepc_mic_automute(codec);
+        alc_mic_automute(codec);
 }
 /* ***************** Mode3 ******************************/
@@ -16193 +16441 @@
                 break;
         case ALC880_MIC_EVENT:
-                alc662_eeepc_mic_automute(codec);
+                alc_mic_automute(codec);
                 break;
         }
 }
 
+#define alc663_mode3_setup      alc663_m51va_setup
+
 static void alc663_mode3_inithook(struct hda_codec *codec)
 {
         alc663_two_hp_m1_speaker_automute(codec);
-        alc662_eeepc_mic_automute(codec);
+        alc_mic_automute(codec);
 }
 /* ***************** Mode4 ******************************/
@@ -16212 +16462 @@
                 break;
         case ALC880_MIC_EVENT:
-                alc662_eeepc_mic_automute(codec);
+                alc_mic_automute(codec);
                 break;
         }
 }
 
+#define alc663_mode4_setup      alc663_m51va_setup
+
 static void alc663_mode4_inithook(struct hda_codec *codec)
 {
         alc663_21jd_two_speaker_automute(codec);
-        alc662_eeepc_mic_automute(codec);
+        alc_mic_automute(codec);
 }
 /* ***************** Mode5 ******************************/
@@ -16231 +16483 @@
                 break;
         case ALC880_MIC_EVENT:
-                alc662_eeepc_mic_automute(codec);
+                alc_mic_automute(codec);
                 break;
         }
 }
 
+#define alc663_mode5_setup      alc663_m51va_setup
+
 static void alc663_mode5_inithook(struct hda_codec *codec)
 {
         alc663_15jd_two_speaker_automute(codec);
-        alc662_eeepc_mic_automute(codec);
+        alc_mic_automute(codec);
 }
 /* ***************** Mode6 ******************************/
@@ -16250 +16504 @@
                 break;
         case ALC880_MIC_EVENT:
-                alc662_eeepc_mic_automute(codec);
+                alc_mic_automute(codec);
                 break;
         }
 }
 
+#define alc663_mode6_setup      alc663_m51va_setup
+
 static void alc663_mode6_inithook(struct hda_codec *codec)
 {
         alc663_two_hp_m2_speaker_automute(codec);
-        alc662_eeepc_mic_automute(codec);
+        alc_mic_automute(codec);
 }
 
@@ -16300 +16556 @@
                 break;
         case ALC880_MIC_EVENT:
-                alc662_eeepc_mic_automute(codec);
+                alc_mic_automute(codec);
                 break;
         }
 }
 
+#define alc663_g71v_setup       alc663_m51va_setup
+
 static void alc663_g71v_inithook(struct hda_codec *codec)
 {
         alc663_g71v_front_automute(codec);
         alc663_g71v_hp_automute(codec);
-        alc662_eeepc_mic_automute(codec);
+        alc_mic_automute(codec);
 }
 
@@ -16320 +16578 @@
                 break;
         case ALC880_MIC_EVENT:
-                alc662_eeepc_mic_automute(codec);
+                alc_mic_automute(codec);
                 break;
         }
 }
 
+#define alc663_g50v_setup       alc663_m51va_setup
+
 static void alc663_g50v_inithook(struct hda_codec *codec)
 {
         alc663_m51va_speaker_automute(codec);
-        alc662_eeepc_mic_automute(codec);
-}
-
-/* bind hp and internal speaker mute (with plug check) */
-static int alc662_ecs_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, 0x1b, 0, HDA_OUTPUT, 0,
-                                          HDA_AMP_MUTE,
-                                          valp[0] ? 0 : HDA_AMP_MUTE);
-        change |= snd_hda_codec_amp_update(codec, 0x1b, 1, HDA_OUTPUT, 0,
-                                           HDA_AMP_MUTE,
-                                           valp[1] ? 0 : HDA_AMP_MUTE);
-        if (change)
-                alc262_hippo1_automute(codec);
-        return change;
+        alc_mic_automute(codec);
 }
 
 static struct snd_kcontrol_new alc662_ecs_mixer[] = {
         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, 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 = alc662_ecs_master_sw_put,
-                .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
-        },
+        ALC262_HIPPO_MASTER_SWITCH,
 
         HDA_CODEC_VOLUME("e-Mic/LineIn Boost", 0x18, 0, HDA_INPUT),
@@ -16371 +16605 @@
 };
 
+static struct snd_kcontrol_new alc272_nc10_mixer[] = {
+        /* Master Playback automatically created from Speaker and Headphone */
+        HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
+
+        HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
+
+        HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
+        HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
+        HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
+        {0} /* end */
+};
+
 #ifdef CONFIG_SND_HDA_POWER_SAVE
 #define alc662_loopbacks        alc880_loopbacks
@@ -16376 +16627 @@
 
 
-/* pcm configuration: identiacal with ALC880 */
+/* pcm configuration: identical with ALC880 */
 #define alc662_pcm_analog_playback      alc880_pcm_analog_playback
 #define alc662_pcm_analog_capture       alc880_pcm_analog_capture
@@ -16404 +16655 @@
         [ALC663_ASUS_MODE5] = "asus-mode5",
         [ALC663_ASUS_MODE6] = "asus-mode6",
+        [ALC272_DELL]           = "dell",
+        [ALC272_DELL_ZM1]       = "dell-zm1",
+        [ALC272_SAMSUNG_NC10]   = "samsung-nc10",
         [ALC662_AUTO]           = "auto",
 };
@@ -16461 +16715 @@
         SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
                       ALC662_3ST_6ch_DIG),
+        SND_PCI_QUIRK(0x144d, 0xca00, "Samsung NC10", ALC272_SAMSUNG_NC10),
         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
                       ALC662_3ST_6ch_DIG),
@@ -16537 +16792 @@
                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
                 .channel_mode = alc662_3ST_2ch_modes,
-                .input_mux = &alc662_eeepc_capture_source,
                 .unsol_event = alc662_eeepc_unsol_event,
+                .setup = alc662_eeepc_setup,
                 .init_hook = alc662_eeepc_inithook,
         },
@@ -16551 +16806 @@
                 .channel_mode = alc662_3ST_6ch_modes,
                 .input_mux = &alc662_lenovo_101e_capture_source,
-                .unsol_event = alc662_eeepc_ep20_unsol_event,
+                .unsol_event = alc662_eeepc_unsol_event,
+                .setup = alc662_eeepc_ep20_setup,
                 .init_hook = alc662_eeepc_ep20_inithook,
         },
@@ -16562 +16818 @@
                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
                 .channel_mode = alc662_3ST_2ch_modes,
-                .input_mux = &alc662_eeepc_capture_source,
                 .unsol_event = alc662_eeepc_unsol_event,
+                .setup = alc662_eeepc_setup,
                 .init_hook = alc662_eeepc_inithook,
         },
@@ -16574 +16830 @@
                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
                 .channel_mode = alc662_3ST_2ch_modes,
-                .input_mux = &alc663_m51va_capture_source,
                 .unsol_event = alc663_m51va_unsol_event,
+                .setup = alc663_m51va_setup,
                 .init_hook = alc663_m51va_inithook,
         },
@@ -16586 +16842 @@
                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
                 .channel_mode = alc662_3ST_2ch_modes,
-                .input_mux = &alc662_eeepc_capture_source,
                 .unsol_event = alc663_g71v_unsol_event,
+                .setup = alc663_g71v_setup,
                 .init_hook = alc663_g71v_inithook,
         },
@@ -16597 +16853 @@
                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
                 .channel_mode = alc662_3ST_2ch_modes,
-                .input_mux = &alc663_m51va_capture_source,
                 .unsol_event = alc663_m51va_unsol_event,
                 .init_hook = alc663_m51va_inithook,
@@ -16611 +16866 @@
                 .input_mux = &alc663_capture_source,
                 .unsol_event = alc663_g50v_unsol_event,
+                .setup = alc663_g50v_setup,
                 .init_hook = alc663_g50v_inithook,
         },
@@ -16624 +16880 @@
                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
                 .channel_mode = alc662_3ST_2ch_modes,
-                .input_mux = &alc662_eeepc_capture_source,
                 .unsol_event = alc663_mode1_unsol_event,
+                .setup = alc663_mode1_setup,
                 .init_hook = alc663_mode1_inithook,
         },
@@ -16638 +16894 @@
                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
                 .channel_mode = alc662_3ST_2ch_modes,
-                .input_mux = &alc662_eeepc_capture_source,
                 .unsol_event = alc662_mode2_unsol_event,
+                .setup = alc662_mode2_setup,
                 .init_hook = alc662_mode2_inithook,
         },
@@ -16653 +16909 @@
                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
                 .channel_mode = alc662_3ST_2ch_modes,
-                .input_mux = &alc662_eeepc_capture_source,
                 .unsol_event = alc663_mode3_unsol_event,
+                .setup = alc663_mode3_setup,
                 .init_hook = alc663_mode3_inithook,
         },
@@ -16668 +16924 @@
                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
                 .channel_mode = alc662_3ST_2ch_modes,
-                .input_mux = &alc662_eeepc_capture_source,
                 .unsol_event = alc663_mode4_unsol_event,
+                .setup = alc663_mode4_setup,
                 .init_hook = alc663_mode4_inithook,
         },
@@ -16683 +16939 @@
                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
                 .channel_mode = alc662_3ST_2ch_modes,
-                .input_mux = &alc662_eeepc_capture_source,
                 .unsol_event = alc663_mode5_unsol_event,
+                .setup = alc663_mode5_setup,
                 .init_hook = alc663_mode5_inithook,
         },
@@ -16698 +16954 @@
                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
                 .channel_mode = alc662_3ST_2ch_modes,
-                .input_mux = &alc662_eeepc_capture_source,
                 .unsol_event = alc663_mode6_unsol_event,
+                .setup = alc663_mode6_setup,
                 .init_hook = alc663_mode6_inithook,
         },
@@ -16713 +16969 @@
                 .capsrc_nids = alc272_capsrc_nids,
                 .channel_mode = alc662_3ST_2ch_modes,
-                .input_mux = &alc663_m51va_capture_source,
                 .unsol_event = alc663_m51va_unsol_event,
+                .setup = alc663_m51va_setup,
                 .init_hook = alc663_m51va_inithook,
         },
@@ -16725 +16981 @@
                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
                 .adc_nids = alc662_adc_nids,
-                .num_adc_nids = ARRAY_SIZE(alc662_adc_nids),
+                .num_adc_nids = 1,
                 .capsrc_nids = alc662_capsrc_nids,
                 .channel_mode = alc662_3ST_2ch_modes,
-                .input_mux = &alc663_m51va_capture_source,
                 .unsol_event = alc663_m51va_unsol_event,
+                .setup = alc663_m51va_setup,
                 .init_hook = alc663_m51va_inithook,
+        },
+        [ALC272_SAMSUNG_NC10] = {
+                .mixers = { alc272_nc10_mixer },
+                .init_verbs = { alc662_init_verbs,
+                                alc663_21jd_amic_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc272_dac_nids),
+                .dac_nids = alc272_dac_nids,
+                .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
+                .channel_mode = alc662_3ST_2ch_modes,
+                /*.input_mux = &alc272_nc10_capture_source,*/
+                .unsol_event = alc663_mode4_unsol_event,
+                .setup = alc663_mode4_setup,
+                .init_hook = alc663_mode4_inithook,
         },
 };
@@ -16781 +17050 @@
                                 return err;
                 } else {
-                        sprintf(name, "%s Playback Volume", chname[i]);
+                        const char *pfx;
+                        if (cfg->line_outs == 1 &&
+                            cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
+                                if (!cfg->hp_pins)
+                                        pfx = "Speaker";
+                                else
+                                        pfx = "PCM";
+                        } else
+                                pfx = chname[i];
+                        sprintf(name, "%s Playback Volume", pfx);
                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
@@ -16787 +17065 @@
                         if (err < 0)
                                 return err;
-                        sprintf(name, "%s Playback Switch", chname[i]);
+                        if (cfg->line_outs == 1 &&
+                            cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
+                                pfx = "Speaker";
+                        sprintf(name, "%s Playback Switch", pfx);
                         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
                                 HDA_COMPOSE_AMP_VAL(alc880_idx_to_mixer(i),
@@ -16849 +17130 @@
 }
 
-/* return the index of the src widget from the connection list of the nid.
- * return -1 if not found
- */
-static int alc662_input_pin_idx(struct hda_codec *codec, hda_nid_t nid,
-                                hda_nid_t src)
-{
-        hda_nid_t conn_list[HDA_MAX_CONNECTIONS];
-        int i, conns;
-
-        conns = snd_hda_get_connections(codec, nid, conn_list,
-                                        ARRAY_SIZE(conn_list));
-        if (conns < 0)
-                return -1;
-        for (i = 0; i < conns; i++)
-                if (conn_list[i] == src)
-                        return i;
-        return -1;
-}
-
-static int alc662_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
-{
-        unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
-        return (pincap & AC_PINCAP_IN) != 0;
-}
-
 /* create playback/capture controls for input pins */
-static int alc662_auto_create_analog_input_ctls(struct hda_codec *codec,
-                                                const struct auto_pin_cfg *cfg)
-{
-        struct alc_spec *spec = codec->spec;
-        struct hda_input_mux *imux = &spec->private_imux[0];
-        int i, err, idx;
-
-        for (i = 0; i < AUTO_PIN_LAST; i++) {
-                if (alc662_is_input_pin(codec, cfg->input_pins[i])) {
-                        idx = alc662_input_pin_idx(codec, 0x0b,
-                                                   cfg->input_pins[i]);
-                        if (idx >= 0) {
-                                err = new_analog_input(spec, cfg->input_pins[i],
-                                                       auto_pin_cfg_labels[i],
-                                                       idx, 0x0b);
-                                if (err < 0)
-                                        return err;
-                        }
-                        idx = alc662_input_pin_idx(codec, 0x22,
-                                                   cfg->input_pins[i]);
-                        if (idx >= 0) {
-                                imux->items[imux->num_items].label =
-                                        auto_pin_cfg_labels[i];
-                                imux->items[imux->num_items].index = idx;
-                                imux->num_items++;
-                        }
-                }
-        }
-        return 0;
-}
+#define alc662_auto_create_input_ctls \
+        alc880_auto_create_input_ctls
 
 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
@@ -16926 +17154 @@
         int i;
 
-        alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
         for (i = 0; i <= HDA_SIDE; i++) {
                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
@@ -16959 +17186 @@
         for (i = 0; i < AUTO_PIN_LAST; i++) {
                 hda_nid_t nid = spec->autocfg.input_pins[i];
-                if (alc662_is_input_pin(codec, nid)) {
+                if (alc_is_input_pin(codec, nid)) {
                         alc_set_input_pin(codec, nid, i);
                         if (nid != ALC662_PIN_CD_NID &&
@@ -17000 +17227 @@
         if (err < 0)
                 return err;
-        err = alc662_auto_create_analog_input_ctls(codec, &spec->autocfg);
+        err = alc662_auto_create_input_ctls(codec, &spec->autocfg);
         if (err < 0)
                 return err;
@@ -17022 +17249 @@
         if (err < 0)
                 return err;
+
+        alc_ssid_check(codec, 0x15, 0x1b, 0x14);
 
         return 1;
@@ -17055 +17284 @@
                                                   alc662_cfg_tbl);
         if (board_config < 0) {
-                printk(KERN_INFO "hda_codec: Unknown model for ALC662, "
-                       "trying auto-probe from BIOS...\n");
+                printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
+                       codec->chip_name);
                 board_config = ALC662_AUTO;
         }
@@ -17081 +17310 @@
 
         if (board_config != ALC662_AUTO)
-                setup_preset(spec, &alc662_presets[board_config]);
-
-        if (codec->vendor_id == 0x10ec0663) {
-                spec->stream_name_analog = "ALC663 Analog";
-                spec->stream_name_digital = "ALC663 Digital";
-        } else if (codec->vendor_id == 0x10ec0272) {
-                spec->stream_name_analog = "ALC272 Analog";
-                spec->stream_name_digital = "ALC272 Digital";
-        } else {
-                spec->stream_name_analog = "ALC662 Analog";
-                spec->stream_name_digital = "ALC662 Digital";
-        }
+                setup_preset(codec, &alc662_presets[board_config]);
 
         spec->stream_analog_playback = &alc662_pcm_analog_playback;
@@ -17100 +17318 @@
         spec->stream_digital_capture = &alc662_pcm_digital_capture;
 
-        spec->adc_nids = alc662_adc_nids;
-        spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
-        spec->capsrc_nids = alc662_capsrc_nids;
-        spec->capture_style = CAPT_MIX;
+        if (!spec->adc_nids) {
+                spec->adc_nids = alc662_adc_nids;
+                spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
+        }
+        if (!spec->capsrc_nids)
+                spec->capsrc_nids = alc662_capsrc_nids;
 
         if (!spec->cap_mixer)
-                set_capture_mixer(spec);
+                set_capture_mixer(codec);
         if (codec->vendor_id == 0x10ec0662)
                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
@@ -17142 +17362 @@
         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
-          .patch = patch_alc883 },
+          .patch = patch_alc882 },
         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
           .patch = patch_alc662 },
@@ -17148 +17368 @@
         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
-        { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc883 },
+        { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
         { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
-          .patch = patch_alc882 }, /* should be patch_alc883() in future */
+          .patch = patch_alc882 },
         { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
-          .patch = patch_alc882 }, /* should be patch_alc883() in future */
+          .patch = patch_alc882 },
         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
-        { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc883 },
+        { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc882 },
         { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
-          .patch = patch_alc883 },
-        { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc883 },
-        { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc883 },
+          .patch = patch_alc882 },
+        { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc882 },
+        { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
         {0} /* terminator */
 };

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

@@ -41 +41 @@
         STAC_PWR_EVENT,
         STAC_HP_EVENT,
+        STAC_LO_EVENT,
+        STAC_MIC_EVENT,
 };
 
@@ -77 +79 @@
         STAC_92HD73XX_NO_JD, /* no jack-detection */
         STAC_92HD73XX_REF,
+        STAC_92HD73XX_INTEL,
         STAC_DELL_M6_AMIC,
         STAC_DELL_M6_DMIC,
@@ -101 +104 @@
         STAC_HP_DV5,
         STAC_HP_HDX,
+        STAC_HP_DV4_1222NR,
         STAC_92HD71BXX_MODELS
 };
@@ -151 +155 @@
         STAC_D965_3ST,
         STAC_D965_5ST,
+        STAC_D965_5ST_NO_FP,
         STAC_DELL_3ST,
         STAC_DELL_BIOS,
@@ -173 +178 @@
         int type;
         struct snd_jack *jack;
+};
+
+struct sigmatel_mic_route {
+        hda_nid_t pin;
+        unsigned char mux_idx;
+        unsigned char dmux_idx;
 };
 
@@ -186 +197 @@
         unsigned int spdif_mute: 1;
         unsigned int check_volume_offset:1;
+        unsigned int auto_mic:1;
 
         /* gpio lines */
@@ -193 +205 @@
         unsigned int gpio_data;
         unsigned int gpio_mute;
+        unsigned int gpio_led;
 
         /* stream */
@@ -236 +249 @@
         hda_nid_t *smux_nids;
         unsigned int num_smuxes;
+        unsigned int num_analog_muxes;
+
+        unsigned long *capvols; /* amp-volume attr: HDA_COMPOSE_AMP_VAL() */
+        unsigned long *capsws; /* amp-mute attr: HDA_COMPOSE_AMP_VAL() */
+        unsigned int num_caps; /* number of capture volume/switch elements */
+
+        struct sigmatel_mic_route ext_mic;
+        struct sigmatel_mic_route int_mic;
+
         const char **spdif_labels;
 
@@ -332 +354 @@
 };
 
-#define STAC92HD83XXX_NUM_DMICS 2
-static hda_nid_t stac92hd83xxx_dmic_nids[STAC92HD83XXX_NUM_DMICS + 1] = {
-        0x11, 0x12, 0
-};
+#define STAC92HD73XX_NUM_CAPS   2
+static unsigned long stac92hd73xx_capvols[] = {
+        HDA_COMPOSE_AMP_VAL(0x20, 3, 0, HDA_OUTPUT),
+        HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
+};
+#define stac92hd73xx_capsws     stac92hd73xx_capvols
 
 #define STAC92HD83_DAC_COUNT 3
 
-static hda_nid_t stac92hd83xxx_dmux_nids[2] = {
+static hda_nid_t stac92hd83xxx_mux_nids[2] = {
         0x17, 0x18,
 };
@@ -359 +383 @@
 };
 
-static hda_nid_t stac92hd83xxx_amp_nids[1] = {
-        0xc,
-};
+#define STAC92HD83XXX_NUM_CAPS  2
+static unsigned long stac92hd83xxx_capvols[] = {
+        HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
+        HDA_COMPOSE_AMP_VAL(0x18, 3, 0, HDA_OUTPUT),
+};
+#define stac92hd83xxx_capsws    stac92hd83xxx_capvols
 
 static hda_nid_t stac92hd71bxx_pwr_nids[3] = {
@@ -392 +419 @@
 };
 
+#define STAC92HD71BXX_NUM_CAPS          2
+static unsigned long stac92hd71bxx_capvols[] = {
+        HDA_COMPOSE_AMP_VAL(0x1c, 3, 0, HDA_OUTPUT),
+        HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT),
+};
+#define stac92hd71bxx_capsws    stac92hd71bxx_capvols
+
 static hda_nid_t stac925x_adc_nids[1] = {
         0x03,
@@ -413 +447 @@
 };
 
+static unsigned long stac925x_capvols[] = {
+        HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
+};
+static unsigned long stac925x_capsws[] = {
+        HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
+};
+
 static hda_nid_t stac922x_adc_nids[2] = {
         0x06, 0x07,
@@ -420 +461 @@
         0x12, 0x13,
 };
+
+#define STAC922X_NUM_CAPS       2
+static unsigned long stac922x_capvols[] = {
+        HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_INPUT),
+        HDA_COMPOSE_AMP_VAL(0x18, 3, 0, HDA_INPUT),
+};
+#define stac922x_capsws         stac922x_capvols
 
 static hda_nid_t stac927x_slave_dig_outs[2] = {
@@ -450 +498 @@
 };
 
+#define STAC927X_NUM_CAPS       3
+static unsigned long stac927x_capvols[] = {
+        HDA_COMPOSE_AMP_VAL(0x18, 3, 0, HDA_INPUT),
+        HDA_COMPOSE_AMP_VAL(0x19, 3, 0, HDA_INPUT),
+        HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_INPUT),
+};
+static unsigned long stac927x_capsws[] = {
+        HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
+        HDA_COMPOSE_AMP_VAL(0x1c, 3, 0, HDA_OUTPUT),
+        HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT),
+};
+
 static const char *stac927x_spdif_labels[5] = {
         "Digital Playback", "ADAT", "Analog Mux 1",
@@ -474 +534 @@
 static hda_nid_t stac9205_dmic_nids[STAC9205_NUM_DMICS + 1] = {
         0x17, 0x18, 0
+};
+
+#define STAC9205_NUM_CAPS       2
+static unsigned long stac9205_capvols[] = {
+        HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_INPUT),
+        HDA_COMPOSE_AMP_VAL(0x1c, 3, 0, HDA_INPUT),
+};
+static unsigned long stac9205_capsws[] = {
+        HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT),
+        HDA_COMPOSE_AMP_VAL(0x1e, 3, 0, HDA_OUTPUT),
 };
 
@@ -634 +704 @@
 }
 
+static unsigned int stac92xx_vref_set(struct hda_codec *codec,
+                                        hda_nid_t nid, unsigned int new_vref)
+{
+        int error;
+        unsigned int pincfg;
+        pincfg = snd_hda_codec_read(codec, nid, 0,
+                                AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
+
+        pincfg &= 0xff;
+        pincfg &= ~(AC_PINCTL_VREFEN | AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
+        pincfg |= new_vref;
+
+        if (new_vref == AC_PINCTL_VREF_HIZ)
+                pincfg |= AC_PINCTL_OUT_EN;
+        else
+                pincfg |= AC_PINCTL_IN_EN;
+
+        error = snd_hda_codec_write_cache(codec, nid, 0,
+                                        AC_VERB_SET_PIN_WIDGET_CONTROL, pincfg);
+        if (error < 0)
+                return error;
+        else
+                return 1;
+}
+
+static unsigned int stac92xx_vref_get(struct hda_codec *codec, hda_nid_t nid)
+{
+        unsigned int vref;
+        vref = snd_hda_codec_read(codec, nid, 0,
+                                AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
+        vref &= AC_PINCTL_VREFEN;
+        return vref;
+}
+
 static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 {
@@ -656 +760 @@
         struct sigmatel_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->mux_nids[adc_idx], &spec->cur_mux[adc_idx]);
+        const struct hda_input_mux *imux = spec->input_mux;
+        unsigned int idx, prev_idx;
+
+        idx = ucontrol->value.enumerated.item[0];
+        if (idx >= imux->num_items)
+                idx = imux->num_items - 1;
+        prev_idx = spec->cur_mux[adc_idx];
+        if (prev_idx == idx)
+                return 0;
+        if (idx < spec->num_analog_muxes) {
+                snd_hda_codec_write_cache(codec, spec->mux_nids[adc_idx], 0,
+                                          AC_VERB_SET_CONNECT_SEL,
+                                          imux->items[idx].index);
+                if (prev_idx >= spec->num_analog_muxes) {
+                        imux = spec->dinput_mux;
+                        /* 0 = analog */
+                        snd_hda_codec_write_cache(codec,
+                                                  spec->dmux_nids[adc_idx], 0,
+                                                  AC_VERB_SET_CONNECT_SEL,
+                                                  imux->items[0].index);
+                }
+        } else {
+                imux = spec->dinput_mux;
+                snd_hda_codec_write_cache(codec, spec->dmux_nids[adc_idx], 0,
+                                          AC_VERB_SET_CONNECT_SEL,
+                                          imux->items[idx - 1].index);
+        }
+        spec->cur_mux[adc_idx] = idx;
+        return 1;
 }
 
@@ -888 +1018 @@
 };
 
-#define HD_DISABLE_PORTF 1
-static struct hda_verb stac92hd71bxx_analog_core_init[] = {
-        /* start of config #1 */
-
-        /* connect port 0f to audio mixer */
-        { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x2},
-        /* start of config #2 */
-
-        /* set master volume and direct control */
-        { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
-        {0}
-};
-
 static struct hda_verb stac92hd71bxx_unmute_core_init[] = {
         /* unmute right and left channels for nodes 0x0f, 0xa, 0x0d */
@@ -995 +1112 @@
         }
 
+#define DC_BIAS(xname, idx, nid) \
+        { \
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
+                .name = xname, \
+                .index = idx, \
+                .info = stac92xx_dc_bias_info, \
+                .get = stac92xx_dc_bias_get, \
+                .put = stac92xx_dc_bias_put, \
+                .private_value = nid, \
+        }
+
 static struct snd_kcontrol_new stac9200_mixer[] = {
         HDA_CODEC_VOLUME("Master Playback Volume", 0xb, 0, HDA_OUTPUT),
@@ -1022 +1150 @@
         HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
 
-        HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
-        HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
-
-        HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
-        HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
-
         {0} /* end */
 };
@@ -1047 +1169 @@
 
 static struct snd_kcontrol_new stac92hd73xx_8ch_mixer[] = {
-        HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
-        HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
-
-        HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
-        HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
-
         HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
         HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
@@ -1071 +1187 @@
 
 static struct snd_kcontrol_new stac92hd73xx_10ch_mixer[] = {
-        HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
-        HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
-
-        HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
-        HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
-
         HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
         HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
@@ -1095 +1205 @@
 
 
-static struct snd_kcontrol_new stac92hd83xxx_mixer[] = {
-        HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x17, 0x0, HDA_OUTPUT),
-        HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x17, 0x0, HDA_OUTPUT),
-
-        HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x18, 0x0, HDA_OUTPUT),
-        HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x18, 0x0, HDA_OUTPUT),
-
-        HDA_CODEC_VOLUME("DAC0 Capture Volume", 0x1b, 0x3, HDA_INPUT),
-        HDA_CODEC_MUTE("DAC0 Capture Switch", 0x1b, 0x3, HDA_INPUT),
-
-        HDA_CODEC_VOLUME("DAC1 Capture Volume", 0x1b, 0x4, HDA_INPUT),
-        HDA_CODEC_MUTE("DAC1 Capture Switch", 0x1b, 0x4, HDA_INPUT),
-
-        HDA_CODEC_VOLUME("Front Mic Capture Volume", 0x1b, 0x0, HDA_INPUT),
-        HDA_CODEC_MUTE("Front Mic Capture Switch", 0x1b, 0x0, HDA_INPUT),
-
-        HDA_CODEC_VOLUME("Line In Capture Volume", 0x1b, 0x2, HDA_INPUT),
-        HDA_CODEC_MUTE("Line In Capture Switch", 0x1b, 0x2, HDA_INPUT),
-
-        /*
-        HDA_CODEC_VOLUME("Mic Capture Volume", 0x1b, 0x1, HDA_INPUT),
-        HDA_CODEC_MUTE("Mic Capture Switch", 0x1b 0x1, HDA_INPUT),
-        */
-        {0} /* end */
-};
-
-static struct snd_kcontrol_new stac92hd71bxx_analog_mixer[] = {
-        HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
-        HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),
-
-        HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT),
-        HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT),
-        /* analog pc-beep replaced with digital beep support */
-        /*
-        HDA_CODEC_VOLUME("PC Beep Volume", 0x17, 0x2, HDA_INPUT),
-        HDA_CODEC_MUTE("PC Beep Switch", 0x17, 0x2, HDA_INPUT),
-        */
-
-        HDA_CODEC_MUTE("Import0 Mux Capture Switch", 0x17, 0x0, HDA_INPUT),
-        HDA_CODEC_VOLUME("Import0 Mux Capture Volume", 0x17, 0x0, HDA_INPUT),
-
-        HDA_CODEC_MUTE("Import1 Mux Capture Switch", 0x17, 0x1, HDA_INPUT),
-        HDA_CODEC_VOLUME("Import1 Mux Capture Volume", 0x17, 0x1, HDA_INPUT),
-
-        HDA_CODEC_MUTE("DAC0 Capture Switch", 0x17, 0x3, HDA_INPUT),
-        HDA_CODEC_VOLUME("DAC0 Capture Volume", 0x17, 0x3, HDA_INPUT),
-
-        HDA_CODEC_MUTE("DAC1 Capture Switch", 0x17, 0x4, HDA_INPUT),
-        HDA_CODEC_VOLUME("DAC1 Capture Volume", 0x17, 0x4, HDA_INPUT),
-        {0} /* end */
-};
-
 static struct snd_kcontrol_new stac92hd71bxx_loopback[] = {
         STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2)
-};
-
-static struct snd_kcontrol_new stac92hd71bxx_mixer[] = {
-        HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
-        HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),
-
-        HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT),
-        HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT),
-        {0} /* end */
 };
 
@@ -1163 +1212 @@
         HDA_CODEC_VOLUME("Master Playback Volume", 0x0e, 0, HDA_OUTPUT),
         HDA_CODEC_MUTE("Master Playback Switch", 0x0e, 0, HDA_OUTPUT),
-        HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_OUTPUT),
-        HDA_CODEC_MUTE("Capture Switch", 0x14, 0, HDA_OUTPUT),
-        {0} /* end */
-};
-
-static struct snd_kcontrol_new stac9205_mixer[] = {
-        HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1b, 0x0, HDA_INPUT),
-        HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1d, 0x0, HDA_OUTPUT),
-
-        HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1c, 0x0, HDA_INPUT),
-        HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1e, 0x0, HDA_OUTPUT),
         {0} /* end */
 };
@@ -1180 +1218 @@
         STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0, 1),
         {0}
-};
-
-/* This needs to be generated dynamically based on sequence */
-static struct snd_kcontrol_new stac922x_mixer[] = {
-        HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x17, 0x0, HDA_INPUT),
-        HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x17, 0x0, HDA_INPUT),
-
-        HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x18, 0x0, HDA_INPUT),
-        HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x18, 0x0, HDA_INPUT),
-        {0} /* end */
-};
-
-
-static struct snd_kcontrol_new stac927x_mixer[] = {
-        HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x18, 0x0, HDA_INPUT),
-        HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1b, 0x0, HDA_OUTPUT),
-
-        HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x19, 0x0, HDA_INPUT),
-        HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1c, 0x0, HDA_OUTPUT),
-
-        HDA_CODEC_VOLUME_IDX("Capture Volume", 0x2, 0x1A, 0x0, HDA_INPUT),
-        HDA_CODEC_MUTE_IDX("Capture Switch", 0x2, 0x1d, 0x0, HDA_OUTPUT),
-        {0} /* end */
 };
 
@@ -1262 +1277 @@
         int i;
 
-        err = snd_hda_add_new_ctls(codec, spec->mixer);
-        if (err < 0)
-                return err;
+        if (spec->mixer) {
+                err = snd_hda_add_new_ctls(codec, spec->mixer);
+                if (err < 0)
+                        return err;
+        }
 
         for (i = 0; i < spec->num_mixers; i++) {
@@ -1271 +1288 @@
                         return err;
         }
-        if (spec->num_dmuxes > 0) {
+        if (!spec->auto_mic && spec->num_dmuxes > 0 &&
+            snd_hda_get_bool_hint(codec, "separate_dmux") == 1) {
                 stac_dmux_mixer.count = spec->num_dmuxes;
                 err = snd_hda_ctl_add(codec,
@@ -1730 +1748 @@
         [STAC_92HD73XX_NO_JD] = "no-jd",
         [STAC_92HD73XX_REF] = "ref",
+        [STAC_92HD73XX_INTEL] = "intel",
         [STAC_DELL_M6_AMIC] = "dell-m6-amic",
         [STAC_DELL_M6_DMIC] = "dell-m6-dmic",
@@ -1742 +1761 @@
         SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
                                 "DFI LanParty", STAC_92HD73XX_REF),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5002,
+                                "Intel DG45ID", STAC_92HD73XX_INTEL),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5003,
+                                "Intel DG45FC", STAC_92HD73XX_INTEL),
         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0254,
                                 "Dell Studio 1535", STAC_DELL_M6_DMIC),
@@ -1762 +1785 @@
         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02a0,
                                 "Dell Studio 17", STAC_DELL_M6_DMIC),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02be,
+                                "Dell Studio 1555", STAC_DELL_M6_DMIC),
         {0} /* terminator */
 };
@@ -1837 +1862 @@
         [STAC_HP_DV5]           = NULL,
         [STAC_HP_HDX]           = NULL,
+        [STAC_HP_DV4_1222NR]    = NULL,
 };
 
@@ -1848 +1874 @@
         [STAC_HP_DV5] = "hp-dv5",
         [STAC_HP_HDX] = "hp-hdx",
+        [STAC_HP_DV4_1222NR] = "hp-dv4-1222nr",
 };
 
@@ -1856 +1883 @@
         SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
                       "DFI LanParty", STAC_92HD71BXX_REF),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30fb,
+                      "HP dv4-1222nr", STAC_HP_DV4_1222NR),
         SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3080,
                       "HP", STAC_HP_DV5),
@@ -1868 +1897 @@
         SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361b,
                       "HP HDX", STAC_HP_HDX),  /* HDX16 */
+        SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x7010,
+                      "HP", STAC_HP_DV5),
         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0233,
                                 "unknown Dell", STAC_DELL_M4_1),
@@ -2155 +2186 @@
 };
 
+static unsigned int d965_5st_no_fp_pin_configs[14] = {
+        0x40000100, 0x40000100, 0x0181304e, 0x01014010,
+        0x01a19040, 0x01011012, 0x01016011, 0x40000100,
+        0x40000100, 0x40000100, 0x40000100, 0x01442070,
+        0x40000100, 0x40000100
+};
+
 static unsigned int dell_3st_pin_configs[14] = {
         0x02211230, 0x02a11220, 0x01a19040, 0x01114210,
@@ -2167 +2205 @@
         [STAC_D965_3ST]  = d965_3st_pin_configs,
         [STAC_D965_5ST]  = d965_5st_pin_configs,
+        [STAC_D965_5ST_NO_FP]  = d965_5st_no_fp_pin_configs,
         [STAC_DELL_3ST]  = dell_3st_pin_configs,
         [STAC_DELL_BIOS] = NULL,
@@ -2177 +2216 @@
         [STAC_D965_3ST]         = "3stack",
         [STAC_D965_5ST]         = "5stack",
+        [STAC_D965_5ST_NO_FP]   = "5stack-no-fp",
         [STAC_DELL_3ST]         = "dell-3stack",
         [STAC_DELL_BIOS]        = "dell-bios",
@@ -2204 +2244 @@
         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0227, "Dell Vostro 1400  ", STAC_DELL_BIOS),
         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x022e, "Dell     ", STAC_DELL_BIOS),
-        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x022f, "Dell Inspiron 1525", STAC_DELL_3ST),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x022f, "Dell Inspiron 1525", STAC_DELL_BIOS),
         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0242, "Dell     ", STAC_DELL_BIOS),
         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0243, "Dell     ", STAC_DELL_BIOS),
@@ -2282 +2322 @@
         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
                       "DFI LanParty", STAC_9205_REF),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xfb30,
+                      "SigmaTel", STAC_9205_REF),
         SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
                       "DFI LanParty", STAC_9205_REF),
@@ -2316 +2358 @@
                       "Dell Vostro 1500", STAC_9205_DELL_M42),
         /* Gateway */
+        SND_PCI_QUIRK(0x107b, 0x0560, "Gateway T6834c", STAC_9205_EAPD),
         SND_PCI_QUIRK(0x107b, 0x0565, "Gateway T1616", STAC_9205_EAPD),
         {0} /* terminator */
@@ -2536 +2579 @@
 }
 
-static unsigned int stac92xx_get_vref(struct hda_codec *codec, hda_nid_t nid)
+static unsigned int stac92xx_get_default_vref(struct hda_codec *codec,
+                                        hda_nid_t nid)
 {
         unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
@@ -2570 +2614 @@
 }
 
-static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid,
-                                   unsigned char type);
+static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid);
 
 static int stac92xx_hp_switch_put(struct snd_kcontrol *kcontrol,
@@ -2585 +2628 @@
          * switch changes
          */
-        stac_issue_unsol_event(codec, nid, STAC_HP_EVENT);
+        stac_issue_unsol_event(codec, nid);
 
         return 1;
 }
 
-#define stac92xx_io_switch_info         snd_ctl_boolean_mono_info
+static int stac92xx_dc_bias_info(struct snd_kcontrol *kcontrol,
+                                struct snd_ctl_elem_info *uinfo)
+{
+        int i;
+        static char *texts[] = {
+                "Mic In", "Line In", "Line Out"
+        };
+
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct sigmatel_spec *spec = codec->spec;
+        hda_nid_t nid = kcontrol->private_value;
+
+        if (nid == spec->mic_switch || nid == spec->line_switch)
+                i = 3;
+        else
+                i = 2;
+
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        uinfo->value.enumerated.items = i;
+        uinfo->count = 1;
+        if (uinfo->value.enumerated.item >= i)
+                uinfo->value.enumerated.item = i-1;
+        strcpy(uinfo->value.enumerated.name,
+                texts[uinfo->value.enumerated.item]);
+
+        return 0;
+}
+
+static int stac92xx_dc_bias_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;
+        unsigned int vref = stac92xx_vref_get(codec, nid);
+
+        if (vref == stac92xx_get_default_vref(codec, nid))
+                ucontrol->value.enumerated.item[0] = 0;
+        else if (vref == AC_PINCTL_VREF_GRD)
+                ucontrol->value.enumerated.item[0] = 1;
+        else if (vref == AC_PINCTL_VREF_HIZ)
+                ucontrol->value.enumerated.item[0] = 2;
+
+        return 0;
+}
+
+static int stac92xx_dc_bias_put(struct snd_kcontrol *kcontrol,
+                                struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        unsigned int new_vref = 0;
+        int error;
+        hda_nid_t nid = kcontrol->private_value;
+
+        if (ucontrol->value.enumerated.item[0] == 0)
+                new_vref = stac92xx_get_default_vref(codec, nid);
+        else if (ucontrol->value.enumerated.item[0] == 1)
+                new_vref = AC_PINCTL_VREF_GRD;
+        else if (ucontrol->value.enumerated.item[0] == 2)
+                new_vref = AC_PINCTL_VREF_HIZ;
+        else
+                return 0;
+
+        if (new_vref != stac92xx_vref_get(codec, nid)) {
+                error = stac92xx_vref_set(codec, nid, new_vref);
+                return error;
+        }
+
+        return 0;
+}
+
+static int stac92xx_io_switch_info(struct snd_kcontrol *kcontrol,
+                                struct snd_ctl_elem_info *uinfo)
+{
+        static char *texts[2];
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct sigmatel_spec *spec = codec->spec;
+
+        if (kcontrol->private_value == spec->line_switch)
+                texts[0] = "Line In";
+        else
+                texts[0] = "Mic In";
+        texts[1] = "Line Out";
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        uinfo->value.enumerated.items = 2;
+        uinfo->count = 1;
+
+        if (uinfo->value.enumerated.item >= 2)
+                uinfo->value.enumerated.item = 1;
+        strcpy(uinfo->value.enumerated.name,
+                texts[uinfo->value.enumerated.item]);
+
+        return 0;
+}
 
 static int stac92xx_io_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
@@ -2596 +2731 @@
         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
         struct sigmatel_spec *spec = codec->spec;
-        int io_idx = kcontrol-> private_value & 0xff;
-
-        ucontrol->value.integer.value[0] = spec->io_switch[io_idx];
+        hda_nid_t nid = kcontrol->private_value;
+        int io_idx = (nid == spec->mic_switch) ? 1 : 0;
+
+        ucontrol->value.enumerated.item[0] = spec->io_switch[io_idx];
         return 0;
 }
@@ -2606 +2742 @@
         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
         struct sigmatel_spec *spec = codec->spec;
-        hda_nid_t nid = kcontrol->private_value >> 8;
-        int io_idx = kcontrol-> private_value & 0xff;
-        unsigned short val = !!ucontrol->value.integer.value[0];
+        hda_nid_t nid = kcontrol->private_value;
+        int io_idx = (nid == spec->mic_switch) ? 1 : 0;
+        unsigned short val = !!ucontrol->value.enumerated.item[0];
 
         spec->io_switch[io_idx] = val;
@@ -2617 +2753 @@
                 unsigned int pinctl = AC_PINCTL_IN_EN;
                 if (io_idx) /* set VREF for mic */
-                        pinctl |= stac92xx_get_vref(codec, nid);
+                        pinctl |= stac92xx_get_default_vref(codec, nid);
                 stac92xx_auto_set_pinctl(codec, nid, pinctl);
         }
@@ -2625 +2761 @@
          */
         if (spec->hp_detect)
-                stac_issue_unsol_event(codec, nid, STAC_HP_EVENT);
+                stac_issue_unsol_event(codec, nid);
 
         return 1;
@@ -2698 +2834 @@
         STAC_CTL_WIDGET_HP_SWITCH,
         STAC_CTL_WIDGET_IO_SWITCH,
-        STAC_CTL_WIDGET_CLFE_SWITCH
+        STAC_CTL_WIDGET_CLFE_SWITCH,
+        STAC_CTL_WIDGET_DC_BIAS
 };
 
@@ -2710 +2847 @@
         STAC_CODEC_IO_SWITCH(NULL, 0),
         STAC_CODEC_CLFE_SWITCH(NULL, 0),
+        DC_BIAS(NULL, 0, 0),
 };
 
@@ -2773 +2911 @@
 };
 
+static inline int stac92xx_add_jack_mode_control(struct hda_codec *codec,
+                                                hda_nid_t nid, int idx)
+{
+        int def_conf = snd_hda_codec_get_pincfg(codec, nid);
+        int control = 0;
+        struct sigmatel_spec *spec = codec->spec;
+        char name[22];
+
+        if (!((get_defcfg_connect(def_conf)) & AC_JACK_PORT_FIXED)) {
+                if (stac92xx_get_default_vref(codec, nid) == AC_PINCTL_VREF_GRD
+                        && nid == spec->line_switch)
+                        control = STAC_CTL_WIDGET_IO_SWITCH;
+                else if (snd_hda_query_pin_caps(codec, nid)
+                        & (AC_PINCAP_VREF_GRD << AC_PINCAP_VREF_SHIFT))
+                        control = STAC_CTL_WIDGET_DC_BIAS;
+                else if (nid == spec->mic_switch)
+                        control = STAC_CTL_WIDGET_IO_SWITCH;
+        }
+
+        if (control) {
+                strcpy(name, auto_pin_cfg_labels[idx]);
+                return stac92xx_add_control(codec->spec, control,
+                                        strcat(name, " Jack Mode"), nid);
+        }
+
+        return 0;
+}
+
 static int stac92xx_add_input_source(struct sigmatel_spec *spec)
 {
@@ -2778 +2944 @@
         struct hda_input_mux *imux = &spec->private_imux;
 
+        if (spec->auto_mic)
+                return 0; /* no need for input source */
         if (!spec->num_adcs || imux->num_items <= 1)
                 return 0; /* no need for input source control */
@@ -2871 +3039 @@
         for (j = 0; j < conn_len; j++) {
                 wcaps = get_wcaps(codec, conn[j]);
-                wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
+                wtype = get_wcaps_type(wcaps);
                 /* we check only analog outputs */
                 if (wtype != AC_WID_AUD_OUT || (wcaps & AC_WCAP_DIGITAL))
@@ -3130 +3298 @@
 }
 
+static int stac92xx_add_capvol_ctls(struct hda_codec *codec, unsigned long vol,
+                                    unsigned long sw, int idx)
+{
+        int err;
+        err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_VOL, idx,
+                                       "Capture Volume", vol);
+        if (err < 0)
+                return err;
+        err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_MUTE, idx,
+                                       "Capture Switch", sw);
+        if (err < 0)
+                return err;
+        return 0;
+}
+
 /* add playback controls from the parsed DAC table */
 static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
@@ -3135 +3318 @@
 {
         struct sigmatel_spec *spec = codec->spec;
+        hda_nid_t nid;
         int err;
+        int idx;
 
         err = create_multi_out_ctls(codec, cfg->line_outs, cfg->line_out_pins,
@@ -3152 +3337 @@
         }
 
-        if (spec->line_switch) {
-                err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH,
-                                           "Line In as Output Switch",
-                                           spec->line_switch << 8);
-                if (err < 0)
-                        return err;
-        }
-
-        if (spec->mic_switch) {
-                err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH,
-                                           "Mic as Output Switch",
-                                           (spec->mic_switch << 8) | 1);
-                if (err < 0)
-                        return err;
+        for (idx = AUTO_PIN_MIC; idx <= AUTO_PIN_FRONT_LINE; idx++) {
+                nid = cfg->input_pins[idx];
+                if (nid) {
+                        err = stac92xx_add_jack_mode_control(codec, nid, idx);
+                        if (err < 0)
+                                return err;
+                }
         }
 
@@ -3208 +3386 @@
                                 con_lst,
                                 HDA_MAX_NUM_INPUTS);
-        if (!num_cons || num_cons > ARRAY_SIZE(stac92xx_mono_labels))
+        if (num_cons <= 0 || num_cons > ARRAY_SIZE(stac92xx_mono_labels))
                 return -EINVAL;
 
@@ -3321 +3499 @@
 {
         struct sigmatel_spec *spec = codec->spec;
-        int wcaps, nid, i, err = 0;
+        int i, j, err = 0;
 
         for (i = 0; i < spec->num_muxes; i++) {
+                hda_nid_t nid;
+                unsigned int wcaps;
+                unsigned long val;
+
                 nid = spec->mux_nids[i];
                 wcaps = get_wcaps(codec, nid);
-
-                if (wcaps & AC_WCAP_OUT_AMP) {
-                        err = stac92xx_add_control_idx(spec,
-                                STAC_CTL_WIDGET_VOL, i, "Mux Capture Volume",
-                                HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
-                        if (err < 0)
-                                return err;
+                if (!(wcaps & AC_WCAP_OUT_AMP))
+                        continue;
+
+                /* check whether already the same control was created as
+                 * normal Capture Volume.
+                 */
+                val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
+                for (j = 0; j < spec->num_caps; j++) {
+                        if (spec->capvols[j] == val)
+                                break;
                 }
+                if (j < spec->num_caps)
+                        continue;
+
+                err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_VOL, i,
+                                               "Mux Capture Volume", val);
+                if (err < 0)
+                        return err;
         }
         return 0;
@@ -3354 +3546 @@
                                 con_lst,
                                 HDA_MAX_NUM_INPUTS);
-        if (!num_cons)
+        if (num_cons <= 0)
                 return -EINVAL;
 
@@ -3375 +3567 @@
 };
 
+static int get_connection_index(struct hda_codec *codec, hda_nid_t mux,
+                                hda_nid_t nid)
+{
+        hda_nid_t conn[HDA_MAX_NUM_INPUTS];
+        int i, nums;
+
+        nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
+        for (i = 0; i < nums; i++)
+                if (conn[i] == nid)
+                        return i;
+        return -1;
+}
+
+/* create a volume assigned to the given pin (only if supported) */
+static int create_elem_capture_vol(struct hda_codec *codec, hda_nid_t nid,
+                                   const char *label)
+{
+        unsigned int caps, nums;
+        char name[32];
+
+        if (!(get_wcaps(codec, nid) & AC_WCAP_IN_AMP))
+                return 0;
+        caps = query_amp_caps(codec, nid, HDA_OUTPUT);
+        nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
+        if (!nums)
+                return 0;
+        snprintf(name, sizeof(name), "%s Capture Volume", label);
+        return stac92xx_add_control(codec->spec, STAC_CTL_WIDGET_VOL, name,
+                                    HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
+}
+
 /* create playback/capture controls for input pins on dmic capable codecs */
 static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
@@ -3380 +3603 @@
 {
         struct sigmatel_spec *spec = codec->spec;
+        struct hda_input_mux *imux = &spec->private_imux;
         struct hda_input_mux *dimux = &spec->private_dimux;
-        hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
-        int err, i, j;
-        char name[32];
+        int err, i, active_mics;
+        unsigned int def_conf;
 
         dimux->items[dimux->num_items].label = stac92xx_dmic_labels[0];
@@ -3389 +3612 @@
         dimux->num_items++;
 
+        active_mics = 0;
+        for (i = 0; i < spec->num_dmics; i++) {
+                /* check the validity: sometimes it's a dead vendor-spec node */
+                if (get_wcaps_type(get_wcaps(codec, spec->dmic_nids[i]))
+                    != AC_WID_PIN)
+                        continue;
+                def_conf = snd_hda_codec_get_pincfg(codec, spec->dmic_nids[i]);
+                if (get_defcfg_connect(def_conf) != AC_JACK_PORT_NONE)
+                        active_mics++;
+        }
+
         for (i = 0; i < spec->num_dmics; i++) {
                 hda_nid_t nid;
                 int index;
-                int num_cons;
-                unsigned int wcaps;
-                unsigned int def_conf;
-
-                def_conf = snd_hda_codec_get_pincfg(codec, spec->dmic_nids[i]);
+                const char *label;
+
+                nid = spec->dmic_nids[i];
+                if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
+                        continue;
+                def_conf = snd_hda_codec_get_pincfg(codec, nid);
                 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
                         continue;
 
-                nid = spec->dmic_nids[i];
-                num_cons = snd_hda_get_connections(codec,
-                                spec->dmux_nids[0],
-                                con_lst,
-                                HDA_MAX_NUM_INPUTS);
-                for (j = 0; j < num_cons; j++)
-                        if (con_lst[j] == nid) {
-                                index = j;
-                                goto found;
-                        }
-                continue;
-found:
-                wcaps = get_wcaps(codec, nid) &
-                        (AC_WCAP_OUT_AMP | AC_WCAP_IN_AMP);
-
-                if (wcaps) {
-                        sprintf(name, "%s Capture Volume",
-                                stac92xx_dmic_labels[dimux->num_items]);
-
-                        err = stac92xx_add_control(spec,
-                                STAC_CTL_WIDGET_VOL,
-                                name,
-                                HDA_COMPOSE_AMP_VAL(nid, 3, 0,
-                                (wcaps & AC_WCAP_OUT_AMP) ?
-                                HDA_OUTPUT : HDA_INPUT));
-                        if (err < 0)
-                                return err;
-                }
-
-                dimux->items[dimux->num_items].label =
-                        stac92xx_dmic_labels[dimux->num_items];
+                index = get_connection_index(codec, spec->dmux_nids[0], nid);
+                if (index < 0)
+                        continue;
+
+                if (active_mics == 1)
+                        label = "Digital Mic";
+                else
+                        label = stac92xx_dmic_labels[dimux->num_items];
+
+                err = create_elem_capture_vol(codec, nid, label);
+                if (err < 0)
+                        return err;
+
+                dimux->items[dimux->num_items].label = label;
                 dimux->items[dimux->num_items].index = index;
                 dimux->num_items++;
+                if (snd_hda_get_bool_hint(codec, "separate_dmux") != 1) {
+                        imux->items[imux->num_items].label = label;
+                        imux->items[imux->num_items].index = index;
+                        imux->num_items++;
+                }
         }
 
         return 0;
+}
+
+static int check_mic_pin(struct hda_codec *codec, hda_nid_t nid,
+                         hda_nid_t *fixed, hda_nid_t *ext)
+{
+        unsigned int cfg;
+
+        if (!nid)
+                return 0;
+        cfg = snd_hda_codec_get_pincfg(codec, nid);
+        switch (get_defcfg_connect(cfg)) {
+        case AC_JACK_PORT_FIXED:
+                if (*fixed)
+                        return 1; /* already occupied */
+                *fixed = nid;
+                break;
+        case AC_JACK_PORT_COMPLEX:
+                if (*ext)
+                        return 1; /* already occupied */
+                *ext = nid;
+                break;
+        }
+        return 0;
+}
+
+static int set_mic_route(struct hda_codec *codec,
+                         struct sigmatel_mic_route *mic,
+                         hda_nid_t pin)
+{
+        struct sigmatel_spec *spec = codec->spec;
+        struct auto_pin_cfg *cfg = &spec->autocfg;
+        int i;
+
+        mic->pin = pin;
+        for (i = AUTO_PIN_MIC; i <= AUTO_PIN_FRONT_MIC; i++)
+                if (pin == cfg->input_pins[i])
+                        break;
+        if (i <= AUTO_PIN_FRONT_MIC) {
+                /* analog pin */
+                mic->dmux_idx = 0;
+                i = get_connection_index(codec, spec->mux_nids[0], pin);
+                if (i < 0)
+                        return -1;
+                mic->mux_idx = i;
+        }  else if (spec->dmux_nids) {
+                /* digital pin */
+                mic->mux_idx = 0;
+                i = get_connection_index(codec, spec->dmux_nids[0], pin);
+                if (i < 0)
+                        return -1;
+                mic->dmux_idx = i;
+        }
+        return 0;
+}
+
+/* return non-zero if the device is for automatic mic switch */
+static int stac_check_auto_mic(struct hda_codec *codec)
+{
+        struct sigmatel_spec *spec = codec->spec;
+        struct auto_pin_cfg *cfg = &spec->autocfg;
+        hda_nid_t fixed, ext;
+        int i;
+
+        for (i = AUTO_PIN_LINE; i < AUTO_PIN_LAST; i++) {
+                if (cfg->input_pins[i])
+                        return 0; /* must be exclusively mics */
+        }
+        fixed = ext = 0;
+        for (i = AUTO_PIN_MIC; i <= AUTO_PIN_FRONT_MIC; i++)
+                if (check_mic_pin(codec, cfg->input_pins[i], &fixed, &ext))
+                        return 0;
+        for (i = 0; i < spec->num_dmics; i++)
+                if (check_mic_pin(codec, spec->dmic_nids[i], &fixed, &ext))
+                        return 0;
+        if (!fixed || !ext)
+                return 0;
+        if (!(get_wcaps(codec, ext) & AC_WCAP_UNSOL_CAP))
+                return 0; /* no unsol support */
+        if (set_mic_route(codec, &spec->ext_mic, ext) ||
+            set_mic_route(codec, &spec->int_mic, fixed))
+                return 0; /* something is wrong */
+        return 1;
 }
 
@@ -3443 +3748 @@
         struct sigmatel_spec *spec = codec->spec;
         struct hda_input_mux *imux = &spec->private_imux;
-        hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
-        int i, j, k;
+        int i, j;
 
         for (i = 0; i < AUTO_PIN_LAST; i++) {
-                int index;
-
-                if (!cfg->input_pins[i])
+                hda_nid_t nid = cfg->input_pins[i];
+                int index, err;
+
+                if (!nid)
                         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;
-                                }
+                        index = get_connection_index(codec, spec->mux_nids[j],
+                                                     nid);
+                        if (index >= 0)
+                                break;
                 }
-                continue;
-        found:
+                if (index < 0)
+                        continue;
+
+                err = create_elem_capture_vol(codec, nid,
+                                              auto_pin_cfg_labels[i]);
+                if (err < 0)
+                        return err;
+
                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
                 imux->items[imux->num_items].index = index;
                 imux->num_items++;
         }
+        spec->num_analog_muxes = imux->num_items;
 
         if (imux->num_items) {
@@ -3521 +3827 @@
         struct sigmatel_spec *spec = codec->spec;
         int hp_swap = 0;
-        int err;
+        int i, err;
 
         if ((err = snd_hda_parse_pin_def_config(codec,
@@ -3561 +3867 @@
                                 spec->autocfg.mono_out_pin, conn_list, 1) &&
                                 snd_hda_get_connections(codec, conn_list[0],
-                                conn_list, 1)) {
+                                conn_list, 1) > 0) {
 
                                 int wcaps = get_wcaps(codec, conn_list[0]);
-                                int wid_type = (wcaps & AC_WCAP_TYPE)
-                                        >> AC_WCAP_TYPE_SHIFT;
+                                int wid_type = get_wcaps_type(wcaps);
                                 /* LR swap check, some stac925x have a mux that
                                  * changes the DACs output path instead of the
@@ -3630 +3935 @@
                 if (err < 0)
                         return err;
+                /* IDT/STAC codecs have linear beep tone parameter */
+                codec->beep->linear_tone = 1;
                 /* if no beep switch is available, make its own one */
                 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
@@ -3652 +3959 @@
                 spec->autocfg.line_out_type = AUTO_PIN_HP_OUT;
                 spec->autocfg.line_outs = 0;
+        }
+
+        if (stac_check_auto_mic(codec)) {
+                spec->auto_mic = 1;
+                /* only one capture for auto-mic */
+                spec->num_adcs = 1;
+                spec->num_caps = 1;
+                spec->num_muxes = 1;
+        }
+
+        for (i = 0; i < spec->num_caps; i++) {
+                err = stac92xx_add_capvol_ctls(codec, spec->capvols[i],
+                                               spec->capsws[i], i);
+                if (err < 0)
+                        return err;
         }
 
@@ -3852 +4174 @@
 }
 
-#ifdef CONFIG_SND_JACK
+#ifdef CONFIG_SND_HDA_INPUT_JACK
 static void stac92xx_free_jack_priv(struct snd_jack *jack)
 {
@@ -3864 +4186 @@
                 hda_nid_t nid, int type)
 {
-#ifdef CONFIG_SND_JACK
+#ifdef CONFIG_SND_HDA_INPUT_JACK
         struct sigmatel_spec *spec = codec->spec;
         struct sigmatel_jack *jack;
@@ -3882 +4204 @@
         jack->type = type;
 
-        sprintf(name, "%s at %s %s Jack",
+        snprintf(name, sizeof(name), "%s at %s %s Jack",
                 snd_hda_get_jack_type(def_conf),
                 snd_hda_get_jack_connectivity(def_conf),
@@ -3916 +4238 @@
 
 static struct sigmatel_event *stac_get_event(struct hda_codec *codec,
-                                             hda_nid_t nid, unsigned char type)
+                                             hda_nid_t nid)
 {
         struct sigmatel_spec *spec = codec->spec;
@@ -3923 +4245 @@
 
         for (i = 0; i < spec->events.used; i++, event++) {
-                if (event->nid == nid && event->type == type)
+                if (event->nid == nid)
                         return event;
         }
@@ -3943 +4265 @@
 }
 
-static void enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
-                              unsigned int type)
+/* check if given nid is a valid pin and no other events are assigned
+ * to it.  If OK, assign the event, set the unsol flag, and returns 1.
+ * Otherwise, returns zero.
+ */
+static int enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
+                             unsigned int type)
 {
         struct sigmatel_event *event;
@@ -3950 +4276 @@
 
         if (!(get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP))
-                return;
-        event = stac_get_event(codec, nid, type);
-        if (event)
+                return 0;
+        event = stac_get_event(codec, nid);
+        if (event) {
+                if (event->type != type)
+                        return 0;
                 tag = event->tag;
-        else
+        } else {
                 tag = stac_add_event(codec->spec, nid, type, 0);
-        if (tag < 0)
-                return;
+                if (tag < 0)
+                        return 0;
+        }
         snd_hda_codec_write_cache(codec, nid, 0,
                                   AC_VERB_SET_UNSOLICITED_ENABLE,
                                   AC_USRSP_EN | tag);
+        return 1;
 }
 
@@ -4053 +4383 @@
                         enable_pin_detect(codec, nid, STAC_HP_EVENT);
                 }
+                if (cfg->line_out_type == AUTO_PIN_LINE_OUT &&
+                    cfg->speaker_outs > 0) {
+                        /* enable pin-detect for line-outs as well */
+                        for (i = 0; i < cfg->line_outs; i++) {
+                                hda_nid_t nid = cfg->line_out_pins[i];
+                                enable_pin_detect(codec, nid, STAC_LO_EVENT);
+                        }
+                }
+
                 /* force to enable the first line-out; the others are set up
                  * in unsol_event
@@ -4059 +4398 @@
                                 AC_PINCTL_OUT_EN);
                 /* fake event to set up pins */
-                stac_issue_unsol_event(codec, spec->autocfg.hp_pins[0],
-                                       STAC_HP_EVENT);
+                stac_issue_unsol_event(codec, spec->autocfg.hp_pins[0]);
         } else {
                 stac92xx_auto_init_multi_out(codec);
@@ -4066 +4404 @@
                 for (i = 0; i < cfg->hp_outs; i++)
                         stac_toggle_power_map(codec, cfg->hp_pins[i], 1);
+        }
+        if (spec->auto_mic) {
+                /* initialize connection to analog input */
+                if (spec->dmux_nids)
+                        snd_hda_codec_write_cache(codec, spec->dmux_nids[0], 0,
+                                          AC_VERB_SET_CONNECT_SEL, 0);
+                if (enable_pin_detect(codec, spec->ext_mic.pin, STAC_MIC_EVENT))
+                        stac_issue_unsol_event(codec, spec->ext_mic.pin);
         }
         for (i = 0; i < AUTO_PIN_LAST; i++) {
@@ -4073 +4419 @@
                         if (i == AUTO_PIN_MIC || i == AUTO_PIN_FRONT_MIC) {
                                 /* for mic pins, force to initialize */
-                                pinctl = stac92xx_get_vref(codec, nid);
+                                pinctl = stac92xx_get_default_vref(codec, nid);
                                 pinctl |= AC_PINCTL_IN_EN;
                                 stac92xx_auto_set_pinctl(codec, nid, pinctl);
@@ -4080 +4426 @@
                                         AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
                                 /* if PINCTL already set then skip */
-                                if (!(pinctl & AC_PINCTL_IN_EN)) {
+                                /* Also, if both INPUT and OUTPUT are set,
+                                 * it must be a BIOS bug; need to override, too
+                                 */
+                                if (!(pinctl & AC_PINCTL_IN_EN) ||
+                                    (pinctl & AC_PINCTL_OUT_EN)) {
+                                        pinctl &= ~AC_PINCTL_OUT_EN;
                                         pinctl |= AC_PINCTL_IN_EN;
                                         stac92xx_auto_set_pinctl(codec, nid,
@@ -4088 +4439 @@
                         conf = snd_hda_codec_get_pincfg(codec, nid);
                         if (get_defcfg_connect(conf) != AC_JACK_PORT_FIXED) {
-                                enable_pin_detect(codec, nid,
-                                                  STAC_INSERT_EVENT);
-                                stac_issue_unsol_event(codec, nid,
-                                                       STAC_INSERT_EVENT);
+                                if (enable_pin_detect(codec, nid,
+                                                      STAC_INSERT_EVENT))
+                                        stac_issue_unsol_event(codec, nid);
                         }
                 }
@@ -4136 +4486 @@
                         continue;
                 }
-                if (!stac_get_event(codec, nid, STAC_INSERT_EVENT)) {
-                        enable_pin_detect(codec, nid, STAC_PWR_EVENT);
-                        stac_issue_unsol_event(codec, nid, STAC_PWR_EVENT);
-                }
+                if (enable_pin_detect(codec, nid, STAC_PWR_EVENT))
+                        stac_issue_unsol_event(codec, nid);
         }
         if (spec->dac_list)
@@ -4148 +4496 @@
 static void stac92xx_free_jacks(struct hda_codec *codec)
 {
-#ifdef CONFIG_SND_JACK
+#ifdef CONFIG_SND_HDA_INPUT_JACK
         /* free jack instances manually when clearing/reconfiguring */
         struct sigmatel_spec *spec = codec->spec;
@@ -4242 +4590 @@
         return 0;
 }
+
+static void stac92xx_line_out_detect(struct hda_codec *codec,
+                                     int presence)
+{
+        struct sigmatel_spec *spec = codec->spec;
+        struct auto_pin_cfg *cfg = &spec->autocfg;
+        int i;
+
+        for (i = 0; i < cfg->line_outs; i++) {
+                if (presence)
+                        break;
+                presence = get_pin_presence(codec, cfg->line_out_pins[i]);
+                if (presence) {
+                        unsigned int pinctl;
+                        pinctl = snd_hda_codec_read(codec,
+                                                    cfg->line_out_pins[i], 0,
+                                            AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
+                        if (pinctl & AC_PINCTL_IN_EN)
+                                presence = 0; /* mic- or line-input */
+                }
+        }
+
+        if (presence) {
+                /* disable speakers */
+                for (i = 0; i < cfg->speaker_outs; i++)
+                        stac92xx_reset_pinctl(codec, cfg->speaker_pins[i],
+                                                AC_PINCTL_OUT_EN);
+                if (spec->eapd_mask && spec->eapd_switch)
+                        stac_gpio_set(codec, spec->gpio_mask,
+                                spec->gpio_dir, spec->gpio_data &
+                                ~spec->eapd_mask);
+        } else {
+                /* enable speakers */
+                for (i = 0; i < cfg->speaker_outs; i++)
+                        stac92xx_set_pinctl(codec, cfg->speaker_pins[i],
+                                                AC_PINCTL_OUT_EN);
+                if (spec->eapd_mask && spec->eapd_switch)
+                        stac_gpio_set(codec, spec->gpio_mask,
+                                spec->gpio_dir, spec->gpio_data |
+                                spec->eapd_mask);
+        }
+} 
 
 /* return non-zero if the hp-pin of the given array index isn't
@@ -4295 +4685 @@
                         stac92xx_reset_pinctl(codec, cfg->line_out_pins[i],
                                                 AC_PINCTL_OUT_EN);
-                for (i = 0; i < cfg->speaker_outs; i++)
-                        stac92xx_reset_pinctl(codec, cfg->speaker_pins[i],
-                                                AC_PINCTL_OUT_EN);
-                if (spec->eapd_mask && spec->eapd_switch)
-                        stac_gpio_set(codec, spec->gpio_mask,
-                                spec->gpio_dir, spec->gpio_data &
-                                ~spec->eapd_mask);
         } else {
                 /* enable lineouts */
@@ -4310 +4693 @@
                         stac92xx_set_pinctl(codec, cfg->line_out_pins[i],
                                                 AC_PINCTL_OUT_EN);
-                for (i = 0; i < cfg->speaker_outs; i++)
-                        stac92xx_set_pinctl(codec, cfg->speaker_pins[i],
-                                                AC_PINCTL_OUT_EN);
-                if (spec->eapd_mask && spec->eapd_switch)
-                        stac_gpio_set(codec, spec->gpio_mask,
-                                spec->gpio_dir, spec->gpio_data |
-                                spec->eapd_mask);
-        }
+        }
+        stac92xx_line_out_detect(codec, presence);
         /* toggle hp outs */
         for (i = 0; i < cfg->hp_outs; i++) {
@@ -4402 +4779 @@
 }
 
-static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid,
-                                   unsigned char type)
-{
-        struct sigmatel_event *event = stac_get_event(codec, nid, type);
+static void stac92xx_mic_detect(struct hda_codec *codec)
+{
+        struct sigmatel_spec *spec = codec->spec;
+        struct sigmatel_mic_route *mic;
+
+        if (get_pin_presence(codec, spec->ext_mic.pin))
+                mic = &spec->ext_mic;
+        else
+                mic = &spec->int_mic;
+        if (mic->dmux_idx)
+                snd_hda_codec_write_cache(codec, spec->dmux_nids[0], 0,
+                                          AC_VERB_SET_CONNECT_SEL,
+                                          mic->dmux_idx);
+        else
+                snd_hda_codec_write_cache(codec, spec->mux_nids[0], 0,
+                                          AC_VERB_SET_CONNECT_SEL,
+                                          mic->mux_idx);
+}
+
+static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid)
+{
+        struct sigmatel_event *event = stac_get_event(codec, nid);
         if (!event)
                 return;
@@ -4424 +4819 @@
         switch (event->type) {
         case STAC_HP_EVENT:
+        case STAC_LO_EVENT:
                 stac92xx_hp_detect(codec);
-                /* fallthru */
+                break;
+        case STAC_MIC_EVENT:
+                stac92xx_mic_detect(codec);
+                break;
+        }
+
+        switch (event->type) {
+        case STAC_HP_EVENT:
+        case STAC_LO_EVENT:
+        case STAC_MIC_EVENT:
         case STAC_INSERT_EVENT:
         case STAC_PWR_EVENT:
@@ -4516 +4921 @@
         /* fake event to set up pins again to override cached values */
         if (spec->hp_detect)
-                stac_issue_unsol_event(codec, spec->autocfg.hp_pins[0],
-                                       STAC_HP_EVENT);
+                stac_issue_unsol_event(codec, spec->autocfg.hp_pins[0]);
         return 0;
 }
 
-
 /*
- * using power check for controlling mute led of HP HDX notebooks
+ * using power check for controlling mute led of HP notebooks
  * check for mute state only on Speakers (nid = 0x10)
  *
  * For this feature CONFIG_SND_HDA_POWER_SAVE is needed, otherwise
  * the LED is NOT working properly !
+ *
+ * Changed name to reflect that it now works for any designated
+ * model, not just HP HDX.
  */
 
 #ifdef CONFIG_SND_HDA_POWER_SAVE
-static int stac92xx_hp_hdx_check_power_status(struct hda_codec *codec,
+static int stac92xx_hp_check_power_status(struct hda_codec *codec,
                                               hda_nid_t nid)
 {
@@ -4539 +4945 @@
                 if (snd_hda_codec_amp_read(codec, nid, 0, HDA_OUTPUT, 0) &
                     HDA_AMP_MUTE)
-                        spec->gpio_data &= ~0x08;  /* orange */
+                        spec->gpio_data &= ~spec->gpio_led; /* orange */
                 else
-                        spec->gpio_data |= 0x08;   /* white */
+                        spec->gpio_data |= spec->gpio_led; /* white */
 
                 stac_gpio_set(codec, spec->gpio_mask,
@@ -4555 +4961 @@
 {
         struct sigmatel_spec *spec = codec->spec;
+        int i;
+        hda_nid_t nid;
+
+        /* reset each pin before powering down DAC/ADC to avoid click noise */
+        nid = codec->start_nid;
+        for (i = 0; i < codec->num_nodes; i++, nid++) {
+                unsigned int wcaps = get_wcaps(codec, nid);
+                unsigned int wid_type = get_wcaps_type(wcaps);
+                if (wid_type == AC_WID_PIN)
+                        snd_hda_codec_read(codec, nid, 0,
+                                AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
+        }
+
         if (spec->eapd_mask)
                 stac_gpio_set(codec, spec->gpio_mask,
@@ -4591 +5010 @@
                                                         stac9200_cfg_tbl);
         if (spec->board_config < 0)
-                snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9200, using BIOS defaults\n");
+                snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
+                            codec->chip_name);
         else
                 stac92xx_set_config_regs(codec,
@@ -4663 +5083 @@
  again:
         if (spec->board_config < 0)
-                snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC925x,"
-                                      "using BIOS defaults\n");
+                snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
+                            codec->chip_name);
         else
                 stac92xx_set_config_regs(codec,
@@ -4694 +5114 @@
         spec->init = stac925x_core_init;
         spec->mixer = stac925x_mixer;
+        spec->num_caps = 1;
+        spec->capvols = stac925x_capvols;
+        spec->capsws = stac925x_capsws;
 
         err = stac92xx_parse_auto_config(codec, 0x8, 0x7);
@@ -4714 +5137 @@
         return 0;
 }
-
-static struct hda_input_mux stac92hd73xx_dmux = {
-        .num_items = 4,
-        .items = {
-                { "Analog Inputs", 0x0b },
-                { "Digital Mic 1", 0x09 },
-                { "Digital Mic 2", 0x0a },
-                { "CD", 0x08 },
-        }
-};
 
 static int patch_stac92hd73xx(struct hda_codec *codec)
@@ -4746 +5159 @@
 again:
         if (spec->board_config < 0)
-                snd_printdd(KERN_INFO "hda_codec: Unknown model for"
-                        " STAC92HD73XX, using BIOS defaults\n");
+                snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
+                            codec->chip_name);
         else
                 stac92xx_set_config_regs(codec,
@@ -4794 +5207 @@
         spec->num_adcs = ARRAY_SIZE(stac92hd73xx_adc_nids);
         spec->num_dmuxes = ARRAY_SIZE(stac92hd73xx_dmux_nids);
-        memcpy(&spec->private_dimux, &stac92hd73xx_dmux,
-                        sizeof(stac92hd73xx_dmux));
+
+        spec->num_caps = STAC92HD73XX_NUM_CAPS;
+        spec->capvols = stac92hd73xx_capvols;
+        spec->capsws = stac92hd73xx_capsws;
 
         switch (spec->board_config) {
@@ -4816 +5231 @@
                         snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170);
                         spec->num_dmics = 0;
-                        spec->private_dimux.num_items = 1;
                         break;
                 case STAC_DELL_M6_DMIC: /* Digital Mics */
                         snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160);
                         spec->num_dmics = 1;
-                        spec->private_dimux.num_items = 2;
                         break;
                 case STAC_DELL_M6_BOTH: /* Both */
@@ -4827 +5240 @@
                         snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160);
                         spec->num_dmics = 1;
-                        spec->private_dimux.num_items = 2;
                         break;
                 }
@@ -4835 +5247 @@
                 spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids);
                 spec->eapd_switch = 1;
+                break;
         }
         if (spec->board_config > STAC_92HD73XX_REF) {
@@ -4841 +5254 @@
                 spec->gpio_data = 0x01;
         }
-        spec->dinput_mux = &spec->private_dimux;
 
         spec->num_pwrs = ARRAY_SIZE(stac92hd73xx_pwr_nids);
@@ -4873 +5285 @@
 }
 
-static struct hda_input_mux stac92hd83xxx_dmux = {
-        .num_items = 3,
-        .items = {
-                { "Analog Inputs", 0x03 },
-                { "Digital Mic 1", 0x04 },
-                { "Digital Mic 2", 0x05 },
-        }
-};
-
 static int patch_stac92hd83xxx(struct hda_codec *codec)
 {
@@ -4898 +5301 @@
         spec->mono_nid = 0x19;
         spec->digbeep_nid = 0x21;
-        spec->dmic_nids = stac92hd83xxx_dmic_nids;
-        spec->dmux_nids = stac92hd83xxx_dmux_nids;
+        spec->mux_nids = stac92hd83xxx_mux_nids;
+        spec->num_muxes = ARRAY_SIZE(stac92hd83xxx_mux_nids);
         spec->adc_nids = stac92hd83xxx_adc_nids;
+        spec->num_adcs = ARRAY_SIZE(stac92hd83xxx_adc_nids);
         spec->pwr_nids = stac92hd83xxx_pwr_nids;
-        spec->amp_nids = stac92hd83xxx_amp_nids;
         spec->pwr_mapping = stac92hd83xxx_pwr_mapping;
         spec->num_pwrs = ARRAY_SIZE(stac92hd83xxx_pwr_nids);
@@ -4908 +5311 @@
 
         spec->init = stac92hd83xxx_core_init;
-        spec->mixer = stac92hd83xxx_mixer;
         spec->num_pins = ARRAY_SIZE(stac92hd83xxx_pin_nids);
-        spec->num_dmuxes = ARRAY_SIZE(stac92hd83xxx_dmux_nids);
-        spec->num_adcs = ARRAY_SIZE(stac92hd83xxx_adc_nids);
-        spec->num_amps = ARRAY_SIZE(stac92hd83xxx_amp_nids);
-        spec->num_dmics = STAC92HD83XXX_NUM_DMICS;
-        spec->dinput_mux = &stac92hd83xxx_dmux;
         spec->pin_nids = stac92hd83xxx_pin_nids;
+        spec->num_caps = STAC92HD83XXX_NUM_CAPS;
+        spec->capvols = stac92hd83xxx_capvols;
+        spec->capsws = stac92hd83xxx_capsws;
+
         spec->board_config = snd_hda_check_board_config(codec,
                                                         STAC_92HD83XXX_MODELS,
@@ -4922 +5323 @@
 again:
         if (spec->board_config < 0)
-                snd_printdd(KERN_INFO "hda_codec: Unknown model for"
-                        " STAC92HD83XXX, using BIOS defaults\n");
+                snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
+                            codec->chip_name);
         else
                 stac92xx_set_config_regs(codec,
@@ -4965 +5366 @@
         num_dacs = snd_hda_get_connections(codec, nid,
                                 conn, STAC92HD83_DAC_COUNT + 1) - 1;
+        if (num_dacs < 0)
+                num_dacs = STAC92HD83_DAC_COUNT;
 
         /* set port X to select the last DAC
@@ -4977 +5380 @@
         return 0;
 }
-
-static struct hda_input_mux stac92hd71bxx_dmux_nomixer = {
-        .num_items = 3,
-        .items = {
-                { "Analog Inputs", 0x00 },
-                { "Digital Mic 1", 0x02 },
-                { "Digital Mic 2", 0x03 },
-        }
-};
-
-static struct hda_input_mux stac92hd71bxx_dmux_amixer = {
-        .num_items = 4,
-        .items = {
-                { "Analog Inputs", 0x00 },
-                { "Mixer", 0x01 },
-                { "Digital Mic 1", 0x02 },
-                { "Digital Mic 2", 0x03 },
-        }
-};
 
 /* get the pin connection (fixed, none, etc) */
@@ -5057 +5441 @@
         struct hda_verb *unmute_init = stac92hd71bxx_unmute_core_init;
         int err = 0;
-        unsigned int ndmic_nids = 0;
 
         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
@@ -5086 +5469 @@
 again:
         if (spec->board_config < 0)
-                snd_printdd(KERN_INFO "hda_codec: Unknown model for"
-                        " STAC92HD71BXX, using BIOS defaults\n");
+                snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
+                            codec->chip_name);
         else
                 stac92xx_set_config_regs(codec,
@@ -5101 +5484 @@
         spec->dmic_nids = stac92hd71bxx_dmic_nids;
         spec->dmux_nids = stac92hd71bxx_dmux_nids;
+
+        spec->num_caps = STAC92HD71BXX_NUM_CAPS;
+        spec->capvols = stac92hd71bxx_capvols;
+        spec->capsws = stac92hd71bxx_capsws;
 
         switch (codec->vendor_id) {
@@ -5109 +5496 @@
         case 0x111d76b4: /* 6 Port without Analog Mixer */
         case 0x111d76b5:
-                memcpy(&spec->private_dimux, &stac92hd71bxx_dmux_nomixer,
-                       sizeof(stac92hd71bxx_dmux_nomixer));
-                spec->mixer = stac92hd71bxx_mixer;
                 spec->init = stac92hd71bxx_core_init;
                 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
@@ -5117 +5501 @@
                                         stac92hd71bxx_dmic_nids,
                                         STAC92HD71BXX_NUM_DMICS);
-                if (spec->num_dmics) {
-                        spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
-                        spec->dinput_mux = &spec->private_dimux;
-                        ndmic_nids = ARRAY_SIZE(stac92hd71bxx_dmic_nids) - 1;
-                }
                 break;
         case 0x111d7608: /* 5 Port with Analog Mixer */
-                memcpy(&spec->private_dimux, &stac92hd71bxx_dmux_amixer,
-                       sizeof(stac92hd71bxx_dmux_amixer));
-                spec->private_dimux.num_items--;
                 switch (spec->board_config) {
                 case STAC_HP_M4:
@@ -5148 +5524 @@
                 /* no output amps */
                 spec->num_pwrs = 0;
-                spec->mixer = stac92hd71bxx_analog_mixer;
-                spec->dinput_mux = &spec->private_dimux;
-
                 /* disable VSW */
-                spec->init = &stac92hd71bxx_analog_core_init[HD_DISABLE_PORTF];
+                spec->init = stac92hd71bxx_core_init;
                 unmute_init++;
                 snd_hda_codec_set_pincfg(codec, 0x0f, 0x40f000f0);
@@ -5160 +5533 @@
                                         stac92hd71bxx_dmic_nids,
                                         STAC92HD71BXX_NUM_DMICS - 1);
-                spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
-                ndmic_nids = ARRAY_SIZE(stac92hd71bxx_dmic_nids) - 2;
                 break;
         case 0x111d7603: /* 6 Port with Analog Mixer */
@@ -5171 +5542 @@
                 /* fallthru */
         default:
-                memcpy(&spec->private_dimux, &stac92hd71bxx_dmux_amixer,
-                       sizeof(stac92hd71bxx_dmux_amixer));
-                spec->dinput_mux = &spec->private_dimux;
-                spec->mixer = stac92hd71bxx_analog_mixer;
-                spec->init = stac92hd71bxx_analog_core_init;
+                spec->init = stac92hd71bxx_core_init;
                 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
                 spec->num_dmics = stac92hd71bxx_connected_ports(codec,
                                         stac92hd71bxx_dmic_nids,
                                         STAC92HD71BXX_NUM_DMICS);
-                spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
-                ndmic_nids = ARRAY_SIZE(stac92hd71bxx_dmic_nids) - 1;
+                break;
         }
 
         if (get_wcaps(codec, 0xa) & AC_WCAP_IN_AMP)
                 snd_hda_sequence_write_cache(codec, unmute_init);
+
+        /* Some HP machines seem to have unstable codec communications
+         * especially with ATI fglrx driver.  For recovering from the
+         * CORB/RIRB stall, allow the BUS reset and keep always sync
+         */
+        if (spec->board_config == STAC_HP_DV5) {
+                codec->bus->sync_write = 1;
+                codec->bus->allow_bus_reset = 1;
+        }
 
         spec->aloopback_ctl = stac92hd71bxx_loopback;
@@ -5200 +5575 @@
         spec->num_muxes = ARRAY_SIZE(stac92hd71bxx_mux_nids);
         spec->num_adcs = ARRAY_SIZE(stac92hd71bxx_adc_nids);
+        spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
         spec->num_smuxes = stac92hd71bxx_connected_smuxes(codec, 0x1e);
 
@@ -5220 +5596 @@
                 spec->num_dmuxes = 1;
                 break;
+        case STAC_HP_DV4_1222NR:
+                spec->num_dmics = 1;
+                /* I don't know if it needs 1 or 2 smuxes - will wait for
+                 * bug reports to fix if needed
+                 */
+                spec->num_smuxes = 1;
+                spec->num_dmuxes = 1;
+                spec->gpio_led = 0x01;
+                /* fallthrough */
         case STAC_HP_DV5:
                 snd_hda_codec_set_pincfg(codec, 0x0d, 0x90170010);
@@ -5228 +5613 @@
                 spec->num_dmuxes = 1;
                 spec->num_smuxes = 1;
-                /*
-                 * For controlling MUTE LED on HP HDX16/HDX18 notebooks,
-                 * the CONFIG_SND_HDA_POWER_SAVE is needed to be set.
-                 */
+                /* orange/white mute led on GPIO3, orange=0, white=1 */
+                spec->gpio_led = 0x08;
+                break;
+        }
+
 #ifdef CONFIG_SND_HDA_POWER_SAVE
-                /* orange/white mute led on GPIO3, orange=0, white=1 */
-                spec->gpio_mask |= 0x08;
-                spec->gpio_dir  |= 0x08;
-                spec->gpio_data |= 0x08;  /* set to white */
-
+        if (spec->gpio_led) {
+                spec->gpio_mask |= spec->gpio_led;
+                spec->gpio_dir |= spec->gpio_led;
+                spec->gpio_data |= spec->gpio_led;
                 /* register check_power_status callback. */
                 codec->patch_ops.check_power_status =
-                    stac92xx_hp_hdx_check_power_status;
+                        stac92xx_hp_check_power_status;
+        }
 #endif  
-                break;
-        };
 
         spec->multiout.dac_nids = spec->dac_nids;
-        if (spec->dinput_mux)
-                spec->private_dimux.num_items += spec->num_dmics - ndmic_nids;
 
         err = stac92xx_parse_auto_config(codec, 0x21, 0);
@@ -5268 +5650 @@
 
         return 0;
-};
+}
 
 static int patch_stac922x(struct hda_codec *codec)
@@ -5325 +5707 @@
  again:
         if (spec->board_config < 0)
-                snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC922x, "
-                        "using BIOS defaults\n");
+                snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
+                            codec->chip_name);
         else
                 stac92xx_set_config_regs(codec,
@@ -5339 +5721 @@
 
         spec->init = stac922x_core_init;
-        spec->mixer = stac922x_mixer;
+
+        spec->num_caps = STAC922X_NUM_CAPS;
+        spec->capvols = stac922x_capvols;
+        spec->capsws = stac922x_capsws;
 
         spec->multiout.dac_nids = spec->dac_nids;
@@ -5388 +5773 @@
  again:
         if (spec->board_config < 0)
-                snd_printdd(KERN_INFO "hda_codec: Unknown model for"
-                            "STAC927x, using BIOS defaults\n");
+                snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
+                            codec->chip_name);
         else
                 stac92xx_set_config_regs(codec,
@@ -5414 +5799 @@
 
                 spec->init = d965_core_init;
-                spec->mixer = stac927x_mixer;
                 break;
         case STAC_DELL_BIOS:
@@ -5423 +5807 @@
                         snd_hda_codec_set_pincfg(codec, 0x21, 0x01442070);
                         break;
-                };
+                }
                 /* configure the analog microphone on some laptops */
                 snd_hda_codec_set_pincfg(codec, 0x0c, 0x90a79130);
@@ -5435 +5819 @@
                 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x04;
                 spec->gpio_data = 0x04;
+                switch (codec->subsystem_id) {
+                case 0x1028022f:
+                        /* correct EAPD to be GPIO0 */
+                        spec->eapd_mask = spec->gpio_mask = 0x01;
+                        spec->gpio_dir = spec->gpio_data = 0x01;
+                        break;
+                };
                 spec->dmic_nids = stac927x_dmic_nids;
                 spec->num_dmics = STAC927X_NUM_DMICS;
 
                 spec->init = d965_core_init;
-                spec->mixer = stac927x_mixer;
                 spec->dmux_nids = stac927x_dmux_nids;
                 spec->num_dmuxes = ARRAY_SIZE(stac927x_dmux_nids);
@@ -5452 +5842 @@
 
                 spec->init = stac927x_core_init;
-                spec->mixer = stac927x_mixer;
-        }
+        }
+
+        spec->num_caps = STAC927X_NUM_CAPS;
+        spec->capvols = stac927x_capvols;
+        spec->capsws = stac927x_capsws;
 
         spec->num_pwrs = 0;
@@ -5516 +5909 @@
  again:
         if (spec->board_config < 0)
-                snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9205, using BIOS defaults\n");
+                snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
+                            codec->chip_name);
         else
                 stac92xx_set_config_regs(codec,
@@ -5535 +5929 @@
 
         spec->init = stac9205_core_init;
-        spec->mixer = stac9205_mixer;
         spec->aloopback_ctl = stac9205_loopback;
+
+        spec->num_caps = STAC9205_NUM_CAPS;
+        spec->capvols = stac9205_capvols;
+        spec->capsws = stac9205_capsws;
 
         spec->aloopback_mask = 0x40;
@@ -5612 +6009 @@
 };
 
-static struct snd_kcontrol_new stac9872_mixer[] = {
-        HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
-        HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
-        {0} /* end */
-};
-
 static hda_nid_t stac9872_pin_nids[] = {
         0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
@@ -5630 +6021 @@
         0x15
 };
+
+static unsigned long stac9872_capvols[] = {
+        HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
+};
+#define stac9872_capsws         stac9872_capvols
 
 static unsigned int stac9872_vaio_pin_configs[9] = {
@@ -5647 +6043 @@
 
 static struct snd_pci_quirk stac9872_cfg_tbl[] = {
+        SND_PCI_QUIRK_MASK(0x104d, 0xfff0, 0x81e0,
+                           "Sony VAIO F/S", STAC_9872_VAIO),
         {0} /* terminator */
 };
@@ -5659 +6057 @@
                 return -ENOMEM;
         codec->spec = spec;
+        spec->num_pins = ARRAY_SIZE(stac9872_pin_nids);
+        spec->pin_nids = stac9872_pin_nids;
 
         spec->board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS,
@@ -5664 +6064 @@
                                                         stac9872_cfg_tbl);
         if (spec->board_config < 0)
-                snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9872, "
-                            "using BIOS defaults\n");
+                snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
+                            codec->chip_name);
         else
                 stac92xx_set_config_regs(codec,
                                          stac9872_brd_tbl[spec->board_config]);
 
-        spec->num_pins = ARRAY_SIZE(stac9872_pin_nids);
-        spec->pin_nids = stac9872_pin_nids;
         spec->multiout.dac_nids = spec->dac_nids;
         spec->num_adcs = ARRAY_SIZE(stac9872_adc_nids);
@@ -5677 +6075 @@
         spec->num_muxes = ARRAY_SIZE(stac9872_mux_nids);
         spec->mux_nids = stac9872_mux_nids;
-        spec->mixer = stac9872_mixer;
         spec->init = stac9872_core_init;
+        spec->num_caps = 1;
+        spec->capvols = stac9872_capvols;
+        spec->capsws = stac9872_capsws;
 
         err = stac92xx_parse_auto_config(codec, 0x10, 0x12);
@@ -5733 +6133 @@
         { .id = 0x83847662, .name = "STAC9872AK", .patch = patch_stac9872 },
         { .id = 0x83847664, .name = "CXD9872AKD", .patch = patch_stac9872 },
+        { .id = 0x83847698, .name = "STAC9205", .patch = patch_stac9205 },
         { .id = 0x838476a0, .name = "STAC9205", .patch = patch_stac9205 },
         { .id = 0x838476a1, .name = "STAC9205D", .patch = patch_stac9205 },

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

@@ -206 +206 @@
         /* playback */
         struct hda_multi_out multiout;
-        hda_nid_t extra_dig_out_nid;
+        hda_nid_t slave_dig_outs[2];
 
         /* capture */
         unsigned int num_adc_nids;
         hda_nid_t *adc_nids;
+        hda_nid_t mux_nids[3];
         hda_nid_t dig_in_nid;
+        hda_nid_t dig_in_pin;
 
         /* capture source */
@@ -320 +322 @@
         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
                             AMP_OUT_UNMUTE);
+        if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
+                snd_hda_codec_write(codec, nid, 0, 
+                                    AC_VERB_SET_EAPD_BTLENABLE, 0x02);
 }
 
@@ -388 +393 @@
         struct via_spec *spec = codec->spec;
         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
-        unsigned int vendor_id = codec->vendor_id;
-
-        /* AIW0  lydia 060801 add for correct sw0 input select */
-        if (IS_VT1708_VENDORID(vendor_id) && (adc_idx == 0))
-                return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
-                                             0x18, &spec->cur_mux[adc_idx]);
-        else if ((IS_VT1709_10CH_VENDORID(vendor_id) ||
-                  IS_VT1709_6CH_VENDORID(vendor_id)) && (adc_idx == 0))
-                return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
-                                             0x19, &spec->cur_mux[adc_idx]);
-        else if ((IS_VT1708B_8CH_VENDORID(vendor_id) ||
-                  IS_VT1708B_4CH_VENDORID(vendor_id)) && (adc_idx == 0))
-                return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
-                                             0x17, &spec->cur_mux[adc_idx]);
-        else if (IS_VT1702_VENDORID(vendor_id) && (adc_idx == 0))
-                return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
-                                             0x13, &spec->cur_mux[adc_idx]);
-        else
-                return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
-                                             spec->adc_nids[adc_idx],
-                                             &spec->cur_mux[adc_idx]);
+
+        if (!spec->mux_nids[adc_idx])
+                return -EINVAL;
+        return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
+                                     spec->mux_nids[adc_idx],
+                                     &spec->cur_mux[adc_idx]);
 }
 
@@ -732 +722 @@
 }
 
-/* setup SPDIF output stream */
-static void setup_dig_playback_stream(struct hda_codec *codec, hda_nid_t nid,
-                                 unsigned int stream_tag, unsigned int format)
-{
-        /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
-        if (codec->spdif_ctls & AC_DIG1_ENABLE)
-                snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
-                                    codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff);
-        snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
-        /* turn on again (if needed) */
-        if (codec->spdif_ctls & AC_DIG1_ENABLE)
-                snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
-                                    codec->spdif_ctls & 0xff);
-}
-
 static int via_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
                                         struct hda_codec *codec,
@@ -754 +729 @@
 {
         struct via_spec *spec = codec->spec;
-        hda_nid_t nid;
-
-        /* 1st or 2nd S/PDIF */
-        if (substream->number == 0)
-                nid = spec->multiout.dig_out_nid;
-        else if (substream->number == 1)
-                nid = spec->extra_dig_out_nid;
-        else
-                return -1;
-
-        mutex_lock(&codec->spdif_mutex);
-        setup_dig_playback_stream(codec, nid, stream_tag, format);
-        mutex_unlock(&codec->spdif_mutex);
+        return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
+                                             stream_tag, format, substream);
+}
+
+static int via_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
+                                        struct hda_codec *codec,
+                                        struct snd_pcm_substream *substream)
+{
+        struct via_spec *spec = codec->spec;
+        snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
         return 0;
 }
@@ -843 +815 @@
                 .open = via_dig_playback_pcm_open,
                 .close = via_dig_playback_pcm_close,
-                .prepare = via_dig_playback_pcm_prepare
+                .prepare = via_dig_playback_pcm_prepare,
+                .cleanup = via_dig_playback_pcm_cleanup
         },
 };
@@ -875 +848 @@
                         return err;
                 spec->multiout.share_spdif = 1;
-
-                if (spec->extra_dig_out_nid) {
-                        err = snd_hda_create_spdif_out_ctls(codec,
-                                                    spec->extra_dig_out_nid);
-                        if (err < 0)
-                                return err;
-                }
         }
         if (spec->dig_in_nid) {
@@ -1014 +980 @@
 }
 
-static hda_nid_t slave_dig_outs[] = {
-        0,
-};
-
 static int via_init(struct hda_codec *codec)
 {
@@ -1027 +989 @@
         /* Lydia Add for EAPD enable */
         if (!spec->dig_in_nid) { /* No Digital In connection */
-                if (IS_VT1708_VENDORID(codec->vendor_id)) {
-                        snd_hda_codec_write(codec, VT1708_DIGIN_PIN, 0,
+                if (spec->dig_in_pin) {
+                        snd_hda_codec_write(codec, spec->dig_in_pin, 0,
                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
                                             PIN_OUT);
-                        snd_hda_codec_write(codec, VT1708_DIGIN_PIN, 0,
-                                            AC_VERB_SET_EAPD_BTLENABLE, 0x02);
-                } else if (IS_VT1709_10CH_VENDORID(codec->vendor_id) ||
-                           IS_VT1709_6CH_VENDORID(codec->vendor_id)) {
-                        snd_hda_codec_write(codec, VT1709_DIGIN_PIN, 0,
-                                            AC_VERB_SET_PIN_WIDGET_CONTROL,
-                                            PIN_OUT);
-                        snd_hda_codec_write(codec, VT1709_DIGIN_PIN, 0,
-                                            AC_VERB_SET_EAPD_BTLENABLE, 0x02);
-                } else if (IS_VT1708B_8CH_VENDORID(codec->vendor_id) ||
-                           IS_VT1708B_4CH_VENDORID(codec->vendor_id)) {
-                        snd_hda_codec_write(codec, VT1708B_DIGIN_PIN, 0,
-                                            AC_VERB_SET_PIN_WIDGET_CONTROL,
-                                            PIN_OUT);
-                        snd_hda_codec_write(codec, VT1708B_DIGIN_PIN, 0,
+                        snd_hda_codec_write(codec, spec->dig_in_pin, 0,
                                             AC_VERB_SET_EAPD_BTLENABLE, 0x02);
                 }
@@ -1052 +1000 @@
                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN);
 
-        /* no slave outs */
-        codec->slave_dig_outs = slave_dig_outs;
+        /* assign slave outs */
+        if (spec->slave_dig_outs[0])
+                codec->slave_dig_outs = spec->slave_dig_outs;
 
         return 0;
@@ -1354 +1303 @@
         if (spec->autocfg.dig_outs)
                 spec->multiout.dig_out_nid = VT1708_DIGOUT_NID;
+        spec->dig_in_pin = VT1708_DIGIN_PIN;
         if (spec->autocfg.dig_in_pin)
                 spec->dig_in_nid = VT1708_DIGIN_NID;
@@ -1377 +1327 @@
         via_auto_init_hp_out(codec);
         via_auto_init_analog_input(codec);
+        return 0;
+}
+
+static int get_mux_nids(struct hda_codec *codec)
+{
+        struct via_spec *spec = codec->spec;
+        hda_nid_t nid, conn[8];
+        unsigned int type;
+        int i, n;
+
+        for (i = 0; i < spec->num_adc_nids; i++) {
+                nid = spec->adc_nids[i];
+                while (nid) {
+                        type = get_wcaps_type(get_wcaps(codec, nid));
+                        if (type == AC_WID_PIN)
+                                break;
+                        n = snd_hda_get_connections(codec, nid, conn,
+                                                    ARRAY_SIZE(conn));
+                        if (n <= 0)
+                                break;
+                        if (n > 1) {
+                                spec->mux_nids[i] = nid;
+                                break;
+                        }
+                        nid = conn[0];
+                }
+        }
         return 0;
 }
@@ -1827 +1804 @@
         if (spec->autocfg.dig_outs)
                 spec->multiout.dig_out_nid = VT1709_DIGOUT_NID;
+        spec->dig_in_pin = VT1709_DIGIN_PIN;
         if (spec->autocfg.dig_in_pin)
                 spec->dig_in_nid = VT1709_DIGIN_NID;
@@ -1887 +1865 @@
                 spec->adc_nids = vt1709_adc_nids;
                 spec->num_adc_nids = ARRAY_SIZE(vt1709_adc_nids);
+                get_mux_nids(codec);
                 spec->mixers[spec->num_mixers] = vt1709_capture_mixer;
                 spec->num_mixers++;
@@ -1980 +1959 @@
                 spec->adc_nids = vt1709_adc_nids;
                 spec->num_adc_nids = ARRAY_SIZE(vt1709_adc_nids);
+                get_mux_nids(codec);
                 spec->mixers[spec->num_mixers] = vt1709_capture_mixer;
                 spec->num_mixers++;
@@ -2139 +2119 @@
                 .open = via_dig_playback_pcm_open,
                 .close = via_dig_playback_pcm_close,
-                .prepare = via_dig_playback_pcm_prepare
+                .prepare = via_dig_playback_pcm_prepare,
+                .cleanup = via_dig_playback_pcm_cleanup
         },
 };
@@ -2375 +2356 @@
         if (spec->autocfg.dig_outs)
                 spec->multiout.dig_out_nid = VT1708B_DIGOUT_NID;
+        spec->dig_in_pin = VT1708B_DIGIN_PIN;
         if (spec->autocfg.dig_in_pin)
                 spec->dig_in_nid = VT1708B_DIGIN_NID;
@@ -2435 +2417 @@
                 spec->adc_nids = vt1708B_adc_nids;
                 spec->num_adc_nids = ARRAY_SIZE(vt1708B_adc_nids);
+                get_mux_nids(codec);
                 spec->mixers[spec->num_mixers] = vt1708B_capture_mixer;
                 spec->num_mixers++;
@@ -2486 +2469 @@
                 spec->adc_nids = vt1708B_adc_nids;
                 spec->num_adc_nids = ARRAY_SIZE(vt1708B_adc_nids);
+                get_mux_nids(codec);
                 spec->mixers[spec->num_mixers] = vt1708B_capture_mixer;
                 spec->num_mixers++;
@@ -2591 +2575 @@
 
 static struct hda_pcm_stream vt1708S_pcm_digital_playback = {
-        .substreams = 2,
+        .substreams = 1,
         .channels_min = 2,
         .channels_max = 2,
@@ -2598 +2582 @@
                 .open = via_dig_playback_pcm_open,
                 .close = via_dig_playback_pcm_close,
-                .prepare = via_dig_playback_pcm_prepare
+                .prepare = via_dig_playback_pcm_prepare,
+                .cleanup = via_dig_playback_pcm_cleanup
         },
 };
@@ -2807 +2792 @@
 }
 
+/* fill out digital output widgets; one for master and one for slave outputs */
+static void fill_dig_outs(struct hda_codec *codec)
+{
+        struct via_spec *spec = codec->spec;
+        int i;
+
+        for (i = 0; i < spec->autocfg.dig_outs; i++) {
+                hda_nid_t nid;
+                int conn;
+
+                nid = spec->autocfg.dig_out_pins[i];
+                if (!nid)
+                        continue;
+                conn = snd_hda_get_connections(codec, nid, &nid, 1);
+                if (conn < 1)
+                        continue;
+                if (!spec->multiout.dig_out_nid)
+                        spec->multiout.dig_out_nid = nid;
+                else {
+                        spec->slave_dig_outs[0] = nid;
+                        break; /* at most two dig outs */
+                }
+        }
+}
+
 static int vt1708S_parse_auto_config(struct hda_codec *codec)
 {
         struct via_spec *spec = codec->spec;
         int err;
-        static hda_nid_t vt1708s_ignore[] = {0x21, 0};
-
-        err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
-                                           vt1708s_ignore);
+
+        err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
         if (err < 0)
                 return err;
@@ -2835 +2843 @@
         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
 
-        if (spec->autocfg.dig_outs)
-                spec->multiout.dig_out_nid = VT1708S_DIGOUT_NID;
-
-        spec->extra_dig_out_nid = 0x15;
+        fill_dig_outs(codec);
 
         if (spec->kctls.list)
@@ -2857 +2862 @@
         { 0x16, HDA_INPUT, 3 },
         { 0x16, HDA_INPUT, 4 },
-        { } /* end */
+        {0} /* end */
 };
 #endif
@@ -2896 +2901 @@
                 spec->adc_nids = vt1708S_adc_nids;
                 spec->num_adc_nids = ARRAY_SIZE(vt1708S_adc_nids);
+                get_mux_nids(codec);
                 spec->mixers[spec->num_mixers] = vt1708S_capture_mixer;
                 spec->num_mixers++;
@@ -3002 +3008 @@
                 .open = via_dig_playback_pcm_open,
                 .close = via_dig_playback_pcm_close,
-                .prepare = via_dig_playback_pcm_prepare
+                .prepare = via_dig_playback_pcm_prepare,
+                .cleanup = via_dig_playback_pcm_cleanup
         },
 };
@@ -3130 +3137 @@
         struct via_spec *spec = codec->spec;
         int err;
-        static hda_nid_t vt1702_ignore[] = {0x1C, 0};
-
-        err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
-                                           vt1702_ignore);
+
+        err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
         if (err < 0)
                 return err;
@@ -3154 +3159 @@
         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
 
-        if (spec->autocfg.dig_outs)
-                spec->multiout.dig_out_nid = VT1702_DIGOUT_NID;
-
-        spec->extra_dig_out_nid = 0x1B;
+        fill_dig_outs(codec);
 
         if (spec->kctls.list)
@@ -3217 +3219 @@
                 spec->adc_nids = vt1702_adc_nids;
                 spec->num_adc_nids = ARRAY_SIZE(vt1702_adc_nids);
+                get_mux_nids(codec);
                 spec->mixers[spec->num_mixers] = vt1702_capture_mixer;
                 spec->num_mixers++;

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

@@ -357 +357 @@
         unsigned int pos_shift;
         unsigned int last_pos;
-        unsigned long last_pos_jiffies;
-        unsigned int jiffy_to_bytes;
         int frags;
         int lvi;
@@ -424 +422 @@
 
 static struct pci_device_id snd_intel8x0_ids[] = {
-        { 0x8086, 0x2415, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_INTEL }, /* 82801AA */
-        { 0x8086, 0x2425, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_INTEL }, /* 82901AB */
-        { 0x8086, 0x2445, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_INTEL }, /* 82801BA */
-        { 0x8086, 0x2485, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_INTEL }, /* ICH3 */
-        { 0x8086, 0x24c5, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_INTEL_ICH4 }, /* ICH4 */
-        { 0x8086, 0x24d5, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_INTEL_ICH4 }, /* ICH5 */
-        { 0x8086, 0x25a6, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_INTEL_ICH4 }, /* ESB */
-        { 0x8086, 0x266e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_INTEL_ICH4 }, /* ICH6 */
-        { 0x8086, 0x27de, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_INTEL_ICH4 }, /* ICH7 */
-        { 0x8086, 0x2698, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_INTEL_ICH4 }, /* ESB2 */
-        { 0x8086, 0x7195, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_INTEL }, /* 440MX */
-        { 0x1039, 0x7012, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_SIS },   /* SI7012 */
-        { 0x10de, 0x01b1, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_NFORCE },        /* NFORCE */
-        { 0x10de, 0x003a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_NFORCE },        /* MCP04 */
-        { 0x10de, 0x006a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_NFORCE },        /* NFORCE2 */
-        { 0x10de, 0x0059, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_NFORCE },        /* CK804 */
-        { 0x10de, 0x008a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_NFORCE },        /* CK8 */
-        { 0x10de, 0x00da, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_NFORCE },        /* NFORCE3 */
-        { 0x10de, 0x00ea, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_NFORCE },        /* CK8S */
-        { 0x10de, 0x026b, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_NFORCE },        /* MCP51 */
-        { 0x1022, 0x746d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_INTEL }, /* AMD8111 */
-        { 0x1022, 0x7445, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_INTEL }, /* AMD768 */
-        { 0x10b9, 0x5455, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_ALI },   /* Ali5455 */
+        { PCI_VDEVICE(INTEL, 0x2415), DEVICE_INTEL },   /* 82801AA */
+        { PCI_VDEVICE(INTEL, 0x2425), DEVICE_INTEL },   /* 82901AB */
+        { PCI_VDEVICE(INTEL, 0x2445), DEVICE_INTEL },   /* 82801BA */
+        { PCI_VDEVICE(INTEL, 0x2485), DEVICE_INTEL },   /* ICH3 */
+        { PCI_VDEVICE(INTEL, 0x24c5), DEVICE_INTEL_ICH4 }, /* ICH4 */
+        { PCI_VDEVICE(INTEL, 0x24d5), DEVICE_INTEL_ICH4 }, /* ICH5 */
+        { PCI_VDEVICE(INTEL, 0x25a6), DEVICE_INTEL_ICH4 }, /* ESB */
+        { PCI_VDEVICE(INTEL, 0x266e), DEVICE_INTEL_ICH4 }, /* ICH6 */
+        { PCI_VDEVICE(INTEL, 0x27de), DEVICE_INTEL_ICH4 }, /* ICH7 */
+        { PCI_VDEVICE(INTEL, 0x2698), DEVICE_INTEL_ICH4 }, /* ESB2 */
+        { PCI_VDEVICE(INTEL, 0x7195), DEVICE_INTEL },   /* 440MX */
+        { PCI_VDEVICE(SI, 0x7012), DEVICE_SIS },        /* SI7012 */
+        { PCI_VDEVICE(NVIDIA, 0x01b1), DEVICE_NFORCE }, /* NFORCE */
+        { PCI_VDEVICE(NVIDIA, 0x003a), DEVICE_NFORCE }, /* MCP04 */
+        { PCI_VDEVICE(NVIDIA, 0x006a), DEVICE_NFORCE }, /* NFORCE2 */
+        { PCI_VDEVICE(NVIDIA, 0x0059), DEVICE_NFORCE }, /* CK804 */
+        { PCI_VDEVICE(NVIDIA, 0x008a), DEVICE_NFORCE }, /* CK8 */
+        { PCI_VDEVICE(NVIDIA, 0x00da), DEVICE_NFORCE }, /* NFORCE3 */
+        { PCI_VDEVICE(NVIDIA, 0x00ea), DEVICE_NFORCE }, /* CK8S */
+        { PCI_VDEVICE(NVIDIA, 0x026b), DEVICE_NFORCE }, /* MCP51 */
+        { PCI_VDEVICE(AMD, 0x746d), DEVICE_INTEL },     /* AMD8111 */
+        { PCI_VDEVICE(AMD, 0x7445), DEVICE_INTEL },     /* AMD768 */
+        { PCI_VDEVICE(AL, 0x5455), DEVICE_ALI },   /* Ali5455 */
         { 0, }
 };
@@ -845 +843 @@
                 val = ICH_IOCE | ICH_STARTBM;
                 ichdev->last_pos = ichdev->position;
-                ichdev->last_pos_jiffies = jiffies;
                 break;
         case SNDRV_PCM_TRIGGER_SUSPEND:
@@ -1049 +1046 @@
         }
         snd_intel8x0_setup_periods(chip, ichdev);
-        ichdev->jiffy_to_bytes = (runtime->rate * 4 * ichdev->pos_shift) / HZ;
         return 0;
 }
@@ -1074 +1070 @@
                         break;
         } while (timeout--);
+        ptr = ichdev->last_pos;
         if (ptr1 != 0) {
                 ptr1 <<= ichdev->pos_shift;
                 ptr = ichdev->fragsize1 - ptr1;
                 ptr += position;
-                ichdev->last_pos = ptr;
-                ichdev->last_pos_jiffies = jiffies;
-        } else {
-                ptr1 = jiffies - ichdev->last_pos_jiffies;
-                if (ptr1)
-                        ptr1 -= 1;
-                ptr = ichdev->last_pos + ptr1 * ichdev->jiffy_to_bytes;
-                ptr %= ichdev->size;
-        }
+                if (ptr < ichdev->last_pos) {
+                        unsigned int pos_base, last_base;
+                        pos_base = position / ichdev->fragsize1;
+                        last_base = ichdev->last_pos / ichdev->fragsize1;
+                        /* another sanity check; ptr1 can go back to full
+                         * before the base position is updated
+                         */
+                        if (pos_base == last_base)
+                                ptr = ichdev->last_pos;
+                }
+        }
+        ichdev->last_pos = ptr;
         spin_unlock(&chip->reg_lock);
         if (ptr >= ichdev->size)

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

@@ -1239 +1239 @@
         .info =              (SNDRV_PCM_INFO_MMAP |
                               SNDRV_PCM_INFO_MMAP_VALID |
-                              SNDRV_PCM_INFO_INTERLEAVED),
+                              SNDRV_PCM_INFO_INTERLEAVED |
+                              SNDRV_PCM_INFO_BATCH),
         .formats =            SNDRV_PCM_FMTBIT_S16_LE,
         .rates =              (SNDRV_PCM_RATE_44100 |
@@ -1259 +1260 @@
         .info =              (SNDRV_PCM_INFO_MMAP |
                               SNDRV_PCM_INFO_MMAP_VALID |
-                              SNDRV_PCM_INFO_INTERLEAVED),
+                              SNDRV_PCM_INFO_INTERLEAVED |
+                              SNDRV_PCM_INFO_BATCH),
         .formats =            SNDRV_PCM_FMTBIT_S16_LE,
         .rates =              (SNDRV_PCM_RATE_44100 |

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

@@ -264 +264 @@
  */
 static struct pci_device_id snd_nm256_ids[] = {
-        {PCI_VENDOR_ID_NEOMAGIC, PCI_DEVICE_ID_NEOMAGIC_NM256AV_AUDIO, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
-        {PCI_VENDOR_ID_NEOMAGIC, PCI_DEVICE_ID_NEOMAGIC_NM256ZX_AUDIO, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
-        {PCI_VENDOR_ID_NEOMAGIC, PCI_DEVICE_ID_NEOMAGIC_NM256XL_PLUS_AUDIO, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
+        {PCI_VDEVICE(NEOMAGIC, PCI_DEVICE_ID_NEOMAGIC_NM256AV_AUDIO), 0},
+        {PCI_VDEVICE(NEOMAGIC, PCI_DEVICE_ID_NEOMAGIC_NM256ZX_AUDIO), 0},
+        {PCI_VDEVICE(NEOMAGIC, PCI_DEVICE_ID_NEOMAGIC_NM256XL_PLUS_AUDIO), 0},
         {0,},
 };

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

@@ -233 +233 @@
 
 static struct pci_device_id snd_rme96_ids[] = {
-        { PCI_VENDOR_ID_XILINX, PCI_DEVICE_ID_RME_DIGI96,
-          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },
-        { PCI_VENDOR_ID_XILINX, PCI_DEVICE_ID_RME_DIGI96_8,
-          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },
-        { PCI_VENDOR_ID_XILINX, PCI_DEVICE_ID_RME_DIGI96_8_PRO,
-          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },
-        { PCI_VENDOR_ID_XILINX, PCI_DEVICE_ID_RME_DIGI96_8_PAD_OR_PST,
-          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, 
+        { PCI_VDEVICE(XILINX, PCI_DEVICE_ID_RME_DIGI96), 0, },
+        { PCI_VDEVICE(XILINX, PCI_DEVICE_ID_RME_DIGI96_8), 0, },
+        { PCI_VDEVICE(XILINX, PCI_DEVICE_ID_RME_DIGI96_8_PRO), 0, },
+        { PCI_VDEVICE(XILINX, PCI_DEVICE_ID_RME_DIGI96_8_PAD_OR_PST), 0, },
         { 0, }
 };

GPL/trunk/alsa-kernel/pci/rme9652/hdsp.c

@@ -29 +29 @@
 #include <linux/firmware.h>
 #include <linux/moduleparam.h>
+#include <linux/math64.h>
 
 #include <sound/core.h>
@@ -403 +404 @@
 #define HDSP_DMA_AREA_KILOBYTES (HDSP_DMA_AREA_BYTES/1024)
 
-/* use hotplug firmeare loader? */
+/* use hotplug firmware loader? */
 #if defined(CONFIG_FW_LOADER) || defined(CONFIG_FW_LOADER_MODULE)
-#if !defined(HDSP_USE_HWDEP_LOADER) && !defined(CONFIG_SND_HDSP)
+#if !defined(HDSP_USE_HWDEP_LOADER)
 #define HDSP_FW_LOADER
 #endif
@@ -1048 +1049 @@
 {
         u64 n;
-        u32 r;
 
         if (rate >= 112000)
@@ -1056 +1056 @@
 
         n = DDS_NUMERATOR;
-        div64_32(&n, rate, &r);
+        n = div_u64(n, rate);
         /* n should be less than 2^32 for being written to FREQ register */
         snd_BUG_ON(n >> 32);
@@ -3098 +3098 @@
 {
         u64 n;
-        u32 r;
         unsigned int dds_value = hdsp->dds_value;
         int system_sample_rate = hdsp->system_sample_rate;
@@ -3110 +3109 @@
          * rate = n / dds_value
          */
-        div64_32(&n, dds_value, &r);
+        n = div_u64(n, dds_value);
         if (system_sample_rate >= 112000)
                 n *= 4;
@@ -3296 +3295 @@
         int x;
 
-        if (hdsp_check_for_iobox (hdsp)) {
-                snd_iprintf(buffer, "No I/O box connected.\nPlease connect one and upload firmware.\n");
+        status = hdsp_read(hdsp, HDSP_statusRegister);
+        status2 = hdsp_read(hdsp, HDSP_status2Register);
+
+        snd_iprintf(buffer, "%s (Card #%d)\n", hdsp->card_name,
+                    hdsp->card->number + 1);
+        snd_iprintf(buffer, "Buffers: capture %p playback %p\n",
+                    hdsp->capture_buffer, hdsp->playback_buffer);
+        snd_iprintf(buffer, "IRQ: %d Registers bus: 0x%lx VM: 0x%lx\n",
+                    hdsp->irq, hdsp->port, (unsigned long)hdsp->iobase);
+        snd_iprintf(buffer, "Control register: 0x%x\n", hdsp->control_register);
+        snd_iprintf(buffer, "Control2 register: 0x%x\n",
+                    hdsp->control2_register);
+        snd_iprintf(buffer, "Status register: 0x%x\n", status);
+        snd_iprintf(buffer, "Status2 register: 0x%x\n", status2);
+
+        if (hdsp_check_for_iobox(hdsp)) {
+                snd_iprintf(buffer, "No I/O box connected.\n"
+                            "Please connect one and upload firmware.\n");
                 return;
-        }
+        }
 
         if (hdsp_check_for_firmware(hdsp, 0)) {
                 if (hdsp->state & HDSP_FirmwareCached) {
                         if (snd_hdsp_load_firmware_from_cache(hdsp) != 0) {
-                                snd_iprintf(buffer, "Firmware loading from cache failed, please upload manually.\n");
+                                snd_iprintf(buffer, "Firmware loading from "
+                                            "cache failed, "
+                                            "please upload manually.\n");
                                 return;
                         }
@@ -3321 +3338 @@
         }
 
-        status = hdsp_read(hdsp, HDSP_statusRegister);
-        status2 = hdsp_read(hdsp, HDSP_status2Register);
-
-        snd_iprintf(buffer, "%s (Card #%d)\n", hdsp->card_name, hdsp->card->number + 1);
-        snd_iprintf(buffer, "Buffers: capture %p playback %p\n",
-                    hdsp->capture_buffer, hdsp->playback_buffer);
-        snd_iprintf(buffer, "IRQ: %d Registers bus: 0x%lx VM: 0x%lx\n",
-                    hdsp->irq, hdsp->port, (unsigned long)hdsp->iobase);
-        snd_iprintf(buffer, "Control register: 0x%x\n", hdsp->control_register);
-        snd_iprintf(buffer, "Control2 register: 0x%x\n", hdsp->control2_register);
-        snd_iprintf(buffer, "Status register: 0x%x\n", status);
-        snd_iprintf(buffer, "Status2 register: 0x%x\n", status2);
         snd_iprintf(buffer, "FIFO status: %d\n", hdsp_read(hdsp, HDSP_fifoStatus) & 0xff);
         snd_iprintf(buffer, "MIDI1 Output status: 0x%x\n", hdsp_read(hdsp, HDSP_midiStatusOut0));
@@ -3352 +3357 @@
 
         snd_iprintf(buffer, "\n");
-
 
         switch (hdsp_clock_source(hdsp)) {

GPL/trunk/alsa-kernel/pci/rme9652/hdspm.c

@@ -30 +30 @@
 #include <linux/slab.h>
 #include <linux/pci.h>
+#include <linux/math64.h>
 #include <asm/io.h>
 
@@ -832 +833 @@
 {
         u64 n;
-        u32 r;
         
         if (rate >= 112000)
@@ -845 +845 @@
         /* n = 104857600000000ULL; */ /*  =  2^20 * 10^8 */
         n = 110100480000000ULL;    /* Value checked for AES32 and MADI */
-        div64_32(&n, rate, &r);
+        n = div_u64(n, rate);
         /* n should be less than 2^32 for being written to FREQ register */
         snd_BUG_ON(n >> 32);

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

@@ -244 +244 @@
 
 static struct pci_device_id snd_sonic_ids[] = {
-        { 0x5333, 0xca00, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },
+        { PCI_VDEVICE(S3, 0xca00), 0, },
         { 0, }
 };

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

@@ -86 +86 @@
 static char *ac97_quirk;
 static int dxs_support;
+static int nodelay;
 
 module_param(index, int, 0444);
@@ -103 +104 @@
 module_param(dxs_support, int, 0444);
 MODULE_PARM_DESC(dxs_support, "Support for DXS channels (0 = auto, 1 = enable, 2 = disable, 3 = 48k only, 4 = no VRA, 5 = enable any sample rate)");
+module_param(nodelay, int, 0444);
+MODULE_PARM_DESC(nodelay, "Disable 500ms init delay");
 
 /* just for backward compatibility */
@@ -400 +403 @@
 static struct pci_device_id snd_via82xx_ids[] = {
         /* 0x1106, 0x3058 */
-        { PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C686_5, PCI_ANY_ID, PCI_ANY_ID, 0, 0, TYPE_CARD_VIA686, },     /* 686A */
+        { PCI_VDEVICE(VIA, PCI_DEVICE_ID_VIA_82C686_5), TYPE_CARD_VIA686, },    /* 686A */
         /* 0x1106, 0x3059 */
-        { PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8233_5, PCI_ANY_ID, PCI_ANY_ID, 0, 0, TYPE_CARD_VIA8233, },      /* VT8233 */
+        { PCI_VDEVICE(VIA, PCI_DEVICE_ID_VIA_8233_5), TYPE_CARD_VIA8233, },     /* VT8233 */
         { 0, }
 };
@@ -550 +553 @@
         err = snd_via82xx_codec_ready(chip, ac97->num);
         /* here we need to wait fairly for long time.. */
-        msleep(500);
+        if (!nodelay)
+                msleep(500);
 }
 

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

@@ -68 +68 @@
 
 static struct pci_device_id snd_ymfpci_ids[] = {
-        { 0x1073, 0x0004, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },   /* YMF724 */
-        { 0x1073, 0x000d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },   /* YMF724F */
-        { 0x1073, 0x000a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },   /* YMF740 */
-        { 0x1073, 0x000c, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },   /* YMF740C */
-        { 0x1073, 0x0010, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },   /* YMF744 */
-        { 0x1073, 0x0012, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },   /* YMF754 */
+        { PCI_VDEVICE(YAMAHA, 0x0004), 0, },   /* YMF724 */
+        { PCI_VDEVICE(YAMAHA, 0x000d), 0, },   /* YMF724F */
+        { PCI_VDEVICE(YAMAHA, 0x000a), 0, },   /* YMF740 */
+        { PCI_VDEVICE(YAMAHA, 0x000c), 0, },   /* YMF740C */
+        { PCI_VDEVICE(YAMAHA, 0x0010), 0, },   /* YMF744 */
+        { PCI_VDEVICE(YAMAHA, 0x0012), 0, },   /* YMF754 */
         { 0, }
 };

GPL/trunk/alsa-kernel/pci/ymfpci/ymfpci_main.c

@@ -835 +835 @@
         if (status & 1) {
                 if (chip->timer)
-                        snd_timer_interrupt(chip->timer, chip->timer->sticks);
+                        snd_timer_interrupt(chip->timer, chip->timer_ticks);
         }
         snd_ymfpci_writew(chip, YDSXGR_INTFLAG, status);
@@ -1886 +1886 @@
 
         chip = snd_timer_chip(timer);
-        count = (timer->sticks << 1) - 1;
         spin_lock_irqsave(&chip->reg_lock, flags);
+        if (timer->sticks > 1) {
+                chip->timer_ticks = timer->sticks;
+                count = timer->sticks - 1;
+        } else {
+                /*
+                 * Divisor 1 is not allowed; fake it by using divisor 2 and
+                 * counting two ticks for each interrupt.
+                 */
+                chip->timer_ticks = 2;
+                count = 2 - 1;
+        }
         snd_ymfpci_writew(chip, YDSXGR_TIMERCOUNT, count);
         snd_ymfpci_writeb(chip, YDSXGR_TIMERCTRL, 0x03);
@@ -1910 +1920 @@
 {
         *num = 1;
-        *den = 48000;
+        *den = 96000;
         return 0;
 }
@@ -1916 +1926 @@
 static struct snd_timer_hardware snd_ymfpci_timer_hw = {
         .flags = SNDRV_TIMER_HW_AUTO,
-        .resolution = 20833, /* 1/fs = 20.8333...us */
-        .ticks = 0x8000,
+        .resolution = 10417, /* 1 / 96 kHz = 10.41666...us */
+        .ticks = 0x10000,
         .start = snd_ymfpci_timer_start,
         .stop = snd_ymfpci_timer_stop,