126 files changed, 7799 insertions, 4712 deletions

diff --git a/sound/Kconfig b/sound/Kconfig
index 1eceb85287c5..439e15c8faa3 100644
--- a/sound/Kconfig
+++ b/sound/Kconfig
@@ -32,6 +32,34 @@ config SOUND_OSS_CORE
         bool
         default n
 
+config SOUND_OSS_CORE_PRECLAIM
+        bool "Preclaim OSS device numbers"
+        depends on SOUND_OSS_CORE
+        default y
+        help
+          With this option enabled, the kernel will claim all OSS device
+          numbers if any OSS support (native or emulation) is enabled
+          whether the respective module is loaded or not and try to load the
+          appropriate module using sound-slot/service-* and char-major-*
+          module aliases when one of the device numbers is opened.  With
+          this option disabled, kernel will only claim actually in-use
+          device numbers and opening a missing device will generate only the
+          standard char-major-* aliases.
+
+          The only visible difference is use of additional module aliases
+          and whether OSS sound devices appear multiple times in
+          /proc/devices.  sound-slot/service-* module aliases are scheduled
+          to be removed (ie. PRECLAIM won't be available) and this option is
+          to make the transition easier.  This option can be overridden
+          during boot using the kernel parameter soundcore.preclaim_oss.
+
+          Disabling this allows alternative OSS implementations.
+
+          Please read Documentation/feature-removal-schedule.txt for
+          details.
+
+          If unusre, say Y.
+
 source "sound/oss/dmasound/Kconfig"
 
 if !M68K
diff --git a/sound/aoa/codecs/tas.c b/sound/aoa/codecs/tas.c
index f0ebc971c686..1dd66ddffcaf 100644
--- a/sound/aoa/codecs/tas.c
+++ b/sound/aoa/codecs/tas.c
@@ -897,6 +897,15 @@ static int tas_create(struct i2c_adapter *adapter,
         client = i2c_new_device(adapter, &info);
         if (!client)
                 return -ENODEV;
+        /*
+         * We know the driver is already loaded, so the device should be
+         * already bound. If not it means binding failed, and then there
+         * is no point in keeping the device instantiated.
+         */
+        if (!client->driver) {
+                i2c_unregister_device(client);
+                return -ENODEV;
+        }
 
         /*
          * Let i2c-core delete that device on driver removal.
diff --git a/sound/aoa/core/gpio-pmf.c b/sound/aoa/core/gpio-pmf.c
index 5ca2220eac7d..1dd0c28d1fb7 100644
--- a/sound/aoa/core/gpio-pmf.c
+++ b/sound/aoa/core/gpio-pmf.c
@@ -182,6 +182,10 @@ static int pmf_set_notify(struct gpio_runtime *rt,
         if (!old && notify) {
                 irq_client = kzalloc(sizeof(struct pmf_irq_client),
                                      GFP_KERNEL);
+                if (!irq_client) {
+                        err = -ENOMEM;
+                        goto out_unlock;
+                }
                 irq_client->data = notif;
                 irq_client->handler = pmf_handle_notify_irq;
                 irq_client->owner = THIS_MODULE;
diff --git a/sound/core/Kconfig b/sound/core/Kconfig
index 6061fb5f4e1c..c15682a2f9db 100644
--- a/sound/core/Kconfig
+++ b/sound/core/Kconfig
@@ -206,4 +206,8 @@ config SND_PCM_XRUN_DEBUG
 config SND_VMASTER
         bool
 
+config SND_DMA_SGBUF
+        def_bool y
+        depends on X86
+
 source "sound/core/seq/Kconfig"
diff --git a/sound/core/Makefile b/sound/core/Makefile
index 4229052e7b91..350a08d277f4 100644
--- a/sound/core/Makefile
+++ b/sound/core/Makefile
@@ -13,7 +13,7 @@ snd-pcm-objs := pcm.o pcm_native.o pcm_lib.o pcm_timer.o pcm_misc.o \
                 pcm_memory.o
 
 snd-page-alloc-y := memalloc.o
-snd-page-alloc-$(CONFIG_HAS_DMA) += sgbuf.o
+snd-page-alloc-$(CONFIG_SND_DMA_SGBUF) += sgbuf.o
 
 snd-rawmidi-objs  := rawmidi.o
 snd-timer-objs    := timer.o
diff --git a/sound/core/control.c b/sound/core/control.c
index 17b8d47a5cd0..a8b7fabe645e 100644
--- a/sound/core/control.c
+++ b/sound/core/control.c
@@ -414,7 +414,7 @@ int snd_ctl_remove_id(struct snd_card *card, struct snd_ctl_elem_id *id)
 EXPORT_SYMBOL(snd_ctl_remove_id);
 
 /**
- * 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
  *
@@ -423,8 +423,8 @@ EXPORT_SYMBOL(snd_ctl_remove_id);
  * 
  * 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;
         struct snd_kcontrol *kctl;
@@ -433,15 +433,23 @@ static int snd_ctl_remove_unlocked_id(struct snd_ctl_file * file,
         down_write(&card->controls_rwsem);
         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;
 }
@@ -951,7 +959,7 @@ static int snd_ctl_elem_add(struct snd_ctl_file *file,
         
         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 :
                 (info->access & (SNDRV_CTL_ELEM_ACCESS_READWRITE|
@@ -1052,18 +1060,10 @@ static int snd_ctl_elem_remove(struct snd_ctl_file *file,
                                struct snd_ctl_elem_id __user *_id)
 {
         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);
 }
 
 static int snd_ctl_subscribe_events(struct snd_ctl_file *file, int __user *ptr)
diff --git a/sound/core/info.c b/sound/core/info.c
index 35df614f6c55..d749a0d394a7 100644
--- a/sound/core/info.c
+++ b/sound/core/info.c
@@ -88,12 +88,10 @@ static int resize_info_buffer(struct snd_info_buffer *buffer,
         char *nbuf;
 
         nsize = PAGE_ALIGN(nsize);
-        nbuf = kmalloc(nsize, GFP_KERNEL);
+        nbuf = krealloc(buffer->buffer, nsize, GFP_KERNEL);
         if (! nbuf)
                 return -ENOMEM;
 
-        memcpy(nbuf, buffer->buffer, buffer->len);
-        kfree(buffer->buffer);
         buffer->buffer = nbuf;
         buffer->len = nsize;
         return 0;
@@ -108,7 +106,7 @@ static int resize_info_buffer(struct snd_info_buffer *buffer,
  *
  * Returns the size of output string.
  */
-int snd_iprintf(struct snd_info_buffer *buffer, char *fmt,...)
+int snd_iprintf(struct snd_info_buffer *buffer, const char *fmt, ...)
 {
         va_list args;
         int len, res;
@@ -727,7 +725,7 @@ EXPORT_SYMBOL(snd_info_get_line);
  * Returns the updated pointer of the original string so that
  * it can be used for the next call.
  */
-char *snd_info_get_str(char *dest, char *src, int len)
+const char *snd_info_get_str(char *dest, const char *src, int len)
 {
         int c;
 
diff --git a/sound/core/init.c b/sound/core/init.c
index d5d40d78c409..ec4a50ce5656 100644
--- a/sound/core/init.c
+++ b/sound/core/init.c
@@ -31,6 +31,14 @@
 #include <sound/control.h>
 #include <sound/info.h>
 
+/* monitor files for graceful shutdown (hotplug) */
+struct snd_monitor_file {
+        struct file *file;
+        const struct file_operations *disconnected_f_op;
+        struct list_head shutdown_list; /* still need to shutdown */
+        struct list_head list;  /* link of monitor files */
+};
+
 static DEFINE_SPINLOCK(shutdown_lock);
 static LIST_HEAD(shutdown_files);
 
diff --git a/sound/core/memalloc.c b/sound/core/memalloc.c
index 1b3534d67686..9e92441f9b78 100644
--- a/sound/core/memalloc.c
+++ b/sound/core/memalloc.c
@@ -199,6 +199,8 @@ int snd_dma_alloc_pages(int type, struct device *device, size_t size,
         case SNDRV_DMA_TYPE_DEV:
                 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);
                 break;
@@ -269,6 +271,8 @@ void snd_dma_free_pages(struct snd_dma_buffer *dmab)
         case SNDRV_DMA_TYPE_DEV:
                 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);
                 break;
diff --git a/sound/core/misc.c b/sound/core/misc.c
index a9710e0c97af..23a032c6d487 100644
--- a/sound/core/misc.c
+++ b/sound/core/misc.c
@@ -24,6 +24,20 @@
 #include <linux/ioport.h>
 #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)
 {
         if (res) {
@@ -35,46 +49,53 @@ void release_and_free_resource(struct resource *res)
 EXPORT_SYMBOL(release_and_free_resource);
 
 #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)
 {
-        va_list args;
-        
-        if (format[0] == '<' && format[1] >= '0' && format[1] <= '7' && format[2] == '>') {
-                char tmp[] = "<0>";
+        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];
-                printk("%sALSA %s:%d: ", tmp, file, line);
-                format += 3;
-        } else {
-                printk("ALSA %s:%d: ", file, line);
+                pfx = tmp;
+                ret = 1;
         }
-        va_start(args, format);
-        vprintk(format, args);
-        va_end(args);
+        printk("%sALSA %s:%d: ", pfx, file, line);
+        return ret;
 }
-
-EXPORT_SYMBOL(snd_verbose_printk);
+#else
+#define print_snd_pfx(level, path, line, format)        0
 #endif
 
-#if defined(CONFIG_SND_DEBUG) && defined(CONFIG_SND_VERBOSE_PRINTK)
-void snd_verbose_printd(const char *file, int line, const char *format, ...)
+#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(KERN_DEBUG "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_printd);
+EXPORT_SYMBOL_GPL(__snd_printk);
 #endif
 
 #ifdef CONFIG_PCI
diff --git a/sound/core/oss/mixer_oss.c b/sound/core/oss/mixer_oss.c
index 5dcd8a526970..772423889eb3 100644
--- a/sound/core/oss/mixer_oss.c
+++ b/sound/core/oss/mixer_oss.c
@@ -1154,7 +1154,8 @@ static void snd_mixer_oss_proc_write(struct snd_info_entry *entry,
                                      struct snd_info_buffer *buffer)
 {
         struct snd_mixer_oss *mixer = entry->private_data;
-        char line[128], str[32], idxstr[16], *cptr;
+        char line[128], str[32], idxstr[16];
+        const char *cptr;
         int ch, idx;
         struct snd_mixer_oss_assign_table *tbl;
         struct slot *slot;
diff --git a/sound/core/oss/pcm_oss.c b/sound/core/oss/pcm_oss.c
index dbe406b82591..d9c96353121a 100644
--- a/sound/core/oss/pcm_oss.c
+++ b/sound/core/oss/pcm_oss.c
@@ -1043,10 +1043,15 @@ static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream)
         runtime->oss.channels = params_channels(params);
         runtime->oss.rate = params_rate(params);
 
-        runtime->oss.params = 0;
-        runtime->oss.prepare = 1;
         vfree(runtime->oss.buffer);
         runtime->oss.buffer = vmalloc(runtime->oss.period_bytes);
+        if (!runtime->oss.buffer) {
+                err = -ENOMEM;
+                goto failure;
+        }
+
+        runtime->oss.params = 0;
+        runtime->oss.prepare = 1;
         runtime->oss.buffer_used = 0;
         if (runtime->dma_area)
                 snd_pcm_format_set_silence(runtime->format, runtime->dma_area, bytes_to_samples(runtime, runtime->dma_bytes));
@@ -2836,7 +2841,8 @@ static void snd_pcm_oss_proc_write(struct snd_info_entry *entry,
                                    struct snd_info_buffer *buffer)
 {
         struct snd_pcm_str *pstr = entry->private_data;
-        char line[128], str[32], task_name[32], *ptr;
+        char line[128], str[32], task_name[32];
+        const char *ptr;
         int idx1;
         struct snd_pcm_oss_setup *setup, *setup1, template;
 
diff --git a/sound/core/pcm.c b/sound/core/pcm.c
index 145931a9ff30..0c1440121c22 100644
--- a/sound/core/pcm.c
+++ b/sound/core/pcm.c
@@ -162,18 +162,7 @@ static int snd_pcm_control_ioctl(struct snd_card *card,
         return -ENOIOCTLCMD;
 }
 
-#ifdef CONFIG_SND_VERBOSE_PROCFS
-
-#define STATE(v) [SNDRV_PCM_STATE_##v] = #v
-#define STREAM(v) [SNDRV_PCM_STREAM_##v] = #v
-#define READY(v) [SNDRV_PCM_READY_##v] = #v
-#define XRUN(v) [SNDRV_PCM_XRUN_##v] = #v
-#define SILENCE(v) [SNDRV_PCM_SILENCE_##v] = #v
-#define TSTAMP(v) [SNDRV_PCM_TSTAMP_##v] = #v
-#define ACCESS(v) [SNDRV_PCM_ACCESS_##v] = #v
-#define START(v) [SNDRV_PCM_START_##v] = #v
 #define FORMAT(v) [SNDRV_PCM_FORMAT_##v] = #v
-#define SUBFORMAT(v) [SNDRV_PCM_SUBFORMAT_##v] = #v 
 
 static char *snd_pcm_format_names[] = {
         FORMAT(S8),
@@ -216,10 +205,23 @@ static char *snd_pcm_format_names[] = {
         FORMAT(U18_3BE),
 };
 
-static const char *snd_pcm_format_name(snd_pcm_format_t format)
+const char *snd_pcm_format_name(snd_pcm_format_t format)
 {
         return snd_pcm_format_names[format];
 }
+EXPORT_SYMBOL_GPL(snd_pcm_format_name);
+
+#ifdef CONFIG_SND_VERBOSE_PROCFS
+
+#define STATE(v) [SNDRV_PCM_STATE_##v] = #v
+#define STREAM(v) [SNDRV_PCM_STREAM_##v] = #v
+#define READY(v) [SNDRV_PCM_READY_##v] = #v
+#define XRUN(v) [SNDRV_PCM_XRUN_##v] = #v
+#define SILENCE(v) [SNDRV_PCM_SILENCE_##v] = #v
+#define TSTAMP(v) [SNDRV_PCM_TSTAMP_##v] = #v
+#define ACCESS(v) [SNDRV_PCM_ACCESS_##v] = #v
+#define START(v) [SNDRV_PCM_START_##v] = #v
+#define SUBFORMAT(v) [SNDRV_PCM_SUBFORMAT_##v] = #v 
 
 static char *snd_pcm_stream_names[] = {
         STREAM(PLAYBACK),
diff --git a/sound/core/pcm_lib.c b/sound/core/pcm_lib.c
index 333e4dd29450..30f410832a25 100644
--- a/sound/core/pcm_lib.c
+++ b/sound/core/pcm_lib.c
@@ -197,12 +197,16 @@ static int snd_pcm_update_hw_ptr_post(struct snd_pcm_substream *substream,
                 avail = snd_pcm_capture_avail(runtime);
         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)
                 wake_up(&runtime->sleep);
@@ -233,6 +237,18 @@ static int snd_pcm_update_hw_ptr_interrupt(struct snd_pcm_substream *substream)
                 xrun(substream);
                 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;
         hw_ptr_interrupt = runtime->hw_ptr_interrupt + runtime->period_size;
@@ -244,18 +260,27 @@ static int snd_pcm_update_hw_ptr_interrupt(struct snd_pcm_substream *substream)
                         delta = new_hw_ptr - hw_ptr_interrupt;
         }
         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, 
                                      "Unexpected hw_pointer value "
                                      "(stream=%i, pos=%ld, intr_ptr=%ld)\n",
                                      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;
                         /* align hw_base to buffer_size */
                         hw_base -= hw_base % runtime->buffer_size;
                         delta = 0;
+#endif
                 } else {
                         hw_base += runtime->buffer_size;
                         if (hw_base >= runtime->boundary)
@@ -344,6 +369,19 @@ int snd_pcm_update_hw_ptr(struct snd_pcm_substream *substream)
                 xrun(substream);
                 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;
 
@@ -909,47 +947,24 @@ static int snd_interval_ratden(struct snd_interval *i,
 int snd_interval_list(struct snd_interval *i, unsigned int count, unsigned int *list, unsigned int mask)
 {
         unsigned int k;
-        int changed = 0;
+        struct snd_interval list_range;
 
         if (!count) {
                 i->empty = 1;
                 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;
-                }
-        }
-        i->empty = 1;
-        return -EINVAL;
- _l1:
-        for (k = count; k-- > 0;) {
-                if (mask && !(mask & (1 << k)))
+                if (!snd_interval_test(i, list[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;
-                }
+                list_range.min = min(list_range.min, list[k]);
+                list_range.max = max(list_range.max, list[k]);
         }
-        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);
 }
 
 EXPORT_SYMBOL(snd_interval_list);
diff --git a/sound/core/pcm_memory.c b/sound/core/pcm_memory.c
index a6d42808828c..caa7796bc2f5 100644
--- a/sound/core/pcm_memory.c
+++ b/sound/core/pcm_memory.c
@@ -304,6 +304,7 @@ int snd_pcm_lib_preallocate_pages_for_all(struct snd_pcm *pcm,
 
 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
  * @substream: the pcm substream instance
@@ -349,6 +350,7 @@ unsigned int snd_pcm_sgbuf_get_chunk_size(struct snd_pcm_substream *substream,
         return size;
 }
 EXPORT_SYMBOL(snd_pcm_sgbuf_get_chunk_size);
+#endif /* CONFIG_SND_DMA_SGBUF */
 
 /**
  * snd_pcm_lib_malloc_pages - allocate the DMA buffer
diff --git a/sound/core/pcm_native.c b/sound/core/pcm_native.c
index ac2150e0670d..561d6d95a2d3 100644
--- a/sound/core/pcm_native.c
+++ b/sound/core/pcm_native.c
@@ -1343,8 +1343,6 @@ static int snd_pcm_prepare(struct snd_pcm_substream *substream,
 
 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;
 }
@@ -1389,12 +1387,6 @@ static struct action_ops snd_pcm_action_drain_init = {
         .post_action = snd_pcm_post_drain_init
 };
 
-struct drain_rec {
-        struct snd_pcm_substream *substream;
-        wait_queue_t wait;
-        snd_pcm_uframes_t stop_threshold;
-};
-
 static int snd_pcm_drop(struct snd_pcm_substream *substream);
 
 /*
@@ -1404,14 +1396,15 @@ static int snd_pcm_drop(struct snd_pcm_substream *substream);
  * After this call, all streams are supposed to be either SETUP or DRAINING
  * (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;
         struct snd_pcm_runtime *runtime;
         struct snd_pcm_substream *s;
+        wait_queue_t wait;
         int result = 0;
-        int i, num_drecs;
-        struct drain_rec *drec, drec_tmp, *d;
+        int nonblock = 0;
 
         card = substream->pcm->card;
         runtime = substream->runtime;
@@ -1428,70 +1421,59 @@ static int snd_pcm_drain(struct snd_pcm_substream *substream)
                 }
         }
 
-        /* allocate temporary record for drain sync */
-        down_read(&snd_pcm_link_rwsem);
-        if (snd_pcm_stream_linked(substream)) {
-                drec = kmalloc(substream->group->count * sizeof(*drec), GFP_KERNEL);
-                if (! drec) {
-                        up_read(&snd_pcm_link_rwsem);
-                        snd_power_unlock(card);
-                        return -ENOMEM;
-                }
-        } else
-                drec = &drec_tmp;
-
-        /* count only playback streams */
-        num_drecs = 0;
-        snd_pcm_group_for_each_entry(s, substream) {
-                runtime = s->runtime;
-                if (s->stream == SNDRV_PCM_STREAM_PLAYBACK) {
-                        d = &drec[num_drecs++];
-                        d->substream = s;
-                        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);
+        if (file) {
+                if (file->f_flags & O_NONBLOCK)
+                        nonblock = 1;
+        } else if (substream->f_flags & O_NONBLOCK)
+                nonblock = 1;
 
+        down_read(&snd_pcm_link_rwsem);
         snd_pcm_stream_lock_irq(substream);
         /* resume pause */
-        if (substream->runtime->status->state == SNDRV_PCM_STATE_PAUSED)
+        if (runtime->status->state == SNDRV_PCM_STATE_PAUSED)
                 snd_pcm_pause(substream, 0);
 
         /* 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;
         }
 
         for (;;) {
                 long tout;
+                struct snd_pcm_runtime *to_check;
                 if (signal_pending(current)) {
                         result = -ERESTARTSYS;
                         break;
                 }
-                /* all finished? */
-                for (i = 0; i < num_drecs; i++) {
-                        runtime = drec[i].substream->runtime;
-                        if (runtime->status->state == SNDRV_PCM_STATE_DRAINING)
+                /* find a substream to drain */
+                to_check = NULL;
+                snd_pcm_group_for_each_entry(s, substream) {
+                        if (s->stream != SNDRV_PCM_STREAM_PLAYBACK)
+                                continue;
+                        runtime = s->runtime;
+                        if (runtime->status->state == SNDRV_PCM_STATE_DRAINING) {
+                                to_check = runtime;
                                 break;
+                        }
                 }
-                if (i == num_drecs)
-                        break; /* yes, all drained */
-
+                if (!to_check)
+                        break; /* all drained */
+                init_waitqueue_entry(&wait, current);
+                add_wait_queue(&to_check->sleep, &wait);
                 set_current_state(TASK_INTERRUPTIBLE);
                 snd_pcm_stream_unlock_irq(substream);
+                up_read(&snd_pcm_link_rwsem);
                 snd_power_unlock(card);
                 tout = schedule_timeout(10 * HZ);
                 snd_power_lock(card);
+                down_read(&snd_pcm_link_rwsem);
                 snd_pcm_stream_lock_irq(substream);
+                remove_wait_queue(&to_check->sleep, &wait);
                 if (tout == 0) {
                         if (substream->runtime->status->state == SNDRV_PCM_STATE_SUSPENDED)
                                 result = -ESTRPIPE;
@@ -1504,18 +1486,9 @@ static int snd_pcm_drain(struct snd_pcm_substream *substream)
                 }
         }
 
+ 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);
+        up_read(&snd_pcm_link_rwsem);
         snd_power_unlock(card);
 
         return result;
@@ -2208,6 +2181,9 @@ static snd_pcm_sframes_t snd_pcm_playback_rewind(struct snd_pcm_substream *subst
         case SNDRV_PCM_STATE_XRUN:
                 ret = -EPIPE;
                 goto __end;
+        case SNDRV_PCM_STATE_SUSPENDED:
+                ret = -ESTRPIPE;
+                goto __end;
         default:
                 ret = -EBADFD;
                 goto __end;
@@ -2253,6 +2229,9 @@ static snd_pcm_sframes_t snd_pcm_capture_rewind(struct snd_pcm_substream *substr
         case SNDRV_PCM_STATE_XRUN:
                 ret = -EPIPE;
                 goto __end;
+        case SNDRV_PCM_STATE_SUSPENDED:
+                ret = -ESTRPIPE;
+                goto __end;
         default:
                 ret = -EBADFD;
                 goto __end;
@@ -2299,6 +2278,9 @@ static snd_pcm_sframes_t snd_pcm_playback_forward(struct snd_pcm_substream *subs
         case SNDRV_PCM_STATE_XRUN:
                 ret = -EPIPE;
                 goto __end;
+        case SNDRV_PCM_STATE_SUSPENDED:
+                ret = -ESTRPIPE;
+                goto __end;
         default:
                 ret = -EBADFD;
                 goto __end;
@@ -2345,6 +2327,9 @@ static snd_pcm_sframes_t snd_pcm_capture_forward(struct snd_pcm_substream *subst
         case SNDRV_PCM_STATE_XRUN:
                 ret = -EPIPE;
                 goto __end;
+        case SNDRV_PCM_STATE_SUSPENDED:
+                ret = -ESTRPIPE;
+                goto __end;
         default:
                 ret = -EBADFD;
                 goto __end;
@@ -2544,7 +2529,7 @@ static int snd_pcm_common_ioctl1(struct file *file,
                 return snd_pcm_hw_params_old_user(substream, arg);
 #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);
         case SNDRV_PCM_IOCTL_PAUSE:
diff --git a/sound/core/rawmidi.c b/sound/core/rawmidi.c
index 473247c8e6d3..c0adc14c91f0 100644
--- a/sound/core/rawmidi.c
+++ b/sound/core/rawmidi.c
@@ -274,7 +274,7 @@ static int open_substream(struct snd_rawmidi *rmidi,
                 return err;
         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;
         rmidi->streams[substream->stream].substream_opened++;
diff --git a/sound/core/seq/Makefile b/sound/core/seq/Makefile
index 1bcb360330e5..941f64a853eb 100644
--- a/sound/core/seq/Makefile
+++ b/sound/core/seq/Makefile
@@ -3,10 +3,6 @@
 # Copyright (c) 1999 by Jaroslav Kysela <perex@perex.cz>
 #
 
-ifeq ($(CONFIG_SND_SEQUENCER_OSS),y)
-  obj-$(CONFIG_SND_SEQUENCER) += oss/
-endif
-
 snd-seq-device-objs := seq_device.o
 snd-seq-objs := seq.o seq_lock.o seq_clientmgr.o seq_memory.o seq_queue.o \
                 seq_fifo.o seq_prioq.o seq_timer.o \
@@ -19,7 +15,8 @@ snd-seq-virmidi-objs := seq_virmidi.o
 
 obj-$(CONFIG_SND_SEQUENCER) += snd-seq.o snd-seq-device.o
 ifeq ($(CONFIG_SND_SEQUENCER_OSS),y)
-obj-$(CONFIG_SND_SEQUENCER) += snd-seq-midi-event.o
+  obj-$(CONFIG_SND_SEQUENCER) += snd-seq-midi-event.o
+  obj-$(CONFIG_SND_SEQUENCER) += oss/
 endif
 obj-$(CONFIG_SND_SEQ_DUMMY) += snd-seq-dummy.o
 
diff --git a/sound/core/seq/oss/seq_oss_midi.c b/sound/core/seq/oss/seq_oss_midi.c
index 0a711d2d04f0..9dfb2f77be60 100644
--- a/sound/core/seq/oss/seq_oss_midi.c
+++ b/sound/core/seq/oss/seq_oss_midi.c
@@ -20,6 +20,7 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  */
 
+#include <sound/asoundef.h>
 #include "seq_oss_midi.h"
 #include "seq_oss_readq.h"
 #include "seq_oss_timer.h"
@@ -476,19 +477,20 @@ snd_seq_oss_midi_reset(struct seq_oss_devinfo *dp, int dev)
                 ev.source.port = dp->port;
                 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);
                         }
                 }
         }
diff --git a/sound/core/seq/seq_midi.c b/sound/core/seq/seq_midi.c
index 4d26146a62cc..ebaf1b541dcd 100644
--- a/sound/core/seq/seq_midi.c
+++ b/sound/core/seq/seq_midi.c
@@ -120,7 +120,8 @@ static int dump_midi(struct snd_rawmidi_substream *substream, const char *buf, i
                 return -EINVAL;
         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;
         }
         if (snd_rawmidi_kernel_write(substream, buf, count) < count)
@@ -236,6 +237,7 @@ static int midisynth_use(void *private_data, struct snd_seq_port_subscribe *info
         memset(&params, 0, sizeof(params));
         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);
                 return err;
@@ -248,12 +250,9 @@ static int midisynth_use(void *private_data, struct snd_seq_port_subscribe *info
 static int midisynth_unuse(void *private_data, struct snd_seq_port_subscribe *info)
 {
         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);
 }
diff --git a/sound/core/vmaster.c b/sound/core/vmaster.c
index 257624bd1997..3b9b550109cb 100644
--- a/sound/core/vmaster.c
+++ b/sound/core/vmaster.c
@@ -353,7 +353,8 @@ static void master_free(struct snd_kcontrol *kcontrol)
  *
  * 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,
                                                  const unsigned int *tlv)
@@ -384,7 +385,10 @@ struct snd_kcontrol *snd_ctl_make_virtual_master(char *name,
         kctl->private_free = master_free;
 
         /* 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));
                 kctl->tlv.p = master->tlv;
diff --git a/sound/drivers/dummy.c b/sound/drivers/dummy.c
index 54239d2e0997..6ba066c41d2e 100644
--- a/sound/drivers/dummy.c
+++ b/sound/drivers/dummy.c
@@ -25,12 +25,15 @@
 #include <linux/slab.h>
 #include <linux/time.h>
 #include <linux/wait.h>
+#include <linux/hrtimer.h>
+#include <linux/math64.h>
 #include <linux/moduleparam.h>
 #include <sound/core.h>
 #include <sound/control.h>
 #include <sound/tlv.h>
 #include <sound/pcm.h>
 #include <sound/rawmidi.h>
+#include <sound/info.h>
 #include <sound/initval.h>
 
 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
@@ -39,7 +42,7 @@ MODULE_LICENSE("GPL");
 MODULE_SUPPORTED_DEVICE("{{ALSA,Dummy soundcard}}");
 
 #define MAX_PCM_DEVICES         4
-#define MAX_PCM_SUBSTREAMS      16
+#define MAX_PCM_SUBSTREAMS      128
 #define MAX_MIDI_DEVICES        2
 
 #if 0 /* emu10k1 emulation */
@@ -148,6 +151,10 @@ static int enable[SNDRV_CARDS] = {1, [1 ... (SNDRV_CARDS - 1)] = 0};
 static int pcm_devs[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1};
 static int pcm_substreams[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 8};
 //static int midi_devs[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 2};
+#ifdef CONFIG_HIGH_RES_TIMERS
+static int hrtimer = 1;
+#endif
+static int fake_buffer = 1;
 
 module_param_array(index, int, NULL, 0444);
 MODULE_PARM_DESC(index, "Index value for dummy soundcard.");
@@ -161,6 +168,12 @@ module_param_array(pcm_substreams, int, NULL, 0444);
 MODULE_PARM_DESC(pcm_substreams, "PCM substreams # (1-16) for dummy driver.");
 //module_param_array(midi_devs, int, NULL, 0444);
 //MODULE_PARM_DESC(midi_devs, "MIDI devices # (0-2) for dummy driver.");
+module_param(fake_buffer, bool, 0444);
+MODULE_PARM_DESC(fake_buffer, "Fake buffer allocations.");
+#ifdef CONFIG_HIGH_RES_TIMERS
+module_param(hrtimer, bool, 0644);
+MODULE_PARM_DESC(hrtimer, "Use hrtimer as the timer source.");
+#endif
 
 static struct platform_device *devices[SNDRV_CARDS];
 
@@ -171,137 +184,324 @@ static struct platform_device *devices[SNDRV_CARDS];
 #define MIXER_ADDR_CD           4
 #define MIXER_ADDR_LAST         4
 
+struct dummy_timer_ops {
+        int (*create)(struct snd_pcm_substream *);
+        void (*free)(struct snd_pcm_substream *);
+        int (*prepare)(struct snd_pcm_substream *);
+        int (*start)(struct snd_pcm_substream *);
+        int (*stop)(struct snd_pcm_substream *);
+        snd_pcm_uframes_t (*pointer)(struct snd_pcm_substream *);
+};
+
 struct snd_dummy {
         struct snd_card *card;
         struct snd_pcm *pcm;
         spinlock_t mixer_lock;
         int mixer_volume[MIXER_ADDR_LAST+1][2];
         int capture_source[MIXER_ADDR_LAST+1][2];
+        const struct dummy_timer_ops *timer_ops;
 };
 
-struct snd_dummy_pcm {
-        struct snd_dummy *dummy;
+/*
+ * system timer interface
+ */
+
+struct dummy_systimer_pcm {
         spinlock_t lock;
         struct timer_list timer;
-        unsigned int pcm_buffer_size;
-        unsigned int pcm_period_size;
-        unsigned int pcm_bps;           /* bytes per second */
-        unsigned int pcm_hz;            /* HZ */
-        unsigned int pcm_irq_pos;       /* IRQ position */
-        unsigned int pcm_buf_pos;       /* position in buffer */
+        unsigned long base_time;
+        unsigned int frac_pos;  /* fractional sample position (based HZ) */
+        unsigned int frac_period_rest;
+        unsigned int frac_buffer_size;  /* buffer_size * HZ */
+        unsigned int frac_period_size;  /* period_size * HZ */
+        unsigned int rate;
+        int elapsed;
         struct snd_pcm_substream *substream;
 };
 
-
-static inline void snd_card_dummy_pcm_timer_start(struct snd_dummy_pcm *dpcm)
+static void dummy_systimer_rearm(struct dummy_systimer_pcm *dpcm)
 {
-        dpcm->timer.expires = 1 + jiffies;
+        dpcm->timer.expires = jiffies +
+                (dpcm->frac_period_rest + dpcm->rate - 1) / dpcm->rate;
         add_timer(&dpcm->timer);
 }
 
-static inline void snd_card_dummy_pcm_timer_stop(struct snd_dummy_pcm *dpcm)
+static void dummy_systimer_update(struct dummy_systimer_pcm *dpcm)
 {
-        del_timer(&dpcm->timer);
+        unsigned long delta;
+
+        delta = jiffies - dpcm->base_time;
+        if (!delta)
+                return;
+        dpcm->base_time += delta;
+        delta *= dpcm->rate;
+        dpcm->frac_pos += delta;
+        while (dpcm->frac_pos >= dpcm->frac_buffer_size)
+                dpcm->frac_pos -= dpcm->frac_buffer_size;
+        while (dpcm->frac_period_rest <= delta) {
+                dpcm->elapsed++;
+                dpcm->frac_period_rest += dpcm->frac_period_size;
+        }
+        dpcm->frac_period_rest -= delta;
 }
 
-static int snd_card_dummy_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
+static int dummy_systimer_start(struct snd_pcm_substream *substream)
 {
-        struct snd_pcm_runtime *runtime = substream->runtime;
-        struct snd_dummy_pcm *dpcm = runtime->private_data;
-        int err = 0;
+        struct dummy_systimer_pcm *dpcm = substream->runtime->private_data;
+        spin_lock(&dpcm->lock);
+        dpcm->base_time = jiffies;
+        dummy_systimer_rearm(dpcm);
+        spin_unlock(&dpcm->lock);
+        return 0;
+}
 
+static int dummy_systimer_stop(struct snd_pcm_substream *substream)
+{
+        struct dummy_systimer_pcm *dpcm = substream->runtime->private_data;
         spin_lock(&dpcm->lock);
-        switch (cmd) {
-        case SNDRV_PCM_TRIGGER_START:
-        case SNDRV_PCM_TRIGGER_RESUME:
-                snd_card_dummy_pcm_timer_start(dpcm);
-                break;
-        case SNDRV_PCM_TRIGGER_STOP:
-        case SNDRV_PCM_TRIGGER_SUSPEND:
-                snd_card_dummy_pcm_timer_stop(dpcm);
-                break;
-        default:
-                err = -EINVAL;
-                break;
-        }
+        del_timer(&dpcm->timer);
         spin_unlock(&dpcm->lock);
         return 0;
 }
 
-static int snd_card_dummy_pcm_prepare(struct snd_pcm_substream *substream)
+static int dummy_systimer_prepare(struct snd_pcm_substream *substream)
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
-        struct snd_dummy_pcm *dpcm = runtime->private_data;
-        int bps;
-
-        bps = snd_pcm_format_width(runtime->format) * runtime->rate *
-                runtime->channels / 8;
-
-        if (bps <= 0)
-                return -EINVAL;
-
-        dpcm->pcm_bps = bps;
-        dpcm->pcm_hz = HZ;
-        dpcm->pcm_buffer_size = snd_pcm_lib_buffer_bytes(substream);
-        dpcm->pcm_period_size = snd_pcm_lib_period_bytes(substream);
-        dpcm->pcm_irq_pos = 0;
-        dpcm->pcm_buf_pos = 0;
+        struct dummy_systimer_pcm *dpcm = runtime->private_data;
 
-        snd_pcm_format_set_silence(runtime->format, runtime->dma_area,
-                        bytes_to_samples(runtime, runtime->dma_bytes));
+        dpcm->frac_pos = 0;
+        dpcm->rate = runtime->rate;
+        dpcm->frac_buffer_size = runtime->buffer_size * HZ;
+        dpcm->frac_period_size = runtime->period_size * HZ;
+        dpcm->frac_period_rest = dpcm->frac_period_size;
+        dpcm->elapsed = 0;
 
         return 0;
 }
 
-static void snd_card_dummy_pcm_timer_function(unsigned long data)
+static void dummy_systimer_callback(unsigned long data)
 {
-        struct snd_dummy_pcm *dpcm = (struct snd_dummy_pcm *)data;
+        struct dummy_systimer_pcm *dpcm = (struct dummy_systimer_pcm *)data;
         unsigned long flags;
+        int elapsed = 0;
         
         spin_lock_irqsave(&dpcm->lock, flags);
-        dpcm->timer.expires = 1 + jiffies;
-        add_timer(&dpcm->timer);
-        dpcm->pcm_irq_pos += dpcm->pcm_bps;
-        dpcm->pcm_buf_pos += dpcm->pcm_bps;
-        dpcm->pcm_buf_pos %= dpcm->pcm_buffer_size * dpcm->pcm_hz;
-        if (dpcm->pcm_irq_pos >= dpcm->pcm_period_size * dpcm->pcm_hz) {
-                dpcm->pcm_irq_pos %= dpcm->pcm_period_size * dpcm->pcm_hz;
-                spin_unlock_irqrestore(&dpcm->lock, flags);
+        dummy_systimer_update(dpcm);
+        dummy_systimer_rearm(dpcm);
+        elapsed = dpcm->elapsed;
+        dpcm->elapsed = 0;
+        spin_unlock_irqrestore(&dpcm->lock, flags);
+        if (elapsed)
+                snd_pcm_period_elapsed(dpcm->substream);
+}
+
+static snd_pcm_uframes_t
+dummy_systimer_pointer(struct snd_pcm_substream *substream)
+{
+        struct dummy_systimer_pcm *dpcm = substream->runtime->private_data;
+        snd_pcm_uframes_t pos;
+
+        spin_lock(&dpcm->lock);
+        dummy_systimer_update(dpcm);
+        pos = dpcm->frac_pos / HZ;
+        spin_unlock(&dpcm->lock);
+        return pos;
+}
+
+static int dummy_systimer_create(struct snd_pcm_substream *substream)
+{
+        struct dummy_systimer_pcm *dpcm;
+
+        dpcm = kzalloc(sizeof(*dpcm), GFP_KERNEL);
+        if (!dpcm)
+                return -ENOMEM;
+        substream->runtime->private_data = dpcm;
+        init_timer(&dpcm->timer);
+        dpcm->timer.data = (unsigned long) dpcm;
+        dpcm->timer.function = dummy_systimer_callback;
+        spin_lock_init(&dpcm->lock);
+        dpcm->substream = substream;
+        return 0;
+}
+
+static void dummy_systimer_free(struct snd_pcm_substream *substream)
+{
+        kfree(substream->runtime->private_data);
+}
+
+static struct dummy_timer_ops dummy_systimer_ops = {
+        .create =       dummy_systimer_create,
+        .free =         dummy_systimer_free,
+        .prepare =      dummy_systimer_prepare,
+        .start =        dummy_systimer_start,
+        .stop =         dummy_systimer_stop,
+        .pointer =      dummy_systimer_pointer,
+};
+
+#ifdef CONFIG_HIGH_RES_TIMERS
+/*
+ * hrtimer interface
+ */
+
+struct dummy_hrtimer_pcm {
+        ktime_t base_time;
+        ktime_t period_time;
+        atomic_t running;
+        struct hrtimer timer;
+        struct tasklet_struct tasklet;
+        struct snd_pcm_substream *substream;
+};
+
+static void dummy_hrtimer_pcm_elapsed(unsigned long priv)
+{
+        struct dummy_hrtimer_pcm *dpcm = (struct dummy_hrtimer_pcm *)priv;
+        if (atomic_read(&dpcm->running))
                 snd_pcm_period_elapsed(dpcm->substream);
-        } else
-                spin_unlock_irqrestore(&dpcm->lock, flags);
 }
 
-static snd_pcm_uframes_t snd_card_dummy_pcm_pointer(struct snd_pcm_substream *substream)
+static enum hrtimer_restart dummy_hrtimer_callback(struct hrtimer *timer)
+{
+        struct dummy_hrtimer_pcm *dpcm;
+
+        dpcm = container_of(timer, struct dummy_hrtimer_pcm, timer);
+        if (!atomic_read(&dpcm->running))
+                return HRTIMER_NORESTART;
+        tasklet_schedule(&dpcm->tasklet);
+        hrtimer_forward_now(timer, dpcm->period_time);
+        return HRTIMER_RESTART;
+}
+
+static int dummy_hrtimer_start(struct snd_pcm_substream *substream)
+{
+        struct dummy_hrtimer_pcm *dpcm = substream->runtime->private_data;
+
+        dpcm->base_time = hrtimer_cb_get_time(&dpcm->timer);
+        hrtimer_start(&dpcm->timer, dpcm->period_time, HRTIMER_MODE_REL);
+        atomic_set(&dpcm->running, 1);
+        return 0;
+}
+
+static int dummy_hrtimer_stop(struct snd_pcm_substream *substream)
+{
+        struct dummy_hrtimer_pcm *dpcm = substream->runtime->private_data;
+
+        atomic_set(&dpcm->running, 0);
+        hrtimer_cancel(&dpcm->timer);
+        return 0;
+}
+
+static inline void dummy_hrtimer_sync(struct dummy_hrtimer_pcm *dpcm)
+{
+        tasklet_kill(&dpcm->tasklet);
+}
+
+static snd_pcm_uframes_t
+dummy_hrtimer_pointer(struct snd_pcm_substream *substream)
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
-        struct snd_dummy_pcm *dpcm = runtime->private_data;
+        struct dummy_hrtimer_pcm *dpcm = runtime->private_data;
+        u64 delta;
+        u32 pos;
+
+        delta = ktime_us_delta(hrtimer_cb_get_time(&dpcm->timer),
+                               dpcm->base_time);
+        delta = div_u64(delta * runtime->rate + 999999, 1000000);
+        div_u64_rem(delta, runtime->buffer_size, &pos);
+        return pos;
+}
 
-        return bytes_to_frames(runtime, dpcm->pcm_buf_pos / dpcm->pcm_hz);
+static int dummy_hrtimer_prepare(struct snd_pcm_substream *substream)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct dummy_hrtimer_pcm *dpcm = runtime->private_data;
+        unsigned int period, rate;
+        long sec;
+        unsigned long nsecs;
+
+        dummy_hrtimer_sync(dpcm);
+        period = runtime->period_size;
+        rate = runtime->rate;
+        sec = period / rate;
+        period %= rate;
+        nsecs = div_u64((u64)period * 1000000000UL + rate - 1, rate);
+        dpcm->period_time = ktime_set(sec, nsecs);
+
+        return 0;
 }
 
-static struct snd_pcm_hardware snd_card_dummy_playback =
+static int dummy_hrtimer_create(struct snd_pcm_substream *substream)
 {
-        .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
-                                 SNDRV_PCM_INFO_RESUME | SNDRV_PCM_INFO_MMAP_VALID),
-        .formats =              USE_FORMATS,
-        .rates =                USE_RATE,
-        .rate_min =             USE_RATE_MIN,
-        .rate_max =             USE_RATE_MAX,
-        .channels_min =         USE_CHANNELS_MIN,
-        .channels_max =         USE_CHANNELS_MAX,
-        .buffer_bytes_max =     MAX_BUFFER_SIZE,
-        .period_bytes_min =     64,
-        .period_bytes_max =     MAX_PERIOD_SIZE,
-        .periods_min =          USE_PERIODS_MIN,
-        .periods_max =          USE_PERIODS_MAX,
-        .fifo_size =            0,
+        struct dummy_hrtimer_pcm *dpcm;
+
+        dpcm = kzalloc(sizeof(*dpcm), GFP_KERNEL);
+        if (!dpcm)
+                return -ENOMEM;
+        substream->runtime->private_data = dpcm;
+        hrtimer_init(&dpcm->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
+        dpcm->timer.function = dummy_hrtimer_callback;
+        dpcm->substream = substream;
+        atomic_set(&dpcm->running, 0);
+        tasklet_init(&dpcm->tasklet, dummy_hrtimer_pcm_elapsed,
+                     (unsigned long)dpcm);
+        return 0;
+}
+
+static void dummy_hrtimer_free(struct snd_pcm_substream *substream)
+{
+        struct dummy_hrtimer_pcm *dpcm = substream->runtime->private_data;
+        dummy_hrtimer_sync(dpcm);
+        kfree(dpcm);
+}
+
+static struct dummy_timer_ops dummy_hrtimer_ops = {
+        .create =       dummy_hrtimer_create,
+        .free =         dummy_hrtimer_free,
+        .prepare =      dummy_hrtimer_prepare,
+        .start =        dummy_hrtimer_start,
+        .stop =         dummy_hrtimer_stop,
+        .pointer =      dummy_hrtimer_pointer,
 };
 
-static struct snd_pcm_hardware snd_card_dummy_capture =
+#endif /* CONFIG_HIGH_RES_TIMERS */
+
+/*
+ * PCM interface
+ */
+
+static int dummy_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
 {
-        .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
-                                 SNDRV_PCM_INFO_RESUME | SNDRV_PCM_INFO_MMAP_VALID),
+        struct snd_dummy *dummy = snd_pcm_substream_chip(substream);
+
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+        case SNDRV_PCM_TRIGGER_RESUME:
+                return dummy->timer_ops->start(substream);
+        case SNDRV_PCM_TRIGGER_STOP:
+        case SNDRV_PCM_TRIGGER_SUSPEND:
+                return dummy->timer_ops->stop(substream);
+        }
+        return -EINVAL;
+}
+
+static int dummy_pcm_prepare(struct snd_pcm_substream *substream)
+{
+        struct snd_dummy *dummy = snd_pcm_substream_chip(substream);
+
+        return dummy->timer_ops->prepare(substream);
+}
+
+static snd_pcm_uframes_t dummy_pcm_pointer(struct snd_pcm_substream *substream)
+{
+        struct snd_dummy *dummy = snd_pcm_substream_chip(substream);
+
+        return dummy->timer_ops->pointer(substream);
+}
+
+static struct snd_pcm_hardware dummy_pcm_hardware = {
+        .info =                 (SNDRV_PCM_INFO_MMAP |
+                                 SNDRV_PCM_INFO_INTERLEAVED |
+                                 SNDRV_PCM_INFO_RESUME |
+                                 SNDRV_PCM_INFO_MMAP_VALID),
         .formats =              USE_FORMATS,
         .rates =                USE_RATE,
         .rate_min =             USE_RATE_MIN,
@@ -316,123 +516,152 @@ static struct snd_pcm_hardware snd_card_dummy_capture =
         .fifo_size =            0,
 };
 
-static void snd_card_dummy_runtime_free(struct snd_pcm_runtime *runtime)
-{
-        kfree(runtime->private_data);
-}
-
-static int snd_card_dummy_hw_params(struct snd_pcm_substream *substream,
-                                    struct snd_pcm_hw_params *hw_params)
+static int dummy_pcm_hw_params(struct snd_pcm_substream *substream,
+                               struct snd_pcm_hw_params *hw_params)
 {
-        return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
+        if (fake_buffer) {
+                /* runtime->dma_bytes has to be set manually to allow mmap */
+                substream->runtime->dma_bytes = params_buffer_bytes(hw_params);
+                return 0;
+        }
+        return snd_pcm_lib_malloc_pages(substream,
+                                        params_buffer_bytes(hw_params));
 }
 
-static int snd_card_dummy_hw_free(struct snd_pcm_substream *substream)
+static int dummy_pcm_hw_free(struct snd_pcm_substream *substream)
 {
+        if (fake_buffer)
+                return 0;
         return snd_pcm_lib_free_pages(substream);
 }
 
-static struct snd_dummy_pcm *new_pcm_stream(struct snd_pcm_substream *substream)
-{
-        struct snd_dummy_pcm *dpcm;
-
-        dpcm = kzalloc(sizeof(*dpcm), GFP_KERNEL);
-        if (! dpcm)
-                return dpcm;
-        init_timer(&dpcm->timer);
-        dpcm->timer.data = (unsigned long) dpcm;
-        dpcm->timer.function = snd_card_dummy_pcm_timer_function;
-        spin_lock_init(&dpcm->lock);
-        dpcm->substream = substream;
-        return dpcm;
-}
-
-static int snd_card_dummy_playback_open(struct snd_pcm_substream *substream)
+static int dummy_pcm_open(struct snd_pcm_substream *substream)
 {
+        struct snd_dummy *dummy = snd_pcm_substream_chip(substream);
         struct snd_pcm_runtime *runtime = substream->runtime;
-        struct snd_dummy_pcm *dpcm;
         int err;
 
-        if ((dpcm = new_pcm_stream(substream)) == NULL)
-                return -ENOMEM;
-        runtime->private_data = dpcm;
-        /* makes the infrastructure responsible for freeing dpcm */
-        runtime->private_free = snd_card_dummy_runtime_free;
-        runtime->hw = snd_card_dummy_playback;
+        dummy->timer_ops = &dummy_systimer_ops;
+#ifdef CONFIG_HIGH_RES_TIMERS
+        if (hrtimer)
+                dummy->timer_ops = &dummy_hrtimer_ops;
+#endif
+
+        err = dummy->timer_ops->create(substream);
+        if (err < 0)
+                return err;
+
+        runtime->hw = dummy_pcm_hardware;
         if (substream->pcm->device & 1) {
                 runtime->hw.info &= ~SNDRV_PCM_INFO_INTERLEAVED;
                 runtime->hw.info |= SNDRV_PCM_INFO_NONINTERLEAVED;
         }
         if (substream->pcm->device & 2)
-                runtime->hw.info &= ~(SNDRV_PCM_INFO_MMAP|SNDRV_PCM_INFO_MMAP_VALID);
-        err = add_playback_constraints(runtime);
-        if (err < 0)
+                runtime->hw.info &= ~(SNDRV_PCM_INFO_MMAP |
+                                      SNDRV_PCM_INFO_MMAP_VALID);
+
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+                err = add_playback_constraints(substream->runtime);
+        else
+                err = add_capture_constraints(substream->runtime);
+        if (err < 0) {
+                dummy->timer_ops->free(substream);
                 return err;
-
+        }
         return 0;
 }
 
-static int snd_card_dummy_capture_open(struct snd_pcm_substream *substream)
+static int dummy_pcm_close(struct snd_pcm_substream *substream)
 {
-        struct snd_pcm_runtime *runtime = substream->runtime;
-        struct snd_dummy_pcm *dpcm;
-        int err;
+        struct snd_dummy *dummy = snd_pcm_substream_chip(substream);
+        dummy->timer_ops->free(substream);
+        return 0;
+}
 
-        if ((dpcm = new_pcm_stream(substream)) == NULL)
-                return -ENOMEM;
-        runtime->private_data = dpcm;
-        /* makes the infrastructure responsible for freeing dpcm */
-        runtime->private_free = snd_card_dummy_runtime_free;
-        runtime->hw = snd_card_dummy_capture;
-        if (substream->pcm->device == 1) {
-                runtime->hw.info &= ~SNDRV_PCM_INFO_INTERLEAVED;
-                runtime->hw.info |= SNDRV_PCM_INFO_NONINTERLEAVED;
+/*
+ * dummy buffer handling
+ */
+
+static void *dummy_page[2];
+
+static void free_fake_buffer(void)
+{
+        if (fake_buffer) {
+                int i;
+                for (i = 0; i < 2; i++)
+                        if (dummy_page[i]) {
+                                free_page((unsigned long)dummy_page[i]);
+                                dummy_page[i] = NULL;
+                        }
         }
-        if (substream->pcm->device & 2)
-                runtime->hw.info &= ~(SNDRV_PCM_INFO_MMAP|SNDRV_PCM_INFO_MMAP_VALID);
-        err = add_capture_constraints(runtime);
-        if (err < 0)
-                return err;
+}
 
+static int alloc_fake_buffer(void)
+{
+        int i;
+
+        if (!fake_buffer)
+                return 0;
+        for (i = 0; i < 2; i++) {
+                dummy_page[i] = (void *)get_zeroed_page(GFP_KERNEL);
+                if (!dummy_page[i]) {
+                        free_fake_buffer();
+                        return -ENOMEM;
+                }
+        }
         return 0;
 }
 
-static int snd_card_dummy_playback_close(struct snd_pcm_substream *substream)
+static int dummy_pcm_copy(struct snd_pcm_substream *substream,
+                          int channel, snd_pcm_uframes_t pos,
+                          void __user *dst, snd_pcm_uframes_t count)
 {
-        return 0;
+        return 0; /* do nothing */
 }
 
-static int snd_card_dummy_capture_close(struct snd_pcm_substream *substream)
+static int dummy_pcm_silence(struct snd_pcm_substream *substream,
+                             int channel, snd_pcm_uframes_t pos,
+                             snd_pcm_uframes_t count)
 {
-        return 0;
+        return 0; /* do nothing */
+}
+
+static struct page *dummy_pcm_page(struct snd_pcm_substream *substream,
+                                   unsigned long offset)
+{
+        return virt_to_page(dummy_page[substream->stream]); /* the same page */
 }
 
-static struct snd_pcm_ops snd_card_dummy_playback_ops = {
-        .open =                 snd_card_dummy_playback_open,
-        .close =                snd_card_dummy_playback_close,
-        .ioctl =                snd_pcm_lib_ioctl,
-        .hw_params =            snd_card_dummy_hw_params,
-        .hw_free =              snd_card_dummy_hw_free,
-        .prepare =              snd_card_dummy_pcm_prepare,
-        .trigger =              snd_card_dummy_pcm_trigger,
-        .pointer =              snd_card_dummy_pcm_pointer,
+static struct snd_pcm_ops dummy_pcm_ops = {
+        .open =         dummy_pcm_open,
+        .close =        dummy_pcm_close,
+        .ioctl =        snd_pcm_lib_ioctl,
+        .hw_params =    dummy_pcm_hw_params,
+        .hw_free =      dummy_pcm_hw_free,
+        .prepare =      dummy_pcm_prepare,
+        .trigger =      dummy_pcm_trigger,
+        .pointer =      dummy_pcm_pointer,
 };
 
-static struct snd_pcm_ops snd_card_dummy_capture_ops = {
-        .open =                 snd_card_dummy_capture_open,
-        .close =                snd_card_dummy_capture_close,
-        .ioctl =                snd_pcm_lib_ioctl,
-        .hw_params =            snd_card_dummy_hw_params,
-        .hw_free =              snd_card_dummy_hw_free,
-        .prepare =              snd_card_dummy_pcm_prepare,
-        .trigger =              snd_card_dummy_pcm_trigger,
-        .pointer =              snd_card_dummy_pcm_pointer,
+static struct snd_pcm_ops dummy_pcm_ops_no_buf = {
+        .open =         dummy_pcm_open,
+        .close =        dummy_pcm_close,
+        .ioctl =        snd_pcm_lib_ioctl,
+        .hw_params =    dummy_pcm_hw_params,
+        .hw_free =      dummy_pcm_hw_free,
+        .prepare =      dummy_pcm_prepare,
+        .trigger =      dummy_pcm_trigger,
+        .pointer =      dummy_pcm_pointer,
+        .copy =         dummy_pcm_copy,
+        .silence =      dummy_pcm_silence,
+        .page =         dummy_pcm_page,
 };
 
 static int __devinit snd_card_dummy_pcm(struct snd_dummy *dummy, int device,
                                         int substreams)
 {
         struct snd_pcm *pcm;
+        struct snd_pcm_ops *ops;
         int err;
 
         err = snd_pcm_new(dummy->card, "Dummy PCM", device,
@@ -440,17 +669,28 @@ static int __devinit snd_card_dummy_pcm(struct snd_dummy *dummy, int device,
         if (err < 0)
                 return err;
         dummy->pcm = pcm;
-        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_card_dummy_playback_ops);
-        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_card_dummy_capture_ops);
+        if (fake_buffer)
+                ops = &dummy_pcm_ops_no_buf;
+        else
+                ops = &dummy_pcm_ops;
+        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, ops);
+        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, ops);
         pcm->private_data = dummy;
         pcm->info_flags = 0;
         strcpy(pcm->name, "Dummy PCM");
-        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS,
-                                              snd_dma_continuous_data(GFP_KERNEL),
-                                              0, 64*1024);
+        if (!fake_buffer) {
+                snd_pcm_lib_preallocate_pages_for_all(pcm,
+                        SNDRV_DMA_TYPE_CONTINUOUS,
+                        snd_dma_continuous_data(GFP_KERNEL),
+                        0, 64*1024);
+        }
         return 0;
 }
 
+/*
+ * mixer interface
+ */
+
 #define DUMMY_VOLUME(xname, xindex, addr) \
 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
   .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ, \
@@ -581,6 +821,131 @@ static int __devinit snd_card_dummy_new_mixer(struct snd_dummy *dummy)
         return 0;
 }
 
+#if defined(CONFIG_SND_DEBUG) && defined(CONFIG_PROC_FS)
+/*
+ * proc interface
+ */
+static void print_formats(struct snd_info_buffer *buffer)
+{
+        int i;
+
+        for (i = 0; i < SNDRV_PCM_FORMAT_LAST; i++) {
+                if (dummy_pcm_hardware.formats & (1ULL << i))
+                        snd_iprintf(buffer, " %s", snd_pcm_format_name(i));
+        }
+}
+
+static void print_rates(struct snd_info_buffer *buffer)
+{
+        static int rates[] = {
+                5512, 8000, 11025, 16000, 22050, 32000, 44100, 48000,
+                64000, 88200, 96000, 176400, 192000,
+        };
+        int i;
+
+        if (dummy_pcm_hardware.rates & SNDRV_PCM_RATE_CONTINUOUS)
+                snd_iprintf(buffer, " continuous");
+        if (dummy_pcm_hardware.rates & SNDRV_PCM_RATE_KNOT)
+                snd_iprintf(buffer, " knot");
+        for (i = 0; i < ARRAY_SIZE(rates); i++)
+                if (dummy_pcm_hardware.rates & (1 << i))
+                        snd_iprintf(buffer, " %d", rates[i]);
+}
+
+#define get_dummy_int_ptr(ofs) \
+        (unsigned int *)((char *)&dummy_pcm_hardware + (ofs))
+#define get_dummy_ll_ptr(ofs) \
+        (unsigned long long *)((char *)&dummy_pcm_hardware + (ofs))
+
+struct dummy_hw_field {
+        const char *name;
+        const char *format;
+        unsigned int offset;
+        unsigned int size;
+};
+#define FIELD_ENTRY(item, fmt) {                   \
+        .name = #item,                             \
+        .format = fmt,                             \
+        .offset = offsetof(struct snd_pcm_hardware, item), \
+        .size = sizeof(dummy_pcm_hardware.item) }
+
+static struct dummy_hw_field fields[] = {
+        FIELD_ENTRY(formats, "%#llx"),
+        FIELD_ENTRY(rates, "%#x"),
+        FIELD_ENTRY(rate_min, "%d"),
+        FIELD_ENTRY(rate_max, "%d"),
+        FIELD_ENTRY(channels_min, "%d"),
+        FIELD_ENTRY(channels_max, "%d"),
+        FIELD_ENTRY(buffer_bytes_max, "%ld"),
+        FIELD_ENTRY(period_bytes_min, "%ld"),
+        FIELD_ENTRY(period_bytes_max, "%ld"),
+        FIELD_ENTRY(periods_min, "%d"),
+        FIELD_ENTRY(periods_max, "%d"),
+};
+
+static void dummy_proc_read(struct snd_info_entry *entry,
+                            struct snd_info_buffer *buffer)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(fields); i++) {
+                snd_iprintf(buffer, "%s ", fields[i].name);
+                if (fields[i].size == sizeof(int))
+                        snd_iprintf(buffer, fields[i].format,
+                                    *get_dummy_int_ptr(fields[i].offset));
+                else
+                        snd_iprintf(buffer, fields[i].format,
+                                    *get_dummy_ll_ptr(fields[i].offset));
+                if (!strcmp(fields[i].name, "formats"))
+                        print_formats(buffer);
+                else if (!strcmp(fields[i].name, "rates"))
+                        print_rates(buffer);
+                snd_iprintf(buffer, "\n");
+        }
+}
+
+static void dummy_proc_write(struct snd_info_entry *entry,
+                             struct snd_info_buffer *buffer)
+{
+        char line[64];
+
+        while (!snd_info_get_line(buffer, line, sizeof(line))) {
+                char item[20];
+                const char *ptr;
+                unsigned long long val;
+                int i;
+
+                ptr = snd_info_get_str(item, line, sizeof(item));
+                for (i = 0; i < ARRAY_SIZE(fields); i++) {
+                        if (!strcmp(item, fields[i].name))
+                                break;
+                }
+                if (i >= ARRAY_SIZE(fields))
+                        continue;
+                snd_info_get_str(item, ptr, sizeof(item));
+                if (strict_strtoull(item, 0, &val))
+                        continue;
+                if (fields[i].size == sizeof(int))
+                        *get_dummy_int_ptr(fields[i].offset) = val;
+                else
+                        *get_dummy_ll_ptr(fields[i].offset) = val;
+        }
+}
+
+static void __devinit dummy_proc_init(struct snd_dummy *chip)
+{
+        struct snd_info_entry *entry;
+
+        if (!snd_card_proc_new(chip->card, "dummy_pcm", &entry)) {
+                snd_info_set_text_ops(entry, chip, dummy_proc_read);
+                entry->c.text.write = dummy_proc_write;
+                entry->mode |= S_IWUSR;
+        }
+}
+#else
+#define dummy_proc_init(x)
+#endif /* CONFIG_SND_DEBUG && CONFIG_PROC_FS */
+
 static int __devinit snd_dummy_probe(struct platform_device *devptr)
 {
         struct snd_card *card;
@@ -610,6 +975,8 @@ static int __devinit snd_dummy_probe(struct platform_device *devptr)
         strcpy(card->shortname, "Dummy");
         sprintf(card->longname, "Dummy %i", dev + 1);
 
+        dummy_proc_init(dummy);
+
         snd_card_set_dev(card, &devptr->dev);
 
         err = snd_card_register(card);
@@ -670,6 +1037,7 @@ static void snd_dummy_unregister_all(void)
         for (i = 0; i < ARRAY_SIZE(devices); ++i)
                 platform_device_unregister(devices[i]);
         platform_driver_unregister(&snd_dummy_driver);
+        free_fake_buffer();
 }
 
 static int __init alsa_card_dummy_init(void)
@@ -680,6 +1048,12 @@ static int __init alsa_card_dummy_init(void)
         if (err < 0)
                 return err;
 
+        err = alloc_fake_buffer();
+        if (err < 0) {
+                platform_driver_unregister(&snd_dummy_driver);
+                return err;
+        }
+
         cards = 0;
         for (i = 0; i < SNDRV_CARDS; i++) {
                 struct platform_device *device;
diff --git a/sound/isa/cmi8330.c b/sound/isa/cmi8330.c
index de83608719ea..02f79d252718 100644
--- a/sound/isa/cmi8330.c
+++ b/sound/isa/cmi8330.c
@@ -1,5 +1,5 @@
 /*
- *  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
  *
@@ -35,7 +35,7 @@
  *
  *  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.
  *  The utilities in alsa-utils are aware of both devices, so passing
@@ -64,7 +64,7 @@
 /*
  */
 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}}}");
 
@@ -86,38 +86,38 @@ static long mpuport[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
 static int mpuirq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ;
 
 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);
 MODULE_PARM_DESC(isapnp, "PnP detection for specified soundcard.");
 #endif
 
 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;
 static int pnp_registered;
@@ -156,6 +156,11 @@ static unsigned char snd_cmi8330_image[((CMI8330_CDINGAIN)-16) + 1] =
 
 typedef int (*snd_pcm_open_callback_t)(struct snd_pcm_substream *);
 
+enum card_type {
+        CMI8330,
+        CMI8329
+};
+
 struct snd_cmi8330 {
 #ifdef CONFIG_PNP
         struct pnp_dev *cap;
@@ -172,11 +177,14 @@ struct snd_cmi8330 {
                 snd_pcm_open_callback_t open;
                 void *private_data; /* sb or wss */
         } streams[2];
+
+        enum card_type type;
 };
 
 #ifdef CONFIG_PNP
 
 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 = "" }
 };
@@ -304,7 +312,7 @@ static int __devinit snd_cmi8330_mixer(struct snd_card *card, struct snd_cmi8330
         unsigned int idx;
         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++) {
                 err = snd_ctl_add(card,
@@ -329,6 +337,9 @@ static int __devinit snd_cmi8330_pnp(int dev, struct snd_cmi8330 *acard,
         struct pnp_dev *pdev;
         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)
                 return -EBUSY;
@@ -338,45 +349,52 @@ static int __devinit snd_cmi8330_pnp(int dev, struct snd_cmi8330 *acard,
                 return -EBUSY;
 
         acard->mpu = pnp_request_card_device(card, id->devs[2].id, NULL);
-        if (acard->play == NULL)
+        if (acard->mpu == NULL)
                 return -EBUSY;
 
         pdev = acard->cap;
 
         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;
         }
         wssport[dev] = pnp_port_start(pdev, 0);
         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 */
         pdev = acard->play;
 
         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;
         }
         sbport[dev] = pnp_port_start(pdev, 0);
         sbdma8[dev] = pnp_dma(pdev, 0);
         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 */
         pdev = acard->mpu;
 
         err = pnp_activate_dev(pdev);
-        if (err < 0) {
-                snd_printk(KERN_ERR
-                           "CMI8330/C3D (MPU-401) PnP configure failure\n");
-                return -EBUSY;
+        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);
         }
-        mpuport[dev] = pnp_port_start(pdev, 0);
-        mpuirq[dev] = pnp_irq(pdev, 0);
         return 0;
 }
 #endif
@@ -430,9 +448,9 @@ static int __devinit snd_cmi8330_pcm(struct snd_card *card, struct snd_cmi8330 *
                 snd_cmi8330_capture_open
         };
 
-        if ((err = snd_pcm_new(card, "CMI8330", 0, 1, 1, &pcm)) < 0)
+        if ((err = snd_pcm_new(card, (chip->type == CMI8329) ? "CMI8329" : "CMI8330", 0, 1, 1, &pcm)) < 0)
                 return err;
-        strcpy(pcm->name, "CMI8330");
+        strcpy(pcm->name, (chip->type == CMI8329) ? "CMI8329" : "CMI8330");
         pcm->private_data = chip;
         
         /* SB16 */
@@ -527,11 +545,11 @@ static int __devinit snd_cmi8330_probe(struct snd_card *card, int dev)
                              wssdma[dev], -1,
                              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;
         }
 
@@ -541,11 +559,11 @@ static int __devinit snd_cmi8330_probe(struct snd_card *card, int dev)
                                     sbdma8[dev],
                                     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;
         }
 
@@ -585,8 +603,8 @@ static int __devinit snd_cmi8330_probe(struct snd_card *card, int dev)
                                 mpuport[dev]);
         }
 
-        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,
                 acard->wss->port,
diff --git a/sound/isa/gus/gus_pcm.c b/sound/isa/gus/gus_pcm.c
index edb11eefdfe3..2dcf45bf7293 100644
--- a/sound/isa/gus/gus_pcm.c
+++ b/sound/isa/gus/gus_pcm.c
@@ -795,13 +795,13 @@ static int snd_gf1_pcm_volume_put(struct snd_kcontrol *kcontrol, struct snd_ctl_
                 if (!(pcmp->flags & SNDRV_GF1_PCM_PFLG_ACTIVE))
                         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);
                 vol = pvoice == pcmp->pvoices[0] ? gus->gf1.pcm_volume_level_left : gus->gf1.pcm_volume_level_right;
                 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);
         return change;
diff --git a/sound/mips/hal2.c b/sound/mips/hal2.c
index c52691c2fc46..9a88cdfd952a 100644
--- a/sound/mips/hal2.c
+++ b/sound/mips/hal2.c
@@ -915,7 +915,7 @@ static int __devinit hal2_probe(struct platform_device *pdev)
         return 0;
 }
 
-static int __exit hal2_remove(struct platform_device *pdev)
+static int __devexit hal2_remove(struct platform_device *pdev)
 {
         struct snd_card *card = platform_get_drvdata(pdev);
 
diff --git a/sound/mips/sgio2audio.c b/sound/mips/sgio2audio.c
index e497525bc11b..8691f4cf6191 100644
--- a/sound/mips/sgio2audio.c
+++ b/sound/mips/sgio2audio.c
@@ -973,7 +973,7 @@ static int __devinit snd_sgio2audio_probe(struct platform_device *pdev)
         return 0;
 }
 
-static int __exit snd_sgio2audio_remove(struct platform_device *pdev)
+static int __devexit snd_sgio2audio_remove(struct platform_device *pdev)
 {
         struct snd_card *card = platform_get_drvdata(pdev);
 
diff --git a/sound/oss/aedsp16.c b/sound/oss/aedsp16.c
index 3ee9900ffd7b..35b5912cf3f8 100644
--- a/sound/oss/aedsp16.c
+++ b/sound/oss/aedsp16.c
@@ -325,8 +325,9 @@
 /*
  * Size of character arrays that store name and version of sound card
  */
-#define CARDNAMELEN 15          /* Size of the card's name in chars     */
-#define CARDVERLEN  2           /* Size of the card's version in chars  */
+#define CARDNAMELEN     15      /* Size of the card's name in chars     */
+#define CARDVERLEN      10      /* Size of the card's version in chars  */
+#define CARDVERDIGITS   2       /* Number of digits in the version      */
 
 #if defined(CONFIG_SC6600)
 /*
@@ -410,7 +411,7 @@
 
 static int      soft_cfg __initdata = 0;        /* bitmapped config */
 static int      soft_cfg_mss __initdata = 0;    /* bitmapped mss config */
-static int      ver[CARDVERLEN] __initdata = {0, 0};    /* DSP Ver:
+static int      ver[CARDVERDIGITS] __initdata = {0, 0}; /* DSP Ver:
                                                    hi->ver[0] lo->ver[1] */
 
 #if defined(CONFIG_SC6600)
@@ -957,7 +958,7 @@ static int __init aedsp16_dsp_version(int port)
          * string is finished.
          */
                 ver[len++] = ret;
-          } while (len < CARDVERLEN);
+          } while (len < CARDVERDIGITS);
         sprintf(DSPVersion, "%d.%d", ver[0], ver[1]);
 
         DBG(("success.\n"));
diff --git a/sound/oss/kahlua.c b/sound/oss/kahlua.c
index c180598f1710..89466b056be7 100644
--- a/sound/oss/kahlua.c
+++ b/sound/oss/kahlua.c
@@ -199,7 +199,7 @@ MODULE_LICENSE("GPL");
  */
 
 static struct pci_device_id id_tbl[] = {
-        { PCI_VENDOR_ID_CYRIX, PCI_DEVICE_ID_CYRIX_5530_AUDIO, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
+        { PCI_VDEVICE(CYRIX, PCI_DEVICE_ID_CYRIX_5530_AUDIO), 0 },
         { }
 };
 
diff --git a/sound/oss/midibuf.c b/sound/oss/midibuf.c
index a40be0cf1d97..782b3b84dac6 100644
--- a/sound/oss/midibuf.c
+++ b/sound/oss/midibuf.c
@@ -127,15 +127,16 @@ static void midi_poll(unsigned long dummy)
                 for (dev = 0; dev < num_midis; dev++)
                         if (midi_devs[dev] != NULL && midi_out_buf[dev] != NULL)
                         {
-                                int ok = 1;
-
-                                while (DATA_AVAIL(midi_out_buf[dev]) && ok)
+                                while (DATA_AVAIL(midi_out_buf[dev]))
                                 {
+                                        int ok;
                                         int c = midi_out_buf[dev]->queue[midi_out_buf[dev]->head];
 
                                         spin_unlock_irqrestore(&lock,flags);/* Give some time to others */
                                         ok = midi_devs[dev]->outputc(dev, c);
                                         spin_lock_irqsave(&lock, flags);
+                                        if (!ok)
+                                                break;
                                         midi_out_buf[dev]->head = (midi_out_buf[dev]->head + 1) % MAX_QUEUE_SIZE;
                                         midi_out_buf[dev]->len--;
                                 }
diff --git a/sound/oss/mpu401.c b/sound/oss/mpu401.c
index 6c0a770ed054..734b8f9e2f78 100644
--- a/sound/oss/mpu401.c
+++ b/sound/oss/mpu401.c
@@ -926,31 +926,21 @@ static struct midi_operations mpu401_midi_operations[MAX_MIDI_DEV];
 static void mpu401_chk_version(int n, struct mpu_config *devc)
 {
         int tmp;
-        unsigned long flags;
 
         devc->version = devc->revision = 0;
 
-        spin_lock_irqsave(&devc->lock,flags);
-        if ((tmp = mpu_cmd(n, 0xAC, 0)) < 0)
-        {
-                spin_unlock_irqrestore(&devc->lock,flags);
+        tmp = mpu_cmd(n, 0xAC, 0);
+        if (tmp < 0)
                 return;
-        }
         if ((tmp & 0xf0) > 0x20)        /* Why it's larger than 2.x ??? */
-        {
-                spin_unlock_irqrestore(&devc->lock,flags);
                 return;
-        }
         devc->version = tmp;
 
-        if ((tmp = mpu_cmd(n, 0xAD, 0)) < 0)
-        {
+        if ((tmp = mpu_cmd(n, 0xAD, 0)) < 0) {
                 devc->version = 0;
-                spin_unlock_irqrestore(&devc->lock,flags);
                 return;
         }
         devc->revision = tmp;
-        spin_unlock_irqrestore(&devc->lock,flags);
 }
 
 int attach_mpu401(struct address_info *hw_config, struct module *owner)
@@ -1084,7 +1074,7 @@ int attach_mpu401(struct address_info *hw_config, struct module *owner)
                         sprintf(mpu_synth_info[m].name, "%s (MPU401)", hw_config->name);
                 else
                         sprintf(mpu_synth_info[m].name,
-                                "MPU-401 %d.%d%c Midi interface #%d",
+                                "MPU-401 %d.%d%c MIDI #%d",
                                 (int) (devc->version & 0xf0) >> 4,
                                 devc->version & 0x0f,
                                 revision_char,
diff --git a/sound/oss/vwsnd.c b/sound/oss/vwsnd.c
index 187f72750e8f..6713110bdc75 100644
--- a/sound/oss/vwsnd.c
+++ b/sound/oss/vwsnd.c
@@ -628,7 +628,7 @@ static void li_setup_dma(dma_chan_t *chan,
         ASSERT(!(buffer_paddr & 0xFF));
         chan->baseval = (buffer_paddr >> 8) | 1 << (37 - 8);
 
-        chan->cfgval = (!LI_CCFG_LOCK |
+        chan->cfgval = ((chan->cfgval & ~LI_CCFG_LOCK) |
                         SHIFT_FIELD(desc->ad1843_slot, LI_CCFG_SLOT) |
                         desc->direction |
                         mode |
@@ -638,9 +638,9 @@ static void li_setup_dma(dma_chan_t *chan,
         tmask = 13 - fragshift;         /* See Lithium DMA Notes above. */
         ASSERT(size >= 2 && size <= 7);
         ASSERT(tmask >= 1 && tmask <= 7);
-        chan->ctlval = (!LI_CCTL_RESET |
+        chan->ctlval = ((chan->ctlval & ~LI_CCTL_RESET) |
                         SHIFT_FIELD(size, LI_CCTL_SIZE) |
-                        !LI_CCTL_DMA_ENABLE |
+                        (chan->ctlval & ~LI_CCTL_DMA_ENABLE) |
                         SHIFT_FIELD(tmask, LI_CCTL_TMASK) |
                         SHIFT_FIELD(0, LI_CCTL_TPTR));
 
diff --git a/sound/pci/Kconfig b/sound/pci/Kconfig
index 748f6b7d90b7..fb5ee3cc3968 100644
--- a/sound/pci/Kconfig
+++ b/sound/pci/Kconfig
@@ -135,11 +135,11 @@ config SND_AW2
 
 
 config SND_AZT3328
-        tristate "Aztech AZF3328 / PCI168 (EXPERIMENTAL)"
-        depends on EXPERIMENTAL
+        tristate "Aztech AZF3328 / PCI168"
         select SND_OPL3_LIB
         select SND_MPU401_UART
         select SND_PCM
+        select SND_RAWMIDI
         help
           Say Y here to include support for Aztech AZF3328 (PCI168)
           soundcards.
diff --git a/sound/pci/ali5451/ali5451.c b/sound/pci/ali5451/ali5451.c
index c551006e2920..b458d208720b 100644
--- a/sound/pci/ali5451/ali5451.c
+++ b/sound/pci/ali5451/ali5451.c
@@ -310,12 +310,16 @@ static int snd_ali_codec_ready(struct snd_ali *codec,
         unsigned int res;
         
         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 ");
         return -EIO;
@@ -327,15 +331,17 @@ static int snd_ali_stimer_ready(struct snd_ali *codec)
         unsigned long dwChk1,dwChk2;
         
         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;
 }
@@ -472,45 +478,6 @@ static int snd_ali_reset_5451(struct snd_ali *codec)
         return 0;
 }
 
-#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
  */
@@ -555,22 +522,6 @@ static void snd_ali_disable_address_interrupt(struct snd_ali *codec)
         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,
                                       unsigned int channel)
 {
@@ -671,16 +622,6 @@ static void snd_ali_free_channel_pcm(struct snd_ali *codec, int channel)
         }
 }
 
-#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)
 {
         unsigned int mask = 1 << (channel & 0x1f);
diff --git a/sound/pci/atiixp.c b/sound/pci/atiixp.c
index 71515ddb4593..d6752dff2a44 100644
--- a/sound/pci/atiixp.c
+++ b/sound/pci/atiixp.c
@@ -287,10 +287,10 @@ struct atiixp {
 /*
  */
 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, }
 };
 
diff --git a/sound/pci/atiixp_modem.c b/sound/pci/atiixp_modem.c
index c3136cccc559..e7e147bf8eb2 100644
--- a/sound/pci/atiixp_modem.c
+++ b/sound/pci/atiixp_modem.c
@@ -262,8 +262,8 @@ struct atiixp_modem {
 /*
  */
 static struct pci_device_id snd_atiixp_ids[] = {
-        { 0x1002, 0x434d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, /* SB200 */
-        { 0x1002, 0x4378, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, /* SB400 */
+        { PCI_VDEVICE(ATI, 0x434d), 0 }, /* SB200 */
+        { PCI_VDEVICE(ATI, 0x4378), 0 }, /* SB400 */
         { 0, }
 };
 
diff --git a/sound/pci/au88x0/au8810.c b/sound/pci/au88x0/au8810.c
index fce22c7af0ea..c0e8c6b295cb 100644
--- a/sound/pci/au88x0/au8810.c
+++ b/sound/pci/au88x0/au8810.c
@@ -1,8 +1,7 @@
 #include "au8810.h"
 #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,}
 };
 
diff --git a/sound/pci/au88x0/au8820.c b/sound/pci/au88x0/au8820.c
index d1fbcce07257..a6527330df58 100644
--- a/sound/pci/au88x0/au8820.c
+++ b/sound/pci/au88x0/au8820.c
@@ -1,8 +1,7 @@
 #include "au8820.h"
 #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,}
 };
 
diff --git a/sound/pci/au88x0/au8830.c b/sound/pci/au88x0/au8830.c
index d4f2717c14fb..6c702ad4352a 100644
--- a/sound/pci/au88x0/au8830.c
+++ b/sound/pci/au88x0/au8830.c
@@ -1,8 +1,7 @@
 #include "au8830.h"
 #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,}
 };
 
diff --git a/sound/pci/azt3328.c b/sound/pci/azt3328.c
index f290bc56178f..8451a0169f32 100644
--- a/sound/pci/azt3328.c
+++ b/sound/pci/azt3328.c
@@ -1,6 +1,6 @@
 /*
  *  azt3328.c - driver for Aztech AZF3328 based soundcards (e.g. PCI168).
- *  Copyright (C) 2002, 2005 - 2008 by Andreas Mohr <andi AT lisas.de>
+ *  Copyright (C) 2002, 2005 - 2009 by Andreas Mohr <andi AT lisas.de>
  *
  *  Framework borrowed from Bart Hartgers's als4000.c.
  *  Driver developed on PCI168 AP(W) version (PCI rev. 10, subsystem ID 1801),
@@ -10,6 +10,13 @@
  *  PCI168 A/AP, sub ID 8000
  *  Please give me feedback in case you try my driver with one of these!!
  *
+ *  Keywords: Windows XP Vista 168nt4-125.zip 168win95-125.zip PCI 168 download
+ *  (XP/Vista do not support this card at all but every Linux distribution
+ *   has very good support out of the box;
+ *   just to make sure that the right people hit this and get to know that,
+ *   despite the high level of Internet ignorance - as usual :-P -
+ *   about very good support for this card - on Linux!)
+ *
  * GPL LICENSE
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -71,10 +78,11 @@
  *  - built-in General DirectX timer having a 20 bits counter
  *    with 1us resolution (see below!)
  *  - I2S serial output port for external DAC
+ *    [FIXME: 3.3V or 5V level? maximum rate is 66.2kHz right?]
  *  - supports 33MHz PCI spec 2.1, PCI power management 1.0, compliant with ACPI
  *  - supports hardware volume control
  *  - single chip low cost solution (128 pin QFP)
- *  - supports programmable Sub-vendor and Sub-system ID
+ *  - supports programmable Sub-vendor and Sub-system ID [24C02 SEEPROM chip]
  *    required for Microsoft's logo compliance (FIXME: where?)
  *    At least the Trident 4D Wave DX has one bit somewhere
  *    to enable writes to PCI subsystem VID registers, that should be it.
@@ -82,6 +90,7 @@
  *    some custom data starting at 0x80. What kind of config settings
  *    are located in our extended PCI space anyway??
  *  - PCI168 AP(W) card: power amplifier with 4 Watts/channel at 4 Ohms
+ *    [TDA1517P chip]
  *
  *  Note that this driver now is actually *better* than the Windows driver,
  *  since it additionally supports the card's 1MHz DirectX timer - just try
@@ -146,10 +155,15 @@
  *    to read the Digital Enhanced Game Port. Not sure whether it is fixable.
  *
  * TODO
+ *  - use PCI_VDEVICE
+ *  - verify driver status on x86_64
+ *  - test multi-card driver operation
+ *  - (ab)use 1MHz DirectX timer as kernel clocksource
  *  - test MPU401 MIDI playback etc.
  *  - add more power micro-management (disable various units of the card
- *    as long as they're unused). However this requires more I/O ports which I
- *    haven't figured out yet and which thus might not even exist...
+ *    as long as they're unused, to improve audio quality and save power).
+ *    However this requires more I/O ports which I haven't figured out yet
+ *    and which thus might not even exist...
  *    The standard suspend/resume functionality could probably make use of
  *    some improvement, too...
  *  - figure out what all unknown port bits are responsible for
@@ -185,25 +199,46 @@ MODULE_SUPPORTED_DEVICE("{{Aztech,AZF3328}}");
 #define SUPPORT_GAMEPORT 1
 #endif
 
+/* === Debug settings ===
+  Further diagnostic functionality than the settings below
+  does not need to be provided, since one can easily write a bash script
+  to dump the card's I/O ports (those listed in lspci -v -v):
+  function dump()
+  {
+    local descr=$1; local addr=$2; local count=$3
+
+    echo "${descr}: ${count} @ ${addr}:"
+    dd if=/dev/port skip=$[${addr}] count=${count} bs=1 2>/dev/null| hexdump -C
+  }
+  and then use something like
+  "dump joy200 0x200 8", "dump mpu388 0x388 4", "dump joy 0xb400 8",
+  "dump codec00 0xa800 32", "dump mixer 0xb800 64", "dump synth 0xbc00 8",
+  possibly within a "while true; do ... sleep 1; done" loop.
+  Tweaking ports could be done using
+  VALSTRING="`printf "%02x" $value`"
+  printf "\x""$VALSTRING"|dd of=/dev/port seek=$[${addr}] bs=1 2>/dev/null
+*/
+
 #define DEBUG_MISC      0
 #define DEBUG_CALLS     0
 #define DEBUG_MIXER     0
-#define DEBUG_PLAY_REC  0
+#define DEBUG_CODEC     0
 #define DEBUG_IO        0
 #define DEBUG_TIMER     0
 #define DEBUG_GAME      0
+#define DEBUG_PM        0
 #define MIXER_TESTING   0
 
 #if DEBUG_MISC
-#define snd_azf3328_dbgmisc(format, args...) printk(KERN_ERR format, ##args)
+#define snd_azf3328_dbgmisc(format, args...) printk(KERN_DEBUG format, ##args)
 #else
 #define snd_azf3328_dbgmisc(format, args...)
 #endif
 
 #if DEBUG_CALLS
 #define snd_azf3328_dbgcalls(format, args...) printk(format, ##args)
-#define snd_azf3328_dbgcallenter() printk(KERN_ERR "--> %s\n", __func__)
-#define snd_azf3328_dbgcallleave() printk(KERN_ERR "<-- %s\n", __func__)
+#define snd_azf3328_dbgcallenter() printk(KERN_DEBUG "--> %s\n", __func__)
+#define snd_azf3328_dbgcallleave() printk(KERN_DEBUG "<-- %s\n", __func__)
 #else
 #define snd_azf3328_dbgcalls(format, args...)
 #define snd_azf3328_dbgcallenter()
@@ -216,10 +251,10 @@ MODULE_SUPPORTED_DEVICE("{{Aztech,AZF3328}}");
 #define snd_azf3328_dbgmixer(format, args...)
 #endif
 
-#if DEBUG_PLAY_REC
-#define snd_azf3328_dbgplay(format, args...) printk(KERN_DEBUG format, ##args)
+#if DEBUG_CODEC
+#define snd_azf3328_dbgcodec(format, args...) printk(KERN_DEBUG format, ##args)
 #else
-#define snd_azf3328_dbgplay(format, args...)
+#define snd_azf3328_dbgcodec(format, args...)
 #endif
 
 #if DEBUG_MISC
@@ -234,6 +269,12 @@ MODULE_SUPPORTED_DEVICE("{{Aztech,AZF3328}}");
 #define snd_azf3328_dbggame(format, args...)
 #endif
 
+#if DEBUG_PM
+#define snd_azf3328_dbgpm(format, args...) printk(KERN_DEBUG format, ##args)
+#else
+#define snd_azf3328_dbgpm(format, args...)
+#endif
+
 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
 module_param_array(index, int, NULL, 0444);
 MODULE_PARM_DESC(index, "Index value for AZF3328 soundcard.");
@@ -250,22 +291,23 @@ static int seqtimer_scaling = 128;
 module_param(seqtimer_scaling, int, 0444);
 MODULE_PARM_DESC(seqtimer_scaling, "Set 1024000Hz sequencer timer scale factor (lockup danger!). Default 128.");
 
-struct snd_azf3328_audio_stream {
+struct snd_azf3328_codec_data {
+        unsigned long io_base;
         struct snd_pcm_substream *substream;
-        int enabled;
-        int running;
-        unsigned long portbase;
+        bool running;
+        const char *name;
 };
 
-enum snd_azf3328_stream_index {
-  AZF_PLAYBACK = 0,
-  AZF_CAPTURE = 1,
+enum snd_azf3328_codec_type {
+  AZF_CODEC_PLAYBACK = 0,
+  AZF_CODEC_CAPTURE = 1,
+  AZF_CODEC_I2S_OUT = 2,
 };
 
 struct snd_azf3328 {
         /* often-used fields towards beginning, then grouped */
 
-        unsigned long codec_io; /* usually 0xb000, size 128 */
+        unsigned long ctrl_io; /* usually 0xb000, size 128 */
         unsigned long game_io;  /* usually 0xb400, size 8 */
         unsigned long mpu_io;   /* usually 0xb800, size 4 */
         unsigned long opl3_io; /* usually 0xbc00, size 8 */
@@ -275,15 +317,17 @@ struct snd_azf3328 {
 
         struct snd_timer *timer;
 
-        struct snd_pcm *pcm;
-        struct snd_azf3328_audio_stream audio_stream[2];
+        struct snd_pcm *pcm[3];
+
+        /* playback, recording and I2S out codecs */
+        struct snd_azf3328_codec_data codecs[3];
 
         struct snd_card *card;
         struct snd_rawmidi *rmidi;
 
 #ifdef SUPPORT_GAMEPORT
         struct gameport *gameport;
-        int axes[4];
+        u16 axes[4];
 #endif
 
         struct pci_dev *pci;
@@ -293,16 +337,16 @@ struct snd_azf3328 {
          * If we need to add more registers here, then we might try to fold this
          * into some transparent combined shadow register handling with
          * CONFIG_PM register storage below, but that's slightly difficult. */
-        u16 shadow_reg_codec_6AH;
+        u16 shadow_reg_ctrl_6AH;
 
 #ifdef CONFIG_PM
         /* register value containers for power management
-         * Note: not always full I/O range preserved (just like Win driver!) */
-        u16 saved_regs_codec[AZF_IO_SIZE_CODEC_PM / 2];
-        u16 saved_regs_game [AZF_IO_SIZE_GAME_PM / 2];
-        u16 saved_regs_mpu  [AZF_IO_SIZE_MPU_PM / 2];
-        u16 saved_regs_opl3 [AZF_IO_SIZE_OPL3_PM / 2];
-        u16 saved_regs_mixer[AZF_IO_SIZE_MIXER_PM / 2];
+         * Note: not always full I/O range preserved (similar to Win driver!) */
+        u32 saved_regs_ctrl[AZF_ALIGN(AZF_IO_SIZE_CTRL_PM) / 4];
+        u32 saved_regs_game[AZF_ALIGN(AZF_IO_SIZE_GAME_PM) / 4];
+        u32 saved_regs_mpu[AZF_ALIGN(AZF_IO_SIZE_MPU_PM) / 4];
+        u32 saved_regs_opl3[AZF_ALIGN(AZF_IO_SIZE_OPL3_PM) / 4];
+        u32 saved_regs_mixer[AZF_ALIGN(AZF_IO_SIZE_MIXER_PM) / 4];
 #endif
 };
 
@@ -316,7 +360,7 @@ MODULE_DEVICE_TABLE(pci, snd_azf3328_ids);
 
 
 static int
-snd_azf3328_io_reg_setb(unsigned reg, u8 mask, int do_set)
+snd_azf3328_io_reg_setb(unsigned reg, u8 mask, bool do_set)
 {
         u8 prev = inb(reg), new;
 
@@ -331,39 +375,72 @@ snd_azf3328_io_reg_setb(unsigned reg, u8 mask, int do_set)
 }
 
 static inline void
-snd_azf3328_codec_outb(const struct snd_azf3328 *chip, unsigned reg, u8 value)
+snd_azf3328_codec_outb(const struct snd_azf3328_codec_data *codec,
+                       unsigned reg,
+                       u8 value
+)
 {
-        outb(value, chip->codec_io + reg);
+        outb(value, codec->io_base + reg);
 }
 
 static inline u8
-snd_azf3328_codec_inb(const struct snd_azf3328 *chip, unsigned reg)
+snd_azf3328_codec_inb(const struct snd_azf3328_codec_data *codec, unsigned reg)
 {
-        return inb(chip->codec_io + reg);
+        return inb(codec->io_base + reg);
 }
 
 static inline void
-snd_azf3328_codec_outw(const struct snd_azf3328 *chip, unsigned reg, u16 value)
+snd_azf3328_codec_outw(const struct snd_azf3328_codec_data *codec,
+                       unsigned reg,
+                       u16 value
+)
 {
-        outw(value, chip->codec_io + reg);
+        outw(value, codec->io_base + reg);
 }
 
 static inline u16
-snd_azf3328_codec_inw(const struct snd_azf3328 *chip, unsigned reg)
+snd_azf3328_codec_inw(const struct snd_azf3328_codec_data *codec, unsigned reg)
 {
-        return inw(chip->codec_io + reg);
+        return inw(codec->io_base + reg);
 }
 
 static inline void
-snd_azf3328_codec_outl(const struct snd_azf3328 *chip, unsigned reg, u32 value)
+snd_azf3328_codec_outl(const struct snd_azf3328_codec_data *codec,
+                       unsigned reg,
+                       u32 value
+)
 {
-        outl(value, chip->codec_io + reg);
+        outl(value, codec->io_base + reg);
 }
 
 static inline u32
-snd_azf3328_codec_inl(const struct snd_azf3328 *chip, unsigned reg)
+snd_azf3328_codec_inl(const struct snd_azf3328_codec_data *codec, unsigned reg)
+{
+        return inl(codec->io_base + reg);
+}
+
+static inline void
+snd_azf3328_ctrl_outb(const struct snd_azf3328 *chip, unsigned reg, u8 value)
+{
+        outb(value, chip->ctrl_io + reg);
+}
+
+static inline u8
+snd_azf3328_ctrl_inb(const struct snd_azf3328 *chip, unsigned reg)
+{
+        return inb(chip->ctrl_io + reg);
+}
+
+static inline void
+snd_azf3328_ctrl_outw(const struct snd_azf3328 *chip, unsigned reg, u16 value)
+{
+        outw(value, chip->ctrl_io + reg);
+}
+
+static inline void
+snd_azf3328_ctrl_outl(const struct snd_azf3328 *chip, unsigned reg, u32 value)
 {
-        return inl(chip->codec_io + reg);
+        outl(value, chip->ctrl_io + reg);
 }
 
 static inline void
@@ -404,13 +481,13 @@ snd_azf3328_mixer_inw(const struct snd_azf3328 *chip, unsigned reg)
 
 #define AZF_MUTE_BIT 0x80
 
-static int
+static bool
 snd_azf3328_mixer_set_mute(const struct snd_azf3328 *chip,
-                           unsigned reg, int do_mute
+                           unsigned reg, bool do_mute
 )
 {
         unsigned long portbase = chip->mixer_io + reg + 1;
-        int updated;
+        bool updated;
 
         /* the mute bit is on the *second* (i.e. right) register of a
          * left/right channel setting */
@@ -569,7 +646,7 @@ snd_azf3328_get_mixer(struct snd_kcontrol *kcontrol,
 {
         struct snd_azf3328 *chip = snd_kcontrol_chip(kcontrol);
         struct azf3328_mixer_reg reg;
-        unsigned int oreg, val;
+        u16 oreg, val;
 
         snd_azf3328_dbgcallenter();
         snd_azf3328_mixer_reg_decode(&reg, kcontrol->private_value);
@@ -600,7 +677,7 @@ snd_azf3328_put_mixer(struct snd_kcontrol *kcontrol,
 {
         struct snd_azf3328 *chip = snd_kcontrol_chip(kcontrol);
         struct azf3328_mixer_reg reg;
-        unsigned int oreg, nreg, val;
+        u16 oreg, nreg, val;
 
         snd_azf3328_dbgcallenter();
         snd_azf3328_mixer_reg_decode(&reg, kcontrol->private_value);
@@ -709,7 +786,7 @@ snd_azf3328_put_mixer_enum(struct snd_kcontrol *kcontrol,
 {
         struct snd_azf3328 *chip = snd_kcontrol_chip(kcontrol);
         struct azf3328_mixer_reg reg;
-        unsigned int oreg, nreg, val;
+        u16 oreg, nreg, val;
 
         snd_azf3328_mixer_reg_decode(&reg, kcontrol->private_value);
         oreg = snd_azf3328_mixer_inw(chip, reg.reg);
@@ -867,14 +944,15 @@ snd_azf3328_hw_free(struct snd_pcm_substream *substream)
 
 static void
 snd_azf3328_codec_setfmt(struct snd_azf3328 *chip,
-                               unsigned reg,
+                               enum snd_azf3328_codec_type codec_type,
                                enum azf_freq_t bitrate,
                                unsigned int format_width,
                                unsigned int channels
 )
 {
-        u16 val = 0xff00;
         unsigned long flags;
+        const struct snd_azf3328_codec_data *codec = &chip->codecs[codec_type];
+        u16 val = 0xff00;
 
         snd_azf3328_dbgcallenter();
         switch (bitrate) {
@@ -917,7 +995,7 @@ snd_azf3328_codec_setfmt(struct snd_azf3328 *chip,
         spin_lock_irqsave(&chip->reg_lock, flags);
 
         /* set bitrate/format */
-        snd_azf3328_codec_outw(chip, reg, val);
+        snd_azf3328_codec_outw(codec, IDX_IO_CODEC_SOUNDFORMAT, val);
 
         /* changing the bitrate/format settings switches off the
          * audio output with an annoying click in case of 8/16bit format change
@@ -926,11 +1004,11 @@ snd_azf3328_codec_setfmt(struct snd_azf3328 *chip,
          * (FIXME: yes, it works, but what exactly am I doing here?? :)
          * FIXME: does this have some side effects for full-duplex
          * or other dramatic side effects? */
-        if (reg == IDX_IO_PLAY_SOUNDFORMAT) /* only do it for playback */
-                snd_azf3328_codec_outw(chip, IDX_IO_PLAY_FLAGS,
-                        snd_azf3328_codec_inw(chip, IDX_IO_PLAY_FLAGS) |
-                        DMA_PLAY_SOMETHING1 |
-                        DMA_PLAY_SOMETHING2 |
+        if (codec_type == AZF_CODEC_PLAYBACK) /* only do it for playback */
+                snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS,
+                        snd_azf3328_codec_inw(codec, IDX_IO_CODEC_DMA_FLAGS) |
+                        DMA_RUN_SOMETHING1 |
+                        DMA_RUN_SOMETHING2 |
                         SOMETHING_ALMOST_ALWAYS_SET |
                         DMA_EPILOGUE_SOMETHING |
                         DMA_SOMETHING_ELSE
@@ -942,112 +1020,134 @@ snd_azf3328_codec_setfmt(struct snd_azf3328 *chip,
 
 static inline void
 snd_azf3328_codec_setfmt_lowpower(struct snd_azf3328 *chip,
-                            unsigned reg
+                            enum snd_azf3328_codec_type codec_type
 )
 {
         /* choose lowest frequency for low power consumption.
          * While this will cause louder noise due to rather coarse frequency,
          * it should never matter since output should always
          * get disabled properly when idle anyway. */
-        snd_azf3328_codec_setfmt(chip, reg, AZF_FREQ_4000, 8, 1);
+        snd_azf3328_codec_setfmt(chip, codec_type, AZF_FREQ_4000, 8, 1);
 }
 
 static void
-snd_azf3328_codec_reg_6AH_update(struct snd_azf3328 *chip,
+snd_azf3328_ctrl_reg_6AH_update(struct snd_azf3328 *chip,
                                         unsigned bitmask,
-                                        int enable
+                                        bool enable
 )
 {
-        if (enable)
-                chip->shadow_reg_codec_6AH &= ~bitmask;
+        bool do_mask = !enable;
+        if (do_mask)
+                chip->shadow_reg_ctrl_6AH |= bitmask;
         else
-                chip->shadow_reg_codec_6AH |= bitmask;
-        snd_azf3328_dbgplay("6AH_update mask 0x%04x enable %d: val 0x%04x\n",
-                        bitmask, enable, chip->shadow_reg_codec_6AH);
-        snd_azf3328_codec_outw(chip, IDX_IO_6AH, chip->shadow_reg_codec_6AH);
+                chip->shadow_reg_ctrl_6AH &= ~bitmask;
+        snd_azf3328_dbgcodec("6AH_update mask 0x%04x do_mask %d: val 0x%04x\n",
+                        bitmask, do_mask, chip->shadow_reg_ctrl_6AH);
+        snd_azf3328_ctrl_outw(chip, IDX_IO_6AH, chip->shadow_reg_ctrl_6AH);
 }
 
 static inline void
-snd_azf3328_codec_enable(struct snd_azf3328 *chip, int enable)
+snd_azf3328_ctrl_enable_codecs(struct snd_azf3328 *chip, bool enable)
 {
-        snd_azf3328_dbgplay("codec_enable %d\n", enable);
+        snd_azf3328_dbgcodec("codec_enable %d\n", enable);
         /* no idea what exactly is being done here, but I strongly assume it's
          * PM related */
-        snd_azf3328_codec_reg_6AH_update(
+        snd_azf3328_ctrl_reg_6AH_update(
                 chip, IO_6A_PAUSE_PLAYBACK_BIT8, enable
         );
 }
 
 static void
-snd_azf3328_codec_activity(struct snd_azf3328 *chip,
-                                enum snd_azf3328_stream_index stream_type,
-                                int enable
+snd_azf3328_ctrl_codec_activity(struct snd_azf3328 *chip,
+                                enum snd_azf3328_codec_type codec_type,
+                                bool enable
 )
 {
-        int need_change = (chip->audio_stream[stream_type].running != enable);
+        struct snd_azf3328_codec_data *codec = &chip->codecs[codec_type];
+        bool need_change = (codec->running != enable);
 
-        snd_azf3328_dbgplay(
-                "codec_activity: type %d, enable %d, need_change %d\n",
-                                stream_type, enable, need_change
+        snd_azf3328_dbgcodec(
+                "codec_activity: %s codec, enable %d, need_change %d\n",
+                                codec->name, enable, need_change
         );
         if (need_change) {
-                enum snd_azf3328_stream_index other =
-                        (stream_type == AZF_PLAYBACK) ?
-                                AZF_CAPTURE : AZF_PLAYBACK;
-                /* small check to prevent shutting down the other party
-                 * in case it's active */
-                if ((enable) || !(chip->audio_stream[other].running))
-                        snd_azf3328_codec_enable(chip, enable);
+                static const struct {
+                        enum snd_azf3328_codec_type other1;
+                        enum snd_azf3328_codec_type other2;
+                } peer_codecs[3] =
+                        { { AZF_CODEC_CAPTURE, AZF_CODEC_I2S_OUT },
+                          { AZF_CODEC_PLAYBACK, AZF_CODEC_I2S_OUT },
+                          { AZF_CODEC_PLAYBACK, AZF_CODEC_CAPTURE } };
+                bool call_function;
+
+                if (enable)
+                        /* if enable codec, call enable_codecs func
+                           to enable codec supply... */
+                        call_function = 1;
+                else {
+                        /* ...otherwise call enable_codecs func
+                           (which globally shuts down operation of codecs)
+                           only in case the other codecs are currently
+                           not active either! */
+                        call_function =
+                                ((!chip->codecs[peer_codecs[codec_type].other1]
+                                        .running)
+                             &&  (!chip->codecs[peer_codecs[codec_type].other2]
+                                        .running));
+                 }
+                 if (call_function)
+                        snd_azf3328_ctrl_enable_codecs(chip, enable);
 
                 /* ...and adjust clock, too
                  * (reduce noise and power consumption) */
                 if (!enable)
                         snd_azf3328_codec_setfmt_lowpower(
                                 chip,
-                                chip->audio_stream[stream_type].portbase
-                                        + IDX_IO_PLAY_SOUNDFORMAT
+                                codec_type
                         );
+                codec->running = enable;
         }
-        chip->audio_stream[stream_type].running = enable;
 }
 
 static void
-snd_azf3328_setdmaa(struct snd_azf3328 *chip,
-                                long unsigned int addr,
-                                unsigned int count,
-                                unsigned int size,
-                                enum snd_azf3328_stream_index stream_type
+snd_azf3328_codec_setdmaa(struct snd_azf3328 *chip,
+                                enum snd_azf3328_codec_type codec_type,
+                                unsigned long addr,
+                                unsigned int count,
+                                unsigned int size
 )
 {
+        const struct snd_azf3328_codec_data *codec = &chip->codecs[codec_type];
         snd_azf3328_dbgcallenter();
-        if (!chip->audio_stream[stream_type].running) {
-                /* AZF3328 uses a two buffer pointer DMA playback approach */
+        if (!codec->running) {
+                /* AZF3328 uses a two buffer pointer DMA transfer approach */
 
-                unsigned long flags, portbase, addr_area2;
+                unsigned long flags, addr_area2;
 
                 /* width 32bit (prevent overflow): */
-                unsigned long count_areas, count_tmp;
+                u32 count_areas, lengths;
 
-                portbase = chip->audio_stream[stream_type].portbase;
                 count_areas = size/2;
                 addr_area2 = addr+count_areas;
                 count_areas--; /* max. index */
-                snd_azf3328_dbgplay("set DMA: buf1 %08lx[%lu], buf2 %08lx[%lu]\n", addr, count_areas, addr_area2, count_areas);
+                snd_azf3328_dbgcodec("setdma: buffers %08lx[%u] / %08lx[%u]\n",
+                                addr, count_areas, addr_area2, count_areas);
 
                 /* build combined I/O buffer length word */
-                count_tmp = count_areas;
-                count_areas |= (count_tmp << 16);
+                lengths = (count_areas << 16) | (count_areas);
                 spin_lock_irqsave(&chip->reg_lock, flags);
-                outl(addr, portbase + IDX_IO_PLAY_DMA_START_1);
-                outl(addr_area2, portbase + IDX_IO_PLAY_DMA_START_2);
-                outl(count_areas, portbase + IDX_IO_PLAY_DMA_LEN_1);
+                snd_azf3328_codec_outl(codec, IDX_IO_CODEC_DMA_START_1, addr);
+                snd_azf3328_codec_outl(codec, IDX_IO_CODEC_DMA_START_2,
+                                                                addr_area2);
+                snd_azf3328_codec_outl(codec, IDX_IO_CODEC_DMA_LENGTHS,
+                                                                lengths);
                 spin_unlock_irqrestore(&chip->reg_lock, flags);
         }
         snd_azf3328_dbgcallleave();
 }
 
 static int
-snd_azf3328_playback_prepare(struct snd_pcm_substream *substream)
+snd_azf3328_codec_prepare(struct snd_pcm_substream *substream)
 {
 #if 0
         struct snd_azf3328 *chip = snd_pcm_substream_chip(substream);
@@ -1058,157 +1158,161 @@ snd_azf3328_playback_prepare(struct snd_pcm_substream *substream)
 
         snd_azf3328_dbgcallenter();
 #if 0
-        snd_azf3328_codec_setfmt(chip, IDX_IO_PLAY_SOUNDFORMAT,
+        snd_azf3328_codec_setfmt(chip, AZF_CODEC_...,
                 runtime->rate,
                 snd_pcm_format_width(runtime->format),
                 runtime->channels);
-        snd_azf3328_setdmaa(chip, runtime->dma_addr, count, size, AZF_PLAYBACK);
+        snd_azf3328_codec_setdmaa(chip, AZF_CODEC_...,
+                                        runtime->dma_addr, count, size);
 #endif
         snd_azf3328_dbgcallleave();
         return 0;
 }
 
 static int
-snd_azf3328_capture_prepare(struct snd_pcm_substream *substream)
-{
-#if 0
-        struct snd_azf3328 *chip = snd_pcm_substream_chip(substream);
-        struct snd_pcm_runtime *runtime = substream->runtime;
-        unsigned int size = snd_pcm_lib_buffer_bytes(substream);
-        unsigned int count = snd_pcm_lib_period_bytes(substream);
-#endif
-
-        snd_azf3328_dbgcallenter();
-#if 0
-        snd_azf3328_codec_setfmt(chip, IDX_IO_REC_SOUNDFORMAT,
-                runtime->rate,
-                snd_pcm_format_width(runtime->format),
-                runtime->channels);
-        snd_azf3328_setdmaa(chip, runtime->dma_addr, count, size, AZF_CAPTURE);
-#endif
-        snd_azf3328_dbgcallleave();
-        return 0;
-}
-
-static int
-snd_azf3328_playback_trigger(struct snd_pcm_substream *substream, int cmd)
+snd_azf3328_codec_trigger(enum snd_azf3328_codec_type codec_type,
+                        struct snd_pcm_substream *substream, int cmd)
 {
         struct snd_azf3328 *chip = snd_pcm_substream_chip(substream);
+        const struct snd_azf3328_codec_data *codec = &chip->codecs[codec_type];
         struct snd_pcm_runtime *runtime = substream->runtime;
         int result = 0;
-        unsigned int status1;
-        int previously_muted;
+        u16 flags1;
+        bool previously_muted = 0;
+        bool is_playback_codec = (AZF_CODEC_PLAYBACK == codec_type);
 
-        snd_azf3328_dbgcalls("snd_azf3328_playback_trigger cmd %d\n", cmd);
+        snd_azf3328_dbgcalls("snd_azf3328_codec_trigger cmd %d\n", cmd);
 
         switch (cmd) {
         case SNDRV_PCM_TRIGGER_START:
-                snd_azf3328_dbgplay("START PLAYBACK\n");
-
-                /* mute WaveOut (avoid clicking during setup) */
-                previously_muted =
-                        snd_azf3328_mixer_set_mute(chip, IDX_MIXER_WAVEOUT, 1);
+                snd_azf3328_dbgcodec("START %s\n", codec->name);
+
+                if (is_playback_codec) {
+                        /* mute WaveOut (avoid clicking during setup) */
+                        previously_muted =
+                                snd_azf3328_mixer_set_mute(
+                                                chip, IDX_MIXER_WAVEOUT, 1
+                                );
+                }
 
-                snd_azf3328_codec_setfmt(chip, IDX_IO_PLAY_SOUNDFORMAT,
+                snd_azf3328_codec_setfmt(chip, codec_type,
                         runtime->rate,
                         snd_pcm_format_width(runtime->format),
                         runtime->channels);
 
                 spin_lock(&chip->reg_lock);
                 /* first, remember current value: */
-                status1 = snd_azf3328_codec_inw(chip, IDX_IO_PLAY_FLAGS);
+                flags1 = snd_azf3328_codec_inw(codec, IDX_IO_CODEC_DMA_FLAGS);
 
-                /* stop playback */
-                status1 &= ~DMA_RESUME;
-                snd_azf3328_codec_outw(chip, IDX_IO_PLAY_FLAGS, status1);
+                /* stop transfer */
+                flags1 &= ~DMA_RESUME;
+                snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS, flags1);
 
                 /* FIXME: clear interrupts or what??? */
-                snd_azf3328_codec_outw(chip, IDX_IO_PLAY_IRQTYPE, 0xffff);
+                snd_azf3328_codec_outw(codec, IDX_IO_CODEC_IRQTYPE, 0xffff);
                 spin_unlock(&chip->reg_lock);
 
-                snd_azf3328_setdmaa(chip, runtime->dma_addr,
+                snd_azf3328_codec_setdmaa(chip, codec_type, runtime->dma_addr,
                         snd_pcm_lib_period_bytes(substream),
-                        snd_pcm_lib_buffer_bytes(substream),
-                        AZF_PLAYBACK);
+                        snd_pcm_lib_buffer_bytes(substream)
+                );
 
                 spin_lock(&chip->reg_lock);
 #ifdef WIN9X
                 /* FIXME: enable playback/recording??? */
-                status1 |= DMA_PLAY_SOMETHING1 | DMA_PLAY_SOMETHING2;
-                snd_azf3328_codec_outw(chip, IDX_IO_PLAY_FLAGS, status1);
+                flags1 |= DMA_RUN_SOMETHING1 | DMA_RUN_SOMETHING2;
+                snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS, flags1);
 
-                /* start playback again */
+                /* start transfer again */
                 /* FIXME: what is this value (0x0010)??? */
-                status1 |= DMA_RESUME | DMA_EPILOGUE_SOMETHING;
-                snd_azf3328_codec_outw(chip, IDX_IO_PLAY_FLAGS, status1);
+                flags1 |= DMA_RESUME | DMA_EPILOGUE_SOMETHING;
+                snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS, flags1);
 #else /* NT4 */
-                snd_azf3328_codec_outw(chip, IDX_IO_PLAY_FLAGS,
+                snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS,
                         0x0000);
-                snd_azf3328_codec_outw(chip, IDX_IO_PLAY_FLAGS,
-                        DMA_PLAY_SOMETHING1);
-                snd_azf3328_codec_outw(chip, IDX_IO_PLAY_FLAGS,
-                        DMA_PLAY_SOMETHING1 |
-                        DMA_PLAY_SOMETHING2);
-                snd_azf3328_codec_outw(chip, IDX_IO_PLAY_FLAGS,
+                snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS,
+                        DMA_RUN_SOMETHING1);
+                snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS,
+                        DMA_RUN_SOMETHING1 |
+                        DMA_RUN_SOMETHING2);
+                snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS,
                         DMA_RESUME |
                         SOMETHING_ALMOST_ALWAYS_SET |
                         DMA_EPILOGUE_SOMETHING |
                         DMA_SOMETHING_ELSE);
 #endif
                 spin_unlock(&chip->reg_lock);
-                snd_azf3328_codec_activity(chip, AZF_PLAYBACK, 1);
-
-                /* now unmute WaveOut */
-                if (!previously_muted)
-                        snd_azf3328_mixer_set_mute(chip, IDX_MIXER_WAVEOUT, 0);
+                snd_azf3328_ctrl_codec_activity(chip, codec_type, 1);
+
+                if (is_playback_codec) {
+                        /* now unmute WaveOut */
+                        if (!previously_muted)
+                                snd_azf3328_mixer_set_mute(
+                                                chip, IDX_MIXER_WAVEOUT, 0
+                                );
+                }
 
-                snd_azf3328_dbgplay("STARTED PLAYBACK\n");
+                snd_azf3328_dbgcodec("STARTED %s\n", codec->name);
                 break;
         case SNDRV_PCM_TRIGGER_RESUME:
-                snd_azf3328_dbgplay("RESUME PLAYBACK\n");
-                /* resume playback if we were active */
+                snd_azf3328_dbgcodec("RESUME %s\n", codec->name);
+                /* resume codec if we were active */
                 spin_lock(&chip->reg_lock);
-                if (chip->audio_stream[AZF_PLAYBACK].running)
-                        snd_azf3328_codec_outw(chip, IDX_IO_PLAY_FLAGS,
-                                snd_azf3328_codec_inw(chip, IDX_IO_PLAY_FLAGS) | DMA_RESUME);
+                if (codec->running)
+                        snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS,
+                                snd_azf3328_codec_inw(
+                                        codec, IDX_IO_CODEC_DMA_FLAGS
+                                ) | DMA_RESUME
+                        );
                 spin_unlock(&chip->reg_lock);
                 break;
         case SNDRV_PCM_TRIGGER_STOP:
-                snd_azf3328_dbgplay("STOP PLAYBACK\n");
-
-                /* mute WaveOut (avoid clicking during setup) */
-                previously_muted =
-                        snd_azf3328_mixer_set_mute(chip, IDX_MIXER_WAVEOUT, 1);
+                snd_azf3328_dbgcodec("STOP %s\n", codec->name);
+
+                if (is_playback_codec) {
+                        /* mute WaveOut (avoid clicking during setup) */
+                        previously_muted =
+                                snd_azf3328_mixer_set_mute(
+                                                chip, IDX_MIXER_WAVEOUT, 1
+                                );
+                }
 
                 spin_lock(&chip->reg_lock);
                 /* first, remember current value: */
-                status1 = snd_azf3328_codec_inw(chip, IDX_IO_PLAY_FLAGS);
+                flags1 = snd_azf3328_codec_inw(codec, IDX_IO_CODEC_DMA_FLAGS);
 
-                /* stop playback */
-                status1 &= ~DMA_RESUME;
-                snd_azf3328_codec_outw(chip, IDX_IO_PLAY_FLAGS, status1);
+                /* stop transfer */
+                flags1 &= ~DMA_RESUME;
+                snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS, flags1);
 
                 /* hmm, is this really required? we're resetting the same bit
                  * immediately thereafter... */
-                status1 |= DMA_PLAY_SOMETHING1;
-                snd_azf3328_codec_outw(chip, IDX_IO_PLAY_FLAGS, status1);
+                flags1 |= DMA_RUN_SOMETHING1;
+                snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS, flags1);
 
-                status1 &= ~DMA_PLAY_SOMETHING1;
-                snd_azf3328_codec_outw(chip, IDX_IO_PLAY_FLAGS, status1);
+                flags1 &= ~DMA_RUN_SOMETHING1;
+                snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS, flags1);
                 spin_unlock(&chip->reg_lock);
-                snd_azf3328_codec_activity(chip, AZF_PLAYBACK, 0);
-
-                /* now unmute WaveOut */
-                if (!previously_muted)
-                        snd_azf3328_mixer_set_mute(chip, IDX_MIXER_WAVEOUT, 0);
+                snd_azf3328_ctrl_codec_activity(chip, codec_type, 0);
+
+                if (is_playback_codec) {
+                        /* now unmute WaveOut */
+                        if (!previously_muted)
+                                snd_azf3328_mixer_set_mute(
+                                                chip, IDX_MIXER_WAVEOUT, 0
+                                );
+                }
 
-                snd_azf3328_dbgplay("STOPPED PLAYBACK\n");
+                snd_azf3328_dbgcodec("STOPPED %s\n", codec->name);
                 break;
         case SNDRV_PCM_TRIGGER_SUSPEND:
-                snd_azf3328_dbgplay("SUSPEND PLAYBACK\n");
-                /* make sure playback is stopped */
-                snd_azf3328_codec_outw(chip, IDX_IO_PLAY_FLAGS,
-                        snd_azf3328_codec_inw(chip, IDX_IO_PLAY_FLAGS) & ~DMA_RESUME);
+                snd_azf3328_dbgcodec("SUSPEND %s\n", codec->name);
+                /* make sure codec is stopped */
+                snd_azf3328_codec_outw(codec, IDX_IO_CODEC_DMA_FLAGS,
+                        snd_azf3328_codec_inw(
+                                codec, IDX_IO_CODEC_DMA_FLAGS
+                        ) & ~DMA_RESUME
+                );
                 break;
         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
                 snd_printk(KERN_ERR "FIXME: SNDRV_PCM_TRIGGER_PAUSE_PUSH NIY!\n");
@@ -1217,7 +1321,7 @@ snd_azf3328_playback_trigger(struct snd_pcm_substream *substream, int cmd)
                 snd_printk(KERN_ERR "FIXME: SNDRV_PCM_TRIGGER_PAUSE_RELEASE NIY!\n");
                 break;
         default:
-                printk(KERN_ERR "FIXME: unknown trigger mode!\n");
+                snd_printk(KERN_ERR "FIXME: unknown trigger mode!\n");
                 return -EINVAL;
         }
 
@@ -1225,172 +1329,74 @@ snd_azf3328_playback_trigger(struct snd_pcm_substream *substream, int cmd)
         return result;
 }
 
-/* this is just analogous to playback; I'm not quite sure whether recording
- * should actually be triggered like that */
 static int
-snd_azf3328_capture_trigger(struct snd_pcm_substream *substream, int cmd)
+snd_azf3328_codec_playback_trigger(struct snd_pcm_substream *substream, int cmd)
 {
-        struct snd_azf3328 *chip = snd_pcm_substream_chip(substream);
-        struct snd_pcm_runtime *runtime = substream->runtime;
-        int result = 0;
-        unsigned int status1;
-
-        snd_azf3328_dbgcalls("snd_azf3328_capture_trigger cmd %d\n", cmd);
-
-        switch (cmd) {
-        case SNDRV_PCM_TRIGGER_START:
-
-                snd_azf3328_dbgplay("START CAPTURE\n");
-
-                snd_azf3328_codec_setfmt(chip, IDX_IO_REC_SOUNDFORMAT,
-                        runtime->rate,
-                        snd_pcm_format_width(runtime->format),
-                        runtime->channels);
-
-                spin_lock(&chip->reg_lock);
-                /* first, remember current value: */
-                status1 = snd_azf3328_codec_inw(chip, IDX_IO_REC_FLAGS);
-
-                /* stop recording */
-                status1 &= ~DMA_RESUME;
-                snd_azf3328_codec_outw(chip, IDX_IO_REC_FLAGS, status1);
-
-                /* FIXME: clear interrupts or what??? */
-                snd_azf3328_codec_outw(chip, IDX_IO_REC_IRQTYPE, 0xffff);
-                spin_unlock(&chip->reg_lock);
-
-                snd_azf3328_setdmaa(chip, runtime->dma_addr,
-                        snd_pcm_lib_period_bytes(substream),
-                        snd_pcm_lib_buffer_bytes(substream),
-                        AZF_CAPTURE);
-
-                spin_lock(&chip->reg_lock);
-#ifdef WIN9X
-                /* FIXME: enable playback/recording??? */
-                status1 |= DMA_PLAY_SOMETHING1 | DMA_PLAY_SOMETHING2;
-                snd_azf3328_codec_outw(chip, IDX_IO_REC_FLAGS, status1);
-
-                /* start capture again */
-                /* FIXME: what is this value (0x0010)??? */
-                status1 |= DMA_RESUME | DMA_EPILOGUE_SOMETHING;
-                snd_azf3328_codec_outw(chip, IDX_IO_REC_FLAGS, status1);
-#else
-                snd_azf3328_codec_outw(chip, IDX_IO_REC_FLAGS,
-                        0x0000);
-                snd_azf3328_codec_outw(chip, IDX_IO_REC_FLAGS,
-                        DMA_PLAY_SOMETHING1);
-                snd_azf3328_codec_outw(chip, IDX_IO_REC_FLAGS,
-                        DMA_PLAY_SOMETHING1 |
-                        DMA_PLAY_SOMETHING2);
-                snd_azf3328_codec_outw(chip, IDX_IO_REC_FLAGS,
-                        DMA_RESUME |
-                        SOMETHING_ALMOST_ALWAYS_SET |
-                        DMA_EPILOGUE_SOMETHING |
-                        DMA_SOMETHING_ELSE);
-#endif
-                spin_unlock(&chip->reg_lock);
-                snd_azf3328_codec_activity(chip, AZF_CAPTURE, 1);
-
-                snd_azf3328_dbgplay("STARTED CAPTURE\n");
-                break;
-        case SNDRV_PCM_TRIGGER_RESUME:
-                snd_azf3328_dbgplay("RESUME CAPTURE\n");
-                /* resume recording if we were active */
-                spin_lock(&chip->reg_lock);
-                if (chip->audio_stream[AZF_CAPTURE].running)
-                        snd_azf3328_codec_outw(chip, IDX_IO_REC_FLAGS,
-                                snd_azf3328_codec_inw(chip, IDX_IO_REC_FLAGS) | DMA_RESUME);
-                spin_unlock(&chip->reg_lock);
-                break;
-        case SNDRV_PCM_TRIGGER_STOP:
-                snd_azf3328_dbgplay("STOP CAPTURE\n");
-
-                spin_lock(&chip->reg_lock);
-                /* first, remember current value: */
-                status1 = snd_azf3328_codec_inw(chip, IDX_IO_REC_FLAGS);
-
-                /* stop recording */
-                status1 &= ~DMA_RESUME;
-                snd_azf3328_codec_outw(chip, IDX_IO_REC_FLAGS, status1);
-
-                status1 |= DMA_PLAY_SOMETHING1;
-                snd_azf3328_codec_outw(chip, IDX_IO_REC_FLAGS, status1);
-
-                status1 &= ~DMA_PLAY_SOMETHING1;
-                snd_azf3328_codec_outw(chip, IDX_IO_REC_FLAGS, status1);
-                spin_unlock(&chip->reg_lock);
-                snd_azf3328_codec_activity(chip, AZF_CAPTURE, 0);
+        return snd_azf3328_codec_trigger(AZF_CODEC_PLAYBACK, substream, cmd);
+}
 
-                snd_azf3328_dbgplay("STOPPED CAPTURE\n");
-                break;
-        case SNDRV_PCM_TRIGGER_SUSPEND:
-                snd_azf3328_dbgplay("SUSPEND CAPTURE\n");
-                /* make sure recording is stopped */
-                snd_azf3328_codec_outw(chip, IDX_IO_REC_FLAGS,
-                        snd_azf3328_codec_inw(chip, IDX_IO_REC_FLAGS) & ~DMA_RESUME);
-                break;
-        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
-                snd_printk(KERN_ERR "FIXME: SNDRV_PCM_TRIGGER_PAUSE_PUSH NIY!\n");
-                break;
-        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
-                snd_printk(KERN_ERR "FIXME: SNDRV_PCM_TRIGGER_PAUSE_RELEASE NIY!\n");
-                break;
-        default:
-                printk(KERN_ERR "FIXME: unknown trigger mode!\n");
-                return -EINVAL;
-        }
+static int
+snd_azf3328_codec_capture_trigger(struct snd_pcm_substream *substream, int cmd)
+{
+        return snd_azf3328_codec_trigger(AZF_CODEC_CAPTURE, substream, cmd);
+}
 
-        snd_azf3328_dbgcallleave();
-        return result;
+static int
+snd_azf3328_codec_i2s_out_trigger(struct snd_pcm_substream *substream, int cmd)
+{
+        return snd_azf3328_codec_trigger(AZF_CODEC_I2S_OUT, substream, cmd);
 }
 
 static snd_pcm_uframes_t
-snd_azf3328_playback_pointer(struct snd_pcm_substream *substream)
+snd_azf3328_codec_pointer(struct snd_pcm_substream *substream,
+                          enum snd_azf3328_codec_type codec_type
+)
 {
-        struct snd_azf3328 *chip = snd_pcm_substream_chip(substream);
+        const struct snd_azf3328 *chip = snd_pcm_substream_chip(substream);
+        const struct snd_azf3328_codec_data *codec = &chip->codecs[codec_type];
         unsigned long bufptr, result;
         snd_pcm_uframes_t frmres;
 
 #ifdef QUERY_HARDWARE
-        bufptr = snd_azf3328_codec_inl(chip, IDX_IO_PLAY_DMA_START_1);
+        bufptr = snd_azf3328_codec_inl(codec, IDX_IO_CODEC_DMA_START_1);
 #else
         bufptr = substream->runtime->dma_addr;
 #endif
-        result = snd_azf3328_codec_inl(chip, IDX_IO_PLAY_DMA_CURRPOS);
+        result = snd_azf3328_codec_inl(codec, IDX_IO_CODEC_DMA_CURRPOS);
 
         /* calculate offset */
         result -= bufptr;
         frmres = bytes_to_frames( substream->runtime, result);
-        snd_azf3328_dbgplay("PLAY @ 0x%8lx, frames %8ld\n", result, frmres);
+        snd_azf3328_dbgcodec("%s @ 0x%8lx, frames %8ld\n",
+                                codec->name, result, frmres);
         return frmres;
 }
 
 static snd_pcm_uframes_t
-snd_azf3328_capture_pointer(struct snd_pcm_substream *substream)
+snd_azf3328_codec_playback_pointer(struct snd_pcm_substream *substream)
 {
-        struct snd_azf3328 *chip = snd_pcm_substream_chip(substream);
-        unsigned long bufptr, result;
-        snd_pcm_uframes_t frmres;
+        return snd_azf3328_codec_pointer(substream, AZF_CODEC_PLAYBACK);
+}
 
-#ifdef QUERY_HARDWARE
-        bufptr = snd_azf3328_codec_inl(chip, IDX_IO_REC_DMA_START_1);
-#else
-        bufptr = substream->runtime->dma_addr;
-#endif
-        result = snd_azf3328_codec_inl(chip, IDX_IO_REC_DMA_CURRPOS);
+static snd_pcm_uframes_t
+snd_azf3328_codec_capture_pointer(struct snd_pcm_substream *substream)
+{
+        return snd_azf3328_codec_pointer(substream, AZF_CODEC_CAPTURE);
+}
 
-        /* calculate offset */
-        result -= bufptr;
-        frmres = bytes_to_frames( substream->runtime, result);
-        snd_azf3328_dbgplay("REC  @ 0x%8lx, frames %8ld\n", result, frmres);
-        return frmres;
+static snd_pcm_uframes_t
+snd_azf3328_codec_i2s_out_pointer(struct snd_pcm_substream *substream)
+{
+        return snd_azf3328_codec_pointer(substream, AZF_CODEC_I2S_OUT);
 }
 
 /******************************************************************/
 
 #ifdef SUPPORT_GAMEPORT
 static inline void
-snd_azf3328_gameport_irq_enable(struct snd_azf3328 *chip, int enable)
+snd_azf3328_gameport_irq_enable(struct snd_azf3328 *chip,
+                                bool enable
+)
 {
         snd_azf3328_io_reg_setb(
                 chip->game_io+IDX_GAME_HWCONFIG,
@@ -1400,7 +1406,9 @@ snd_azf3328_gameport_irq_enable(struct snd_azf3328 *chip, int enable)
 }
 
 static inline void
-snd_azf3328_gameport_legacy_address_enable(struct snd_azf3328 *chip, int enable)
+snd_azf3328_gameport_legacy_address_enable(struct snd_azf3328 *chip,
+                                           bool enable
+)
 {
         snd_azf3328_io_reg_setb(
                 chip->game_io+IDX_GAME_HWCONFIG,
@@ -1409,10 +1417,27 @@ snd_azf3328_gameport_legacy_address_enable(struct snd_azf3328 *chip, int enable)
         );
 }
 
+static void
+snd_azf3328_gameport_set_counter_frequency(struct snd_azf3328 *chip,
+                                           unsigned int freq_cfg
+)
+{
+        snd_azf3328_io_reg_setb(
+                chip->game_io+IDX_GAME_HWCONFIG,
+                0x02,
+                (freq_cfg & 1) != 0
+        );
+        snd_azf3328_io_reg_setb(
+                chip->game_io+IDX_GAME_HWCONFIG,
+                0x04,
+                (freq_cfg & 2) != 0
+        );
+}
+
 static inline void
-snd_azf3328_gameport_axis_circuit_enable(struct snd_azf3328 *chip, int enable)
+snd_azf3328_gameport_axis_circuit_enable(struct snd_azf3328 *chip, bool enable)
 {
-        snd_azf3328_codec_reg_6AH_update(
+        snd_azf3328_ctrl_reg_6AH_update(
                 chip, IO_6A_SOMETHING2_GAMEPORT, enable
         );
 }
@@ -1447,6 +1472,8 @@ snd_azf3328_gameport_open(struct gameport *gameport, int mode)
                 break;
         }
 
+        snd_azf3328_gameport_set_counter_frequency(chip,
+                                GAME_HWCFG_ADC_COUNTER_FREQ_STD);
         snd_azf3328_gameport_axis_circuit_enable(chip, (res == 0));
 
         return res;
@@ -1458,6 +1485,8 @@ snd_azf3328_gameport_close(struct gameport *gameport)
         struct snd_azf3328 *chip = gameport_get_port_data(gameport);
 
         snd_azf3328_dbggame("gameport_close\n");
+        snd_azf3328_gameport_set_counter_frequency(chip,
+                                GAME_HWCFG_ADC_COUNTER_FREQ_1_200);
         snd_azf3328_gameport_axis_circuit_enable(chip, 0);
 }
 
@@ -1491,7 +1520,7 @@ snd_azf3328_gameport_cooked_read(struct gameport *gameport,
 
         val = snd_azf3328_game_inb(chip, IDX_GAME_AXES_CONFIG);
         if (val & GAME_AXES_SAMPLING_READY) {
-                for (i = 0; i < 4; ++i) {
+                for (i = 0; i < ARRAY_SIZE(chip->axes); ++i) {
                         /* configure the axis to read */
                         val = (i << 4) | 0x0f;
                         snd_azf3328_game_outb(chip, IDX_GAME_AXES_CONFIG, val);
@@ -1514,7 +1543,7 @@ snd_azf3328_gameport_cooked_read(struct gameport *gameport,
         snd_azf3328_game_outw(chip, IDX_GAME_AXIS_VALUE, 0xffff);
         spin_unlock_irqrestore(&chip->reg_lock, flags);
 
-        for (i = 0; i < 4; i++) {
+        for (i = 0; i < ARRAY_SIZE(chip->axes); i++) {
                 axes[i] = chip->axes[i];
                 if (axes[i] == 0xffff)
                         axes[i] = -1;
@@ -1552,6 +1581,8 @@ snd_azf3328_gameport(struct snd_azf3328 *chip, int dev)
         /* DISABLE legacy address: we don't need it! */
         snd_azf3328_gameport_legacy_address_enable(chip, 0);
 
+        snd_azf3328_gameport_set_counter_frequency(chip,
+                                GAME_HWCFG_ADC_COUNTER_FREQ_1_200);
         snd_azf3328_gameport_axis_circuit_enable(chip, 0);
 
         gameport_register_port(chip->gameport);
@@ -1585,40 +1616,77 @@ snd_azf3328_gameport_interrupt(struct snd_azf3328 *chip)
 static inline void
 snd_azf3328_irq_log_unknown_type(u8 which)
 {
-        snd_azf3328_dbgplay(
+        snd_azf3328_dbgcodec(
         "azt3328: unknown IRQ type (%x) occurred, please report!\n",
                 which
         );
 }
 
+static inline void
+snd_azf3328_codec_interrupt(struct snd_azf3328 *chip, u8 status)
+{
+        u8 which;
+        enum snd_azf3328_codec_type codec_type;
+        const struct snd_azf3328_codec_data *codec;
+
+        for (codec_type = AZF_CODEC_PLAYBACK;
+                 codec_type <= AZF_CODEC_I2S_OUT;
+                         ++codec_type) {
+
+                /* skip codec if there's no interrupt for it */
+                if (!(status & (1 << codec_type)))
+                        continue;
+
+                codec = &chip->codecs[codec_type];
+
+                spin_lock(&chip->reg_lock);
+                which = snd_azf3328_codec_inb(codec, IDX_IO_CODEC_IRQTYPE);
+                /* ack all IRQ types immediately */
+                snd_azf3328_codec_outb(codec, IDX_IO_CODEC_IRQTYPE, which);
+                spin_unlock(&chip->reg_lock);
+
+                if ((chip->pcm[codec_type]) && (codec->substream)) {
+                        snd_pcm_period_elapsed(codec->substream);
+                        snd_azf3328_dbgcodec("%s period done (#%x), @ %x\n",
+                                codec->name,
+                                which,
+                                snd_azf3328_codec_inl(
+                                        codec, IDX_IO_CODEC_DMA_CURRPOS
+                                )
+                        );
+                } else
+                        printk(KERN_WARNING "azt3328: irq handler problem!\n");
+                if (which & IRQ_SOMETHING)
+                        snd_azf3328_irq_log_unknown_type(which);
+        }
+}
+
 static irqreturn_t
 snd_azf3328_interrupt(int irq, void *dev_id)
 {
         struct snd_azf3328 *chip = dev_id;
-        u8 status, which;
-#if DEBUG_PLAY_REC
+        u8 status;
+#if DEBUG_CODEC
         static unsigned long irq_count;
 #endif
 
-        status = snd_azf3328_codec_inb(chip, IDX_IO_IRQSTATUS);
+        status = snd_azf3328_ctrl_inb(chip, IDX_IO_IRQSTATUS);
 
         /* fast path out, to ease interrupt sharing */
         if (!(status &
-                (IRQ_PLAYBACK|IRQ_RECORDING|IRQ_GAMEPORT|IRQ_MPU401|IRQ_TIMER)
+                (IRQ_PLAYBACK|IRQ_RECORDING|IRQ_I2S_OUT
+                |IRQ_GAMEPORT|IRQ_MPU401|IRQ_TIMER)
         ))
                 return IRQ_NONE; /* must be interrupt for another device */
 
-        snd_azf3328_dbgplay(
-                "irq_count %ld! IDX_IO_PLAY_FLAGS %04x, "
-                "IDX_IO_PLAY_IRQTYPE %04x, IDX_IO_IRQSTATUS %04x\n",
+        snd_azf3328_dbgcodec(
+                "irq_count %ld! IDX_IO_IRQSTATUS %04x\n",
                         irq_count++ /* debug-only */,
-                        snd_azf3328_codec_inw(chip, IDX_IO_PLAY_FLAGS),
-                        snd_azf3328_codec_inw(chip, IDX_IO_PLAY_IRQTYPE),
                         status
         );
 
         if (status & IRQ_TIMER) {
-                /* snd_azf3328_dbgplay("timer %ld\n",
+                /* snd_azf3328_dbgcodec("timer %ld\n",
                         snd_azf3328_codec_inl(chip, IDX_IO_TIMER_VALUE)
                                 & TIMER_VALUE_MASK
                 ); */
@@ -1626,71 +1694,36 @@ snd_azf3328_interrupt(int irq, void *dev_id)
                         snd_timer_interrupt(chip->timer, chip->timer->sticks);
                 /* ACK timer */
                 spin_lock(&chip->reg_lock);
-                snd_azf3328_codec_outb(chip, IDX_IO_TIMER_VALUE + 3, 0x07);
+                snd_azf3328_ctrl_outb(chip, IDX_IO_TIMER_VALUE + 3, 0x07);
                 spin_unlock(&chip->reg_lock);
-                snd_azf3328_dbgplay("azt3328: timer IRQ\n");
+                snd_azf3328_dbgcodec("azt3328: timer IRQ\n");
         }
-        if (status & IRQ_PLAYBACK) {
-                spin_lock(&chip->reg_lock);
-                which = snd_azf3328_codec_inb(chip, IDX_IO_PLAY_IRQTYPE);
-                /* ack all IRQ types immediately */
-                snd_azf3328_codec_outb(chip, IDX_IO_PLAY_IRQTYPE, which);
-                spin_unlock(&chip->reg_lock);
 
-                if (chip->pcm && chip->audio_stream[AZF_PLAYBACK].substream) {
-                        snd_pcm_period_elapsed(
-                                chip->audio_stream[AZF_PLAYBACK].substream
-                        );
-                        snd_azf3328_dbgplay("PLAY period done (#%x), @ %x\n",
-                                which,
-                                snd_azf3328_codec_inl(
-                                        chip, IDX_IO_PLAY_DMA_CURRPOS
-                                )
-                        );
-                } else
-                        printk(KERN_WARNING "azt3328: irq handler problem!\n");
-                if (which & IRQ_PLAY_SOMETHING)
-                        snd_azf3328_irq_log_unknown_type(which);
-        }
-        if (status & IRQ_RECORDING) {
-                spin_lock(&chip->reg_lock);
-                which = snd_azf3328_codec_inb(chip, IDX_IO_REC_IRQTYPE);
-                /* ack all IRQ types immediately */
-                snd_azf3328_codec_outb(chip, IDX_IO_REC_IRQTYPE, which);
-                spin_unlock(&chip->reg_lock);
+        if (status & (IRQ_PLAYBACK|IRQ_RECORDING|IRQ_I2S_OUT))
+                snd_azf3328_codec_interrupt(chip, status);
 
-                if (chip->pcm && chip->audio_stream[AZF_CAPTURE].substream) {
-                        snd_pcm_period_elapsed(
-                                chip->audio_stream[AZF_CAPTURE].substream
-                        );
-                        snd_azf3328_dbgplay("REC  period done (#%x), @ %x\n",
-                                which,
-                                snd_azf3328_codec_inl(
-                                        chip, IDX_IO_REC_DMA_CURRPOS
-                                )
-                        );
-                } else
-                        printk(KERN_WARNING "azt3328: irq handler problem!\n");
-                if (which & IRQ_REC_SOMETHING)
-                        snd_azf3328_irq_log_unknown_type(which);
-        }
         if (status & IRQ_GAMEPORT)
                 snd_azf3328_gameport_interrupt(chip);
+
         /* MPU401 has less critical IRQ requirements
          * than timer and playback/recording, right? */
         if (status & IRQ_MPU401) {
                 snd_mpu401_uart_interrupt(irq, chip->rmidi->private_data);
 
                 /* hmm, do we have to ack the IRQ here somehow?
-                 * If so, then I don't know how... */
-                snd_azf3328_dbgplay("azt3328: MPU401 IRQ\n");
+                 * If so, then I don't know how yet... */
+                snd_azf3328_dbgcodec("azt3328: MPU401 IRQ\n");
         }
         return IRQ_HANDLED;
 }
 
 /*****************************************************************/
 
-static const struct snd_pcm_hardware snd_azf3328_playback =
+/* as long as we think we have identical snd_pcm_hardware parameters
+   for playback, capture and i2s out, we can use the same physical struct
+   since the struct is simply being copied into a member.
+*/
+static const struct snd_pcm_hardware snd_azf3328_hardware =
 {
         /* FIXME!! Correct? */
         .info =                 SNDRV_PCM_INFO_MMAP |
@@ -1718,31 +1751,6 @@ static const struct snd_pcm_hardware snd_azf3328_playback =
         .fifo_size =            0,
 };
 
-static const struct snd_pcm_hardware snd_azf3328_capture =
-{
-        /* FIXME */
-        .info =                 SNDRV_PCM_INFO_MMAP |
-                                SNDRV_PCM_INFO_INTERLEAVED |
-                                SNDRV_PCM_INFO_MMAP_VALID,
-        .formats =              SNDRV_PCM_FMTBIT_S8 |
-                                SNDRV_PCM_FMTBIT_U8 |
-                                SNDRV_PCM_FMTBIT_S16_LE |
-                                SNDRV_PCM_FMTBIT_U16_LE,
-        .rates =                SNDRV_PCM_RATE_5512 |
-                                SNDRV_PCM_RATE_8000_48000 |
-                                SNDRV_PCM_RATE_KNOT,
-        .rate_min =             AZF_FREQ_4000,
-        .rate_max =             AZF_FREQ_66200,
-        .channels_min =         1,
-        .channels_max =         2,
-        .buffer_bytes_max =     65536,
-        .period_bytes_min =     64,
-        .period_bytes_max =     65536,
-        .periods_min =          1,
-        .periods_max =          1024,
-        .fifo_size =            0,
-};
-
 
 static unsigned int snd_azf3328_fixed_rates[] = {
         AZF_FREQ_4000,
@@ -1770,14 +1778,19 @@ static struct snd_pcm_hw_constraint_list snd_azf3328_hw_constraints_rates = {
 /*****************************************************************/
 
 static int
-snd_azf3328_playback_open(struct snd_pcm_substream *substream)
+snd_azf3328_pcm_open(struct snd_pcm_substream *substream,
+                     enum snd_azf3328_codec_type codec_type
+)
 {
         struct snd_azf3328 *chip = snd_pcm_substream_chip(substream);
         struct snd_pcm_runtime *runtime = substream->runtime;
 
         snd_azf3328_dbgcallenter();
-        chip->audio_stream[AZF_PLAYBACK].substream = substream;
-        runtime->hw = snd_azf3328_playback;
+        chip->codecs[codec_type].substream = substream;
+
+        /* same parameters for all our codecs - at least we think so... */
+        runtime->hw = snd_azf3328_hardware;
+
         snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
                                    &snd_azf3328_hw_constraints_rates);
         snd_azf3328_dbgcallleave();
@@ -1785,40 +1798,52 @@ snd_azf3328_playback_open(struct snd_pcm_substream *substream)
 }
 
 static int
+snd_azf3328_playback_open(struct snd_pcm_substream *substream)
+{
+        return snd_azf3328_pcm_open(substream, AZF_CODEC_PLAYBACK);
+}
+
+static int
 snd_azf3328_capture_open(struct snd_pcm_substream *substream)
 {
-        struct snd_azf3328 *chip = snd_pcm_substream_chip(substream);
-        struct snd_pcm_runtime *runtime = substream->runtime;
+        return snd_azf3328_pcm_open(substream, AZF_CODEC_CAPTURE);
+}
 
-        snd_azf3328_dbgcallenter();
-        chip->audio_stream[AZF_CAPTURE].substream = substream;
-        runtime->hw = snd_azf3328_capture;
-        snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
-                                   &snd_azf3328_hw_constraints_rates);
-        snd_azf3328_dbgcallleave();
-        return 0;
+static int
+snd_azf3328_i2s_out_open(struct snd_pcm_substream *substream)
+{
+        return snd_azf3328_pcm_open(substream, AZF_CODEC_I2S_OUT);
 }
 
 static int
-snd_azf3328_playback_close(struct snd_pcm_substream *substream)
+snd_azf3328_pcm_close(struct snd_pcm_substream *substream,
+                      enum snd_azf3328_codec_type codec_type
+)
 {
         struct snd_azf3328 *chip = snd_pcm_substream_chip(substream);
 
         snd_azf3328_dbgcallenter();
-        chip->audio_stream[AZF_PLAYBACK].substream = NULL;
+        chip->codecs[codec_type].substream = NULL;
         snd_azf3328_dbgcallleave();
         return 0;
 }
 
 static int
+snd_azf3328_playback_close(struct snd_pcm_substream *substream)
+{
+        return snd_azf3328_pcm_close(substream, AZF_CODEC_PLAYBACK);
+}
+
+static int
 snd_azf3328_capture_close(struct snd_pcm_substream *substream)
 {
-        struct snd_azf3328 *chip = snd_pcm_substream_chip(substream);
+        return snd_azf3328_pcm_close(substream, AZF_CODEC_CAPTURE);
+}
 
-        snd_azf3328_dbgcallenter();
-        chip->audio_stream[AZF_CAPTURE].substream = NULL;
-        snd_azf3328_dbgcallleave();
-        return 0;
+static int
+snd_azf3328_i2s_out_close(struct snd_pcm_substream *substream)
+{
+        return snd_azf3328_pcm_close(substream, AZF_CODEC_I2S_OUT);
 }
 
 /******************************************************************/
@@ -1829,9 +1854,9 @@ static struct snd_pcm_ops snd_azf3328_playback_ops = {
         .ioctl =        snd_pcm_lib_ioctl,
         .hw_params =    snd_azf3328_hw_params,
         .hw_free =      snd_azf3328_hw_free,
-        .prepare =      snd_azf3328_playback_prepare,
-        .trigger =      snd_azf3328_playback_trigger,
-        .pointer =      snd_azf3328_playback_pointer
+        .prepare =      snd_azf3328_codec_prepare,
+        .trigger =      snd_azf3328_codec_playback_trigger,
+        .pointer =      snd_azf3328_codec_playback_pointer
 };
 
 static struct snd_pcm_ops snd_azf3328_capture_ops = {
@@ -1840,30 +1865,67 @@ static struct snd_pcm_ops snd_azf3328_capture_ops = {
         .ioctl =        snd_pcm_lib_ioctl,
         .hw_params =    snd_azf3328_hw_params,
         .hw_free =      snd_azf3328_hw_free,
-        .prepare =      snd_azf3328_capture_prepare,
-        .trigger =      snd_azf3328_capture_trigger,
-        .pointer =      snd_azf3328_capture_pointer
+        .prepare =      snd_azf3328_codec_prepare,
+        .trigger =      snd_azf3328_codec_capture_trigger,
+        .pointer =      snd_azf3328_codec_capture_pointer
+};
+
+static struct snd_pcm_ops snd_azf3328_i2s_out_ops = {
+        .open =         snd_azf3328_i2s_out_open,
+        .close =        snd_azf3328_i2s_out_close,
+        .ioctl =        snd_pcm_lib_ioctl,
+        .hw_params =    snd_azf3328_hw_params,
+        .hw_free =      snd_azf3328_hw_free,
+        .prepare =      snd_azf3328_codec_prepare,
+        .trigger =      snd_azf3328_codec_i2s_out_trigger,
+        .pointer =      snd_azf3328_codec_i2s_out_pointer
 };
 
 static int __devinit
-snd_azf3328_pcm(struct snd_azf3328 *chip, int device)
+snd_azf3328_pcm(struct snd_azf3328 *chip)
 {
+enum { AZF_PCMDEV_STD, AZF_PCMDEV_I2S_OUT, NUM_AZF_PCMDEVS }; /* pcm devices */
+
         struct snd_pcm *pcm;
         int err;
 
         snd_azf3328_dbgcallenter();
-        if ((err = snd_pcm_new(chip->card, "AZF3328 DSP", device, 1, 1, &pcm)) < 0)
+
+        err = snd_pcm_new(chip->card, "AZF3328 DSP", AZF_PCMDEV_STD,
+                                                                1, 1, &pcm);
+        if (err < 0)
                 return err;
-        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_azf3328_playback_ops);
-        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_azf3328_capture_ops);
+        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
+                                                &snd_azf3328_playback_ops);
+        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
+                                                &snd_azf3328_capture_ops);
 
         pcm->private_data = chip;
         pcm->info_flags = 0;
         strcpy(pcm->name, chip->card->shortname);
-        chip->pcm = pcm;
+        /* same pcm object for playback/capture (see snd_pcm_new() above) */
+        chip->pcm[AZF_CODEC_PLAYBACK] = pcm;
+        chip->pcm[AZF_CODEC_CAPTURE] = pcm;
 
         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                              snd_dma_pci_data(chip->pci), 64*1024, 64*1024);
+                                                snd_dma_pci_data(chip->pci),
+                                                        64*1024, 64*1024);
+
+        err = snd_pcm_new(chip->card, "AZF3328 I2S OUT", AZF_PCMDEV_I2S_OUT,
+                                                                1, 0, &pcm);
+        if (err < 0)
+                return err;
+        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
+                                                &snd_azf3328_i2s_out_ops);
+
+        pcm->private_data = chip;
+        pcm->info_flags = 0;
+        strcpy(pcm->name, chip->card->shortname);
+        chip->pcm[AZF_CODEC_I2S_OUT] = pcm;
+
+        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
+                                                snd_dma_pci_data(chip->pci),
+                                                        64*1024, 64*1024);
 
         snd_azf3328_dbgcallleave();
         return 0;
@@ -1902,7 +1964,7 @@ snd_azf3328_timer_start(struct snd_timer *timer)
         snd_azf3328_dbgtimer("setting timer countdown value %d, add COUNTDOWN|IRQ\n", delay);
         delay |= TIMER_COUNTDOWN_ENABLE | TIMER_IRQ_ENABLE;
         spin_lock_irqsave(&chip->reg_lock, flags);
-        snd_azf3328_codec_outl(chip, IDX_IO_TIMER_VALUE, delay);
+        snd_azf3328_ctrl_outl(chip, IDX_IO_TIMER_VALUE, delay);
         spin_unlock_irqrestore(&chip->reg_lock, flags);
         snd_azf3328_dbgcallleave();
         return 0;
@@ -1919,7 +1981,7 @@ snd_azf3328_timer_stop(struct snd_timer *timer)
         spin_lock_irqsave(&chip->reg_lock, flags);
         /* disable timer countdown and interrupt */
         /* FIXME: should we write TIMER_IRQ_ACK here? */
-        snd_azf3328_codec_outb(chip, IDX_IO_TIMER_VALUE + 3, 0);
+        snd_azf3328_ctrl_outb(chip, IDX_IO_TIMER_VALUE + 3, 0);
         spin_unlock_irqrestore(&chip->reg_lock, flags);
         snd_azf3328_dbgcallleave();
         return 0;
@@ -2035,7 +2097,7 @@ snd_azf3328_test_bit(unsigned unsigned reg, int bit)
 
         outb(val, reg);
 
-        printk(KERN_ERR "reg %04x bit %d: %02x %02x %02x\n",
+        printk(KERN_DEBUG "reg %04x bit %d: %02x %02x %02x\n",
                                 reg, bit, val, valoff, valon
         );
 }
@@ -2048,9 +2110,9 @@ snd_azf3328_debug_show_ports(const struct snd_azf3328 *chip)
         u16 tmp;
 
         snd_azf3328_dbgmisc(
-                "codec_io 0x%lx, game_io 0x%lx, mpu_io 0x%lx, "
+                "ctrl_io 0x%lx, game_io 0x%lx, mpu_io 0x%lx, "
                 "opl3_io 0x%lx, mixer_io 0x%lx, irq %d\n",
-                chip->codec_io, chip->game_io, chip->mpu_io,
+                chip->ctrl_io, chip->game_io, chip->mpu_io,
                 chip->opl3_io, chip->mixer_io, chip->irq
         );
 
@@ -2083,9 +2145,9 @@ snd_azf3328_debug_show_ports(const struct snd_azf3328 *chip)
                                 inb(0x38c + tmp)
                 );
 
-        for (tmp = 0; tmp < AZF_IO_SIZE_CODEC; tmp += 2)
-                snd_azf3328_dbgmisc("codec 0x%02x: 0x%04x\n",
-                        tmp, snd_azf3328_codec_inw(chip, tmp)
+        for (tmp = 0; tmp < AZF_IO_SIZE_CTRL; tmp += 2)
+                snd_azf3328_dbgmisc("ctrl 0x%02x: 0x%04x\n",
+                        tmp, snd_azf3328_ctrl_inw(chip, tmp)
                 );
 
         for (tmp = 0; tmp < AZF_IO_SIZE_MIXER; tmp += 2)
@@ -2106,7 +2168,8 @@ snd_azf3328_create(struct snd_card *card,
         static struct snd_device_ops ops = {
                 .dev_free =     snd_azf3328_dev_free,
         };
-        u16 tmp;
+        u8 dma_init;
+        enum snd_azf3328_codec_type codec_type;
 
         *rchip = NULL;
 
@@ -2138,14 +2201,21 @@ snd_azf3328_create(struct snd_card *card,
         if (err < 0)
                 goto out_err;
 
-        chip->codec_io = pci_resource_start(pci, 0);
+        chip->ctrl_io  = pci_resource_start(pci, 0);
         chip->game_io  = pci_resource_start(pci, 1);
         chip->mpu_io   = pci_resource_start(pci, 2);
-        chip->opl3_io = pci_resource_start(pci, 3);
+        chip->opl3_io  = pci_resource_start(pci, 3);
         chip->mixer_io = pci_resource_start(pci, 4);
 
-        chip->audio_stream[AZF_PLAYBACK].portbase = chip->codec_io + 0x00;
-        chip->audio_stream[AZF_CAPTURE].portbase   = chip->codec_io + 0x20;
+        chip->codecs[AZF_CODEC_PLAYBACK].io_base =
+                                chip->ctrl_io + AZF_IO_OFFS_CODEC_PLAYBACK;
+        chip->codecs[AZF_CODEC_PLAYBACK].name = "PLAYBACK";
+        chip->codecs[AZF_CODEC_CAPTURE].io_base =
+                                chip->ctrl_io + AZF_IO_OFFS_CODEC_CAPTURE;
+        chip->codecs[AZF_CODEC_CAPTURE].name = "CAPTURE";
+        chip->codecs[AZF_CODEC_I2S_OUT].io_base =
+                                chip->ctrl_io + AZF_IO_OFFS_CODEC_I2S_OUT;
+        chip->codecs[AZF_CODEC_I2S_OUT].name = "I2S_OUT";
 
         if (request_irq(pci->irq, snd_azf3328_interrupt,
                         IRQF_SHARED, card->shortname, chip)) {
@@ -2168,20 +2238,25 @@ snd_azf3328_create(struct snd_card *card,
         if (err < 0)
                 goto out_err;
 
-        /* shutdown codecs to save power */
-                /* have snd_azf3328_codec_activity() act properly */
-        chip->audio_stream[AZF_PLAYBACK].running = 1;
-        snd_azf3328_codec_activity(chip, AZF_PLAYBACK, 0);
+        /* standard codec init stuff */
+                /* default DMA init value */
+        dma_init = DMA_RUN_SOMETHING2|DMA_EPILOGUE_SOMETHING|DMA_SOMETHING_ELSE;
 
-        /* standard chip init stuff */
-                /* default IRQ init value */
-        tmp = DMA_PLAY_SOMETHING2|DMA_EPILOGUE_SOMETHING|DMA_SOMETHING_ELSE;
+        for (codec_type = AZF_CODEC_PLAYBACK;
+                codec_type <= AZF_CODEC_I2S_OUT; ++codec_type) {
+                struct snd_azf3328_codec_data *codec =
+                         &chip->codecs[codec_type];
 
-        spin_lock_irq(&chip->reg_lock);
-        snd_azf3328_codec_outb(chip, IDX_IO_PLAY_FLAGS, tmp);
-        snd_azf3328_codec_outb(chip, IDX_IO_REC_FLAGS, tmp);
-        snd_azf3328_codec_outb(chip, IDX_IO_SOMETHING_FLAGS, tmp);
-        spin_unlock_irq(&chip->reg_lock);
+                /* shutdown codecs to save power */
+                        /* have ...ctrl_codec_activity() act properly */
+                codec->running = 1;
+                snd_azf3328_ctrl_codec_activity(chip, codec_type, 0);
+
+                spin_lock_irq(&chip->reg_lock);
+                snd_azf3328_codec_outb(codec, IDX_IO_CODEC_DMA_FLAGS,
+                                                 dma_init);
+                spin_unlock_irq(&chip->reg_lock);
+        }
 
         snd_card_set_dev(card, &pci->dev);
 
@@ -2229,8 +2304,11 @@ snd_azf3328_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)
 
         card->private_data = chip;
 
+        /* chose to use MPU401_HW_AZT2320 ID instead of MPU401_HW_MPU401,
+           since our hardware ought to be similar, thus use same ID. */
         err = snd_mpu401_uart_new(
-                card, 0, MPU401_HW_MPU401, chip->mpu_io, MPU401_INFO_INTEGRATED,
+                card, 0,
+                MPU401_HW_AZT2320, chip->mpu_io, MPU401_INFO_INTEGRATED,
                 pci->irq, 0, &chip->rmidi
         );
         if (err < 0) {
@@ -2244,7 +2322,7 @@ snd_azf3328_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)
         if (err < 0)
                 goto out_err;
 
-        err = snd_azf3328_pcm(chip, 0);
+        err = snd_azf3328_pcm(chip);
         if (err < 0)
                 goto out_err;
 
@@ -2266,14 +2344,14 @@ snd_azf3328_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)
         opl3->private_data = chip;
 
         sprintf(card->longname, "%s at 0x%lx, irq %i",
-                card->shortname, chip->codec_io, chip->irq);
+                card->shortname, chip->ctrl_io, chip->irq);
 
         err = snd_card_register(card);
         if (err < 0)
                 goto out_err;
 
 #ifdef MODULE
-        printk(
+        printk(KERN_INFO
 "azt3328: Sound driver for Aztech AZF3328-based soundcards such as PCI168.\n"
 "azt3328: Hardware was completely undocumented, unfortunately.\n"
 "azt3328: Feel free to contact andi AT lisas.de for bug reports etc.!\n"
@@ -2308,36 +2386,52 @@ snd_azf3328_remove(struct pci_dev *pci)
 }
 
 #ifdef CONFIG_PM
+static inline void
+snd_azf3328_suspend_regs(unsigned long io_addr, unsigned count, u32 *saved_regs)
+{
+        unsigned reg;
+
+        for (reg = 0; reg < count; ++reg) {
+                *saved_regs = inl(io_addr);
+                snd_azf3328_dbgpm("suspend: io 0x%04lx: 0x%08x\n",
+                        io_addr, *saved_regs);
+                ++saved_regs;
+                io_addr += sizeof(*saved_regs);
+        }
+}
+
 static int
 snd_azf3328_suspend(struct pci_dev *pci, pm_message_t state)
 {
         struct snd_card *card = pci_get_drvdata(pci);
         struct snd_azf3328 *chip = card->private_data;
-        unsigned reg;
+        u16 *saved_regs_ctrl_u16;
 
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
 
-        snd_pcm_suspend_all(chip->pcm);
+        snd_pcm_suspend_all(chip->pcm[AZF_CODEC_PLAYBACK]);
+        snd_pcm_suspend_all(chip->pcm[AZF_CODEC_I2S_OUT]);
 
-        for (reg = 0; reg < AZF_IO_SIZE_MIXER_PM / 2; ++reg)
-                chip->saved_regs_mixer[reg] = inw(chip->mixer_io + reg * 2);
+        snd_azf3328_suspend_regs(chip->mixer_io,
+                ARRAY_SIZE(chip->saved_regs_mixer), chip->saved_regs_mixer);
 
         /* make sure to disable master volume etc. to prevent looping sound */
         snd_azf3328_mixer_set_mute(chip, IDX_MIXER_PLAY_MASTER, 1);
         snd_azf3328_mixer_set_mute(chip, IDX_MIXER_WAVEOUT, 1);
 
-        for (reg = 0; reg < AZF_IO_SIZE_CODEC_PM / 2; ++reg)
-                chip->saved_regs_codec[reg] = inw(chip->codec_io + reg * 2);
+        snd_azf3328_suspend_regs(chip->ctrl_io,
+                ARRAY_SIZE(chip->saved_regs_ctrl), chip->saved_regs_ctrl);
 
         /* manually store the one currently relevant write-only reg, too */
-        chip->saved_regs_codec[IDX_IO_6AH / 2] = chip->shadow_reg_codec_6AH;
+        saved_regs_ctrl_u16 = (u16 *)chip->saved_regs_ctrl;
+        saved_regs_ctrl_u16[IDX_IO_6AH / 2] = chip->shadow_reg_ctrl_6AH;
 
-        for (reg = 0; reg < AZF_IO_SIZE_GAME_PM / 2; ++reg)
-                chip->saved_regs_game[reg] = inw(chip->game_io + reg * 2);
-        for (reg = 0; reg < AZF_IO_SIZE_MPU_PM / 2; ++reg)
-                chip->saved_regs_mpu[reg] = inw(chip->mpu_io + reg * 2);
-        for (reg = 0; reg < AZF_IO_SIZE_OPL3_PM / 2; ++reg)
-                chip->saved_regs_opl3[reg] = inw(chip->opl3_io + reg * 2);
+        snd_azf3328_suspend_regs(chip->game_io,
+                ARRAY_SIZE(chip->saved_regs_game), chip->saved_regs_game);
+        snd_azf3328_suspend_regs(chip->mpu_io,
+                ARRAY_SIZE(chip->saved_regs_mpu), chip->saved_regs_mpu);
+        snd_azf3328_suspend_regs(chip->opl3_io,
+                ARRAY_SIZE(chip->saved_regs_opl3), chip->saved_regs_opl3);
 
         pci_disable_device(pci);
         pci_save_state(pci);
@@ -2345,12 +2439,28 @@ snd_azf3328_suspend(struct pci_dev *pci, pm_message_t state)
         return 0;
 }
 
+static inline void
+snd_azf3328_resume_regs(const u32 *saved_regs,
+                        unsigned long io_addr,
+                        unsigned count
+)
+{
+        unsigned reg;
+
+        for (reg = 0; reg < count; ++reg) {
+                outl(*saved_regs, io_addr);
+                snd_azf3328_dbgpm("resume: io 0x%04lx: 0x%08x --> 0x%08x\n",
+                        io_addr, *saved_regs, inl(io_addr));
+                ++saved_regs;
+                io_addr += sizeof(*saved_regs);
+        }
+}
+
 static int
 snd_azf3328_resume(struct pci_dev *pci)
 {
         struct snd_card *card = pci_get_drvdata(pci);
-        struct snd_azf3328 *chip = card->private_data;
-        unsigned reg;
+        const struct snd_azf3328 *chip = card->private_data;
 
         pci_set_power_state(pci, PCI_D0);
         pci_restore_state(pci);
@@ -2362,16 +2472,24 @@ snd_azf3328_resume(struct pci_dev *pci)
         }
         pci_set_master(pci);
 
-        for (reg = 0; reg < AZF_IO_SIZE_GAME_PM / 2; ++reg)
-                outw(chip->saved_regs_game[reg], chip->game_io + reg * 2);
-        for (reg = 0; reg < AZF_IO_SIZE_MPU_PM / 2; ++reg)
-                outw(chip->saved_regs_mpu[reg], chip->mpu_io + reg * 2);
-        for (reg = 0; reg < AZF_IO_SIZE_OPL3_PM / 2; ++reg)
-                outw(chip->saved_regs_opl3[reg], chip->opl3_io + reg * 2);
-        for (reg = 0; reg < AZF_IO_SIZE_MIXER_PM / 2; ++reg)
-                outw(chip->saved_regs_mixer[reg], chip->mixer_io + reg * 2);
-        for (reg = 0; reg < AZF_IO_SIZE_CODEC_PM / 2; ++reg)
-                outw(chip->saved_regs_codec[reg], chip->codec_io + reg * 2);
+        snd_azf3328_resume_regs(chip->saved_regs_game, chip->game_io,
+                                        ARRAY_SIZE(chip->saved_regs_game));
+        snd_azf3328_resume_regs(chip->saved_regs_mpu, chip->mpu_io,
+                                        ARRAY_SIZE(chip->saved_regs_mpu));
+        snd_azf3328_resume_regs(chip->saved_regs_opl3, chip->opl3_io,
+                                        ARRAY_SIZE(chip->saved_regs_opl3));
+
+        snd_azf3328_resume_regs(chip->saved_regs_mixer, chip->mixer_io,
+                                        ARRAY_SIZE(chip->saved_regs_mixer));
+
+        /* unfortunately with 32bit transfers, IDX_MIXER_PLAY_MASTER (0x02)
+           and IDX_MIXER_RESET (offset 0x00) get touched at the same time,
+           resulting in a mixer reset condition persisting until _after_
+           master vol was restored. Thus master vol needs an extra restore. */
+        outw(((u16 *)chip->saved_regs_mixer)[1], chip->mixer_io + 2);
+
+        snd_azf3328_resume_regs(chip->saved_regs_ctrl, chip->ctrl_io,
+                                        ARRAY_SIZE(chip->saved_regs_ctrl));
 
         snd_power_change_state(card, SNDRV_CTL_POWER_D0);
         return 0;
diff --git a/sound/pci/azt3328.h b/sound/pci/azt3328.h
index 974e05122f00..6f46b97650cc 100644
--- a/sound/pci/azt3328.h
+++ b/sound/pci/azt3328.h
@@ -6,50 +6,59 @@
 
 /*** main I/O area port indices ***/
 /* (only 0x70 of 0x80 bytes saved/restored by Windows driver) */
-#define AZF_IO_SIZE_CODEC       0x80
-#define AZF_IO_SIZE_CODEC_PM    0x70
+#define AZF_IO_SIZE_CTRL        0x80
+#define AZF_IO_SIZE_CTRL_PM     0x70
 
-/* the driver initialisation suggests a layout of 4 main areas:
- * from 0x00 (playback), from 0x20 (recording) and from 0x40 (maybe MPU401??).
+/* the driver initialisation suggests a layout of 4 areas
+ * within the main card control I/O:
+ * from 0x00 (playback codec), from 0x20 (recording codec)
+ * and from 0x40 (most certainly I2S out codec).
  * And another area from 0x60 to 0x6f (DirectX timer, IRQ management,
  * power management etc.???). */
 
-/** playback area **/
-#define IDX_IO_PLAY_FLAGS       0x00 /* PU:0x0000 */
+#define AZF_IO_OFFS_CODEC_PLAYBACK      0x00
+#define AZF_IO_OFFS_CODEC_CAPTURE       0x20
+#define AZF_IO_OFFS_CODEC_I2S_OUT       0x40
+
+#define IDX_IO_CODEC_DMA_FLAGS       0x00 /* PU:0x0000 */
      /* able to reactivate output after output muting due to 8/16bit
       * output change, just like 0x0002.
       * 0x0001 is the only bit that's able to start the DMA counter */
-  #define DMA_RESUME                    0x0001 /* paused if cleared ? */
+  #define DMA_RESUME                    0x0001 /* paused if cleared? */
      /* 0x0002 *temporarily* set during DMA stopping. hmm
       * both 0x0002 and 0x0004 set in playback setup. */
      /* able to reactivate output after output muting due to 8/16bit
       * output change, just like 0x0001. */
-  #define DMA_PLAY_SOMETHING1           0x0002 /* \ alternated (toggled) */
+  #define DMA_RUN_SOMETHING1            0x0002 /* \ alternated (toggled) */
      /* 0x0004: NOT able to reactivate output */
-  #define DMA_PLAY_SOMETHING2           0x0004 /* / bits */
+  #define DMA_RUN_SOMETHING2            0x0004 /* / bits */
   #define SOMETHING_ALMOST_ALWAYS_SET   0x0008 /* ???; can be modified */
   #define DMA_EPILOGUE_SOMETHING        0x0010
   #define DMA_SOMETHING_ELSE            0x0020 /* ??? */
-  #define SOMETHING_UNMODIFIABLE        0xffc0 /* unused ? not modifiable */
-#define IDX_IO_PLAY_IRQTYPE     0x02 /* PU:0x0001 */
+  #define SOMETHING_UNMODIFIABLE        0xffc0 /* unused? not modifiable */
+#define IDX_IO_CODEC_IRQTYPE     0x02 /* PU:0x0001 */
   /* write back to flags in case flags are set, in order to ACK IRQ in handler
    * (bit 1 of port 0x64 indicates interrupt for one of these three types)
    * sometimes in this case it just writes 0xffff to globally ACK all IRQs
    * settings written are not reflected when reading back, though.
-   * seems to be IRQ, too (frequently used: port |= 0x07 !), but who knows ? */
-  #define IRQ_PLAY_SOMETHING            0x0001 /* something & ACK */
-  #define IRQ_FINISHED_PLAYBUF_1        0x0002 /* 1st dmabuf finished & ACK */
-  #define IRQ_FINISHED_PLAYBUF_2        0x0004 /* 2nd dmabuf finished & ACK */
+   * seems to be IRQ, too (frequently used: port |= 0x07 !), but who knows? */
+  #define IRQ_SOMETHING                 0x0001 /* something & ACK */
+  #define IRQ_FINISHED_DMABUF_1         0x0002 /* 1st dmabuf finished & ACK */
+  #define IRQ_FINISHED_DMABUF_2         0x0004 /* 2nd dmabuf finished & ACK */
   #define IRQMASK_SOME_STATUS_1         0x0008 /* \ related bits */
   #define IRQMASK_SOME_STATUS_2         0x0010 /* / (checked together in loop) */
-  #define IRQMASK_UNMODIFIABLE          0xffe0 /* unused ? not modifiable */
-#define IDX_IO_PLAY_DMA_START_1 0x04 /* start address of 1st DMA play area, PU:0x00000000 */
-#define IDX_IO_PLAY_DMA_START_2 0x08 /* start address of 2nd DMA play area, PU:0x00000000 */
-#define IDX_IO_PLAY_DMA_LEN_1   0x0c /* length of 1st DMA play area, PU:0x0000 */
-#define IDX_IO_PLAY_DMA_LEN_2   0x0e /* length of 2nd DMA play area, PU:0x0000 */
-#define IDX_IO_PLAY_DMA_CURRPOS 0x10 /* current DMA position, PU:0x00000000 */
-#define IDX_IO_PLAY_DMA_CURROFS 0x14 /* offset within current DMA play area, PU:0x0000 */
-#define IDX_IO_PLAY_SOUNDFORMAT 0x16 /* PU:0x0010 */
+  #define IRQMASK_UNMODIFIABLE          0xffe0 /* unused? not modifiable */
+  /* start address of 1st DMA transfer area, PU:0x00000000 */
+#define IDX_IO_CODEC_DMA_START_1 0x04
+  /* start address of 2nd DMA transfer area, PU:0x00000000 */
+#define IDX_IO_CODEC_DMA_START_2 0x08
+  /* both lengths of DMA transfer areas, PU:0x00000000
+     length1: offset 0x0c, length2: offset 0x0e */
+#define IDX_IO_CODEC_DMA_LENGTHS 0x0c
+#define IDX_IO_CODEC_DMA_CURRPOS 0x10 /* current DMA position, PU:0x00000000 */
+  /* offset within current DMA transfer area, PU:0x0000 */
+#define IDX_IO_CODEC_DMA_CURROFS 0x14
+#define IDX_IO_CODEC_SOUNDFORMAT 0x16 /* PU:0x0010 */
   /* all unspecified bits can't be modified */
   #define SOUNDFORMAT_FREQUENCY_MASK    0x000f
   #define SOUNDFORMAT_XTAL1             0x00
@@ -76,6 +85,7 @@
   #define SOUNDFORMAT_FLAG_16BIT        0x0010
   #define SOUNDFORMAT_FLAG_2CHANNELS    0x0020
 
+
 /* define frequency helpers, for maximum value safety */
 enum azf_freq_t {
 #define AZF_FREQ(rate) AZF_FREQ_##rate = rate
@@ -96,29 +106,6 @@ enum azf_freq_t {
 #undef AZF_FREQ
 };
 
-/** recording area (see also: playback bit flag definitions) **/
-#define IDX_IO_REC_FLAGS        0x20 /* ??, PU:0x0000 */
-#define IDX_IO_REC_IRQTYPE      0x22 /* ??, PU:0x0000 */
-  #define IRQ_REC_SOMETHING             0x0001 /* something & ACK */
-  #define IRQ_FINISHED_RECBUF_1         0x0002 /* 1st dmabuf finished & ACK */
-  #define IRQ_FINISHED_RECBUF_2         0x0004 /* 2nd dmabuf finished & ACK */
-  /* hmm, maybe these are just the corresponding *recording* flags ?
-   * but OTOH they are most likely at port 0x22 instead */
-  #define IRQMASK_SOME_STATUS_1         0x0008 /* \ related bits */
-  #define IRQMASK_SOME_STATUS_2         0x0010 /* / (checked together in loop) */
-#define IDX_IO_REC_DMA_START_1  0x24 /* PU:0x00000000 */
-#define IDX_IO_REC_DMA_START_2  0x28 /* PU:0x00000000 */
-#define IDX_IO_REC_DMA_LEN_1    0x2c /* PU:0x0000 */
-#define IDX_IO_REC_DMA_LEN_2    0x2e /* PU:0x0000 */
-#define IDX_IO_REC_DMA_CURRPOS  0x30 /* PU:0x00000000 */
-#define IDX_IO_REC_DMA_CURROFS  0x34 /* PU:0x00000000 */
-#define IDX_IO_REC_SOUNDFORMAT  0x36 /* PU:0x0000 */
-
-/** hmm, what is this I/O area for? MPU401?? or external DAC via I2S?? (after playback, recording, ???, timer) **/
-#define IDX_IO_SOMETHING_FLAGS  0x40 /* gets set to 0x34 just like port 0x0 and 0x20 on card init, PU:0x0000 */
-/* general */
-#define IDX_IO_42H              0x42 /* PU:0x0001 */
-
 /** DirectX timer, main interrupt area (FIXME: and something else?) **/ 
 #define IDX_IO_TIMER_VALUE      0x60 /* found this timer area by pure luck :-) */
   /* timer countdown value; triggers IRQ when timer is finished */
@@ -133,17 +120,19 @@ enum azf_freq_t {
 #define IDX_IO_IRQSTATUS        0x64
   /* some IRQ bit in here might also be used to signal a power-management timer
    * timeout, to request shutdown of the chip (e.g. AD1815JS has such a thing).
-   * Some OPL3 hardware (e.g. in LM4560) has some special timer hardware which
-   * can trigger an OPL3 timer IRQ, so maybe there's such a thing as well... */
+   * OPL3 hardware contains several timers which confusingly in most cases
+   * are NOT routed to an IRQ, but some designs (e.g. LM4560) DO support that,
+   * so I wouldn't be surprised at all to discover that AZF3328
+   * supports that thing as well... */
 
   #define IRQ_PLAYBACK  0x0001
   #define IRQ_RECORDING 0x0002
-  #define IRQ_UNKNOWN1  0x0004 /* most probably I2S port */
+  #define IRQ_I2S_OUT   0x0004 /* this IS I2S, right!? (untested) */
   #define IRQ_GAMEPORT  0x0008 /* Interrupt of Digital(ly) Enhanced Game Port */
   #define IRQ_MPU401    0x0010
   #define IRQ_TIMER     0x0020 /* DirectX timer */
-  #define IRQ_UNKNOWN2  0x0040 /* probably unused, or possibly I2S port? */
-  #define IRQ_UNKNOWN3  0x0080 /* probably unused, or possibly I2S port? */
+  #define IRQ_UNKNOWN2  0x0040 /* probably unused, or possibly OPL3 timer? */
+  #define IRQ_UNKNOWN3  0x0080 /* probably unused, or possibly OPL3 timer? */
 #define IDX_IO_66H              0x66    /* writing 0xffff returns 0x0000 */
   /* this is set to e.g. 0x3ff or 0x300, and writable;
    * maybe some buffer limit, but I couldn't find out more, PU:0x00ff: */
@@ -206,7 +195,7 @@ enum azf_freq_t {
 /*** Gameport area port indices ***/
 /* (only 0x06 of 0x08 bytes saved/restored by Windows driver) */ 
 #define AZF_IO_SIZE_GAME                0x08
-#define AZF_IO_SIZE_GAME_PM     0x06
+#define AZF_IO_SIZE_GAME_PM             0x06
 
 enum {
         AZF_GAME_LEGACY_IO_PORT = 0x200
@@ -272,6 +261,12 @@ enum {
    * 11 --> 1/200: */
   #define GAME_HWCFG_ADC_COUNTER_FREQ_MASK      0x06
 
+  /* FIXME: these values might be reversed... */
+  #define GAME_HWCFG_ADC_COUNTER_FREQ_STD       0
+  #define GAME_HWCFG_ADC_COUNTER_FREQ_1_2       1
+  #define GAME_HWCFG_ADC_COUNTER_FREQ_1_20      2
+  #define GAME_HWCFG_ADC_COUNTER_FREQ_1_200     3
+
   /* enable gameport legacy I/O address (0x200)
    * I was unable to locate any configurability for a different address: */
   #define GAME_HWCFG_LEGACY_ADDRESS_ENABLE      0x08
@@ -281,6 +276,7 @@ enum {
 #define AZF_IO_SIZE_MPU_PM      0x04
 
 /*** OPL3 synth ***/
+/* (only 0x06 of 0x08 bytes saved/restored by Windows driver) */
 #define AZF_IO_SIZE_OPL3        0x08
 #define AZF_IO_SIZE_OPL3_PM     0x06
 /* hmm, given that a standard OPL3 has 4 registers only,
@@ -340,4 +336,7 @@ enum {
 #define SET_CHAN_LEFT   1
 #define SET_CHAN_RIGHT  2
 
+/* helper macro to align I/O port ranges to 32bit I/O width */
+#define AZF_ALIGN(x) (((x) + 3) & (~3))
+
 #endif /* __SOUND_AZT3328_H  */
diff --git a/sound/pci/ca0106/ca0106_main.c b/sound/pci/ca0106/ca0106_main.c
index 57b992a5c057..15e4138bce17 100644
--- a/sound/pci/ca0106/ca0106_main.c
+++ b/sound/pci/ca0106/ca0106_main.c
@@ -325,9 +325,9 @@ static struct snd_pcm_hardware snd_ca0106_capture_hw = {
         .rate_max =             192000,
         .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,
         .fifo_size =            0,
@@ -1876,7 +1876,7 @@ static int snd_ca0106_resume(struct pci_dev *pci)
 
 // 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, }
 };
 MODULE_DEVICE_TABLE(pci, snd_ca0106_ids);
diff --git a/sound/pci/cmipci.c b/sound/pci/cmipci.c
index 449fe02f666e..ddcd4a9fd7e6 100644
--- a/sound/pci/cmipci.c
+++ b/sound/pci/cmipci.c
@@ -2797,11 +2797,11 @@ static inline void snd_cmipci_proc_init(struct cmipci *cm) {}
 
 
 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,},
 };
 
diff --git a/sound/pci/cs4281.c b/sound/pci/cs4281.c
index f6286f84a221..e2e0359bb056 100644
--- a/sound/pci/cs4281.c
+++ b/sound/pci/cs4281.c
@@ -495,7 +495,7 @@ struct cs4281 {
 static irqreturn_t snd_cs4281_interrupt(int irq, void *dev_id);
 
 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, }
 };
 
diff --git a/sound/pci/cs46xx/cs46xx.c b/sound/pci/cs46xx/cs46xx.c
index c9b3e3d48cbc..033aec430117 100644
--- a/sound/pci/cs46xx/cs46xx.c
+++ b/sound/pci/cs46xx/cs46xx.c
@@ -65,9 +65,9 @@ module_param_array(mmap_valid, bool, NULL, 0444);
 MODULE_PARM_DESC(mmap_valid, "Support OSS mmap.");
 
 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, }
 };
 
diff --git a/sound/pci/cs46xx/cs46xx_lib.h b/sound/pci/cs46xx/cs46xx_lib.h
index 4eb55aa33612..b5189495d58a 100644
--- a/sound/pci/cs46xx/cs46xx_lib.h
+++ b/sound/pci/cs46xx/cs46xx_lib.h
@@ -35,7 +35,7 @@
 
 
 #ifdef CONFIG_SND_CS46XX_NEW_DSP
-#define CS46XX_MIN_PERIOD_SIZE 1
+#define CS46XX_MIN_PERIOD_SIZE 64
 #define CS46XX_MAX_PERIOD_SIZE 1024*1024
 #else
 #define CS46XX_MIN_PERIOD_SIZE 2048
diff --git a/sound/pci/ctxfi/ct20k2reg.h b/sound/pci/ctxfi/ct20k2reg.h
index 2d07986f57cc..e0394e3996e8 100644
--- a/sound/pci/ctxfi/ct20k2reg.h
+++ b/sound/pci/ctxfi/ct20k2reg.h
@@ -11,9 +11,12 @@
 
 
 /* Timer Registers */
-#define TIMER_TIMR          0x1B7004
-#define INTERRUPT_GIP       0x1B7010
-#define INTERRUPT_GIE       0x1B7014
+#define WC              0x1b7000
+#define TIMR            0x1b7004
+# define        TIMR_IE         (1<<15)
+# define        TIMR_IP         (1<<14)
+#define GIP             0x1b7010
+#define GIE             0x1b7014
 
 /* I2C Registers */
 #define I2C_IF_ADDRESS   0x1B9000
diff --git a/sound/pci/ctxfi/ctamixer.c b/sound/pci/ctxfi/ctamixer.c
index a1db51b3ead8..fee35cfc0c7f 100644
--- a/sound/pci/ctxfi/ctamixer.c
+++ b/sound/pci/ctxfi/ctamixer.c
@@ -63,7 +63,7 @@ static int amixer_set_input(struct amixer *amixer, struct rsc *rsc)
         hw = amixer->rsc.hw;
         hw->amixer_set_mode(amixer->rsc.ctrl_blk, AMIXER_Y_IMMEDIATE);
         amixer->input = rsc;
-        if (NULL == rsc)
+        if (!rsc)
                 hw->amixer_set_x(amixer->rsc.ctrl_blk, BLANK_SLOT);
         else
                 hw->amixer_set_x(amixer->rsc.ctrl_blk,
@@ -99,7 +99,7 @@ static int amixer_set_sum(struct amixer *amixer, struct sum *sum)
 
         hw = amixer->rsc.hw;
         amixer->sum = sum;
-        if (NULL == sum) {
+        if (!sum) {
                 hw->amixer_set_se(amixer->rsc.ctrl_blk, 0);
         } else {
                 hw->amixer_set_se(amixer->rsc.ctrl_blk, 1);
@@ -124,20 +124,20 @@ static int amixer_commit_write(struct amixer *amixer)
 
         /* Program master and conjugate resources */
         amixer->rsc.ops->master(&amixer->rsc);
-        if (NULL != input)
+        if (input)
                 input->ops->master(input);
 
-        if (NULL != sum)
+        if (sum)
                 sum->rsc.ops->master(&sum->rsc);
 
         for (i = 0; i < amixer->rsc.msr; i++) {
                 hw->amixer_set_dirty_all(amixer->rsc.ctrl_blk);
-                if (NULL != input) {
+                if (input) {
                         hw->amixer_set_x(amixer->rsc.ctrl_blk,
                                                 input->ops->output_slot(input));
                         input->ops->next_conj(input);
                 }
-                if (NULL != sum) {
+                if (sum) {
                         hw->amixer_set_sadr(amixer->rsc.ctrl_blk,
                                                 sum->rsc.ops->index(&sum->rsc));
                         sum->rsc.ops->next_conj(&sum->rsc);
@@ -147,10 +147,10 @@ static int amixer_commit_write(struct amixer *amixer)
                 amixer->rsc.ops->next_conj(&amixer->rsc);
         }
         amixer->rsc.ops->master(&amixer->rsc);
-        if (NULL != input)
+        if (input)
                 input->ops->master(input);
 
-        if (NULL != sum)
+        if (sum)
                 sum->rsc.ops->master(&sum->rsc);
 
         return 0;
@@ -242,13 +242,12 @@ static int get_amixer_rsc(struct amixer_mgr *mgr,
 
         /* Allocate mem for amixer resource */
         amixer = kzalloc(sizeof(*amixer), GFP_KERNEL);
-        if (NULL == amixer) {
-                err = -ENOMEM;
-                return err;
-        }
+        if (!amixer)
+                return -ENOMEM;
 
         /* Check whether there are sufficient
          * amixer resources to meet request. */
+        err = 0;
         spin_lock_irqsave(&mgr->mgr_lock, flags);
         for (i = 0; i < desc->msr; i++) {
                 err = mgr_get_resource(&mgr->mgr, 1, &idx);
@@ -304,7 +303,7 @@ int amixer_mgr_create(void *hw, struct amixer_mgr **ramixer_mgr)
 
         *ramixer_mgr = NULL;
         amixer_mgr = kzalloc(sizeof(*amixer_mgr), GFP_KERNEL);
-        if (NULL == amixer_mgr)
+        if (!amixer_mgr)
                 return -ENOMEM;
 
         err = rsc_mgr_init(&amixer_mgr->mgr, AMIXER, AMIXER_RESOURCE_NUM, hw);
@@ -397,12 +396,11 @@ static int get_sum_rsc(struct sum_mgr *mgr,
 
         /* Allocate mem for sum resource */
         sum = kzalloc(sizeof(*sum), GFP_KERNEL);
-        if (NULL == sum) {
-                err = -ENOMEM;
-                return err;
-        }
+        if (!sum)
+                return -ENOMEM;
 
         /* Check whether there are sufficient sum resources to meet request. */
+        err = 0;
         spin_lock_irqsave(&mgr->mgr_lock, flags);
         for (i = 0; i < desc->msr; i++) {
                 err = mgr_get_resource(&mgr->mgr, 1, &idx);
@@ -458,7 +456,7 @@ int sum_mgr_create(void *hw, struct sum_mgr **rsum_mgr)
 
         *rsum_mgr = NULL;
         sum_mgr = kzalloc(sizeof(*sum_mgr), GFP_KERNEL);
-        if (NULL == sum_mgr)
+        if (!sum_mgr)
                 return -ENOMEM;
 
         err = rsc_mgr_init(&sum_mgr->mgr, SUM, SUM_RESOURCE_NUM, hw);
diff --git a/sound/pci/ctxfi/ctatc.c b/sound/pci/ctxfi/ctatc.c
index a49c76647307..75454648d50c 100644
--- a/sound/pci/ctxfi/ctatc.c
+++ b/sound/pci/ctxfi/ctatc.c
@@ -136,7 +136,7 @@ static int ct_map_audio_buffer(struct ct_atc *atc, struct ct_atc_pcm *apcm)
         struct snd_pcm_runtime *runtime;
         struct ct_vm *vm;
 
-        if (NULL == apcm->substream)
+        if (!apcm->substream)
                 return 0;
 
         runtime = apcm->substream->runtime;
@@ -144,7 +144,7 @@ static int ct_map_audio_buffer(struct ct_atc *atc, struct ct_atc_pcm *apcm)
 
         apcm->vm_block = vm->map(vm, apcm->substream, runtime->dma_bytes);
 
-        if (NULL == apcm->vm_block)
+        if (!apcm->vm_block)
                 return -ENOENT;
 
         return 0;
@@ -154,7 +154,7 @@ static void ct_unmap_audio_buffer(struct ct_atc *atc, struct ct_atc_pcm *apcm)
 {
         struct ct_vm *vm;
 
-        if (NULL == apcm->vm_block)
+        if (!apcm->vm_block)
                 return;
 
         vm = atc->vm;
@@ -231,16 +231,16 @@ atc_get_pitch(unsigned int input_rate, unsigned int output_rate)
 
 static int select_rom(unsigned int pitch)
 {
-        if ((pitch > 0x00428f5c) && (pitch < 0x01b851ec)) {
+        if (pitch > 0x00428f5c && pitch < 0x01b851ec) {
                 /* 0.26 <= pitch <= 1.72 */
                 return 1;
-        } else if ((0x01d66666 == pitch) || (0x01d66667 == pitch)) {
+        } else if (pitch == 0x01d66666 || pitch == 0x01d66667) {
                 /* pitch == 1.8375 */
                 return 2;
-        } else if (0x02000000 == pitch) {
+        } else if (pitch == 0x02000000) {
                 /* pitch == 2 */
                 return 3;
-        } else if ((pitch >= 0x0) && (pitch <= 0x08000000)) {
+        } else if (pitch >= 0x0 && pitch <= 0x08000000) {
                 /* 0 <= pitch <= 8 */
                 return 0;
         } else {
@@ -283,7 +283,7 @@ static int atc_pcm_playback_prepare(struct ct_atc *atc, struct ct_atc_pcm *apcm)
         /* Get AMIXER resource */
         n_amixer = (n_amixer < 2) ? 2 : n_amixer;
         apcm->amixers = kzalloc(sizeof(void *)*n_amixer, GFP_KERNEL);
-        if (NULL == apcm->amixers) {
+        if (!apcm->amixers) {
                 err = -ENOMEM;
                 goto error1;
         }
@@ -311,7 +311,7 @@ static int atc_pcm_playback_prepare(struct ct_atc *atc, struct ct_atc_pcm *apcm)
                                         INIT_VOL, atc->pcm[i+device*2]);
                 mutex_unlock(&atc->atc_mutex);
                 src = src->ops->next_interleave(src);
-                if (NULL == src)
+                if (!src)
                         src = apcm->src;
         }
 
@@ -334,7 +334,7 @@ atc_pcm_release_resources(struct ct_atc *atc, struct ct_atc_pcm *apcm)
         struct srcimp *srcimp;
         int i;
 
-        if (NULL != apcm->srcimps) {
+        if (apcm->srcimps) {
                 for (i = 0; i < apcm->n_srcimp; i++) {
                         srcimp = apcm->srcimps[i];
                         srcimp->ops->unmap(srcimp);
@@ -345,7 +345,7 @@ atc_pcm_release_resources(struct ct_atc *atc, struct ct_atc_pcm *apcm)
                 apcm->srcimps = NULL;
         }
 
-        if (NULL != apcm->srccs) {
+        if (apcm->srccs) {
                 for (i = 0; i < apcm->n_srcc; i++) {
                         src_mgr->put_src(src_mgr, apcm->srccs[i]);
                         apcm->srccs[i] = NULL;
@@ -354,7 +354,7 @@ atc_pcm_release_resources(struct ct_atc *atc, struct ct_atc_pcm *apcm)
                 apcm->srccs = NULL;
         }
 
-        if (NULL != apcm->amixers) {
+        if (apcm->amixers) {
                 for (i = 0; i < apcm->n_amixer; i++) {
                         amixer_mgr->put_amixer(amixer_mgr, apcm->amixers[i]);
                         apcm->amixers[i] = NULL;
@@ -363,17 +363,17 @@ atc_pcm_release_resources(struct ct_atc *atc, struct ct_atc_pcm *apcm)
                 apcm->amixers = NULL;
         }
 
-        if (NULL != apcm->mono) {
+        if (apcm->mono) {
                 sum_mgr->put_sum(sum_mgr, apcm->mono);
                 apcm->mono = NULL;
         }
 
-        if (NULL != apcm->src) {
+        if (apcm->src) {
                 src_mgr->put_src(src_mgr, apcm->src);
                 apcm->src = NULL;
         }
 
-        if (NULL != apcm->vm_block) {
+        if (apcm->vm_block) {
                 /* Undo device virtual mem map */
                 ct_unmap_audio_buffer(atc, apcm);
                 apcm->vm_block = NULL;
@@ -419,7 +419,7 @@ static int atc_pcm_stop(struct ct_atc *atc, struct ct_atc_pcm *apcm)
         src->ops->set_state(src, SRC_STATE_OFF);
         src->ops->commit_write(src);
 
-        if (NULL != apcm->srccs) {
+        if (apcm->srccs) {
                 for (i = 0; i < apcm->n_srcc; i++) {
                         src = apcm->srccs[i];
                         src->ops->set_bm(src, 0);
@@ -544,18 +544,18 @@ atc_pcm_capture_get_resources(struct ct_atc *atc, struct ct_atc_pcm *apcm)
 
         if (n_srcc) {
                 apcm->srccs = kzalloc(sizeof(void *)*n_srcc, GFP_KERNEL);
-                if (NULL == apcm->srccs)
+                if (!apcm->srccs)
                         return -ENOMEM;
         }
         if (n_amixer) {
                 apcm->amixers = kzalloc(sizeof(void *)*n_amixer, GFP_KERNEL);
-                if (NULL == apcm->amixers) {
+                if (!apcm->amixers) {
                         err = -ENOMEM;
                         goto error1;
                 }
         }
         apcm->srcimps = kzalloc(sizeof(void *)*n_srcimp, GFP_KERNEL);
-        if (NULL == apcm->srcimps) {
+        if (!apcm->srcimps) {
                 err = -ENOMEM;
                 goto error1;
         }
@@ -818,7 +818,7 @@ static int spdif_passthru_playback_get_resources(struct ct_atc *atc,
         /* Get AMIXER resource */
         n_amixer = (n_amixer < 2) ? 2 : n_amixer;
         apcm->amixers = kzalloc(sizeof(void *)*n_amixer, GFP_KERNEL);
-        if (NULL == apcm->amixers) {
+        if (!apcm->amixers) {
                 err = -ENOMEM;
                 goto error1;
         }
@@ -919,7 +919,7 @@ spdif_passthru_playback_prepare(struct ct_atc *atc, struct ct_atc_pcm *apcm)
                 amixer = apcm->amixers[i];
                 amixer->ops->setup(amixer, &src->rsc, INIT_VOL, NULL);
                 src = src->ops->next_interleave(src);
-                if (NULL == src)
+                if (!src)
                         src = apcm->src;
         }
         /* Connect to SPDIFOO */
@@ -1037,7 +1037,7 @@ static int atc_line_front_unmute(struct ct_atc *atc, unsigned char state)
 
 static int atc_line_surround_unmute(struct ct_atc *atc, unsigned char state)
 {
-        return atc_daio_unmute(atc, state, LINEO4);
+        return atc_daio_unmute(atc, state, LINEO2);
 }
 
 static int atc_line_clfe_unmute(struct ct_atc *atc, unsigned char state)
@@ -1047,7 +1047,7 @@ static int atc_line_clfe_unmute(struct ct_atc *atc, unsigned char state)
 
 static int atc_line_rear_unmute(struct ct_atc *atc, unsigned char state)
 {
-        return atc_daio_unmute(atc, state, LINEO2);
+        return atc_daio_unmute(atc, state, LINEO4);
 }
 
 static int atc_line_in_unmute(struct ct_atc *atc, unsigned char state)
@@ -1121,7 +1121,7 @@ static int atc_release_resources(struct ct_atc *atc)
         struct ct_mixer *mixer = NULL;
 
         /* disconnect internal mixer objects */
-        if (NULL != atc->mixer) {
+        if (atc->mixer) {
                 mixer = atc->mixer;
                 mixer->set_input_left(mixer, MIX_LINE_IN, NULL);
                 mixer->set_input_right(mixer, MIX_LINE_IN, NULL);
@@ -1131,7 +1131,7 @@ static int atc_release_resources(struct ct_atc *atc)
                 mixer->set_input_right(mixer, MIX_SPDIF_IN, NULL);
         }
 
-        if (NULL != atc->daios) {
+        if (atc->daios) {
                 daio_mgr = (struct daio_mgr *)atc->rsc_mgrs[DAIO];
                 for (i = 0; i < atc->n_daio; i++) {
                         daio = atc->daios[i];
@@ -1149,7 +1149,7 @@ static int atc_release_resources(struct ct_atc *atc)
                 atc->daios = NULL;
         }
 
-        if (NULL != atc->pcm) {
+        if (atc->pcm) {
                 sum_mgr = atc->rsc_mgrs[SUM];
                 for (i = 0; i < atc->n_pcm; i++)
                         sum_mgr->put_sum(sum_mgr, atc->pcm[i]);
@@ -1158,7 +1158,7 @@ static int atc_release_resources(struct ct_atc *atc)
                 atc->pcm = NULL;
         }
 
-        if (NULL != atc->srcs) {
+        if (atc->srcs) {
                 src_mgr = atc->rsc_mgrs[SRC];
                 for (i = 0; i < atc->n_src; i++)
                         src_mgr->put_src(src_mgr, atc->srcs[i]);
@@ -1167,7 +1167,7 @@ static int atc_release_resources(struct ct_atc *atc)
                 atc->srcs = NULL;
         }
 
-        if (NULL != atc->srcimps) {
+        if (atc->srcimps) {
                 srcimp_mgr = atc->rsc_mgrs[SRCIMP];
                 for (i = 0; i < atc->n_srcimp; i++) {
                         srcimp = atc->srcimps[i];
@@ -1185,7 +1185,7 @@ static int ct_atc_destroy(struct ct_atc *atc)
 {
         int i = 0;
 
-        if (NULL == atc)
+        if (!atc)
                 return 0;
 
         if (atc->timer) {
@@ -1196,21 +1196,20 @@ static int ct_atc_destroy(struct ct_atc *atc)
         atc_release_resources(atc);
 
         /* Destroy internal mixer objects */
-        if (NULL != atc->mixer)
+        if (atc->mixer)
                 ct_mixer_destroy(atc->mixer);
 
         for (i = 0; i < NUM_RSCTYP; i++) {
-                if ((NULL != rsc_mgr_funcs[i].destroy) &&
-                    (NULL != atc->rsc_mgrs[i]))
+                if (rsc_mgr_funcs[i].destroy && atc->rsc_mgrs[i])
                         rsc_mgr_funcs[i].destroy(atc->rsc_mgrs[i]);
 
         }
 
-        if (NULL != atc->hw)
+        if (atc->hw)
                 destroy_hw_obj((struct hw *)atc->hw);
 
         /* Destroy device virtual memory manager object */
-        if (NULL != atc->vm) {
+        if (atc->vm) {
                 ct_vm_destroy(atc->vm);
                 atc->vm = NULL;
         }
@@ -1275,7 +1274,7 @@ int __devinit ct_atc_create_alsa_devs(struct ct_atc *atc)
         alsa_dev_funcs[MIXER].public_name = atc->chip_name;
 
         for (i = 0; i < NUM_CTALSADEVS; i++) {
-                if (NULL == alsa_dev_funcs[i].create)
+                if (!alsa_dev_funcs[i].create)
                         continue;
 
                 err = alsa_dev_funcs[i].create(atc, i,
@@ -1312,7 +1311,7 @@ static int __devinit atc_create_hw_devs(struct ct_atc *atc)
                 return err;
 
         for (i = 0; i < NUM_RSCTYP; i++) {
-                if (NULL == rsc_mgr_funcs[i].create)
+                if (!rsc_mgr_funcs[i].create)
                         continue;
 
                 err = rsc_mgr_funcs[i].create(atc->hw, &atc->rsc_mgrs[i]);
@@ -1339,19 +1338,19 @@ static int atc_get_resources(struct ct_atc *atc)
         int err, i;
 
         atc->daios = kzalloc(sizeof(void *)*(DAIONUM), GFP_KERNEL);
-        if (NULL == atc->daios)
+        if (!atc->daios)
                 return -ENOMEM;
 
         atc->srcs = kzalloc(sizeof(void *)*(2*2), GFP_KERNEL);
-        if (NULL == atc->srcs)
+        if (!atc->srcs)
                 return -ENOMEM;
 
         atc->srcimps = kzalloc(sizeof(void *)*(2*2), GFP_KERNEL);
-        if (NULL == atc->srcimps)
+        if (!atc->srcimps)
                 return -ENOMEM;
 
         atc->pcm = kzalloc(sizeof(void *)*(2*4), GFP_KERNEL);
-        if (NULL == atc->pcm)
+        if (!atc->pcm)
                 return -ENOMEM;
 
         daio_mgr = (struct daio_mgr *)atc->rsc_mgrs[DAIO];
@@ -1648,7 +1647,7 @@ int __devinit ct_atc_create(struct snd_card *card, struct pci_dev *pci,
         *ratc = NULL;
 
         atc = kzalloc(sizeof(*atc), GFP_KERNEL);
-        if (NULL == atc)
+        if (!atc)
                 return -ENOMEM;
 
         /* Set operations */
diff --git a/sound/pci/ctxfi/ctdaio.c b/sound/pci/ctxfi/ctdaio.c
index 082e35c08c02..af56eb949bde 100644
--- a/sound/pci/ctxfi/ctdaio.c
+++ b/sound/pci/ctxfi/ctdaio.c
@@ -57,9 +57,9 @@ struct daio_rsc_idx idx_20k1[NUM_DAIOTYP] = {
 
 struct daio_rsc_idx idx_20k2[NUM_DAIOTYP] = {
         [LINEO1] = {.left = 0x40, .right = 0x41},
-        [LINEO2] = {.left = 0x70, .right = 0x71},
+        [LINEO2] = {.left = 0x60, .right = 0x61},
         [LINEO3] = {.left = 0x50, .right = 0x51},
-        [LINEO4] = {.left = 0x60, .right = 0x61},
+        [LINEO4] = {.left = 0x70, .right = 0x71},
         [LINEIM] = {.left = 0x45, .right = 0xc5},
         [SPDIFOO] = {.left = 0x00, .right = 0x01},
         [SPDIFIO] = {.left = 0x05, .right = 0x85},
@@ -173,7 +173,7 @@ static int dao_set_left_input(struct dao *dao, struct rsc *input)
         int i;
 
         entry = kzalloc((sizeof(*entry) * daio->rscl.msr), GFP_KERNEL);
-        if (NULL == entry)
+        if (!entry)
                 return -ENOMEM;
 
         /* Program master and conjugate resources */
@@ -201,7 +201,7 @@ static int dao_set_right_input(struct dao *dao, struct rsc *input)
         int i;
 
         entry = kzalloc((sizeof(*entry) * daio->rscr.msr), GFP_KERNEL);
-        if (NULL == entry)
+        if (!entry)
                 return -ENOMEM;
 
         /* Program master and conjugate resources */
@@ -228,7 +228,7 @@ static int dao_clear_left_input(struct dao *dao)
         struct daio *daio = &dao->daio;
         int i;
 
-        if (NULL == dao->imappers[0])
+        if (!dao->imappers[0])
                 return 0;
 
         entry = dao->imappers[0];
@@ -252,7 +252,7 @@ static int dao_clear_right_input(struct dao *dao)
         struct daio *daio = &dao->daio;
         int i;
 
-        if (NULL == dao->imappers[daio->rscl.msr])
+        if (!dao->imappers[daio->rscl.msr])
                 return 0;
 
         entry = dao->imappers[daio->rscl.msr];
@@ -408,7 +408,7 @@ static int dao_rsc_init(struct dao *dao,
                 return err;
 
         dao->imappers = kzalloc(sizeof(void *)*desc->msr*2, GFP_KERNEL);
-        if (NULL == dao->imappers) {
+        if (!dao->imappers) {
                 err = -ENOMEM;
                 goto error1;
         }
@@ -442,11 +442,11 @@ error1:
 
 static int dao_rsc_uninit(struct dao *dao)
 {
-        if (NULL != dao->imappers) {
-                if (NULL != dao->imappers[0])
+        if (dao->imappers) {
+                if (dao->imappers[0])
                         dao_clear_left_input(dao);
 
-                if (NULL != dao->imappers[dao->daio.rscl.msr])
+                if (dao->imappers[dao->daio.rscl.msr])
                         dao_clear_right_input(dao);
 
                 kfree(dao->imappers);
@@ -555,7 +555,7 @@ static int get_daio_rsc(struct daio_mgr *mgr,
         /* Allocate mem for daio resource */
         if (desc->type <= DAIO_OUT_MAX) {
                 dao = kzalloc(sizeof(*dao), GFP_KERNEL);
-                if (NULL == dao) {
+                if (!dao) {
                         err = -ENOMEM;
                         goto error;
                 }
@@ -566,7 +566,7 @@ static int get_daio_rsc(struct daio_mgr *mgr,
                 *rdaio = &dao->daio;
         } else {
                 dai = kzalloc(sizeof(*dai), GFP_KERNEL);
-                if (NULL == dai) {
+                if (!dai) {
                         err = -ENOMEM;
                         goto error;
                 }
@@ -583,9 +583,9 @@ static int get_daio_rsc(struct daio_mgr *mgr,
         return 0;
 
 error:
-        if (NULL != dao)
+        if (dao)
                 kfree(dao);
-        else if (NULL != dai)
+        else if (dai)
                 kfree(dai);
 
         spin_lock_irqsave(&mgr->mgr_lock, flags);
@@ -663,7 +663,7 @@ static int daio_imap_add(struct daio_mgr *mgr, struct imapper *entry)
         int err;
 
         spin_lock_irqsave(&mgr->imap_lock, flags);
-        if ((0 == entry->addr) && (mgr->init_imap_added)) {
+        if (!entry->addr && mgr->init_imap_added) {
                 input_mapper_delete(&mgr->imappers, mgr->init_imap,
                                                         daio_map_op, mgr);
                 mgr->init_imap_added = 0;
@@ -707,7 +707,7 @@ int daio_mgr_create(void *hw, struct daio_mgr **rdaio_mgr)
 
         *rdaio_mgr = NULL;
         daio_mgr = kzalloc(sizeof(*daio_mgr), GFP_KERNEL);
-        if (NULL == daio_mgr)
+        if (!daio_mgr)
                 return -ENOMEM;
 
         err = rsc_mgr_init(&daio_mgr->mgr, DAIO, DAIO_RESOURCE_NUM, hw);
@@ -718,7 +718,7 @@ int daio_mgr_create(void *hw, struct daio_mgr **rdaio_mgr)
         spin_lock_init(&daio_mgr->imap_lock);
         INIT_LIST_HEAD(&daio_mgr->imappers);
         entry = kzalloc(sizeof(*entry), GFP_KERNEL);
-        if (NULL == entry) {
+        if (!entry) {
                 err = -ENOMEM;
                 goto error2;
         }
diff --git a/sound/pci/ctxfi/cthw20k1.c b/sound/pci/ctxfi/cthw20k1.c
index ad3e1d144464..0cf400f879f9 100644
--- a/sound/pci/ctxfi/cthw20k1.c
+++ b/sound/pci/ctxfi/cthw20k1.c
@@ -168,7 +168,7 @@ static int src_get_rsc_ctrl_blk(void **rblk)
 
         *rblk = NULL;
         blk = kzalloc(sizeof(*blk), GFP_KERNEL);
-        if (NULL == blk)
+        if (!blk)
                 return -ENOMEM;
 
         *rblk = blk;
@@ -494,7 +494,7 @@ static int src_mgr_get_ctrl_blk(void **rblk)
 
         *rblk = NULL;
         blk = kzalloc(sizeof(*blk), GFP_KERNEL);
-        if (NULL == blk)
+        if (!blk)
                 return -ENOMEM;
 
         *rblk = blk;
@@ -515,7 +515,7 @@ static int srcimp_mgr_get_ctrl_blk(void **rblk)
 
         *rblk = NULL;
         blk = kzalloc(sizeof(*blk), GFP_KERNEL);
-        if (NULL == blk)
+        if (!blk)
                 return -ENOMEM;
 
         *rblk = blk;
@@ -702,7 +702,7 @@ static int amixer_rsc_get_ctrl_blk(void **rblk)
 
         *rblk = NULL;
         blk = kzalloc(sizeof(*blk), GFP_KERNEL);
-        if (NULL == blk)
+        if (!blk)
                 return -ENOMEM;
 
         *rblk = blk;
@@ -723,7 +723,7 @@ static int amixer_mgr_get_ctrl_blk(void **rblk)
 
         *rblk = NULL;
         /*blk = kzalloc(sizeof(*blk), GFP_KERNEL);
-        if (NULL == blk)
+        if (!blk)
                 return -ENOMEM;
 
         *rblk = blk;*/
@@ -909,7 +909,7 @@ static int dai_get_ctrl_blk(void **rblk)
 
         *rblk = NULL;
         blk = kzalloc(sizeof(*blk), GFP_KERNEL);
-        if (NULL == blk)
+        if (!blk)
                 return -ENOMEM;
 
         *rblk = blk;
@@ -958,7 +958,7 @@ static int dao_get_ctrl_blk(void **rblk)
 
         *rblk = NULL;
         blk = kzalloc(sizeof(*blk), GFP_KERNEL);
-        if (NULL == blk)
+        if (!blk)
                 return -ENOMEM;
 
         *rblk = blk;
@@ -1152,7 +1152,7 @@ static int daio_mgr_get_ctrl_blk(struct hw *hw, void **rblk)
 
         *rblk = NULL;
         blk = kzalloc(sizeof(*blk), GFP_KERNEL);
-        if (NULL == blk)
+        if (!blk)
                 return -ENOMEM;
 
         blk->i2sctl = hw_read_20kx(hw, I2SCTL);
@@ -1808,7 +1808,7 @@ static int uaa_to_xfi(struct pci_dev *pci)
         /* By default, Hendrix card UAA Bar0 should be using memory... */
         io_base = pci_resource_start(pci, 0);
         mem_base = ioremap(io_base, pci_resource_len(pci, 0));
-        if (NULL == mem_base)
+        if (!mem_base)
                 return -ENOENT;
 
         /* Read current mode from Mode Change Register */
@@ -1977,7 +1977,7 @@ static int hw_card_shutdown(struct hw *hw)
 
         hw->irq = -1;
 
-        if (NULL != ((void *)hw->mem_base))
+        if (hw->mem_base)
                 iounmap((void *)hw->mem_base);
 
         hw->mem_base = (unsigned long)NULL;
@@ -2274,7 +2274,7 @@ int __devinit create_20k1_hw_obj(struct hw **rhw)
 
         *rhw = NULL;
         hw20k1 = kzalloc(sizeof(*hw20k1), GFP_KERNEL);
-        if (NULL == hw20k1)
+        if (!hw20k1)
                 return -ENOMEM;
 
         spin_lock_init(&hw20k1->reg_20k1_lock);
diff --git a/sound/pci/ctxfi/cthw20k2.c b/sound/pci/ctxfi/cthw20k2.c
index dec46d04b041..b6b11bfe7574 100644
--- a/sound/pci/ctxfi/cthw20k2.c
+++ b/sound/pci/ctxfi/cthw20k2.c
@@ -166,7 +166,7 @@ static int src_get_rsc_ctrl_blk(void **rblk)
 
         *rblk = NULL;
         blk = kzalloc(sizeof(*blk), GFP_KERNEL);
-        if (NULL == blk)
+        if (!blk)
                 return -ENOMEM;
 
         *rblk = blk;
@@ -492,7 +492,7 @@ static int src_mgr_get_ctrl_blk(void **rblk)
 
         *rblk = NULL;
         blk = kzalloc(sizeof(*blk), GFP_KERNEL);
-        if (NULL == blk)
+        if (!blk)
                 return -ENOMEM;
 
         *rblk = blk;
@@ -513,7 +513,7 @@ static int srcimp_mgr_get_ctrl_blk(void **rblk)
 
         *rblk = NULL;
         blk = kzalloc(sizeof(*blk), GFP_KERNEL);
-        if (NULL == blk)
+        if (!blk)
                 return -ENOMEM;
 
         *rblk = blk;
@@ -702,7 +702,7 @@ static int amixer_rsc_get_ctrl_blk(void **rblk)
 
         *rblk = NULL;
         blk = kzalloc(sizeof(*blk), GFP_KERNEL);
-        if (NULL == blk)
+        if (!blk)
                 return -ENOMEM;
 
         *rblk = blk;
@@ -891,7 +891,7 @@ static int dai_get_ctrl_blk(void **rblk)
 
         *rblk = NULL;
         blk = kzalloc(sizeof(*blk), GFP_KERNEL);
-        if (NULL == blk)
+        if (!blk)
                 return -ENOMEM;
 
         *rblk = blk;
@@ -941,7 +941,7 @@ static int dao_get_ctrl_blk(void **rblk)
 
         *rblk = NULL;
         blk = kzalloc(sizeof(*blk), GFP_KERNEL);
-        if (NULL == blk)
+        if (!blk)
                 return -ENOMEM;
 
         *rblk = blk;
@@ -1092,7 +1092,7 @@ static int daio_mgr_get_ctrl_blk(struct hw *hw, void **rblk)
 
         *rblk = NULL;
         blk = kzalloc(sizeof(*blk), GFP_KERNEL);
-        if (NULL == blk)
+        if (!blk)
                 return -ENOMEM;
 
         for (i = 0; i < 8; i++) {
@@ -1112,6 +1112,26 @@ static int daio_mgr_put_ctrl_blk(void *blk)
         return 0;
 }
 
+/* Timer interrupt */
+static int set_timer_irq(struct hw *hw, int enable)
+{
+        hw_write_20kx(hw, GIE, enable ? IT_INT : 0);
+        return 0;
+}
+
+static int set_timer_tick(struct hw *hw, unsigned int ticks)
+{
+        if (ticks)
+                ticks |= TIMR_IE | TIMR_IP;
+        hw_write_20kx(hw, TIMR, ticks);
+        return 0;
+}
+
+static unsigned int get_wc(struct hw *hw)
+{
+        return hw_read_20kx(hw, WC);
+}
+
 /* Card hardware initialization block */
 struct dac_conf {
         unsigned int msr; /* master sample rate in rsrs */
@@ -1841,6 +1861,22 @@ static int hw_have_digit_io_switch(struct hw *hw)
         return 0;
 }
 
+static irqreturn_t ct_20k2_interrupt(int irq, void *dev_id)
+{
+        struct hw *hw = dev_id;
+        unsigned int status;
+
+        status = hw_read_20kx(hw, GIP);
+        if (!status)
+                return IRQ_NONE;
+
+        if (hw->irq_callback)
+                hw->irq_callback(hw->irq_callback_data, status);
+
+        hw_write_20kx(hw, GIP, status);
+        return IRQ_HANDLED;
+}
+
 static int hw_card_start(struct hw *hw)
 {
         int err = 0;
@@ -1868,7 +1904,7 @@ static int hw_card_start(struct hw *hw)
                 hw->io_base = pci_resource_start(hw->pci, 2);
                 hw->mem_base = (unsigned long)ioremap(hw->io_base,
                                         pci_resource_len(hw->pci, 2));
-                if (NULL == (void *)hw->mem_base) {
+                if (!hw->mem_base) {
                         err = -ENOENT;
                         goto error2;
                 }
@@ -1879,12 +1915,15 @@ static int hw_card_start(struct hw *hw)
         set_field(&gctl, GCTL_UAA, 0);
         hw_write_20kx(hw, GLOBAL_CNTL_GCTL, gctl);
 
-        /*if ((err = request_irq(pci->irq, ct_atc_interrupt, IRQF_SHARED,
-                                atc->chip_details->nm_card, hw))) {
-                goto error3;
+        if (hw->irq < 0) {
+                err = request_irq(pci->irq, ct_20k2_interrupt, IRQF_SHARED,
+                                  "ctxfi", hw);
+                if (err < 0) {
+                        printk(KERN_ERR "XFi: Cannot get irq %d\n", pci->irq);
+                        goto error2;
+                }
+                hw->irq = pci->irq;
         }
-        hw->irq = pci->irq;
-        */
 
         pci_set_master(pci);
 
@@ -1923,7 +1962,7 @@ static int hw_card_shutdown(struct hw *hw)
 
         hw->irq = -1;
 
-        if (NULL != ((void *)hw->mem_base))
+        if (hw->mem_base)
                 iounmap((void *)hw->mem_base);
 
         hw->mem_base = (unsigned long)NULL;
@@ -1972,7 +2011,7 @@ static int hw_card_init(struct hw *hw, struct card_conf *info)
         hw_write_20kx(hw, GLOBAL_CNTL_GCTL, gctl);
 
         /* Reset all global pending interrupts */
-        hw_write_20kx(hw, INTERRUPT_GIE, 0);
+        hw_write_20kx(hw, GIE, 0);
         /* Reset all SRC pending interrupts */
         hw_write_20kx(hw, SRC_IP, 0);
 
@@ -2149,6 +2188,10 @@ static struct hw ct20k2_preset __devinitdata = {
         .daio_mgr_set_imapnxt = daio_mgr_set_imapnxt,
         .daio_mgr_set_imapaddr = daio_mgr_set_imapaddr,
         .daio_mgr_commit_write = daio_mgr_commit_write,
+
+        .set_timer_irq = set_timer_irq,
+        .set_timer_tick = set_timer_tick,
+        .get_wc = get_wc,
 };
 
 int __devinit create_20k2_hw_obj(struct hw **rhw)
diff --git a/sound/pci/ctxfi/ctmixer.c b/sound/pci/ctxfi/ctmixer.c
index f26d7cd9db9f..15c1e7271ea8 100644
--- a/sound/pci/ctxfi/ctmixer.c
+++ b/sound/pci/ctxfi/ctmixer.c
@@ -654,7 +654,7 @@ ct_mixer_kcontrol_new(struct ct_mixer *mixer, struct snd_kcontrol_new *new)
         int err;
 
         kctl = snd_ctl_new1(new, mixer->atc);
-        if (NULL == kctl)
+        if (!kctl)
                 return -ENOMEM;
 
         if (SNDRV_CTL_ELEM_IFACE_PCM == kctl->id.iface)
@@ -837,17 +837,17 @@ static int ct_mixer_get_mem(struct ct_mixer **rmixer)
         *rmixer = NULL;
         /* Allocate mem for mixer obj */
         mixer = kzalloc(sizeof(*mixer), GFP_KERNEL);
-        if (NULL == mixer)
+        if (!mixer)
                 return -ENOMEM;
 
         mixer->amixers = kzalloc(sizeof(void *)*(NUM_CT_AMIXERS*CHN_NUM),
                                  GFP_KERNEL);
-        if (NULL == mixer->amixers) {
+        if (!mixer->amixers) {
                 err = -ENOMEM;
                 goto error1;
         }
         mixer->sums = kzalloc(sizeof(void *)*(NUM_CT_SUMS*CHN_NUM), GFP_KERNEL);
-        if (NULL == mixer->sums) {
+        if (!mixer->sums) {
                 err = -ENOMEM;
                 goto error2;
         }
diff --git a/sound/pci/ctxfi/ctpcm.c b/sound/pci/ctxfi/ctpcm.c
index 60ea23180acb..d0dc227fbdd3 100644
--- a/sound/pci/ctxfi/ctpcm.c
+++ b/sound/pci/ctxfi/ctpcm.c
@@ -97,7 +97,7 @@ static void ct_atc_pcm_interrupt(struct ct_atc_pcm *atc_pcm)
 {
         struct ct_atc_pcm *apcm = atc_pcm;
 
-        if (NULL == apcm->substream)
+        if (!apcm->substream)
                 return;
 
         snd_pcm_period_elapsed(apcm->substream);
@@ -123,7 +123,7 @@ static int ct_pcm_playback_open(struct snd_pcm_substream *substream)
         int err;
 
         apcm = kzalloc(sizeof(*apcm), GFP_KERNEL);
-        if (NULL == apcm)
+        if (!apcm)
                 return -ENOMEM;
 
         apcm->substream = substream;
@@ -271,7 +271,7 @@ static int ct_pcm_capture_open(struct snd_pcm_substream *substream)
         int err;
 
         apcm = kzalloc(sizeof(*apcm), GFP_KERNEL);
-        if (NULL == apcm)
+        if (!apcm)
                 return -ENOMEM;
 
         apcm->started = 0;
diff --git a/sound/pci/ctxfi/ctresource.c b/sound/pci/ctxfi/ctresource.c
index 889c495bb7d1..7dfaf67344d4 100644
--- a/sound/pci/ctxfi/ctresource.c
+++ b/sound/pci/ctxfi/ctresource.c
@@ -144,7 +144,7 @@ int rsc_init(struct rsc *rsc, u32 idx, enum RSCTYP type, u32 msr, void *hw)
         rsc->msr = msr;
         rsc->hw = hw;
         rsc->ops = &rsc_generic_ops;
-        if (NULL == hw) {
+        if (!hw) {
                 rsc->ctrl_blk = NULL;
                 return 0;
         }
@@ -216,7 +216,7 @@ int rsc_mgr_init(struct rsc_mgr *mgr, enum RSCTYP type,
         mgr->type = NUM_RSCTYP;
 
         mgr->rscs = kzalloc(((amount + 8 - 1) / 8), GFP_KERNEL);
-        if (NULL == mgr->rscs)
+        if (!mgr->rscs)
                 return -ENOMEM;
 
         switch (type) {
diff --git a/sound/pci/ctxfi/ctsrc.c b/sound/pci/ctxfi/ctsrc.c
index e1c145d8b702..c749fa720889 100644
--- a/sound/pci/ctxfi/ctsrc.c
+++ b/sound/pci/ctxfi/ctsrc.c
@@ -441,7 +441,7 @@ get_src_rsc(struct src_mgr *mgr, const struct src_desc *desc, struct src **rsrc)
         else
                 src = kzalloc(sizeof(*src), GFP_KERNEL);
 
-        if (NULL == src) {
+        if (!src) {
                 err = -ENOMEM;
                 goto error1;
         }
@@ -550,7 +550,7 @@ int src_mgr_create(void *hw, struct src_mgr **rsrc_mgr)
 
         *rsrc_mgr = NULL;
         src_mgr = kzalloc(sizeof(*src_mgr), GFP_KERNEL);
-        if (NULL == src_mgr)
+        if (!src_mgr)
                 return -ENOMEM;
 
         err = rsc_mgr_init(&src_mgr->mgr, SRC, SRC_RESOURCE_NUM, hw);
@@ -679,7 +679,7 @@ static int srcimp_rsc_init(struct srcimp *srcimp,
         /* Reserve memory for imapper nodes */
         srcimp->imappers = kzalloc(sizeof(struct imapper)*desc->msr,
                                    GFP_KERNEL);
-        if (NULL == srcimp->imappers) {
+        if (!srcimp->imappers) {
                 err = -ENOMEM;
                 goto error1;
         }
@@ -724,12 +724,11 @@ static int get_srcimp_rsc(struct srcimp_mgr *mgr,
 
         /* Allocate mem for SRCIMP resource */
         srcimp = kzalloc(sizeof(*srcimp), GFP_KERNEL);
-        if (NULL == srcimp) {
-                err = -ENOMEM;
-                return err;
-        }
+        if (!srcimp)
+                return -ENOMEM;
 
         /* Check whether there are sufficient SRCIMP resources. */
+        err = 0;
         spin_lock_irqsave(&mgr->mgr_lock, flags);
         for (i = 0; i < desc->msr; i++) {
                 err = mgr_get_resource(&mgr->mgr, 1, &idx);
@@ -834,7 +833,7 @@ int srcimp_mgr_create(void *hw, struct srcimp_mgr **rsrcimp_mgr)
 
         *rsrcimp_mgr = NULL;
         srcimp_mgr = kzalloc(sizeof(*srcimp_mgr), GFP_KERNEL);
-        if (NULL == srcimp_mgr)
+        if (!srcimp_mgr)
                 return -ENOMEM;
 
         err = rsc_mgr_init(&srcimp_mgr->mgr, SRCIMP, SRCIMP_RESOURCE_NUM, hw);
@@ -845,7 +844,7 @@ int srcimp_mgr_create(void *hw, struct srcimp_mgr **rsrcimp_mgr)
         spin_lock_init(&srcimp_mgr->imap_lock);
         INIT_LIST_HEAD(&srcimp_mgr->imappers);
         entry = kzalloc(sizeof(*entry), GFP_KERNEL);
-        if (NULL == entry) {
+        if (!entry) {
                 err = -ENOMEM;
                 goto error2;
         }
diff --git a/sound/pci/ctxfi/ctvmem.c b/sound/pci/ctxfi/ctvmem.c
index 67665a7e43c6..6b78752e9503 100644
--- a/sound/pci/ctxfi/ctvmem.c
+++ b/sound/pci/ctxfi/ctvmem.c
@@ -60,7 +60,7 @@ get_vm_block(struct ct_vm *vm, unsigned int size)
         }
 
         block = kzalloc(sizeof(*block), GFP_KERNEL);
-        if (NULL == block)
+        if (!block)
                 goto out;
 
         block->addr = entry->addr;
@@ -181,7 +181,7 @@ int ct_vm_create(struct ct_vm **rvm)
         *rvm = NULL;
 
         vm = kzalloc(sizeof(*vm), GFP_KERNEL);
-        if (NULL == vm)
+        if (!vm)
                 return -ENOMEM;
 
         mutex_init(&vm->lock);
@@ -189,7 +189,7 @@ int ct_vm_create(struct ct_vm **rvm)
         /* Allocate page table pages */
         for (i = 0; i < CT_PTP_NUM; i++) {
                 vm->ptp[i] = kmalloc(PAGE_SIZE, GFP_KERNEL);
-                if (NULL == vm->ptp[i])
+                if (!vm->ptp[i])
                         break;
         }
         if (!i) {
diff --git a/sound/pci/echoaudio/echoaudio.c b/sound/pci/echoaudio/echoaudio.c
index da2065cd2c0d..1305f7ca02c3 100644
--- a/sound/pci/echoaudio/echoaudio.c
+++ b/sound/pci/echoaudio/echoaudio.c
@@ -950,7 +950,7 @@ static int __devinit snd_echo_new_pcm(struct echoaudio *chip)
         Control interface
 ******************************************************************************/
 
-#ifndef ECHOCARD_HAS_VMIXER
+#if !defined(ECHOCARD_HAS_VMIXER) || defined(ECHOCARD_HAS_LINE_OUT_GAIN)
 
 /******************* PCM output volume *******************/
 static int snd_echo_output_gain_info(struct snd_kcontrol *kcontrol,
@@ -1003,6 +1003,19 @@ static int snd_echo_output_gain_put(struct snd_kcontrol *kcontrol,
         return changed;
 }
 
+#ifdef ECHOCARD_HAS_LINE_OUT_GAIN
+/* On the Mia this one controls the line-out volume */
+static struct snd_kcontrol_new snd_echo_line_output_gain __devinitdata = {
+        .name = "Line Playback Volume",
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
+                  SNDRV_CTL_ELEM_ACCESS_TLV_READ,
+        .info = snd_echo_output_gain_info,
+        .get = snd_echo_output_gain_get,
+        .put = snd_echo_output_gain_put,
+        .tlv = {.p = db_scale_output_gain},
+};
+#else
 static struct snd_kcontrol_new snd_echo_pcm_output_gain __devinitdata = {
         .name = "PCM Playback Volume",
         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
@@ -1012,9 +1025,10 @@ static struct snd_kcontrol_new snd_echo_pcm_output_gain __devinitdata = {
         .put = snd_echo_output_gain_put,
         .tlv = {.p = db_scale_output_gain},
 };
-
 #endif
 
+#endif /* !ECHOCARD_HAS_VMIXER || ECHOCARD_HAS_LINE_OUT_GAIN */
+
 
 
 #ifdef ECHOCARD_HAS_INPUT_GAIN
@@ -2030,10 +2044,18 @@ static int __devinit snd_echo_probe(struct pci_dev *pci,
         snd_echo_vmixer.count = num_pipes_out(chip) * num_busses_out(chip);
         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vmixer, chip))) < 0)
                 goto ctl_error;
-#else
-        if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_pcm_output_gain, chip))) < 0)
+#ifdef ECHOCARD_HAS_LINE_OUT_GAIN
+        err = snd_ctl_add(chip->card,
+                          snd_ctl_new1(&snd_echo_line_output_gain, chip));
+        if (err < 0)
                 goto ctl_error;
 #endif
+#else /* ECHOCARD_HAS_VMIXER */
+        err = snd_ctl_add(chip->card,
+                          snd_ctl_new1(&snd_echo_pcm_output_gain, chip));
+        if (err < 0)
+                goto ctl_error;
+#endif /* ECHOCARD_HAS_VMIXER */
 
 #ifdef ECHOCARD_HAS_INPUT_GAIN
         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_line_input_gain, chip))) < 0)
diff --git a/sound/pci/echoaudio/mia.c b/sound/pci/echoaudio/mia.c
index f3b9b45c9c1b..f05c8c097aa8 100644
--- a/sound/pci/echoaudio/mia.c
+++ b/sound/pci/echoaudio/mia.c
@@ -29,6 +29,7 @@
 #define ECHOCARD_HAS_ADAT       FALSE
 #define ECHOCARD_HAS_STEREO_BIG_ENDIAN32
 #define ECHOCARD_HAS_MIDI
+#define ECHOCARD_HAS_LINE_OUT_GAIN
 
 /* Pipe indexes */
 #define PX_ANALOG_OUT   0       /* 8 */
diff --git a/sound/pci/emu10k1/emu10k1.c b/sound/pci/emu10k1/emu10k1.c
index c7f3b994101c..168af67d938e 100644
--- a/sound/pci/emu10k1/emu10k1.c
+++ b/sound/pci/emu10k1/emu10k1.c
@@ -77,9 +77,9 @@ MODULE_PARM_DESC(subsystem, "Force card subsystem model.");
  * Class 0401: 1102:0008 (rev 00) Subsystem: 1102:1001 -> Audigy2 Value  Model:SB0400
  */
 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, }
 };
 
diff --git a/sound/pci/emu10k1/emu10k1x.c b/sound/pci/emu10k1/emu10k1x.c
index 4d3ad793e98f..36e08bd2b3cc 100644
--- a/sound/pci/emu10k1/emu10k1x.c
+++ b/sound/pci/emu10k1/emu10k1x.c
@@ -1607,7 +1607,7 @@ static void __devexit snd_emu10k1x_remove(struct pci_dev *pci)
 
 // 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, }
 };
 MODULE_DEVICE_TABLE(pci, snd_emu10k1x_ids);
diff --git a/sound/pci/emu10k1/p16v.c b/sound/pci/emu10k1/p16v.c
index e617acaf10e3..61b8ab39800f 100644
--- a/sound/pci/emu10k1/p16v.c
+++ b/sound/pci/emu10k1/p16v.c
@@ -644,7 +644,7 @@ int __devinit snd_p16v_pcm(struct snd_emu10k1 *emu, int device, struct snd_pcm *
         int err;
         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)
                 *rpcm = NULL;
diff --git a/sound/pci/ens1370.c b/sound/pci/ens1370.c
index 18f4d1e98c46..2b82c5c723e1 100644
--- a/sound/pci/ens1370.c
+++ b/sound/pci/ens1370.c
@@ -445,12 +445,12 @@ static irqreturn_t snd_audiopci_interrupt(int irq, void *dev_id);
 
 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, }
 };
diff --git a/sound/pci/es1938.c b/sound/pci/es1938.c
index fbd2ac09aa34..820318ee62c1 100644
--- a/sound/pci/es1938.c
+++ b/sound/pci/es1938.c
@@ -244,7 +244,7 @@ struct es1938 {
 static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id);
 
 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, }
 };
 
diff --git a/sound/pci/hda/Kconfig b/sound/pci/hda/Kconfig
index 04438f1d682d..55545e0818b5 100644
--- a/sound/pci/hda/Kconfig
+++ b/sound/pci/hda/Kconfig
@@ -46,6 +46,20 @@ config SND_HDA_INPUT_JACK
           Say Y here to enable the jack plugging notification via
           input layer.
 
+config SND_HDA_PATCH_LOADER
+        bool "Support initialization patch loading for HD-audio"
+        depends on EXPERIMENTAL
+        select FW_LOADER
+        select SND_HDA_HWDEP
+        select SND_HDA_RECONFIG
+        help
+          Say Y here to allow the HD-audio driver to load a pseudo
+          firmware file ("patch") for overriding the BIOS setup at
+          start up.  The "patch" file can be specified via patch module
+          option, such as patch=hda-init.
+
+          This option turns on hwdep and reconfig features automatically.
+
 config SND_HDA_CODEC_REALTEK
         bool "Build Realtek HD-audio codec support"
         default y
@@ -134,6 +148,19 @@ config SND_HDA_ELD
         def_bool y
         depends on SND_HDA_CODEC_INTELHDMI
 
+config SND_HDA_CODEC_CIRRUS
+        bool "Build Cirrus Logic codec support"
+        depends on SND_HDA_INTEL
+        default y
+        help
+          Say Y here to include Cirrus Logic codec support in
+          snd-hda-intel driver, such as CS4206.
+
+          When the HD-audio driver is built as a module, the codec
+          support code is also built as another module,
+          snd-hda-codec-cirrus.
+          This module is automatically loaded at probing.
+
 config SND_HDA_CODEC_CONEXANT
         bool "Build Conexant HD-audio codec support"
         default y
diff --git a/sound/pci/hda/Makefile b/sound/pci/hda/Makefile
index e3081d4586cc..315a1c4f8998 100644
--- a/sound/pci/hda/Makefile
+++ b/sound/pci/hda/Makefile
@@ -13,6 +13,7 @@ snd-hda-codec-analog-objs :=	patch_analog.o
 snd-hda-codec-idt-objs :=       patch_sigmatel.o
 snd-hda-codec-si3054-objs :=    patch_si3054.o
 snd-hda-codec-atihdmi-objs :=   patch_atihdmi.o
+snd-hda-codec-cirrus-objs :=    patch_cirrus.o
 snd-hda-codec-ca0110-objs :=    patch_ca0110.o
 snd-hda-codec-conexant-objs :=  patch_conexant.o
 snd-hda-codec-via-objs :=       patch_via.o
@@ -41,6 +42,9 @@ endif
 ifdef CONFIG_SND_HDA_CODEC_ATIHDMI
 obj-$(CONFIG_SND_HDA_INTEL) += snd-hda-codec-atihdmi.o
 endif
+ifdef CONFIG_SND_HDA_CODEC_CIRRUS
+obj-$(CONFIG_SND_HDA_INTEL) += snd-hda-codec-cirrus.o
+endif
 ifdef CONFIG_SND_HDA_CODEC_CA0110
 obj-$(CONFIG_SND_HDA_INTEL) += snd-hda-codec-ca0110.o
 endif
diff --git a/sound/pci/hda/hda_beep.c b/sound/pci/hda/hda_beep.c
index 29272f2e95a0..3f51a981e604 100644
--- a/sound/pci/hda/hda_beep.c
+++ b/sound/pci/hda/hda_beep.c
@@ -24,6 +24,7 @@
 #include <linux/workqueue.h>
 #include <sound/core.h>
 #include "hda_beep.h"
+#include "hda_local.h"
 
 enum {
         DIGBEEP_HZ_STEP = 46875,        /* 46.875 Hz */
@@ -50,19 +51,22 @@ static void snd_hda_generate_beep(struct work_struct *work)
  * The tone frequency of beep generator on IDT/STAC codecs is
  * defined from the 8bit tone parameter, in Hz,
  *    freq = 48000 * (257 - tone) / 1024
- * that is from 12kHz to 93.75kHz in step of 46.875 hz
+ * that is from 12kHz to 93.75Hz in steps of 46.875 Hz
  */
 static int beep_linear_tone(struct hda_beep *beep, int hz)
 {
+        if (hz <= 0)
+                return 0;
         hz *= 1000; /* fixed point */
-        hz = hz - DIGBEEP_HZ_MIN;
+        hz = hz - DIGBEEP_HZ_MIN
+                + DIGBEEP_HZ_STEP / 2; /* round to nearest step */
         if (hz < 0)
                 hz = 0; /* turn off PC beep*/
         else if (hz >= (DIGBEEP_HZ_MAX - DIGBEEP_HZ_MIN))
-                hz = 0xff;
+                hz = 1; /* max frequency */
         else {
                 hz /= DIGBEEP_HZ_STEP;
-                hz++;
+                hz = 255 - hz;
         }
         return hz;
 }
@@ -115,6 +119,9 @@ int snd_hda_attach_beep_device(struct hda_codec *codec, int nid)
         struct hda_beep *beep;
         int err;
 
+        if (!snd_hda_get_bool_hint(codec, "beep"))
+                return 0; /* disabled explicitly */
+
         beep = kzalloc(sizeof(*beep), GFP_KERNEL);
         if (beep == NULL)
                 return -ENOMEM;
diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c
index 462e2cedaa6a..af989f660cca 100644
--- a/sound/pci/hda/hda_codec.c
+++ b/sound/pci/hda/hda_codec.c
@@ -44,6 +44,7 @@ struct hda_vendor_id {
 /* codec vendor labels */
 static struct hda_vendor_id hda_vendor_ids[] = {
         { 0x1002, "ATI" },
+        { 0x1013, "Cirrus Logic" },
         { 0x1057, "Motorola" },
         { 0x1095, "Silicon Image" },
         { 0x10de, "Nvidia" },
@@ -150,7 +151,14 @@ make_codec_cmd(struct hda_codec *codec, hda_nid_t nid, int direct,
 {
         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;
         val |= verb << 8;
@@ -167,6 +175,9 @@ static int codec_exec_verb(struct hda_codec *codec, unsigned int cmd,
         struct hda_bus *bus = codec->bus;
         int err;
 
+        if (cmd == ~0)
+                return -1;
+
         if (res)
                 *res = -1;
  again:
@@ -174,7 +185,7 @@ static int codec_exec_verb(struct hda_codec *codec, unsigned int cmd,
         mutex_lock(&bus->cmd_mutex);
         err = bus->ops.command(bus, cmd);
         if (!err && res)
-                *res = bus->ops.get_response(bus);
+                *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) {
@@ -291,11 +302,20 @@ int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
         unsigned int parm;
         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);
         if (parm & AC_CLIST_LONG) {
                 /* long form */
@@ -316,6 +336,8 @@ int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
                 /* single connection */
                 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;
         }
@@ -327,11 +349,20 @@ int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
                 int range_val;
                 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) {
                         /* ranges between the previous and this one */
@@ -721,8 +752,7 @@ static int read_pin_defaults(struct hda_codec *codec)
         for (i = 0; i < codec->num_nodes; i++, nid++) {
                 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;
                 pin = snd_array_new(&codec->init_pins);
@@ -885,7 +915,7 @@ static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
  * Returns 0 if successful, or a negative error code.
  */
 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;
         char component[31];
@@ -978,11 +1008,6 @@ int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr
                             codec->afg ? codec->afg : codec->mfg,
                             AC_PWRST_D0);
 
-        if (do_init) {
-                err = snd_hda_codec_configure(codec);
-                if (err < 0)
-                        goto error;
-        }
         snd_hda_codec_proc_new(codec);
 
         snd_hda_create_hwdep(codec);
@@ -1036,6 +1061,7 @@ int snd_hda_codec_configure(struct hda_codec *codec)
                 err = init_unsol_queue(codec->bus);
         return err;
 }
+EXPORT_SYMBOL_HDA(snd_hda_codec_configure);
 
 /**
  * snd_hda_codec_setup_stream - set up the codec for streaming
@@ -2350,16 +2376,20 @@ static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
         hda_nid_t nid;
         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;
         for (i = 0; i < codec->num_nodes; i++, nid++) {
                 unsigned int wcaps = get_wcaps(codec, nid);
                 if (wcaps & AC_WCAP_POWER) {
-                        unsigned int wid_type = (wcaps & AC_WCAP_TYPE) >>
-                                AC_WCAP_TYPE_SHIFT;
+                        unsigned int wid_type = get_wcaps_type(wcaps);
                         if (power_state == AC_PWRST_D3 &&
                             wid_type == AC_WID_PIN) {
                                 unsigned int pincap;
@@ -2567,7 +2597,7 @@ unsigned int snd_hda_calc_stream_format(unsigned int rate,
         case 20:
         case 24:
         case 32:
-                if (maxbps >= 32)
+                if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
                         val |= 0x40;
                 else if (maxbps >= 24)
                         val |= 0x30;
@@ -2694,11 +2724,12 @@ static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
                                         bps = 20;
                         }
                 }
-                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
                          * for the direct AC3 stream...
@@ -3096,7 +3127,7 @@ int snd_hda_check_board_codec_sid_config(struct hda_codec *codec,
         tbl = q;
 
         if (tbl->value >= 0 && tbl->value < num_configs) {
-#ifdef CONFIG_SND_DEBUG_DETECT
+#ifdef CONFIG_SND_DEBUG_VERBOSE
                 char tmp[10];
                 const char *model = NULL;
                 if (models)
@@ -3470,10 +3501,16 @@ int snd_hda_multi_out_analog_open(struct hda_codec *codec,
                 }
                 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);
         }
@@ -3643,8 +3680,7 @@ int snd_hda_parse_pin_def_config(struct hda_codec *codec,
         end_nid = codec->start_nid + codec->num_nodes;
         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;
 
diff --git a/sound/pci/hda/hda_codec.h b/sound/pci/hda/hda_codec.h
index cad79efaabc9..99552fb5f756 100644
--- a/sound/pci/hda/hda_codec.h
+++ b/sound/pci/hda/hda_codec.h
@@ -568,7 +568,7 @@ struct hda_bus_ops {
         /* send a single command */
         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 *);
         /* attach a PCM stream */
@@ -830,7 +830,8 @@ enum {
 int snd_hda_bus_new(struct snd_card *card, const struct hda_bus_template *temp,
                     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);
 
 /*
  * low level functions
@@ -938,6 +939,13 @@ static inline void snd_hda_power_down(struct hda_codec *codec) {}
 #define snd_hda_codec_needs_resume(codec) 1
 #endif
 
+#ifdef CONFIG_SND_HDA_PATCH_LOADER
+/*
+ * patch firmware
+ */
+int snd_hda_load_patch(struct hda_bus *bus, const char *patch);
+#endif
+
 /*
  * Codec modularization
  */
diff --git a/sound/pci/hda/hda_eld.c b/sound/pci/hda/hda_eld.c
index fcad5ec31773..9446a5abea13 100644
--- a/sound/pci/hda/hda_eld.c
+++ b/sound/pci/hda/hda_eld.c
@@ -508,7 +508,7 @@ static void hdmi_write_eld_info(struct snd_info_entry *entry,
         char name[64];
         char *sname;
         long long val;
-        int n;
+        unsigned int n;
 
         while (!snd_info_get_line(buffer, line, sizeof(line))) {
                 if (sscanf(line, "%s %llx", name, &val) != 2)
@@ -539,7 +539,7 @@ static void hdmi_write_eld_info(struct snd_info_entry *entry,
                                 sname++;
                                 n = 10 * n + name[4] - '0';
                         }
-                        if (n < 0 || n > 31) /* double the CEA limit */
+                        if (n >= ELD_MAX_SAD)
                                 continue;
                         if (!strcmp(sname, "_coding_type"))
                                 e->sad[n].format = val;
diff --git a/sound/pci/hda/hda_generic.c b/sound/pci/hda/hda_generic.c
index 1d5797a96682..b36f6c5a92df 100644
--- a/sound/pci/hda/hda_generic.c
+++ b/sound/pci/hda/hda_generic.c
@@ -121,11 +121,17 @@ static int add_new_node(struct hda_codec *codec, struct hda_gspec *spec, hda_nid
         if (node == NULL)
                 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))
                 node->conn_list = node->slist;
@@ -140,8 +146,6 @@ static int add_new_node(struct hda_codec *codec, struct hda_gspec *spec, hda_nid
         }
         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) {
                 node->pin_caps = snd_hda_query_pin_caps(codec, node->nid);
diff --git a/sound/pci/hda/hda_hwdep.c b/sound/pci/hda/hda_hwdep.c
index 6812fbe80fa4..cc24e6721d74 100644
--- a/sound/pci/hda/hda_hwdep.c
+++ b/sound/pci/hda/hda_hwdep.c
@@ -24,6 +24,7 @@
 #include <linux/compat.h>
 #include <linux/mutex.h>
 #include <linux/ctype.h>
+#include <linux/firmware.h>
 #include <sound/core.h>
 #include "hda_codec.h"
 #include "hda_local.h"
@@ -312,12 +313,8 @@ static ssize_t init_verbs_show(struct device *dev,
         return len;
 }
 
-static ssize_t init_verbs_store(struct device *dev,
-                                struct device_attribute *attr,
-                                const char *buf, size_t count)
+static int parse_init_verbs(struct hda_codec *codec, const char *buf)
 {
-        struct snd_hwdep *hwdep = dev_get_drvdata(dev);
-        struct hda_codec *codec = hwdep->private_data;
         struct hda_verb *v;
         int nid, verb, param;
 
@@ -331,6 +328,18 @@ static ssize_t init_verbs_store(struct device *dev,
         v->nid = nid;
         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;
 }
 
@@ -376,19 +385,15 @@ static void remove_trail_spaces(char *str)
 
 #define MAX_HINTS       1024
 
-static ssize_t hints_store(struct device *dev,
-                           struct device_attribute *attr,
-                           const char *buf, size_t count)
+static int parse_hints(struct hda_codec *codec, const char *buf)
 {
-        struct snd_hwdep *hwdep = dev_get_drvdata(dev);
-        struct hda_codec *codec = hwdep->private_data;
         char *key, *val;
         struct hda_hint *hint;
 
         while (isspace(*buf))
                 buf++;
         if (!*buf || *buf == '#' || *buf == '\n')
-                return count;
+                return 0;
         if (*buf == '=')
                 return -EINVAL;
         key = kstrndup_noeol(buf, 1024);
@@ -411,7 +416,7 @@ static ssize_t hints_store(struct device *dev,
                 kfree(hint->key);
                 hint->key = key;
                 hint->val = val;
-                return count;
+                return 0;
         }
         /* allocate a new hint entry */
         if (codec->hints.used >= MAX_HINTS)
@@ -424,6 +429,18 @@ static ssize_t hints_store(struct device *dev,
         }
         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;
 }
 
@@ -469,20 +486,24 @@ static ssize_t driver_pin_configs_show(struct device *dev,
 
 #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)
+static int parse_user_pin_configs(struct hda_codec *codec, const char *buf)
 {
-        struct snd_hwdep *hwdep = dev_get_drvdata(dev);
-        struct hda_codec *codec = hwdep->private_data;
         int nid, cfg;
-        int err;
 
         if (sscanf(buf, "%i %i", &nid, &cfg) != 2)
                 return -EINVAL;
         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;
         return count;
@@ -553,3 +574,180 @@ int snd_hda_get_bool_hint(struct hda_codec *codec, const char *key)
 EXPORT_SYMBOL_HDA(snd_hda_get_bool_hint);
 
 #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 */
diff --git a/sound/pci/hda/hda_intel.c b/sound/pci/hda/hda_intel.c
index 4e9ea7080270..20a66f85f0a4 100644
--- a/sound/pci/hda/hda_intel.c
+++ b/sound/pci/hda/hda_intel.c
@@ -61,6 +61,9 @@ static int probe_mask[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] = -1};
 static int probe_only[SNDRV_CARDS];
 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);
 MODULE_PARM_DESC(index, "Index value for Intel HD audio interface.");
@@ -84,6 +87,10 @@ MODULE_PARM_DESC(single_cmd, "Use single command to communicate with codecs "
                  "(for debugging only).");
 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
 static int power_save = CONFIG_SND_HDA_POWER_SAVE_DEFAULT;
@@ -253,7 +260,7 @@ enum { SDI0, SDI1, SDI2, SDI3, SDO0, SDO1, SDO2, SDO3 };
 
 /* 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 */
 #define SD_CTL_STREAM_RESET     0x01    /* stream reset bit */
@@ -361,8 +368,8 @@ struct azx_rb {
         dma_addr_t addr;        /* physical address of CORB/RIRB buffer */
         /* 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 */
 };
 
 struct azx {
@@ -418,7 +425,7 @@ struct azx {
         unsigned int probing :1; /* codec probing phase */
 
         /* for debugging */
-        unsigned int last_cmd;  /* last issued command (to sync) */
+        unsigned int last_cmd[AZX_MAX_CODECS];
 
         /* for pending irqs */
         struct work_struct irq_pending_work;
@@ -513,6 +520,7 @@ static int azx_alloc_cmd_io(struct azx *chip)
 
 static void azx_init_cmd_io(struct azx *chip)
 {
+        spin_lock_irq(&chip->reg_lock);
         /* CORB set up */
         chip->corb.addr = chip->rb.addr;
         chip->corb.buf = (u32 *)chip->rb.area;
@@ -531,7 +539,8 @@ static void azx_init_cmd_io(struct azx *chip)
         /* RIRB set up */
         chip->rirb.addr = chip->rb.addr + 2048;
         chip->rirb.buf = (u32 *)(chip->rb.area + 2048);
-        chip->rirb.wp = chip->rirb.rp = chip->rirb.cmds = 0;
+        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));
 
@@ -543,30 +552,60 @@ static void azx_init_cmd_io(struct azx *chip)
         azx_writew(chip, RINTCNT, 1);
         /* enable rirb dma and response irq */
         azx_writeb(chip, RIRBCTL, ICH6_RBCTL_DMA_EN | ICH6_RBCTL_IRQ_EN);
+        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;
 }
 
 /* send a command */
 static int azx_corb_send_cmd(struct hda_bus *bus, u32 val)
 {
         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 */
         wp = azx_readb(chip, CORBWP);
         wp++;
         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);
 
         return 0;
@@ -578,13 +617,14 @@ static int azx_corb_send_cmd(struct hda_bus *bus, u32 val)
 static void azx_update_rirb(struct azx *chip)
 {
         unsigned int rp, wp;
+        unsigned int addr;
         u32 res, res_ex;
 
         wp = azx_readb(chip, RIRBWP);
         if (wp == chip->rirb.wp)
                 return;
         chip->rirb.wp = wp;
-                
+
         while (chip->rirb.rp != wp) {
                 chip->rirb.rp++;
                 chip->rirb.rp %= ICH6_MAX_RIRB_ENTRIES;
@@ -592,18 +632,24 @@ static void azx_update_rirb(struct azx *chip)
                 rp = chip->rirb.rp << 1; /* an RIRB entry is 8-bytes */
                 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;
         unsigned long timeout;
@@ -616,10 +662,10 @@ static unsigned int azx_rirb_get_response(struct hda_bus *bus)
                         azx_update_rirb(chip);
                         spin_unlock_irq(&chip->reg_lock);
                 }
-                if (!chip->rirb.cmds) {
+                if (!chip->rirb.cmds[addr]) {
                         smp_rmb();
                         bus->rirb_error = 0;
-                        return chip->rirb.res; /* the last value */
+                        return chip->rirb.res[addr]; /* the last value */
                 }
                 if (time_after(jiffies, timeout))
                         break;
@@ -633,7 +679,8 @@ static unsigned int azx_rirb_get_response(struct hda_bus *bus)
 
         if (chip->msi) {
                 snd_printk(KERN_WARNING SFX "No response from codec, "
-                           "disabling MSI: last cmd=0x%08x\n", chip->last_cmd);
+                           "disabling MSI: last cmd=0x%08x\n",
+                           chip->last_cmd[addr]);
                 free_irq(chip->irq, chip);
                 chip->irq = -1;
                 pci_disable_msi(chip->pci);
@@ -648,7 +695,7 @@ static unsigned int azx_rirb_get_response(struct hda_bus *bus)
         if (!chip->polling_mode) {
                 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;
         }
@@ -672,7 +719,7 @@ static unsigned int azx_rirb_get_response(struct hda_bus *bus)
 
         snd_printk(KERN_ERR "hda_intel: azx_get_response timeout, "
                    "switching to single_cmd mode: last cmd=0x%08x\n",
-                   chip->last_cmd);
+                   chip->last_cmd[addr]);
         chip->single_cmd = 1;
         bus->response_reset = 0;
         /* re-initialize CORB/RIRB */
@@ -692,7 +739,7 @@ static unsigned int azx_rirb_get_response(struct hda_bus *bus)
  */
 
 /* receive a response */
-static int azx_single_wait_for_response(struct azx *chip)
+static int azx_single_wait_for_response(struct azx *chip, unsigned int addr)
 {
         int timeout = 50;
 
@@ -700,7 +747,7 @@ static int azx_single_wait_for_response(struct azx *chip)
                 /* check IRV busy bit */
                 if (azx_readw(chip, IRS) & ICH6_IRS_VALID) {
                         /* reuse rirb.res as the response return value */
-                        chip->rirb.res = azx_readl(chip, IR);
+                        chip->rirb.res[addr] = azx_readl(chip, IR);
                         return 0;
                 }
                 udelay(1);
@@ -708,7 +755,7 @@ static int azx_single_wait_for_response(struct azx *chip)
         if (printk_ratelimit())
                 snd_printd(SFX "get_response timeout: IRS=0x%x\n",
                            azx_readw(chip, IRS));
-        chip->rirb.res = -1;
+        chip->rirb.res[addr] = -1;
         return -EIO;
 }
 
@@ -716,6 +763,7 @@ static int azx_single_wait_for_response(struct azx *chip)
 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;
@@ -728,7 +776,7 @@ static int azx_single_send_cmd(struct hda_bus *bus, u32 val)
                         azx_writel(chip, IC, val);
                         azx_writew(chip, IRS, azx_readw(chip, IRS) |
                                    ICH6_IRS_BUSY);
-                        return azx_single_wait_for_response(chip);
+                        return azx_single_wait_for_response(chip, addr);
                 }
                 udelay(1);
         }
@@ -739,10 +787,11 @@ static int azx_single_send_cmd(struct hda_bus *bus, u32 val)
 }
 
 /* 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;
-        return chip->rirb.res;
+        return chip->rirb.res[addr];
 }
 
 /*
@@ -757,7 +806,7 @@ static int azx_send_cmd(struct hda_bus *bus, unsigned int val)
 {
         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);
         else
@@ -765,13 +814,14 @@ static int azx_send_cmd(struct hda_bus *bus, unsigned int val)
 }
 
 /* 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);
 }
 
 #ifdef CONFIG_SND_HDA_POWER_SAVE
@@ -1243,10 +1293,12 @@ static int probe_codec(struct azx *chip, int addr)
                 (AC_VERB_PARAMETERS << 8) | AC_PAR_VENDOR_ID;
         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(SFX "codec #%d probed OK\n", addr);
@@ -1286,8 +1338,7 @@ static unsigned int azx_max_codecs[AZX_NUM_DRIVERS] __devinitdata = {
         [AZX_DRIVER_TERA] = 1,
 };
 
-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;
         int c, codecs, err;
@@ -1346,7 +1397,7 @@ static int __devinit azx_codec_create(struct azx *chip, const char *model,
         for (c = 0; c < max_slots; c++) {
                 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;
                         codecs++;
@@ -1356,7 +1407,16 @@ static int __devinit azx_codec_create(struct azx *chip, const char *model,
                 snd_printk(KERN_ERR SFX "no codecs initialized\n");
                 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) {
+                snd_hda_codec_configure(codec);
+        }
         return 0;
 }
 
@@ -1454,6 +1514,18 @@ static int azx_pcm_open(struct snd_pcm_substream *substream)
                 mutex_unlock(&chip->open_mutex);
                 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;
         azx_dev->running = 0;
@@ -1462,7 +1534,6 @@ static int azx_pcm_open(struct snd_pcm_substream *substream)
         runtime->private_data = azx_dev;
         snd_pcm_set_sync(substream);
         mutex_unlock(&chip->open_mutex);
-
         return 0;
 }
 
@@ -2228,6 +2299,30 @@ static void __devinit check_probe_mask(struct azx *chip, int dev)
         }
 }
 
+/*
+ * white-list for enable_msi
+ */
+static struct snd_pci_quirk msi_white_list[] __devinitdata = {
+        SND_PCI_QUIRK(0x103c, 0x3607, "HP Compa CQ40", 1),
+        {}
+};
+
+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;
+        }
+}
+
 
 /*
  * constructor
@@ -2262,7 +2357,7 @@ static int __devinit azx_create(struct snd_card *card, struct pci_dev *pci,
         chip->pci = pci;
         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);
 
@@ -2322,9 +2417,19 @@ static int __devinit azx_create(struct snd_card *card, struct pci_dev *pci,
         gcap = azx_readw(chip, GCAP);
         snd_printdd(SFX "chipset global capabilities = 0x%x\n", gcap);
 
-        /* ATI chips seems buggy about 64bit DMA addresses */
-        if (chip->driver_type == AZX_DRIVER_ATI)
-                gcap &= ~ICH6_GCAP_64OK;
+        /* 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 (p_smbus->revision < 0x30)
+                                gcap &= ~ICH6_GCAP_64OK;
+                        pci_dev_put(p_smbus);
+                }
+        }
 
         /* allow 64bit DMA address if supported by H/W */
         if ((gcap & ICH6_GCAP_64OK) && !pci_set_dma_mask(pci, DMA_BIT_MASK(64)))
@@ -2460,15 +2565,32 @@ static int __devinit azx_probe(struct pci_dev *pci,
                 return err;
         }
 
+        /* 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)
                 goto out_free;
         card->private_data = chip;
 
         /* 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 */
         err = snd_hda_build_pcms(chip->bus);
@@ -2480,8 +2602,6 @@ static int __devinit azx_probe(struct pci_dev *pci,
         if (err < 0)
                 goto out_free;
 
-        snd_card_set_dev(card, &pci->dev);
-
         err = snd_card_register(card);
         if (err < 0)
                 goto out_free;
@@ -2583,11 +2703,15 @@ static struct pci_device_id azx_ids[] = {
         /* this entry seems still valid -- i.e. without emu20kx chip */
         { PCI_DEVICE(0x1102, 0x0009), .driver_data = AZX_DRIVER_GENERIC },
 #endif
-        /* AMD Generic, PCI class code and Vendor ID for HD Audio */
+        /* 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,
+          .driver_data = AZX_DRIVER_GENERIC },
         { 0, }
 };
 MODULE_DEVICE_TABLE(pci, azx_ids);
diff --git a/sound/pci/hda/hda_local.h b/sound/pci/hda/hda_local.h
index 83349013b4df..5f1dcc59002b 100644
--- a/sound/pci/hda/hda_local.h
+++ b/sound/pci/hda/hda_local.h
@@ -99,7 +99,6 @@ struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
 int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
                         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 */
 #define HDA_AMP_MUTE    0x80
@@ -408,6 +407,19 @@ static inline u32 get_wcaps(struct hda_codec *codec, hda_nid_t nid)
         return codec->wcaps[nid - codec->start_nid];
 }
 
+/* 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,
                               unsigned int caps);
diff --git a/sound/pci/hda/hda_proc.c b/sound/pci/hda/hda_proc.c
index 418c5d1badaa..95f24e4729f8 100644
--- a/sound/pci/hda/hda_proc.c
+++ b/sound/pci/hda/hda_proc.c
@@ -508,17 +508,14 @@ static void print_codec_info(struct snd_info_entry *entry,
                 unsigned int wid_caps =
                         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;
 
                 snd_iprintf(buffer, "Node 0x%02x [%s] wcaps 0x%x:", nid,
                             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");
                         else
diff --git a/sound/pci/hda/patch_analog.c b/sound/pci/hda/patch_analog.c
index 84cc49ca9148..215e72a87113 100644
--- a/sound/pci/hda/patch_analog.c
+++ b/sound/pci/hda/patch_analog.c
@@ -72,6 +72,7 @@ struct ad198x_spec {
         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 
         unsigned int jack_present :1;
+        unsigned int inv_jack_detect:1;
 
 #ifdef CONFIG_SND_HDA_POWER_SAVE
         struct hda_loopback_check loopback;
@@ -669,39 +670,13 @@ static struct hda_input_mux ad1986a_automic_capture_source = {
         },
 };
 
-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 */
-        },
         { } /* 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),
+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),
         HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
@@ -727,6 +702,12 @@ static struct snd_kcontrol_new ad1986a_samsung_mixers[] = {
         { } /* end */
 };
 
+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),
+        { } /* end */
+};
+
 /* re-connect the mic boost input according to the jack sensing */
 static void ad1986a_automic(struct hda_codec *codec)
 {
@@ -776,8 +757,9 @@ static void ad1986a_hp_automute(struct hda_codec *codec)
         unsigned int present;
 
         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);
 }
 
@@ -816,7 +798,7 @@ static int ad1986a_hp_master_sw_put(struct snd_kcontrol *kcontrol,
         return change;
 }
 
-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),
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
@@ -826,33 +808,10 @@ static struct snd_kcontrol_new ad1986a_laptop_automute_mixers[] = {
                 .put = ad1986a_hp_master_sw_put,
                 .private_value = HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
         },
-        HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT),
-        HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT),
-        HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x17, 0x0, HDA_OUTPUT),
-        HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x17, 0x0, HDA_OUTPUT),
-        HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
-        HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
-        HDA_CODEC_VOLUME("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 */
-        },
         { } /* end */
 };
 
+
 /*
  * initialization verbs
  */
@@ -981,6 +940,27 @@ static struct hda_verb ad1986a_hp_init_verbs[] = {
         {}
 };
 
+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 */
 enum {
@@ -991,6 +971,7 @@ enum {
         AD1986A_LAPTOP_AUTOMUTE,
         AD1986A_ULTRA,
         AD1986A_SAMSUNG,
+        AD1986A_SAMSUNG_P50,
         AD1986A_MODELS
 };
 
@@ -1002,6 +983,7 @@ static const char *ad1986a_models[AD1986A_MODELS] = {
         [AD1986A_LAPTOP_AUTOMUTE] = "laptop-automute",
         [AD1986A_ULTRA]         = "ultra",
         [AD1986A_SAMSUNG]       = "samsung",
+        [AD1986A_SAMSUNG_P50]   = "samsung-p50",
 };
 
 static struct snd_pci_quirk ad1986a_cfg_tbl[] = {
@@ -1024,6 +1006,7 @@ static struct snd_pci_quirk ad1986a_cfg_tbl[] = {
         SND_PCI_QUIRK(0x1179, 0xff40, "Toshiba", AD1986A_LAPTOP_EAPD),
         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),
         SND_PCI_QUIRK(0x144d, 0xc504, "Samsung Q35", AD1986A_3STACK),
@@ -1111,7 +1094,10 @@ static int patch_ad1986a(struct hda_codec *codec)
                 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
                 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;
                 spec->multiout.max_channels = 2;
@@ -1122,7 +1108,9 @@ static int patch_ad1986a(struct hda_codec *codec)
                 spec->input_mux = &ad1986a_laptop_eapd_capture_source;
                 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;
                 spec->init_verbs[2] = ad1986a_automic_verbs;
@@ -1135,8 +1123,28 @@ static int patch_ad1986a(struct hda_codec *codec)
                 codec->patch_ops.unsol_event = ad1986a_automic_unsol_event;
                 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;
                 spec->init_verbs[2] = ad1986a_hp_init_verbs;
@@ -1148,6 +1156,10 @@ static int patch_ad1986a(struct hda_codec *codec)
                 spec->input_mux = &ad1986a_laptop_eapd_capture_source;
                 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:
                 spec->mixers[0] = ad1986a_laptop_eapd_mixers;
@@ -2970,7 +2982,8 @@ static int patch_ad1988(struct hda_codec *codec)
         board_config = snd_hda_check_board_config(codec, AD1988_MODEL_LAST,
                                                   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;
         }
 
@@ -3690,19 +3703,29 @@ static struct hda_amp_list ad1884a_loopbacks[] = {
  * Port F: Internal speakers
  */
 
-static struct hda_input_mux ad1884a_laptop_capture_source = {
-        .num_items = 4,
-        .items = {
-                { "Mic", 0x0 },         /* port-B */
-                { "Internal Mic", 0x1 }, /* port-C */
-                { "Dock Mic", 0x4 },    /* port-E */
-                { "Mix", 0x3 },
-        },
-};
+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_laptop_mixers[] = {
         HDA_CODEC_VOLUME("Master Playback Volume", 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_MUTE("Dock Playback Switch", 0x12, 0x0, HDA_OUTPUT),
         HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
         HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
@@ -3717,26 +3740,20 @@ static struct snd_kcontrol_new ad1884a_laptop_mixers[] = {
         HDA_CODEC_VOLUME("Dock Mic Boost", 0x25, 0x0, HDA_OUTPUT),
         HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
         HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
-        HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
-        HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 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 = ad198x_mux_enum_info,
-                .get = ad198x_mux_enum_get,
-                .put = ad198x_mux_enum_put,
-        },
         { } /* end */
 };
 
 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),
         HDA_CODEC_VOLUME("Mic Capture Volume", 0x14, 0x0, HDA_INPUT),
@@ -3795,6 +3812,63 @@ static int ad1884a_hp_init(struct hda_codec *codec)
         return 0;
 }
 
+/* mute internal speaker if HP or docking HP is plugged */
+static void ad1884a_laptop_automute(struct hda_codec *codec)
+{
+        unsigned int present;
+
+        present = snd_hda_codec_read(codec, 0x11, 0, AC_VERB_GET_PIN_SENSE, 0);
+        present &= AC_PINSENSE_PRESENCE;
+        if (!present) {
+                present = snd_hda_codec_read(codec, 0x12, 0,
+                                             AC_VERB_GET_PIN_SENSE, 0);
+                present &= AC_PINSENSE_PRESENCE;
+        }
+        snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
+                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
+        snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_EAPD_BTLENABLE,
+                            present ? 0x00 : 0x02);
+}
+
+/* switch to external mic if plugged */
+static void ad1884a_laptop_automic(struct hda_codec *codec)
+{
+        unsigned int idx;
+
+        if (snd_hda_codec_read(codec, 0x14, 0, AC_VERB_GET_PIN_SENSE, 0) &
+            AC_PINSENSE_PRESENCE)
+                idx = 0;
+        else if (snd_hda_codec_read(codec, 0x1c, 0, AC_VERB_GET_PIN_SENSE, 0) &
+                 AC_PINSENSE_PRESENCE)
+                idx = 4;
+        else
+                idx = 1;
+        snd_hda_codec_write(codec, 0x0c, 0, AC_VERB_SET_CONNECT_SEL, idx);
+}
+
+/* unsolicited event for HP jack sensing */
+static void ad1884a_laptop_unsol_event(struct hda_codec *codec,
+                                       unsigned int res)
+{
+        switch (res >> 26) {
+        case AD1884A_HP_EVENT:
+                ad1884a_laptop_automute(codec);
+                break;
+        case AD1884A_MIC_EVENT:
+                ad1884a_laptop_automic(codec);
+                break;
+        }
+}
+
+/* initialize jack-sensing, too */
+static int ad1884a_laptop_init(struct hda_codec *codec)
+{
+        ad198x_init(codec);
+        ad1884a_laptop_automute(codec);
+        ad1884a_laptop_automic(codec);
+        return 0;
+}
+
 /* additional verbs for laptop model */
 static struct hda_verb ad1884a_laptop_verbs[] = {
         /* Port-A (HP) pin - always unmuted */
@@ -3802,18 +3876,28 @@ static struct hda_verb ad1884a_laptop_verbs[] = {
         /* Port-F (int speaker) mixer - route only from analog mixer */
         {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},
         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7002}, /* raise mic as default */
         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x7002}, /* raise mic as default */
+        /* Port-D (docking line-out) pin - default unmuted */
+        {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
         /* analog mix */
         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
         /* unsolicited event for pin-sense */
         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT},
+        {0x12, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT},
         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_MIC_EVENT},
+        {0x1c, 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 */
         { } /* end */
 };
 
@@ -3857,6 +3941,10 @@ static struct hda_verb ad1884a_mobile_verbs[] = {
         /* unsolicited event for pin-sense */
         {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 */
         { } /* end */
 };
 
@@ -3966,8 +4054,10 @@ static struct snd_pci_quirk ad1884a_cfg_tbl[] = {
         SND_PCI_QUIRK(0x103c, 0x3037, "HP 2230s", AD1884A_LAPTOP),
         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),
         {}
 };
@@ -4017,9 +4107,8 @@ static int patch_ad1884a(struct hda_codec *codec)
                 spec->mixers[0] = ad1884a_laptop_mixers;
                 spec->init_verbs[spec->num_init_verbs++] = ad1884a_laptop_verbs;
                 spec->multiout.dig_out_nid = 0;
-                spec->input_mux = &ad1884a_laptop_capture_source;
-                codec->patch_ops.unsol_event = ad1884a_hp_unsol_event;
-                codec->patch_ops.init = ad1884a_hp_init;
+                codec->patch_ops.unsol_event = ad1884a_laptop_unsol_event;
+                codec->patch_ops.init = ad1884a_laptop_init;
                 /* set the upper-limit for mixer amp to 0dB for avoiding the
                  * possible damage by overloading
                  */
diff --git a/sound/pci/hda/patch_atihdmi.c b/sound/pci/hda/patch_atihdmi.c
index 233e4778bba9..fb684f00156b 100644
--- a/sound/pci/hda/patch_atihdmi.c
+++ b/sound/pci/hda/patch_atihdmi.c
@@ -141,8 +141,7 @@ static int atihdmi_build_pcms(struct hda_codec *codec)
         /* FIXME: we must check ELD and change the PCM parameters dynamically
          */
         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;
 
         return 0;
diff --git a/sound/pci/hda/patch_ca0110.c b/sound/pci/hda/patch_ca0110.c
index 392d108c3558..d08353d3bb7f 100644
--- a/sound/pci/hda/patch_ca0110.c
+++ b/sound/pci/hda/patch_ca0110.c
@@ -459,8 +459,7 @@ static void parse_input(struct hda_codec *codec)
         nid = codec->start_nid;
         for (i = 0; i < codec->num_nodes; i++, nid++) {
                 unsigned int wcaps = get_wcaps(codec, nid);
-                unsigned int type = (wcaps & AC_WCAP_TYPE) >>
-                        AC_WCAP_TYPE_SHIFT;
+                unsigned int type = get_wcaps_type(wcaps);
                 if (type != AC_WID_AUD_IN)
                         continue;
                 if (snd_hda_get_connections(codec, nid, &pin, 1) != 1)
@@ -510,7 +509,7 @@ static int ca0110_parse_auto_config(struct hda_codec *codec)
 }
 
 
-int patch_ca0110(struct hda_codec *codec)
+static int patch_ca0110(struct hda_codec *codec)
 {
         struct ca0110_spec *spec;
         int err;
diff --git a/sound/pci/hda/patch_cirrus.c b/sound/pci/hda/patch_cirrus.c
new file mode 100644
index 000000000000..8ba306856d38
--- /dev/null
+++ b/sound/pci/hda/patch_cirrus.c
@@ -0,0 +1,1194 @@
+/*
+ * HD audio interface patch for Cirrus Logic CS420x chip
+ *
+ * Copyright (c) 2009 Takashi Iwai <tiwai@suse.de>
+ *
+ *  This driver is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This driver is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ */
+
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/slab.h>
+#include <linux/pci.h>
+#include <sound/core.h>
+#include "hda_codec.h"
+#include "hda_local.h"
+
+/*
+ */
+
+struct cs_spec {
+        int board_config;
+        struct auto_pin_cfg autocfg;
+        struct hda_multi_out multiout;
+        struct snd_kcontrol *vmaster_sw;
+        struct snd_kcontrol *vmaster_vol;
+
+        hda_nid_t dac_nid[AUTO_CFG_MAX_OUTS];
+        hda_nid_t slave_dig_outs[2];
+
+        unsigned int input_idx[AUTO_PIN_LAST];
+        unsigned int capsrc_idx[AUTO_PIN_LAST];
+        hda_nid_t adc_nid[AUTO_PIN_LAST];
+        unsigned int adc_idx[AUTO_PIN_LAST];
+        unsigned int num_inputs;
+        unsigned int cur_input;
+        unsigned int automic_idx;
+        hda_nid_t cur_adc;
+        unsigned int cur_adc_stream_tag;
+        unsigned int cur_adc_format;
+        hda_nid_t dig_in;
+
+        struct hda_bind_ctls *capture_bind[2];
+
+        unsigned int gpio_mask;
+        unsigned int gpio_dir;
+        unsigned int gpio_data;
+
+        struct hda_pcm pcm_rec[2];      /* PCM information */
+
+        unsigned int hp_detect:1;
+        unsigned int mic_detect:1;
+};
+
+/* available models */
+enum {
+        CS420X_MBP55,
+        CS420X_AUTO,
+        CS420X_MODELS
+};
+
+/* Vendor-specific processing widget */
+#define CS420X_VENDOR_NID       0x11
+#define CS_DIG_OUT1_PIN_NID     0x10
+#define CS_DIG_OUT2_PIN_NID     0x15
+#define CS_DMIC1_PIN_NID        0x12
+#define CS_DMIC2_PIN_NID        0x0e
+
+/* coef indices */
+#define IDX_SPDIF_STAT          0x0000
+#define IDX_SPDIF_CTL           0x0001
+#define IDX_ADC_CFG             0x0002
+/* SZC bitmask, 4 modes below:
+ * 0 = immediate,
+ * 1 = digital immediate, analog zero-cross
+ * 2 = digtail & analog soft-ramp
+ * 3 = digital soft-ramp, analog zero-cross
+ */
+#define   CS_COEF_ADC_SZC_MASK          (3 << 0)
+#define   CS_COEF_ADC_MIC_SZC_MODE      (3 << 0) /* SZC setup for mic */
+#define   CS_COEF_ADC_LI_SZC_MODE       (3 << 0) /* SZC setup for line-in */
+/* PGA mode: 0 = differential, 1 = signle-ended */
+#define   CS_COEF_ADC_MIC_PGA_MODE      (1 << 5) /* PGA setup for mic */
+#define   CS_COEF_ADC_LI_PGA_MODE       (1 << 6) /* PGA setup for line-in */
+#define IDX_DAC_CFG             0x0003
+/* SZC bitmask, 4 modes below:
+ * 0 = Immediate
+ * 1 = zero-cross
+ * 2 = soft-ramp
+ * 3 = soft-ramp on zero-cross
+ */
+#define   CS_COEF_DAC_HP_SZC_MODE       (3 << 0) /* nid 0x02 */
+#define   CS_COEF_DAC_LO_SZC_MODE       (3 << 2) /* nid 0x03 */
+#define   CS_COEF_DAC_SPK_SZC_MODE      (3 << 4) /* nid 0x04 */
+
+#define IDX_BEEP_CFG            0x0004
+/* 0x0008 - test reg key */
+/* 0x0009 - 0x0014 -> 12 test regs */
+/* 0x0015 - visibility reg */
+
+
+static inline int cs_vendor_coef_get(struct hda_codec *codec, unsigned int idx)
+{
+        snd_hda_codec_write(codec, CS420X_VENDOR_NID, 0,
+                            AC_VERB_SET_COEF_INDEX, idx);
+        return snd_hda_codec_read(codec, CS420X_VENDOR_NID, 0,
+                                  AC_VERB_GET_PROC_COEF, 0);
+}
+
+static inline void cs_vendor_coef_set(struct hda_codec *codec, unsigned int idx,
+                                      unsigned int coef)
+{
+        snd_hda_codec_write(codec, CS420X_VENDOR_NID, 0,
+                            AC_VERB_SET_COEF_INDEX, idx);
+        snd_hda_codec_write(codec, CS420X_VENDOR_NID, 0,
+                            AC_VERB_SET_PROC_COEF, coef);
+}
+
+
+#define HP_EVENT        1
+#define MIC_EVENT       2
+
+/*
+ * PCM callbacks
+ */
+static int cs_playback_pcm_open(struct hda_pcm_stream *hinfo,
+                                struct hda_codec *codec,
+                                struct snd_pcm_substream *substream)
+{
+        struct cs_spec *spec = codec->spec;
+        return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
+                                             hinfo);
+}
+
+static int cs_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
+                                   struct hda_codec *codec,
+                                   unsigned int stream_tag,
+                                   unsigned int format,
+                                   struct snd_pcm_substream *substream)
+{
+        struct cs_spec *spec = codec->spec;
+        return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
+                                                stream_tag, format, substream);
+}
+
+static int cs_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
+                                   struct hda_codec *codec,
+                                   struct snd_pcm_substream *substream)
+{
+        struct cs_spec *spec = codec->spec;
+        return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
+}
+
+/*
+ * Digital out
+ */
+static int cs_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
+                                    struct hda_codec *codec,
+                                    struct snd_pcm_substream *substream)
+{
+        struct cs_spec *spec = codec->spec;
+        return snd_hda_multi_out_dig_open(codec, &spec->multiout);
+}
+
+static int cs_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
+                                     struct hda_codec *codec,
+                                     struct snd_pcm_substream *substream)
+{
+        struct cs_spec *spec = codec->spec;
+        return snd_hda_multi_out_dig_close(codec, &spec->multiout);
+}
+
+static int cs_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
+                                       struct hda_codec *codec,
+                                       unsigned int stream_tag,
+                                       unsigned int format,
+                                       struct snd_pcm_substream *substream)
+{
+        struct cs_spec *spec = codec->spec;
+        return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, stream_tag,
+                                             format, substream);
+}
+
+static int cs_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
+                                       struct hda_codec *codec,
+                                       struct snd_pcm_substream *substream)
+{
+        struct cs_spec *spec = codec->spec;
+        return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
+}
+
+/*
+ * Analog capture
+ */
+static int cs_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
+                                  struct hda_codec *codec,
+                                  unsigned int stream_tag,
+                                  unsigned int format,
+                                  struct snd_pcm_substream *substream)
+{
+        struct cs_spec *spec = codec->spec;
+        spec->cur_adc = spec->adc_nid[spec->cur_input];
+        spec->cur_adc_stream_tag = stream_tag;
+        spec->cur_adc_format = format;
+        snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
+        return 0;
+}
+
+static int cs_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
+                                  struct hda_codec *codec,
+                                  struct snd_pcm_substream *substream)
+{
+        struct cs_spec *spec = codec->spec;
+        snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
+        spec->cur_adc = 0;
+        return 0;
+}
+
+/*
+ */
+static struct hda_pcm_stream cs_pcm_analog_playback = {
+        .substreams = 1,
+        .channels_min = 2,
+        .channels_max = 2,
+        .ops = {
+                .open = cs_playback_pcm_open,
+                .prepare = cs_playback_pcm_prepare,
+                .cleanup = cs_playback_pcm_cleanup
+        },
+};
+
+static struct hda_pcm_stream cs_pcm_analog_capture = {
+        .substreams = 1,
+        .channels_min = 2,
+        .channels_max = 2,
+        .ops = {
+                .prepare = cs_capture_pcm_prepare,
+                .cleanup = cs_capture_pcm_cleanup
+        },
+};
+
+static struct hda_pcm_stream cs_pcm_digital_playback = {
+        .substreams = 1,
+        .channels_min = 2,
+        .channels_max = 2,
+        .ops = {
+                .open = cs_dig_playback_pcm_open,
+                .close = cs_dig_playback_pcm_close,
+                .prepare = cs_dig_playback_pcm_prepare,
+                .cleanup = cs_dig_playback_pcm_cleanup
+        },
+};
+
+static struct hda_pcm_stream cs_pcm_digital_capture = {
+        .substreams = 1,
+        .channels_min = 2,
+        .channels_max = 2,
+};
+
+static int cs_build_pcms(struct hda_codec *codec)
+{
+        struct cs_spec *spec = codec->spec;
+        struct hda_pcm *info = spec->pcm_rec;
+
+        codec->pcm_info = info;
+        codec->num_pcms = 0;
+
+        info->name = "Cirrus Analog";
+        info->stream[SNDRV_PCM_STREAM_PLAYBACK] = cs_pcm_analog_playback;
+        info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->dac_nid[0];
+        info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
+                spec->multiout.max_channels;
+        info->stream[SNDRV_PCM_STREAM_CAPTURE] = cs_pcm_analog_capture;
+        info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
+                spec->adc_nid[spec->cur_input];
+        codec->num_pcms++;
+
+        if (!spec->multiout.dig_out_nid && !spec->dig_in)
+                return 0;
+
+        info++;
+        info->name = "Cirrus Digital";
+        info->pcm_type = spec->autocfg.dig_out_type[0];
+        if (!info->pcm_type)
+                info->pcm_type = HDA_PCM_TYPE_SPDIF;
+        if (spec->multiout.dig_out_nid) {
+                info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
+                        cs_pcm_digital_playback;
+                info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
+                        spec->multiout.dig_out_nid;
+        }
+        if (spec->dig_in) {
+                info->stream[SNDRV_PCM_STREAM_CAPTURE] =
+                        cs_pcm_digital_capture;
+                info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in;
+        }
+        codec->num_pcms++;
+
+        return 0;
+}
+
+/*
+ * parse codec topology
+ */
+
+static hda_nid_t get_dac(struct hda_codec *codec, hda_nid_t pin)
+{
+        hda_nid_t dac;
+        if (!pin)
+                return 0;
+        if (snd_hda_get_connections(codec, pin, &dac, 1) != 1)
+                return 0;
+        return dac;
+}
+
+static int is_ext_mic(struct hda_codec *codec, unsigned int idx)
+{
+        struct cs_spec *spec = codec->spec;
+        struct auto_pin_cfg *cfg = &spec->autocfg;
+        hda_nid_t pin = cfg->input_pins[idx];
+        unsigned int val = snd_hda_query_pin_caps(codec, pin);
+        if (!(val & AC_PINCAP_PRES_DETECT))
+                return 0;
+        val = snd_hda_codec_get_pincfg(codec, pin);
+        return (get_defcfg_connect(val) == AC_JACK_PORT_COMPLEX);
+}
+
+static hda_nid_t get_adc(struct hda_codec *codec, hda_nid_t pin,
+                         unsigned int *idxp)
+{
+        int i;
+        hda_nid_t nid;
+
+        nid = codec->start_nid;
+        for (i = 0; i < codec->num_nodes; i++, nid++) {
+                hda_nid_t pins[2];
+                unsigned int type;
+                int j, nums;
+                type = (get_wcaps(codec, nid) & AC_WCAP_TYPE)
+                        >> AC_WCAP_TYPE_SHIFT;
+                if (type != AC_WID_AUD_IN)
+                        continue;
+                nums = snd_hda_get_connections(codec, nid, pins,
+                                               ARRAY_SIZE(pins));
+                if (nums <= 0)
+                        continue;
+                for (j = 0; j < nums; j++) {
+                        if (pins[j] == pin) {
+                                *idxp = j;
+                                return nid;
+                        }
+                }
+        }
+        return 0;
+}
+
+static int is_active_pin(struct hda_codec *codec, hda_nid_t nid)
+{
+        unsigned int val;
+        val = snd_hda_codec_get_pincfg(codec, nid);
+        return (get_defcfg_connect(val) != AC_JACK_PORT_NONE);
+}
+
+static int parse_output(struct hda_codec *codec)
+{
+        struct cs_spec *spec = codec->spec;
+        struct auto_pin_cfg *cfg = &spec->autocfg;
+        int i, extra_nids;
+        hda_nid_t dac;
+
+        for (i = 0; i < cfg->line_outs; i++) {
+                dac = get_dac(codec, cfg->line_out_pins[i]);
+                if (!dac)
+                        break;
+                spec->dac_nid[i] = dac;
+        }
+        spec->multiout.num_dacs = i;
+        spec->multiout.dac_nids = spec->dac_nid;
+        spec->multiout.max_channels = i * 2;
+
+        /* add HP and speakers */
+        extra_nids = 0;
+        for (i = 0; i < cfg->hp_outs; i++) {
+                dac = get_dac(codec, cfg->hp_pins[i]);
+                if (!dac)
+                        break;
+                if (!i)
+                        spec->multiout.hp_nid = dac;
+                else
+                        spec->multiout.extra_out_nid[extra_nids++] = dac;
+        }
+        for (i = 0; i < cfg->speaker_outs; i++) {
+                dac = get_dac(codec, cfg->speaker_pins[i]);
+                if (!dac)
+                        break;
+                spec->multiout.extra_out_nid[extra_nids++] = dac;
+        }
+
+        if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
+                cfg->speaker_outs = cfg->line_outs;
+                memcpy(cfg->speaker_pins, cfg->line_out_pins,
+                       sizeof(cfg->speaker_pins));
+                cfg->line_outs = 0;
+        }
+
+        return 0;
+}
+
+static int parse_input(struct hda_codec *codec)
+{
+        struct cs_spec *spec = codec->spec;
+        struct auto_pin_cfg *cfg = &spec->autocfg;
+        int i;
+
+        for (i = 0; i < AUTO_PIN_LAST; i++) {
+                hda_nid_t pin = cfg->input_pins[i];
+                if (!pin)
+                        continue;
+                spec->input_idx[spec->num_inputs] = i;
+                spec->capsrc_idx[i] = spec->num_inputs++;
+                spec->cur_input = i;
+                spec->adc_nid[i] = get_adc(codec, pin, &spec->adc_idx[i]);
+        }
+        if (!spec->num_inputs)
+                return 0;
+
+        /* check whether the automatic mic switch is available */
+        if (spec->num_inputs == 2 &&
+            spec->adc_nid[AUTO_PIN_MIC] && spec->adc_nid[AUTO_PIN_FRONT_MIC]) {
+                if (is_ext_mic(codec, cfg->input_pins[AUTO_PIN_FRONT_MIC])) {
+                        if (!is_ext_mic(codec, cfg->input_pins[AUTO_PIN_MIC])) {
+                                spec->mic_detect = 1;
+                                spec->automic_idx = AUTO_PIN_FRONT_MIC;
+                        }
+                } else {
+                        if (is_ext_mic(codec, cfg->input_pins[AUTO_PIN_MIC])) {
+                                spec->mic_detect = 1;
+                                spec->automic_idx = AUTO_PIN_MIC;
+                        }
+                }
+        }
+        return 0;
+}
+
+
+static int parse_digital_output(struct hda_codec *codec)
+{
+        struct cs_spec *spec = codec->spec;
+        struct auto_pin_cfg *cfg = &spec->autocfg;
+        hda_nid_t nid;
+
+        if (!cfg->dig_outs)
+                return 0;
+        if (snd_hda_get_connections(codec, cfg->dig_out_pins[0], &nid, 1) < 1)
+                return 0;
+        spec->multiout.dig_out_nid = nid;
+        spec->multiout.share_spdif = 1;
+        if (cfg->dig_outs > 1 &&
+            snd_hda_get_connections(codec, cfg->dig_out_pins[1], &nid, 1) > 0) {
+                spec->slave_dig_outs[0] = nid;
+                codec->slave_dig_outs = spec->slave_dig_outs;
+        }
+        return 0;
+}
+
+static int parse_digital_input(struct hda_codec *codec)
+{
+        struct cs_spec *spec = codec->spec;
+        struct auto_pin_cfg *cfg = &spec->autocfg;
+        int idx;
+
+        if (cfg->dig_in_pin)
+                spec->dig_in = get_adc(codec, cfg->dig_in_pin, &idx);
+        return 0;
+}
+
+/*
+ * create mixer controls
+ */
+
+static const char *dir_sfx[2] = { "Playback", "Capture" };
+
+static int add_mute(struct hda_codec *codec, const char *name, int index,
+                    unsigned int pval, int dir, struct snd_kcontrol **kctlp)
+{
+        char tmp[44];
+        struct snd_kcontrol_new knew =
+                HDA_CODEC_MUTE_IDX(tmp, index, 0, 0, HDA_OUTPUT);
+        knew.private_value = pval;
+        snprintf(tmp, sizeof(tmp), "%s %s Switch", name, dir_sfx[dir]);
+        *kctlp = snd_ctl_new1(&knew, codec);
+        return snd_hda_ctl_add(codec, *kctlp);
+}
+
+static int add_volume(struct hda_codec *codec, const char *name,
+                      int index, unsigned int pval, int dir,
+                      struct snd_kcontrol **kctlp)
+{
+        char tmp[32];
+        struct snd_kcontrol_new knew =
+                HDA_CODEC_VOLUME_IDX(tmp, index, 0, 0, HDA_OUTPUT);
+        knew.private_value = pval;
+        snprintf(tmp, sizeof(tmp), "%s %s Volume", name, dir_sfx[dir]);
+        *kctlp = snd_ctl_new1(&knew, codec);
+        return snd_hda_ctl_add(codec, *kctlp);
+}
+
+static void fix_volume_caps(struct hda_codec *codec, hda_nid_t dac)
+{
+        unsigned int caps;
+
+        /* set the upper-limit for mixer amp to 0dB */
+        caps = query_amp_caps(codec, dac, HDA_OUTPUT);
+        caps &= ~(0x7f << AC_AMPCAP_NUM_STEPS_SHIFT);
+        caps |= ((caps >> AC_AMPCAP_OFFSET_SHIFT) & 0x7f)
+                << AC_AMPCAP_NUM_STEPS_SHIFT;
+        snd_hda_override_amp_caps(codec, dac, HDA_OUTPUT, caps);
+}
+
+static int add_vmaster(struct hda_codec *codec, hda_nid_t dac)
+{
+        struct cs_spec *spec = codec->spec;
+        unsigned int tlv[4];
+        int err;
+
+        spec->vmaster_sw =
+                snd_ctl_make_virtual_master("Master Playback Switch", NULL);
+        err = snd_hda_ctl_add(codec, spec->vmaster_sw);
+        if (err < 0)
+                return err;
+
+        snd_hda_set_vmaster_tlv(codec, dac, HDA_OUTPUT, tlv);
+        spec->vmaster_vol =
+                snd_ctl_make_virtual_master("Master Playback Volume", tlv);
+        err = snd_hda_ctl_add(codec, spec->vmaster_vol);
+        if (err < 0)
+                return err;
+        return 0;
+}
+
+static int add_output(struct hda_codec *codec, hda_nid_t dac, int idx,
+                      int num_ctls, int type)
+{
+        struct cs_spec *spec = codec->spec;
+        const char *name;
+        int err, index;
+        struct snd_kcontrol *kctl;
+        static char *speakers[] = {
+                "Front Speaker", "Surround Speaker", "Bass Speaker"
+        };
+        static char *line_outs[] = {
+                "Front Line-Out", "Surround Line-Out", "Bass Line-Out"
+        };
+
+        fix_volume_caps(codec, dac);
+        if (!spec->vmaster_sw) {
+                err = add_vmaster(codec, dac);
+                if (err < 0)
+                        return err;
+        }
+
+        index = 0;
+        switch (type) {
+        case AUTO_PIN_HP_OUT:
+                name = "Headphone";
+                index = idx;
+                break;
+        case AUTO_PIN_SPEAKER_OUT:
+                if (num_ctls > 1)
+                        name = speakers[idx];
+                else
+                        name = "Speaker";
+                break;
+        default:
+                if (num_ctls > 1)
+                        name = line_outs[idx];
+                else
+                        name = "Line-Out";
+                break;
+        }
+
+        err = add_mute(codec, name, index,
+                       HDA_COMPOSE_AMP_VAL(dac, 3, 0, HDA_OUTPUT), 0, &kctl);
+        if (err < 0)
+                return err;
+        err = snd_ctl_add_slave(spec->vmaster_sw, kctl);
+        if (err < 0)
+                return err;
+
+        err = add_volume(codec, name, index,
+                         HDA_COMPOSE_AMP_VAL(dac, 3, 0, HDA_OUTPUT), 0, &kctl);
+        if (err < 0)
+                return err;
+        err = snd_ctl_add_slave(spec->vmaster_vol, kctl);
+        if (err < 0)
+                return err;
+
+        return 0;
+}               
+
+static int build_output(struct hda_codec *codec)
+{
+        struct cs_spec *spec = codec->spec;
+        struct auto_pin_cfg *cfg = &spec->autocfg;
+        int i, err;
+
+        for (i = 0; i < cfg->line_outs; i++) {
+                err = add_output(codec, get_dac(codec, cfg->line_out_pins[i]),
+                                 i, cfg->line_outs, cfg->line_out_type);
+                if (err < 0)
+                        return err;
+        }
+        for (i = 0; i < cfg->hp_outs; i++) {
+                err = add_output(codec, get_dac(codec, cfg->hp_pins[i]),
+                                 i, cfg->hp_outs, AUTO_PIN_HP_OUT);
+                if (err < 0)
+                        return err;
+        }
+        for (i = 0; i < cfg->speaker_outs; i++) {
+                err = add_output(codec, get_dac(codec, cfg->speaker_pins[i]),
+                                 i, cfg->speaker_outs, AUTO_PIN_SPEAKER_OUT);
+                if (err < 0)
+                        return err;
+        }
+        return 0;
+}
+
+/*
+ */
+
+static struct snd_kcontrol_new cs_capture_ctls[] = {
+        HDA_BIND_SW("Capture Switch", 0),
+        HDA_BIND_VOL("Capture Volume", 0),
+};
+
+static int change_cur_input(struct hda_codec *codec, unsigned int idx,
+                            int force)
+{
+        struct cs_spec *spec = codec->spec;
+        
+        if (spec->cur_input == idx && !force)
+                return 0;
+        if (spec->cur_adc && spec->cur_adc != spec->adc_nid[idx]) {
+                /* stream is running, let's swap the current ADC */
+                snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
+                spec->cur_adc = spec->adc_nid[idx];
+                snd_hda_codec_setup_stream(codec, spec->cur_adc,
+                                           spec->cur_adc_stream_tag, 0,
+                                           spec->cur_adc_format);
+        }
+        snd_hda_codec_write(codec, spec->cur_adc, 0,
+                            AC_VERB_SET_CONNECT_SEL,
+                            spec->adc_idx[idx]);
+        spec->cur_input = idx;
+        return 1;
+}
+
+static int cs_capture_source_info(struct snd_kcontrol *kcontrol,
+                                  struct snd_ctl_elem_info *uinfo)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct cs_spec *spec = codec->spec;
+        unsigned int idx;
+
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        uinfo->count = 1;
+        uinfo->value.enumerated.items = spec->num_inputs;
+        if (uinfo->value.enumerated.item >= spec->num_inputs)
+                uinfo->value.enumerated.item = spec->num_inputs - 1;
+        idx = spec->input_idx[uinfo->value.enumerated.item];
+        strcpy(uinfo->value.enumerated.name, auto_pin_cfg_labels[idx]);
+        return 0;
+}
+
+static int cs_capture_source_get(struct snd_kcontrol *kcontrol,
+                                 struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct cs_spec *spec = codec->spec;
+        ucontrol->value.enumerated.item[0] = spec->capsrc_idx[spec->cur_input];
+        return 0;
+}
+
+static int cs_capture_source_put(struct snd_kcontrol *kcontrol,
+                                 struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct cs_spec *spec = codec->spec;
+        unsigned int idx = ucontrol->value.enumerated.item[0];
+
+        if (idx >= spec->num_inputs)
+                return -EINVAL;
+        idx = spec->input_idx[idx];
+        return change_cur_input(codec, idx, 0);
+}
+
+static struct snd_kcontrol_new cs_capture_source = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name = "Capture Source",
+        .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
+        .info = cs_capture_source_info,
+        .get = cs_capture_source_get,
+        .put = cs_capture_source_put,
+};
+
+static struct hda_bind_ctls *make_bind_capture(struct hda_codec *codec,
+                                               struct hda_ctl_ops *ops)
+{
+        struct cs_spec *spec = codec->spec;
+        struct hda_bind_ctls *bind;
+        int i, n;
+
+        bind = kzalloc(sizeof(*bind) + sizeof(long) * (spec->num_inputs + 1),
+                       GFP_KERNEL);
+        if (!bind)
+                return NULL;
+        bind->ops = ops;
+        n = 0;
+        for (i = 0; i < AUTO_PIN_LAST; i++) {
+                if (!spec->adc_nid[i])
+                        continue;
+                bind->values[n++] =
+                        HDA_COMPOSE_AMP_VAL(spec->adc_nid[i], 3,
+                                            spec->adc_idx[i], HDA_INPUT);
+        }
+        return bind;
+}
+
+static int build_input(struct hda_codec *codec)
+{
+        struct cs_spec *spec = codec->spec;
+        int i, err;
+
+        if (!spec->num_inputs)
+                return 0;
+
+        /* make bind-capture */
+        spec->capture_bind[0] = make_bind_capture(codec, &snd_hda_bind_sw);
+        spec->capture_bind[1] = make_bind_capture(codec, &snd_hda_bind_vol);
+        for (i = 0; i < 2; i++) {
+                struct snd_kcontrol *kctl;
+                if (!spec->capture_bind[i])
+                        return -ENOMEM;
+                kctl = snd_ctl_new1(&cs_capture_ctls[i], codec);
+                if (!kctl)
+                        return -ENOMEM;
+                kctl->private_value = (long)spec->capture_bind[i];
+                err = snd_hda_ctl_add(codec, kctl);
+                if (err < 0)
+                        return err;
+        }
+        
+        if (spec->num_inputs > 1 && !spec->mic_detect) {
+                err = snd_hda_ctl_add(codec,
+                                      snd_ctl_new1(&cs_capture_source, codec));
+                if (err < 0)
+                        return err;
+        }
+
+        return 0;
+}
+
+/*
+ */
+
+static int build_digital_output(struct hda_codec *codec)
+{
+        struct cs_spec *spec = codec->spec;
+        int err;
+
+        if (!spec->multiout.dig_out_nid)
+                return 0;
+
+        err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
+        if (err < 0)
+                return err;
+        err = snd_hda_create_spdif_share_sw(codec, &spec->multiout);
+        if (err < 0)
+                return err;
+        return 0;
+}
+
+static int build_digital_input(struct hda_codec *codec)
+{
+        struct cs_spec *spec = codec->spec;
+        if (spec->dig_in)
+                return snd_hda_create_spdif_in_ctls(codec, spec->dig_in);
+        return 0;
+}
+
+/*
+ * auto-mute and auto-mic switching
+ */
+
+static void cs_automute(struct hda_codec *codec)
+{
+        struct cs_spec *spec = codec->spec;
+        struct auto_pin_cfg *cfg = &spec->autocfg;
+        unsigned int caps, present, hp_present;
+        hda_nid_t nid;
+        int i;
+
+        hp_present = 0;
+        for (i = 0; i < cfg->hp_outs; i++) {
+                nid = cfg->hp_pins[i];
+                caps = snd_hda_query_pin_caps(codec, nid);
+                if (!(caps & AC_PINCAP_PRES_DETECT))
+                        continue;
+                if (caps & AC_PINCAP_TRIG_REQ)
+                        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);
+                hp_present |= (present & AC_PINSENSE_PRESENCE) != 0;
+                if (hp_present)
+                        break;
+        }
+        for (i = 0; i < cfg->speaker_outs; i++) {
+                nid = cfg->speaker_pins[i];
+                snd_hda_codec_write(codec, nid, 0,
+                                    AC_VERB_SET_PIN_WIDGET_CONTROL,
+                                    hp_present ? 0 : PIN_OUT);
+        }
+        if (spec->board_config == CS420X_MBP55) {
+                unsigned int gpio = hp_present ? 0x02 : 0x08;
+                snd_hda_codec_write(codec, 0x01, 0,
+                                    AC_VERB_SET_GPIO_DATA, gpio);
+        }
+}
+
+static void cs_automic(struct hda_codec *codec)
+{
+        struct cs_spec *spec = codec->spec;
+        struct auto_pin_cfg *cfg = &spec->autocfg;
+        hda_nid_t nid;
+        unsigned int caps, present;
+        
+        nid = cfg->input_pins[spec->automic_idx];
+        caps = snd_hda_query_pin_caps(codec, nid);
+        if (caps & AC_PINCAP_TRIG_REQ)
+                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);
+        if (present & AC_PINSENSE_PRESENCE)
+                change_cur_input(codec, spec->automic_idx, 0);
+        else {
+                unsigned int imic = (spec->automic_idx == AUTO_PIN_MIC) ?
+                        AUTO_PIN_FRONT_MIC : AUTO_PIN_MIC;
+                change_cur_input(codec, imic, 0);
+        }
+}
+
+/*
+ */
+
+static void init_output(struct hda_codec *codec)
+{
+        struct cs_spec *spec = codec->spec;
+        struct auto_pin_cfg *cfg = &spec->autocfg;
+        int i;
+
+        /* mute first */
+        for (i = 0; i < spec->multiout.num_dacs; i++)
+                snd_hda_codec_write(codec, spec->multiout.dac_nids[i], 0,
+                                    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
+        if (spec->multiout.hp_nid)
+                snd_hda_codec_write(codec, spec->multiout.hp_nid, 0,
+                                    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
+        for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++) {
+                if (!spec->multiout.extra_out_nid[i])
+                        break;
+                snd_hda_codec_write(codec, spec->multiout.extra_out_nid[i], 0,
+                                    AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
+        }
+
+        /* set appropriate pin controls */
+        for (i = 0; i < cfg->line_outs; i++)
+                snd_hda_codec_write(codec, cfg->line_out_pins[i], 0,
+                                    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
+        for (i = 0; i < cfg->hp_outs; i++) {
+                hda_nid_t nid = cfg->hp_pins[i];
+                snd_hda_codec_write(codec, nid, 0,
+                                    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP);
+                if (!cfg->speaker_outs)
+                        continue;
+                if (get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP) {
+                        snd_hda_codec_write(codec, nid, 0,
+                                            AC_VERB_SET_UNSOLICITED_ENABLE,
+                                            AC_USRSP_EN | HP_EVENT);
+                        spec->hp_detect = 1;
+                }
+        }
+        for (i = 0; i < cfg->speaker_outs; i++)
+                snd_hda_codec_write(codec, cfg->speaker_pins[i], 0,
+                                    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
+        if (spec->hp_detect)
+                cs_automute(codec);
+}
+
+static void init_input(struct hda_codec *codec)
+{
+        struct cs_spec *spec = codec->spec;
+        struct auto_pin_cfg *cfg = &spec->autocfg;
+        unsigned int coef;
+        int i;
+
+        for (i = 0; i < AUTO_PIN_LAST; i++) {
+                unsigned int ctl;
+                hda_nid_t pin = cfg->input_pins[i];
+                if (!pin || !spec->adc_nid[i])
+                        continue;
+                /* set appropriate pin control and mute first */
+                ctl = PIN_IN;
+                if (i <= AUTO_PIN_FRONT_MIC) {
+                        unsigned int caps = snd_hda_query_pin_caps(codec, pin);
+                        caps >>= AC_PINCAP_VREF_SHIFT;
+                        if (caps & AC_PINCAP_VREF_80)
+                                ctl = PIN_VREF80;
+                }
+                snd_hda_codec_write(codec, pin, 0,
+                                    AC_VERB_SET_PIN_WIDGET_CONTROL, ctl);
+                snd_hda_codec_write(codec, spec->adc_nid[i], 0,
+                                    AC_VERB_SET_AMP_GAIN_MUTE,
+                                    AMP_IN_MUTE(spec->adc_idx[i]));
+                if (spec->mic_detect && spec->automic_idx == i)
+                        snd_hda_codec_write(codec, pin, 0,
+                                            AC_VERB_SET_UNSOLICITED_ENABLE,
+                                            AC_USRSP_EN | MIC_EVENT);
+        }
+        change_cur_input(codec, spec->cur_input, 1);
+        if (spec->mic_detect)
+                cs_automic(codec);
+
+        coef = 0x000a; /* ADC1/2 - Digital and Analog Soft Ramp */
+        if (is_active_pin(codec, CS_DMIC2_PIN_NID))
+                coef |= 0x0500; /* DMIC2 enable 2 channels, disable GPIO1 */
+        if (is_active_pin(codec, CS_DMIC1_PIN_NID))
+                coef |= 0x1800; /* DMIC1 enable 2 channels, disable GPIO0 
+                                 * No effect if SPDIF_OUT2 is slected in 
+                                 * IDX_SPDIF_CTL.
+                                  */
+        cs_vendor_coef_set(codec, IDX_ADC_CFG, coef);
+}
+
+static struct hda_verb cs_coef_init_verbs[] = {
+        {0x11, AC_VERB_SET_PROC_STATE, 1},
+        {0x11, AC_VERB_SET_COEF_INDEX, IDX_DAC_CFG},
+        {0x11, AC_VERB_SET_PROC_COEF,
+         (0x002a /* DAC1/2/3 SZCMode Soft Ramp */
+          | 0x0040 /* Mute DACs on FIFO error */
+          | 0x1000 /* Enable DACs High Pass Filter */
+          | 0x0400 /* Disable Coefficient Auto increment */
+          )},
+        /* Beep */
+        {0x11, AC_VERB_SET_COEF_INDEX, IDX_DAC_CFG},
+        {0x11, AC_VERB_SET_PROC_COEF, 0x0007}, /* Enable Beep thru DAC1/2/3 */
+
+        {} /* terminator */
+};
+
+/* SPDIF setup */
+static void init_digital(struct hda_codec *codec)
+{
+        unsigned int coef;
+
+        coef = 0x0002; /* SRC_MUTE soft-mute on SPDIF (if no lock) */
+        coef |= 0x0008; /* Replace with mute on error */
+        if (is_active_pin(codec, CS_DIG_OUT2_PIN_NID))
+                coef |= 0x4000; /* RX to TX1 or TX2 Loopthru / SPDIF2
+                                 * SPDIF_OUT2 is shared with GPIO1 and
+                                 * DMIC_SDA2.
+                                 */
+        cs_vendor_coef_set(codec, IDX_SPDIF_CTL, coef);
+}
+
+static int cs_init(struct hda_codec *codec)
+{
+        struct cs_spec *spec = codec->spec;
+
+        snd_hda_sequence_write(codec, cs_coef_init_verbs);
+
+        if (spec->gpio_mask) {
+                snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_MASK,
+                                    spec->gpio_mask);
+                snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DIRECTION,
+                                    spec->gpio_dir);
+                snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
+                                    spec->gpio_data);
+        }
+
+        init_output(codec);
+        init_input(codec);
+        init_digital(codec);
+        return 0;
+}
+
+static int cs_build_controls(struct hda_codec *codec)
+{
+        int err;
+
+        err = build_output(codec);
+        if (err < 0)
+                return err;
+        err = build_input(codec);
+        if (err < 0)
+                return err;
+        err = build_digital_output(codec);
+        if (err < 0)
+                return err;
+        err = build_digital_input(codec);
+        if (err < 0)
+                return err;
+        return cs_init(codec);
+}
+
+static void cs_free(struct hda_codec *codec)
+{
+        struct cs_spec *spec = codec->spec;
+        kfree(spec->capture_bind[0]);
+        kfree(spec->capture_bind[1]);
+        kfree(codec->spec);
+}
+
+static void cs_unsol_event(struct hda_codec *codec, unsigned int res)
+{
+        switch ((res >> 26) & 0x7f) {
+        case HP_EVENT:
+                cs_automute(codec);
+                break;
+        case MIC_EVENT:
+                cs_automic(codec);
+                break;
+        }
+}
+
+static struct hda_codec_ops cs_patch_ops = {
+        .build_controls = cs_build_controls,
+        .build_pcms = cs_build_pcms,
+        .init = cs_init,
+        .free = cs_free,
+        .unsol_event = cs_unsol_event,
+};
+
+static int cs_parse_auto_config(struct hda_codec *codec)
+{
+        struct cs_spec *spec = codec->spec;
+        int err;
+
+        err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
+        if (err < 0)
+                return err;
+
+        err = parse_output(codec);
+        if (err < 0)
+                return err;
+        err = parse_input(codec);
+        if (err < 0)
+                return err;
+        err = parse_digital_output(codec);
+        if (err < 0)
+                return err;
+        err = parse_digital_input(codec);
+        if (err < 0)
+                return err;
+        return 0;
+}
+
+static const char *cs420x_models[CS420X_MODELS] = {
+        [CS420X_MBP55] = "mbp55",
+        [CS420X_AUTO] = "auto",
+};
+
+
+static struct snd_pci_quirk cs420x_cfg_tbl[] = {
+        SND_PCI_QUIRK(0x10de, 0xcb79, "MacBookPro 5,5", CS420X_MBP55),
+        {} /* terminator */
+};
+
+struct cs_pincfg {
+        hda_nid_t nid;
+        u32 val;
+};
+
+static struct cs_pincfg mbp55_pincfgs[] = {
+        { 0x09, 0x012b4030 },
+        { 0x0a, 0x90100121 },
+        { 0x0b, 0x90100120 },
+        { 0x0c, 0x400000f0 },
+        { 0x0d, 0x90a00110 },
+        { 0x0e, 0x400000f0 },
+        { 0x0f, 0x400000f0 },
+        { 0x10, 0x014be040 },
+        { 0x12, 0x400000f0 },
+        { 0x15, 0x400000f0 },
+        {} /* terminator */
+};
+
+static struct cs_pincfg *cs_pincfgs[CS420X_MODELS] = {
+        [CS420X_MBP55] = mbp55_pincfgs,
+};
+
+static void fix_pincfg(struct hda_codec *codec, int model)
+{
+        const struct cs_pincfg *cfg = cs_pincfgs[model];
+        if (!cfg)
+                return;
+        for (; cfg->nid; cfg++)
+                snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val);
+}
+
+
+static int patch_cs420x(struct hda_codec *codec)
+{
+        struct cs_spec *spec;
+        int err;
+
+        spec = kzalloc(sizeof(*spec), GFP_KERNEL);
+        if (!spec)
+                return -ENOMEM;
+        codec->spec = spec;
+
+        spec->board_config =
+                snd_hda_check_board_config(codec, CS420X_MODELS,
+                                           cs420x_models, cs420x_cfg_tbl);
+        if (spec->board_config >= 0)
+                fix_pincfg(codec, spec->board_config);
+
+        switch (spec->board_config) {
+        case CS420X_MBP55:
+                /* GPIO1 = headphones */
+                /* GPIO3 = speakers */
+                spec->gpio_mask = 0x0a;
+                spec->gpio_dir = 0x0a;
+                break;
+        }
+
+        err = cs_parse_auto_config(codec);
+        if (err < 0)
+                goto error;
+
+        codec->patch_ops = cs_patch_ops;
+
+        return 0;
+
+ error:
+        kfree(codec->spec);
+        codec->spec = NULL;
+        return err;
+}
+
+
+/*
+ * patch entries
+ */
+static struct hda_codec_preset snd_hda_preset_cirrus[] = {
+        { .id = 0x10134206, .name = "CS4206", .patch = patch_cs420x },
+        { .id = 0x10134207, .name = "CS4207", .patch = patch_cs420x },
+        {} /* terminator */
+};
+
+MODULE_ALIAS("snd-hda-codec-id:10134206");
+MODULE_ALIAS("snd-hda-codec-id:10134207");
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Cirrus Logic HD-audio codec");
+
+static struct hda_codec_preset_list cirrus_list = {
+        .preset = snd_hda_preset_cirrus,
+        .owner = THIS_MODULE,
+};
+
+static int __init patch_cirrus_init(void)
+{
+        return snd_hda_add_codec_preset(&cirrus_list);
+}
+
+static void __exit patch_cirrus_exit(void)
+{
+        snd_hda_delete_codec_preset(&cirrus_list);
+}
+
+module_init(patch_cirrus_init)
+module_exit(patch_cirrus_exit)
diff --git a/sound/pci/hda/patch_cmedia.c b/sound/pci/hda/patch_cmedia.c
index c921264bbd71..780e1a72114a 100644
--- a/sound/pci/hda/patch_cmedia.c
+++ b/sound/pci/hda/patch_cmedia.c
@@ -635,7 +635,8 @@ static int patch_cmi9880(struct hda_codec *codec)
                                                         cmi9880_models,
                                                         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 */
         }
 
diff --git a/sound/pci/hda/patch_conexant.c b/sound/pci/hda/patch_conexant.c
index ac868c59f9e3..9d899eda44d7 100644
--- a/sound/pci/hda/patch_conexant.c
+++ b/sound/pci/hda/patch_conexant.c
@@ -108,6 +108,8 @@ struct conexant_spec {
         struct hda_input_mux private_imux;
         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 
+        unsigned int dell_automute;
+        unsigned int port_d_mode;
 };
 
 static int conexant_playback_pcm_open(struct hda_pcm_stream *hinfo,
@@ -1908,6 +1910,480 @@ static int patch_cxt5051(struct hda_codec *codec)
         return 0;
 }
 
+/* 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},
+                {}
+        };
+        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},
+                {}
+        };
+        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),
+        {}
+};
+
+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),
+        },
+        {}
+};
+
+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),
+        {}
+};
+
+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},
+        { } /* 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},
+        { } /* end */
+};
+
+static struct hda_verb cxt5066_init_verbs_portd_lo[] = {
+        {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        { } /* 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),
+        {}
+};
+
+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,12 +2395,15 @@ static struct hda_codec_preset snd_hda_preset_conexant[] = {
           .patch = patch_cxt5047 },
         { .id = 0x14f15051, .name = "CX20561 (Hermosa)",
           .patch = patch_cxt5051 },
+        { .id = 0x14f15066, .name = "CX20582 (Pebble)",
+          .patch = patch_cxt5066 },
         {} /* terminator */
 };
 
 MODULE_ALIAS("snd-hda-codec-id:14f15045");
 MODULE_ALIAS("snd-hda-codec-id:14f15047");
 MODULE_ALIAS("snd-hda-codec-id:14f15051");
+MODULE_ALIAS("snd-hda-codec-id:14f15066");
 
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("Conexant HD-audio codec");
diff --git a/sound/pci/hda/patch_intelhdmi.c b/sound/pci/hda/patch_intelhdmi.c
index fcc77fec4487..01a18ed475ac 100644
--- a/sound/pci/hda/patch_intelhdmi.c
+++ b/sound/pci/hda/patch_intelhdmi.c
@@ -33,8 +33,8 @@
 #include "hda_codec.h"
 #include "hda_local.h"
 
-#define CVT_NID         0x02    /* audio converter */
-#define PIN_NID         0x03    /* HDMI output pin */
+static hda_nid_t cvt_nid;       /* audio converter */
+static hda_nid_t pin_nid;       /* HDMI output pin */
 
 #define INTEL_HDMI_EVENT_TAG            0x08
 
@@ -44,30 +44,6 @@ struct intel_hdmi_spec {
         struct hdmi_eld sink_eld;
 };
 
-static struct hda_verb pinout_enable_verb[] = {
-        {PIN_NID, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-        {} /* terminator */
-};
-
-static struct hda_verb unsolicited_response_verb[] = {
-        {PIN_NID, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN |
-                                                  INTEL_HDMI_EVENT_TAG},
-        {}
-};
-
-static struct hda_verb def_chan_map[] = {
-        {CVT_NID, AC_VERB_SET_HDMI_CHAN_SLOT, 0x00},
-        {CVT_NID, AC_VERB_SET_HDMI_CHAN_SLOT, 0x11},
-        {CVT_NID, AC_VERB_SET_HDMI_CHAN_SLOT, 0x22},
-        {CVT_NID, AC_VERB_SET_HDMI_CHAN_SLOT, 0x33},
-        {CVT_NID, AC_VERB_SET_HDMI_CHAN_SLOT, 0x44},
-        {CVT_NID, AC_VERB_SET_HDMI_CHAN_SLOT, 0x55},
-        {CVT_NID, AC_VERB_SET_HDMI_CHAN_SLOT, 0x66},
-        {CVT_NID, AC_VERB_SET_HDMI_CHAN_SLOT, 0x77},
-        {}
-};
-
-
 struct hdmi_audio_infoframe {
         u8 type; /* 0x84 */
         u8 ver;  /* 0x01 */
@@ -244,11 +220,12 @@ static void hdmi_write_dip_byte(struct hda_codec *codec, hda_nid_t nid,
 static void hdmi_enable_output(struct hda_codec *codec)
 {
         /* Unmute */
-        if (get_wcaps(codec, PIN_NID) & AC_WCAP_OUT_AMP)
-                snd_hda_codec_write(codec, PIN_NID, 0,
+        if (get_wcaps(codec, pin_nid) & AC_WCAP_OUT_AMP)
+                snd_hda_codec_write(codec, pin_nid, 0,
                                 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
         /* Enable pin out */
-        snd_hda_sequence_write(codec, pinout_enable_verb);
+        snd_hda_codec_write(codec, pin_nid, 0,
+                            AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
 }
 
 /*
@@ -256,8 +233,8 @@ static void hdmi_enable_output(struct hda_codec *codec)
  */
 static void hdmi_start_infoframe_trans(struct hda_codec *codec)
 {
-        hdmi_set_dip_index(codec, PIN_NID, 0x0, 0x0);
-        snd_hda_codec_write(codec, PIN_NID, 0, AC_VERB_SET_HDMI_DIP_XMIT,
+        hdmi_set_dip_index(codec, pin_nid, 0x0, 0x0);
+        snd_hda_codec_write(codec, pin_nid, 0, AC_VERB_SET_HDMI_DIP_XMIT,
                                                 AC_DIPXMIT_BEST);
 }
 
@@ -266,20 +243,20 @@ static void hdmi_start_infoframe_trans(struct hda_codec *codec)
  */
 static void hdmi_stop_infoframe_trans(struct hda_codec *codec)
 {
-        hdmi_set_dip_index(codec, PIN_NID, 0x0, 0x0);
-        snd_hda_codec_write(codec, PIN_NID, 0, AC_VERB_SET_HDMI_DIP_XMIT,
+        hdmi_set_dip_index(codec, pin_nid, 0x0, 0x0);
+        snd_hda_codec_write(codec, pin_nid, 0, AC_VERB_SET_HDMI_DIP_XMIT,
                                                 AC_DIPXMIT_DISABLE);
 }
 
 static int hdmi_get_channel_count(struct hda_codec *codec)
 {
-        return 1 + snd_hda_codec_read(codec, CVT_NID, 0,
+        return 1 + snd_hda_codec_read(codec, cvt_nid, 0,
                                         AC_VERB_GET_CVT_CHAN_COUNT, 0);
 }
 
 static void hdmi_set_channel_count(struct hda_codec *codec, int chs)
 {
-        snd_hda_codec_write(codec, CVT_NID, 0,
+        snd_hda_codec_write(codec, cvt_nid, 0,
                                         AC_VERB_SET_CVT_CHAN_COUNT, chs - 1);
 
         if (chs != hdmi_get_channel_count(codec))
@@ -294,7 +271,7 @@ static void hdmi_debug_channel_mapping(struct hda_codec *codec)
         int slot;
 
         for (i = 0; i < 8; i++) {
-                slot = snd_hda_codec_read(codec, CVT_NID, 0,
+                slot = snd_hda_codec_read(codec, cvt_nid, 0,
                                                 AC_VERB_GET_HDMI_CHAN_SLOT, i);
                 printk(KERN_DEBUG "HDMI: ASP channel %d => slot %d\n",
                                                 slot >> 4, slot & 0x7);
@@ -307,7 +284,7 @@ static void hdmi_parse_eld(struct hda_codec *codec)
         struct intel_hdmi_spec *spec = codec->spec;
         struct hdmi_eld *eld = &spec->sink_eld;
 
-        if (!snd_hdmi_get_eld(eld, codec, PIN_NID))
+        if (!snd_hdmi_get_eld(eld, codec, pin_nid))
                 snd_hdmi_show_eld(eld);
 }
 
@@ -322,11 +299,11 @@ static void hdmi_debug_dip_size(struct hda_codec *codec)
         int i;
         int size;
 
-        size = snd_hdmi_get_eld_size(codec, PIN_NID);
+        size = snd_hdmi_get_eld_size(codec, pin_nid);
         printk(KERN_DEBUG "HDMI: ELD buf size is %d\n", size);
 
         for (i = 0; i < 8; i++) {
-                size = snd_hda_codec_read(codec, PIN_NID, 0,
+                size = snd_hda_codec_read(codec, pin_nid, 0,
                                                 AC_VERB_GET_HDMI_DIP_SIZE, i);
                 printk(KERN_DEBUG "HDMI: DIP GP[%d] buf size is %d\n", i, size);
         }
@@ -340,15 +317,15 @@ static void hdmi_clear_dip_buffers(struct hda_codec *codec)
         int size;
         int pi, bi;
         for (i = 0; i < 8; i++) {
-                size = snd_hda_codec_read(codec, PIN_NID, 0,
+                size = snd_hda_codec_read(codec, pin_nid, 0,
                                                 AC_VERB_GET_HDMI_DIP_SIZE, i);
                 if (size == 0)
                         continue;
 
-                hdmi_set_dip_index(codec, PIN_NID, i, 0x0);
+                hdmi_set_dip_index(codec, pin_nid, i, 0x0);
                 for (j = 1; j < 1000; j++) {
-                        hdmi_write_dip_byte(codec, PIN_NID, 0x0);
-                        hdmi_get_dip_index(codec, PIN_NID, &pi, &bi);
+                        hdmi_write_dip_byte(codec, pin_nid, 0x0);
+                        hdmi_get_dip_index(codec, pin_nid, &pi, &bi);
                         if (pi != i)
                                 snd_printd(KERN_INFO "dip index %d: %d != %d\n",
                                                 bi, pi, i);
@@ -376,9 +353,9 @@ static void hdmi_fill_audio_infoframe(struct hda_codec *codec,
                 sum += params[i];
         ai->checksum = - sum;
 
-        hdmi_set_dip_index(codec, PIN_NID, 0x0, 0x0);
+        hdmi_set_dip_index(codec, pin_nid, 0x0, 0x0);
         for (i = 0; i < sizeof(ai); i++)
-                hdmi_write_dip_byte(codec, PIN_NID, params[i]);
+                hdmi_write_dip_byte(codec, pin_nid, params[i]);
 }
 
 /*
@@ -465,6 +442,8 @@ static int hdmi_setup_channel_allocation(struct hda_codec *codec,
 static void hdmi_setup_channel_mapping(struct hda_codec *codec,
                                         struct hdmi_audio_infoframe *ai)
 {
+        int i;
+
         if (!ai->CA)
                 return;
 
@@ -473,7 +452,11 @@ static void hdmi_setup_channel_mapping(struct hda_codec *codec,
          * ALSA sequence is front/surr/clfe/side?
          */
 
-        snd_hda_sequence_write(codec, def_chan_map);
+        for (i = 0; i < 8; i++)
+                snd_hda_codec_write(codec, cvt_nid, 0,
+                                    AC_VERB_SET_HDMI_CHAN_SLOT,
+                                    (i << 4) | i);
+
         hdmi_debug_channel_mapping(codec);
 }
 
@@ -597,7 +580,6 @@ static struct hda_pcm_stream intel_hdmi_pcm_playback = {
         .substreams = 1,
         .channels_min = 2,
         .channels_max = 8,
-        .nid = CVT_NID, /* NID to query formats and rates and setup streams */
         .ops = {
                 .open    = intel_hdmi_playback_pcm_open,
                 .close   = intel_hdmi_playback_pcm_close,
@@ -613,6 +595,9 @@ static int intel_hdmi_build_pcms(struct hda_codec *codec)
         codec->num_pcms = 1;
         codec->pcm_info = info;
 
+        /* NID to query formats and rates and setup streams */
+        intel_hdmi_pcm_playback.nid = cvt_nid;
+
         info->name = "INTEL HDMI";
         info->pcm_type = HDA_PCM_TYPE_HDMI;
         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = intel_hdmi_pcm_playback;
@@ -636,8 +621,9 @@ static int intel_hdmi_init(struct hda_codec *codec)
 {
         hdmi_enable_output(codec);
 
-        snd_hda_sequence_write(codec, unsolicited_response_verb);
-
+        snd_hda_codec_write(codec, pin_nid, 0,
+                            AC_VERB_SET_UNSOLICITED_ENABLE,
+                            AC_USRSP_EN | INTEL_HDMI_EVENT_TAG);
         return 0;
 }
 
@@ -657,7 +643,7 @@ static struct hda_codec_ops intel_hdmi_patch_ops = {
         .unsol_event            = intel_hdmi_unsol_event,
 };
 
-static int patch_intel_hdmi(struct hda_codec *codec)
+static int do_patch_intel_hdmi(struct hda_codec *codec)
 {
         struct intel_hdmi_spec *spec;
 
@@ -667,7 +653,7 @@ static int patch_intel_hdmi(struct hda_codec *codec)
 
         spec->multiout.num_dacs = 0;      /* no analog */
         spec->multiout.max_channels = 8;
-        spec->multiout.dig_out_nid = CVT_NID;
+        spec->multiout.dig_out_nid = cvt_nid;
 
         codec->spec = spec;
         codec->patch_ops = intel_hdmi_patch_ops;
@@ -679,12 +665,27 @@ static int patch_intel_hdmi(struct hda_codec *codec)
         return 0;
 }
 
+static int patch_intel_hdmi(struct hda_codec *codec)
+{
+        cvt_nid = 0x02;
+        pin_nid = 0x03;
+        return do_patch_intel_hdmi(codec);
+}
+
+static int patch_intel_hdmi_ibexpeak(struct hda_codec *codec)
+{
+        cvt_nid = 0x02;
+        pin_nid = 0x04;
+        return do_patch_intel_hdmi(codec);
+}
+
 static struct hda_codec_preset snd_hda_preset_intelhdmi[] = {
         { .id = 0x808629fb, .name = "G45 DEVCL",  .patch = patch_intel_hdmi },
         { .id = 0x80862801, .name = "G45 DEVBLC", .patch = patch_intel_hdmi },
         { .id = 0x80862802, .name = "G45 DEVCTG", .patch = patch_intel_hdmi },
         { .id = 0x80862803, .name = "G45 DEVELK", .patch = patch_intel_hdmi },
         { .id = 0x80862804, .name = "G45 DEVIBX", .patch = patch_intel_hdmi },
+        { .id = 0x80860054, .name = "Q57 DEVIBX", .patch = patch_intel_hdmi_ibexpeak },
         { .id = 0x10951392, .name = "SiI1392 HDMI",     .patch = patch_intel_hdmi },
         {} /* terminator */
 };
@@ -694,6 +695,7 @@ MODULE_ALIAS("snd-hda-codec-id:80862801");
 MODULE_ALIAS("snd-hda-codec-id:80862802");
 MODULE_ALIAS("snd-hda-codec-id:80862803");
 MODULE_ALIAS("snd-hda-codec-id:80862804");
+MODULE_ALIAS("snd-hda-codec-id:80860054");
 MODULE_ALIAS("snd-hda-codec-id:10951392");
 
 MODULE_LICENSE("GPL");
diff --git a/sound/pci/hda/patch_nvhdmi.c b/sound/pci/hda/patch_nvhdmi.c
index f5792e2eea82..c8435c9a97f9 100644
--- a/sound/pci/hda/patch_nvhdmi.c
+++ b/sound/pci/hda/patch_nvhdmi.c
@@ -377,6 +377,7 @@ static int patch_nvhdmi_2ch(struct hda_codec *codec)
  */
 static struct hda_codec_preset snd_hda_preset_nvhdmi[] = {
         { .id = 0x10de0002, .name = "MCP78 HDMI", .patch = patch_nvhdmi_8ch },
+        { .id = 0x10de0003, .name = "MCP78 HDMI", .patch = patch_nvhdmi_8ch },
         { .id = 0x10de0006, .name = "MCP78 HDMI", .patch = patch_nvhdmi_8ch },
         { .id = 0x10de0007, .name = "MCP7A HDMI", .patch = patch_nvhdmi_8ch },
         { .id = 0x10de0067, .name = "MCP67 HDMI", .patch = patch_nvhdmi_2ch },
@@ -385,6 +386,7 @@ static struct hda_codec_preset snd_hda_preset_nvhdmi[] = {
 };
 
 MODULE_ALIAS("snd-hda-codec-id:10de0002");
+MODULE_ALIAS("snd-hda-codec-id:10de0003");
 MODULE_ALIAS("snd-hda-codec-id:10de0006");
 MODULE_ALIAS("snd-hda-codec-id:10de0007");
 MODULE_ALIAS("snd-hda-codec-id:10de0067");
diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c
index 334533197425..129605819560 100644
--- a/sound/pci/hda/patch_realtek.c
+++ b/sound/pci/hda/patch_realtek.c
@@ -208,12 +208,6 @@ enum {
         ALC885_MBP3,
         ALC885_MB5,
         ALC885_IMAC24,
-        ALC882_AUTO,
-        ALC882_MODEL_LAST,
-};
-
-/* ALC883 models */
-enum {
         ALC883_3ST_2ch_DIG,
         ALC883_3ST_6ch_DIG,
         ALC883_3ST_6ch,
@@ -226,6 +220,7 @@ enum {
         ALC888_ACER_ASPIRE_4930G,
         ALC888_ACER_ASPIRE_6530G,
         ALC888_ACER_ASPIRE_8930G,
+        ALC888_ACER_ASPIRE_7730G,
         ALC883_MEDION,
         ALC883_MEDION_MD2,
         ALC883_LAPTOP_EAPD,
@@ -237,17 +232,20 @@ enum {
         ALC888_3ST_HP,
         ALC888_6ST_DELL,
         ALC883_MITAC,
+        ALC883_CLEVO_M540R,
         ALC883_CLEVO_M720,
         ALC883_FUJITSU_PI2515,
         ALC888_FUJITSU_XA3530,
         ALC883_3ST_6ch_INTEL,
+        ALC889A_INTEL,
+        ALC889_INTEL,
         ALC888_ASUS_M90V,
         ALC888_ASUS_EEE1601,
         ALC889A_MB31,
         ALC1200_ASUS_P5Q,
         ALC883_SONY_VAIO_TT,
-        ALC883_AUTO,
-        ALC883_MODEL_LAST,
+        ALC882_AUTO,
+        ALC882_MODEL_LAST,
 };
 
 /* for GPIO Poll */
@@ -262,6 +260,14 @@ enum {
         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 {
         /* codec parameterization */
         struct snd_kcontrol_new *mixers[5];     /* mixer arrays */
@@ -275,13 +281,13 @@ struct alc_spec {
                                                  */
         unsigned int num_init_verbs;
 
-        char stream_name_analog[16];    /* 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;
         struct hda_pcm_stream *stream_analog_alt_playback;
         struct hda_pcm_stream *stream_analog_alt_capture;
 
-        char stream_name_digital[16];   /* 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;
 
@@ -304,6 +310,8 @@ struct alc_spec {
         unsigned int num_mux_defs;
         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 */
         const struct hda_channel_mode *channel_mode;
@@ -320,6 +328,8 @@ struct alc_spec {
         struct snd_array kctls;
         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 */
         void (*init_hook)(struct hda_codec *codec);
@@ -329,6 +339,7 @@ struct alc_spec {
         unsigned int sense_updated: 1;
         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 */
@@ -370,6 +381,7 @@ struct alc_config_preset {
         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
         struct hda_amp_list *loopbacks;
@@ -417,7 +429,7 @@ static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
         mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
         imux = &spec->input_mux[mux_idx];
 
-        type = (get_wcaps(codec, nid) & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
+        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];
@@ -559,7 +571,7 @@ static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
 
         /* 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);
         return 0;
@@ -842,9 +854,10 @@ static void print_realtek_coef(struct snd_info_buffer *buffer,
 /*
  * 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;
 
         for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
@@ -886,6 +899,9 @@ static void setup_preset(struct alc_spec *spec,
 #ifdef CONFIG_SND_HDA_POWER_SAVE
         spec->loopback.amplist = preset->loopbacks;
 #endif
+
+        if (preset->setup)
+                preset->setup(codec);
 }
 
 /* Enable GPIO mask and set output */
@@ -945,12 +961,13 @@ static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
 static void alc_automute_pin(struct hda_codec *codec)
 {
         struct alc_spec *spec = codec->spec;
-        unsigned int present;
+        unsigned int present, pincap;
         unsigned int nid = spec->autocfg.hp_pins[0];
         int i;
 
-        /* need to execute and sync at first */
-        snd_hda_codec_read(codec, nid, 0, AC_VERB_SET_PIN_SENSE, 0);
+        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 & AC_PINSENSE_PRESENCE) != 0;
@@ -964,30 +981,64 @@ static void alc_automute_pin(struct hda_codec *codec)
         }
 }
 
-#if 0 /* it's broken in some cases -- temporarily disabled */
+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);
+        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 */
 }
-#else
-#define alc_mic_automute(codec) do {} while(0) /* NOP */
-#endif /* disabled */
 
 /* unsolicited event for HP jack sensing */
 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
@@ -1030,6 +1081,16 @@ static void alc888_coef_init(struct hda_codec *codec)
                                     AC_VERB_SET_PROC_COEF, 0x3030);
 }
 
+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;
@@ -1087,15 +1148,7 @@ static void alc_auto_init_amp(struct hda_codec *codec, int type)
                 case 0x10ec0885:
                 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);
@@ -1141,6 +1194,55 @@ static void alc_init_auto_hp(struct hda_codec *codec)
         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
  */
@@ -1242,6 +1344,7 @@ do_sku:
         }
 
         alc_init_auto_hp(codec);
+        alc_init_auto_mic(codec);
         return 1;
 }
 
@@ -1254,6 +1357,7 @@ static void alc_ssid_check(struct hda_codec *codec,
                            "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);
         }
 }
 
@@ -1392,7 +1496,7 @@ static struct hda_verb alc888_fujitsu_xa3530_verbs[] = {
 static void alc_automute_amp(struct hda_codec *codec)
 {
         struct alc_spec *spec = codec->spec;
-        unsigned int val, mute;
+        unsigned int val, mute, pincap;
         hda_nid_t nid;
         int i;
 
@@ -1401,6 +1505,10 @@ static void alc_automute_amp(struct hda_codec *codec)
                 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) {
@@ -1431,7 +1539,25 @@ static void alc_automute_amp_unsol_event(struct hda_codec *codec,
                 alc_automute_amp(codec);
 }
 
-static void alc888_fujitsu_xa3530_init_hook(struct hda_codec *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;
 
@@ -1439,7 +1565,6 @@ static void alc888_fujitsu_xa3530_init_hook(struct hda_codec *codec)
         spec->autocfg.hp_pins[1] = 0x1b; /* hp */
         spec->autocfg.speaker_pins[0] = 0x14; /* speaker */
         spec->autocfg.speaker_pins[1] = 0x15; /* bass */
-        alc_automute_amp(codec);
 }
 
 /*
@@ -1471,6 +1596,10 @@ static struct hda_verb alc888_acer_aspire_4930g_verbs[] = {
 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 */
@@ -1560,18 +1689,22 @@ static struct hda_input_mux alc888_2_capture_sources[2] = {
 static struct hda_input_mux alc888_acer_aspire_6530_sources[2] = {
         /* Interal mic only available on one ADC */
         {
-                .num_items = 3,
+                .num_items = 5,
                 .items = {
                         { "Ext Mic", 0x0 },
+                        { "Line In", 0x2 },
                         { "CD", 0x4 },
+                        { "Input Mix", 0xa },
                         { "Int Mic", 0xb },
                 },
         },
         {
-                .num_items = 2,
+                .num_items = 4,
                 .items = {
                         { "Ext Mic", 0x0 },
+                        { "Line In", 0x2 },
                         { "CD", 0x4 },
+                        { "Input Mix", 0xa },
                 },
         }
 };
@@ -1630,16 +1763,25 @@ static struct snd_kcontrol_new alc888_base_mixer[] = {
         { } /* end */
 };
 
-static void alc888_acer_aspire_4930g_init_hook(struct hda_codec *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;
-        alc_automute_amp(codec);
 }
 
-static void alc889_acer_aspire_8930g_init_hook(struct hda_codec *codec)
+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;
 
@@ -1647,7 +1789,6 @@ static void alc889_acer_aspire_8930g_init_hook(struct hda_codec *codec)
         spec->autocfg.speaker_pins[0] = 0x14;
         spec->autocfg.speaker_pins[1] = 0x16;
         spec->autocfg.speaker_pins[2] = 0x1b;
-        alc_automute_amp(codec);
 }
 
 /*
@@ -2627,13 +2768,17 @@ static void alc880_uniwill_mic_automute(struct hda_codec *codec)
         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
 }
 
-static void alc880_uniwill_init_hook(struct hda_codec *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);
 }
@@ -2654,13 +2799,12 @@ static void alc880_uniwill_unsol_event(struct hda_codec *codec,
         }
 }
 
-static void alc880_uniwill_p53_init_hook(struct hda_codec *codec)
+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;
-        alc_automute_amp(codec);
 }
 
 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
@@ -2923,13 +3067,12 @@ static struct hda_verb alc880_lg_init_verbs[] = {
 };
 
 /* toggle speaker-output according to the hp-jack state */
-static void alc880_lg_init_hook(struct hda_codec *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;
-        alc_automute_amp(codec);
 }
 
 /*
@@ -3008,13 +3151,12 @@ static struct hda_verb alc880_lg_lw_init_verbs[] = {
 };
 
 /* toggle speaker-output according to the hp-jack state */
-static void alc880_lg_lw_init_hook(struct hda_codec *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;
-        alc_automute_amp(codec);
 }
 
 static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
@@ -3080,13 +3222,12 @@ static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
                 alc880_medion_rim_automute(codec);
 }
 
-static void alc880_medion_rim_init_hook(struct hda_codec *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;
-        alc880_medion_rim_automute(codec);
 }
 
 #ifdef CONFIG_SND_HDA_POWER_SAVE
@@ -3953,7 +4094,8 @@ static struct alc_config_preset alc880_presets[] = {
                 .channel_mode = alc880_2_jack_modes,
                 .input_mux = &alc880_f1734_capture_source,
                 .unsol_event = alc880_uniwill_p53_unsol_event,
-                .init_hook = alc880_uniwill_p53_init_hook,
+                .setup = alc880_uniwill_p53_setup,
+                .init_hook = alc_automute_amp,
         },
         [ALC880_ASUS] = {
                 .mixers = { alc880_asus_mixer },
@@ -4030,6 +4172,7 @@ static struct alc_config_preset alc880_presets[] = {
                 .need_dac_fix = 1,
                 .input_mux = &alc880_capture_source,
                 .unsol_event = alc880_uniwill_unsol_event,
+                .setup = alc880_uniwill_setup,
                 .init_hook = alc880_uniwill_init_hook,
         },
         [ALC880_UNIWILL_P53] = {
@@ -4042,7 +4185,8 @@ static struct alc_config_preset alc880_presets[] = {
                 .channel_mode = alc880_threestack_modes,
                 .input_mux = &alc880_capture_source,
                 .unsol_event = alc880_uniwill_p53_unsol_event,
-                .init_hook = alc880_uniwill_p53_init_hook,
+                .setup = alc880_uniwill_p53_setup,
+                .init_hook = alc_automute_amp,
         },
         [ALC880_FUJITSU] = {
                 .mixers = { alc880_fujitsu_mixer },
@@ -4056,7 +4200,8 @@ static struct alc_config_preset alc880_presets[] = {
                 .channel_mode = alc880_2_jack_modes,
                 .input_mux = &alc880_capture_source,
                 .unsol_event = alc880_uniwill_p53_unsol_event,
-                .init_hook = alc880_uniwill_p53_init_hook,
+                .setup = alc880_uniwill_p53_setup,
+                .init_hook = alc_automute_amp,
         },
         [ALC880_CLEVO] = {
                 .mixers = { alc880_three_stack_mixer },
@@ -4082,7 +4227,8 @@ static struct alc_config_preset alc880_presets[] = {
                 .need_dac_fix = 1,
                 .input_mux = &alc880_lg_capture_source,
                 .unsol_event = alc_automute_amp_unsol_event,
-                .init_hook = alc880_lg_init_hook,
+                .setup = alc880_lg_setup,
+                .init_hook = alc_automute_amp,
 #ifdef CONFIG_SND_HDA_POWER_SAVE
                 .loopbacks = alc880_lg_loopbacks,
 #endif
@@ -4098,7 +4244,8 @@ static struct alc_config_preset alc880_presets[] = {
                 .channel_mode = alc880_lg_lw_modes,
                 .input_mux = &alc880_lg_lw_capture_source,
                 .unsol_event = alc_automute_amp_unsol_event,
-                .init_hook = alc880_lg_lw_init_hook,
+                .setup = alc880_lg_lw_setup,
+                .init_hook = alc_automute_amp,
         },
         [ALC880_MEDION_RIM] = {
                 .mixers = { alc880_medion_rim_mixer },
@@ -4112,7 +4259,8 @@ static struct alc_config_preset alc880_presets[] = {
                 .channel_mode = alc880_2_jack_modes,
                 .input_mux = &alc880_medion_rim_capture_source,
                 .unsol_event = alc880_medion_rim_unsol_event,
-                .init_hook = alc880_medion_rim_init_hook,
+                .setup = alc880_medion_rim_setup,
+                .init_hook = alc880_medion_rim_automute,
         },
 #ifdef CONFIG_SND_DEBUG
         [ALC880_TEST] = {
@@ -4165,8 +4313,6 @@ static int add_control(struct alc_spec *spec, int type, const char *name,
 #define alc880_fixed_pin_idx(nid)       ((nid) - 0x14)
 #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)
 #define alc880_idx_to_mixer(nid)        ((nid) + 0x0c)
@@ -4254,13 +4400,19 @@ static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
                         if (err < 0)
                                 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,
                                                               HDA_OUTPUT));
                         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,
                                                               HDA_INPUT));
@@ -4334,31 +4486,61 @@ static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
         return 0;
 }
 
+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);
+}
+
 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
                                unsigned int pin_type)
 {
@@ -4424,7 +4606,7 @@ static void alc880_auto_init_analog_input(struct hda_codec *codec)
 
         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 &&
                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
@@ -4467,7 +4649,7 @@ static int alc880_parse_auto_config(struct hda_codec *codec)
                                            "Headphone");
         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;
 
@@ -4517,8 +4699,42 @@ static void alc880_auto_init(struct hda_codec *codec)
                 alc_inithook(codec);
 }
 
-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,
                   alc_capture_mixer_nosrc2,
@@ -4529,7 +4745,10 @@ static void set_capture_mixer(struct alc_spec *spec)
         };
         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
                         mux = 0;
@@ -4560,8 +4779,8 @@ static int patch_alc880(struct hda_codec *codec)
                                                   alc880_models,
                                                   alc880_cfg_tbl);
         if (board_config < 0) {
-                printk(KERN_INFO "hda_codec: Unknown model for %s, "
-                       "trying auto-probe from BIOS...\n", codec->chip_name);
+                printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
+                       codec->chip_name);
                 board_config = ALC880_AUTO;
         }
 
@@ -4586,7 +4805,7 @@ static int patch_alc880(struct hda_codec *codec)
         }
 
         if (board_config != ALC880_AUTO)
-                setup_preset(spec, &alc880_presets[board_config]);
+                setup_preset(codec, &alc880_presets[board_config]);
 
         spec->stream_analog_playback = &alc880_pcm_analog_playback;
         spec->stream_analog_capture = &alc880_pcm_analog_capture;
@@ -4599,7 +4818,7 @@ static int patch_alc880(struct hda_codec *codec)
                 /* check whether NID 0x07 is valid */
                 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;
                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
@@ -4608,7 +4827,7 @@ static int patch_alc880(struct hda_codec *codec)
                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
                 }
         }
-        set_capture_mixer(spec);
+        set_capture_mixer(codec);
         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
 
         spec->vmaster_nid = 0x0c;
@@ -5800,7 +6019,14 @@ static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
 
         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;
         }
@@ -5823,39 +6049,10 @@ static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
 }
 
 /* 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);
 }
 
 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
@@ -5969,7 +6166,7 @@ static int alc260_parse_auto_config(struct hda_codec *codec)
                 return err;
         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;
 
@@ -6204,8 +6401,7 @@ static int patch_alc260(struct hda_codec *codec)
                                                   alc260_models,
                                                   alc260_cfg_tbl);
         if (board_config < 0) {
-                snd_printd(KERN_INFO "hda_codec: Unknown model for %s, "
-                           "trying auto-probe from BIOS...\n",
+                snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
                            codec->chip_name);
                 board_config = ALC260_AUTO;
         }
@@ -6231,7 +6427,7 @@ static int patch_alc260(struct hda_codec *codec)
         }
 
         if (board_config != ALC260_AUTO)
-                setup_preset(spec, &alc260_presets[board_config]);
+                setup_preset(codec, &alc260_presets[board_config]);
 
         spec->stream_analog_playback = &alc260_pcm_analog_playback;
         spec->stream_analog_capture = &alc260_pcm_analog_capture;
@@ -6242,7 +6438,7 @@ static int patch_alc260(struct hda_codec *codec)
         if (!spec->adc_nids && spec->input_mux) {
                 /* 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) {
                         spec->adc_nids = alc260_adc_nids_alt;
@@ -6252,7 +6448,7 @@ static int patch_alc260(struct hda_codec *codec)
                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
                 }
         }
-        set_capture_mixer(spec);
+        set_capture_mixer(codec);
         set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
 
         spec->vmaster_nid = 0x08;
@@ -6271,7 +6467,7 @@ static int patch_alc260(struct hda_codec *codec)
 
 
 /*
- * ALC882 support
+ * ALC882/883/885/888/889 support
  *
  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
  * configuration.  Each pin widget can choose any input DACs and a mixer.
@@ -6283,22 +6479,35 @@ static int patch_alc260(struct hda_codec *codec)
  */
 #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] = {
         { 8, NULL }
 };
 
+/* DACs */
 static hda_nid_t alc882_dac_nids[4] = {
         /* front, rear, clfe, rear_surr */
         0x02, 0x03, 0x04, 0x05
 };
+#define alc883_dac_nids         alc882_dac_nids
 
-/* identical with ALC880 */
+/* 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 */
 /* FIXME: should be a matrix-type input source selection */
@@ -6313,6 +6522,17 @@ static struct hda_input_mux alc882_capture_source = {
         },
 };
 
+#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 = {
@@ -6322,6 +6542,77 @@ static struct hda_input_mux mb5_capture_source = {
         },
 };
 
+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
  */
@@ -6334,6 +6625,18 @@ static struct hda_verb alc882_3ST_ch2_init[] = {
 };
 
 /*
+ * 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 },
+        { } /* end */
+};
+
+/*
  * 6ch mode
  */
 static struct hda_verb alc882_3ST_ch6_init[] = {
@@ -6346,11 +6649,60 @@ static struct hda_verb alc882_3ST_ch6_init[] = {
         { } /* end */
 };
 
-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
+
+/*
+ * 2ch mode
+ */
+static struct hda_verb alc883_3ST_ch2_clevo_init[] = {
+        { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
+        { 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 },
+        { } /* end */
+};
+
+/*
+ * 4ch mode
+ */
+static struct hda_verb alc883_3ST_ch4_clevo_init[] = {
+        { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
+        { 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 },
+        { } /* end */
+};
+
+/*
+ * 6ch mode
+ */
+static struct hda_verb alc883_3ST_ch6_clevo_init[] = {
+        { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
+        { 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 },
+        { } /* end */
+};
+
+static struct hda_channel_mode alc883_3ST_6ch_clevo_modes[3] = {
+        { 2, alc883_3ST_ch2_clevo_init },
+        { 4, alc883_3ST_ch4_clevo_init },
+        { 6, alc883_3ST_ch6_clevo_init },
+};
+
+
 /*
  * 6ch mode
  */
@@ -6393,9 +6745,9 @@ static struct hda_verb alc885_mbp_ch2_init[] = {
 };
 
 /*
- * 6ch mode
+ * 4ch mode
  */
-static struct hda_verb alc885_mbp_ch6_init[] = {
+static struct hda_verb alc885_mbp_ch4_init[] = {
         { 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 },
@@ -6404,9 +6756,9 @@ static struct hda_verb alc885_mbp_ch6_init[] = {
         { } /* end */
 };
 
-static struct hda_channel_mode alc885_mbp_6ch_modes[2] = {
+static struct hda_channel_mode alc885_mbp_4ch_modes[2] = {
         { 2, alc885_mbp_ch2_init },
-        { 6, alc885_mbp_ch6_init },
+        { 4, alc885_mbp_ch4_init },
 };
 
 /*
@@ -6438,6 +6790,189 @@ static struct hda_channel_mode alc885_mb5_6ch_modes[2] = {
         { 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 },
+        { } /* 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 },
+        { } /* 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 },
+        { } /* 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 },
+        { } /* 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 },
+        { } /* 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 },
+        { } /* 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 },
+        { } /* 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 },
+        { } /* 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 },
+        { } /* 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 },
+        { } /* 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 },
+        { } /* 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 },
+        { } /* end */
+};
+
+static struct hda_channel_mode alc883_sixstack_modes[2] = {
+        { 6, alc883_sixstack_ch6_init },
+        { 8, alc883_sixstack_ch8_init },
+};
+
+
 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
  */
@@ -6467,10 +7002,11 @@ static struct snd_kcontrol_new alc882_base_mixer[] = {
 };
 
 static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
-        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
-        HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
-        HDA_CODEC_MUTE  ("Speaker Playback Switch", 0x14, 0x00, HDA_OUTPUT),
-        HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
+        HDA_BIND_MUTE   ("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT),
+        HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
+        HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0e, 0x02, HDA_INPUT),
+        HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, 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, 0x00, HDA_INPUT),
@@ -6573,7 +7109,7 @@ static struct snd_kcontrol_new alc882_chmode_mixer[] = {
         { } /* end */
 };
 
-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},
         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
@@ -6591,6 +7127,13 @@ static struct hda_verb alc882_init_verbs[] = {
         {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},
@@ -6625,11 +7168,6 @@ static struct hda_verb alc882_init_verbs[] = {
 
         /* FIXME: use matrix-type input source selection */
         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
-        /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
-        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
-        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
-        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
         /* Input mixer2 */
         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
@@ -6640,9 +7178,6 @@ static struct hda_verb alc882_init_verbs[] = {
         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
-        /* ADC1: mute amp left and right */
-        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-        {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
         /* ADC2: mute amp left and right */
         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
@@ -6653,6 +7188,18 @@ static struct hda_verb alc882_init_verbs[] = {
         { }
 };
 
+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},
+        { }
+};
+
 static struct hda_verb alc882_eapd_verbs[] = {
         /* change to EAPD mode */
         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
@@ -6660,6 +7207,110 @@ static struct hda_verb alc882_eapd_verbs[] = {
         { }
 };
 
+static struct hda_verb alc889_eapd_verbs[] = {
+        {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
+        {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
+        { }
+};
+
+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},
+        {}
+};
+
+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)},
+
+        { }
+};
+
+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)},
+        { }
+};
+
+
+/* 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},
+        { }
+};
+
+
+#define alc883_init_verbs       alc882_base_init_verbs
+
 /* Mac Pro test */
 static struct snd_kcontrol_new alc882_macpro_mixer[] = {
         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
@@ -6784,14 +7435,18 @@ static struct hda_verb alc885_mbp3_init_verbs[] = {
         {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)},
+        /* HP 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)},
         /* 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},
-        /* HP Pin: output 0 (0x0d) */
+        /* HP Pin: output 0 (0x0e) */
         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
-        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-        {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x15, AC_VERB_SET_CONNECT_SEL, 0x02},
         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
         /* Mic (rear) pin: input vref at 80% */
         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
@@ -6863,23 +7518,21 @@ static struct hda_verb alc885_imac24_init_verbs[] = {
 };
 
 /* Toggle speaker-output according to the hp-jack state */
-static void alc885_imac24_automute_init_hook(struct hda_codec *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;
-        alc_automute_amp(codec);
 }
 
-static void alc885_mbp3_init_hook(struct hda_codec *codec)
+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;
-        alc_automute_amp(codec);
 }
 
 
@@ -6895,9 +7548,6 @@ static struct hda_verb alc882_targa_verbs[] = {
         {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},
         { } /* end */
 };
 
@@ -6910,13 +7560,12 @@ static void alc882_targa_automute(struct hda_codec *codec)
                                   spec->jack_present ? 1 : 3);
 }
 
-static void alc882_targa_init_hook(struct hda_codec *codec)
+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;
-        alc882_targa_automute(codec);
 }
 
 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
@@ -7004,18 +7653,16 @@ static void alc885_macpro_init_hook(struct hda_codec *codec)
 static void alc885_imac24_init_hook(struct hda_codec *codec)
 {
         alc885_macpro_init_hook(codec);
-        alc885_imac24_automute_init_hook(codec);
+        alc_automute_amp(codec);
 }
 
 /*
  * 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)},
         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
@@ -7056,11 +7703,6 @@ static struct hda_verb alc882_auto_init_verbs[] = {
 
         /* FIXME: use matrix-type input source selection */
         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
-        /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
-        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
-        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
-        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
-        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
         /* Input mixer2 */
         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
@@ -7075,819 +7717,6 @@ static struct hda_verb alc882_auto_init_verbs[] = {
         { }
 };
 
-#ifdef CONFIG_SND_HDA_POWER_SAVE
-#define alc882_loopbacks        alc880_loopbacks
-#endif
-
-/* 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
-
-/*
- * configuration and preset
- */
-static const char *alc882_models[ALC882_MODEL_LAST] = {
-        [ALC882_3ST_DIG]        = "3stack-dig",
-        [ALC882_6ST_DIG]        = "6stack-dig",
-        [ALC882_ARIMA]          = "arima",
-        [ALC882_W2JC]           = "w2jc",
-        [ALC882_TARGA]          = "targa",
-        [ALC882_ASUS_A7J]       = "asus-a7j",
-        [ALC882_ASUS_A7M]       = "asus-a7m",
-        [ALC885_MACPRO]         = "macpro",
-        [ALC885_MB5]            = "mb5",
-        [ALC885_MBP3]           = "mbp3",
-        [ALC885_IMAC24]         = "imac24",
-        [ALC882_AUTO]           = "auto",
-};
-
-static struct snd_pci_quirk alc882_cfg_tbl[] = {
-        SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
-        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, 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(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
-        SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
-        SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
-        SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
-        SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA),
-        {}
-};
-
-static struct alc_config_preset alc882_presets[] = {
-        [ALC882_3ST_DIG] = {
-                .mixers = { alc882_base_mixer },
-                .init_verbs = { alc882_init_verbs },
-                .num_dacs = ARRAY_SIZE(alc882_dac_nids),
-                .dac_nids = alc882_dac_nids,
-                .dig_out_nid = ALC882_DIGOUT_NID,
-                .dig_in_nid = ALC882_DIGIN_NID,
-                .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
-                .channel_mode = alc882_ch_modes,
-                .need_dac_fix = 1,
-                .input_mux = &alc882_capture_source,
-        },
-        [ALC882_6ST_DIG] = {
-                .mixers = { alc882_base_mixer, alc882_chmode_mixer },
-                .init_verbs = { alc882_init_verbs },
-                .num_dacs = ARRAY_SIZE(alc882_dac_nids),
-                .dac_nids = alc882_dac_nids,
-                .dig_out_nid = ALC882_DIGOUT_NID,
-                .dig_in_nid = ALC882_DIGIN_NID,
-                .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
-                .channel_mode = alc882_sixstack_modes,
-                .input_mux = &alc882_capture_source,
-        },
-        [ALC882_ARIMA] = {
-                .mixers = { alc882_base_mixer, alc882_chmode_mixer },
-                .init_verbs = { alc882_init_verbs, alc882_eapd_verbs },
-                .num_dacs = ARRAY_SIZE(alc882_dac_nids),
-                .dac_nids = alc882_dac_nids,
-                .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
-                .channel_mode = alc882_sixstack_modes,
-                .input_mux = &alc882_capture_source,
-        },
-        [ALC882_W2JC] = {
-                .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
-                .init_verbs = { alc882_init_verbs, alc882_eapd_verbs,
-                                alc880_gpio1_init_verbs },
-                .num_dacs = ARRAY_SIZE(alc882_dac_nids),
-                .dac_nids = alc882_dac_nids,
-                .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
-                .channel_mode = alc880_threestack_modes,
-                .need_dac_fix = 1,
-                .input_mux = &alc882_capture_source,
-                .dig_out_nid = ALC882_DIGOUT_NID,
-        },
-        [ALC885_MBP3] = {
-                .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
-                .init_verbs = { alc885_mbp3_init_verbs,
-                                alc880_gpio1_init_verbs },
-                .num_dacs = ARRAY_SIZE(alc882_dac_nids),
-                .dac_nids = alc882_dac_nids,
-                .channel_mode = alc885_mbp_6ch_modes,
-                .num_channel_mode = ARRAY_SIZE(alc885_mbp_6ch_modes),
-                .input_mux = &alc882_capture_source,
-                .dig_out_nid = ALC882_DIGOUT_NID,
-                .dig_in_nid = ALC882_DIGIN_NID,
-                .unsol_event = alc_automute_amp_unsol_event,
-                .init_hook = alc885_mbp3_init_hook,
-        },
-        [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] = {
-                .mixers = { alc882_macpro_mixer },
-                .init_verbs = { alc882_macpro_init_verbs },
-                .num_dacs = ARRAY_SIZE(alc882_dac_nids),
-                .dac_nids = alc882_dac_nids,
-                .dig_out_nid = ALC882_DIGOUT_NID,
-                .dig_in_nid = ALC882_DIGIN_NID,
-                .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
-                .channel_mode = alc882_ch_modes,
-                .input_mux = &alc882_capture_source,
-                .init_hook = alc885_macpro_init_hook,
-        },
-        [ALC885_IMAC24] = {
-                .mixers = { alc885_imac24_mixer },
-                .init_verbs = { alc885_imac24_init_verbs },
-                .num_dacs = ARRAY_SIZE(alc882_dac_nids),
-                .dac_nids = alc882_dac_nids,
-                .dig_out_nid = ALC882_DIGOUT_NID,
-                .dig_in_nid = ALC882_DIGIN_NID,
-                .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
-                .channel_mode = alc882_ch_modes,
-                .input_mux = &alc882_capture_source,
-                .unsol_event = alc_automute_amp_unsol_event,
-                .init_hook = alc885_imac24_init_hook,
-        },
-        [ALC882_TARGA] = {
-                .mixers = { alc882_targa_mixer, alc882_chmode_mixer },
-                .init_verbs = { alc882_init_verbs, alc882_targa_verbs},
-                .num_dacs = ARRAY_SIZE(alc882_dac_nids),
-                .dac_nids = alc882_dac_nids,
-                .dig_out_nid = ALC882_DIGOUT_NID,
-                .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
-                .adc_nids = alc882_adc_nids,
-                .capsrc_nids = alc882_capsrc_nids,
-                .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
-                .channel_mode = alc882_3ST_6ch_modes,
-                .need_dac_fix = 1,
-                .input_mux = &alc882_capture_source,
-                .unsol_event = alc882_targa_unsol_event,
-                .init_hook = alc882_targa_init_hook,
-        },
-        [ALC882_ASUS_A7J] = {
-                .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer },
-                .init_verbs = { alc882_init_verbs, alc882_asus_a7j_verbs},
-                .num_dacs = ARRAY_SIZE(alc882_dac_nids),
-                .dac_nids = alc882_dac_nids,
-                .dig_out_nid = ALC882_DIGOUT_NID,
-                .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
-                .adc_nids = alc882_adc_nids,
-                .capsrc_nids = alc882_capsrc_nids,
-                .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
-                .channel_mode = alc882_3ST_6ch_modes,
-                .need_dac_fix = 1,
-                .input_mux = &alc882_capture_source,
-        },
-        [ALC882_ASUS_A7M] = {
-                .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
-                .init_verbs = { alc882_init_verbs, alc882_eapd_verbs,
-                                alc880_gpio1_init_verbs,
-                                alc882_asus_a7m_verbs },
-                .num_dacs = ARRAY_SIZE(alc882_dac_nids),
-                .dac_nids = alc882_dac_nids,
-                .dig_out_nid = ALC882_DIGOUT_NID,
-                .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
-                .channel_mode = alc880_threestack_modes,
-                .need_dac_fix = 1,
-                .input_mux = &alc882_capture_source,
-        },
-};
-
-
-/*
- * Pin config fixes
- */
-enum {
-        PINFIX_ABIT_AW9D_MAX
-};
-
-static struct alc_pincfg alc882_abit_aw9d_pinfix[] = {
-        { 0x15, 0x01080104 }, /* side */
-        { 0x16, 0x01011012 }, /* rear */
-        { 0x17, 0x01016011 }, /* clfe */
-        { }
-};
-
-static const struct alc_pincfg *alc882_pin_fixes[] = {
-        [PINFIX_ABIT_AW9D_MAX] = alc882_abit_aw9d_pinfix,
-};
-
-static struct snd_pci_quirk alc882_pinfix_tbl[] = {
-        SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
-        {}
-};
-
-/*
- * BIOS auto configuration
- */
-static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
-                                              hda_nid_t nid, int pin_type,
-                                              int dac_idx)
-{
-        /* set as output */
-        struct alc_spec *spec = codec->spec;
-        int idx;
-
-        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 alc882_auto_init_multi_out(struct hda_codec *codec)
-{
-        struct alc_spec *spec = codec->spec;
-        int i;
-
-        for (i = 0; i <= HDA_SIDE; i++) {
-                hda_nid_t nid = spec->autocfg.line_out_pins[i];
-                int pin_type = get_pin_type(spec->autocfg.line_out_type);
-                if (nid)
-                        alc882_auto_set_output_and_unmute(codec, nid, pin_type,
-                                                          i);
-        }
-}
-
-static void alc882_auto_init_hp_out(struct hda_codec *codec)
-{
-        struct alc_spec *spec = codec->spec;
-        hda_nid_t pin;
-
-        pin = spec->autocfg.hp_pins[0];
-        if (pin) /* connect to front */
-                /* use dac 0 */
-                alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
-        pin = spec->autocfg.speaker_pins[0];
-        if (pin)
-                alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
-}
-
-#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)
-{
-        struct alc_spec *spec = codec->spec;
-        int i;
-
-        for (i = 0; i < AUTO_PIN_LAST; i++) {
-                hda_nid_t nid = spec->autocfg.input_pins[i];
-                if (!nid)
-                        continue;
-                alc_set_input_pin(codec, nid, AUTO_PIN_FRONT_MIC /*i*/);
-                if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
-                        snd_hda_codec_write(codec, nid, 0,
-                                            AC_VERB_SET_AMP_GAIN_MUTE,
-                                            AMP_OUT_MUTE);
-        }
-}
-
-static void alc882_auto_init_input_src(struct hda_codec *codec)
-{
-        struct alc_spec *spec = codec->spec;
-        int c;
-
-        for (c = 0; c < spec->num_adc_nids; c++) {
-                hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
-                hda_nid_t nid = spec->capsrc_nids[c];
-                unsigned int mux_idx;
-                const struct hda_input_mux *imux;
-                int conns, mute, idx, item;
-
-                conns = snd_hda_get_connections(codec, nid, conn_list,
-                                                ARRAY_SIZE(conn_list));
-                if (conns < 0)
-                        continue;
-                mux_idx = c >= spec->num_mux_defs ? 0 : c;
-                imux = &spec->input_mux[mux_idx];
-                for (idx = 0; idx < conns; idx++) {
-                        /* if the current connection is the selected one,
-                         * unmute it as default - otherwise mute it
-                         */
-                        mute = AMP_IN_MUTE(idx);
-                        for (item = 0; item < imux->num_items; item++) {
-                                if (imux->items[item].index == idx) {
-                                        if (spec->cur_mux[c] == item)
-                                                mute = AMP_IN_UNMUTE(idx);
-                                        break;
-                                }
-                        }
-                        /* check if we have a selector or mixer
-                         * we could check for the widget type instead, but
-                         * just check for Amp-In presence (in case of mixer
-                         * without amp-in there is something wrong, this
-                         * function shouldn't be used or capsrc nid is wrong)
-                         */
-                        if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)
-                                snd_hda_codec_write(codec, nid, 0,
-                                                    AC_VERB_SET_AMP_GAIN_MUTE,
-                                                    mute);
-                        else if (mute != AMP_IN_MUTE(idx))
-                                snd_hda_codec_write(codec, nid, 0,
-                                                    AC_VERB_SET_CONNECT_SEL,
-                                                    idx);
-                }
-        }
-}
-
-/* add mic boosts if needed */
-static int alc_auto_add_mic_boost(struct hda_codec *codec)
-{
-        struct alc_spec *spec = codec->spec;
-        int err;
-        hda_nid_t nid;
-
-        nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
-        if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
-                err = add_control(spec, ALC_CTL_WIDGET_VOL,
-                                  "Mic Boost",
-                                  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
-                if (err < 0)
-                        return err;
-        }
-        nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
-        if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
-                err = add_control(spec, ALC_CTL_WIDGET_VOL,
-                                  "Front Mic Boost",
-                                  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
-                if (err < 0)
-                        return err;
-        }
-        return 0;
-}
-
-/* almost identical with ALC880 parser... */
-static int alc882_parse_auto_config(struct hda_codec *codec)
-{
-        struct alc_spec *spec = codec->spec;
-        int err = alc880_parse_auto_config(codec);
-
-        if (err < 0)
-                return err;
-        else if (!err)
-                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] = alc882_auto_init_verbs;
-
-        return 1; /* config found */
-}
-
-/* additional initialization for auto-configuration model */
-static void alc882_auto_init(struct hda_codec *codec)
-{
-        struct alc_spec *spec = codec->spec;
-        alc882_auto_init_multi_out(codec);
-        alc882_auto_init_hp_out(codec);
-        alc882_auto_init_analog_input(codec);
-        alc882_auto_init_input_src(codec);
-        if (spec->unsol_event)
-                alc_inithook(codec);
-}
-
-static int patch_alc883(struct hda_codec *codec); /* called in patch_alc882() */
-
-static int patch_alc882(struct hda_codec *codec)
-{
-        struct alc_spec *spec;
-        int err, board_config;
-
-        spec = kzalloc(sizeof(*spec), GFP_KERNEL);
-        if (spec == NULL)
-                return -ENOMEM;
-
-        codec->spec = spec;
-
-        board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
-                                                  alc882_models,
-                                                  alc882_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 */
-                /* Macbook 3.1 (0x106b3600) is handled by patch_alc883() */
-                case 0x106b3800: /* MacbookPro4,1 - latter revision */
-                        board_config = ALC885_MBP3;
-                        break;
-                case 0x106b3f00: /* Macbook 5,1 */
-                case 0x106b4000: /* Macbook Pro 5,1 - FIXME: HP jack sense
-                                  *   seems not working, so apparently
-                                  *   no perfect solution yet
-                                  */
-                        board_config = ALC885_MB5;
-                        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 %s, "
-                               "trying auto-probe from BIOS...\n",
-                               codec->chip_name);
-                        board_config = ALC882_AUTO;
-                }
-        }
-
-        alc_fix_pincfg(codec, alc882_pinfix_tbl, alc882_pin_fixes);
-
-        if (board_config == ALC882_AUTO) {
-                /* automatic parse from the BIOS config */
-                err = alc882_parse_auto_config(codec);
-                if (err < 0) {
-                        alc_free(codec);
-                        return err;
-                } else if (!err) {
-                        printk(KERN_INFO
-                               "hda_codec: Cannot set up configuration "
-                               "from BIOS.  Using base mode...\n");
-                        board_config = ALC882_3ST_DIG;
-                }
-        }
-
-        err = snd_hda_attach_beep_device(codec, 0x1);
-        if (err < 0) {
-                alc_free(codec);
-                return err;
-        }
-
-        if (board_config != ALC882_AUTO)
-                setup_preset(spec, &alc882_presets[board_config]);
-
-        spec->stream_analog_playback = &alc882_pcm_analog_playback;
-        spec->stream_analog_capture = &alc882_pcm_analog_capture;
-        /* FIXME: setup DAC5 */
-        /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
-        spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
-
-        spec->stream_digital_playback = &alc882_pcm_digital_playback;
-        spec->stream_digital_capture = &alc882_pcm_digital_capture;
-
-        if (!spec->adc_nids && spec->input_mux) {
-                /* check whether NID 0x07 is valid */
-                unsigned int wcap = get_wcaps(codec, 0x07);
-                /* 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;
-                }
-        }
-        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 == ALC882_AUTO)
-                spec->init_hook = alc882_auto_init;
-#ifdef CONFIG_SND_HDA_POWER_SAVE
-        if (!spec->loopback.amplist)
-                spec->loopback.amplist = alc882_loopbacks;
-#endif
-        codec->proc_widget_hook = print_realtek_coef;
-
-        return 0;
-}
-
-/*
- * 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 },
-        },
-};
-
-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
- */
-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 },
-        { } /* 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 },
-        { } /* 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 },
-        { } /* 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_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 },
-        { } /* 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 },
-        { } /* 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 },
-        { } /* 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 },
-        { } /* 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 },
-        { } /* 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 },
-        { } /* 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 },
-        { } /* 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 },
-        { } /* 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 },
-        { } /* end */
-};
-
-static struct hda_channel_mode alc883_sixstack_modes[2] = {
-        { 6, alc883_sixstack_ch6_init },
-        { 8, alc883_sixstack_ch8_init },
-};
-
 /* 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 */
@@ -7938,34 +7767,7 @@ static struct hda_verb alc883_medion_eapd_verbs[] = {
         { }
 };
 
-/* 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),
-        { } /* end */
-};
+#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),
@@ -8076,6 +7878,30 @@ static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
         { } /* 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),
+        { } /* 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),
@@ -8101,8 +7927,9 @@ static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
 
 static struct snd_kcontrol_new alc883_targa_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_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Speaker 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),
@@ -8121,8 +7948,9 @@ static struct snd_kcontrol_new alc883_targa_mixer[] = {
 
 static struct snd_kcontrol_new alc883_targa_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", 0x14, 0x0, HDA_OUTPUT),
-        HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Speaker 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),
@@ -8134,6 +7962,15 @@ static struct snd_kcontrol_new alc883_targa_2ch_mixer[] = {
         { } /* end */
 };
 
+static struct snd_kcontrol_new alc883_targa_8ch_mixer[] = {
+        HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, 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),
+        { } /* 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),
@@ -8189,6 +8026,8 @@ static struct snd_kcontrol_new alc888_acer_aspire_6530_mixer[] = {
         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),
@@ -8314,93 +8153,14 @@ static struct snd_kcontrol_new alc883_chmode_mixer[] = {
         { } /* 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)},
-        { }
-};
-
 /* toggle speaker-output according to the hp-jack state */
-static void alc883_mitac_init_hook(struct hda_codec *codec)
+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;
-        alc_automute_amp(codec);
 }
 
 /* auto-toggle front mic */
@@ -8432,6 +8192,22 @@ static struct hda_verb alc883_mitac_verbs[] = {
         { } /* end */
 };
 
+static struct hda_verb alc883_clevo_m540r_verbs[] = {
+        /* HP */
+        {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        /* Int speaker */
+        /*{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},*/
+
+        /* 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},
+        */
+
+        { } /* end */
+};
+
 static struct hda_verb alc883_clevo_m720_verbs[] = {
         /* HP */
         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
@@ -8555,7 +8331,7 @@ static struct hda_verb alc883_vaiott_verbs[] = {
         { } /* end */
 };
 
-static void alc888_3st_hp_init_hook(struct hda_codec *codec)
+static void alc888_3st_hp_setup(struct hda_codec *codec)
 {
         struct alc_spec *spec = codec->spec;
 
@@ -8563,7 +8339,6 @@ static void alc888_3st_hp_init_hook(struct hda_codec *codec)
         spec->autocfg.speaker_pins[0] = 0x14;
         spec->autocfg.speaker_pins[1] = 0x16;
         spec->autocfg.speaker_pins[2] = 0x18;
-        alc_automute_amp(codec);
 }
 
 static struct hda_verb alc888_3st_hp_verbs[] = {
@@ -8660,13 +8435,12 @@ static struct hda_verb alc883_medion_md2_verbs[] = {
 };
 
 /* toggle speaker-output according to the hp-jack state */
-static void alc883_medion_md2_init_hook(struct hda_codec *codec)
+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;
-        alc_automute_amp(codec);
 }
 
 /* toggle speaker-output according to the hp-jack state */
@@ -8683,12 +8457,16 @@ static void alc883_clevo_m720_mic_automute(struct hda_codec *codec)
                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
 }
 
-static void alc883_clevo_m720_init_hook(struct hda_codec *codec)
+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);
 }
@@ -8707,22 +8485,20 @@ static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
 }
 
 /* toggle speaker-output according to the hp-jack state */
-static void alc883_2ch_fujitsu_pi2515_init_hook(struct hda_codec *codec)
+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;
-        alc_automute_amp(codec);
 }
 
-static void alc883_haier_w66_init_hook(struct hda_codec *codec)
+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;
-        alc_automute_amp(codec);
 }
 
 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
@@ -8761,14 +8537,13 @@ static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
 }
 
 /* toggle speaker-output according to the hp-jack state */
-static void alc883_acer_aspire_init_hook(struct hda_codec *codec)
+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;
-        alc_automute_amp(codec);
 }
 
 static struct hda_verb alc883_acer_eapd_verbs[] = {
@@ -8789,7 +8564,14 @@ static struct hda_verb alc883_acer_eapd_verbs[] = {
         { }
 };
 
-static void alc888_6st_dell_init_hook(struct hda_codec *codec)
+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},
+        { } /* end */
+};
+
+static void alc888_6st_dell_setup(struct hda_codec *codec)
 {
         struct alc_spec *spec = codec->spec;
 
@@ -8798,10 +8580,9 @@ static void alc888_6st_dell_init_hook(struct hda_codec *codec)
         spec->autocfg.speaker_pins[1] = 0x15;
         spec->autocfg.speaker_pins[2] = 0x16;
         spec->autocfg.speaker_pins[3] = 0x17;
-        alc_automute_amp(codec);
 }
 
-static void alc888_lenovo_sky_init_hook(struct hda_codec *codec)
+static void alc888_lenovo_sky_setup(struct hda_codec *codec)
 {
         struct alc_spec *spec = codec->spec;
 
@@ -8811,82 +8592,17 @@ static void alc888_lenovo_sky_init_hook(struct hda_codec *codec)
         spec->autocfg.speaker_pins[2] = 0x16;
         spec->autocfg.speaker_pins[3] = 0x17;
         spec->autocfg.speaker_pins[4] = 0x1a;
-        alc_automute_amp(codec);
 }
 
-static void alc883_vaiott_init_hook(struct hda_codec *codec)
+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;
-        alc_automute_amp(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)},
-
-        { }
-};
-
 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)},
@@ -8897,19 +8613,7 @@ static struct hda_verb alc888_asus_m90v_verbs[] = {
         { } /* 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_init_hook(struct hda_codec *codec)
+static void alc883_mode2_setup(struct hda_codec *codec)
 {
         struct alc_spec *spec = codec->spec;
 
@@ -8917,26 +8621,11 @@ static void alc883_M90V_init_hook(struct hda_codec *codec)
         spec->autocfg.speaker_pins[0] = 0x14;
         spec->autocfg.speaker_pins[1] = 0x15;
         spec->autocfg.speaker_pins[2] = 0x16;
-        alc_automute_pin(codec);
-}
-
-static void alc883_mode2_unsol_event(struct hda_codec *codec,
-                                           unsigned int res)
-{
-        switch (res >> 26) {
-        case ALC880_MIC_EVENT:
-                alc883_nb_mic_automute(codec);
-                break;
-        default:
-                alc_sku_unsol_event(codec, res);
-                break;
-        }
-}
-
-static void alc883_mode2_inithook(struct hda_codec *codec)
-{
-        alc883_M90V_init_hook(codec);
-        alc883_nb_mic_automute(codec);
+        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[] = {
@@ -8997,25 +8686,44 @@ static void alc889A_mb31_unsol_event(struct hda_codec *codec, unsigned int res)
                 alc889A_mb31_automute(codec);
 }
 
+
 #ifdef CONFIG_SND_HDA_POWER_SAVE
-#define alc883_loopbacks        alc880_loopbacks
+#define alc882_loopbacks        alc880_loopbacks
 #endif
 
 /* pcm configuration: identical 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
+#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,
+};
 
 /*
  * configuration and preset
  */
-static const char *alc883_models[ALC883_MODEL_LAST] = {
-        [ALC883_3ST_2ch_DIG]    = "3stack-dig",
+static const char *alc882_models[ALC882_MODEL_LAST] = {
+        [ALC882_3ST_DIG]        = "3stack-dig",
+        [ALC882_6ST_DIG]        = "6stack-dig",
+        [ALC882_ARIMA]          = "arima",
+        [ALC882_W2JC]           = "w2jc",
+        [ALC882_TARGA]          = "targa",
+        [ALC882_ASUS_A7J]       = "asus-a7j",
+        [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]        = "6stack-dig",
+        [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",
@@ -9024,6 +8732,7 @@ static const char *alc883_models[ALC883_MODEL_LAST] = {
         [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",
@@ -9035,18 +8744,22 @@ static const char *alc883_models[ALC883_MODEL_LAST] = {
         [ALC888_3ST_HP]         = "3stack-hp",
         [ALC888_6ST_DELL]       = "6stack-dell",
         [ALC883_MITAC]          = "mitac",
+        [ALC883_CLEVO_M540R]    = "clevo-m540r",
         [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",
-        [ALC883_AUTO]           = "auto",
+        [ALC882_AUTO]           = "auto",
 };
 
-static struct snd_pci_quirk alc883_cfg_tbl[] = {
-        SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC883_3ST_6ch_DIG),
+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),
@@ -9061,40 +8774,56 @@ static struct snd_pci_quirk alc883_cfg_tbl[] = {
                 ALC888_ACER_ASPIRE_8930G),
         SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
                 ALC888_ACER_ASPIRE_8930G),
-        SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC883_AUTO),
-        SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC883_AUTO),
+        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_4930G),
+                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", 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, "MSI", ALC883_6ST_DIG),
+        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(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),
@@ -9103,6 +8832,7 @@ static struct snd_pci_quirk alc883_cfg_tbl[] = {
         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),
@@ -9116,11 +8846,15 @@ static struct snd_pci_quirk alc883_cfg_tbl[] = {
         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(0x1558, 0x5409, "Clevo laptop M540R", ALC883_CLEVO_M540R),
         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),
@@ -9135,24 +8869,186 @@ static struct snd_pci_quirk alc883_cfg_tbl[] = {
         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, 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),
-        SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC883_SONY_VAIO_TT),
-        {}
-};
 
-static hda_nid_t alc883_slave_dig_outs[] = {
-        ALC1200_DIGOUT_NID, 0,
+        {}
 };
 
-static hda_nid_t alc1200_slave_dig_outs[] = {
-        ALC883_DIGOUT_NID, 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),
+        {} /* terminator */
 };
 
-static struct alc_config_preset alc883_presets[] = {
+static struct alc_config_preset alc882_presets[] = {
+        [ALC882_3ST_DIG] = {
+                .mixers = { alc882_base_mixer },
+                .init_verbs = { alc882_base_init_verbs,
+                                alc882_adc1_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc882_dac_nids),
+                .dac_nids = alc882_dac_nids,
+                .dig_out_nid = ALC882_DIGOUT_NID,
+                .dig_in_nid = ALC882_DIGIN_NID,
+                .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
+                .channel_mode = alc882_ch_modes,
+                .need_dac_fix = 1,
+                .input_mux = &alc882_capture_source,
+        },
+        [ALC882_6ST_DIG] = {
+                .mixers = { alc882_base_mixer, alc882_chmode_mixer },
+                .init_verbs = { alc882_base_init_verbs,
+                                alc882_adc1_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc882_dac_nids),
+                .dac_nids = alc882_dac_nids,
+                .dig_out_nid = ALC882_DIGOUT_NID,
+                .dig_in_nid = ALC882_DIGIN_NID,
+                .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
+                .channel_mode = alc882_sixstack_modes,
+                .input_mux = &alc882_capture_source,
+        },
+        [ALC882_ARIMA] = {
+                .mixers = { alc882_base_mixer, alc882_chmode_mixer },
+                .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
+                                alc882_eapd_verbs },
+                .num_dacs = ARRAY_SIZE(alc882_dac_nids),
+                .dac_nids = alc882_dac_nids,
+                .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
+                .channel_mode = alc882_sixstack_modes,
+                .input_mux = &alc882_capture_source,
+        },
+        [ALC882_W2JC] = {
+                .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
+                .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,
+                .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
+                .channel_mode = alc880_threestack_modes,
+                .need_dac_fix = 1,
+                .input_mux = &alc882_capture_source,
+                .dig_out_nid = ALC882_DIGOUT_NID,
+        },
+        [ALC885_MBP3] = {
+                .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
+                .init_verbs = { alc885_mbp3_init_verbs,
+                                alc880_gpio1_init_verbs },
+                .num_dacs = 2,
+                .dac_nids = alc882_dac_nids,
+                .hp_nid = 0x04,
+                .channel_mode = alc885_mbp_4ch_modes,
+                .num_channel_mode = ARRAY_SIZE(alc885_mbp_4ch_modes),
+                .input_mux = &alc882_capture_source,
+                .dig_out_nid = ALC882_DIGOUT_NID,
+                .dig_in_nid = ALC882_DIGIN_NID,
+                .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] = {
+                .mixers = { alc882_macpro_mixer },
+                .init_verbs = { alc882_macpro_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc882_dac_nids),
+                .dac_nids = alc882_dac_nids,
+                .dig_out_nid = ALC882_DIGOUT_NID,
+                .dig_in_nid = ALC882_DIGIN_NID,
+                .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
+                .channel_mode = alc882_ch_modes,
+                .input_mux = &alc882_capture_source,
+                .init_hook = alc885_macpro_init_hook,
+        },
+        [ALC885_IMAC24] = {
+                .mixers = { alc885_imac24_mixer },
+                .init_verbs = { alc885_imac24_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc882_dac_nids),
+                .dac_nids = alc882_dac_nids,
+                .dig_out_nid = ALC882_DIGOUT_NID,
+                .dig_in_nid = ALC882_DIGIN_NID,
+                .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
+                .channel_mode = alc882_ch_modes,
+                .input_mux = &alc882_capture_source,
+                .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_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,
+                .dig_out_nid = ALC882_DIGOUT_NID,
+                .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
+                .adc_nids = alc882_adc_nids,
+                .capsrc_nids = alc882_capsrc_nids,
+                .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
+                .channel_mode = alc882_3ST_6ch_modes,
+                .need_dac_fix = 1,
+                .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_base_init_verbs, alc882_adc1_init_verbs,
+                                alc882_asus_a7j_verbs},
+                .num_dacs = ARRAY_SIZE(alc882_dac_nids),
+                .dac_nids = alc882_dac_nids,
+                .dig_out_nid = ALC882_DIGOUT_NID,
+                .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
+                .adc_nids = alc882_adc_nids,
+                .capsrc_nids = alc882_capsrc_nids,
+                .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
+                .channel_mode = alc882_3ST_6ch_modes,
+                .need_dac_fix = 1,
+                .input_mux = &alc882_capture_source,
+        },
+        [ALC882_ASUS_A7M] = {
+                .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
+                .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),
+                .dac_nids = alc882_dac_nids,
+                .dig_out_nid = ALC882_DIGOUT_NID,
+                .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
+                .channel_mode = alc880_threestack_modes,
+                .need_dac_fix = 1,
+                .input_mux = &alc882_capture_source,
+        },
         [ALC883_3ST_2ch_DIG] = {
                 .mixers = { alc883_3ST_2ch_mixer },
                 .init_verbs = { alc883_init_verbs },
@@ -9199,6 +9095,46 @@ static struct alc_config_preset alc883_presets[] = {
                 .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 },
@@ -9212,7 +9148,8 @@ static struct alc_config_preset alc883_presets[] = {
         },
         [ALC883_TARGA_DIG] = {
                 .mixers = { alc883_targa_mixer, alc883_chmode_mixer },
-                .init_verbs = { alc883_init_verbs, alc883_targa_verbs},
+                .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,
@@ -9221,11 +9158,13 @@ static struct alc_config_preset alc883_presets[] = {
                 .need_dac_fix = 1,
                 .input_mux = &alc883_capture_source,
                 .unsol_event = alc883_targa_unsol_event,
-                .init_hook = alc883_targa_init_hook,
+                .setup = alc882_targa_setup,
+                .init_hook = alc882_targa_automute,
         },
         [ALC883_TARGA_2ch_DIG] = {
                 .mixers = { alc883_targa_2ch_mixer},
-                .init_verbs = { alc883_init_verbs, alc883_targa_verbs},
+                .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,
@@ -9235,10 +9174,12 @@ static struct alc_config_preset alc883_presets[] = {
                 .channel_mode = alc883_3ST_2ch_modes,
                 .input_mux = &alc883_capture_source,
                 .unsol_event = alc883_targa_unsol_event,
-                .init_hook = alc883_targa_init_hook,
+                .setup = alc882_targa_setup,
+                .init_hook = alc882_targa_automute,
         },
         [ALC883_TARGA_8ch_DIG] = {
-                .mixers = { alc883_base_mixer, alc883_chmode_mixer },
+                .mixers = { alc883_targa_mixer, alc883_targa_8ch_mixer,
+                            alc883_chmode_mixer },
                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
                                 alc883_targa_verbs },
                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
@@ -9253,7 +9194,8 @@ static struct alc_config_preset alc883_presets[] = {
                 .need_dac_fix = 1,
                 .input_mux = &alc883_capture_source,
                 .unsol_event = alc883_targa_unsol_event,
-                .init_hook = alc883_targa_init_hook,
+                .setup = alc882_targa_setup,
+                .init_hook = alc882_targa_automute,
         },
         [ALC883_ACER] = {
                 .mixers = { alc883_base_mixer },
@@ -9279,7 +9221,8 @@ static struct alc_config_preset alc883_presets[] = {
                 .channel_mode = alc883_3ST_2ch_modes,
                 .input_mux = &alc883_capture_source,
                 .unsol_event = alc_automute_amp_unsol_event,
-                .init_hook = alc883_acer_aspire_init_hook,
+                .setup = alc883_acer_aspire_setup,
+                .init_hook = alc_automute_amp,
         },
         [ALC888_ACER_ASPIRE_4930G] = {
                 .mixers = { alc888_base_mixer,
@@ -9299,7 +9242,8 @@ static struct alc_config_preset alc883_presets[] = {
                         ARRAY_SIZE(alc888_2_capture_sources),
                 .input_mux = alc888_2_capture_sources,
                 .unsol_event = alc_automute_amp_unsol_event,
-                .init_hook = alc888_acer_aspire_4930g_init_hook,
+                .setup = alc888_acer_aspire_4930g_setup,
+                .init_hook = alc_automute_amp,
         },
         [ALC888_ACER_ASPIRE_6530G] = {
                 .mixers = { alc888_acer_aspire_6530_mixer },
@@ -9317,7 +9261,8 @@ static struct alc_config_preset alc883_presets[] = {
                         ARRAY_SIZE(alc888_2_capture_sources),
                 .input_mux = alc888_acer_aspire_6530_sources,
                 .unsol_event = alc_automute_amp_unsol_event,
-                .init_hook = alc888_acer_aspire_4930g_init_hook,
+                .setup = alc888_acer_aspire_6530g_setup,
+                .init_hook = alc_automute_amp,
         },
         [ALC888_ACER_ASPIRE_8930G] = {
                 .mixers = { alc888_base_mixer,
@@ -9338,7 +9283,28 @@ static struct alc_config_preset alc883_presets[] = {
                         ARRAY_SIZE(alc889_capture_sources),
                 .input_mux = alc889_capture_sources,
                 .unsol_event = alc_automute_amp_unsol_event,
-                .init_hook = alc889_acer_aspire_8930g_init_hook,
+                .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,
@@ -9363,7 +9329,8 @@ static struct alc_config_preset alc883_presets[] = {
                 .channel_mode = alc883_3ST_2ch_modes,
                 .input_mux = &alc883_capture_source,
                 .unsol_event = alc_automute_amp_unsol_event,
-                .init_hook = alc883_medion_md2_init_hook,
+                .setup = alc883_medion_md2_setup,
+                .init_hook = alc_automute_amp,
         },
         [ALC883_LAPTOP_EAPD] = {
                 .mixers = { alc883_base_mixer },
@@ -9374,6 +9341,21 @@ static struct alc_config_preset alc883_presets[] = {
                 .channel_mode = alc883_3ST_2ch_modes,
                 .input_mux = &alc883_capture_source,
         },
+        [ALC883_CLEVO_M540R] = {
+                .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
+                .init_verbs = { alc883_init_verbs, alc883_clevo_m540r_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_clevo_modes),
+                .channel_mode = alc883_3ST_6ch_clevo_modes,
+                .need_dac_fix = 1,
+                .input_mux = &alc883_capture_source,
+                /* This machine has the hardware HP auto-muting, thus
+                 * we need no software mute via unsol event
+                 */
+        },
         [ALC883_CLEVO_M720] = {
                 .mixers = { alc883_clevo_m720_mixer },
                 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
@@ -9384,6 +9366,7 @@ static struct alc_config_preset alc883_presets[] = {
                 .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] = {
@@ -9409,7 +9392,8 @@ static struct alc_config_preset alc883_presets[] = {
                 .need_dac_fix = 1,
                 .input_mux = &alc883_lenovo_nb0763_capture_source,
                 .unsol_event = alc_automute_amp_unsol_event,
-                .init_hook = alc883_medion_md2_init_hook,
+                .setup = alc883_medion_md2_setup,
+                .init_hook = alc_automute_amp,
         },
         [ALC888_LENOVO_MS7195_DIG] = {
                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
@@ -9434,7 +9418,8 @@ static struct alc_config_preset alc883_presets[] = {
                 .channel_mode = alc883_3ST_2ch_modes,
                 .input_mux = &alc883_capture_source,
                 .unsol_event = alc_automute_amp_unsol_event,
-                .init_hook = alc883_haier_w66_init_hook,
+                .setup = alc883_haier_w66_setup,
+                .init_hook = alc_automute_amp,
         },
         [ALC888_3ST_HP] = {
                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
@@ -9446,7 +9431,8 @@ static struct alc_config_preset alc883_presets[] = {
                 .need_dac_fix = 1,
                 .input_mux = &alc883_capture_source,
                 .unsol_event = alc_automute_amp_unsol_event,
-                .init_hook = alc888_3st_hp_init_hook,
+                .setup = alc888_3st_hp_setup,
+                .init_hook = alc_automute_amp,
         },
         [ALC888_6ST_DELL] = {
                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
@@ -9459,7 +9445,8 @@ static struct alc_config_preset alc883_presets[] = {
                 .channel_mode = alc883_sixstack_modes,
                 .input_mux = &alc883_capture_source,
                 .unsol_event = alc_automute_amp_unsol_event,
-                .init_hook = alc888_6st_dell_init_hook,
+                .setup = alc888_6st_dell_setup,
+                .init_hook = alc_automute_amp,
         },
         [ALC883_MITAC] = {
                 .mixers = { alc883_mitac_mixer },
@@ -9470,7 +9457,8 @@ static struct alc_config_preset alc883_presets[] = {
                 .channel_mode = alc883_3ST_2ch_modes,
                 .input_mux = &alc883_capture_source,
                 .unsol_event = alc_automute_amp_unsol_event,
-                .init_hook = alc883_mitac_init_hook,
+                .setup = alc883_mitac_setup,
+                .init_hook = alc_automute_amp,
         },
         [ALC883_FUJITSU_PI2515] = {
                 .mixers = { alc883_2ch_fujitsu_pi2515_mixer },
@@ -9483,7 +9471,8 @@ static struct alc_config_preset alc883_presets[] = {
                 .channel_mode = alc883_3ST_2ch_modes,
                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
                 .unsol_event = alc_automute_amp_unsol_event,
-                .init_hook = alc883_2ch_fujitsu_pi2515_init_hook,
+                .setup = alc883_2ch_fujitsu_pi2515_setup,
+                .init_hook = alc_automute_amp,
         },
         [ALC888_FUJITSU_XA3530] = {
                 .mixers = { alc888_base_mixer, alc883_chmode_mixer },
@@ -9501,7 +9490,8 @@ static struct alc_config_preset alc883_presets[] = {
                         ARRAY_SIZE(alc888_2_capture_sources),
                 .input_mux = alc888_2_capture_sources,
                 .unsol_event = alc_automute_amp_unsol_event,
-                .init_hook = alc888_fujitsu_xa3530_init_hook,
+                .setup = alc888_fujitsu_xa3530_setup,
+                .init_hook = alc_automute_amp,
         },
         [ALC888_LENOVO_SKY] = {
                 .mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
@@ -9514,7 +9504,8 @@ static struct alc_config_preset alc883_presets[] = {
                 .need_dac_fix = 1,
                 .input_mux = &alc883_lenovo_sky_capture_source,
                 .unsol_event = alc_automute_amp_unsol_event,
-                .init_hook = alc888_lenovo_sky_init_hook,
+                .setup = alc888_lenovo_sky_setup,
+                .init_hook = alc_automute_amp,
         },
         [ALC888_ASUS_M90V] = {
                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
@@ -9527,8 +9518,9 @@ static struct alc_config_preset alc883_presets[] = {
                 .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,
+                .unsol_event = alc_sku_unsol_event,
+                .setup = alc883_mode2_setup,
+                .init_hook = alc_inithook,
         },
         [ALC888_ASUS_EEE1601] = {
                 .mixers = { alc883_asus_eee1601_mixer },
@@ -9581,15 +9573,45 @@ static struct alc_config_preset alc883_presets[] = {
                 .channel_mode = alc883_3ST_2ch_modes,
                 .input_mux = &alc883_capture_source,
                 .unsol_event = alc_automute_amp_unsol_event,
-                .init_hook = alc883_vaiott_init_hook,
+                .setup = alc883_vaiott_setup,
+                .init_hook = alc_automute_amp,
         },
 };
 
 
 /*
+ * Pin config fixes
+ */
+enum {
+        PINFIX_ABIT_AW9D_MAX
+};
+
+static struct alc_pincfg alc882_abit_aw9d_pinfix[] = {
+        { 0x15, 0x01080104 }, /* side */
+        { 0x16, 0x01011012 }, /* rear */
+        { 0x17, 0x01016011 }, /* clfe */
+        { }
+};
+
+static const struct alc_pincfg *alc882_pin_fixes[] = {
+        [PINFIX_ABIT_AW9D_MAX] = alc882_abit_aw9d_pinfix,
+};
+
+static struct snd_pci_quirk alc882_pinfix_tbl[] = {
+        SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
+        {}
+};
+
+/*
  * BIOS auto configuration
  */
-static void alc883_auto_set_output_and_unmute(struct hda_codec *codec,
+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,
                                               int dac_idx)
 {
@@ -9606,7 +9628,7 @@ static void alc883_auto_set_output_and_unmute(struct hda_codec *codec,
 
 }
 
-static void alc883_auto_init_multi_out(struct hda_codec *codec)
+static void alc882_auto_init_multi_out(struct hda_codec *codec)
 {
         struct alc_spec *spec = codec->spec;
         int i;
@@ -9615,12 +9637,12 @@ static void alc883_auto_init_multi_out(struct hda_codec *codec)
                 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,
+                        alc882_auto_set_output_and_unmute(codec, nid, pin_type,
                                                           i);
         }
 }
 
-static void alc883_auto_init_hp_out(struct hda_codec *codec)
+static void alc882_auto_init_hp_out(struct hda_codec *codec)
 {
         struct alc_spec *spec = codec->spec;
         hda_nid_t pin;
@@ -9628,91 +9650,191 @@ static void alc883_auto_init_hp_out(struct hda_codec *codec)
         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);
+                alc882_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);
+                alc882_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)
+static void alc882_auto_init_analog_input(struct hda_codec *codec)
 {
         struct alc_spec *spec = codec->spec;
         int i;
 
         for (i = 0; i < AUTO_PIN_LAST; i++) {
                 hda_nid_t nid = spec->autocfg.input_pins[i];
-                if (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))
+                if (!nid)
+                        continue;
+                alc_set_input_pin(codec, nid, i);
+                if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
+                        snd_hda_codec_write(codec, nid, 0,
+                                            AC_VERB_SET_AMP_GAIN_MUTE,
+                                            AMP_OUT_MUTE);
+        }
+}
+
+static void alc882_auto_init_input_src(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+        int c;
+
+        for (c = 0; c < spec->num_adc_nids; c++) {
+                hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
+                hda_nid_t nid = spec->capsrc_nids[c];
+                unsigned int mux_idx;
+                const struct hda_input_mux *imux;
+                int conns, mute, idx, item;
+
+                conns = snd_hda_get_connections(codec, nid, conn_list,
+                                                ARRAY_SIZE(conn_list));
+                if (conns < 0)
+                        continue;
+                mux_idx = c >= spec->num_mux_defs ? 0 : c;
+                imux = &spec->input_mux[mux_idx];
+                for (idx = 0; idx < conns; idx++) {
+                        /* if the current connection is the selected one,
+                         * unmute it as default - otherwise mute it
+                         */
+                        mute = AMP_IN_MUTE(idx);
+                        for (item = 0; item < imux->num_items; item++) {
+                                if (imux->items[item].index == idx) {
+                                        if (spec->cur_mux[c] == item)
+                                                mute = AMP_IN_UNMUTE(idx);
+                                        break;
+                                }
+                        }
+                        /* check if we have a selector or mixer
+                         * we could check for the widget type instead, but
+                         * just check for Amp-In presence (in case of mixer
+                         * without amp-in there is something wrong, this
+                         * function shouldn't be used or capsrc nid is wrong)
+                         */
+                        if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)
                                 snd_hda_codec_write(codec, nid, 0,
                                                     AC_VERB_SET_AMP_GAIN_MUTE,
-                                                    AMP_OUT_MUTE);
+                                                    mute);
+                        else if (mute != AMP_IN_MUTE(idx))
+                                snd_hda_codec_write(codec, nid, 0,
+                                                    AC_VERB_SET_CONNECT_SEL,
+                                                    idx);
                 }
         }
 }
 
-#define alc883_auto_init_input_src      alc882_auto_init_input_src
+/* add mic boosts if needed */
+static int alc_auto_add_mic_boost(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+        int err;
+        hda_nid_t nid;
+
+        nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
+        if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
+                err = add_control(spec, ALC_CTL_WIDGET_VOL,
+                                  "Mic Boost",
+                                  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
+                if (err < 0)
+                        return err;
+        }
+        nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
+        if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
+                err = add_control(spec, ALC_CTL_WIDGET_VOL,
+                                  "Front Mic Boost",
+                                  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
+                if (err < 0)
+                        return err;
+        }
+        return 0;
+}
 
 /* almost identical with ALC880 parser... */
-static int alc883_parse_auto_config(struct hda_codec *codec)
+static int alc882_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;
+        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 = alc_auto_add_mic_boost(codec);
+        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;
 
-        /* hack - override the init verbs */
-        spec->init_verbs[0] = alc883_auto_init_verbs;
+        spec->multiout.max_channels = spec->multiout.num_dacs * 2;
 
-        /* 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;
+        /* 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;
 
         return 1; /* config found */
 }
 
 /* additional initialization for auto-configuration model */
-static void alc883_auto_init(struct hda_codec *codec)
+static void alc882_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);
+        alc882_auto_init_multi_out(codec);
+        alc882_auto_init_hp_out(codec);
+        alc882_auto_init_analog_input(codec);
+        alc882_auto_init_input_src(codec);
         if (spec->unsol_event)
                 alc_inithook(codec);
 }
 
-static int patch_alc883(struct hda_codec *codec)
+static int patch_alc882(struct hda_codec *codec)
 {
         struct alc_spec *spec;
         int err, board_config;
@@ -9723,28 +9845,35 @@ static int patch_alc883(struct hda_codec *codec)
 
         codec->spec = spec;
 
-        alc_fix_pll_init(codec, 0x20, 0x0a, 10);
+        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, ALC883_MODEL_LAST,
-                                                  alc883_models,
-                                                  alc883_cfg_tbl);
-        if (board_config < 0 || board_config >= ALC883_MODEL_LAST) {
-                /* Pick up systems that don't supply PCI SSID */
-                switch (codec->subsystem_id) {
-                case 0x106b3600: /* Macbook 3.1 */
-                        board_config = ALC889A_MB31;
-                        break;
-                default:
-                        printk(KERN_INFO
-                                "hda_codec: Unknown model for %s, trying "
-                                "auto-probe from BIOS...\n", codec->chip_name);
-                        board_config = ALC883_AUTO;
-                }
+        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) {
+                printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
+                       codec->chip_name);
+                board_config = ALC882_AUTO;
         }
 
-        if (board_config == ALC883_AUTO) {
+        alc_fix_pincfg(codec, alc882_pinfix_tbl, alc882_pin_fixes);
+
+        if (board_config == ALC882_AUTO) {
                 /* automatic parse from the BIOS config */
-                err = alc883_parse_auto_config(codec);
+                err = alc882_parse_auto_config(codec);
                 if (err < 0) {
                         alc_free(codec);
                         return err;
@@ -9752,7 +9881,7 @@ static int patch_alc883(struct hda_codec *codec)
                         printk(KERN_INFO
                                "hda_codec: Cannot set up configuration "
                                "from BIOS.  Using base mode...\n");
-                        board_config = ALC883_3ST_2ch_DIG;
+                        board_config = ALC882_3ST_DIG;
                 }
         }
 
@@ -9762,63 +9891,61 @@ static int patch_alc883(struct hda_codec *codec)
                 return err;
         }
 
-        if (board_config != ALC883_AUTO)
-                setup_preset(spec, &alc883_presets[board_config]);
+        if (board_config != ALC882_AUTO)
+                setup_preset(codec, &alc882_presets[board_config]);
 
-        switch (codec->vendor_id) {
-        case 0x10ec0888:
-                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->stream_analog_playback = &alc882_pcm_analog_playback;
+        spec->stream_analog_capture = &alc882_pcm_analog_capture;
+        /* FIXME: setup DAC5 */
+        /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
+        spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
+
+        spec->stream_digital_playback = &alc882_pcm_digital_playback;
+        spec->stream_digital_capture = &alc882_pcm_digital_capture;
+
+        if (codec->vendor_id == 0x10ec0888)
                 spec->init_amp = ALC_INIT_DEFAULT; /* always initialize */
-                break;
-        case 0x10ec0889:
-                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;
-                break;
-        default:
-                if (!spec->num_adc_nids) {
-                        spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids);
-                        spec->adc_nids = alc883_adc_nids;
+
+        if (!spec->adc_nids && spec->input_mux) {
+                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++;
                 }
-                if (!spec->capsrc_nids)
-                        spec->capsrc_nids = alc883_capsrc_nids;
-                break;
+                spec->adc_nids = spec->private_adc_nids;
+                spec->capsrc_nids = spec->private_capsrc_nids;
         }
 
-        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_capture_mixer(codec);
         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;
-
+        if (board_config == ALC882_AUTO)
+                spec->init_hook = alc882_auto_init;
 #ifdef CONFIG_SND_HDA_POWER_SAVE
         if (!spec->loopback.amplist)
-                spec->loopback.amplist = alc883_loopbacks;
+                spec->loopback.amplist = alc882_loopbacks;
 #endif
         codec->proc_widget_hook = print_realtek_coef;
 
         return 0;
 }
 
+
 /*
  * ALC262 support
  */
@@ -9994,13 +10121,12 @@ static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
 };
 
 /* mute/unmute internal speaker according to the hp jack and mute state */
-static void alc262_hp_t5735_init_hook(struct hda_codec *codec)
+static void alc262_hp_t5735_setup(struct hda_codec *codec)
 {
         struct alc_spec *spec = codec->spec;
 
         spec->autocfg.hp_pins[0] = 0x15;
         spec->autocfg.speaker_pins[0] = 0x0c; /* HACK: not actually a pin */
-        alc_automute_amp(codec);
 }
 
 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
@@ -10157,22 +10283,20 @@ static void alc262_hippo_unsol_event(struct hda_codec *codec, unsigned int res)
         alc262_hippo_automute(codec);
 }
 
-static void alc262_hippo_init_hook(struct hda_codec *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;
-        alc262_hippo_automute(codec);
 }
 
-static void alc262_hippo1_init_hook(struct hda_codec *codec)
+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;
-        alc262_hippo_automute(codec);
 }
 
 
@@ -10229,13 +10353,12 @@ static struct hda_verb alc262_tyan_verbs[] = {
 };
 
 /* unsolicited event for HP jack sensing */
-static void alc262_tyan_init_hook(struct hda_codec *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;
-        alc_automute_amp(codec);
 }
 
 
@@ -10327,12 +10450,6 @@ static struct hda_verb alc262_eapd_verbs[] = {
         { }
 };
 
-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},
-        {}
-};
-
 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
@@ -10353,14 +10470,6 @@ static struct hda_verb alc262_sony_unsol_verbs[] = {
         {}
 };
 
-static struct hda_input_mux alc262_dmic_capture_source = {
-        .num_items = 2,
-        .items = {
-                { "Int DMic", 0x9 },
-                { "Mic", 0x0 },
-        },
-};
-
 static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
@@ -10382,35 +10491,17 @@ static struct hda_verb alc262_toshiba_s06_verbs[] = {
         {}
 };
 
-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);
-}
-
-
-/* unsolicited event for HP jack sensing */
-static void alc262_toshiba_s06_unsol_event(struct hda_codec *codec,
-                                       unsigned int res)
-{
-        if ((res >> 26) == ALC880_MIC_EVENT)
-                alc262_dmic_automute(codec);
-        else
-                alc_sku_unsol_event(codec, res);
-}
-
-static void alc262_toshiba_s06_init_hook(struct hda_codec *codec)
+static void alc262_toshiba_s06_setup(struct hda_codec *codec)
 {
         struct alc_spec *spec = codec->spec;
 
         spec->autocfg.hp_pins[0] = 0x15;
         spec->autocfg.speaker_pins[0] = 0x14;
-        alc_automute_pin(codec);
-        alc262_dmic_automute(codec);
+        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;
 }
 
 /*
@@ -10599,6 +10690,18 @@ static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
         alc262_lenovo_3000_automute(codec, 1);
 }
 
+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,
                                          struct snd_ctl_elem_value *ucontrol)
@@ -10607,13 +10710,8 @@ static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
         long *valp = ucontrol->value.integer.value;
         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);
         return change;
@@ -10648,10 +10746,7 @@ static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
         long *valp = ucontrol->value.integer.value;
         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);
         return change;
@@ -10824,104 +10919,111 @@ static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
         { } /* end */
 };
 
+/* 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;
 
         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(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;
-                }
-        }
-        return 0;
-}
-
-static int alc262_auto_create_analog_input_ctls(struct alc_spec *spec,
-                                                const struct auto_pin_cfg *cfg)
-{
-        int 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;
 
-        err = alc880_auto_create_analog_input_ctls(spec, cfg);
+        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;
-        /* 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 = 0x09;
-                imux->num_items++;
-        }
         return 0;
 }
 
+#define alc262_auto_create_input_ctls \
+        alc880_auto_create_input_ctls
 
 /*
  * generic initialization of ADC, input mixers and output mixers
@@ -11239,7 +11341,7 @@ static int alc262_parse_auto_config(struct hda_codec *codec)
         err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
         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;
 
@@ -11370,7 +11472,7 @@ static struct alc_config_preset alc262_presets[] = {
         },
         [ALC262_HIPPO] = {
                 .mixers = { alc262_hippo_mixer },
-                .init_verbs = { alc262_init_verbs, alc262_hippo_unsol_verbs},
+                .init_verbs = { alc262_init_verbs, alc_hp15_unsol_verbs},
                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
                 .dac_nids = alc262_dac_nids,
                 .hp_nid = 0x03,
@@ -11379,7 +11481,8 @@ static struct alc_config_preset alc262_presets[] = {
                 .channel_mode = alc262_modes,
                 .input_mux = &alc262_capture_source,
                 .unsol_event = alc262_hippo_unsol_event,
-                .init_hook = alc262_hippo_init_hook,
+                .setup = alc262_hippo_setup,
+                .init_hook = alc262_hippo_automute,
         },
         [ALC262_HIPPO_1] = {
                 .mixers = { alc262_hippo1_mixer },
@@ -11392,7 +11495,8 @@ static struct alc_config_preset alc262_presets[] = {
                 .channel_mode = alc262_modes,
                 .input_mux = &alc262_capture_source,
                 .unsol_event = alc262_hippo_unsol_event,
-                .init_hook = alc262_hippo1_init_hook,
+                .setup = alc262_hippo1_setup,
+                .init_hook = alc262_hippo_automute,
         },
         [ALC262_FUJITSU] = {
                 .mixers = { alc262_fujitsu_mixer },
@@ -11455,7 +11559,8 @@ static struct alc_config_preset alc262_presets[] = {
                 .channel_mode = alc262_modes,
                 .input_mux = &alc262_capture_source,
                 .unsol_event = alc_automute_amp_unsol_event,
-                .init_hook = alc262_hp_t5735_init_hook,
+                .setup = alc262_hp_t5735_setup,
+                .init_hook = alc_automute_amp,
         },
         [ALC262_HP_RP5700] = {
                 .mixers = { alc262_hp_rp5700_mixer },
@@ -11486,11 +11591,13 @@ static struct alc_config_preset alc262_presets[] = {
                 .channel_mode = alc262_modes,
                 .input_mux = &alc262_capture_source,
                 .unsol_event = alc262_hippo_unsol_event,
-                .init_hook = alc262_hippo_init_hook,
+                .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,
                 .hp_nid = 0x03,
@@ -11498,7 +11605,8 @@ static struct alc_config_preset alc262_presets[] = {
                 .channel_mode = alc262_modes,
                 .input_mux = &alc262_capture_source,
                 .unsol_event = alc262_hippo_unsol_event,
-                .init_hook = alc262_hippo_init_hook,
+                .setup = alc262_hippo_setup,
+                .init_hook = alc262_hippo_automute,
         },
         [ALC262_ULTRA] = {
                 .mixers = { alc262_ultra_mixer },
@@ -11550,9 +11658,9 @@ static struct alc_config_preset alc262_presets[] = {
                 .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] = {
                 .mixers = { alc262_toshiba_rx1_mixer },
@@ -11564,7 +11672,8 @@ static struct alc_config_preset alc262_presets[] = {
                 .channel_mode = alc262_modes,
                 .input_mux = &alc262_capture_source,
                 .unsol_event = alc262_hippo_unsol_event,
-                .init_hook = alc262_hippo_init_hook,
+                .setup = alc262_hippo_setup,
+                .init_hook = alc262_hippo_automute,
         },
         [ALC262_TYAN] = {
                 .mixers = { alc262_tyan_mixer },
@@ -11577,7 +11686,8 @@ static struct alc_config_preset alc262_presets[] = {
                 .channel_mode = alc262_modes,
                 .input_mux = &alc262_capture_source,
                 .unsol_event = alc_automute_amp_unsol_event,
-                .init_hook = alc262_tyan_init_hook,
+                .setup = alc262_tyan_setup,
+                .init_hook = alc_automute_amp,
         },
 };
 
@@ -11612,8 +11722,8 @@ static int patch_alc262(struct hda_codec *codec)
                                                   alc262_cfg_tbl);
 
         if (board_config < 0) {
-                printk(KERN_INFO "hda_codec: Unknown model for %s, "
-                       "trying auto-probe from BIOS...\n", codec->chip_name);
+                printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
+                       codec->chip_name);
                 board_config = ALC262_AUTO;
         }
 
@@ -11640,7 +11750,7 @@ static int patch_alc262(struct hda_codec *codec)
         }
 
         if (board_config != ALC262_AUTO)
-                setup_preset(spec, &alc262_presets[board_config]);
+                setup_preset(codec, &alc262_presets[board_config]);
 
         spec->stream_analog_playback = &alc262_pcm_analog_playback;
         spec->stream_analog_capture = &alc262_pcm_analog_capture;
@@ -11666,7 +11776,7 @@ static int patch_alc262(struct hda_codec *codec)
                         unsigned int wcap = get_wcaps(codec, 0x07);
 
                         /* 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 = alc262_adc_nids_alt;
                                 spec->num_adc_nids =
@@ -11681,7 +11791,7 @@ static int patch_alc262(struct hda_codec *codec)
                 }
         }
         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);
 
@@ -11773,14 +11883,6 @@ static struct hda_verb alc268_toshiba_verbs[] = {
         { } /* end */
 };
 
-static struct hda_input_mux alc268_acer_lc_capture_source = {
-        .num_items = 2,
-        .items = {
-                { "i-Mic", 0x6 },
-                { "E-Mic", 0x0 },
-        },
-};
-
 /* Acer specific */
 /* bind volumes of both NID 0x02 and 0x03 */
 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
@@ -11822,12 +11924,7 @@ static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
         long *valp = ucontrol->value.integer.value;
         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);
         return change;
@@ -11904,7 +12001,8 @@ static struct hda_verb alc268_acer_verbs[] = {
 
 /* unsolicited event for HP jack sensing */
 #define alc268_toshiba_unsol_event      alc262_hippo_unsol_event
-#define alc268_toshiba_init_hook        alc262_hippo_init_hook
+#define alc268_toshiba_setup            alc262_hippo_setup
+#define alc268_toshiba_automute         alc262_hippo_automute
 
 static void alc268_acer_unsol_event(struct hda_codec *codec,
                                        unsigned int res)
@@ -11934,30 +12032,33 @@ static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
                                 AMP_IN_MUTE(0), bits);
 }
 
-
-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;
 }
 
 static void alc268_acer_lc_init_hook(struct hda_codec *codec)
 {
         alc268_aspire_one_speaker_automute(codec);
-        alc268_acer_mic_automute(codec);
+        alc_mic_automute(codec);
 }
 
 static struct snd_kcontrol_new alc268_dell_mixer[] = {
@@ -11975,17 +12076,22 @@ static struct hda_verb alc268_dell_verbs[] = {
         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
         {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},
         { }
 };
 
 /* mute/unmute internal speaker according to the hp jack and mute state */
-static void alc268_dell_init_hook(struct hda_codec *codec)
+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;
-        alc_automute_pin(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 struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
@@ -12006,38 +12112,16 @@ static struct hda_verb alc267_quanta_il1_verbs[] = {
         { }
 };
 
-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_init_hook(struct hda_codec *codec)
+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;
-        alc_automute_pin(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_MIC_EVENT:
-                alc267_quanta_il1_mic_automute(codec);
-                break;
-        default:
-                alc_sku_unsol_event(codec, res);
-                break;
-        }
+        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;
 }
 
 /*
@@ -12117,21 +12201,16 @@ static struct hda_verb alc268_volume_init_verbs[] = {
         { }
 };
 
+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),
+        { } /* 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),
         { } /* end */
 };
 
@@ -12140,18 +12219,7 @@ static struct snd_kcontrol_new alc268_capture_mixer[] = {
         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
         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),
         { } /* end */
 };
 
@@ -12238,26 +12306,38 @@ static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
                                     const char *ctlname, int idx)
 {
         char name[32];
+        hda_nid_t dac;
         int err;
 
         sprintf(name, "%s Playback Volume", ctlname);
-        if (nid == 0x14) {
-                err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
-                                  HDA_COMPOSE_AMP_VAL(0x02, 3, idx,
-                                                      HDA_OUTPUT));
-                if (err < 0)
-                        return err;
-        } else if (nid == 0x15) {
+        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(0x03, 3, idx,
+                                  HDA_COMPOSE_AMP_VAL(dac, 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;
         return 0;
@@ -12270,14 +12350,19 @@ static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
         hda_nid_t nid;
         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];
         if (nid == 0x1d) {
@@ -12286,16 +12371,23 @@ static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
                 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];
         if (nid == 0x16) {
                 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;
         }
@@ -12303,38 +12395,46 @@ static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
 }
 
 /* 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;
+        return alc_auto_create_input_ctls(codec, cfg, 0, 0x23, 0x24);
+}
 
-        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++;
+static void alc268_auto_set_output_and_unmute(struct hda_codec *codec,
+                                              hda_nid_t nid, int pin_type)
+{
+        int idx;
+
+        alc_set_pin_output(codec, nid, pin_type);
+        if (nid == 0x14 || nid == 0x16)
+                idx = 0;
+        else
+                idx = 1;
+        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
+}
+
+static void alc268_auto_init_multi_out(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+        hda_nid_t nid = spec->autocfg.line_out_pins[0];
+        if (nid) {
+                int pin_type = get_pin_type(spec->autocfg.line_out_type);
+                alc268_auto_set_output_and_unmute(codec, nid, pin_type);
         }
-        return 0;
+}
+
+static void alc268_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)
+                alc268_auto_set_output_and_unmute(codec, pin, PIN_HP);
+        pin = spec->autocfg.speaker_pins[0];
+        if (pin)
+                alc268_auto_set_output_and_unmute(codec, pin, PIN_OUT);
 }
 
 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
@@ -12345,9 +12445,10 @@ static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
         unsigned int    dac_vol1, dac_vol2;
 
-        if (speaker_nid) {
+        if (line_nid == 0x1d || speaker_nid == 0x1d) {
                 snd_hda_codec_write(codec, speaker_nid, 0,
                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
+                /* mute mixer inputs from 0x1d */
                 snd_hda_codec_write(codec, 0x0f, 0,
                                     AC_VERB_SET_AMP_GAIN_MUTE,
                                     AMP_IN_UNMUTE(1));
@@ -12355,6 +12456,7 @@ static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
                                     AC_VERB_SET_AMP_GAIN_MUTE,
                                     AMP_IN_UNMUTE(1));
         } else {
+                /* unmute mixer inputs from 0x1d */
                 snd_hda_codec_write(codec, 0x0f, 0,
                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
                 snd_hda_codec_write(codec, 0x10, 0,
@@ -12411,7 +12513,7 @@ static int alc268_parse_auto_config(struct hda_codec *codec)
         err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
         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;
 
@@ -12430,18 +12532,18 @@ static int alc268_parse_auto_config(struct hda_codec *codec)
                 add_mixer(spec, alc268_beep_mixer);
 
         add_verb(spec, alc268_volume_init_verbs);
-        spec->num_mux_defs = 1;
+        spec->num_mux_defs = 2;
         spec->input_mux = &spec->private_imux[0];
 
         err = alc_auto_add_mic_boost(codec);
         if (err < 0)
                 return err;
 
+        alc_ssid_check(codec, 0x15, 0x1b, 0x14);
+
         return 1;
 }
 
-#define alc268_auto_init_multi_out      alc882_auto_init_multi_out
-#define alc268_auto_init_hp_out         alc882_auto_init_hp_out
 #define alc268_auto_init_analog_input   alc882_auto_init_analog_input
 
 /* init callback for auto-configuration model -- overriding the default init */
@@ -12484,12 +12586,13 @@ static struct snd_pci_quirk alc268_cfg_tbl[] = {
                                                 ALC268_ACER_ASPIRE_ONE),
         SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
         SND_PCI_QUIRK(0x1028, 0x02b0, "Dell Inspiron Mini9", ALC268_DELL),
+        /* almost compatible with toshiba but with optional digital outs;
+         * auto-probing seems working fine
+         */
         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3000, "HP TX25xx series",
-                           ALC268_TOSHIBA),
+                           ALC268_AUTO),
         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
         SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
-        SND_PCI_QUIRK_MASK(0x1179, 0xff00, 0xff00, "TOSHIBA A/Lx05",
-                           ALC268_TOSHIBA),
         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),
@@ -12497,9 +12600,19 @@ static struct snd_pci_quirk alc268_cfg_tbl[] = {
         {}
 };
 
+/* 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),
+        {}
+};
+
 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 },
                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
@@ -12509,9 +12622,9 @@ static struct alc_config_preset alc268_presets[] = {
                 .hp_nid = 0x03,
                 .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_init_hook,
+                .unsol_event = alc_sku_unsol_event,
+                .setup = alc267_quanta_il1_setup,
+                .init_hook = alc_inithook,
         },
         [ALC268_3ST] = {
                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
@@ -12543,10 +12656,11 @@ static struct alc_config_preset alc268_presets[] = {
                 .channel_mode = alc268_modes,
                 .input_mux = &alc268_capture_source,
                 .unsol_event = alc268_toshiba_unsol_event,
-                .init_hook = alc268_toshiba_init_hook,
+                .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,
                                 alc268_acer_verbs },
@@ -12582,7 +12696,7 @@ static struct alc_config_preset alc268_presets[] = {
         [ALC268_ACER_ASPIRE_ONE] = {
                 .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 },
                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
@@ -12593,22 +12707,26 @@ static struct alc_config_preset alc268_presets[] = {
                 .hp_nid = 0x03,
                 .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 = alc_sku_unsol_event,
-                .init_hook = alc268_dell_init_hook,
-                .input_mux = &alc268_capture_source,
+                .setup = alc268_dell_setup,
+                .init_hook = alc_inithook,
         },
         [ALC268_ZEPTO] = {
                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
@@ -12625,8 +12743,8 @@ static struct alc_config_preset alc268_presets[] = {
                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
                 .channel_mode = alc268_modes,
                 .input_mux = &alc268_capture_source,
-                .unsol_event = alc268_toshiba_unsol_event,
-                .init_hook = alc268_toshiba_init_hook
+                .setup = alc268_toshiba_setup,
+                .init_hook = alc268_toshiba_automute,
         },
 #ifdef CONFIG_SND_DEBUG
         [ALC268_TEST] = {
@@ -12663,9 +12781,13 @@ static int patch_alc268(struct hda_codec *codec)
                                                   alc268_models,
                                                   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 %s, "
-                       "trying auto-probe from BIOS...\n", codec->chip_name);
+                printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
+                       codec->chip_name);
                 board_config = ALC268_AUTO;
         }
 
@@ -12684,7 +12806,7 @@ static int patch_alc268(struct hda_codec *codec)
         }
 
         if (board_config != ALC268_AUTO)
-                setup_preset(spec, &alc268_presets[board_config]);
+                setup_preset(codec, &alc268_presets[board_config]);
 
         spec->stream_analog_playback = &alc268_pcm_analog_playback;
         spec->stream_analog_capture = &alc268_pcm_analog_capture;
@@ -12721,11 +12843,15 @@ static int patch_alc268(struct hda_codec *codec)
                 int i;
 
                 /* 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;
                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
@@ -12736,6 +12862,8 @@ static int patch_alc268(struct hda_codec *codec)
                 for (i = 0; i < spec->num_adc_nids; i++)
                         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);
         }
 
@@ -12770,22 +12898,6 @@ static hda_nid_t alc269_capsrc_nids[1] = {
  *       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
 #define alc269_capture_source   alc880_lg_lw_capture_source
 
@@ -12848,20 +12960,11 @@ static struct snd_kcontrol_new alc269_lifebook_mixer[] = {
         { }
 };
 
-/* 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),
         { } /* end */
 };
 
@@ -12874,12 +12977,7 @@ static struct snd_kcontrol_new alc269_epc_capture_mixer[] = {
 };
 
 /* 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),
-        { } /* end */
-};
+#define alc269_fujitsu_mixer    alc269_eeepc_mixer
 
 static struct hda_verb alc269_quanta_fl1_verbs[] = {
         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
@@ -12961,16 +13059,6 @@ static void alc269_lifebook_speaker_automute(struct hda_codec *codec)
                         AC_VERB_SET_PROC_COEF, 0x480);
 }
 
-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)
 {
         unsigned int present_laptop;
@@ -12997,10 +13085,14 @@ static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
 static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
                                     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;
+        }
 }
 
 static void alc269_lifebook_unsol_event(struct hda_codec *codec,
@@ -13012,10 +13104,20 @@ static void alc269_lifebook_unsol_event(struct hda_codec *codec,
                 alc269_lifebook_mic_autoswitch(codec);
 }
 
+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);
 }
 
 static void alc269_lifebook_init_hook(struct hda_codec *codec)
@@ -13060,60 +13162,44 @@ static void alc269_speaker_automute(struct hda_codec *codec)
                                 AMP_IN_MUTE(0), bits);
 }
 
-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);
+                break;
+        case ALC880_MIC_EVENT:
+                alc_mic_automute(codec);
+                break;
+        }
 }
 
-static void alc269_eeepc_dmic_inithook(struct hda_codec *codec)
+static void alc269_eeepc_dmic_setup(struct hda_codec *codec)
 {
-        alc269_speaker_automute(codec);
-        alc269_eeepc_dmic_automute(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;
 }
 
-/* unsolicited event for HP jack sensing */
-static void alc269_eeepc_amic_unsol_event(struct hda_codec *codec,
-                                     unsigned int res)
+static void alc269_eeepc_amic_setup(struct hda_codec *codec)
 {
-        if ((res >> 26) == ALC880_HP_EVENT)
-                alc269_speaker_automute(codec);
-
-        if ((res >> 26) == ALC880_MIC_EVENT)
-                alc269_eeepc_amic_automute(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_amic_inithook(struct hda_codec *codec)
+static void alc269_eeepc_inithook(struct hda_codec *codec)
 {
         alc269_speaker_automute(codec);
-        alc269_eeepc_amic_automute(codec);
+        alc_mic_automute(codec);
 }
 
 /*
@@ -13186,89 +13272,10 @@ static struct hda_verb alc269_init_verbs[] = {
         { }
 };
 
-/* 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;
-}
-
-#define alc269_auto_create_analog_input_ctls \
-        alc262_auto_create_analog_input_ctls
+#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
 #define alc269_loopbacks        alc880_loopbacks
@@ -13318,7 +13325,7 @@ static int alc269_parse_auto_config(struct hda_codec *codec)
         err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
         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;
 
@@ -13343,13 +13350,15 @@ static int alc269_parse_auto_config(struct hda_codec *codec)
                 return err;
 
         if (!spec->cap_mixer && !spec->no_analog)
-                set_capture_mixer(spec);
+                set_capture_mixer(codec);
+
+        alc_ssid_check(codec, 0x15, 0x1b, 0x14);
 
         return 1;
 }
 
-#define alc269_auto_init_multi_out      alc882_auto_init_multi_out
-#define alc269_auto_init_hp_out         alc882_auto_init_hp_out
+#define alc269_auto_init_multi_out      alc268_auto_init_multi_out
+#define alc269_auto_init_hp_out         alc268_auto_init_hp_out
 #define alc269_auto_init_analog_input   alc882_auto_init_analog_input
 
 
@@ -13373,7 +13382,8 @@ static const char *alc269_models[ALC269_MODEL_LAST] = {
         [ALC269_ASUS_EEEPC_P703]        = "eeepc-p703",
         [ALC269_ASUS_EEEPC_P901]        = "eeepc-p901",
         [ALC269_FUJITSU]                = "fujitsu",
-        [ALC269_LIFEBOOK]               = "lifebook"
+        [ALC269_LIFEBOOK]               = "lifebook",
+        [ALC269_AUTO]                   = "auto",
 };
 
 static struct snd_pci_quirk alc269_cfg_tbl[] = {
@@ -13417,6 +13427,7 @@ static struct alc_config_preset alc269_presets[] = {
                 .channel_mode = alc269_modes,
                 .input_mux = &alc269_capture_source,
                 .unsol_event = alc269_quanta_fl1_unsol_event,
+                .setup = alc269_quanta_fl1_setup,
                 .init_hook = alc269_quanta_fl1_init_hook,
         },
         [ALC269_ASUS_EEEPC_P703] = {
@@ -13429,9 +13440,9 @@ static struct alc_config_preset alc269_presets[] = {
                 .hp_nid = 0x03,
                 .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] = {
                 .mixers = { alc269_eeepc_mixer },
@@ -13443,9 +13454,9 @@ static struct alc_config_preset alc269_presets[] = {
                 .hp_nid = 0x03,
                 .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] = {
                 .mixers = { alc269_fujitsu_mixer },
@@ -13457,9 +13468,9 @@ static struct alc_config_preset alc269_presets[] = {
                 .hp_nid = 0x03,
                 .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] = {
                 .mixers = { alc269_lifebook_mixer },
@@ -13494,8 +13505,8 @@ static int patch_alc269(struct hda_codec *codec)
                                                   alc269_cfg_tbl);
 
         if (board_config < 0) {
-                printk(KERN_INFO "hda_codec: Unknown model for %s, "
-                       "trying auto-probe from BIOS...\n", codec->chip_name);
+                printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
+                       codec->chip_name);
                 board_config = ALC269_AUTO;
         }
 
@@ -13520,7 +13531,7 @@ static int patch_alc269(struct hda_codec *codec)
         }
 
         if (board_config != ALC269_AUTO)
-                setup_preset(spec, &alc269_presets[board_config]);
+                setup_preset(codec, &alc269_presets[board_config]);
 
         if (codec->subsystem_id == 0x17aa3bf8) {
                 /* Due to a hardware problem on Lenovo Ideadpad, we need to
@@ -13539,9 +13550,11 @@ static int patch_alc269(struct hda_codec *codec)
         spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
         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;
         if (board_config == ALC269_AUTO)
                 spec->init_hook = alc269_auto_init;
@@ -14087,23 +14100,23 @@ static struct hda_verb alc861_auto_init_verbs[] = {
         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
 
-        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {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 */
 
@@ -14175,64 +14188,96 @@ static struct hda_input_mux alc861_capture_source = {
         },
 };
 
+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++) {
                 nid = spec->multiout.dac_nids[i];
                 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;
                 }
@@ -14240,8 +14285,9 @@ static int alc861_auto_create_multi_out_ctls(struct alc_spec *spec,
         return 0;
 }
 
-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;
 
@@ -14249,70 +14295,49 @@ static int alc861_auto_create_hp_ctls(struct alc_spec *spec, hda_nid_t pin)
                 return 0;
 
         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;
 }
 
 /* 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);
+        }
 }
 
 static void alc861_auto_init_multi_out(struct hda_codec *codec)
@@ -14335,12 +14360,13 @@ static void alc861_auto_init_hp_out(struct hda_codec *codec)
         hda_nid_t pin;
 
         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]);
 }
 
 static void alc861_auto_init_analog_input(struct hda_codec *codec)
@@ -14372,16 +14398,16 @@ static int alc861_parse_auto_config(struct hda_codec *codec)
         if (!spec->autocfg.line_outs)
                 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;
 
@@ -14400,7 +14426,7 @@ static int alc861_parse_auto_config(struct hda_codec *codec)
 
         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);
 
@@ -14593,8 +14619,8 @@ static int patch_alc861(struct hda_codec *codec)
                                                   alc861_cfg_tbl);
 
         if (board_config < 0) {
-                printk(KERN_INFO "hda_codec: Unknown model for %s, "
-                       "trying auto-probe from BIOS...\n", codec->chip_name);
+                printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
+                       codec->chip_name);
                 board_config = ALC861_AUTO;
         }
 
@@ -14619,7 +14645,7 @@ static int patch_alc861(struct hda_codec *codec)
         }
 
         if (board_config != ALC861_AUTO)
-                setup_preset(spec, &alc861_presets[board_config]);
+                setup_preset(codec, &alc861_presets[board_config]);
 
         spec->stream_analog_playback = &alc861_pcm_analog_playback;
         spec->stream_analog_capture = &alc861_pcm_analog_capture;
@@ -15022,12 +15048,15 @@ static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
                                  HDA_AMP_MUTE, bits);
 }
 
-static void alc861vd_lenovo_init_hook(struct hda_codec *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);
 }
@@ -15091,13 +15120,12 @@ static struct hda_verb alc861vd_dallas_verbs[] = {
 };
 
 /* toggle speaker-output according to the hp-jack state */
-static void alc861vd_dallas_init_hook(struct hda_codec *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;
-        alc_automute_amp(codec);
 }
 
 #ifdef CONFIG_SND_HDA_POWER_SAVE
@@ -15136,7 +15164,7 @@ static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
         SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
         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),
         SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
@@ -15211,6 +15239,7 @@ static struct alc_config_preset alc861vd_presets[] = {
                 .channel_mode = alc861vd_3stack_2ch_modes,
                 .input_mux = &alc861vd_capture_source,
                 .unsol_event = alc861vd_lenovo_unsol_event,
+                .setup = alc861vd_lenovo_setup,
                 .init_hook = alc861vd_lenovo_init_hook,
         },
         [ALC861VD_DALLAS] = {
@@ -15222,7 +15251,8 @@ static struct alc_config_preset alc861vd_presets[] = {
                 .channel_mode = alc861vd_3stack_2ch_modes,
                 .input_mux = &alc861vd_dallas_capture_source,
                 .unsol_event = alc_automute_amp_unsol_event,
-                .init_hook = alc861vd_dallas_init_hook,
+                .setup = alc861vd_dallas_setup,
+                .init_hook = alc_automute_amp,
         },
         [ALC861VD_HP] = {
                 .mixers = { alc861vd_hp_mixer },
@@ -15234,7 +15264,8 @@ static struct alc_config_preset alc861vd_presets[] = {
                 .channel_mode = alc861vd_3stack_2ch_modes,
                 .input_mux = &alc861vd_hp_capture_source,
                 .unsol_event = alc_automute_amp_unsol_event,
-                .init_hook = alc861vd_dallas_init_hook,
+                .setup = alc861vd_dallas_setup,
+                .init_hook = alc_automute_amp,
         },
         [ALC660VD_ASUS_V1S] = {
                 .mixers = { alc861vd_lenovo_mixer },
@@ -15249,6 +15280,7 @@ static struct alc_config_preset alc861vd_presets[] = {
                 .channel_mode = alc861vd_3stack_2ch_modes,
                 .input_mux = &alc861vd_capture_source,
                 .unsol_event = alc861vd_lenovo_unsol_event,
+                .setup = alc861vd_lenovo_setup,
                 .init_hook = alc861vd_lenovo_init_hook,
         },
 };
@@ -15256,6 +15288,13 @@ static struct alc_config_preset alc861vd_presets[] = {
 /*
  * 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)
 {
@@ -15290,7 +15329,6 @@ static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
 }
 
-#define alc861vd_is_input_pin(nid)      alc880_is_input_pin(nid)
 #define ALC861VD_PIN_CD_NID             ALC880_PIN_CD_NID
 
 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
@@ -15300,7 +15338,7 @@ static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
 
         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 &&
                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
@@ -15364,13 +15402,25 @@ static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
                         if (err < 0)
                                 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,
                                                               HDA_OUTPUT));
                         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,
                                                               HDA_INPUT));
@@ -15463,7 +15513,7 @@ static int alc861vd_parse_auto_config(struct hda_codec *codec)
                                              "Headphone");
         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;
 
@@ -15517,8 +15567,8 @@ static int patch_alc861vd(struct hda_codec *codec)
                                                   alc861vd_cfg_tbl);
 
         if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
-                printk(KERN_INFO "hda_codec: Unknown model for %s, "
-                       "trying auto-probe from BIOS...\n", codec->chip_name);
+                printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
+                       codec->chip_name);
                 board_config = ALC861VD_AUTO;
         }
 
@@ -15543,7 +15593,7 @@ static int patch_alc861vd(struct hda_codec *codec)
         }
 
         if (board_config != ALC861VD_AUTO)
-                setup_preset(spec, &alc861vd_presets[board_config]);
+                setup_preset(codec, &alc861vd_presets[board_config]);
 
         if (codec->vendor_id == 0x10ec0660) {
                 /* always turn on EAPD */
@@ -15556,11 +15606,14 @@ static int patch_alc861vd(struct hda_codec *codec)
         spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
         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;
+        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(spec);
+        set_capture_mixer(codec);
         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
 
         spec->vmaster_nid = 0x02;
@@ -15601,9 +15654,9 @@ static hda_nid_t alc272_dac_nids[2] = {
         0x02, 0x03
 };
 
-static hda_nid_t alc662_adc_nids[1] = {
+static hda_nid_t alc662_adc_nids[2] = {
         /* ADC1-2 */
-        0x09,
+        0x09, 0x08
 };
 
 static hda_nid_t alc272_adc_nids[1] = {
@@ -15611,7 +15664,7 @@ static hda_nid_t alc272_adc_nids[1] = {
         0x08,
 };
 
-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 };
 
 
@@ -15635,14 +15688,6 @@ static struct hda_input_mux alc662_lenovo_101e_capture_source = {
         },
 };
 
-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,
         .items = {
@@ -15652,23 +15697,7 @@ static struct hda_input_mux alc663_capture_source = {
         },
 };
 
-static struct hda_input_mux alc663_m51va_capture_source = {
-        .num_items = 2,
-        .items = {
-                { "Ext-Mic", 0x0 },
-                { "D-Mic", 0x9 },
-        },
-};
-
-#if 1 /* set to 0 for testing other input sources below */
-static struct hda_input_mux alc272_nc10_capture_source = {
-        .num_items = 2,
-        .items = {
-                { "Autoselect Mic", 0x0 },
-                { "Internal Mic", 0x1 },
-        },
-};
-#else
+#if 0 /* set to 1 for testing other input sources below */
 static struct hda_input_mux alc272_nc10_capture_source = {
         .num_items = 16,
         .items = {
@@ -16337,47 +16366,44 @@ static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
                 alc662_lenovo_101e_ispeaker_automute(codec);
 }
 
-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_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_init_hook(codec);
-        alc662_eeepc_mic_automute(codec);
+        alc262_hippo_automute(codec);
+        alc_mic_automute(codec);
 }
 
-static void alc662_eeepc_ep20_inithook(struct hda_codec *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;
-        alc262_hippo_master_update(codec);
 }
 
+#define alc662_eeepc_ep20_inithook      alc262_hippo_master_update
+
 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
 {
         unsigned int present;
@@ -16488,23 +16514,6 @@ static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
         }
 }
 
-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)
 {
@@ -16513,36 +16522,32 @@ static void alc663_m51va_unsol_event(struct hda_codec *codec,
                 alc663_m51va_speaker_automute(codec);
                 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;
-        }
-}
+#define alc663_mode1_unsol_event        alc663_m51va_unsol_event
+#define alc663_mode1_setup              alc663_m51va_setup
+#define alc663_mode1_inithook           alc663_m51va_inithook
 
-static void alc663_mode1_inithook(struct hda_codec *codec)
-{
-        alc663_m51va_speaker_automute(codec);
-        alc662_eeepc_mic_automute(codec);
-}
 /* ***************** Mode2 ******************************/
 static void alc662_mode2_unsol_event(struct hda_codec *codec,
                                            unsigned int res)
@@ -16552,15 +16557,17 @@ static void alc662_mode2_unsol_event(struct hda_codec *codec,
                 alc662_f5z_speaker_automute(codec);
                 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 ******************************/
 static void alc663_mode3_unsol_event(struct hda_codec *codec,
@@ -16571,15 +16578,17 @@ static void alc663_mode3_unsol_event(struct hda_codec *codec,
                 alc663_two_hp_m1_speaker_automute(codec);
                 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 ******************************/
 static void alc663_mode4_unsol_event(struct hda_codec *codec,
@@ -16590,15 +16599,17 @@ static void alc663_mode4_unsol_event(struct hda_codec *codec,
                 alc663_21jd_two_speaker_automute(codec);
                 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 ******************************/
 static void alc663_mode5_unsol_event(struct hda_codec *codec,
@@ -16609,15 +16620,17 @@ static void alc663_mode5_unsol_event(struct hda_codec *codec,
                 alc663_15jd_two_speaker_automute(codec);
                 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 ******************************/
 static void alc663_mode6_unsol_event(struct hda_codec *codec,
@@ -16628,15 +16641,17 @@ static void alc663_mode6_unsol_event(struct hda_codec *codec,
                 alc663_two_hp_m2_speaker_automute(codec);
                 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);
 }
 
 static void alc663_g71v_hp_automute(struct hda_codec *codec)
@@ -16678,16 +16693,18 @@ static void alc663_g71v_unsol_event(struct hda_codec *codec,
                 alc663_g71v_front_automute(codec);
                 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);
 }
 
 static void alc663_g50v_unsol_event(struct hda_codec *codec,
@@ -16698,15 +16715,17 @@ static void alc663_g50v_unsol_event(struct hda_codec *codec,
                 alc663_m51va_speaker_automute(codec);
                 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);
+        alc_mic_automute(codec);
 }
 
 static struct snd_kcontrol_new alc662_ecs_mixer[] = {
@@ -16910,8 +16929,8 @@ static struct alc_config_preset alc662_presets[] = {
                 .dac_nids = alc662_dac_nids,
                 .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,
         },
         [ALC662_ASUS_EEEPC_EP20] = {
@@ -16925,6 +16944,7 @@ static struct alc_config_preset alc662_presets[] = {
                 .channel_mode = alc662_3ST_6ch_modes,
                 .input_mux = &alc662_lenovo_101e_capture_source,
                 .unsol_event = alc662_eeepc_unsol_event,
+                .setup = alc662_eeepc_ep20_setup,
                 .init_hook = alc662_eeepc_ep20_inithook,
         },
         [ALC662_ECS] = {
@@ -16935,8 +16955,8 @@ static struct alc_config_preset alc662_presets[] = {
                 .dac_nids = alc662_dac_nids,
                 .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,
         },
         [ALC663_ASUS_M51VA] = {
@@ -16947,8 +16967,8 @@ static struct alc_config_preset alc662_presets[] = {
                 .dig_out_nid = ALC662_DIGOUT_NID,
                 .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,
         },
         [ALC663_ASUS_G71V] = {
@@ -16959,8 +16979,8 @@ static struct alc_config_preset alc662_presets[] = {
                 .dig_out_nid = ALC662_DIGOUT_NID,
                 .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,
         },
         [ALC663_ASUS_H13] = {
@@ -16970,7 +16990,6 @@ static struct alc_config_preset alc662_presets[] = {
                 .dac_nids = alc662_dac_nids,
                 .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,
         },
@@ -16984,6 +17003,7 @@ static struct alc_config_preset alc662_presets[] = {
                 .channel_mode = alc662_3ST_6ch_modes,
                 .input_mux = &alc663_capture_source,
                 .unsol_event = alc663_g50v_unsol_event,
+                .setup = alc663_g50v_setup,
                 .init_hook = alc663_g50v_inithook,
         },
         [ALC663_ASUS_MODE1] = {
@@ -16997,8 +17017,8 @@ static struct alc_config_preset alc662_presets[] = {
                 .dig_out_nid = ALC662_DIGOUT_NID,
                 .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,
         },
         [ALC662_ASUS_MODE2] = {
@@ -17011,8 +17031,8 @@ static struct alc_config_preset alc662_presets[] = {
                 .dig_out_nid = ALC662_DIGOUT_NID,
                 .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,
         },
         [ALC663_ASUS_MODE3] = {
@@ -17026,8 +17046,8 @@ static struct alc_config_preset alc662_presets[] = {
                 .dig_out_nid = ALC662_DIGOUT_NID,
                 .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,
         },
         [ALC663_ASUS_MODE4] = {
@@ -17041,8 +17061,8 @@ static struct alc_config_preset alc662_presets[] = {
                 .dig_out_nid = ALC662_DIGOUT_NID,
                 .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,
         },
         [ALC663_ASUS_MODE5] = {
@@ -17056,8 +17076,8 @@ static struct alc_config_preset alc662_presets[] = {
                 .dig_out_nid = ALC662_DIGOUT_NID,
                 .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,
         },
         [ALC663_ASUS_MODE6] = {
@@ -17071,8 +17091,8 @@ static struct alc_config_preset alc662_presets[] = {
                 .dig_out_nid = ALC662_DIGOUT_NID,
                 .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,
         },
         [ALC272_DELL] = {
@@ -17086,8 +17106,8 @@ static struct alc_config_preset alc662_presets[] = {
                 .num_adc_nids = ARRAY_SIZE(alc272_adc_nids),
                 .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,
         },
         [ALC272_DELL_ZM1] = {
@@ -17098,11 +17118,11 @@ static struct alc_config_preset alc662_presets[] = {
                 .dac_nids = alc662_dac_nids,
                 .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] = {
@@ -17113,8 +17133,9 @@ static struct alc_config_preset alc662_presets[] = {
                 .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,
+                /*.input_mux = &alc272_nc10_capture_source,*/
                 .unsol_event = alc663_mode4_unsol_event,
+                .setup = alc663_mode4_setup,
                 .init_hook = alc663_mode4_inithook,
         },
 };
@@ -17166,13 +17187,25 @@ static int alc662_auto_create_multi_out_ctls(struct alc_spec *spec,
                         if (err < 0)
                                 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,
                                                               HDA_OUTPUT));
                         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),
                                                     3, 0, HDA_INPUT));
@@ -17234,62 +17267,9 @@ static int alc662_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
         return 0;
 }
 
-/* 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,
                                               hda_nid_t nid, int pin_type,
@@ -17343,7 +17323,7 @@ static void alc662_auto_init_analog_input(struct hda_codec *codec)
 
         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 &&
                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
@@ -17384,7 +17364,7 @@ static int alc662_parse_auto_config(struct hda_codec *codec)
                                            "Headphone");
         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;
 
@@ -17441,8 +17421,8 @@ static int patch_alc662(struct hda_codec *codec)
                                                   alc662_models,
                                                   alc662_cfg_tbl);
         if (board_config < 0) {
-                printk(KERN_INFO "hda_codec: Unknown model for %s, "
-                       "trying auto-probe from BIOS...\n", codec->chip_name);
+                printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
+                       codec->chip_name);
                 board_config = ALC662_AUTO;
         }
 
@@ -17467,7 +17447,7 @@ static int patch_alc662(struct hda_codec *codec)
         }
 
         if (board_config != ALC662_AUTO)
-                setup_preset(spec, &alc662_presets[board_config]);
+                setup_preset(codec, &alc662_presets[board_config]);
 
         spec->stream_analog_playback = &alc662_pcm_analog_playback;
         spec->stream_analog_capture = &alc662_pcm_analog_capture;
@@ -17475,12 +17455,15 @@ static int patch_alc662(struct hda_codec *codec)
         spec->stream_digital_playback = &alc662_pcm_digital_playback;
         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;
+        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);
         else
@@ -17516,23 +17499,23 @@ static struct hda_codec_preset snd_hda_preset_realtek[] = {
         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
         { .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 },
         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
         { .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 },
         {} /* terminator */
 };
 
diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c
index 14f3c3e0f62d..826137ec3002 100644
--- a/sound/pci/hda/patch_sigmatel.c
+++ b/sound/pci/hda/patch_sigmatel.c
@@ -40,6 +40,8 @@ enum {
         STAC_INSERT_EVENT,
         STAC_PWR_EVENT,
         STAC_HP_EVENT,
+        STAC_LO_EVENT,
+        STAC_MIC_EVENT,
 };
 
 enum {
@@ -76,10 +78,12 @@ enum {
         STAC_92HD73XX_AUTO,
         STAC_92HD73XX_NO_JD, /* no jack-detection */
         STAC_92HD73XX_REF,
+        STAC_92HD73XX_INTEL,
         STAC_DELL_M6_AMIC,
         STAC_DELL_M6_DMIC,
         STAC_DELL_M6_BOTH,
         STAC_DELL_EQ,
+        STAC_ALIENWARE_M17X,
         STAC_92HD73XX_MODELS
 };
 
@@ -176,6 +180,12 @@ struct sigmatel_jack {
         struct snd_jack *jack;
 };
 
+struct sigmatel_mic_route {
+        hda_nid_t pin;
+        unsigned char mux_idx;
+        unsigned char dmux_idx;
+};
+
 struct sigmatel_spec {
         struct snd_kcontrol_new *mixers[4];
         unsigned int num_mixers;
@@ -187,6 +197,7 @@ struct sigmatel_spec {
         unsigned int hp_detect: 1;
         unsigned int spdif_mute: 1;
         unsigned int check_volume_offset:1;
+        unsigned int auto_mic:1;
 
         /* gpio lines */
         unsigned int eapd_mask;
@@ -218,7 +229,6 @@ struct sigmatel_spec {
 
         /* playback */
         struct hda_input_mux *mono_mux;
-        struct hda_input_mux *amp_mux;
         unsigned int cur_mmux;
         struct hda_multi_out multiout;
         hda_nid_t dac_nids[5];
@@ -238,6 +248,15 @@ struct sigmatel_spec {
         unsigned int num_dmuxes;
         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;
 
         hda_nid_t dig_in_nid;
@@ -262,7 +281,6 @@ struct sigmatel_spec {
         unsigned int cur_smux[2];
         unsigned int cur_amux;
         hda_nid_t *amp_nids;
-        unsigned int num_amps;
         unsigned int powerdown_adcs;
 
         /* i/o switches */
@@ -281,7 +299,6 @@ struct sigmatel_spec {
         struct hda_input_mux private_dimux;
         struct hda_input_mux private_imux;
         struct hda_input_mux private_smux;
-        struct hda_input_mux private_amp_mux;
         struct hda_input_mux private_mono_mux;
 };
 
@@ -310,11 +327,6 @@ static hda_nid_t stac92hd73xx_adc_nids[2] = {
         0x1a, 0x1b
 };
 
-#define DELL_M6_AMP 2
-static hda_nid_t stac92hd73xx_amp_nids[3] = {
-        0x0b, 0x0c, 0x0e
-};
-
 #define STAC92HD73XX_NUM_DMICS  2
 static hda_nid_t stac92hd73xx_dmic_nids[STAC92HD73XX_NUM_DMICS + 1] = {
         0x13, 0x14, 0
@@ -322,8 +334,8 @@ static hda_nid_t stac92hd73xx_dmic_nids[STAC92HD73XX_NUM_DMICS + 1] = {
 
 #define STAC92HD73_DAC_COUNT 5
 
-static hda_nid_t stac92hd73xx_mux_nids[4] = {
-        0x28, 0x29, 0x2a, 0x2b,
+static hda_nid_t stac92hd73xx_mux_nids[2] = {
+        0x20, 0x21,
 };
 
 static hda_nid_t stac92hd73xx_dmux_nids[2] = {
@@ -334,14 +346,16 @@ static hda_nid_t stac92hd73xx_smux_nids[2] = {
         0x22, 0x23,
 };
 
-#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,
 };
 
@@ -361,9 +375,12 @@ static unsigned int stac92hd83xxx_pwr_mapping[4] = {
         0x03, 0x0c, 0x20, 0x40,
 };
 
-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] = {
         0x0a, 0x0d, 0x0f
@@ -394,6 +411,13 @@ static hda_nid_t stac92hd71bxx_slave_dig_outs[2] = {
         0x22, 0
 };
 
+#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,
 };
@@ -415,6 +439,13 @@ static hda_nid_t stac925x_dmux_nids[1] = {
         0x14,
 };
 
+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,
 };
@@ -423,6 +454,13 @@ static hda_nid_t stac922x_mux_nids[2] = {
         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] = {
         0x1f, 0,
 };
@@ -452,6 +490,18 @@ static hda_nid_t stac927x_dmic_nids[STAC927X_NUM_DMICS + 1] = {
         0x13, 0x14, 0
 };
 
+#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",
         "Analog Mux 2", "Analog Mux 3"
@@ -478,6 +528,16 @@ 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),
+};
+
 static hda_nid_t stac9200_pin_nids[8] = {
         0x08, 0x09, 0x0d, 0x0e, 
         0x0f, 0x10, 0x11, 0x12,
@@ -528,34 +588,6 @@ static hda_nid_t stac9205_pin_nids[12] = {
         0x21, 0x22,
 };
 
-#define stac92xx_amp_volume_info snd_hda_mixer_amp_volume_info
-
-static int stac92xx_amp_volume_get(struct snd_kcontrol *kcontrol,
-                                 struct snd_ctl_elem_value *ucontrol)
-{
-        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-        struct sigmatel_spec *spec = codec->spec;
-        hda_nid_t nid = spec->amp_nids[spec->cur_amux];
-
-        kcontrol->private_value ^= get_amp_nid(kcontrol);
-        kcontrol->private_value |= nid;
-
-        return snd_hda_mixer_amp_volume_get(kcontrol, ucontrol);
-}
-
-static int stac92xx_amp_volume_put(struct snd_kcontrol *kcontrol,
-                                 struct snd_ctl_elem_value *ucontrol)
-{
-        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-        struct sigmatel_spec *spec = codec->spec;
-        hda_nid_t nid = spec->amp_nids[spec->cur_amux];
-
-        kcontrol->private_value ^= get_amp_nid(kcontrol);
-        kcontrol->private_value |= nid;
-
-        return snd_hda_mixer_amp_volume_put(kcontrol, ucontrol);
-}
-
 static int stac92xx_dmux_enum_info(struct snd_kcontrol *kcontrol,
                                    struct snd_ctl_elem_info *uinfo)
 {
@@ -692,9 +724,35 @@ static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_e
         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
         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;
 }
 
 static int stac92xx_mono_mux_enum_info(struct snd_kcontrol *kcontrol,
@@ -725,41 +783,6 @@ static int stac92xx_mono_mux_enum_put(struct snd_kcontrol *kcontrol,
                                      spec->mono_nid, &spec->cur_mmux);
 }
 
-static int stac92xx_amp_mux_enum_info(struct snd_kcontrol *kcontrol,
-        struct snd_ctl_elem_info *uinfo)
-{
-        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-        struct sigmatel_spec *spec = codec->spec;
-        return snd_hda_input_mux_info(spec->amp_mux, uinfo);
-}
-
-static int stac92xx_amp_mux_enum_get(struct snd_kcontrol *kcontrol,
-        struct snd_ctl_elem_value *ucontrol)
-{
-        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-        struct sigmatel_spec *spec = codec->spec;
-
-        ucontrol->value.enumerated.item[0] = spec->cur_amux;
-        return 0;
-}
-
-static int stac92xx_amp_mux_enum_put(struct snd_kcontrol *kcontrol,
-        struct snd_ctl_elem_value *ucontrol)
-{
-        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-        struct sigmatel_spec *spec = codec->spec;
-        struct snd_kcontrol *ctl =
-                snd_hda_find_mixer_ctl(codec, "Amp Capture Volume");
-        if (!ctl)
-                return -EINVAL;
-
-        snd_ctl_notify(codec->bus->card, SNDRV_CTL_EVENT_MASK_VALUE |
-                SNDRV_CTL_EVENT_MASK_INFO, &ctl->id);
-
-        return snd_hda_input_mux_put(codec, spec->amp_mux, ucontrol,
-                                     0, &spec->cur_amux);
-}
-
 #define stac92xx_aloopback_info snd_ctl_boolean_mono_info
 
 static int stac92xx_aloopback_get(struct snd_kcontrol *kcontrol,
@@ -827,92 +850,20 @@ static struct hda_verb stac9200_eapd_init[] = {
         {}
 };
 
-static struct hda_verb stac92hd73xx_6ch_core_init[] = {
-        /* set master volume and direct control */
-        { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
-        /* setup adcs to point to mixer */
-        { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
-        { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
-        { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-        { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-        { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-        /* setup import muxs */
-        { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
-        { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
-        { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
-        { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00},
-        {}
-};
-
 static struct hda_verb dell_eq_core_init[] = {
         /* set master volume to max value without distortion
          * and direct control */
         { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xec},
-        /* setup adcs to point to mixer */
-        { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
-        { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
-        /* setup import muxs */
-        { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
-        { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
-        { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
-        { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00},
-        {}
-};
-
-static struct hda_verb dell_m6_core_init[] = {
-        { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
-        /* setup adcs to point to mixer */
-        { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
-        { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
-        /* setup import muxs */
-        { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
-        { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
-        { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
-        { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00},
-        {}
-};
-
-static struct hda_verb stac92hd73xx_8ch_core_init[] = {
-        /* set master volume and direct control */
-        { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
-        /* setup adcs to point to mixer */
-        { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
-        { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
-        { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-        { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-        { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-        /* setup import muxs */
-        { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
-        { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
-        { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
-        { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x03},
         {}
 };
 
-static struct hda_verb stac92hd73xx_10ch_core_init[] = {
+static struct hda_verb stac92hd73xx_core_init[] = {
         /* set master volume and direct control */
         { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
-        /* dac3 is connected to import3 mux */
-        { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0xb07f},
-        /* setup adcs to point to mixer */
-        { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
-        { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
-        { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-        { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-        { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
-        /* setup import muxs */
-        { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
-        { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
-        { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
-        { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x03},
         {}
 };
 
 static struct hda_verb stac92hd83xxx_core_init[] = {
-        { 0xa, AC_VERB_SET_CONNECT_SEL, 0x1},
-        { 0xb, AC_VERB_SET_CONNECT_SEL, 0x1},
-        { 0xd, AC_VERB_SET_CONNECT_SEL, 0x0},
-
         /* power state controls amps */
         { 0x01, AC_VERB_SET_EAPD, 1 << 2},
         {}
@@ -924,19 +875,6 @@ static struct hda_verb stac92hd71bxx_core_init[] = {
         {}
 };
 
-#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},
-        {}
-};
-
 static struct hda_verb stac92hd71bxx_unmute_core_init[] = {
         /* unmute right and left channels for nodes 0x0f, 0xa, 0x0d */
         { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
@@ -995,31 +933,6 @@ static struct hda_verb stac9205_core_init[] = {
                 .put = stac92xx_mono_mux_enum_put, \
         }
 
-#define STAC_AMP_MUX \
-        { \
-                .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
-                .name = "Amp Selector Capture Switch", \
-                .count = 1, \
-                .info = stac92xx_amp_mux_enum_info, \
-                .get = stac92xx_amp_mux_enum_get, \
-                .put = stac92xx_amp_mux_enum_put, \
-        }
-
-#define STAC_AMP_VOL(xname, nid, chs, idx, dir) \
-        { \
-                .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
-                .name = xname, \
-                .index = 0, \
-                .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
-                        SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
-                        SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK, \
-                .info = stac92xx_amp_volume_info, \
-                .get = stac92xx_amp_volume_get, \
-                .put = stac92xx_amp_volume_put, \
-                .tlv = { .c = snd_hda_mixer_amp_tlv }, \
-                .private_value = HDA_COMPOSE_AMP_VAL(nid, chs, idx, dir) \
-        }
-
 #define STAC_ANALOG_LOOPBACK(verb_read, verb_write, cnt) \
         { \
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
@@ -1050,34 +963,6 @@ static struct snd_kcontrol_new stac9200_mixer[] = {
         { } /* end */
 };
 
-#define DELL_M6_MIXER 6
-static struct snd_kcontrol_new stac92hd73xx_6ch_mixer[] = {
-        /* start of config #1 */
-        HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
-        HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
-
-        HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
-        HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
-
-        HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
-        HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
-
-        /* start of config #2 */
-        HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
-        HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
-
-        HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
-        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),
-
-        { } /* end */
-};
-
 static struct snd_kcontrol_new stac92hd73xx_6ch_loopback[] = {
         STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 3),
         {}
@@ -1093,134 +978,14 @@ static struct snd_kcontrol_new stac92hd73xx_10ch_loopback[] = {
         {}
 };
 
-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),
-
-        HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
-        HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
-
-        HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
-        HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
-
-        HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
-        HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
-
-        HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
-        HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
-        { } /* end */
-};
-
-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),
-
-        HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
-        HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
-
-        HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
-        HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
-
-        HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
-        HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
-
-        HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
-        HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
-        { } /* end */
-};
-
-
-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),
-        */
-        { } /* 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),
-        { } /* 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),
-        { } /* end */
-};
-
 static struct snd_kcontrol_new stac925x_mixer[] = {
         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),
-        { } /* 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),
         { } /* end */
 };
 
@@ -1229,29 +994,6 @@ static struct snd_kcontrol_new stac9205_loopback[] = {
         {}
 };
 
-/* 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),
-        { } /* 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),
-        { } /* end */
-};
-
 static struct snd_kcontrol_new stac927x_loopback[] = {
         STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB, 1),
         {}
@@ -1309,16 +1051,19 @@ static int stac92xx_build_controls(struct hda_codec *codec)
         int err;
         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++) {
                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
                 if (err < 0)
                         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,
                                   snd_ctl_new1(&stac_dmux_mixer, codec));
@@ -1590,8 +1335,6 @@ static struct snd_pci_quirk stac9200_cfg_tbl[] = {
         /* SigmaTel reference board */
         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
                       "DFI LanParty", STAC_REF),
-        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xfb30,
-                      "SigmaTel",STAC_9205_REF),
         SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
                       "DFI LanParty", STAC_REF),
         /* Dell laptops have BIOS problem */
@@ -1767,22 +1510,32 @@ static unsigned int dell_m6_pin_configs[13] = {
         0x4f0000f0,
 };
 
+static unsigned int alienware_m17x_pin_configs[13] = {
+        0x0321101f, 0x0321101f, 0x03a11020, 0x03014020,
+        0x90170110, 0x4f0000f0, 0x4f0000f0, 0x4f0000f0,
+        0x4f0000f0, 0x90a60160, 0x4f0000f0, 0x4f0000f0,
+        0x904601b0,
+};
+
 static unsigned int *stac92hd73xx_brd_tbl[STAC_92HD73XX_MODELS] = {
         [STAC_92HD73XX_REF]     = ref92hd73xx_pin_configs,
         [STAC_DELL_M6_AMIC]     = dell_m6_pin_configs,
         [STAC_DELL_M6_DMIC]     = dell_m6_pin_configs,
         [STAC_DELL_M6_BOTH]     = dell_m6_pin_configs,
         [STAC_DELL_EQ]  = dell_m6_pin_configs,
+        [STAC_ALIENWARE_M17X]   = alienware_m17x_pin_configs,
 };
 
 static const char *stac92hd73xx_models[STAC_92HD73XX_MODELS] = {
         [STAC_92HD73XX_AUTO] = "auto",
         [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",
         [STAC_DELL_M6_BOTH] = "dell-m6",
         [STAC_DELL_EQ] = "dell-eq",
+        [STAC_ALIENWARE_M17X] = "alienware",
 };
 
 static struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = {
@@ -1791,6 +1544,10 @@ static struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = {
                                 "DFI LanParty", STAC_92HD73XX_REF),
         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),
         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0255,
@@ -1811,6 +1568,14 @@ static struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = {
                                 "Dell Studio 1537", STAC_DELL_M6_DMIC),
         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),
+        {} /* terminator */
+};
+
+static struct snd_pci_quirk stac92hd73xx_codec_id_cfg_tbl[] = {
+        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02a1,
+                      "Alienware M17x", STAC_ALIENWARE_M17X),
         {} /* terminator */
 };
 
@@ -1821,8 +1586,8 @@ static unsigned int ref92hd83xxx_pin_configs[10] = {
 };
 
 static unsigned int dell_s14_pin_configs[10] = {
-        0x02214030, 0x02211010, 0x02a19020, 0x01014050,
-        0x40f000f0, 0x01819040, 0x40f000f0, 0x90a60160,
+        0x0221403f, 0x0221101f, 0x02a19020, 0x90170110,
+        0x40f000f0, 0x40f000f0, 0x40f000f0, 0x90a60160,
         0x40f000f0, 0x40f000f0,
 };
 
@@ -1921,6 +1686,10 @@ static struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = {
                       "HP mini 1000", STAC_HP_M4),
         SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361b,
                       "HP HDX", STAC_HP_HDX),  /* HDX16 */
+        SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3620,
+                      "HP dv6", STAC_HP_DV5),
+        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),
         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0234,
@@ -2266,7 +2035,7 @@ static struct snd_pci_quirk stac927x_cfg_tbl[] = {
         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01f3, "Dell Inspiron 1420", STAC_DELL_BIOS),
         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),
         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x02ff, "Dell     ", STAC_DELL_BIOS),
@@ -2344,6 +2113,8 @@ static struct snd_pci_quirk stac9205_cfg_tbl[] = {
         /* SigmaTel reference board */
         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),
         /* Dell */
@@ -2378,6 +2149,7 @@ static struct snd_pci_quirk stac9205_cfg_tbl[] = {
         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0228,
                       "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),
         {} /* terminator */
 };
@@ -2633,8 +2405,7 @@ static int stac92xx_hp_switch_get(struct snd_kcontrol *kcontrol,
         return 0;
 }
 
-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,
                         struct snd_ctl_elem_value *ucontrol)
@@ -2648,7 +2419,7 @@ static int stac92xx_hp_switch_put(struct snd_kcontrol *kcontrol,
         /* check to be sure that the ports are upto date with
          * switch changes
          */
-        stac_issue_unsol_event(codec, nid, STAC_HP_EVENT);
+        stac_issue_unsol_event(codec, nid);
 
         return 1;
 }
@@ -2781,7 +2552,7 @@ static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_
          * appropriately according to the pin direction
          */
         if (spec->hp_detect)
-                stac_issue_unsol_event(codec, nid, STAC_HP_EVENT);
+                stac_issue_unsol_event(codec, nid);
 
         return 1;
 }
@@ -2850,8 +2621,6 @@ enum {
         STAC_CTL_WIDGET_VOL,
         STAC_CTL_WIDGET_MUTE,
         STAC_CTL_WIDGET_MONO_MUX,
-        STAC_CTL_WIDGET_AMP_MUX,
-        STAC_CTL_WIDGET_AMP_VOL,
         STAC_CTL_WIDGET_HP_SWITCH,
         STAC_CTL_WIDGET_IO_SWITCH,
         STAC_CTL_WIDGET_CLFE_SWITCH,
@@ -2862,8 +2631,6 @@ static struct snd_kcontrol_new stac92xx_control_templates[] = {
         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
         HDA_CODEC_MUTE(NULL, 0, 0, 0),
         STAC_MONO_MUX,
-        STAC_AMP_MUX,
-        STAC_AMP_VOL(NULL, 0, 0, 0, 0),
         STAC_CODEC_HP_SWITCH(NULL),
         STAC_CODEC_IO_SWITCH(NULL, 0),
         STAC_CODEC_CLFE_SWITCH(NULL, 0),
@@ -2964,6 +2731,8 @@ static int stac92xx_add_input_source(struct sigmatel_spec *spec)
         struct snd_kcontrol_new *knew;
         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 */
         knew = stac_control_new(spec, &stac_input_src_temp,
@@ -3057,7 +2826,7 @@ static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid)
                                            HDA_MAX_CONNECTIONS);
         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))
                         continue;
@@ -3316,6 +3085,21 @@ static int create_multi_out_ctls(struct hda_codec *codec, int num_outs,
         return 0;
 }
 
+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,
                                                const struct auto_pin_cfg *cfg)
@@ -3389,7 +3173,7 @@ static int stac92xx_auto_create_mono_output_ctls(struct hda_codec *codec)
                                 spec->mono_nid,
                                 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;
 
         for (i = 0; i < num_cons; i++) {
@@ -3403,37 +3187,6 @@ static int stac92xx_auto_create_mono_output_ctls(struct hda_codec *codec)
                                 "Mono Mux", spec->mono_nid);
 }
 
-/* labels for amp mux outputs */
-static const char *stac92xx_amp_labels[3] = {
-        "Front Microphone", "Microphone", "Line In",
-};
-
-/* create amp out controls mux on capable codecs */
-static int stac92xx_auto_create_amp_output_ctls(struct hda_codec *codec)
-{
-        struct sigmatel_spec *spec = codec->spec;
-        struct hda_input_mux *amp_mux = &spec->private_amp_mux;
-        int i, err;
-
-        for (i = 0; i < spec->num_amps; i++) {
-                amp_mux->items[amp_mux->num_items].label =
-                                        stac92xx_amp_labels[i];
-                amp_mux->items[amp_mux->num_items].index = i;
-                amp_mux->num_items++;
-        }
-
-        if (spec->num_amps > 1) {
-                err = stac92xx_add_control(spec, STAC_CTL_WIDGET_AMP_MUX,
-                        "Amp Selector Capture Switch", 0);
-                if (err < 0)
-                        return err;
-        }
-        return stac92xx_add_control(spec, STAC_CTL_WIDGET_AMP_VOL,
-                "Amp Capture Volume",
-                HDA_COMPOSE_AMP_VAL(spec->amp_nids[0], 3, 0, HDA_INPUT));
-}
-
-
 /* create PC beep volume controls */
 static int stac92xx_auto_create_beep_ctls(struct hda_codec *codec,
                                                 hda_nid_t nid)
@@ -3502,19 +3255,33 @@ static int stac92xx_beep_switch_ctl(struct hda_codec *codec)
 static int stac92xx_auto_create_mux_input_ctls(struct hda_codec *codec)
 {
         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))
+                        continue;
 
-                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;
+                /* 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;
 };
@@ -3535,7 +3302,7 @@ static int stac92xx_auto_create_spdif_mux_ctls(struct hda_codec *codec)
                                 spec->smux_nids[0],
                                 con_lst,
                                 HDA_MAX_NUM_INPUTS);
-        if (!num_cons)
+        if (num_cons <= 0)
                 return -EINVAL;
 
         if (!labels)
@@ -3556,101 +3323,231 @@ static const char *stac92xx_dmic_labels[5] = {
         "Digital Mic 3", "Digital Mic 4"
 };
 
+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) */
+/* return 1 if the volume control is created */
+static int create_elem_capture_vol(struct hda_codec *codec, hda_nid_t nid,
+                                   const char *label, int direction)
+{
+        unsigned int caps, nums;
+        char name[32];
+        int err;
+
+        if (direction == HDA_OUTPUT)
+                caps = AC_WCAP_OUT_AMP;
+        else
+                caps = AC_WCAP_IN_AMP;
+        if (!(get_wcaps(codec, nid) & caps))
+                return 0;
+        caps = query_amp_caps(codec, nid, direction);
+        nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
+        if (!nums)
+                return 0;
+        snprintf(name, sizeof(name), "%s Capture Volume", label);
+        err = stac92xx_add_control(codec->spec, STAC_CTL_WIDGET_VOL, name,
+                                    HDA_COMPOSE_AMP_VAL(nid, 3, 0, direction));
+        if (err < 0)
+                return err;
+        return 1;
+}
+
 /* create playback/capture controls for input pins on dmic capable codecs */
 static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
                                                 const struct auto_pin_cfg *cfg)
 {
         struct sigmatel_spec *spec = codec->spec;
+        struct hda_input_mux *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];
         dimux->items[dimux->num_items].index = 0;
         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;
+                const char *label;
 
-                def_conf = snd_hda_codec_get_pincfg(codec, spec->dmic_nids[i]);
+                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);
+                index = get_connection_index(codec, spec->dmux_nids[0], nid);
+                if (index < 0)
+                        continue;
 
-                if (wcaps) {
-                        sprintf(name, "%s Capture Volume",
-                                stac92xx_dmic_labels[dimux->num_items]);
+                if (active_mics == 1)
+                        label = "Digital Mic";
+                else
+                        label = 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));
+                err = create_elem_capture_vol(codec, nid, label, HDA_INPUT);
+                if (err < 0)
+                        return err;
+                if (!err) {
+                        err = create_elem_capture_vol(codec, nid, label,
+                                                      HDA_OUTPUT);
                         if (err < 0)
                                 return err;
                 }
 
-                dimux->items[dimux->num_items].label =
-                        stac92xx_dmic_labels[dimux->num_items];
+                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;
+}
+
 /* create playback/capture controls for input pins */
 static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg)
 {
         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;
+                hda_nid_t nid = cfg->input_pins[i];
+                int index, err;
 
-                if (!cfg->input_pins[i])
+                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],
+                                              HDA_INPUT);
+                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) {
                 /*
@@ -3702,7 +3599,7 @@ static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out
 {
         struct sigmatel_spec *spec = codec->spec;
         int hp_swap = 0;
-        int err;
+        int i, err;
 
         if ((err = snd_hda_parse_pin_def_config(codec,
                                                 &spec->autocfg,
@@ -3742,11 +3639,10 @@ static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out
                 if (snd_hda_get_connections(codec,
                                 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
                                  * mono-mux path.
@@ -3837,6 +3733,21 @@ static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_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;
+        }
+
         err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg);
         if (err < 0)
                 return err;
@@ -3846,11 +3757,6 @@ static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out
                 if (err < 0)
                         return err;
         }
-        if (spec->num_amps > 0) {
-                err = stac92xx_auto_create_amp_output_ctls(codec);
-                if (err < 0)
-                        return err;
-        }
         if (spec->num_dmics > 0 && !spec->dinput_mux)
                 if ((err = stac92xx_auto_create_dmic_input_ctls(codec,
                                                 &spec->autocfg)) < 0)
@@ -3887,7 +3793,6 @@ static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out
                 spec->dinput_mux = &spec->private_dimux;
         spec->sinput_mux = &spec->private_smux;
         spec->mono_mux = &spec->private_mono_mux;
-        spec->amp_mux = &spec->private_amp_mux;
         return 1;
 }
 
@@ -4065,7 +3970,7 @@ static int stac92xx_add_jack(struct hda_codec *codec,
         jack->nid = nid;
         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),
                 snd_hda_get_jack_location(def_conf));
@@ -4099,14 +4004,14 @@ static int stac_add_event(struct sigmatel_spec *spec, hda_nid_t nid,
 }
 
 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;
         struct sigmatel_event *event = spec->events.list;
         int i;
 
         for (i = 0; i < spec->events.used; i++, event++) {
-                if (event->nid == nid && event->type == type)
+                if (event->nid == nid)
                         return event;
         }
         return NULL;
@@ -4126,24 +4031,32 @@ static struct sigmatel_event *stac_get_event_from_tag(struct hda_codec *codec,
         return NULL;
 }
 
-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;
         int tag;
 
         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;
 }
 
 static int is_nid_hp_pin(struct auto_pin_cfg *cfg, hda_nid_t nid)
@@ -4236,20 +4149,39 @@ static int stac92xx_init(struct hda_codec *codec)
                         hda_nid_t nid = cfg->hp_pins[i];
                         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
                  */
                 stac92xx_auto_set_pinctl(codec, spec->autocfg.line_out_pins[0],
                                 AC_PINCTL_OUT_EN);
                 /* fake event to set up pins */
-                stac_issue_unsol_event(codec, spec->autocfg.hp_pins[0],
-                                       STAC_HP_EVENT);
+                if (cfg->hp_pins[0])
+                        stac_issue_unsol_event(codec, cfg->hp_pins[0]);
+                else if (cfg->line_out_pins[0])
+                        stac_issue_unsol_event(codec, cfg->line_out_pins[0]);
         } else {
                 stac92xx_auto_init_multi_out(codec);
                 stac92xx_auto_init_hp_out(codec);
                 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++) {
                 hda_nid_t nid = cfg->input_pins[i];
                 if (nid) {
@@ -4276,10 +4208,9 @@ static int stac92xx_init(struct hda_codec *codec)
                         }
                         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);
                         }
                 }
         }
@@ -4324,10 +4255,8 @@ static int stac92xx_init(struct hda_codec *codec)
                                 stac_toggle_power_map(codec, nid, 1);
                         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)
                 stac92xx_power_down(codec);
@@ -4431,6 +4360,48 @@ static int get_pin_presence(struct hda_codec *codec, hda_nid_t nid)
         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
  * a jack-detection target
  */
@@ -4483,13 +4454,6 @@ static void stac92xx_hp_detect(struct hda_codec *codec)
                 for (i = 0; i < cfg->line_outs; i++)
                         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 */
                 if (spec->hp_switch)
@@ -4498,14 +4462,8 @@ static void stac92xx_hp_detect(struct hda_codec *codec)
                 for (i = 0; i < cfg->line_outs; i++)
                         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++) {
                 unsigned int val = AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN;
@@ -4590,10 +4548,28 @@ static void stac92xx_report_jack(struct hda_codec *codec, hda_nid_t nid)
         }
 }
 
-static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid,
-                                   unsigned char 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, type);
+        struct sigmatel_event *event = stac_get_event(codec, nid);
         if (!event)
                 return;
         codec->patch_ops.unsol_event(codec, (unsigned)event->tag << 26);
@@ -4612,8 +4588,18 @@ static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
 
         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:
                 if (spec->num_pwrs > 0)
@@ -4703,9 +4689,13 @@ static int stac92xx_resume(struct hda_codec *codec)
         snd_hda_codec_resume_amp(codec);
         snd_hda_codec_resume_cache(codec);
         /* 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);
+        if (spec->hp_detect) {
+                if (spec->autocfg.hp_pins[0])
+                        stac_issue_unsol_event(codec, spec->autocfg.hp_pins[0]);
+                else if (spec->autocfg.line_out_pins[0])
+                        stac_issue_unsol_event(codec,
+                                               spec->autocfg.line_out_pins[0]);
+        }
         return 0;
 }
 
@@ -4745,6 +4735,19 @@ static int stac92xx_hp_check_power_status(struct hda_codec *codec,
 static int stac92xx_suspend(struct hda_codec *codec, pm_message_t state)
 {
         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,
                                 spec->gpio_dir, spec->gpio_data &
@@ -4781,7 +4784,8 @@ static int patch_stac9200(struct hda_codec *codec)
                                                         stac9200_models,
                                                         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,
                                          stac9200_brd_tbl[spec->board_config]);
@@ -4853,8 +4857,8 @@ static int patch_stac925x(struct hda_codec *codec)
                                                         stac925x_cfg_tbl);
  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,
                                          stac925x_brd_tbl[spec->board_config]);
@@ -4884,6 +4888,9 @@ static int patch_stac925x(struct hda_codec *codec)
 
         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);
         if (!err) {
@@ -4905,16 +4912,6 @@ static int patch_stac925x(struct hda_codec *codec)
         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)
 {
         struct sigmatel_spec *spec;
@@ -4934,10 +4931,16 @@ static int patch_stac92hd73xx(struct hda_codec *codec)
                                                         STAC_92HD73XX_MODELS,
                                                         stac92hd73xx_models,
                                                         stac92hd73xx_cfg_tbl);
+        /* check codec subsystem id if not found */
+        if (spec->board_config < 0)
+                spec->board_config =
+                        snd_hda_check_board_codec_sid_config(codec,
+                                STAC_92HD73XX_MODELS, stac92hd73xx_models,
+                                stac92hd73xx_codec_id_cfg_tbl);
 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,
                                 stac92hd73xx_brd_tbl[spec->board_config]);
@@ -4950,20 +4953,15 @@ again:
                        "number of channels defaulting to DAC count\n");
                 num_dacs = STAC92HD73_DAC_COUNT;
         }
+        spec->init = stac92hd73xx_core_init;
         switch (num_dacs) {
         case 0x3: /* 6 Channel */
-                spec->mixer = stac92hd73xx_6ch_mixer;
-                spec->init = stac92hd73xx_6ch_core_init;
                 spec->aloopback_ctl = stac92hd73xx_6ch_loopback;
                 break;
         case 0x4: /* 8 Channel */
-                spec->mixer = stac92hd73xx_8ch_mixer;
-                spec->init = stac92hd73xx_8ch_core_init;
                 spec->aloopback_ctl = stac92hd73xx_8ch_loopback;
                 break;
         case 0x5: /* 10 Channel */
-                spec->mixer = stac92hd73xx_10ch_mixer;
-                spec->init = stac92hd73xx_10ch_core_init;
                 spec->aloopback_ctl = stac92hd73xx_10ch_loopback;
                 break;
         }
@@ -4978,14 +4976,14 @@ again:
         spec->dmic_nids = stac92hd73xx_dmic_nids;
         spec->dmux_nids = stac92hd73xx_dmux_nids;
         spec->smux_nids = stac92hd73xx_smux_nids;
-        spec->amp_nids = stac92hd73xx_amp_nids;
-        spec->num_amps = ARRAY_SIZE(stac92hd73xx_amp_nids);
 
         spec->num_muxes = ARRAY_SIZE(stac92hd73xx_mux_nids);
         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) {
         case STAC_DELL_EQ:
@@ -4995,43 +4993,40 @@ again:
         case STAC_DELL_M6_DMIC:
         case STAC_DELL_M6_BOTH:
                 spec->num_smuxes = 0;
-                spec->mixer = &stac92hd73xx_6ch_mixer[DELL_M6_MIXER];
-                spec->amp_nids = &stac92hd73xx_amp_nids[DELL_M6_AMP];
                 spec->eapd_switch = 0;
-                spec->num_amps = 1;
 
-                if (spec->board_config != STAC_DELL_EQ)
-                        spec->init = dell_m6_core_init;
                 switch (spec->board_config) {
                 case STAC_DELL_M6_AMIC: /* Analog Mics */
                         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 */
                         snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170);
                         snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160);
                         spec->num_dmics = 1;
-                        spec->private_dimux.num_items = 2;
                         break;
                 }
                 break;
+        case STAC_ALIENWARE_M17X:
+                spec->num_dmics = STAC92HD73XX_NUM_DMICS;
+                spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids);
+                spec->eapd_switch = 0;
+                break;
         default:
                 spec->num_dmics = STAC92HD73XX_NUM_DMICS;
                 spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids);
                 spec->eapd_switch = 1;
+                break;
         }
-        if (spec->board_config > STAC_92HD73XX_REF) {
+        if (spec->board_config != STAC_92HD73XX_REF) {
                 /* GPIO0 High = Enable EAPD */
                 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
                 spec->gpio_data = 0x01;
         }
-        spec->dinput_mux = &spec->private_dimux;
 
         spec->num_pwrs = ARRAY_SIZE(stac92hd73xx_pwr_nids);
         spec->pwr_nids = stac92hd73xx_pwr_nids;
@@ -5063,15 +5058,6 @@ again:
         return 0;
 }
 
-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)
 {
         struct sigmatel_spec *spec;
@@ -5086,34 +5072,31 @@ static int patch_stac92hd83xxx(struct hda_codec *codec)
 
         codec->spec = spec;
         codec->slave_dig_outs = stac92hd83xxx_slave_dig_outs;
-        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);
         spec->multiout.dac_nids = spec->dac_nids;
 
         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,
                                                         stac92hd83xxx_models,
                                                         stac92hd83xxx_cfg_tbl);
 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,
                                 stac92hd83xxx_brd_tbl[spec->board_config]);
@@ -5155,6 +5138,8 @@ again:
 
         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
          */
@@ -5168,25 +5153,6 @@ again:
         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) */
 static unsigned int stac_get_defcfg_connect(struct hda_codec *codec, int idx)
 {
@@ -5247,7 +5213,6 @@ static int patch_stac92hd71bxx(struct hda_codec *codec)
         struct sigmatel_spec *spec;
         struct hda_verb *unmute_init = stac92hd71bxx_unmute_core_init;
         int err = 0;
-        unsigned int ndmic_nids = 0;
 
         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
         if (spec == NULL)
@@ -5276,13 +5241,13 @@ static int patch_stac92hd71bxx(struct hda_codec *codec)
                                                         stac92hd71bxx_cfg_tbl);
 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,
                                 stac92hd71bxx_brd_tbl[spec->board_config]);
 
-        if (spec->board_config > STAC_92HD71BXX_REF) {
+        if (spec->board_config != STAC_92HD71BXX_REF) {
                 /* GPIO0 = EAPD */
                 spec->gpio_mask = 0x01;
                 spec->gpio_dir = 0x01;
@@ -5292,6 +5257,10 @@ again:
         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) {
         case 0x111d76b6: /* 4 Port without Analog Mixer */
         case 0x111d76b7:
@@ -5299,24 +5268,13 @@ again:
                 /* fallthru */
         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;
                 spec->num_dmics = stac92hd71bxx_connected_ports(codec,
                                         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:
                         /* Enable VREF power saving on GPIO1 detect */
@@ -5338,11 +5296,8 @@ again:
 
                 /* 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);
                 snd_hda_codec_set_pincfg(codec, 0x19, 0x40f000f3);
@@ -5350,8 +5305,6 @@ again:
                 spec->num_dmics = stac92hd71bxx_connected_ports(codec,
                                         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 */
                 if ((codec->revision_id & 0xf) == 1)
@@ -5361,17 +5314,12 @@ again:
                 spec->num_pwrs = 0;
                 /* 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)
@@ -5399,6 +5347,7 @@ again:
 
         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);
 
         switch (spec->board_config) {
@@ -5431,6 +5380,11 @@ again:
         case STAC_HP_DV5:
                 snd_hda_codec_set_pincfg(codec, 0x0d, 0x90170010);
                 stac92xx_auto_set_pinctl(codec, 0x0d, AC_PINCTL_OUT_EN);
+                /* HP dv6 gives the headphone pin as a line-out.  Thus we
+                 * need to set hp_detect flag here to force to enable HP
+                 * detection.
+                 */
+                spec->hp_detect = 1;
                 break;
         case STAC_HP_HDX:
                 spec->num_dmics = 1;
@@ -5453,8 +5407,6 @@ again:
 #endif  
 
         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);
         if (!err) {
@@ -5532,8 +5484,8 @@ static int patch_stac922x(struct hda_codec *codec)
 
  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,
                                 stac922x_brd_tbl[spec->board_config]);
@@ -5546,7 +5498,10 @@ static int patch_stac922x(struct hda_codec *codec)
         spec->num_pwrs = 0;
 
         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;
         
@@ -5595,8 +5550,8 @@ static int patch_stac927x(struct hda_codec *codec)
                                                         stac927x_cfg_tbl);
  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,
                                 stac927x_brd_tbl[spec->board_config]);
@@ -5612,16 +5567,18 @@ static int patch_stac927x(struct hda_codec *codec)
         spec->dac_list = stac927x_dac_nids;
         spec->multiout.dac_nids = spec->dac_nids;
 
+        if (spec->board_config != STAC_D965_REF) {
+                /* GPIO0 High = Enable EAPD */
+                spec->eapd_mask = spec->gpio_mask = 0x01;
+                spec->gpio_dir = spec->gpio_data = 0x01;
+        }
+
         switch (spec->board_config) {
         case STAC_D965_3ST:
         case STAC_D965_5ST:
                 /* GPIO0 High = Enable EAPD */
-                spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x01;
-                spec->gpio_data = 0x01;
                 spec->num_dmics = 0;
-
                 spec->init = d965_core_init;
-                spec->mixer = stac927x_mixer;
                 break;
         case STAC_DELL_BIOS:
                 switch (codec->subsystem_id) {
@@ -5639,29 +5596,28 @@ static int patch_stac927x(struct hda_codec *codec)
                 snd_hda_codec_set_pincfg(codec, 0x0e, 0x02a79130);
                 /* fallthru */
         case STAC_DELL_3ST:
-                /* GPIO2 High = Enable EAPD */
-                spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x04;
-                spec->gpio_data = 0x04;
+                if (codec->subsystem_id != 0x1028022f) {
+                        /* GPIO2 High = Enable EAPD */
+                        spec->eapd_mask = spec->gpio_mask = 0x04;
+                        spec->gpio_dir = spec->gpio_data = 0x04;
+                }
                 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);
                 break;
         default:
-                if (spec->board_config > STAC_D965_REF) {
-                        /* GPIO0 High = Enable EAPD */
-                        spec->eapd_mask = spec->gpio_mask = 0x01;
-                        spec->gpio_dir = spec->gpio_data = 0x01;
-                }
                 spec->num_dmics = 0;
-
                 spec->init = stac927x_core_init;
-                spec->mixer = stac927x_mixer;
+                break;
         }
 
+        spec->num_caps = STAC927X_NUM_CAPS;
+        spec->capvols = stac927x_capvols;
+        spec->capsws = stac927x_capsws;
+
         spec->num_pwrs = 0;
         spec->aloopback_ctl = stac927x_loopback;
         spec->aloopback_mask = 0x40;
@@ -5723,7 +5679,8 @@ static int patch_stac9205(struct hda_codec *codec)
                                                         stac9205_cfg_tbl);
  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,
                                          stac9205_brd_tbl[spec->board_config]);
@@ -5742,9 +5699,12 @@ static int patch_stac9205(struct hda_codec *codec)
         spec->num_pwrs = 0;
 
         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;
         spec->aloopback_shift = 0;
         /* Turn on/off EAPD per HP plugging */
@@ -5819,12 +5779,6 @@ static struct hda_verb stac9872_core_init[] = {
         {}
 };
 
-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),
-        { } /* end */
-};
-
 static hda_nid_t stac9872_pin_nids[] = {
         0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
         0x11, 0x13, 0x14,
@@ -5838,6 +5792,11 @@ static hda_nid_t stac9872_mux_nids[] = {
         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] = {
         0x03211020, 0x411111f0, 0x411111f0, 0x03a15030,
         0x411111f0, 0x90170110, 0x411111f0, 0x411111f0,
@@ -5854,6 +5813,8 @@ static unsigned int *stac9872_brd_tbl[STAC_9872_MODELS] = {
 };
 
 static struct snd_pci_quirk stac9872_cfg_tbl[] = {
+        SND_PCI_QUIRK_MASK(0x104d, 0xfff0, 0x81e0,
+                           "Sony VAIO F/S", STAC_9872_VAIO),
         {} /* terminator */
 };
 
@@ -5866,26 +5827,28 @@ static int patch_stac9872(struct hda_codec *codec)
         if (spec == NULL)
                 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,
                                                         stac9872_models,
                                                         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);
         spec->adc_nids = stac9872_adc_nids;
         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);
         if (err < 0) {
diff --git a/sound/pci/hda/patch_via.c b/sound/pci/hda/patch_via.c
index 8e004fb6961a..ee89db90c9b6 100644
--- a/sound/pci/hda/patch_via.c
+++ b/sound/pci/hda/patch_via.c
@@ -210,7 +210,9 @@ struct via_spec {
         /* 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 */
         const struct hda_input_mux *input_mux;
@@ -319,6 +321,9 @@ static void via_auto_set_output_and_unmute(struct hda_codec *codec,
                             pin_type);
         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);
 }
 
 
@@ -387,27 +392,12 @@ static int via_mux_enum_put(struct snd_kcontrol *kcontrol,
         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
         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]);
 }
 
 static int via_independent_hp_info(struct snd_kcontrol *kcontrol,
@@ -998,25 +988,11 @@ static int via_init(struct hda_codec *codec)
 
         /* 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,
-                                            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,
+                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, 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);
                 }
         } else /* enable SPDIF-input pin */
@@ -1326,6 +1302,7 @@ static int vt1708_parse_auto_config(struct hda_codec *codec)
 
         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;
 
@@ -1352,6 +1329,33 @@ static int via_auto_init(struct hda_codec *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;
+}
+
 static int patch_vt1708(struct hda_codec *codec)
 {
         struct via_spec *spec;
@@ -1390,6 +1394,7 @@ static int patch_vt1708(struct hda_codec *codec)
         if (!spec->adc_nids && spec->input_mux) {
                 spec->adc_nids = vt1708_adc_nids;
                 spec->num_adc_nids = ARRAY_SIZE(vt1708_adc_nids);
+                get_mux_nids(codec);
                 spec->mixers[spec->num_mixers] = vt1708_capture_mixer;
                 spec->num_mixers++;
         }
@@ -1799,6 +1804,7 @@ static int vt1709_parse_auto_config(struct hda_codec *codec)
 
         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;
 
@@ -1859,6 +1865,7 @@ static int patch_vt1709_10ch(struct hda_codec *codec)
         if (!spec->adc_nids && spec->input_mux) {
                 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++;
         }
@@ -1952,6 +1959,7 @@ static int patch_vt1709_6ch(struct hda_codec *codec)
         if (!spec->adc_nids && spec->input_mux) {
                 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++;
         }
@@ -2344,6 +2352,7 @@ static int vt1708B_parse_auto_config(struct hda_codec *codec)
 
         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;
 
@@ -2404,6 +2413,7 @@ static int patch_vt1708B_8ch(struct hda_codec *codec)
         if (!spec->adc_nids && spec->input_mux) {
                 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++;
         }
@@ -2455,6 +2465,7 @@ static int patch_vt1708B_4ch(struct hda_codec *codec)
         if (!spec->adc_nids && spec->input_mux) {
                 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++;
         }
@@ -2889,6 +2900,7 @@ static int patch_vt1708S(struct hda_codec *codec)
         if (!spec->adc_nids && spec->input_mux) {
                 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++;
         }
@@ -3206,6 +3218,7 @@ static int patch_vt1702(struct hda_codec *codec)
         if (!spec->adc_nids && spec->input_mux) {
                 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++;
         }
diff --git a/sound/pci/ice1712/ice1712.c b/sound/pci/ice1712/ice1712.c
index 0d0cdbdb4486..cecf1ffeeaaa 100644
--- a/sound/pci/ice1712/ice1712.c
+++ b/sound/pci/ice1712/ice1712.c
@@ -107,7 +107,7 @@ MODULE_PARM_DESC(dxr_enable, "Enable DXR support for Terratec DMX6FIRE.");
 
 
 static const struct pci_device_id snd_ice1712_ids[] = {
-        { PCI_VENDOR_ID_ICE, PCI_DEVICE_ID_ICE_1712, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },   /* ICE1712 */
+        { PCI_VDEVICE(ICE, PCI_DEVICE_ID_ICE_1712), 0 },   /* ICE1712 */
         { 0, }
 };
 
diff --git a/sound/pci/ice1712/ice1712.h b/sound/pci/ice1712/ice1712.h
index adc909ec125c..9da2dae64c5b 100644
--- a/sound/pci/ice1712/ice1712.h
+++ b/sound/pci/ice1712/ice1712.h
@@ -379,6 +379,15 @@ struct snd_ice1712 {
         unsigned char (*set_mclk)(struct snd_ice1712 *ice, unsigned int rate);
         void (*set_spdif_clock)(struct snd_ice1712 *ice);
 
+#ifdef CONFIG_PM
+        int (*pm_suspend)(struct snd_ice1712 *);
+        int (*pm_resume)(struct snd_ice1712 *);
+        int pm_suspend_enabled:1;
+        int pm_saved_is_spdif_master:1;
+        unsigned int pm_saved_spdif_ctrl;
+        unsigned char pm_saved_spdif_cfg;
+        unsigned int pm_saved_route;
+#endif
 };
 
 
diff --git a/sound/pci/ice1712/ice1724.c b/sound/pci/ice1712/ice1724.c
index 36ade77cf371..af6e00148621 100644
--- a/sound/pci/ice1712/ice1724.c
+++ b/sound/pci/ice1712/ice1724.c
@@ -93,7 +93,7 @@ MODULE_PARM_DESC(model, "Use the given board model.");
 
 /* Both VT1720 and VT1724 have the same PCI IDs */
 static const struct pci_device_id snd_vt1724_ids[] = {
-        { PCI_VENDOR_ID_ICE, PCI_DEVICE_ID_VT1724, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
+        { PCI_VDEVICE(ICE, PCI_DEVICE_ID_VT1724), 0 },
         { 0, }
 };
 
@@ -560,6 +560,7 @@ static int snd_vt1724_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
 
         case SNDRV_PCM_TRIGGER_START:
         case SNDRV_PCM_TRIGGER_STOP:
+        case SNDRV_PCM_TRIGGER_SUSPEND:
                 spin_lock(&ice->reg_lock);
                 old = inb(ICEMT1724(ice, DMA_CONTROL));
                 if (cmd == SNDRV_PCM_TRIGGER_START)
@@ -570,6 +571,10 @@ static int snd_vt1724_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
                 spin_unlock(&ice->reg_lock);
                 break;
 
+        case SNDRV_PCM_TRIGGER_RESUME:
+                /* apps will have to restart stream */
+                break;
+
         default:
                 return -EINVAL;
         }
@@ -2262,7 +2267,7 @@ static int __devinit snd_vt1724_read_eeprom(struct snd_ice1712 *ice,
 
 
 
-static void __devinit snd_vt1724_chip_reset(struct snd_ice1712 *ice)
+static void snd_vt1724_chip_reset(struct snd_ice1712 *ice)
 {
         outb(VT1724_RESET , ICEREG1724(ice, CONTROL));
         inb(ICEREG1724(ice, CONTROL)); /* pci posting flush */
@@ -2272,7 +2277,7 @@ static void __devinit snd_vt1724_chip_reset(struct snd_ice1712 *ice)
         msleep(10);
 }
 
-static int __devinit snd_vt1724_chip_init(struct snd_ice1712 *ice)
+static int snd_vt1724_chip_init(struct snd_ice1712 *ice)
 {
         outb(ice->eeprom.data[ICE_EEP2_SYSCONF], ICEREG1724(ice, SYS_CFG));
         outb(ice->eeprom.data[ICE_EEP2_ACLINK], ICEREG1724(ice, AC97_CFG));
@@ -2287,6 +2292,14 @@ static int __devinit snd_vt1724_chip_init(struct snd_ice1712 *ice)
 
         outb(0, ICEREG1724(ice, POWERDOWN));
 
+        /* MPU_RX and TX irq masks are cleared later dynamically */
+        outb(VT1724_IRQ_MPU_RX | VT1724_IRQ_MPU_TX , ICEREG1724(ice, IRQMASK));
+
+        /* don't handle FIFO overrun/underruns (just yet),
+         * since they cause machine lockups
+         */
+        outb(VT1724_MULTI_FIFO_ERR, ICEMT1724(ice, DMA_INT_MASK));
+
         return 0;
 }
 
@@ -2431,6 +2444,8 @@ static int __devinit snd_vt1724_create(struct snd_card *card,
         snd_vt1724_proc_init(ice);
         synchronize_irq(pci->irq);
 
+        card->private_data = ice;
+
         err = pci_request_regions(pci, "ICE1724");
         if (err < 0) {
                 kfree(ice);
@@ -2459,14 +2474,6 @@ static int __devinit snd_vt1724_create(struct snd_card *card,
                 return -EIO;
         }
 
-        /* MPU_RX and TX irq masks are cleared later dynamically */
-        outb(VT1724_IRQ_MPU_RX | VT1724_IRQ_MPU_TX , ICEREG1724(ice, IRQMASK));
-
-        /* don't handle FIFO overrun/underruns (just yet),
-         * since they cause machine lockups
-         */
-        outb(VT1724_MULTI_FIFO_ERR, ICEMT1724(ice, DMA_INT_MASK));
-
         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, ice, &ops);
         if (err < 0) {
                 snd_vt1724_free(ice);
@@ -2650,11 +2657,96 @@ static void __devexit snd_vt1724_remove(struct pci_dev *pci)
         pci_set_drvdata(pci, NULL);
 }
 
+#ifdef CONFIG_PM
+static int snd_vt1724_suspend(struct pci_dev *pci, pm_message_t state)
+{
+        struct snd_card *card = pci_get_drvdata(pci);
+        struct snd_ice1712 *ice = card->private_data;
+
+        if (!ice->pm_suspend_enabled)
+                return 0;
+
+        snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
+
+        snd_pcm_suspend_all(ice->pcm);
+        snd_pcm_suspend_all(ice->pcm_pro);
+        snd_pcm_suspend_all(ice->pcm_ds);
+        snd_ac97_suspend(ice->ac97);
+
+        spin_lock_irq(&ice->reg_lock);
+        ice->pm_saved_is_spdif_master = ice->is_spdif_master(ice);
+        ice->pm_saved_spdif_ctrl = inw(ICEMT1724(ice, SPDIF_CTRL));
+        ice->pm_saved_spdif_cfg = inb(ICEREG1724(ice, SPDIF_CFG));
+        ice->pm_saved_route = inl(ICEMT1724(ice, ROUTE_PLAYBACK));
+        spin_unlock_irq(&ice->reg_lock);
+
+        if (ice->pm_suspend)
+                ice->pm_suspend(ice);
+
+        pci_disable_device(pci);
+        pci_save_state(pci);
+        pci_set_power_state(pci, pci_choose_state(pci, state));
+        return 0;
+}
+
+static int snd_vt1724_resume(struct pci_dev *pci)
+{
+        struct snd_card *card = pci_get_drvdata(pci);
+        struct snd_ice1712 *ice = card->private_data;
+
+        if (!ice->pm_suspend_enabled)
+                return 0;
+
+        pci_set_power_state(pci, PCI_D0);
+        pci_restore_state(pci);
+
+        if (pci_enable_device(pci) < 0) {
+                snd_card_disconnect(card);
+                return -EIO;
+        }
+
+        pci_set_master(pci);
+
+        snd_vt1724_chip_reset(ice);
+
+        if (snd_vt1724_chip_init(ice) < 0) {
+                snd_card_disconnect(card);
+                return -EIO;
+        }
+
+        if (ice->pm_resume)
+                ice->pm_resume(ice);
+
+        if (ice->pm_saved_is_spdif_master) {
+                /* switching to external clock via SPDIF */
+                ice->set_spdif_clock(ice);
+        } else {
+                /* internal on-card clock */
+                snd_vt1724_set_pro_rate(ice, ice->pro_rate_default, 1);
+        }
+
+        update_spdif_bits(ice, ice->pm_saved_spdif_ctrl);
+
+        outb(ice->pm_saved_spdif_cfg, ICEREG1724(ice, SPDIF_CFG));
+        outl(ice->pm_saved_route, ICEMT1724(ice, ROUTE_PLAYBACK));
+
+        if (ice->ac97)
+                snd_ac97_resume(ice->ac97);
+
+        snd_power_change_state(card, SNDRV_CTL_POWER_D0);
+        return 0;
+}
+#endif
+
 static struct pci_driver driver = {
         .name = "ICE1724",
         .id_table = snd_vt1724_ids,
         .probe = snd_vt1724_probe,
         .remove = __devexit_p(snd_vt1724_remove),
+#ifdef CONFIG_PM
+        .suspend = snd_vt1724_suspend,
+        .resume = snd_vt1724_resume,
+#endif
 };
 
 static int __init alsa_card_ice1724_init(void)
diff --git a/sound/pci/ice1712/prodigy_hifi.c b/sound/pci/ice1712/prodigy_hifi.c
index 043a93879bd5..c75515f5be6f 100644
--- a/sound/pci/ice1712/prodigy_hifi.c
+++ b/sound/pci/ice1712/prodigy_hifi.c
@@ -1077,7 +1077,7 @@ static int __devinit prodigy_hifi_init(struct snd_ice1712 *ice)
 /*
  * initialize the chip
  */
-static int __devinit prodigy_hd2_init(struct snd_ice1712 *ice)
+static void ak4396_init(struct snd_ice1712 *ice)
 {
         static unsigned short ak4396_inits[] = {
                 AK4396_CTRL1,      0x87,   /* I2S Normal Mode, 24 bit */
@@ -1087,9 +1087,37 @@ static int __devinit prodigy_hd2_init(struct snd_ice1712 *ice)
                 AK4396_RCH_ATT,  0x00,
         };
 
-        struct prodigy_hifi_spec *spec;
         unsigned int i;
 
+        /* initialize ak4396 codec */
+        /* reset codec */
+        ak4396_write(ice, AK4396_CTRL1, 0x86);
+        msleep(100);
+        ak4396_write(ice, AK4396_CTRL1, 0x87);
+
+        for (i = 0; i < ARRAY_SIZE(ak4396_inits); i += 2)
+                ak4396_write(ice, ak4396_inits[i], ak4396_inits[i+1]);
+}
+
+#ifdef CONFIG_PM
+static int __devinit prodigy_hd2_resume(struct snd_ice1712 *ice)
+{
+        /* initialize ak4396 codec and restore previous mixer volumes */
+        struct prodigy_hifi_spec *spec = ice->spec;
+        int i;
+        mutex_lock(&ice->gpio_mutex);
+        ak4396_init(ice);
+        for (i = 0; i < 2; i++)
+                ak4396_write(ice, AK4396_LCH_ATT + i, spec->vol[i] & 0xff);
+        mutex_unlock(&ice->gpio_mutex);
+        return 0;
+}
+#endif
+
+static int __devinit prodigy_hd2_init(struct snd_ice1712 *ice)
+{
+        struct prodigy_hifi_spec *spec;
+
         ice->vt1720 = 0;
         ice->vt1724 = 1;
 
@@ -1112,14 +1140,12 @@ static int __devinit prodigy_hd2_init(struct snd_ice1712 *ice)
                 return -ENOMEM;
         ice->spec = spec;
 
-        /* initialize ak4396 codec */
-        /* reset codec */
-        ak4396_write(ice, AK4396_CTRL1, 0x86);
-        msleep(100);
-        ak4396_write(ice, AK4396_CTRL1, 0x87);
-                        
-        for (i = 0; i < ARRAY_SIZE(ak4396_inits); i += 2)
-                ak4396_write(ice, ak4396_inits[i], ak4396_inits[i+1]);
+#ifdef CONFIG_PM
+        ice->pm_resume = &prodigy_hd2_resume;
+        ice->pm_suspend_enabled = 1;
+#endif
+
+        ak4396_init(ice);
 
         return 0;
 }
diff --git a/sound/pci/intel8x0.c b/sound/pci/intel8x0.c
index 8aa5687f392a..754867ed4785 100644
--- a/sound/pci/intel8x0.c
+++ b/sound/pci/intel8x0.c
@@ -421,29 +421,29 @@ struct intel8x0 {
 };
 
 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, }
 };
 
@@ -1954,6 +1954,18 @@ static struct ac97_quirk ac97_quirks[] __devinitdata = {
                 .name = "Sony S1XP",
                 .type = AC97_TUNE_INV_EAPD
         },
+        {
+                .subvendor = 0x104d,
+                .subdevice = 0x81c0,
+                .name = "Sony VAIO VGN-T350P", /*AD1981B*/
+                .type = AC97_TUNE_INV_EAPD
+        },
+        {
+                .subvendor = 0x104d,
+                .subdevice = 0x81c5,
+                .name = "Sony VAIO VGN-B1VP", /*AD1981B*/
+                .type = AC97_TUNE_INV_EAPD
+        },
         {
                 .subvendor = 0x1043,
                 .subdevice = 0x80f3,
diff --git a/sound/pci/intel8x0m.c b/sound/pci/intel8x0m.c
index 6ec0fc50d6be..9e7d12e7673f 100644
--- a/sound/pci/intel8x0m.c
+++ b/sound/pci/intel8x0m.c
@@ -220,24 +220,24 @@ struct intel8x0m {
 };
 
 static struct pci_device_id snd_intel8x0m_ids[] = {
-        { 0x8086, 0x2416, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_INTEL }, /* 82801AA */
-        { 0x8086, 0x2426, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_INTEL }, /* 82901AB */
-        { 0x8086, 0x2446, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_INTEL }, /* 82801BA */
-        { 0x8086, 0x2486, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_INTEL }, /* ICH3 */
-        { 0x8086, 0x24c6, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_INTEL }, /* ICH4 */
-        { 0x8086, 0x24d6, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_INTEL }, /* ICH5 */
-        { 0x8086, 0x266d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_INTEL }, /* ICH6 */
-        { 0x8086, 0x27dd, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_INTEL }, /* ICH7 */
-        { 0x8086, 0x7196, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_INTEL }, /* 440MX */
-        { 0x1022, 0x7446, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_INTEL }, /* AMD768 */
-        { 0x1039, 0x7013, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_SIS },   /* SI7013 */
-        { 0x10de, 0x01c1, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_NFORCE }, /* NFORCE */
-        { 0x10de, 0x0069, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_NFORCE }, /* NFORCE2 */
-        { 0x10de, 0x0089, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_NFORCE }, /* NFORCE2s */
-        { 0x10de, 0x00d9, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_NFORCE }, /* NFORCE3 */
+        { PCI_VDEVICE(INTEL, 0x2416), DEVICE_INTEL },   /* 82801AA */
+        { PCI_VDEVICE(INTEL, 0x2426), DEVICE_INTEL },   /* 82901AB */
+        { PCI_VDEVICE(INTEL, 0x2446), DEVICE_INTEL },   /* 82801BA */
+        { PCI_VDEVICE(INTEL, 0x2486), DEVICE_INTEL },   /* ICH3 */
+        { PCI_VDEVICE(INTEL, 0x24c6), DEVICE_INTEL }, /* ICH4 */
+        { PCI_VDEVICE(INTEL, 0x24d6), DEVICE_INTEL }, /* ICH5 */
+        { PCI_VDEVICE(INTEL, 0x266d), DEVICE_INTEL },   /* ICH6 */
+        { PCI_VDEVICE(INTEL, 0x27dd), DEVICE_INTEL },   /* ICH7 */
+        { PCI_VDEVICE(INTEL, 0x7196), DEVICE_INTEL },   /* 440MX */
+        { PCI_VDEVICE(AMD, 0x7446), DEVICE_INTEL },     /* AMD768 */
+        { PCI_VDEVICE(SI, 0x7013), DEVICE_SIS },        /* SI7013 */
+        { PCI_VDEVICE(NVIDIA, 0x01c1), DEVICE_NFORCE }, /* NFORCE */
+        { PCI_VDEVICE(NVIDIA, 0x0069), DEVICE_NFORCE }, /* NFORCE2 */
+        { PCI_VDEVICE(NVIDIA, 0x0089), DEVICE_NFORCE }, /* NFORCE2s */
+        { PCI_VDEVICE(NVIDIA, 0x00d9), DEVICE_NFORCE }, /* NFORCE3 */
 #if 0
-        { 0x1022, 0x746d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_INTEL }, /* AMD8111 */
-        { 0x10b9, 0x5455, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_ALI },   /* Ali5455 */
+        { PCI_VDEVICE(AMD, 0x746d), DEVICE_INTEL },     /* AMD8111 */
+        { PCI_VDEVICE(AL, 0x5455), DEVICE_ALI },   /* Ali5455 */
 #endif
         { 0, }
 };
diff --git a/sound/pci/lx6464es/lx6464es.c b/sound/pci/lx6464es/lx6464es.c
index 18da2ef04d09..11b8c6514b3d 100644
--- a/sound/pci/lx6464es/lx6464es.c
+++ b/sound/pci/lx6464es/lx6464es.c
@@ -654,13 +654,12 @@ static int __devinit lx_init_ethersound_config(struct lx6464es *chip)
         int i;
         u32 orig_conf_es = lx_dsp_reg_read(chip, eReg_CONFES);
 
-        u32 default_conf_es = (64 << IOCR_OUTPUTS_OFFSET) |
+        /* configure 64 io channels */
+        u32 conf_es = (orig_conf_es & CONFES_READ_PART_MASK) |
                 (64 << IOCR_INPUTS_OFFSET) |
+                (64 << IOCR_OUTPUTS_OFFSET) |
                 (FREQ_RATIO_SINGLE_MODE << FREQ_RATIO_OFFSET);
 
-        u32 conf_es = (orig_conf_es & CONFES_READ_PART_MASK)
-                | (default_conf_es & CONFES_WRITE_PART_MASK);
-
         snd_printdd("->lx_init_ethersound\n");
 
         chip->freq_ratio = FREQ_RATIO_SINGLE_MODE;
diff --git a/sound/pci/lx6464es/lx6464es.h b/sound/pci/lx6464es/lx6464es.h
index 012c010c8c89..51afc048961d 100644
--- a/sound/pci/lx6464es/lx6464es.h
+++ b/sound/pci/lx6464es/lx6464es.h
@@ -86,7 +86,6 @@ struct lx6464es {
 
         /* messaging */
         spinlock_t              msg_lock;          /* message spinlock */
-        atomic_t                send_message_locked;
         struct lx_rmh           rmh;
 
         /* configuration */
@@ -95,7 +94,6 @@ struct lx6464es {
         uint                    hardware_running[2];
         u32                     board_sample_rate; /* sample rate read from
                                                     * board */
-        u32                     sample_rate;       /* our sample rate */
         u16                     pcm_granularity;   /* board blocksize */
 
         /* dma */
diff --git a/sound/pci/lx6464es/lx_core.c b/sound/pci/lx6464es/lx_core.c
index 5812780d6e89..3086b751da4a 100644
--- a/sound/pci/lx6464es/lx_core.c
+++ b/sound/pci/lx6464es/lx_core.c
@@ -314,98 +314,6 @@ static inline void lx_message_dump(struct lx_rmh *rmh)
 #define XILINX_POLL_NO_SLEEP    100
 #define XILINX_POLL_ITERATIONS  150
 
-#if 0 /* not used now */
-static int lx_message_send(struct lx6464es *chip, struct lx_rmh *rmh)
-{
-        u32 reg = ED_DSP_TIMED_OUT;
-        int dwloop;
-        int answer_received;
-
-        if (lx_dsp_reg_read(chip, eReg_CSM) & (Reg_CSM_MC | Reg_CSM_MR)) {
-                snd_printk(KERN_ERR LXP "PIOSendMessage eReg_CSM %x\n", reg);
-                return -EBUSY;
-        }
-
-        /* write command */
-        lx_dsp_reg_writebuf(chip, eReg_CRM1, rmh->cmd, rmh->cmd_len);
-
-        snd_BUG_ON(atomic_read(&chip->send_message_locked) != 0);
-        atomic_set(&chip->send_message_locked, 1);
-
-        /* MicoBlaze gogogo */
-        lx_dsp_reg_write(chip, eReg_CSM, Reg_CSM_MC);
-
-        /* wait for interrupt to answer */
-        for (dwloop = 0; dwloop != XILINX_TIMEOUT_MS; ++dwloop) {
-                answer_received = atomic_read(&chip->send_message_locked);
-                if (answer_received == 0)
-                        break;
-                msleep(1);
-        }
-
-        if (answer_received == 0) {
-                /* in Debug mode verify Reg_CSM_MR */
-                snd_BUG_ON(!(lx_dsp_reg_read(chip, eReg_CSM) & Reg_CSM_MR));
-
-                /* command finished, read status */
-                if (rmh->dsp_stat == 0)
-                        reg = lx_dsp_reg_read(chip, eReg_CRM1);
-                else
-                        reg = 0;
-        } else {
-                int i;
-                snd_printk(KERN_WARNING LXP "TIMEOUT lx_message_send! "
-                           "Interrupts disabled?\n");
-
-                /* attente bit Reg_CSM_MR */
-                for (i = 0; i != XILINX_POLL_ITERATIONS; i++) {
-                        if ((lx_dsp_reg_read(chip, eReg_CSM) & Reg_CSM_MR)) {
-                                if (rmh->dsp_stat == 0)
-                                        reg = lx_dsp_reg_read(chip, eReg_CRM1);
-                                else
-                                        reg = 0;
-                                goto polling_successful;
-                        }
-
-                        if (i > XILINX_POLL_NO_SLEEP)
-                                msleep(1);
-                }
-                snd_printk(KERN_WARNING LXP "TIMEOUT lx_message_send! "
-                           "polling failed\n");
-
-polling_successful:
-                atomic_set(&chip->send_message_locked, 0);
-        }
-
-        if ((reg & ERROR_VALUE) == 0) {
-                /* read response */
-                if (rmh->stat_len) {
-                        snd_BUG_ON(rmh->stat_len >= (REG_CRM_NUMBER-1));
-
-                        lx_dsp_reg_readbuf(chip, eReg_CRM2, rmh->stat,
-                                           rmh->stat_len);
-                }
-        } else
-                snd_printk(KERN_WARNING LXP "lx_message_send: error_value %x\n",
-                           reg);
-
-        /* clear Reg_CSM_MR */
-        lx_dsp_reg_write(chip, eReg_CSM, 0);
-
-        switch (reg) {
-        case ED_DSP_TIMED_OUT:
-                snd_printk(KERN_WARNING LXP "lx_message_send: dsp timeout\n");
-                return -ETIMEDOUT;
-
-        case ED_DSP_CRASHED:
-                snd_printk(KERN_WARNING LXP "lx_message_send: dsp crashed\n");
-                return -EAGAIN;
-        }
-
-        lx_message_dump(rmh);
-        return 0;
-}
-#endif /* not used now */
 
 static int lx_message_send_atomic(struct lx6464es *chip, struct lx_rmh *rmh)
 {
@@ -423,7 +331,7 @@ static int lx_message_send_atomic(struct lx6464es *chip, struct lx_rmh *rmh)
         /* MicoBlaze gogogo */
         lx_dsp_reg_write(chip, eReg_CSM, Reg_CSM_MC);
 
-        /* wait for interrupt to answer */
+        /* wait for device to answer */
         for (dwloop = 0; dwloop != XILINX_TIMEOUT_MS * 1000; ++dwloop) {
                 if (lx_dsp_reg_read(chip, eReg_CSM) & Reg_CSM_MR) {
                         if (rmh->dsp_stat == 0)
@@ -1175,10 +1083,6 @@ static int lx_interrupt_ack(struct lx6464es *chip, u32 *r_irqsrc,
                 *r_async_escmd = 1;
         }
 
-        if (irqsrc & MASK_SYS_STATUS_CMD_DONE)
-                /* xilinx command notification */
-                atomic_set(&chip->send_message_locked, 0);
-
         if (irq_async) {
                 /* snd_printd("interrupt: async event pending\n"); */
                 *r_async_pending = 1;
diff --git a/sound/pci/mixart/mixart.c b/sound/pci/mixart/mixart.c
index 82bc5b9e7629..a83d1968a845 100644
--- a/sound/pci/mixart/mixart.c
+++ b/sound/pci/mixart/mixart.c
@@ -61,7 +61,7 @@ MODULE_PARM_DESC(enable, "Enable Digigram " CARD_NAME " soundcard.");
  */
 
 static struct pci_device_id snd_mixart_ids[] = {
-        { 0x1057, 0x0003, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* MC8240 */
+        { PCI_VDEVICE(MOTOROLA, 0x0003), 0, }, /* MC8240 */
         { 0, }
 };
 
diff --git a/sound/pci/nm256/nm256.c b/sound/pci/nm256/nm256.c
index 522a040855d4..97a0731331a1 100644
--- a/sound/pci/nm256/nm256.c
+++ b/sound/pci/nm256/nm256.c
@@ -263,9 +263,9 @@ struct nm256 {
  * PCI ids
  */
 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,},
 };
 
diff --git a/sound/pci/oxygen/oxygen_io.c b/sound/pci/oxygen/oxygen_io.c
index c1eb923f2ac9..09b2b2a36df5 100644
--- a/sound/pci/oxygen/oxygen_io.c
+++ b/sound/pci/oxygen/oxygen_io.c
@@ -215,17 +215,8 @@ EXPORT_SYMBOL(oxygen_write_spi);
 
 void oxygen_write_i2c(struct oxygen *chip, u8 device, u8 map, u8 data)
 {
-        unsigned long timeout;
-
         /* should not need more than about 300 us */
-        timeout = jiffies + msecs_to_jiffies(1);
-        do {
-                if (!(oxygen_read16(chip, OXYGEN_2WIRE_BUS_STATUS)
-                      & OXYGEN_2WIRE_BUSY))
-                        break;
-                udelay(1);
-                cond_resched();
-        } while (time_after_eq(timeout, jiffies));
+        msleep(1);
 
         oxygen_write8(chip, OXYGEN_2WIRE_MAP, map);
         oxygen_write8(chip, OXYGEN_2WIRE_DATA, data);
diff --git a/sound/pci/oxygen/oxygen_lib.c b/sound/pci/oxygen/oxygen_lib.c
index 312251d39696..9a8936e20744 100644
--- a/sound/pci/oxygen/oxygen_lib.c
+++ b/sound/pci/oxygen/oxygen_lib.c
@@ -260,6 +260,9 @@ oxygen_search_pci_id(struct oxygen *chip, const struct pci_device_id ids[])
          * chip didn't if the first EEPROM word was overwritten.
          */
         subdevice = oxygen_read_eeprom(chip, 2);
+        /* use default ID if EEPROM is missing */
+        if (subdevice == 0xffff)
+                subdevice = 0x8788;
         /*
          * We use only the subsystem device ID for searching because it is
          * unique even without the subsystem vendor ID, which may have been
diff --git a/sound/pci/oxygen/oxygen_mixer.c b/sound/pci/oxygen/oxygen_mixer.c
index 304da169bfdc..5401c547c4e3 100644
--- a/sound/pci/oxygen/oxygen_mixer.c
+++ b/sound/pci/oxygen/oxygen_mixer.c
@@ -575,8 +575,10 @@ static int ac97_switch_put(struct snd_kcontrol *ctl,
 static int ac97_volume_info(struct snd_kcontrol *ctl,
                             struct snd_ctl_elem_info *info)
 {
+        int stereo = (ctl->private_value >> 16) & 1;
+
         info->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
-        info->count = 2;
+        info->count = stereo ? 2 : 1;
         info->value.integer.min = 0;
         info->value.integer.max = 0x1f;
         return 0;
@@ -587,6 +589,7 @@ static int ac97_volume_get(struct snd_kcontrol *ctl,
 {
         struct oxygen *chip = ctl->private_data;
         unsigned int codec = (ctl->private_value >> 24) & 1;
+        int stereo = (ctl->private_value >> 16) & 1;
         unsigned int index = ctl->private_value & 0xff;
         u16 reg;
 
@@ -594,7 +597,8 @@ static int ac97_volume_get(struct snd_kcontrol *ctl,
         reg = oxygen_read_ac97(chip, codec, index);
         mutex_unlock(&chip->mutex);
         value->value.integer.value[0] = 31 - (reg & 0x1f);
-        value->value.integer.value[1] = 31 - ((reg >> 8) & 0x1f);
+        if (stereo)
+                value->value.integer.value[1] = 31 - ((reg >> 8) & 0x1f);
         return 0;
 }
 
@@ -603,6 +607,7 @@ static int ac97_volume_put(struct snd_kcontrol *ctl,
 {
         struct oxygen *chip = ctl->private_data;
         unsigned int codec = (ctl->private_value >> 24) & 1;
+        int stereo = (ctl->private_value >> 16) & 1;
         unsigned int index = ctl->private_value & 0xff;
         u16 oldreg, newreg;
         int change;
@@ -612,8 +617,11 @@ static int ac97_volume_put(struct snd_kcontrol *ctl,
         newreg = oldreg;
         newreg = (newreg & ~0x1f) |
                 (31 - (value->value.integer.value[0] & 0x1f));
-        newreg = (newreg & ~0x1f00) |
-                ((31 - (value->value.integer.value[0] & 0x1f)) << 8);
+        if (stereo)
+                newreg = (newreg & ~0x1f00) |
+                        ((31 - (value->value.integer.value[1] & 0x1f)) << 8);
+        else
+                newreg = (newreg & ~0x1f00) | ((newreg & 0x1f) << 8);
         change = newreg != oldreg;
         if (change)
                 oxygen_write_ac97(chip, codec, index, newreg);
@@ -673,7 +681,7 @@ static int ac97_fp_rec_volume_put(struct snd_kcontrol *ctl,
                 .private_value = ((codec) << 24) | ((invert) << 16) | \
                                  ((bitnr) << 8) | (index), \
         }
-#define AC97_VOLUME(xname, codec, index) { \
+#define AC97_VOLUME(xname, codec, index, stereo) { \
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
                 .name = xname, \
                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
@@ -682,7 +690,7 @@ static int ac97_fp_rec_volume_put(struct snd_kcontrol *ctl,
                 .get = ac97_volume_get, \
                 .put = ac97_volume_put, \
                 .tlv = { .p = ac97_db_scale, }, \
-                .private_value = ((codec) << 24) | (index), \
+                .private_value = ((codec) << 24) | ((stereo) << 16) | (index), \
         }
 
 static DECLARE_TLV_DB_SCALE(monitor_db_scale, -1000, 1000, 0);
@@ -882,18 +890,18 @@ static const struct {
 };
 
 static const struct snd_kcontrol_new ac97_controls[] = {
-        AC97_VOLUME("Mic Capture Volume", 0, AC97_MIC),
+        AC97_VOLUME("Mic Capture Volume", 0, AC97_MIC, 0),
         AC97_SWITCH("Mic Capture Switch", 0, AC97_MIC, 15, 1),
         AC97_SWITCH("Mic Boost (+20dB)", 0, AC97_MIC, 6, 0),
         AC97_SWITCH("Line Capture Switch", 0, AC97_LINE, 15, 1),
-        AC97_VOLUME("CD Capture Volume", 0, AC97_CD),
+        AC97_VOLUME("CD Capture Volume", 0, AC97_CD, 1),
         AC97_SWITCH("CD Capture Switch", 0, AC97_CD, 15, 1),
-        AC97_VOLUME("Aux Capture Volume", 0, AC97_AUX),
+        AC97_VOLUME("Aux Capture Volume", 0, AC97_AUX, 1),
         AC97_SWITCH("Aux Capture Switch", 0, AC97_AUX, 15, 1),
 };
 
 static const struct snd_kcontrol_new ac97_fp_controls[] = {
-        AC97_VOLUME("Front Panel Playback Volume", 1, AC97_HEADPHONE),
+        AC97_VOLUME("Front Panel Playback Volume", 1, AC97_HEADPHONE, 1),
         AC97_SWITCH("Front Panel Playback Switch", 1, AC97_HEADPHONE, 15, 1),
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
diff --git a/sound/pci/oxygen/oxygen_pcm.c b/sound/pci/oxygen/oxygen_pcm.c
index 3b5ca70c9d4d..ef2345d82b86 100644
--- a/sound/pci/oxygen/oxygen_pcm.c
+++ b/sound/pci/oxygen/oxygen_pcm.c
@@ -469,9 +469,11 @@ static int oxygen_multich_hw_params(struct snd_pcm_substream *substream,
         oxygen_write16_masked(chip, OXYGEN_I2S_MULTICH_FORMAT,
                               oxygen_rate(hw_params) |
                               chip->model.dac_i2s_format |
+                              oxygen_i2s_mclk(hw_params) |
                               oxygen_i2s_bits(hw_params),
                               OXYGEN_I2S_RATE_MASK |
                               OXYGEN_I2S_FORMAT_MASK |
+                              OXYGEN_I2S_MCLK_MASK |
                               OXYGEN_I2S_BITS_MASK);
         oxygen_update_dac_routing(chip);
         oxygen_update_spdif_source(chip);
diff --git a/sound/pci/oxygen/virtuoso.c b/sound/pci/oxygen/virtuoso.c
index bf971f7cfdc6..6ebcb6bdd712 100644
--- a/sound/pci/oxygen/virtuoso.c
+++ b/sound/pci/oxygen/virtuoso.c
@@ -635,6 +635,8 @@ static void xonar_d2_resume(struct oxygen *chip)
 
 static void xonar_d1_resume(struct oxygen *chip)
 {
+        oxygen_set_bits8(chip, OXYGEN_FUNCTION, OXYGEN_FUNCTION_RESET_CODEC);
+        msleep(1);
         cs43xx_init(chip);
         xonar_enable_output(chip);
 }
diff --git a/sound/pci/riptide/riptide.c b/sound/pci/riptide/riptide.c
index 235a71e5ac8d..b5ca02e2038c 100644
--- a/sound/pci/riptide/riptide.c
+++ b/sound/pci/riptide/riptide.c
@@ -2197,9 +2197,12 @@ static int __init alsa_card_riptide_init(void)
         if (err < 0)
                 return err;
 #if defined(SUPPORT_JOYSTICK)
-        pci_register_driver(&joystick_driver);
+        err = pci_register_driver(&joystick_driver);
+        /* On failure unregister formerly registered audio driver */
+        if (err < 0)
+                pci_unregister_driver(&driver);
 #endif
-        return 0;
+        return err;
 }
 
 static void __exit alsa_card_riptide_exit(void)
diff --git a/sound/pci/rme32.c b/sound/pci/rme32.c
index d7b966e7c4cf..f977dba7cbd0 100644
--- a/sound/pci/rme32.c
+++ b/sound/pci/rme32.c
@@ -227,12 +227,9 @@ struct rme32 {
 };
 
 static struct pci_device_id snd_rme32_ids[] = {
-        {PCI_VENDOR_ID_XILINX_RME, PCI_DEVICE_ID_RME_DIGI32,
-         PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0,},
-        {PCI_VENDOR_ID_XILINX_RME, PCI_DEVICE_ID_RME_DIGI32_8,
-         PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0,},
-        {PCI_VENDOR_ID_XILINX_RME, PCI_DEVICE_ID_RME_DIGI32_PRO,
-         PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0,},
+        {PCI_VDEVICE(XILINX_RME, PCI_DEVICE_ID_RME_DIGI32), 0,},
+        {PCI_VDEVICE(XILINX_RME, PCI_DEVICE_ID_RME_DIGI32_8), 0,},
+        {PCI_VDEVICE(XILINX_RME, PCI_DEVICE_ID_RME_DIGI32_PRO), 0,},
         {0,}
 };
 
diff --git a/sound/pci/rme96.c b/sound/pci/rme96.c
index 55fb1c131f58..2ba5c0fd55db 100644
--- a/sound/pci/rme96.c
+++ b/sound/pci/rme96.c
@@ -232,14 +232,10 @@ struct rme96 {
 };
 
 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, }
 };
 
diff --git a/sound/pci/rme9652/hdsp.c b/sound/pci/rme9652/hdsp.c
index 3da5c029f93b..7bb827c7d806 100644
--- a/sound/pci/rme9652/hdsp.c
+++ b/sound/pci/rme9652/hdsp.c
@@ -3294,15 +3294,33 @@ snd_hdsp_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
         char *clock_source;
         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;
                         }
                 } else {
@@ -3319,18 +3337,6 @@ snd_hdsp_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
                 }
         }
 
-        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));
         snd_iprintf(buffer, "MIDI1 Input status: 0x%x\n", hdsp_read(hdsp, HDSP_midiStatusIn0));
@@ -3351,7 +3357,6 @@ snd_hdsp_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
 
         snd_iprintf(buffer, "\n");
 
-
         switch (hdsp_clock_source(hdsp)) {
         case HDSP_CLOCK_SOURCE_AUTOSYNC:
                 clock_source = "AutoSync";
diff --git a/sound/pci/sonicvibes.c b/sound/pci/sonicvibes.c
index 7dc60ad4772e..1f6406c4534d 100644
--- a/sound/pci/sonicvibes.c
+++ b/sound/pci/sonicvibes.c
@@ -243,7 +243,7 @@ struct sonicvibes {
 };
 
 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, }
 };
 
diff --git a/sound/pci/via82xx.c b/sound/pci/via82xx.c
index 949fcaf6b70e..acfa4760da49 100644
--- a/sound/pci/via82xx.c
+++ b/sound/pci/via82xx.c
@@ -402,9 +402,9 @@ struct via82xx {
 
 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, }
 };
 
diff --git a/sound/pci/via82xx_modem.c b/sound/pci/via82xx_modem.c
index 0d54e3503c1e..47eb61561dfc 100644
--- a/sound/pci/via82xx_modem.c
+++ b/sound/pci/via82xx_modem.c
@@ -261,7 +261,7 @@ struct via82xx_modem {
 };
 
 static struct pci_device_id snd_via82xx_modem_ids[] = {
-        { 0x1106, 0x3068, PCI_ANY_ID, PCI_ANY_ID, 0, 0, TYPE_CARD_VIA82XX_MODEM, },
+        { PCI_VDEVICE(VIA, 0x3068), TYPE_CARD_VIA82XX_MODEM, },
         { 0, }
 };
 
diff --git a/sound/pci/vx222/vx222_ops.c b/sound/pci/vx222/vx222_ops.c
index 6416d3f0c7be..a69e774d0b13 100644
--- a/sound/pci/vx222/vx222_ops.c
+++ b/sound/pci/vx222/vx222_ops.c
@@ -885,10 +885,10 @@ static int vx_input_level_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem
         struct vx_core *_chip = snd_kcontrol_chip(kcontrol);
         struct snd_vx222 *chip = (struct snd_vx222 *)_chip;
         if (ucontrol->value.integer.value[0] < 0 ||
-            ucontrol->value.integer.value[0] < MIC_LEVEL_MAX)
+            ucontrol->value.integer.value[0] > MIC_LEVEL_MAX)
                 return -EINVAL;
         if (ucontrol->value.integer.value[1] < 0 ||
-            ucontrol->value.integer.value[1] < MIC_LEVEL_MAX)
+            ucontrol->value.integer.value[1] > MIC_LEVEL_MAX)
                 return -EINVAL;
         mutex_lock(&_chip->mixer_mutex);
         if (chip->input_level[0] != ucontrol->value.integer.value[0] ||
diff --git a/sound/pci/ymfpci/ymfpci.c b/sound/pci/ymfpci/ymfpci.c
index 4af66661f9b0..e6b18b90d451 100644
--- a/sound/pci/ymfpci/ymfpci.c
+++ b/sound/pci/ymfpci/ymfpci.c
@@ -67,12 +67,12 @@ module_param_array(rear_switch, bool, NULL, 0444);
 MODULE_PARM_DESC(rear_switch, "Enable shared rear/line-in switch");
 
 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, }
 };
 
diff --git a/sound/pci/ymfpci/ymfpci_main.c b/sound/pci/ymfpci/ymfpci_main.c
index 2f0925236a1b..5518371db13f 100644
--- a/sound/pci/ymfpci/ymfpci_main.c
+++ b/sound/pci/ymfpci/ymfpci_main.c
@@ -834,7 +834,7 @@ static irqreturn_t snd_ymfpci_interrupt(int irq, void *dev_id)
         status = snd_ymfpci_readw(chip, YDSXGR_INTFLAG);
         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);
 
@@ -1885,8 +1885,18 @@ static int snd_ymfpci_timer_start(struct snd_timer *timer)
         unsigned int count;
 
         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);
         spin_unlock_irqrestore(&chip->reg_lock, flags);
@@ -1909,14 +1919,14 @@ static int snd_ymfpci_timer_precise_resolution(struct snd_timer *timer,
                                                unsigned long *num, unsigned long *den)
 {
         *num = 1;
-        *den = 48000;
+        *den = 96000;
         return 0;
 }
 
 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,
         .precise_resolution = snd_ymfpci_timer_precise_resolution,
diff --git a/sound/ppc/keywest.c b/sound/ppc/keywest.c
index 835fa19ed461..d06f780bd7e8 100644
--- a/sound/ppc/keywest.c
+++ b/sound/ppc/keywest.c
@@ -59,6 +59,18 @@ static int keywest_attach_adapter(struct i2c_adapter *adapter)
         strlcpy(info.type, "keywest", I2C_NAME_SIZE);
         info.addr = keywest_ctx->addr;
         keywest_ctx->client = i2c_new_device(adapter, &info);
+        if (!keywest_ctx->client)
+                return -ENODEV;
+        /*
+         * We know the driver is already loaded, so the device should be
+         * already bound. If not it means binding failed, and then there
+         * is no point in keeping the device instantiated.
+         */
+        if (!keywest_ctx->client->driver) {
+                i2c_unregister_device(keywest_ctx->client);
+                keywest_ctx->client = NULL;
+                return -ENODEV;
+        }
         
         /*
          * Let i2c-core delete that device on driver removal.
@@ -86,7 +98,7 @@ static const struct i2c_device_id keywest_i2c_id[] = {
         { }
 };
 
-struct i2c_driver keywest_driver = {
+static struct i2c_driver keywest_driver = {
         .driver = {
                 .name = "PMac Keywest Audio",
         },
diff --git a/sound/soc/codecs/wm8988.c b/sound/soc/codecs/wm8988.c
index 1c8653523c8c..3f530f8a972a 100644
--- a/sound/soc/codecs/wm8988.c
+++ b/sound/soc/codecs/wm8988.c
@@ -992,14 +992,14 @@ static int __devinit wm8988_spi_probe(struct spi_device *spi)
         codec->control_data = spi;
         codec->dev = &spi->dev;
 
-        spi->dev.driver_data = wm8988;
+        dev_set_drvdata(&spi->dev, wm8988);
 
         return wm8988_register(wm8988, SND_SOC_SPI);
 }
 
 static int __devexit wm8988_spi_remove(struct spi_device *spi)
 {
-        struct wm8988_priv *wm8988 = spi->dev.driver_data;
+        struct wm8988_priv *wm8988 = dev_get_drvdata(&spi->dev);
 
         wm8988_unregister(wm8988);
 
diff --git a/sound/soc/fsl/efika-audio-fabric.c b/sound/soc/fsl/efika-audio-fabric.c
index 85b0e7569504..3326e2a1e863 100644
--- a/sound/soc/fsl/efika-audio-fabric.c
+++ b/sound/soc/fsl/efika-audio-fabric.c
@@ -30,6 +30,8 @@
 #include "mpc5200_psc_ac97.h"
 #include "../codecs/stac9766.h"
 
+#define DRV_NAME "efika-audio-fabric"
+
 static struct snd_soc_device device;
 static struct snd_soc_card card;
 
diff --git a/sound/soc/fsl/pcm030-audio-fabric.c b/sound/soc/fsl/pcm030-audio-fabric.c
index 8766f7a3893d..b928ef7d28eb 100644
--- a/sound/soc/fsl/pcm030-audio-fabric.c
+++ b/sound/soc/fsl/pcm030-audio-fabric.c
@@ -30,6 +30,8 @@
 #include "mpc5200_psc_ac97.h"
 #include "../codecs/wm9712.h"
 
+#define DRV_NAME "pcm030-audio-fabric"
+
 static struct snd_soc_device device;
 static struct snd_soc_card card;
 
diff --git a/sound/sound_core.c b/sound/sound_core.c
index 12522e6913d9..bb4b88e606bb 100644
--- a/sound/sound_core.c
+++ b/sound/sound_core.c
@@ -10,6 +10,8 @@
 #include <linux/module.h>
 #include <linux/device.h>
 #include <linux/err.h>
+#include <linux/kdev_t.h>
+#include <linux/major.h>
 #include <sound/core.h>
 
 #ifdef CONFIG_SOUND_OSS_CORE
@@ -29,6 +31,8 @@ MODULE_LICENSE("GPL");
 
 static char *sound_nodename(struct device *dev)
 {
+        if (MAJOR(dev->devt) == SOUND_MAJOR)
+                return NULL;
         return kasprintf(GFP_KERNEL, "snd/%s", dev_name(dev));
 }
 
@@ -104,7 +108,6 @@ module_exit(cleanup_soundcore);
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/sound.h>
-#include <linux/major.h>
 #include <linux/kmod.h>
 
 #define SOUND_STEP 16
@@ -125,6 +128,46 @@ extern int msnd_pinnacle_init(void);
 #endif
 
 /*
+ * By default, OSS sound_core claims full legacy minor range (0-255)
+ * of SOUND_MAJOR to trap open attempts to any sound minor and
+ * requests modules using custom sound-slot/service-* module aliases.
+ * The only benefit of doing this is allowing use of custom module
+ * aliases instead of the standard char-major-* ones.  This behavior
+ * prevents alternative OSS implementation and is scheduled to be
+ * removed.
+ *
+ * CONFIG_SOUND_OSS_CORE_PRECLAIM and soundcore.preclaim_oss kernel
+ * parameter are added to allow distros and developers to try and
+ * switch to alternative implementations without needing to rebuild
+ * the kernel in the meantime.  If preclaim_oss is non-zero, the
+ * kernel will behave the same as before.  All SOUND_MAJOR minors are
+ * preclaimed and the custom module aliases along with standard chrdev
+ * ones are emitted if a missing device is opened.  If preclaim_oss is
+ * zero, sound_core only grabs what's actually in use and for missing
+ * devices only the standard chrdev aliases are requested.
+ *
+ * All these clutters are scheduled to be removed along with
+ * sound-slot/service-* module aliases.  Please take a look at
+ * feature-removal-schedule.txt for details.
+ */
+#ifdef CONFIG_SOUND_OSS_CORE_PRECLAIM
+static int preclaim_oss = 1;
+#else
+static int preclaim_oss = 0;
+#endif
+
+module_param(preclaim_oss, int, 0444);
+
+static int soundcore_open(struct inode *, struct file *);
+
+static const struct file_operations soundcore_fops =
+{
+        /* We must have an owner or the module locking fails */
+        .owner  = THIS_MODULE,
+        .open   = soundcore_open,
+};
+
+/*
  *      Low level list operator. Scan the ordered list, find a hole and
  *      join into it. Called with the lock asserted
  */
@@ -216,8 +259,9 @@ static int sound_insert_unit(struct sound_unit **list, const struct file_operati
 
         if (!s)
                 return -ENOMEM;
-                
+
         spin_lock(&sound_loader_lock);
+retry:
         r = __sound_insert_unit(s, list, fops, index, low, top);
         spin_unlock(&sound_loader_lock);
         
@@ -228,11 +272,31 @@ static int sound_insert_unit(struct sound_unit **list, const struct file_operati
         else
                 sprintf(s->name, "sound/%s%d", name, r / SOUND_STEP);
 
+        if (!preclaim_oss) {
+                /*
+                 * Something else might have grabbed the minor.  If
+                 * first free slot is requested, rescan with @low set
+                 * to the next unit; otherwise, -EBUSY.
+                 */
+                r = __register_chrdev(SOUND_MAJOR, s->unit_minor, 1, s->name,
+                                      &soundcore_fops);
+                if (r < 0) {
+                        spin_lock(&sound_loader_lock);
+                        __sound_remove_unit(list, s->unit_minor);
+                        if (index < 0) {
+                                low = s->unit_minor + SOUND_STEP;
+                                goto retry;
+                        }
+                        spin_unlock(&sound_loader_lock);
+                        return -EBUSY;
+                }
+        }
+
         device_create(sound_class, dev, MKDEV(SOUND_MAJOR, s->unit_minor),
                       NULL, s->name+6);
-        return r;
+        return s->unit_minor;
 
- fail:
+fail:
         kfree(s);
         return r;
 }
@@ -251,6 +315,9 @@ static void sound_remove_unit(struct sound_unit **list, int unit)
         p = __sound_remove_unit(list, unit);
         spin_unlock(&sound_loader_lock);
         if (p) {
+                if (!preclaim_oss)
+                        __unregister_chrdev(SOUND_MAJOR, p->unit_minor, 1,
+                                            p->name);
                 device_destroy(sound_class, MKDEV(SOUND_MAJOR, p->unit_minor));
                 kfree(p);
         }
@@ -488,19 +555,6 @@ void unregister_sound_dsp(int unit)
 
 EXPORT_SYMBOL(unregister_sound_dsp);
 
-/*
- *      Now our file operations
- */
-
-static int soundcore_open(struct inode *, struct file *);
-
-static const struct file_operations soundcore_fops=
-{
-        /* We must have an owner or the module locking fails */
-        .owner  = THIS_MODULE,
-        .open   = soundcore_open,
-};
-
 static struct sound_unit *__look_for_unit(int chain, int unit)
 {
         struct sound_unit *s;
@@ -536,8 +590,9 @@ static int soundcore_open(struct inode *inode, struct file *file)
         s = __look_for_unit(chain, unit);
         if (s)
                 new_fops = fops_get(s->unit_fops);
-        if (!new_fops) {
+        if (preclaim_oss && !new_fops) {
                 spin_unlock(&sound_loader_lock);
+
                 /*
                  *  Please, don't change this order or code.
                  *  For ALSA slot means soundcard and OSS emulation code
@@ -547,6 +602,17 @@ static int soundcore_open(struct inode *inode, struct file *file)
                  */
                 request_module("sound-slot-%i", unit>>4);
                 request_module("sound-service-%i-%i", unit>>4, chain);
+
+                /*
+                 * sound-slot/service-* module aliases are scheduled
+                 * for removal in favor of the standard char-major-*
+                 * module aliases.  For the time being, generate both
+                 * the legacy and standard module aliases to ease
+                 * transition.
+                 */
+                if (request_module("char-major-%d-%d", SOUND_MAJOR, unit) > 0)
+                        request_module("char-major-%d", SOUND_MAJOR);
+
                 spin_lock(&sound_loader_lock);
                 s = __look_for_unit(chain, unit);
                 if (s)
@@ -590,7 +656,8 @@ static void cleanup_oss_soundcore(void)
 
 static int __init init_oss_soundcore(void)
 {
-        if (register_chrdev(SOUND_MAJOR, "sound", &soundcore_fops)==-1) {
+        if (preclaim_oss &&
+            register_chrdev(SOUND_MAJOR, "sound", &soundcore_fops) == -1) {
                 printk(KERN_ERR "soundcore: sound device already in use.\n");
                 return -EBUSY;
         }
diff --git a/sound/usb/Kconfig b/sound/usb/Kconfig
index 523aec188ccf..73525c048e7f 100644
--- a/sound/usb/Kconfig
+++ b/sound/usb/Kconfig
@@ -48,6 +48,7 @@ config SND_USB_CAIAQ
             * Native Instruments Kore Controller
             * Native Instruments Kore Controller 2
             * Native Instruments Audio Kontrol 1
+            * Native Instruments Audio 2 DJ
             * Native Instruments Audio 4 DJ
             * Native Instruments Audio 8 DJ
             * Native Instruments Guitar Rig Session I/O
diff --git a/sound/usb/caiaq/audio.c b/sound/usb/caiaq/audio.c
index 8f9b60c5d74c..121af0644fd9 100644
--- a/sound/usb/caiaq/audio.c
+++ b/sound/usb/caiaq/audio.c
@@ -646,6 +646,7 @@ int snd_usb_caiaq_audio_init(struct snd_usb_caiaqdev *dev)
         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_GUITARRIGMOBILE):
                 dev->samplerates |= SNDRV_PCM_RATE_192000;
                 /* fall thru */
+        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO2DJ):
         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO4DJ):
         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO8DJ):
                 dev->samplerates |= SNDRV_PCM_RATE_88200;
diff --git a/sound/usb/caiaq/device.c b/sound/usb/caiaq/device.c
index 0e5db719de24..83e6c1312d47 100644
--- a/sound/usb/caiaq/device.c
+++ b/sound/usb/caiaq/device.c
@@ -35,13 +35,14 @@
 #include "input.h"
 
 MODULE_AUTHOR("Daniel Mack <daniel@caiaq.de>");
-MODULE_DESCRIPTION("caiaq USB audio, version 1.3.17");
+MODULE_DESCRIPTION("caiaq USB audio, version 1.3.19");
 MODULE_LICENSE("GPL");
 MODULE_SUPPORTED_DEVICE("{{Native Instruments, RigKontrol2},"
                          "{Native Instruments, RigKontrol3},"
                          "{Native Instruments, Kore Controller},"
                          "{Native Instruments, Kore Controller 2},"
                          "{Native Instruments, Audio Kontrol 1},"
+                         "{Native Instruments, Audio 2 DJ},"
                          "{Native Instruments, Audio 4 DJ},"
                          "{Native Instruments, Audio 8 DJ},"
                          "{Native Instruments, Session I/O},"
@@ -121,6 +122,11 @@ static struct usb_device_id snd_usb_id_table[] = {
                 .idVendor =     USB_VID_NATIVEINSTRUMENTS,
                 .idProduct =    USB_PID_AUDIO4DJ
         },
+        {
+                .match_flags =  USB_DEVICE_ID_MATCH_DEVICE,
+                .idVendor =     USB_VID_NATIVEINSTRUMENTS,
+                .idProduct =    USB_PID_AUDIO2DJ
+        },
         { /* terminator */ }
 };
 
@@ -349,7 +355,9 @@ static void __devinit setup_card(struct snd_usb_caiaqdev *dev)
                 log("Unable to set up control system (ret=%d)\n", ret);
 }
 
-static int create_card(struct usb_device* usb_dev, struct snd_card **cardp)
+static int create_card(struct usb_device *usb_dev,
+                       struct usb_interface *intf,
+                       struct snd_card **cardp)
 {
         int devnum;
         int err;
@@ -374,7 +382,7 @@ static int create_card(struct usb_device* usb_dev, struct snd_card **cardp)
         dev->chip.usb_id = USB_ID(le16_to_cpu(usb_dev->descriptor.idVendor),
                                   le16_to_cpu(usb_dev->descriptor.idProduct));
         spin_lock_init(&dev->spinlock);
-        snd_card_set_dev(card, &usb_dev->dev);
+        snd_card_set_dev(card, &intf->dev);
 
         *cardp = card;
         return 0;
@@ -461,7 +469,7 @@ static int __devinit snd_probe(struct usb_interface *intf,
         struct snd_card *card;
         struct usb_device *device = interface_to_usbdev(intf);
 
-        ret = create_card(device, &card);
+        ret = create_card(device, intf, &card);
 
         if (ret < 0)
                 return ret;
diff --git a/sound/usb/caiaq/device.h b/sound/usb/caiaq/device.h
index ece73514854e..44e3edf88bef 100644
--- a/sound/usb/caiaq/device.h
+++ b/sound/usb/caiaq/device.h
@@ -10,6 +10,7 @@
 #define USB_PID_KORECONTROLLER  0x4711
 #define USB_PID_KORECONTROLLER2 0x4712
 #define USB_PID_AK1             0x0815
+#define USB_PID_AUDIO2DJ        0x041c
 #define USB_PID_AUDIO4DJ        0x0839
 #define USB_PID_AUDIO8DJ        0x1978
 #define USB_PID_SESSIONIO       0x1915
diff --git a/sound/usb/usbaudio.c b/sound/usb/usbaudio.c
index c7b902358b7b..8db0374e10d5 100644
--- a/sound/usb/usbaudio.c
+++ b/sound/usb/usbaudio.c
@@ -1083,6 +1083,8 @@ static int init_substream_urbs(struct snd_usb_substream *subs, unsigned int peri
         } else
                 urb_packs = 1;
         urb_packs *= packs_per_ms;
+        if (subs->syncpipe)
+                urb_packs = min(urb_packs, 1U << subs->syncinterval);
 
         /* decide how many packets to be used */
         if (is_playback) {
@@ -2124,8 +2126,8 @@ static void proc_dump_substream_formats(struct snd_usb_substream *subs, struct s
                 fp = list_entry(p, struct audioformat, list);
                 snd_iprintf(buffer, "  Interface %d\n", fp->iface);
                 snd_iprintf(buffer, "    Altset %d\n", fp->altsetting);
-                snd_iprintf(buffer, "    Format: %#x (%d bits)\n",
-                            fp->format, snd_pcm_format_width(fp->format));
+                snd_iprintf(buffer, "    Format: %s\n",
+                            snd_pcm_format_name(fp->format));
                 snd_iprintf(buffer, "    Channels: %d\n", fp->channels);
                 snd_iprintf(buffer, "    Endpoint: %d %s (%s)\n",
                             fp->endpoint & USB_ENDPOINT_NUMBER_MASK,
@@ -2661,7 +2663,7 @@ static int parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
         struct usb_interface_descriptor *altsd;
         int i, altno, err, stream;
         int format;
-        struct audioformat *fp;
+        struct audioformat *fp = NULL;
         unsigned char *fmt, *csep;
         int num;
 
@@ -2734,6 +2736,18 @@ static int parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
                         continue;
                 }
 
+                /*
+                 * Blue Microphones workaround: The last altsetting is identical
+                 * with the previous one, except for a larger packet size, but
+                 * is actually a mislabeled two-channel setting; ignore it.
+                 */
+                if (fmt[4] == 1 && fmt[5] == 2 && altno == 2 && num == 3 &&
+                    fp && fp->altsetting == 1 && fp->channels == 1 &&
+                    fp->format == SNDRV_PCM_FORMAT_S16_LE &&
+                    le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize) ==
+                                                        fp->maxpacksize * 2)
+                        continue;
+
                 csep = snd_usb_find_desc(alts->endpoint[0].extra, alts->endpoint[0].extralen, NULL, USB_DT_CS_ENDPOINT);
                 /* Creamware Noah has this descriptor after the 2nd endpoint */
                 if (!csep && altsd->bNumEndpoints >= 2)
diff --git a/sound/usb/usbmidi.c b/sound/usb/usbmidi.c
index 2fb35cc22a30..0eff19ceb7e1 100644
--- a/sound/usb/usbmidi.c
+++ b/sound/usb/usbmidi.c
@@ -45,6 +45,7 @@
 #include <linux/slab.h>
 #include <linux/timer.h>
 #include <linux/usb.h>
+#include <linux/wait.h>
 #include <sound/core.h>
 #include <sound/rawmidi.h>
 #include <sound/asequencer.h>
@@ -62,6 +63,9 @@
  */
 #define ERROR_DELAY_JIFFIES (HZ / 10)
 
+#define OUTPUT_URBS 7
+#define INPUT_URBS 7
+
 
 MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>");
 MODULE_DESCRIPTION("USB Audio/MIDI helper module");
@@ -90,7 +94,7 @@ struct snd_usb_midi_endpoint;
 
 struct usb_protocol_ops {
         void (*input)(struct snd_usb_midi_in_endpoint*, uint8_t*, int);
-        void (*output)(struct snd_usb_midi_out_endpoint*);
+        void (*output)(struct snd_usb_midi_out_endpoint *ep, struct urb *urb);
         void (*output_packet)(struct urb*, uint8_t, uint8_t, uint8_t, uint8_t);
         void (*init_out_endpoint)(struct snd_usb_midi_out_endpoint*);
         void (*finish_out_endpoint)(struct snd_usb_midi_out_endpoint*);
@@ -116,11 +120,15 @@ struct snd_usb_midi {
 
 struct snd_usb_midi_out_endpoint {
         struct snd_usb_midi* umidi;
-        struct urb* urb;
-        int urb_active;
+        struct out_urb_context {
+                struct urb *urb;
+                struct snd_usb_midi_out_endpoint *ep;
+        } urbs[OUTPUT_URBS];
+        unsigned int active_urbs;
+        unsigned int drain_urbs;
         int max_transfer;               /* size of urb buffer */
         struct tasklet_struct tasklet;
-
+        unsigned int next_urb;
         spinlock_t buffer_lock;
 
         struct usbmidi_out_port {
@@ -139,11 +147,13 @@ struct snd_usb_midi_out_endpoint {
                 uint8_t data[2];
         } ports[0x10];
         int current_port;
+
+        wait_queue_head_t drain_wait;
 };
 
 struct snd_usb_midi_in_endpoint {
         struct snd_usb_midi* umidi;
-        struct urb* urb;
+        struct urb* urbs[INPUT_URBS];
         struct usbmidi_in_port {
                 struct snd_rawmidi_substream *substream;
                 u8 running_status_length;
@@ -251,10 +261,17 @@ static void snd_usbmidi_in_urb_complete(struct urb* urb)
 
 static void snd_usbmidi_out_urb_complete(struct urb* urb)
 {
-        struct snd_usb_midi_out_endpoint* ep = urb->context;
+        struct out_urb_context *context = urb->context;
+        struct snd_usb_midi_out_endpoint* ep = context->ep;
+        unsigned int urb_index;
 
         spin_lock(&ep->buffer_lock);
-        ep->urb_active = 0;
+        urb_index = context - ep->urbs;
+        ep->active_urbs &= ~(1 << urb_index);
+        if (unlikely(ep->drain_urbs)) {
+                ep->drain_urbs &= ~(1 << urb_index);
+                wake_up(&ep->drain_wait);
+        }
         spin_unlock(&ep->buffer_lock);
         if (urb->status < 0) {
                 int err = snd_usbmidi_urb_error(urb->status);
@@ -274,24 +291,38 @@ static void snd_usbmidi_out_urb_complete(struct urb* urb)
  */
 static void snd_usbmidi_do_output(struct snd_usb_midi_out_endpoint* ep)
 {
-        struct urb* urb = ep->urb;
+        unsigned int urb_index;
+        struct urb* urb;
         unsigned long flags;
 
         spin_lock_irqsave(&ep->buffer_lock, flags);
-        if (ep->urb_active || ep->umidi->chip->shutdown) {
+        if (ep->umidi->chip->shutdown) {
                 spin_unlock_irqrestore(&ep->buffer_lock, flags);
                 return;
         }
 
-        urb->transfer_buffer_length = 0;
-        ep->umidi->usb_protocol_ops->output(ep);
+        urb_index = ep->next_urb;
+        for (;;) {
+                if (!(ep->active_urbs & (1 << urb_index))) {
+                        urb = ep->urbs[urb_index].urb;
+                        urb->transfer_buffer_length = 0;
+                        ep->umidi->usb_protocol_ops->output(ep, urb);
+                        if (urb->transfer_buffer_length == 0)
+                                break;
 
-        if (urb->transfer_buffer_length > 0) {
-                dump_urb("sending", urb->transfer_buffer,
-                         urb->transfer_buffer_length);
-                urb->dev = ep->umidi->chip->dev;
-                ep->urb_active = snd_usbmidi_submit_urb(urb, GFP_ATOMIC) >= 0;
+                        dump_urb("sending", urb->transfer_buffer,
+                                 urb->transfer_buffer_length);
+                        urb->dev = ep->umidi->chip->dev;
+                        if (snd_usbmidi_submit_urb(urb, GFP_ATOMIC) < 0)
+                                break;
+                        ep->active_urbs |= 1 << urb_index;
+                }
+                if (++urb_index >= OUTPUT_URBS)
+                        urb_index = 0;
+                if (urb_index == ep->next_urb)
+                        break;
         }
+        ep->next_urb = urb_index;
         spin_unlock_irqrestore(&ep->buffer_lock, flags);
 }
 
@@ -306,7 +337,7 @@ static void snd_usbmidi_out_tasklet(unsigned long data)
 static void snd_usbmidi_error_timer(unsigned long data)
 {
         struct snd_usb_midi *umidi = (struct snd_usb_midi *)data;
-        int i;
+        unsigned int i, j;
 
         spin_lock(&umidi->disc_lock);
         if (umidi->disconnected) {
@@ -317,8 +348,10 @@ static void snd_usbmidi_error_timer(unsigned long data)
                 struct snd_usb_midi_in_endpoint *in = umidi->endpoints[i].in;
                 if (in && in->error_resubmit) {
                         in->error_resubmit = 0;
-                        in->urb->dev = umidi->chip->dev;
-                        snd_usbmidi_submit_urb(in->urb, GFP_ATOMIC);
+                        for (j = 0; j < INPUT_URBS; ++j) {
+                                in->urbs[j]->dev = umidi->chip->dev;
+                                snd_usbmidi_submit_urb(in->urbs[j], GFP_ATOMIC);
+                        }
                 }
                 if (umidi->endpoints[i].out)
                         snd_usbmidi_do_output(umidi->endpoints[i].out);
@@ -330,13 +363,14 @@ static void snd_usbmidi_error_timer(unsigned long data)
 static int send_bulk_static_data(struct snd_usb_midi_out_endpoint* ep,
                                  const void *data, int len)
 {
-        int err;
+        int err = 0;
         void *buf = kmemdup(data, len, GFP_KERNEL);
         if (!buf)
                 return -ENOMEM;
         dump_urb("sending", buf, len);
-        err = usb_bulk_msg(ep->umidi->chip->dev, ep->urb->pipe, buf, len,
-                           NULL, 250);
+        if (ep->urbs[0].urb)
+                err = usb_bulk_msg(ep->umidi->chip->dev, ep->urbs[0].urb->pipe,
+                                   buf, len, NULL, 250);
         kfree(buf);
         return err;
 }
@@ -554,9 +588,9 @@ static void snd_usbmidi_transmit_byte(struct usbmidi_out_port* port,
         }
 }
 
-static void snd_usbmidi_standard_output(struct snd_usb_midi_out_endpoint* ep)
+static void snd_usbmidi_standard_output(struct snd_usb_midi_out_endpoint* ep,
+                                        struct urb *urb)
 {
-        struct urb* urb = ep->urb;
         int p;
 
         /* FIXME: lower-numbered ports can starve higher-numbered ports */
@@ -613,14 +647,15 @@ static void snd_usbmidi_novation_input(struct snd_usb_midi_in_endpoint* ep,
         snd_usbmidi_input_data(ep, 0, &buffer[2], buffer[0] - 1);
 }
 
-static void snd_usbmidi_novation_output(struct snd_usb_midi_out_endpoint* ep)
+static void snd_usbmidi_novation_output(struct snd_usb_midi_out_endpoint* ep,
+                                        struct urb *urb)
 {
         uint8_t* transfer_buffer;
         int count;
 
         if (!ep->ports[0].active)
                 return;
-        transfer_buffer = ep->urb->transfer_buffer;
+        transfer_buffer = urb->transfer_buffer;
         count = snd_rawmidi_transmit(ep->ports[0].substream,
                                      &transfer_buffer[2],
                                      ep->max_transfer - 2);
@@ -630,7 +665,7 @@ static void snd_usbmidi_novation_output(struct snd_usb_midi_out_endpoint* ep)
         }
         transfer_buffer[0] = 0;
         transfer_buffer[1] = count;
-        ep->urb->transfer_buffer_length = 2 + count;
+        urb->transfer_buffer_length = 2 + count;
 }
 
 static struct usb_protocol_ops snd_usbmidi_novation_ops = {
@@ -648,20 +683,21 @@ static void snd_usbmidi_raw_input(struct snd_usb_midi_in_endpoint* ep,
         snd_usbmidi_input_data(ep, 0, buffer, buffer_length);
 }
 
-static void snd_usbmidi_raw_output(struct snd_usb_midi_out_endpoint* ep)
+static void snd_usbmidi_raw_output(struct snd_usb_midi_out_endpoint* ep,
+                                   struct urb *urb)
 {
         int count;
 
         if (!ep->ports[0].active)
                 return;
         count = snd_rawmidi_transmit(ep->ports[0].substream,
-                                     ep->urb->transfer_buffer,
+                                     urb->transfer_buffer,
                                      ep->max_transfer);
         if (count < 1) {
                 ep->ports[0].active = 0;
                 return;
         }
-        ep->urb->transfer_buffer_length = count;
+        urb->transfer_buffer_length = count;
 }
 
 static struct usb_protocol_ops snd_usbmidi_raw_ops = {
@@ -681,23 +717,25 @@ static void snd_usbmidi_us122l_input(struct snd_usb_midi_in_endpoint *ep,
                 snd_usbmidi_input_data(ep, 0, buffer, buffer_length);
 }
 
-static void snd_usbmidi_us122l_output(struct snd_usb_midi_out_endpoint *ep)
+static void snd_usbmidi_us122l_output(struct snd_usb_midi_out_endpoint *ep,
+                                      struct urb *urb)
 {
         int count;
 
         if (!ep->ports[0].active)
                 return;
-        count = ep->urb->dev->speed == USB_SPEED_HIGH ? 1 : 2;
+        count = snd_usb_get_speed(ep->umidi->chip->dev) == USB_SPEED_HIGH
+                ? 1 : 2;
         count = snd_rawmidi_transmit(ep->ports[0].substream,
-                                     ep->urb->transfer_buffer,
+                                     urb->transfer_buffer,
                                      count);
         if (count < 1) {
                 ep->ports[0].active = 0;
                 return;
         }
 
-        memset(ep->urb->transfer_buffer + count, 0xFD, 9 - count);
-        ep->urb->transfer_buffer_length = count;
+        memset(urb->transfer_buffer + count, 0xFD, 9 - count);
+        urb->transfer_buffer_length = count;
 }
 
 static struct usb_protocol_ops snd_usbmidi_122l_ops = {
@@ -786,10 +824,11 @@ static void snd_usbmidi_emagic_input(struct snd_usb_midi_in_endpoint* ep,
         }
 }
 
-static void snd_usbmidi_emagic_output(struct snd_usb_midi_out_endpoint* ep)
+static void snd_usbmidi_emagic_output(struct snd_usb_midi_out_endpoint* ep,
+                                      struct urb *urb)
 {
         int port0 = ep->current_port;
-        uint8_t* buf = ep->urb->transfer_buffer;
+        uint8_t* buf = urb->transfer_buffer;
         int buf_free = ep->max_transfer;
         int length, i;
 
@@ -829,7 +868,7 @@ static void snd_usbmidi_emagic_output(struct snd_usb_midi_out_endpoint* ep)
                 *buf = 0xff;
                 --buf_free;
         }
-        ep->urb->transfer_buffer_length = ep->max_transfer - buf_free;
+        urb->transfer_buffer_length = ep->max_transfer - buf_free;
 }
 
 static struct usb_protocol_ops snd_usbmidi_emagic_ops = {
@@ -884,6 +923,35 @@ static void snd_usbmidi_output_trigger(struct snd_rawmidi_substream *substream,
         }
 }
 
+static void snd_usbmidi_output_drain(struct snd_rawmidi_substream *substream)
+{
+        struct usbmidi_out_port* port = substream->runtime->private_data;
+        struct snd_usb_midi_out_endpoint *ep = port->ep;
+        unsigned int drain_urbs;
+        DEFINE_WAIT(wait);
+        long timeout = msecs_to_jiffies(50);
+
+        /*
+         * The substream buffer is empty, but some data might still be in the
+         * currently active URBs, so we have to wait for those to complete.
+         */
+        spin_lock_irq(&ep->buffer_lock);
+        drain_urbs = ep->active_urbs;
+        if (drain_urbs) {
+                ep->drain_urbs |= drain_urbs;
+                do {
+                        prepare_to_wait(&ep->drain_wait, &wait,
+                                        TASK_UNINTERRUPTIBLE);
+                        spin_unlock_irq(&ep->buffer_lock);
+                        timeout = schedule_timeout(timeout);
+                        spin_lock_irq(&ep->buffer_lock);
+                        drain_urbs &= ep->drain_urbs;
+                } while (drain_urbs && timeout);
+                finish_wait(&ep->drain_wait, &wait);
+        }
+        spin_unlock_irq(&ep->buffer_lock);
+}
+
 static int snd_usbmidi_input_open(struct snd_rawmidi_substream *substream)
 {
         return 0;
@@ -908,6 +976,7 @@ static struct snd_rawmidi_ops snd_usbmidi_output_ops = {
         .open = snd_usbmidi_output_open,
         .close = snd_usbmidi_output_close,
         .trigger = snd_usbmidi_output_trigger,
+        .drain = snd_usbmidi_output_drain,
 };
 
 static struct snd_rawmidi_ops snd_usbmidi_input_ops = {
@@ -916,19 +985,26 @@ static struct snd_rawmidi_ops snd_usbmidi_input_ops = {
         .trigger = snd_usbmidi_input_trigger
 };
 
+static void free_urb_and_buffer(struct snd_usb_midi *umidi, struct urb *urb,
+                                unsigned int buffer_length)
+{
+        usb_buffer_free(umidi->chip->dev, buffer_length,
+                        urb->transfer_buffer, urb->transfer_dma);
+        usb_free_urb(urb);
+}
+
 /*
  * Frees an input endpoint.
  * May be called when ep hasn't been initialized completely.
  */
 static void snd_usbmidi_in_endpoint_delete(struct snd_usb_midi_in_endpoint* ep)
 {
-        if (ep->urb) {
-                usb_buffer_free(ep->umidi->chip->dev,
-                                ep->urb->transfer_buffer_length,
-                                ep->urb->transfer_buffer,
-                                ep->urb->transfer_dma);
-                usb_free_urb(ep->urb);
-        }
+        unsigned int i;
+
+        for (i = 0; i < INPUT_URBS; ++i)
+                if (ep->urbs[i])
+                        free_urb_and_buffer(ep->umidi, ep->urbs[i],
+                                            ep->urbs[i]->transfer_buffer_length);
         kfree(ep);
 }
 
@@ -943,6 +1019,7 @@ static int snd_usbmidi_in_endpoint_create(struct snd_usb_midi* umidi,
         void* buffer;
         unsigned int pipe;
         int length;
+        unsigned int i;
 
         rep->in = NULL;
         ep = kzalloc(sizeof(*ep), GFP_KERNEL);
@@ -950,30 +1027,36 @@ static int snd_usbmidi_in_endpoint_create(struct snd_usb_midi* umidi,
                 return -ENOMEM;
         ep->umidi = umidi;
 
-        ep->urb = usb_alloc_urb(0, GFP_KERNEL);
-        if (!ep->urb) {
-                snd_usbmidi_in_endpoint_delete(ep);
-                return -ENOMEM;
+        for (i = 0; i < INPUT_URBS; ++i) {
+                ep->urbs[i] = usb_alloc_urb(0, GFP_KERNEL);
+                if (!ep->urbs[i]) {
+                        snd_usbmidi_in_endpoint_delete(ep);
+                        return -ENOMEM;
+                }
         }
         if (ep_info->in_interval)
                 pipe = usb_rcvintpipe(umidi->chip->dev, ep_info->in_ep);
         else
                 pipe = usb_rcvbulkpipe(umidi->chip->dev, ep_info->in_ep);
         length = usb_maxpacket(umidi->chip->dev, pipe, 0);
-        buffer = usb_buffer_alloc(umidi->chip->dev, length, GFP_KERNEL,
-                                  &ep->urb->transfer_dma);
-        if (!buffer) {
-                snd_usbmidi_in_endpoint_delete(ep);
-                return -ENOMEM;
+        for (i = 0; i < INPUT_URBS; ++i) {
+                buffer = usb_buffer_alloc(umidi->chip->dev, length, GFP_KERNEL,
+                                          &ep->urbs[i]->transfer_dma);
+                if (!buffer) {
+                        snd_usbmidi_in_endpoint_delete(ep);
+                        return -ENOMEM;
+                }
+                if (ep_info->in_interval)
+                        usb_fill_int_urb(ep->urbs[i], umidi->chip->dev,
+                                         pipe, buffer, length,
+                                         snd_usbmidi_in_urb_complete,
+                                         ep, ep_info->in_interval);
+                else
+                        usb_fill_bulk_urb(ep->urbs[i], umidi->chip->dev,
+                                          pipe, buffer, length,
+                                          snd_usbmidi_in_urb_complete, ep);
+                ep->urbs[i]->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
         }
-        if (ep_info->in_interval)
-                usb_fill_int_urb(ep->urb, umidi->chip->dev, pipe, buffer,
-                                 length, snd_usbmidi_in_urb_complete, ep,
-                                 ep_info->in_interval);
-        else
-                usb_fill_bulk_urb(ep->urb, umidi->chip->dev, pipe, buffer,
-                                  length, snd_usbmidi_in_urb_complete, ep);
-        ep->urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
 
         rep->in = ep;
         return 0;
@@ -994,12 +1077,12 @@ static unsigned int snd_usbmidi_count_bits(unsigned int x)
  */
 static void snd_usbmidi_out_endpoint_delete(struct snd_usb_midi_out_endpoint* ep)
 {
-        if (ep->urb) {
-                usb_buffer_free(ep->umidi->chip->dev, ep->max_transfer,
-                                ep->urb->transfer_buffer,
-                                ep->urb->transfer_dma);
-                usb_free_urb(ep->urb);
-        }
+        unsigned int i;
+
+        for (i = 0; i < OUTPUT_URBS; ++i)
+                if (ep->urbs[i].urb)
+                        free_urb_and_buffer(ep->umidi, ep->urbs[i].urb,
+                                            ep->max_transfer);
         kfree(ep);
 }
 
@@ -1011,7 +1094,7 @@ static int snd_usbmidi_out_endpoint_create(struct snd_usb_midi* umidi,
                                            struct snd_usb_midi_endpoint* rep)
 {
         struct snd_usb_midi_out_endpoint* ep;
-        int i;
+        unsigned int i;
         unsigned int pipe;
         void* buffer;
 
@@ -1021,38 +1104,46 @@ static int snd_usbmidi_out_endpoint_create(struct snd_usb_midi* umidi,
                 return -ENOMEM;
         ep->umidi = umidi;
 
-        ep->urb = usb_alloc_urb(0, GFP_KERNEL);
-        if (!ep->urb) {
-                snd_usbmidi_out_endpoint_delete(ep);
-                return -ENOMEM;
+        for (i = 0; i < OUTPUT_URBS; ++i) {
+                ep->urbs[i].urb = usb_alloc_urb(0, GFP_KERNEL);
+                if (!ep->urbs[i].urb) {
+                        snd_usbmidi_out_endpoint_delete(ep);
+                        return -ENOMEM;
+                }
+                ep->urbs[i].ep = ep;
         }
         if (ep_info->out_interval)
                 pipe = usb_sndintpipe(umidi->chip->dev, ep_info->out_ep);
         else
                 pipe = usb_sndbulkpipe(umidi->chip->dev, ep_info->out_ep);
         if (umidi->chip->usb_id == USB_ID(0x0a92, 0x1020)) /* ESI M4U */
-                /* FIXME: we need more URBs to get reasonable bandwidth here: */
                 ep->max_transfer = 4;
         else
                 ep->max_transfer = usb_maxpacket(umidi->chip->dev, pipe, 1);
-        buffer = usb_buffer_alloc(umidi->chip->dev, ep->max_transfer,
-                                  GFP_KERNEL, &ep->urb->transfer_dma);
-        if (!buffer) {
-                snd_usbmidi_out_endpoint_delete(ep);
-                return -ENOMEM;
+        for (i = 0; i < OUTPUT_URBS; ++i) {
+                buffer = usb_buffer_alloc(umidi->chip->dev,
+                                          ep->max_transfer, GFP_KERNEL,
+                                          &ep->urbs[i].urb->transfer_dma);
+                if (!buffer) {
+                        snd_usbmidi_out_endpoint_delete(ep);
+                        return -ENOMEM;
+                }
+                if (ep_info->out_interval)
+                        usb_fill_int_urb(ep->urbs[i].urb, umidi->chip->dev,
+                                         pipe, buffer, ep->max_transfer,
+                                         snd_usbmidi_out_urb_complete,
+                                         &ep->urbs[i], ep_info->out_interval);
+                else
+                        usb_fill_bulk_urb(ep->urbs[i].urb, umidi->chip->dev,
+                                          pipe, buffer, ep->max_transfer,
+                                          snd_usbmidi_out_urb_complete,
+                                          &ep->urbs[i]);
+                ep->urbs[i].urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
         }
-        if (ep_info->out_interval)
-                usb_fill_int_urb(ep->urb, umidi->chip->dev, pipe, buffer,
-                                 ep->max_transfer, snd_usbmidi_out_urb_complete,
-                                 ep, ep_info->out_interval);
-        else
-                usb_fill_bulk_urb(ep->urb, umidi->chip->dev,
-                                  pipe, buffer, ep->max_transfer,
-                                  snd_usbmidi_out_urb_complete, ep);
-        ep->urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
 
         spin_lock_init(&ep->buffer_lock);
         tasklet_init(&ep->tasklet, snd_usbmidi_out_tasklet, (unsigned long)ep);
+        init_waitqueue_head(&ep->drain_wait);
 
         for (i = 0; i < 0x10; ++i)
                 if (ep_info->out_cables & (1 << i)) {
@@ -1090,7 +1181,7 @@ static void snd_usbmidi_free(struct snd_usb_midi* umidi)
 void snd_usbmidi_disconnect(struct list_head* p)
 {
         struct snd_usb_midi* umidi;
-        int i;
+        unsigned int i, j;
 
         umidi = list_entry(p, struct snd_usb_midi, list);
         /*
@@ -1105,13 +1196,15 @@ void snd_usbmidi_disconnect(struct list_head* p)
                 struct snd_usb_midi_endpoint* ep = &umidi->endpoints[i];
                 if (ep->out)
                         tasklet_kill(&ep->out->tasklet);
-                if (ep->out && ep->out->urb) {
-                        usb_kill_urb(ep->out->urb);
+                if (ep->out) {
+                        for (j = 0; j < OUTPUT_URBS; ++j)
+                                usb_kill_urb(ep->out->urbs[j].urb);
                         if (umidi->usb_protocol_ops->finish_out_endpoint)
                                 umidi->usb_protocol_ops->finish_out_endpoint(ep->out);
                 }
                 if (ep->in)
-                        usb_kill_urb(ep->in->urb);
+                        for (j = 0; j < INPUT_URBS; ++j)
+                                usb_kill_urb(ep->in->urbs[j]);
                 /* free endpoints here; later call can result in Oops */
                 if (ep->out) {
                         snd_usbmidi_out_endpoint_delete(ep->out);
@@ -1692,20 +1785,25 @@ static int snd_usbmidi_create_rawmidi(struct snd_usb_midi* umidi,
 void snd_usbmidi_input_stop(struct list_head* p)
 {
         struct snd_usb_midi* umidi;
-        int i;
+        unsigned int i, j;
 
         umidi = list_entry(p, struct snd_usb_midi, list);
         for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) {
                 struct snd_usb_midi_endpoint* ep = &umidi->endpoints[i];
                 if (ep->in)
-                        usb_kill_urb(ep->in->urb);
+                        for (j = 0; j < INPUT_URBS; ++j)
+                                usb_kill_urb(ep->in->urbs[j]);
         }
 }
 
 static void snd_usbmidi_input_start_ep(struct snd_usb_midi_in_endpoint* ep)
 {
-        if (ep) {
-                struct urb* urb = ep->urb;
+        unsigned int i;
+
+        if (!ep)
+                return;
+        for (i = 0; i < INPUT_URBS; ++i) {
+                struct urb* urb = ep->urbs[i];
                 urb->dev = ep->umidi->chip->dev;
                 snd_usbmidi_submit_urb(urb, GFP_KERNEL);
         }
diff --git a/sound/usb/usbmixer.c b/sound/usb/usbmixer.c
index 4bd3a7a0edc1..9efcfd08d747 100644
--- a/sound/usb/usbmixer.c
+++ b/sound/usb/usbmixer.c
@@ -86,6 +86,7 @@ struct usb_mixer_interface {
         u8 rc_buffer[6];
 
         u8 audigy2nx_leds[3];
+        u8 xonar_u1_status;
 };
 
 
@@ -461,7 +462,7 @@ static int mixer_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
                          unsigned int size, unsigned int __user *_tlv)
 {
         struct usb_mixer_elem_info *cval = kcontrol->private_data;
-        DECLARE_TLV_DB_SCALE(scale, 0, 0, 0);
+        DECLARE_TLV_DB_MINMAX(scale, 0, 0);
 
         if (size < sizeof(scale))
                 return -ENOMEM;
@@ -469,7 +470,16 @@ static int mixer_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
          * while ALSA TLV contains in 1/100 dB unit
          */
         scale[2] = (convert_signed_value(cval, cval->min) * 100) / 256;
-        scale[3] = (convert_signed_value(cval, cval->res) * 100) / 256;
+        scale[3] = (convert_signed_value(cval, cval->max) * 100) / 256;
+        if (scale[3] <= scale[2]) {
+                /* something is wrong; assume it's either from/to 0dB */
+                if (scale[2] < 0)
+                        scale[3] = 0;
+                else if (scale[2] > 0)
+                        scale[2] = 0;
+                else /* totally crap, return an error */
+                        return -EINVAL;
+        }
         if (copy_to_user(_tlv, scale, sizeof(scale)))
                 return -EFAULT;
         return 0;
@@ -888,6 +898,11 @@ static struct snd_kcontrol_new usb_feature_unit_ctl = {
  * build a feature control
  */
 
+static size_t append_ctl_name(struct snd_kcontrol *kctl, const char *str)
+{
+        return strlcat(kctl->id.name, str, sizeof(kctl->id.name));
+}
+
 static void build_feature_ctl(struct mixer_build *state, unsigned char *desc,
                               unsigned int ctl_mask, int control,
                               struct usb_audio_term *iterm, int unitid)
@@ -968,13 +983,13 @@ static void build_feature_ctl(struct mixer_build *state, unsigned char *desc,
                  */
                 if (! mapped_name && ! (state->oterm.type >> 16)) {
                         if ((state->oterm.type & 0xff00) == 0x0100) {
-                                len = strlcat(kctl->id.name, " Capture", sizeof(kctl->id.name));
+                                len = append_ctl_name(kctl, " Capture");
                         } else {
-                                len = strlcat(kctl->id.name + len, " Playback", sizeof(kctl->id.name));
+                                len = append_ctl_name(kctl, " Playback");
                         }
                 }
-                strlcat(kctl->id.name + len, control == USB_FEATURE_MUTE ? " Switch" : " Volume",
-                        sizeof(kctl->id.name));
+                append_ctl_name(kctl, control == USB_FEATURE_MUTE ?
+                                " Switch" : " Volume");
                 if (control == USB_FEATURE_VOLUME) {
                         kctl->tlv.c = mixer_vol_tlv;
                         kctl->vd[0].access |= 
@@ -990,20 +1005,35 @@ static void build_feature_ctl(struct mixer_build *state, unsigned char *desc,
                 break;
         }
 
-        /* quirk for UDA1321/N101 */
-        /* note that detection between firmware 2.1.1.7 (N101) and later 2.1.1.21 */
-        /* is not very clear from datasheets */
-        /* I hope that the min value is -15360 for newer firmware --jk */
+        /* volume control quirks */
         switch (state->chip->usb_id) {
         case USB_ID(0x0471, 0x0101):
         case USB_ID(0x0471, 0x0104):
         case USB_ID(0x0471, 0x0105):
         case USB_ID(0x0672, 0x1041):
+        /* quirk for UDA1321/N101.
+         * note that detection between firmware 2.1.1.7 (N101)
+         * and later 2.1.1.21 is not very clear from datasheets.
+         * I hope that the min value is -15360 for newer firmware --jk
+         */
                 if (!strcmp(kctl->id.name, "PCM Playback Volume") &&
                     cval->min == -15616) {
-                        snd_printk(KERN_INFO "using volume control quirk for the UDA1321/N101 chip\n");
+                        snd_printk(KERN_INFO
+                                 "set volume quirk for UDA1321/N101 chip\n");
                         cval->max = -256;
                 }
+                break;
+
+        case USB_ID(0x046d, 0x09a4):
+                if (!strcmp(kctl->id.name, "Mic Capture Volume")) {
+                        snd_printk(KERN_INFO
+                                "set volume quirk for QuickCam E3500\n");
+                        cval->min = 6080;
+                        cval->max = 8768;
+                        cval->res = 192;
+                }
+                break;
+
         }
 
         snd_printdd(KERN_INFO "[%d] FU [%s] ch = %d, val = %d/%d/%d\n",
@@ -1118,7 +1148,7 @@ static void build_mixer_unit_ctl(struct mixer_build *state, unsigned char *desc,
                 len = get_term_name(state, iterm, kctl->id.name, sizeof(kctl->id.name), 0);
         if (! len)
                 len = sprintf(kctl->id.name, "Mixer Source %d", in_ch + 1);
-        strlcat(kctl->id.name + len, " Volume", sizeof(kctl->id.name));
+        append_ctl_name(kctl, " Volume");
 
         snd_printdd(KERN_INFO "[%d] MU [%s] ch = %d, val = %d/%d\n",
                     cval->id, kctl->id.name, cval->channels, cval->min, cval->max);
@@ -1375,8 +1405,8 @@ static int build_audio_procunit(struct mixer_build *state, int unitid, unsigned
                         if (! len)
                                 strlcpy(kctl->id.name, name, sizeof(kctl->id.name));
                 }
-                strlcat(kctl->id.name, " ", sizeof(kctl->id.name));
-                strlcat(kctl->id.name, valinfo->suffix, sizeof(kctl->id.name));
+                append_ctl_name(kctl, " ");
+                append_ctl_name(kctl, valinfo->suffix);
 
                 snd_printdd(KERN_INFO "[%d] PU [%s] ch = %d, val = %d/%d\n",
                             cval->id, kctl->id.name, cval->channels, cval->min, cval->max);
@@ -1585,9 +1615,9 @@ static int parse_audio_selector_unit(struct mixer_build *state, int unitid, unsi
                         strlcpy(kctl->id.name, "USB", sizeof(kctl->id.name));
 
                 if ((state->oterm.type & 0xff00) == 0x0100)
-                        strlcat(kctl->id.name, " Capture Source", sizeof(kctl->id.name));
+                        append_ctl_name(kctl, " Capture Source");
                 else
-                        strlcat(kctl->id.name, " Playback Source", sizeof(kctl->id.name));
+                        append_ctl_name(kctl, " Playback Source");
         }
 
         snd_printdd(KERN_INFO "[%d] SU [%s] items = %d\n",
@@ -2018,6 +2048,58 @@ static void snd_audigy2nx_proc_read(struct snd_info_entry *entry,
         }
 }
 
+static int snd_xonar_u1_switch_get(struct snd_kcontrol *kcontrol,
+                                   struct snd_ctl_elem_value *ucontrol)
+{
+        struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
+
+        ucontrol->value.integer.value[0] = !!(mixer->xonar_u1_status & 0x02);
+        return 0;
+}
+
+static int snd_xonar_u1_switch_put(struct snd_kcontrol *kcontrol,
+                                   struct snd_ctl_elem_value *ucontrol)
+{
+        struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
+        u8 old_status, new_status;
+        int err, changed;
+
+        old_status = mixer->xonar_u1_status;
+        if (ucontrol->value.integer.value[0])
+                new_status = old_status | 0x02;
+        else
+                new_status = old_status & ~0x02;
+        changed = new_status != old_status;
+        err = snd_usb_ctl_msg(mixer->chip->dev,
+                              usb_sndctrlpipe(mixer->chip->dev, 0), 0x08,
+                              USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
+                              50, 0, &new_status, 1, 100);
+        if (err < 0)
+                return err;
+        mixer->xonar_u1_status = new_status;
+        return changed;
+}
+
+static struct snd_kcontrol_new snd_xonar_u1_output_switch = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name = "Digital Playback Switch",
+        .info = snd_ctl_boolean_mono_info,
+        .get = snd_xonar_u1_switch_get,
+        .put = snd_xonar_u1_switch_put,
+};
+
+static int snd_xonar_u1_controls_create(struct usb_mixer_interface *mixer)
+{
+        int err;
+
+        err = snd_ctl_add(mixer->chip->card,
+                          snd_ctl_new1(&snd_xonar_u1_output_switch, mixer));
+        if (err < 0)
+                return err;
+        mixer->xonar_u1_status = 0x05;
+        return 0;
+}
+
 int snd_usb_create_mixer(struct snd_usb_audio *chip, int ctrlif,
                          int ignore_error)
 {
@@ -2060,6 +2142,13 @@ int snd_usb_create_mixer(struct snd_usb_audio *chip, int ctrlif,
                                               snd_audigy2nx_proc_read);
         }
 
+        if (mixer->chip->usb_id == USB_ID(0x0b05, 0x1739) ||
+            mixer->chip->usb_id == USB_ID(0x0b05, 0x1743)) {
+                err = snd_xonar_u1_controls_create(mixer);
+                if (err < 0)
+                        goto _error;
+        }
+
         err = snd_device_new(chip->card, SNDRV_DEV_LOWLEVEL, mixer, &dev_ops);
         if (err < 0)
                 goto _error;
diff --git a/sound/usb/usx2y/us122l.c b/sound/usb/usx2y/us122l.c
index a5aae9d67f31..fd44946ce4b3 100644
--- a/sound/usb/usx2y/us122l.c
+++ b/sound/usb/usx2y/us122l.c
@@ -514,7 +514,6 @@ static int usx2y_create_card(struct usb_device *device, struct snd_card **cardp)
                 US122L(card)->chip.dev->bus->busnum,
                 US122L(card)->chip.dev->devnum
                 );
-        snd_card_set_dev(card, &device->dev);
         *cardp = card;
         return 0;
 }
@@ -531,6 +530,7 @@ static int us122l_usb_probe(struct usb_interface *intf,
         if (err < 0)
                 return err;
 
+        snd_card_set_dev(card, &intf->dev);
         if (!us122l_create_card(card)) {
                 snd_card_free(card);
                 return -EINVAL;
diff --git a/sound/usb/usx2y/usbusx2y.c b/sound/usb/usx2y/usbusx2y.c
index 5ce0da23ee96..cb4bb8373ca2 100644
--- a/sound/usb/usx2y/usbusx2y.c
+++ b/sound/usb/usx2y/usbusx2y.c
@@ -364,7 +364,6 @@ static int usX2Y_create_card(struct usb_device *device, struct snd_card **cardp)
                 0,//us428(card)->usbmidi.ifnum,
                 usX2Y(card)->chip.dev->bus->busnum, usX2Y(card)->chip.dev->devnum
                 );
-        snd_card_set_dev(card, &device->dev);
         *cardp = card;
         return 0;
 }
@@ -388,6 +387,7 @@ static int usX2Y_usb_probe(struct usb_device *device,
         err = usX2Y_create_card(device, &card);
         if (err < 0)
                 return err;
+        snd_card_set_dev(card, &intf->dev);
         if ((err = usX2Y_hwdep_new(card, device)) < 0  ||
             (err = snd_card_register(card)) < 0) {
                 snd_card_free(card);
diff --git a/sound/usb/usx2y/usbusx2yaudio.c b/sound/usb/usx2y/usbusx2yaudio.c
index dd1ab6177840..9efd27f6b52f 100644
--- a/sound/usb/usx2y/usbusx2yaudio.c
+++ b/sound/usb/usx2y/usbusx2yaudio.c
@@ -296,9 +296,10 @@ static void usX2Y_error_urb_status(struct usX2Ydev *usX2Y,
 static void usX2Y_error_sequence(struct usX2Ydev *usX2Y,
                                  struct snd_usX2Y_substream *subs, struct urb *urb)
 {
-        snd_printk(KERN_ERR "Sequence Error!(hcd_frame=%i ep=%i%s;wait=%i,frame=%i).\n"
-                   KERN_ERR "Most propably some urb of usb-frame %i is still missing.\n"
-                   KERN_ERR "Cause could be too long delays in usb-hcd interrupt handling.\n",
+        snd_printk(KERN_ERR
+"Sequence Error!(hcd_frame=%i ep=%i%s;wait=%i,frame=%i).\n"
+"Most propably some urb of usb-frame %i is still missing.\n"
+"Cause could be too long delays in usb-hcd interrupt handling.\n",
                    usb_get_current_frame_number(usX2Y->chip.dev),
                    subs->endpoint, usb_pipein(urb->pipe) ? "in" : "out",
                    usX2Y->wait_iso_frame, urb->start_frame, usX2Y->wait_iso_frame);