Merge branch 'wip-2.6.34' into old-private-masterarchived-private-master

535 files changed, 49684 insertions, 14880 deletions

diff --git a/sound/Kconfig b/sound/Kconfig
index 439e15c8faa3..fcad760f5691 100644
--- a/sound/Kconfig
+++ b/sound/Kconfig
@@ -1,6 +1,3 @@
-# sound/Config.in
-#
-
 menuconfig SOUND
         tristate "Sound card support"
         depends on HAS_IOMEM
@@ -58,7 +55,7 @@ config SOUND_OSS_CORE_PRECLAIM
           Please read Documentation/feature-removal-schedule.txt for
           details.
 
-          If unusre, say Y.
+          If unsure, say Y.
 
 source "sound/oss/dmasound/Kconfig"
 
@@ -136,4 +133,3 @@ config AC97_BUS
           sound subsystem and other function drivers completely unrelated to
           sound although they're sharing the AC97 bus. Concerned drivers
           should "select" this.
-
diff --git a/sound/aoa/codecs/onyx.c b/sound/aoa/codecs/onyx.c
index 84bb07d39a7f..91852e49910e 100644
--- a/sound/aoa/codecs/onyx.c
+++ b/sound/aoa/codecs/onyx.c
@@ -33,6 +33,7 @@
  */
 #include <linux/delay.h>
 #include <linux/module.h>
+#include <linux/slab.h>
 MODULE_AUTHOR("Johannes Berg <johannes@sipsolutions.net>");
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("pcm3052 (onyx) codec driver for snd-aoa");
diff --git a/sound/aoa/codecs/tas.c b/sound/aoa/codecs/tas.c
index 1dd66ddffcaf..fd2188c3df2b 100644
--- a/sound/aoa/codecs/tas.c
+++ b/sound/aoa/codecs/tas.c
@@ -66,6 +66,7 @@
 #include <linux/delay.h>
 #include <linux/module.h>
 #include <linux/mutex.h>
+#include <linux/slab.h>
 
 MODULE_AUTHOR("Johannes Berg <johannes@sipsolutions.net>");
 MODULE_LICENSE("GPL");
diff --git a/sound/aoa/codecs/toonie.c b/sound/aoa/codecs/toonie.c
index f13827e17562..69d2cb601f2a 100644
--- a/sound/aoa/codecs/toonie.c
+++ b/sound/aoa/codecs/toonie.c
@@ -11,6 +11,7 @@
  */
 #include <linux/delay.h>
 #include <linux/module.h>
+#include <linux/slab.h>
 MODULE_AUTHOR("Johannes Berg <johannes@sipsolutions.net>");
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("toonie codec driver for snd-aoa");
diff --git a/sound/aoa/core/gpio-pmf.c b/sound/aoa/core/gpio-pmf.c
index 1dd0c28d1fb7..6776d1c12b63 100644
--- a/sound/aoa/core/gpio-pmf.c
+++ b/sound/aoa/core/gpio-pmf.c
@@ -6,6 +6,7 @@
  * GPL v2, can be found in COPYING.
  */
 
+#include <linux/slab.h>
 #include <asm/pmac_feature.h>
 #include <asm/pmac_pfunc.h>
 #include "../aoa.h"
diff --git a/sound/aoa/fabrics/layout.c b/sound/aoa/fabrics/layout.c
index 586965f9605f..1cd9b301df03 100644
--- a/sound/aoa/fabrics/layout.c
+++ b/sound/aoa/fabrics/layout.c
@@ -12,6 +12,7 @@
 #include <asm/prom.h>
 #include <linux/list.h>
 #include <linux/module.h>
+#include <linux/slab.h>
 #include "../aoa.h"
 #include "../soundbus/soundbus.h"
 
@@ -768,7 +769,7 @@ static int check_codec(struct aoa_codec *codec,
                                 "required property %s not present\n", propname);
                         return -ENODEV;
                 }
-                if (*ref != codec->node->linux_phandle) {
+                if (*ref != codec->node->phandle) {
                         printk(KERN_INFO "snd-aoa-fabric-layout: "
                                 "%s doesn't match!\n", propname);
                         return -ENODEV;
diff --git a/sound/aoa/soundbus/i2sbus/control.c b/sound/aoa/soundbus/i2sbus/control.c
index 87beb4ad4d63..47f854c2001f 100644
--- a/sound/aoa/soundbus/i2sbus/control.c
+++ b/sound/aoa/soundbus/i2sbus/control.c
@@ -8,6 +8,7 @@
 
 #include <linux/kernel.h>
 #include <linux/delay.h>
+#include <linux/slab.h>
 
 #include <asm/io.h>
 #include <asm/prom.h>
diff --git a/sound/aoa/soundbus/i2sbus/core.c b/sound/aoa/soundbus/i2sbus/core.c
index 4e3b819d4993..9d6f3b176ed1 100644
--- a/sound/aoa/soundbus/i2sbus/core.c
+++ b/sound/aoa/soundbus/i2sbus/core.c
@@ -7,6 +7,7 @@
  */
 
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/pci.h>
 #include <linux/interrupt.h>
 #include <linux/dma-mapping.h>
diff --git a/sound/aoa/soundbus/i2sbus/pcm.c b/sound/aoa/soundbus/i2sbus/pcm.c
index 59bacd365733..be838993926d 100644
--- a/sound/aoa/soundbus/i2sbus/pcm.c
+++ b/sound/aoa/soundbus/i2sbus/pcm.c
@@ -8,6 +8,7 @@
 
 #include <asm/io.h>
 #include <linux/delay.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <asm/macio.h>
 #include <linux/pci.h>
diff --git a/sound/arm/Makefile b/sound/arm/Makefile
index 5a549ed6c8aa..8c0c851d4641 100644
--- a/sound/arm/Makefile
+++ b/sound/arm/Makefile
@@ -3,7 +3,7 @@
 #
 
 obj-$(CONFIG_SND_ARMAACI)       += snd-aaci.o
-snd-aaci-objs                   := aaci.o devdma.o
+snd-aaci-objs                   := aaci.o
 
 obj-$(CONFIG_SND_PXA2XX_PCM)    += snd-pxa2xx-pcm.o
 snd-pxa2xx-pcm-objs             := pxa2xx-pcm.o
diff --git a/sound/arm/aaci.c b/sound/arm/aaci.c
index 6c160a038b23..91acc9a243ec 100644
--- a/sound/arm/aaci.c
+++ b/sound/arm/aaci.c
@@ -18,10 +18,7 @@
 #include <linux/interrupt.h>
 #include <linux/err.h>
 #include <linux/amba/bus.h>
-
-#include <asm/io.h>
-#include <asm/irq.h>
-#include <asm/sizes.h>
+#include <linux/io.h>
 
 #include <sound/core.h>
 #include <sound/initval.h>
@@ -30,7 +27,6 @@
 #include <sound/pcm_params.h>
 
 #include "aaci.h"
-#include "devdma.h"
 
 #define DRIVER_NAME     "aaci-pl041"
 
@@ -176,14 +172,15 @@ static unsigned short aaci_ac97_read(struct snd_ac97 *ac97, unsigned short reg)
         return v;
 }
 
-static inline void aaci_chan_wait_ready(struct aaci_runtime *aacirun)
+static inline void
+aaci_chan_wait_ready(struct aaci_runtime *aacirun, unsigned long mask)
 {
         u32 val;
         int timeout = 5000;
 
         do {
                 val = readl(aacirun->base + AACI_SR);
-        } while (val & (SR_TXB|SR_RXB) && timeout--);
+        } while (val & mask && timeout--);
 }
 
 
@@ -212,8 +209,10 @@ static void aaci_fifo_irq(struct aaci *aaci, int channel, u32 mask)
                         writel(0, aacirun->base + AACI_IE);
                         return;
                 }
-                ptr = aacirun->ptr;
 
+                spin_lock(&aacirun->lock);
+
+                ptr = aacirun->ptr;
                 do {
                         unsigned int len = aacirun->fifosz;
                         u32 val;
@@ -221,9 +220,9 @@ static void aaci_fifo_irq(struct aaci *aaci, int channel, u32 mask)
                         if (aacirun->bytes <= 0) {
                                 aacirun->bytes += aacirun->period;
                                 aacirun->ptr = ptr;
-                                spin_unlock(&aaci->lock);
+                                spin_unlock(&aacirun->lock);
                                 snd_pcm_period_elapsed(aacirun->substream);
-                                spin_lock(&aaci->lock);
+                                spin_lock(&aacirun->lock);
                         }
                         if (!(aacirun->cr & CR_EN))
                                 break;
@@ -249,7 +248,10 @@ static void aaci_fifo_irq(struct aaci *aaci, int channel, u32 mask)
                                         ptr = aacirun->start;
                         }
                 } while(1);
+
                 aacirun->ptr = ptr;
+
+                spin_unlock(&aacirun->lock);
         }
 
         if (mask & ISR_URINTR) {
@@ -267,6 +269,8 @@ static void aaci_fifo_irq(struct aaci *aaci, int channel, u32 mask)
                         return;
                 }
 
+                spin_lock(&aacirun->lock);
+
                 ptr = aacirun->ptr;
                 do {
                         unsigned int len = aacirun->fifosz;
@@ -275,9 +279,9 @@ static void aaci_fifo_irq(struct aaci *aaci, int channel, u32 mask)
                         if (aacirun->bytes <= 0) {
                                 aacirun->bytes += aacirun->period;
                                 aacirun->ptr = ptr;
-                                spin_unlock(&aaci->lock);
+                                spin_unlock(&aacirun->lock);
                                 snd_pcm_period_elapsed(aacirun->substream);
-                                spin_lock(&aaci->lock);
+                                spin_lock(&aacirun->lock);
                         }
                         if (!(aacirun->cr & CR_EN))
                                 break;
@@ -305,6 +309,8 @@ static void aaci_fifo_irq(struct aaci *aaci, int channel, u32 mask)
                 } while (1);
 
                 aacirun->ptr = ptr;
+
+                spin_unlock(&aacirun->lock);
         }
 }
 
@@ -314,7 +320,6 @@ static irqreturn_t aaci_irq(int irq, void *devid)
         u32 mask;
         int i;
 
-        spin_lock(&aaci->lock);
         mask = readl(aaci->base + AACI_ALLINTS);
         if (mask) {
                 u32 m = mask;
@@ -324,7 +329,6 @@ static irqreturn_t aaci_irq(int irq, void *devid)
                         }
                 }
         }
-        spin_unlock(&aaci->lock);
 
         return mask ? IRQ_HANDLED : IRQ_NONE;
 }
@@ -334,63 +338,6 @@ static irqreturn_t aaci_irq(int irq, void *devid)
 /*
  * ALSA support.
  */
-
-struct aaci_stream {
-        unsigned char codec_idx;
-        unsigned char rate_idx;
-};
-
-static struct aaci_stream aaci_streams[] = {
-        [ACSTREAM_FRONT] = {
-                .codec_idx      = 0,
-                .rate_idx       = AC97_RATES_FRONT_DAC,
-        },
-        [ACSTREAM_SURROUND] = {
-                .codec_idx      = 0,
-                .rate_idx       = AC97_RATES_SURR_DAC,
-        },
-        [ACSTREAM_LFE] = {
-                .codec_idx      = 0,
-                .rate_idx       = AC97_RATES_LFE_DAC,
-        },
-};
-
-static inline unsigned int aaci_rate_mask(struct aaci *aaci, int streamid)
-{
-        struct aaci_stream *s = aaci_streams + streamid;
-        return aaci->ac97_bus->codec[s->codec_idx]->rates[s->rate_idx];
-}
-
-static unsigned int rate_list[] = {
-        5512, 8000, 11025, 16000, 22050, 32000, 44100,
-        48000, 64000, 88200, 96000, 176400, 192000
-};
-
-/*
- * Double-rate rule: we can support double rate iff channels == 2
- *  (unimplemented)
- */
-static int
-aaci_rule_rate_by_channels(struct snd_pcm_hw_params *p, struct snd_pcm_hw_rule *rule)
-{
-        struct aaci *aaci = rule->private;
-        unsigned int rate_mask = SNDRV_PCM_RATE_8000_48000|SNDRV_PCM_RATE_5512;
-        struct snd_interval *c = hw_param_interval(p, SNDRV_PCM_HW_PARAM_CHANNELS);
-
-        switch (c->max) {
-        case 6:
-                rate_mask &= aaci_rate_mask(aaci, ACSTREAM_LFE);
-        case 4:
-                rate_mask &= aaci_rate_mask(aaci, ACSTREAM_SURROUND);
-        case 2:
-                rate_mask &= aaci_rate_mask(aaci, ACSTREAM_FRONT);
-        }
-
-        return snd_interval_list(hw_param_interval(p, rule->var),
-                                 ARRAY_SIZE(rate_list), rate_list,
-                                 rate_mask);
-}
-
 static struct snd_pcm_hardware aaci_hw_info = {
         .info                   = SNDRV_PCM_INFO_MMAP |
                                   SNDRV_PCM_INFO_MMAP_VALID |
@@ -404,10 +351,7 @@ static struct snd_pcm_hardware aaci_hw_info = {
          */
         .formats                = SNDRV_PCM_FMTBIT_S16_LE,
 
-        /* should this be continuous or knot? */
-        .rates                  = SNDRV_PCM_RATE_CONTINUOUS,
-        .rate_max               = 48000,
-        .rate_min               = 4000,
+        /* rates are setup from the AC'97 codec */
         .channels_min           = 2,
         .channels_max           = 6,
         .buffer_bytes_max       = 64 * 1024,
@@ -427,6 +371,12 @@ static int __aaci_pcm_open(struct aaci *aaci,
         aacirun->substream = substream;
         runtime->private_data = aacirun;
         runtime->hw = aaci_hw_info;
+        runtime->hw.rates = aacirun->pcm->rates;
+        snd_pcm_limit_hw_rates(runtime);
+
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
+            aacirun->pcm->r[1].slots)
+                snd_ac97_pcm_double_rate_rules(runtime);
 
         /*
          * FIXME: ALSA specifies fifo_size in bytes.  If we're in normal
@@ -437,17 +387,6 @@ static int __aaci_pcm_open(struct aaci *aaci,
          */
         runtime->hw.fifo_size = aaci->fifosize * 2;
 
-        /*
-         * Add rule describing hardware rate dependency
-         * on the number of channels.
-         */
-        ret = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
-                                  aaci_rule_rate_by_channels, aaci,
-                                  SNDRV_PCM_HW_PARAM_CHANNELS,
-                                  SNDRV_PCM_HW_PARAM_RATE, -1);
-        if (ret)
-                goto out;
-
         ret = request_irq(aaci->dev->irq[0], aaci_irq, IRQF_SHARED|IRQF_DISABLED,
                           DRIVER_NAME, aaci);
         if (ret)
@@ -492,7 +431,7 @@ static int aaci_pcm_hw_free(struct snd_pcm_substream *substream)
         /*
          * Clear out the DMA and any allocated buffers.
          */
-        devdma_hw_free(NULL, substream);
+        snd_pcm_lib_free_pages(substream);
 
         return 0;
 }
@@ -502,6 +441,7 @@ static int aaci_pcm_hw_params(struct snd_pcm_substream *substream,
                               struct snd_pcm_hw_params *params)
 {
         int err;
+        struct aaci *aaci = substream->private_data;
 
         aaci_pcm_hw_free(substream);
         if (aacirun->pcm_open) {
@@ -509,26 +449,24 @@ static int aaci_pcm_hw_params(struct snd_pcm_substream *substream,
                 aacirun->pcm_open = 0;
         }
 
-        err = devdma_hw_alloc(NULL, substream,
-                              params_buffer_bytes(params));
-        if (err < 0)
-                goto out;
+        err = snd_pcm_lib_malloc_pages(substream,
+                                       params_buffer_bytes(params));
+        if (err >= 0) {
+                unsigned int rate = params_rate(params);
+                int dbl = rate > 48000;
 
-        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
-                err = snd_ac97_pcm_open(aacirun->pcm, params_rate(params),
+                err = snd_ac97_pcm_open(aacirun->pcm, rate,
                                         params_channels(params),
-                                        aacirun->pcm->r[0].slots);
-        else
-                err = snd_ac97_pcm_open(aacirun->pcm, params_rate(params),
-                                        params_channels(params),
-                                        aacirun->pcm->r[0].slots);
+                                        aacirun->pcm->r[dbl].slots);
 
-        if (err)
-                goto out;
+                aacirun->pcm_open = err == 0;
+                aacirun->cr = CR_FEN | CR_COMPACT | CR_SZ16;
+                aacirun->fifosz = aaci->fifosize * 4;
 
-        aacirun->pcm_open = 1;
+                if (aacirun->cr & CR_COMPACT)
+                        aacirun->fifosz >>= 1;
+        }
 
- out:
         return err;
 }
 
@@ -537,8 +475,8 @@ static int aaci_pcm_prepare(struct snd_pcm_substream *substream)
         struct snd_pcm_runtime *runtime = substream->runtime;
         struct aaci_runtime *aacirun = runtime->private_data;
 
-        aacirun->start  = (void *)runtime->dma_area;
-        aacirun->end    = aacirun->start + runtime->dma_bytes;
+        aacirun->start  = runtime->dma_area;
+        aacirun->end    = aacirun->start + snd_pcm_lib_buffer_bytes(substream);
         aacirun->ptr    = aacirun->start;
         aacirun->period =
         aacirun->bytes  = frames_to_bytes(runtime, runtime->period_size);
@@ -555,11 +493,6 @@ static snd_pcm_uframes_t aaci_pcm_pointer(struct snd_pcm_substream *substream)
         return bytes_to_frames(runtime, bytes);
 }
 
-static int aaci_pcm_mmap(struct snd_pcm_substream *substream, struct vm_area_struct *vma)
-{
-        return devdma_mmap(NULL, substream, vma);
-}
-
 
 /*
  * Playback specific ALSA stuff
@@ -628,7 +561,6 @@ static int aaci_pcm_open(struct snd_pcm_substream *substream)
 static int aaci_pcm_playback_hw_params(struct snd_pcm_substream *substream,
                                        struct snd_pcm_hw_params *params)
 {
-        struct aaci *aaci = substream->private_data;
         struct aaci_runtime *aacirun = substream->runtime->private_data;
         unsigned int channels = params_channels(params);
         int ret;
@@ -642,14 +574,9 @@ static int aaci_pcm_playback_hw_params(struct snd_pcm_substream *substream,
          * Enable FIFO, compact mode, 16 bits per sample.
          * FIXME: double rate slots?
          */
-        if (ret >= 0) {
-                aacirun->cr = CR_FEN | CR_COMPACT | CR_SZ16;
+        if (ret >= 0)
                 aacirun->cr |= channels_to_txmask[channels];
 
-                aacirun->fifosz = aaci->fifosize * 4;
-                if (aacirun->cr & CR_COMPACT)
-                        aacirun->fifosz >>= 1;
-        }
         return ret;
 }
 
@@ -661,7 +588,7 @@ static void aaci_pcm_playback_stop(struct aaci_runtime *aacirun)
         ie &= ~(IE_URIE|IE_TXIE);
         writel(ie, aacirun->base + AACI_IE);
         aacirun->cr &= ~CR_EN;
-        aaci_chan_wait_ready(aacirun);
+        aaci_chan_wait_ready(aacirun, SR_TXB);
         writel(aacirun->cr, aacirun->base + AACI_TXCR);
 }
 
@@ -669,7 +596,7 @@ static void aaci_pcm_playback_start(struct aaci_runtime *aacirun)
 {
         u32 ie;
 
-        aaci_chan_wait_ready(aacirun);
+        aaci_chan_wait_ready(aacirun, SR_TXB);
         aacirun->cr |= CR_EN;
 
         ie = readl(aacirun->base + AACI_IE);
@@ -680,12 +607,12 @@ static void aaci_pcm_playback_start(struct aaci_runtime *aacirun)
 
 static int aaci_pcm_playback_trigger(struct snd_pcm_substream *substream, int cmd)
 {
-        struct aaci *aaci = substream->private_data;
         struct aaci_runtime *aacirun = substream->runtime->private_data;
         unsigned long flags;
         int ret = 0;
 
-        spin_lock_irqsave(&aaci->lock, flags);
+        spin_lock_irqsave(&aacirun->lock, flags);
+
         switch (cmd) {
         case SNDRV_PCM_TRIGGER_START:
                 aaci_pcm_playback_start(aacirun);
@@ -712,7 +639,8 @@ static int aaci_pcm_playback_trigger(struct snd_pcm_substream *substream, int cm
         default:
                 ret = -EINVAL;
         }
-        spin_unlock_irqrestore(&aaci->lock, flags);
+
+        spin_unlock_irqrestore(&aacirun->lock, flags);
 
         return ret;
 }
@@ -726,29 +654,19 @@ static struct snd_pcm_ops aaci_playback_ops = {
         .prepare        = aaci_pcm_prepare,
         .trigger        = aaci_pcm_playback_trigger,
         .pointer        = aaci_pcm_pointer,
-        .mmap           = aaci_pcm_mmap,
 };
 
 static int aaci_pcm_capture_hw_params(struct snd_pcm_substream *substream,
                                       struct snd_pcm_hw_params *params)
 {
-        struct aaci *aaci = substream->private_data;
         struct aaci_runtime *aacirun = substream->runtime->private_data;
         int ret;
 
         ret = aaci_pcm_hw_params(substream, aacirun, params);
-
-        if (ret >= 0) {
-                aacirun->cr = CR_FEN | CR_COMPACT | CR_SZ16;
-
+        if (ret >= 0)
                 /* Line in record: slot 3 and 4 */
                 aacirun->cr |= CR_SL3 | CR_SL4;
 
-                aacirun->fifosz = aaci->fifosize * 4;
-
-                if (aacirun->cr & CR_COMPACT)
-                        aacirun->fifosz >>= 1;
-        }
         return ret;
 }
 
@@ -756,7 +674,7 @@ static void aaci_pcm_capture_stop(struct aaci_runtime *aacirun)
 {
         u32 ie;
 
-        aaci_chan_wait_ready(aacirun);
+        aaci_chan_wait_ready(aacirun, SR_RXB);
 
         ie = readl(aacirun->base + AACI_IE);
         ie &= ~(IE_ORIE | IE_RXIE);
@@ -771,7 +689,7 @@ static void aaci_pcm_capture_start(struct aaci_runtime *aacirun)
 {
         u32 ie;
 
-        aaci_chan_wait_ready(aacirun);
+        aaci_chan_wait_ready(aacirun, SR_RXB);
 
 #ifdef DEBUG
         /* RX Timeout value: bits 28:17 in RXCR */
@@ -788,12 +706,11 @@ static void aaci_pcm_capture_start(struct aaci_runtime *aacirun)
 
 static int aaci_pcm_capture_trigger(struct snd_pcm_substream *substream, int cmd)
 {
-        struct aaci *aaci = substream->private_data;
         struct aaci_runtime *aacirun = substream->runtime->private_data;
         unsigned long flags;
         int ret = 0;
 
-        spin_lock_irqsave(&aaci->lock, flags);
+        spin_lock_irqsave(&aacirun->lock, flags);
 
         switch (cmd) {
         case SNDRV_PCM_TRIGGER_START:
@@ -822,7 +739,7 @@ static int aaci_pcm_capture_trigger(struct snd_pcm_substream *substream, int cmd
                 ret = -EINVAL;
         }
 
-        spin_unlock_irqrestore(&aaci->lock, flags);
+        spin_unlock_irqrestore(&aacirun->lock, flags);
 
         return ret;
 }
@@ -854,7 +771,6 @@ static struct snd_pcm_ops aaci_capture_ops = {
         .prepare        = aaci_pcm_capture_prepare,
         .trigger        = aaci_pcm_capture_trigger,
         .pointer        = aaci_pcm_pointer,
-        .mmap           = aaci_pcm_mmap,
 };
 
 /*
@@ -906,6 +822,12 @@ static struct ac97_pcm ac97_defs[] __devinitdata = {
                                           (1 << AC97_SLOT_PCM_SRIGHT) |
                                           (1 << AC97_SLOT_LFE),
                         },
+                        [1] = {
+                                .slots  = (1 << AC97_SLOT_PCM_LEFT) |
+                                          (1 << AC97_SLOT_PCM_RIGHT) |
+                                          (1 << AC97_SLOT_PCM_LEFT_0) |
+                                          (1 << AC97_SLOT_PCM_RIGHT_0),
+                        },
                 },
         },
         [1] = { /* PCM in */
@@ -941,7 +863,6 @@ static int __devinit aaci_probe_ac97(struct aaci *aaci)
         struct snd_ac97 *ac97;
         int ret;
 
-        writel(0, aaci->base + AC97_POWERDOWN);
         /*
          * Assert AACIRESET for 2us
          */
@@ -1018,7 +939,6 @@ static struct aaci * __devinit aaci_init_card(struct amba_device *dev)
 
         aaci = card->private_data;
         mutex_init(&aaci->ac97_sem);
-        spin_lock_init(&aaci->lock);
         aaci->card = card;
         aaci->dev = dev;
 
@@ -1044,6 +964,8 @@ static int __devinit aaci_init_pcm(struct aaci *aaci)
 
                 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &aaci_playback_ops);
                 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &aaci_capture_ops);
+                snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
+                                                      NULL, 0, 64 * 1024);
         }
 
         return ret;
@@ -1103,12 +1025,14 @@ static int __devinit aaci_probe(struct amba_device *dev, struct amba_id *id)
         /*
          * Playback uses AACI channel 0
          */
+        spin_lock_init(&aaci->playback.lock);
         aaci->playback.base = aaci->base + AACI_CSCH1;
         aaci->playback.fifo = aaci->base + AACI_DR1;
 
         /*
          * Capture uses AACI channel 0
          */
+        spin_lock_init(&aaci->capture.lock);
         aaci->capture.base = aaci->base + AACI_CSCH1;
         aaci->capture.fifo = aaci->base + AACI_DR1;
 
@@ -1122,7 +1046,11 @@ static int __devinit aaci_probe(struct amba_device *dev, struct amba_id *id)
 
         writel(0x1fff, aaci->base + AACI_INTCLR);
         writel(aaci->maincr, aaci->base + AACI_MAINCR);
-
+        /*
+         * Fix: ac97 read back fail errors by reading
+         * from any arbitrary aaci register.
+         */
+        readl(aaci->base + AACI_CSCH1);
         ret = aaci_probe_ac97(aaci);
         if (ret)
                 goto out;
diff --git a/sound/arm/aaci.h b/sound/arm/aaci.h
index 924f69c1c44c..6a4a2eebdda1 100644
--- a/sound/arm/aaci.h
+++ b/sound/arm/aaci.h
@@ -202,6 +202,7 @@
 struct aaci_runtime {
         void                    __iomem *base;
         void                    __iomem *fifo;
+        spinlock_t              lock;
 
         struct ac97_pcm         *pcm;
         int                     pcm_open;
@@ -232,7 +233,6 @@ struct aaci {
         struct snd_ac97         *ac97;
 
         u32                     maincr;
-        spinlock_t              lock;
 
         struct aaci_runtime     playback;
         struct aaci_runtime     capture;
diff --git a/sound/arm/devdma.c b/sound/arm/devdma.c
deleted file mode 100644
index 9d1e6665b546..000000000000
--- a/sound/arm/devdma.c
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- *  linux/sound/arm/devdma.c
- *
- *  Copyright (C) 2003-2004 Russell King, All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- *  ARM DMA shim for ALSA.
- */
-#include <linux/device.h>
-#include <linux/dma-mapping.h>
-
-#include <sound/core.h>
-#include <sound/pcm.h>
-
-#include "devdma.h"
-
-void devdma_hw_free(struct device *dev, struct snd_pcm_substream *substream)
-{
-        struct snd_pcm_runtime *runtime = substream->runtime;
-        struct snd_dma_buffer *buf = runtime->dma_buffer_p;
-
-        if (runtime->dma_area == NULL)
-                return;
-
-        if (buf != &substream->dma_buffer) {
-                dma_free_coherent(buf->dev.dev, buf->bytes, buf->area, buf->addr);
-                kfree(runtime->dma_buffer_p);
-        }
-
-        snd_pcm_set_runtime_buffer(substream, NULL);
-}
-
-int devdma_hw_alloc(struct device *dev, struct snd_pcm_substream *substream, size_t size)
-{
-        struct snd_pcm_runtime *runtime = substream->runtime;
-        struct snd_dma_buffer *buf = runtime->dma_buffer_p;
-        int ret = 0;
-
-        if (buf) {
-                if (buf->bytes >= size)
-                        goto out;
-                devdma_hw_free(dev, substream);
-        }
-
-        if (substream->dma_buffer.area != NULL && substream->dma_buffer.bytes >= size) {
-                buf = &substream->dma_buffer;
-        } else {
-                buf = kmalloc(sizeof(struct snd_dma_buffer), GFP_KERNEL);
-                if (!buf)
-                        goto nomem;
-
-                buf->dev.type = SNDRV_DMA_TYPE_DEV;
-                buf->dev.dev = dev;
-                buf->area = dma_alloc_coherent(dev, size, &buf->addr, GFP_KERNEL);
-                buf->bytes = size;
-                buf->private_data = NULL;
-
-                if (!buf->area)
-                        goto free;
-        }
-        snd_pcm_set_runtime_buffer(substream, buf);
-        ret = 1;
- out:
-        runtime->dma_bytes = size;
-        return ret;
-
- free:
-        kfree(buf);
- nomem:
-        return -ENOMEM;
-}
-
-int devdma_mmap(struct device *dev, struct snd_pcm_substream *substream, struct vm_area_struct *vma)
-{
-        struct snd_pcm_runtime *runtime = substream->runtime;
-        return dma_mmap_coherent(dev, vma, runtime->dma_area, runtime->dma_addr, runtime->dma_bytes);
-}
diff --git a/sound/arm/devdma.h b/sound/arm/devdma.h
deleted file mode 100644
index d025329c8a0f..000000000000
--- a/sound/arm/devdma.h
+++ /dev/null
@@ -1,3 +0,0 @@
-void devdma_hw_free(struct device *dev, struct snd_pcm_substream *substream);
-int devdma_hw_alloc(struct device *dev, struct snd_pcm_substream *substream, size_t size);
-int devdma_mmap(struct device *dev, struct snd_pcm_substream *substream, struct vm_area_struct *vma);
diff --git a/sound/arm/pxa2xx-ac97-lib.c b/sound/arm/pxa2xx-ac97-lib.c
index 6fdca97186e7..88eec3847df2 100644
--- a/sound/arm/pxa2xx-ac97-lib.c
+++ b/sound/arm/pxa2xx-ac97-lib.c
@@ -22,7 +22,6 @@
 
 #include <asm/irq.h>
 #include <mach/regs-ac97.h>
-#include <mach/pxa2xx-gpio.h>
 #include <mach/audio.h>
 
 static DEFINE_MUTEX(car_mutex);
@@ -32,6 +31,8 @@ static struct clk *ac97_clk;
 static struct clk *ac97conf_clk;
 static int reset_gpio;
 
+extern void pxa27x_assert_ac97reset(int reset_gpio, int on);
+
 /*
  * Beware PXA27x bugs:
  *
@@ -42,45 +43,6 @@ static int reset_gpio;
  * 1 jiffy timeout if interrupt never comes).
  */
 
-enum {
-        RESETGPIO_FORCE_HIGH,
-        RESETGPIO_FORCE_LOW,
-        RESETGPIO_NORMAL_ALTFUNC
-};
-
-/**
- * set_resetgpio_mode - computes and sets the AC97_RESET gpio mode on PXA
- * @mode: chosen action
- *
- * As the PXA27x CPUs suffer from a AC97 bug, a manual control of the reset line
- * must be done to insure proper work of AC97 reset line.  This function
- * computes the correct gpio_mode for further use by reset functions, and
- * applied the change through pxa_gpio_mode.
- */
-static void set_resetgpio_mode(int resetgpio_action)
-{
-        int mode = 0;
-
-        if (reset_gpio)
-                switch (resetgpio_action) {
-                case RESETGPIO_NORMAL_ALTFUNC:
-                        if (reset_gpio == 113)
-                                mode = 113 | GPIO_ALT_FN_2_OUT;
-                        if (reset_gpio == 95)
-                                mode = 95 | GPIO_ALT_FN_1_OUT;
-                        break;
-                case RESETGPIO_FORCE_LOW:
-                        mode = reset_gpio | GPIO_OUT | GPIO_DFLT_LOW;
-                        break;
-                case RESETGPIO_FORCE_HIGH:
-                        mode = reset_gpio | GPIO_OUT | GPIO_DFLT_HIGH;
-                        break;
-                };
-
-        if (mode)
-                pxa_gpio_mode(mode);
-}
-
 unsigned short pxa2xx_ac97_read(struct snd_ac97 *ac97, unsigned short reg)
 {
         unsigned short val = -1;
@@ -174,12 +136,11 @@ static inline void pxa_ac97_warm_pxa27x(void)
 {
         gsr_bits = 0;
 
-        /* warm reset broken on Bulverde,
-           so manually keep AC97 reset high */
-        set_resetgpio_mode(RESETGPIO_FORCE_HIGH);
+        /* warm reset broken on Bulverde, so manually keep AC97 reset high */
+        pxa27x_assert_ac97reset(reset_gpio, 1);
         udelay(10);
         GCR |= GCR_WARM_RST;
-        set_resetgpio_mode(RESETGPIO_NORMAL_ALTFUNC);
+        pxa27x_assert_ac97reset(reset_gpio, 0);
         udelay(500);
 }
 
@@ -345,16 +306,6 @@ EXPORT_SYMBOL_GPL(pxa2xx_ac97_hw_suspend);
 
 int pxa2xx_ac97_hw_resume(void)
 {
-        if (cpu_is_pxa25x() || cpu_is_pxa27x()) {
-                pxa_gpio_mode(GPIO31_SYNC_AC97_MD);
-                pxa_gpio_mode(GPIO30_SDATA_OUT_AC97_MD);
-                pxa_gpio_mode(GPIO28_BITCLK_AC97_MD);
-                pxa_gpio_mode(GPIO29_SDATA_IN_AC97_MD);
-        }
-        if (cpu_is_pxa27x()) {
-                /* Use GPIO 113 or 95 as AC97 Reset on Bulverde */
-                set_resetgpio_mode(RESETGPIO_NORMAL_ALTFUNC);
-        }
         clk_enable(ac97_clk);
         return 0;
 }
@@ -386,16 +337,9 @@ int __devinit pxa2xx_ac97_hw_probe(struct platform_device *dev)
                         reset_gpio = 113;
         }
 
-        if (cpu_is_pxa25x() || cpu_is_pxa27x()) {
-                pxa_gpio_mode(GPIO31_SYNC_AC97_MD);
-                pxa_gpio_mode(GPIO30_SDATA_OUT_AC97_MD);
-                pxa_gpio_mode(GPIO28_BITCLK_AC97_MD);
-                pxa_gpio_mode(GPIO29_SDATA_IN_AC97_MD);
-        }
-
         if (cpu_is_pxa27x()) {
                 /* Use GPIO 113 as AC97 Reset on Bulverde */
-                set_resetgpio_mode(RESETGPIO_NORMAL_ALTFUNC);
+                pxa27x_assert_ac97reset(reset_gpio, 0);
                 ac97conf_clk = clk_get(&dev->dev, "AC97CONFCLK");
                 if (IS_ERR(ac97conf_clk)) {
                         ret = PTR_ERR(ac97conf_clk);
diff --git a/sound/arm/pxa2xx-ac97.c b/sound/arm/pxa2xx-ac97.c
index b4b48afb6de6..5d9411839cd7 100644
--- a/sound/arm/pxa2xx-ac97.c
+++ b/sound/arm/pxa2xx-ac97.c
@@ -159,7 +159,7 @@ static int pxa2xx_ac97_resume(struct device *dev)
         return ret;
 }
 
-static struct dev_pm_ops pxa2xx_ac97_pm_ops = {
+static const struct dev_pm_ops pxa2xx_ac97_pm_ops = {
         .suspend        = pxa2xx_ac97_suspend,
         .resume         = pxa2xx_ac97_resume,
 };
diff --git a/sound/arm/pxa2xx-pcm-lib.c b/sound/arm/pxa2xx-pcm-lib.c
index 743ac6a29065..8808b82311b1 100644
--- a/sound/arm/pxa2xx-pcm-lib.c
+++ b/sound/arm/pxa2xx-pcm-lib.c
@@ -4,6 +4,7 @@
  * published by the Free Software Foundation.
  */
 
+#include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/dma-mapping.h>
 
@@ -205,6 +206,7 @@ int __pxa2xx_pcm_open(struct snd_pcm_substream *substream)
         if (!rtd->dma_desc_array)
                 goto err1;
 
+        rtd->dma_ch = -1;
         runtime->private_data = rtd;
         return 0;
 
diff --git a/sound/core/Kconfig b/sound/core/Kconfig
index c15682a2f9db..475455c76610 100644
--- a/sound/core/Kconfig
+++ b/sound/core/Kconfig
@@ -5,6 +5,7 @@ config SND_TIMER
 config SND_PCM
         tristate
         select SND_TIMER
+        select GCD
 
 config SND_HWDEP
         tristate
diff --git a/sound/core/control.c b/sound/core/control.c
index a8b7fabe645e..439ce64f9d82 100644
--- a/sound/core/control.c
+++ b/sound/core/control.c
@@ -75,7 +75,7 @@ static int snd_ctl_open(struct inode *inode, struct file *file)
         ctl->card = card;
         ctl->prefer_pcm_subdevice = -1;
         ctl->prefer_rawmidi_subdevice = -1;
-        ctl->pid = current->pid;
+        ctl->pid = get_pid(task_pid(current));
         file->private_data = ctl;
         write_lock_irqsave(&card->ctl_files_rwlock, flags);
         list_add_tail(&ctl->list, &card->ctl_files);
@@ -125,6 +125,7 @@ static int snd_ctl_release(struct inode *inode, struct file *file)
                                 control->vd[idx].owner = NULL;
         up_write(&card->controls_rwsem);
         snd_ctl_empty_read_queue(ctl);
+        put_pid(ctl->pid);
         kfree(ctl);
         module_put(card->module);
         snd_card_file_remove(card, file);
@@ -236,8 +237,9 @@ struct snd_kcontrol *snd_ctl_new1(const struct snd_kcontrol_new *ncontrol,
         access = ncontrol->access == 0 ? SNDRV_CTL_ELEM_ACCESS_READWRITE :
                  (ncontrol->access & (SNDRV_CTL_ELEM_ACCESS_READWRITE|
                                       SNDRV_CTL_ELEM_ACCESS_INACTIVE|
-                                      SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE|
-                                      SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK));
+                                      SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE|
+                                      SNDRV_CTL_ELEM_ACCESS_TLV_COMMAND|
+                                      SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK));
         kctl.info = ncontrol->info;
         kctl.get = ncontrol->get;
         kctl.put = ncontrol->put;
@@ -672,7 +674,7 @@ static int snd_ctl_elem_info(struct snd_ctl_file *ctl,
                         info->access |= SNDRV_CTL_ELEM_ACCESS_LOCK;
                         if (vd->owner == ctl)
                                 info->access |= SNDRV_CTL_ELEM_ACCESS_OWNER;
-                        info->owner = vd->owner_pid;
+                        info->owner = pid_vnr(vd->owner->pid);
                 } else {
                         info->owner = -1;
                 }
@@ -827,7 +829,6 @@ static int snd_ctl_elem_lock(struct snd_ctl_file *file,
                         result = -EBUSY;
                 else {
                         vd->owner = file;
-                        vd->owner_pid = current->pid;
                         result = 0;
                 }
         }
@@ -858,7 +859,6 @@ static int snd_ctl_elem_unlock(struct snd_ctl_file *file,
                         result = -EPERM;
                 else {
                         vd->owner = NULL;
-                        vd->owner_pid = 0;
                         result = 0;
                 }
         }
@@ -1100,7 +1100,7 @@ static int snd_ctl_tlv_ioctl(struct snd_ctl_file *file,
 
         if (copy_from_user(&tlv, _tlv, sizeof(tlv)))
                 return -EFAULT;
-        if (tlv.length < sizeof(unsigned int) * 3)
+        if (tlv.length < sizeof(unsigned int) * 2)
                 return -EINVAL;
         down_read(&card->controls_rwsem);
         kctl = snd_ctl_find_numid(card, tlv.numid);
@@ -1120,7 +1120,7 @@ static int snd_ctl_tlv_ioctl(struct snd_ctl_file *file,
                 goto __kctl_end;
         }
         if (vd->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
-                if (file && vd->owner != NULL && vd->owner != file) {
+                if (vd->owner != NULL && vd->owner != file) {
                         err = -EPERM;
                         goto __kctl_end;
                 }
diff --git a/sound/core/control_compat.c b/sound/core/control_compat.c
index 368dc9c4aef8..426874429a5e 100644
--- a/sound/core/control_compat.c
+++ b/sound/core/control_compat.c
@@ -21,6 +21,7 @@
 /* this file included from control.c */
 
 #include <linux/compat.h>
+#include <linux/slab.h>
 
 struct snd_ctl_elem_list32 {
         u32 offset;
diff --git a/sound/core/hrtimer.c b/sound/core/hrtimer.c
index 34c7d48f5061..7730575bfadd 100644
--- a/sound/core/hrtimer.c
+++ b/sound/core/hrtimer.c
@@ -19,6 +19,7 @@
  */
 
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/hrtimer.h>
@@ -37,14 +38,22 @@ static unsigned int resolution;
 struct snd_hrtimer {
         struct snd_timer *timer;
         struct hrtimer hrt;
+        atomic_t running;
 };
 
 static enum hrtimer_restart snd_hrtimer_callback(struct hrtimer *hrt)
 {
         struct snd_hrtimer *stime = container_of(hrt, struct snd_hrtimer, hrt);
         struct snd_timer *t = stime->timer;
+
+        if (!atomic_read(&stime->running))
+                return HRTIMER_NORESTART;
+
         hrtimer_forward_now(hrt, ns_to_ktime(t->sticks * resolution));
         snd_timer_interrupt(stime->timer, t->sticks);
+
+        if (!atomic_read(&stime->running))
+                return HRTIMER_NORESTART;
         return HRTIMER_RESTART;
 }
 
@@ -58,6 +67,7 @@ static int snd_hrtimer_open(struct snd_timer *t)
         hrtimer_init(&stime->hrt, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
         stime->timer = t;
         stime->hrt.function = snd_hrtimer_callback;
+        atomic_set(&stime->running, 0);
         t->private_data = stime;
         return 0;
 }
@@ -78,16 +88,18 @@ static int snd_hrtimer_start(struct snd_timer *t)
 {
         struct snd_hrtimer *stime = t->private_data;
 
+        atomic_set(&stime->running, 0);
+        hrtimer_cancel(&stime->hrt);
         hrtimer_start(&stime->hrt, ns_to_ktime(t->sticks * resolution),
                       HRTIMER_MODE_REL);
+        atomic_set(&stime->running, 1);
         return 0;
 }
 
 static int snd_hrtimer_stop(struct snd_timer *t)
 {
         struct snd_hrtimer *stime = t->private_data;
-
-        hrtimer_cancel(&stime->hrt);
+        atomic_set(&stime->running, 0);
         return 0;
 }
 
diff --git a/sound/core/info.c b/sound/core/info.c
index d749a0d394a7..cc4a53d4b7f8 100644
--- a/sound/core/info.c
+++ b/sound/core/info.c
@@ -22,6 +22,7 @@
 #include <linux/init.h>
 #include <linux/time.h>
 #include <linux/mm.h>
+#include <linux/slab.h>
 #include <linux/smp_lock.h>
 #include <linux/string.h>
 #include <sound/core.h>
diff --git a/sound/core/isadma.c b/sound/core/isadma.c
index 79f0f16af339..950e19ba91fc 100644
--- a/sound/core/isadma.c
+++ b/sound/core/isadma.c
@@ -85,16 +85,24 @@ EXPORT_SYMBOL(snd_dma_disable);
 unsigned int snd_dma_pointer(unsigned long dma, unsigned int size)
 {
         unsigned long flags;
-        unsigned int result;
+        unsigned int result, result1;
 
         flags = claim_dma_lock();
         clear_dma_ff(dma);
         if (!isa_dma_bridge_buggy)
                 disable_dma(dma);
         result = get_dma_residue(dma);
+        /*
+         * HACK - read the counter again and choose higher value in order to
+         * avoid reading during counter lower byte roll over if the
+         * isa_dma_bridge_buggy is set.
+         */
+        result1 = get_dma_residue(dma);
         if (!isa_dma_bridge_buggy)
                 enable_dma(dma);
         release_dma_lock(flags);
+        if (unlikely(result < result1))
+                result = result1;
 #ifdef CONFIG_SND_DEBUG
         if (result > size)
                 snd_printk(KERN_ERR "pointer (0x%x) for DMA #%ld is greater than transfer size (0x%x)\n", result, dma, size);
diff --git a/sound/core/jack.c b/sound/core/jack.c
index f705eec7372a..14b8a4ee690d 100644
--- a/sound/core/jack.c
+++ b/sound/core/jack.c
@@ -20,6 +20,7 @@
  */
 
 #include <linux/input.h>
+#include <linux/slab.h>
 #include <sound/jack.h>
 #include <sound/core.h>
 
diff --git a/sound/core/misc.c b/sound/core/misc.c
index 23a032c6d487..2c41825c836e 100644
--- a/sound/core/misc.c
+++ b/sound/core/misc.c
@@ -21,6 +21,7 @@
 
 #include <linux/init.h>
 #include <linux/time.h>
+#include <linux/slab.h>
 #include <linux/ioport.h>
 #include <sound/core.h>
 
@@ -101,8 +102,9 @@ EXPORT_SYMBOL_GPL(__snd_printk);
 #ifdef CONFIG_PCI
 #include <linux/pci.h>
 /**
- * snd_pci_quirk_lookup - look up a PCI SSID quirk list
- * @pci: pci_dev handle
+ * snd_pci_quirk_lookup_id - look up a PCI SSID quirk list
+ * @vendor: PCI SSV id
+ * @device: PCI SSD id
  * @list: quirk list, terminated by a null entry
  *
  * Look through the given quirk list and finds a matching entry
@@ -112,18 +114,39 @@ EXPORT_SYMBOL_GPL(__snd_printk);
  * Returns the matched entry pointer, or NULL if nothing matched.
  */
 const struct snd_pci_quirk *
-snd_pci_quirk_lookup(struct pci_dev *pci, const struct snd_pci_quirk *list)
+snd_pci_quirk_lookup_id(u16 vendor, u16 device,
+                        const struct snd_pci_quirk *list)
 {
         const struct snd_pci_quirk *q;
 
         for (q = list; q->subvendor; q++) {
-                if (q->subvendor != pci->subsystem_vendor)
+                if (q->subvendor != vendor)
                         continue;
                 if (!q->subdevice ||
-                    (pci->subsystem_device & q->subdevice_mask) == q->subdevice)
+                    (device & q->subdevice_mask) == q->subdevice)
                         return q;
         }
         return NULL;
 }
+EXPORT_SYMBOL(snd_pci_quirk_lookup_id);
+
+/**
+ * snd_pci_quirk_lookup - look up a PCI SSID quirk list
+ * @pci: pci_dev handle
+ * @list: quirk list, terminated by a null entry
+ *
+ * Look through the given quirk list and finds a matching entry
+ * with the same PCI SSID.  When subdevice is 0, all subdevice
+ * values may match.
+ *
+ * Returns the matched entry pointer, or NULL if nothing matched.
+ */
+const struct snd_pci_quirk *
+snd_pci_quirk_lookup(struct pci_dev *pci, const struct snd_pci_quirk *list)
+{
+        return snd_pci_quirk_lookup_id(pci->subsystem_vendor,
+                                       pci->subsystem_device,
+                                       list);
+}
 EXPORT_SYMBOL(snd_pci_quirk_lookup);
 #endif
diff --git a/sound/core/oss/mixer_oss.c b/sound/core/oss/mixer_oss.c
index 772423889eb3..54e2eb56e4c2 100644
--- a/sound/core/oss/mixer_oss.c
+++ b/sound/core/oss/mixer_oss.c
@@ -1251,7 +1251,9 @@ static void snd_mixer_oss_build(struct snd_mixer_oss *mixer)
                 { SOUND_MIXER_SYNTH,    "FM",                   0 }, /* fallback */
                 { SOUND_MIXER_SYNTH,    "Music",                0 }, /* fallback */
                 { SOUND_MIXER_PCM,      "PCM",                  0 },
-                { SOUND_MIXER_SPEAKER,  "PC Speaker",           0 },
+                { SOUND_MIXER_SPEAKER,  "Beep",                 0 },
+                { SOUND_MIXER_SPEAKER,  "PC Speaker",           0 }, /* fallback */
+                { SOUND_MIXER_SPEAKER,  "Speaker",              0 }, /* fallback */
                 { SOUND_MIXER_LINE,     "Line",                 0 },
                 { SOUND_MIXER_MIC,      "Mic",                  0 },
                 { SOUND_MIXER_CD,       "CD",                   0 },
diff --git a/sound/core/oss/pcm_oss.c b/sound/core/oss/pcm_oss.c
index d9c96353121a..82d4e3329b3d 100644
--- a/sound/core/oss/pcm_oss.c
+++ b/sound/core/oss/pcm_oss.c
@@ -632,6 +632,12 @@ static long snd_pcm_alsa_frames(struct snd_pcm_substream *substream, long bytes)
         return bytes_to_frames(runtime, (buffer_size * bytes) / runtime->oss.buffer_bytes);
 }
 
+static inline
+snd_pcm_uframes_t get_hw_ptr_period(struct snd_pcm_runtime *runtime)
+{
+        return runtime->hw_ptr_interrupt;
+}
+
 /* define extended formats in the recent OSS versions (if any) */
 /* linear formats */
 #define AFMT_S32_LE      0x00001000
@@ -1102,7 +1108,7 @@ static int snd_pcm_oss_prepare(struct snd_pcm_substream *substream)
                 return err;
         }
         runtime->oss.prepare = 0;
-        runtime->oss.prev_hw_ptr_interrupt = 0;
+        runtime->oss.prev_hw_ptr_period = 0;
         runtime->oss.period_ptr = 0;
         runtime->oss.buffer_used = 0;
 
@@ -1950,7 +1956,8 @@ static int snd_pcm_oss_get_caps(struct snd_pcm_oss_file *pcm_oss_file)
         return result;
 }
 
-static void snd_pcm_oss_simulate_fill(struct snd_pcm_substream *substream, snd_pcm_uframes_t hw_ptr)
+static void snd_pcm_oss_simulate_fill(struct snd_pcm_substream *substream,
+                                      snd_pcm_uframes_t hw_ptr)
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
         snd_pcm_uframes_t appl_ptr;
@@ -1986,7 +1993,8 @@ static int snd_pcm_oss_set_trigger(struct snd_pcm_oss_file *pcm_oss_file, int tr
                         if (runtime->oss.trigger)
                                 goto _skip1;
                         if (atomic_read(&psubstream->mmap_count))
-                                snd_pcm_oss_simulate_fill(psubstream, runtime->hw_ptr_interrupt);
+                                snd_pcm_oss_simulate_fill(psubstream,
+                                                get_hw_ptr_period(runtime));
                         runtime->oss.trigger = 1;
                         runtime->start_threshold = 1;
                         cmd = SNDRV_PCM_IOCTL_START;
@@ -2105,11 +2113,12 @@ static int snd_pcm_oss_get_ptr(struct snd_pcm_oss_file *pcm_oss_file, int stream
         info.ptr = snd_pcm_oss_bytes(substream, runtime->status->hw_ptr % runtime->buffer_size);
         if (atomic_read(&substream->mmap_count)) {
                 snd_pcm_sframes_t n;
-                n = (delay = runtime->hw_ptr_interrupt) - runtime->oss.prev_hw_ptr_interrupt;
+                delay = get_hw_ptr_period(runtime);
+                n = delay - runtime->oss.prev_hw_ptr_period;
                 if (n < 0)
                         n += runtime->boundary;
                 info.blocks = n / runtime->period_size;
-                runtime->oss.prev_hw_ptr_interrupt = delay;
+                runtime->oss.prev_hw_ptr_period = delay;
                 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
                         snd_pcm_oss_simulate_fill(substream, delay);
                 info.bytes = snd_pcm_oss_bytes(substream, runtime->status->hw_ptr) & INT_MAX;
@@ -2673,18 +2682,22 @@ static int snd_pcm_oss_playback_ready(struct snd_pcm_substream *substream)
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
         if (atomic_read(&substream->mmap_count))
-                return runtime->oss.prev_hw_ptr_interrupt != runtime->hw_ptr_interrupt;
+                return runtime->oss.prev_hw_ptr_period !=
+                                                get_hw_ptr_period(runtime);
         else
-                return snd_pcm_playback_avail(runtime) >= runtime->oss.period_frames;
+                return snd_pcm_playback_avail(runtime) >=
+                                                runtime->oss.period_frames;
 }
 
 static int snd_pcm_oss_capture_ready(struct snd_pcm_substream *substream)
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
         if (atomic_read(&substream->mmap_count))
-                return runtime->oss.prev_hw_ptr_interrupt != runtime->hw_ptr_interrupt;
+                return runtime->oss.prev_hw_ptr_period !=
+                                                get_hw_ptr_period(runtime);
         else
-                return snd_pcm_capture_avail(runtime) >= runtime->oss.period_frames;
+                return snd_pcm_capture_avail(runtime) >=
+                                                runtime->oss.period_frames;
 }
 
 static unsigned int snd_pcm_oss_poll(struct file *file, poll_table * wait)
diff --git a/sound/core/oss/route.c b/sound/core/oss/route.c
index 0dcc2870d537..bbe25d8c450a 100644
--- a/sound/core/oss/route.c
+++ b/sound/core/oss/route.c
@@ -19,7 +19,6 @@
  *
  */
 
-#include <linux/slab.h>
 #include <linux/time.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
diff --git a/sound/core/pcm.c b/sound/core/pcm.c
index c69c60b2a48a..0d428d0896db 100644
--- a/sound/core/pcm.c
+++ b/sound/core/pcm.c
@@ -435,6 +435,7 @@ static void snd_pcm_substream_proc_status_read(struct snd_info_entry *entry,
                 return;
         }
         snd_iprintf(buffer, "state: %s\n", snd_pcm_state_name(status.state));
+        snd_iprintf(buffer, "owner_pid   : %d\n", pid_vnr(substream->pid));
         snd_iprintf(buffer, "trigger_time: %ld.%09ld\n",
                 status.trigger_tstamp.tv_sec, status.trigger_tstamp.tv_nsec);
         snd_iprintf(buffer, "tstamp      : %ld.%09ld\n",
@@ -809,7 +810,7 @@ int snd_pcm_attach_substream(struct snd_pcm *pcm, int stream,
         card = pcm->card;
         read_lock(&card->ctl_files_rwlock);
         list_for_each_entry(kctl, &card->ctl_files, list) {
-                if (kctl->pid == current->pid) {
+                if (kctl->pid == task_pid(current)) {
                         prefer_subdevice = kctl->prefer_pcm_subdevice;
                         if (prefer_subdevice != -1)
                                 break;
@@ -893,6 +894,7 @@ int snd_pcm_attach_substream(struct snd_pcm *pcm, int stream,
         memset((void*)runtime->control, 0, size);
 
         init_waitqueue_head(&runtime->sleep);
+        init_waitqueue_head(&runtime->tsleep);
 
         runtime->status->state = SNDRV_PCM_STATE_OPEN;
 
@@ -900,6 +902,7 @@ int snd_pcm_attach_substream(struct snd_pcm *pcm, int stream,
         substream->private_data = pcm->private_data;
         substream->ref_count = 1;
         substream->f_flags = file->f_flags;
+        substream->pid = get_pid(task_pid(current));
         pstr->substream_opened++;
         *rsubstream = substream;
         return 0;
@@ -919,8 +922,14 @@ void snd_pcm_detach_substream(struct snd_pcm_substream *substream)
         snd_free_pages((void*)runtime->control,
                        PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control)));
         kfree(runtime->hw_constraints.rules);
+#ifdef CONFIG_SND_PCM_XRUN_DEBUG
+        if (runtime->hwptr_log)
+                kfree(runtime->hwptr_log);
+#endif
         kfree(runtime);
         substream->runtime = NULL;
+        put_pid(substream->pid);
+        substream->pid = NULL;
         substream->pstr->substream_opened--;
 }
 
diff --git a/sound/core/pcm_compat.c b/sound/core/pcm_compat.c
index 08bfed594a83..5fb2e28e796f 100644
--- a/sound/core/pcm_compat.c
+++ b/sound/core/pcm_compat.c
@@ -21,6 +21,7 @@
 /* This file included from pcm_native.c */
 
 #include <linux/compat.h>
+#include <linux/slab.h>
 
 static int snd_pcm_ioctl_delay_compat(struct snd_pcm_substream *substream,
                                       s32 __user *src)
diff --git a/sound/core/pcm_lib.c b/sound/core/pcm_lib.c
index 30f410832a25..a2ff86189d2a 100644
--- a/sound/core/pcm_lib.c
+++ b/sound/core/pcm_lib.c
@@ -126,17 +126,6 @@ void snd_pcm_playback_silence(struct snd_pcm_substream *substream, snd_pcm_ufram
         }
 }
 
-#ifdef CONFIG_SND_PCM_XRUN_DEBUG
-#define xrun_debug(substream, mask)     ((substream)->pstr->xrun_debug & (mask))
-#else
-#define xrun_debug(substream, mask)     0
-#endif
-
-#define dump_stack_on_xrun(substream) do {              \
-                if (xrun_debug(substream, 2))           \
-                        dump_stack();                   \
-        } while (0)
-
 static void pcm_debug_name(struct snd_pcm_substream *substream,
                            char *name, size_t len)
 {
@@ -147,6 +136,27 @@ static void pcm_debug_name(struct snd_pcm_substream *substream,
                  substream->number);
 }
 
+#define XRUN_DEBUG_BASIC        (1<<0)
+#define XRUN_DEBUG_STACK        (1<<1)  /* dump also stack */
+#define XRUN_DEBUG_JIFFIESCHECK (1<<2)  /* do jiffies check */
+#define XRUN_DEBUG_PERIODUPDATE (1<<3)  /* full period update info */
+#define XRUN_DEBUG_HWPTRUPDATE  (1<<4)  /* full hwptr update info */
+#define XRUN_DEBUG_LOG          (1<<5)  /* show last 10 positions on err */
+#define XRUN_DEBUG_LOGONCE      (1<<6)  /* do above only once */
+
+#ifdef CONFIG_SND_PCM_XRUN_DEBUG
+
+#define xrun_debug(substream, mask) \
+                        ((substream)->pstr->xrun_debug & (mask))
+#else
+#define xrun_debug(substream, mask)     0
+#endif
+
+#define dump_stack_on_xrun(substream) do {                      \
+                if (xrun_debug(substream, XRUN_DEBUG_STACK))    \
+                        dump_stack();                           \
+        } while (0)
+
 static void xrun(struct snd_pcm_substream *substream)
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
@@ -154,7 +164,7 @@ static void xrun(struct snd_pcm_substream *substream)
         if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE)
                 snd_pcm_gettime(runtime, (struct timespec *)&runtime->status->tstamp);
         snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
-        if (xrun_debug(substream, 1)) {
+        if (xrun_debug(substream, XRUN_DEBUG_BASIC)) {
                 char name[16];
                 pcm_debug_name(substream, name, sizeof(name));
                 snd_printd(KERN_DEBUG "XRUN: %s\n", name);
@@ -162,32 +172,101 @@ static void xrun(struct snd_pcm_substream *substream)
         }
 }
 
-static snd_pcm_uframes_t
-snd_pcm_update_hw_ptr_pos(struct snd_pcm_substream *substream,
-                          struct snd_pcm_runtime *runtime)
-{
+#ifdef CONFIG_SND_PCM_XRUN_DEBUG
+#define hw_ptr_error(substream, fmt, args...)                           \
+        do {                                                            \
+                if (xrun_debug(substream, XRUN_DEBUG_BASIC)) {          \
+                        xrun_log_show(substream);                       \
+                        if (printk_ratelimit()) {                       \
+                                snd_printd("PCM: " fmt, ##args);        \
+                        }                                               \
+                        dump_stack_on_xrun(substream);                  \
+                }                                                       \
+        } while (0)
+
+#define XRUN_LOG_CNT    10
+
+struct hwptr_log_entry {
+        unsigned long jiffies;
         snd_pcm_uframes_t pos;
+        snd_pcm_uframes_t period_size;
+        snd_pcm_uframes_t buffer_size;
+        snd_pcm_uframes_t old_hw_ptr;
+        snd_pcm_uframes_t hw_ptr_base;
+};
 
-        pos = substream->ops->pointer(substream);
-        if (pos == SNDRV_PCM_POS_XRUN)
-                return pos; /* XRUN */
-        if (pos >= runtime->buffer_size) {
-                if (printk_ratelimit()) {
-                        char name[16];
-                        pcm_debug_name(substream, name, sizeof(name));
-                        snd_printd(KERN_ERR  "BUG: %s, pos = 0x%lx, "
-                                   "buffer size = 0x%lx, period size = 0x%lx\n",
-                                   name, pos, runtime->buffer_size,
-                                   runtime->period_size);
-                }
-                pos = 0;
+struct snd_pcm_hwptr_log {
+        unsigned int idx;
+        unsigned int hit: 1;
+        struct hwptr_log_entry entries[XRUN_LOG_CNT];
+};
+
+static void xrun_log(struct snd_pcm_substream *substream,
+                     snd_pcm_uframes_t pos)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct snd_pcm_hwptr_log *log = runtime->hwptr_log;
+        struct hwptr_log_entry *entry;
+
+        if (log == NULL) {
+                log = kzalloc(sizeof(*log), GFP_ATOMIC);
+                if (log == NULL)
+                        return;
+                runtime->hwptr_log = log;
+        } else {
+                if (xrun_debug(substream, XRUN_DEBUG_LOGONCE) && log->hit)
+                        return;
         }
-        pos -= pos % runtime->min_align;
-        return pos;
+        entry = &log->entries[log->idx];
+        entry->jiffies = jiffies;
+        entry->pos = pos;
+        entry->period_size = runtime->period_size;
+        entry->buffer_size = runtime->buffer_size;;
+        entry->old_hw_ptr = runtime->status->hw_ptr;
+        entry->hw_ptr_base = runtime->hw_ptr_base;
+        log->idx = (log->idx + 1) % XRUN_LOG_CNT;
 }
 
-static int snd_pcm_update_hw_ptr_post(struct snd_pcm_substream *substream,
-                                      struct snd_pcm_runtime *runtime)
+static void xrun_log_show(struct snd_pcm_substream *substream)
+{
+        struct snd_pcm_hwptr_log *log = substream->runtime->hwptr_log;
+        struct hwptr_log_entry *entry;
+        char name[16];
+        unsigned int idx;
+        int cnt;
+
+        if (log == NULL)
+                return;
+        if (xrun_debug(substream, XRUN_DEBUG_LOGONCE) && log->hit)
+                return;
+        pcm_debug_name(substream, name, sizeof(name));
+        for (cnt = 0, idx = log->idx; cnt < XRUN_LOG_CNT; cnt++) {
+                entry = &log->entries[idx];
+                if (entry->period_size == 0)
+                        break;
+                snd_printd("hwptr log: %s: j=%lu, pos=%ld/%ld/%ld, "
+                           "hwptr=%ld/%ld\n",
+                           name, entry->jiffies, (unsigned long)entry->pos,
+                           (unsigned long)entry->period_size,
+                           (unsigned long)entry->buffer_size,
+                           (unsigned long)entry->old_hw_ptr,
+                           (unsigned long)entry->hw_ptr_base);
+                idx++;
+                idx %= XRUN_LOG_CNT;
+        }
+        log->hit = 1;
+}
+
+#else /* ! CONFIG_SND_PCM_XRUN_DEBUG */
+
+#define hw_ptr_error(substream, fmt, args...) do { } while (0)
+#define xrun_log(substream, pos)        do { } while (0)
+#define xrun_log_show(substream)        do { } while (0)
+
+#endif
+
+int snd_pcm_update_state(struct snd_pcm_substream *substream,
+                         struct snd_pcm_runtime *runtime)
 {
         snd_pcm_uframes_t avail;
 
@@ -209,88 +288,94 @@ static int snd_pcm_update_hw_ptr_post(struct snd_pcm_substream *substream,
                 }
         }
         if (avail >= runtime->control->avail_min)
-                wake_up(&runtime->sleep);
+                wake_up(runtime->twake ? &runtime->tsleep : &runtime->sleep);
         return 0;
 }
 
-#define hw_ptr_error(substream, fmt, args...)                           \
-        do {                                                            \
-                if (xrun_debug(substream, 1)) {                         \
-                        if (printk_ratelimit()) {                       \
-                                snd_printd("PCM: " fmt, ##args);        \
-                        }                                               \
-                        dump_stack_on_xrun(substream);                  \
-                }                                                       \
-        } while (0)
-
-static int snd_pcm_update_hw_ptr_interrupt(struct snd_pcm_substream *substream)
+static int snd_pcm_update_hw_ptr0(struct snd_pcm_substream *substream,
+                                  unsigned int in_interrupt)
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
         snd_pcm_uframes_t pos;
-        snd_pcm_uframes_t old_hw_ptr, new_hw_ptr, hw_ptr_interrupt, hw_base;
+        snd_pcm_uframes_t old_hw_ptr, new_hw_ptr, hw_base;
         snd_pcm_sframes_t hdelta, delta;
         unsigned long jdelta;
 
         old_hw_ptr = runtime->status->hw_ptr;
-        pos = snd_pcm_update_hw_ptr_pos(substream, runtime);
+        pos = substream->ops->pointer(substream);
         if (pos == SNDRV_PCM_POS_XRUN) {
                 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);
+        if (pos >= runtime->buffer_size) {
+                if (printk_ratelimit()) {
+                        char name[16];
+                        pcm_debug_name(substream, name, sizeof(name));
+                        xrun_log_show(substream);
+                        snd_printd(KERN_ERR  "BUG: %s, pos = %ld, "
+                                   "buffer size = %ld, period size = %ld\n",
+                                   name, pos, runtime->buffer_size,
+                                   runtime->period_size);
+                }
+                pos = 0;
         }
+        pos -= pos % runtime->min_align;
+        if (xrun_debug(substream, XRUN_DEBUG_LOG))
+                xrun_log(substream, pos);
         hw_base = runtime->hw_ptr_base;
         new_hw_ptr = hw_base + pos;
-        hw_ptr_interrupt = runtime->hw_ptr_interrupt + runtime->period_size;
-        delta = new_hw_ptr - hw_ptr_interrupt;
-        if (hw_ptr_interrupt >= runtime->boundary) {
-                hw_ptr_interrupt -= runtime->boundary;
-                if (hw_base < runtime->boundary / 2)
-                        /* hw_base was already lapped; recalc delta */
-                        delta = new_hw_ptr - hw_ptr_interrupt;
-        }
-        if (delta < 0) {
-                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 {
+        if (in_interrupt) {
+                /* we know that one period was processed */
+                /* delta = "expected next hw_ptr" for in_interrupt != 0 */
+                delta = runtime->hw_ptr_interrupt + runtime->period_size;
+                if (delta > new_hw_ptr) {
                         hw_base += runtime->buffer_size;
                         if (hw_base >= runtime->boundary)
                                 hw_base = 0;
                         new_hw_ptr = hw_base + pos;
+                        goto __delta;
                 }
         }
+        /* new_hw_ptr might be lower than old_hw_ptr in case when */
+        /* pointer crosses the end of the ring buffer */
+        if (new_hw_ptr < old_hw_ptr) {
+                hw_base += runtime->buffer_size;
+                if (hw_base >= runtime->boundary)
+                        hw_base = 0;
+                new_hw_ptr = hw_base + pos;
+        }
+      __delta:
+        delta = (new_hw_ptr - old_hw_ptr) % runtime->boundary;
+        if (xrun_debug(substream, in_interrupt ?
+                        XRUN_DEBUG_PERIODUPDATE : XRUN_DEBUG_HWPTRUPDATE)) {
+                char name[16];
+                pcm_debug_name(substream, name, sizeof(name));
+                snd_printd("%s_update: %s: pos=%u/%u/%u, "
+                           "hwptr=%ld/%ld/%ld/%ld\n",
+                           in_interrupt ? "period" : "hwptr",
+                           name,
+                           (unsigned int)pos,
+                           (unsigned int)runtime->period_size,
+                           (unsigned int)runtime->buffer_size,
+                           (unsigned long)delta,
+                           (unsigned long)old_hw_ptr,
+                           (unsigned long)new_hw_ptr,
+                           (unsigned long)runtime->hw_ptr_base);
+        }
+        /* something must be really wrong */
+        if (delta >= runtime->buffer_size + runtime->period_size) {
+                hw_ptr_error(substream,
+                               "Unexpected hw_pointer value %s"
+                               "(stream=%i, pos=%ld, new_hw_ptr=%ld, "
+                               "old_hw_ptr=%ld)\n",
+                                     in_interrupt ? "[Q] " : "[P]",
+                                     substream->stream, (long)pos,
+                                     (long)new_hw_ptr, (long)old_hw_ptr);
+                return 0;
+        }
 
         /* Do jiffies check only in xrun_debug mode */
-        if (!xrun_debug(substream, 4))
+        if (!xrun_debug(substream, XRUN_DEBUG_JIFFIESCHECK))
                 goto no_jiffies_check;
 
         /* Skip the jiffies check for hardwares with BATCH flag.
@@ -299,7 +384,7 @@ static int snd_pcm_update_hw_ptr_interrupt(struct snd_pcm_substream *substream)
          */
         if (runtime->hw.info & SNDRV_PCM_INFO_BATCH)
                 goto no_jiffies_check;
-        hdelta = new_hw_ptr - old_hw_ptr;
+        hdelta = delta;
         if (hdelta < runtime->delay)
                 goto no_jiffies_check;
         hdelta -= runtime->delay;
@@ -308,130 +393,68 @@ static int snd_pcm_update_hw_ptr_interrupt(struct snd_pcm_substream *substream)
                 delta = jdelta /
                         (((runtime->period_size * HZ) / runtime->rate)
                                                                 + HZ/100);
+                /* move new_hw_ptr according jiffies not pos variable */
+                new_hw_ptr = old_hw_ptr;
+                hw_base = delta;
+                /* use loop to avoid checks for delta overflows */
+                /* the delta value is small or zero in most cases */
+                while (delta > 0) {
+                        new_hw_ptr += runtime->period_size;
+                        if (new_hw_ptr >= runtime->boundary)
+                                new_hw_ptr -= runtime->boundary;
+                        delta--;
+                }
+                /* align hw_base to buffer_size */
                 hw_ptr_error(substream,
-                             "hw_ptr skipping! [Q] "
+                             "hw_ptr skipping! %s"
                              "(pos=%ld, delta=%ld, period=%ld, "
-                             "jdelta=%lu/%lu/%lu)\n",
+                             "jdelta=%lu/%lu/%lu, hw_ptr=%ld/%ld)\n",
+                             in_interrupt ? "[Q] " : "",
                              (long)pos, (long)hdelta,
                              (long)runtime->period_size, jdelta,
-                             ((hdelta * HZ) / runtime->rate), delta);
-                hw_ptr_interrupt = runtime->hw_ptr_interrupt +
-                                   runtime->period_size * delta;
-                if (hw_ptr_interrupt >= runtime->boundary)
-                        hw_ptr_interrupt -= runtime->boundary;
-                /* 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;
+                             ((hdelta * HZ) / runtime->rate), hw_base,
+                             (unsigned long)old_hw_ptr,
+                             (unsigned long)new_hw_ptr);
+                /* reset values to proper state */
                 delta = 0;
+                hw_base = new_hw_ptr - (new_hw_ptr % runtime->buffer_size);
         }
  no_jiffies_check:
         if (delta > runtime->period_size + runtime->period_size / 2) {
                 hw_ptr_error(substream,
-                             "Lost interrupts? "
-                             "(stream=%i, delta=%ld, intr_ptr=%ld)\n",
+                             "Lost interrupts? %s"
+                             "(stream=%i, delta=%ld, new_hw_ptr=%ld, "
+                             "old_hw_ptr=%ld)\n",
+                             in_interrupt ? "[Q] " : "",
                              substream->stream, (long)delta,
-                             (long)hw_ptr_interrupt);
-                /* rebase hw_ptr_interrupt */
-                hw_ptr_interrupt =
-                        new_hw_ptr - new_hw_ptr % runtime->period_size;
+                             (long)new_hw_ptr,
+                             (long)old_hw_ptr);
         }
-        runtime->hw_ptr_interrupt = hw_ptr_interrupt;
+
+        if (runtime->status->hw_ptr == new_hw_ptr)
+                return 0;
 
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
             runtime->silence_size > 0)
                 snd_pcm_playback_silence(substream, new_hw_ptr);
 
-        if (runtime->status->hw_ptr == new_hw_ptr)
-                return 0;
-
+        if (in_interrupt) {
+                runtime->hw_ptr_interrupt = new_hw_ptr -
+                                (new_hw_ptr % runtime->period_size);
+        }
         runtime->hw_ptr_base = hw_base;
         runtime->status->hw_ptr = new_hw_ptr;
         runtime->hw_ptr_jiffies = jiffies;
         if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE)
                 snd_pcm_gettime(runtime, (struct timespec *)&runtime->status->tstamp);
 
-        return snd_pcm_update_hw_ptr_post(substream, runtime);
+        return snd_pcm_update_state(substream, runtime);
 }
 
 /* CAUTION: call it with irq disabled */
 int snd_pcm_update_hw_ptr(struct snd_pcm_substream *substream)
 {
-        struct snd_pcm_runtime *runtime = substream->runtime;
-        snd_pcm_uframes_t pos;
-        snd_pcm_uframes_t old_hw_ptr, new_hw_ptr, hw_base;
-        snd_pcm_sframes_t delta;
-        unsigned long jdelta;
-
-        old_hw_ptr = runtime->status->hw_ptr;
-        pos = snd_pcm_update_hw_ptr_pos(substream, runtime);
-        if (pos == SNDRV_PCM_POS_XRUN) {
-                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;
-
-        delta = new_hw_ptr - old_hw_ptr;
-        jdelta = jiffies - runtime->hw_ptr_jiffies;
-        if (delta < 0) {
-                delta += runtime->buffer_size;
-                if (delta < 0) {
-                        hw_ptr_error(substream, 
-                                     "Unexpected hw_pointer value [2] "
-                                     "(stream=%i, pos=%ld, old_ptr=%ld, jdelta=%li)\n",
-                                     substream->stream, (long)pos,
-                                     (long)old_hw_ptr, jdelta);
-                        return 0;
-                }
-                hw_base += runtime->buffer_size;
-                if (hw_base >= runtime->boundary)
-                        hw_base = 0;
-                new_hw_ptr = hw_base + pos;
-        }
-        /* Do jiffies check only in xrun_debug mode */
-        if (!xrun_debug(substream, 4))
-                goto no_jiffies_check;
-        if (delta < runtime->delay)
-                goto no_jiffies_check;
-        delta -= runtime->delay;
-        if (((delta * HZ) / runtime->rate) > jdelta + HZ/100) {
-                hw_ptr_error(substream,
-                             "hw_ptr skipping! "
-                             "(pos=%ld, delta=%ld, period=%ld, jdelta=%lu/%lu)\n",
-                             (long)pos, (long)delta,
-                             (long)runtime->period_size, jdelta,
-                             ((delta * HZ) / runtime->rate));
-                return 0;
-        }
- no_jiffies_check:
-        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
-            runtime->silence_size > 0)
-                snd_pcm_playback_silence(substream, new_hw_ptr);
-
-        if (runtime->status->hw_ptr == new_hw_ptr)
-                return 0;
-
-        runtime->hw_ptr_base = hw_base;
-        runtime->status->hw_ptr = new_hw_ptr;
-        runtime->hw_ptr_jiffies = jiffies;
-        if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE)
-                snd_pcm_gettime(runtime, (struct timespec *)&runtime->status->tstamp);
-
-        return snd_pcm_update_hw_ptr_post(substream, runtime);
+        return snd_pcm_update_hw_ptr0(substream, 0);
 }
 
 /**
@@ -745,10 +768,13 @@ int snd_interval_ratnum(struct snd_interval *i,
                         unsigned int rats_count, struct snd_ratnum *rats,
                         unsigned int *nump, unsigned int *denp)
 {
-        unsigned int best_num, best_diff, best_den;
+        unsigned int best_num, best_den;
+        int best_diff;
         unsigned int k;
         struct snd_interval t;
         int err;
+        unsigned int result_num, result_den;
+        int result_diff;
 
         best_num = best_den = best_diff = 0;
         for (k = 0; k < rats_count; ++k) {
@@ -758,7 +784,7 @@ int snd_interval_ratnum(struct snd_interval *i,
                 int diff;
                 if (q == 0)
                         q = 1;
-                den = div_down(num, q);
+                den = div_up(num, q);
                 if (den < rats[k].den_min)
                         continue;
                 if (den > rats[k].den_max)
@@ -770,6 +796,8 @@ int snd_interval_ratnum(struct snd_interval *i,
                                 den -= r;
                 }
                 diff = num - q * den;
+                if (diff < 0)
+                        diff = -diff;
                 if (best_num == 0 ||
                     diff * best_den < best_diff * den) {
                         best_diff = diff;
@@ -784,6 +812,9 @@ int snd_interval_ratnum(struct snd_interval *i,
         t.min = div_down(best_num, best_den);
         t.openmin = !!(best_num % best_den);
         
+        result_num = best_num;
+        result_diff = best_diff;
+        result_den = best_den;
         best_num = best_den = best_diff = 0;
         for (k = 0; k < rats_count; ++k) {
                 unsigned int num = rats[k].num;
@@ -794,7 +825,7 @@ int snd_interval_ratnum(struct snd_interval *i,
                         i->empty = 1;
                         return -EINVAL;
                 }
-                den = div_up(num, q);
+                den = div_down(num, q);
                 if (den > rats[k].den_max)
                         continue;
                 if (den < rats[k].den_min)
@@ -806,6 +837,8 @@ int snd_interval_ratnum(struct snd_interval *i,
                                 den += rats[k].den_step - r;
                 }
                 diff = q * den - num;
+                if (diff < 0)
+                        diff = -diff;
                 if (best_num == 0 ||
                     diff * best_den < best_diff * den) {
                         best_diff = diff;
@@ -825,10 +858,14 @@ int snd_interval_ratnum(struct snd_interval *i,
                 return err;
 
         if (snd_interval_single(i)) {
+                if (best_diff * result_den < result_diff * best_den) {
+                        result_num = best_num;
+                        result_den = best_den;
+                }
                 if (nump)
-                        *nump = best_num;
+                        *nump = result_num;
                 if (denp)
-                        *denp = best_den;
+                        *denp = result_den;
         }
         return err;
 }
@@ -1643,7 +1680,7 @@ void snd_pcm_period_elapsed(struct snd_pcm_substream *substream)
 
         snd_pcm_stream_lock_irqsave(substream, flags);
         if (!snd_pcm_running(substream) ||
-            snd_pcm_update_hw_ptr_interrupt(substream) < 0)
+            snd_pcm_update_hw_ptr0(substream, 1) < 0)
                 goto _end;
 
         if (substream->timer_running)
@@ -1674,7 +1711,7 @@ static int wait_for_avail_min(struct snd_pcm_substream *substream,
         long tout;
 
         init_waitqueue_entry(&wait, current);
-        add_wait_queue(&runtime->sleep, &wait);
+        add_wait_queue(&runtime->tsleep, &wait);
         for (;;) {
                 if (signal_pending(current)) {
                         err = -ERESTARTSYS;
@@ -1717,7 +1754,7 @@ static int wait_for_avail_min(struct snd_pcm_substream *substream,
                         break;
         }
  _endloop:
-        remove_wait_queue(&runtime->sleep, &wait);
+        remove_wait_queue(&runtime->tsleep, &wait);
         *availp = avail;
         return err;
 }
@@ -1776,6 +1813,7 @@ static snd_pcm_sframes_t snd_pcm_lib_write1(struct snd_pcm_substream *substream,
                 goto _end_unlock;
         }
 
+        runtime->twake = 1;
         while (size > 0) {
                 snd_pcm_uframes_t frames, appl_ptr, appl_ofs;
                 snd_pcm_uframes_t avail;
@@ -1797,15 +1835,17 @@ static snd_pcm_sframes_t snd_pcm_lib_write1(struct snd_pcm_substream *substream,
                 if (frames > cont)
                         frames = cont;
                 if (snd_BUG_ON(!frames)) {
+                        runtime->twake = 0;
                         snd_pcm_stream_unlock_irq(substream);
                         return -EINVAL;
                 }
                 appl_ptr = runtime->control->appl_ptr;
                 appl_ofs = appl_ptr % runtime->buffer_size;
                 snd_pcm_stream_unlock_irq(substream);
-                if ((err = transfer(substream, appl_ofs, data, offset, frames)) < 0)
-                        goto _end;
+                err = transfer(substream, appl_ofs, data, offset, frames);
                 snd_pcm_stream_lock_irq(substream);
+                if (err < 0)
+                        goto _end_unlock;
                 switch (runtime->status->state) {
                 case SNDRV_PCM_STATE_XRUN:
                         err = -EPIPE;
@@ -1834,8 +1874,10 @@ static snd_pcm_sframes_t snd_pcm_lib_write1(struct snd_pcm_substream *substream,
                 }
         }
  _end_unlock:
+        runtime->twake = 0;
+        if (xfer > 0 && err >= 0)
+                snd_pcm_update_state(substream, runtime);
         snd_pcm_stream_unlock_irq(substream);
- _end:
         return xfer > 0 ? (snd_pcm_sframes_t)xfer : err;
 }
 
@@ -1993,6 +2035,7 @@ static snd_pcm_sframes_t snd_pcm_lib_read1(struct snd_pcm_substream *substream,
                 goto _end_unlock;
         }
 
+        runtime->twake = 1;
         while (size > 0) {
                 snd_pcm_uframes_t frames, appl_ptr, appl_ofs;
                 snd_pcm_uframes_t avail;
@@ -2021,15 +2064,17 @@ static snd_pcm_sframes_t snd_pcm_lib_read1(struct snd_pcm_substream *substream,
                 if (frames > cont)
                         frames = cont;
                 if (snd_BUG_ON(!frames)) {
+                        runtime->twake = 0;
                         snd_pcm_stream_unlock_irq(substream);
                         return -EINVAL;
                 }
                 appl_ptr = runtime->control->appl_ptr;
                 appl_ofs = appl_ptr % runtime->buffer_size;
                 snd_pcm_stream_unlock_irq(substream);
-                if ((err = transfer(substream, appl_ofs, data, offset, frames)) < 0)
-                        goto _end;
+                err = transfer(substream, appl_ofs, data, offset, frames);
                 snd_pcm_stream_lock_irq(substream);
+                if (err < 0)
+                        goto _end_unlock;
                 switch (runtime->status->state) {
                 case SNDRV_PCM_STATE_XRUN:
                         err = -EPIPE;
@@ -2052,8 +2097,10 @@ static snd_pcm_sframes_t snd_pcm_lib_read1(struct snd_pcm_substream *substream,
                 xfer += frames;
         }
  _end_unlock:
+        runtime->twake = 0;
+        if (xfer > 0 && err >= 0)
+                snd_pcm_update_state(substream, runtime);
         snd_pcm_stream_unlock_irq(substream);
- _end:
         return xfer > 0 ? (snd_pcm_sframes_t)xfer : err;
 }
 
diff --git a/sound/core/pcm_memory.c b/sound/core/pcm_memory.c
index caa7796bc2f5..917e4055ee30 100644
--- a/sound/core/pcm_memory.c
+++ b/sound/core/pcm_memory.c
@@ -22,7 +22,9 @@
 #include <asm/io.h>
 #include <linux/time.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <linux/moduleparam.h>
+#include <linux/vmalloc.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/info.h>
@@ -434,3 +436,57 @@ int snd_pcm_lib_free_pages(struct snd_pcm_substream *substream)
 }
 
 EXPORT_SYMBOL(snd_pcm_lib_free_pages);
+
+int _snd_pcm_lib_alloc_vmalloc_buffer(struct snd_pcm_substream *substream,
+                                      size_t size, gfp_t gfp_flags)
+{
+        struct snd_pcm_runtime *runtime;
+
+        if (PCM_RUNTIME_CHECK(substream))
+                return -EINVAL;
+        runtime = substream->runtime;
+        if (runtime->dma_area) {
+                if (runtime->dma_bytes >= size)
+                        return 0; /* already large enough */
+                vfree(runtime->dma_area);
+        }
+        runtime->dma_area = __vmalloc(size, gfp_flags, PAGE_KERNEL);
+        if (!runtime->dma_area)
+                return -ENOMEM;
+        runtime->dma_bytes = size;
+        return 1;
+}
+EXPORT_SYMBOL(_snd_pcm_lib_alloc_vmalloc_buffer);
+
+/**
+ * snd_pcm_lib_free_vmalloc_buffer - free vmalloc buffer
+ * @substream: the substream with a buffer allocated by
+ *      snd_pcm_lib_alloc_vmalloc_buffer()
+ */
+int snd_pcm_lib_free_vmalloc_buffer(struct snd_pcm_substream *substream)
+{
+        struct snd_pcm_runtime *runtime;
+
+        if (PCM_RUNTIME_CHECK(substream))
+                return -EINVAL;
+        runtime = substream->runtime;
+        vfree(runtime->dma_area);
+        runtime->dma_area = NULL;
+        return 0;
+}
+EXPORT_SYMBOL(snd_pcm_lib_free_vmalloc_buffer);
+
+/**
+ * snd_pcm_lib_get_vmalloc_page - map vmalloc buffer offset to page struct
+ * @substream: the substream with a buffer allocated by
+ *      snd_pcm_lib_alloc_vmalloc_buffer()
+ * @offset: offset in the buffer
+ *
+ * This function is to be used as the page callback in the PCM ops.
+ */
+struct page *snd_pcm_lib_get_vmalloc_page(struct snd_pcm_substream *substream,
+                                          unsigned long offset)
+{
+        return vmalloc_to_page(substream->runtime->dma_area + offset);
+}
+EXPORT_SYMBOL(snd_pcm_lib_get_vmalloc_page);
diff --git a/sound/core/pcm_native.c b/sound/core/pcm_native.c
index ab73edf2c89a..20b5982c996b 100644
--- a/sound/core/pcm_native.c
+++ b/sound/core/pcm_native.c
@@ -26,6 +26,8 @@
 #include <linux/time.h>
 #include <linux/pm_qos_params.h>
 #include <linux/uio.h>
+#include <linux/dma-mapping.h>
+#include <linux/math64.h>
 #include <sound/core.h>
 #include <sound/control.h>
 #include <sound/info.h>
@@ -34,6 +36,9 @@
 #include <sound/timer.h>
 #include <sound/minors.h>
 #include <asm/io.h>
+#if defined(CONFIG_MIPS) && defined(CONFIG_DMA_NONCOHERENT)
+#include <dma-coherence.h>
+#endif
 
 /*
  *  Compatibility
@@ -314,10 +319,10 @@ int snd_pcm_hw_refine(struct snd_pcm_substream *substream,
         if (!params->info)
                 params->info = hw->info & ~SNDRV_PCM_INFO_FIFO_IN_FRAMES;
         if (!params->fifo_size) {
-                if (snd_mask_min(&params->masks[SNDRV_PCM_HW_PARAM_FORMAT]) ==
-                    snd_mask_max(&params->masks[SNDRV_PCM_HW_PARAM_FORMAT]) &&
-                    snd_mask_min(&params->masks[SNDRV_PCM_HW_PARAM_CHANNELS]) ==
-                    snd_mask_max(&params->masks[SNDRV_PCM_HW_PARAM_CHANNELS])) {
+                m = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
+                i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
+                if (snd_mask_min(m) == snd_mask_max(m) &&
+                    snd_interval_min(i) == snd_interval_max(i)) {
                         changed = substream->ops->ioctl(substream,
                                         SNDRV_PCM_IOCTL1_FIFO_SIZE, params);
                         if (changed < 0)
@@ -365,6 +370,38 @@ static int period_to_usecs(struct snd_pcm_runtime *runtime)
         return usecs;
 }
 
+static int calc_boundary(struct snd_pcm_runtime *runtime)
+{
+        u_int64_t boundary;
+
+        boundary = (u_int64_t)runtime->buffer_size *
+                   (u_int64_t)runtime->period_size;
+#if BITS_PER_LONG < 64
+        /* try to find lowest common multiple for buffer and period */
+        if (boundary > LONG_MAX - runtime->buffer_size) {
+                u_int32_t remainder = -1;
+                u_int32_t divident = runtime->buffer_size;
+                u_int32_t divisor = runtime->period_size;
+                while (remainder) {
+                        remainder = divident % divisor;
+                        if (remainder) {
+                                divident = divisor;
+                                divisor = remainder;
+                        }
+                }
+                boundary = div_u64(boundary, divisor);
+                if (boundary > LONG_MAX - runtime->buffer_size)
+                        return -ERANGE;
+        }
+#endif
+        if (boundary == 0)
+                return -ERANGE;
+        runtime->boundary = boundary;
+        while (runtime->boundary * 2 <= LONG_MAX - runtime->buffer_size)
+                runtime->boundary *= 2;
+        return 0;
+}
+
 static int snd_pcm_hw_params(struct snd_pcm_substream *substream,
                              struct snd_pcm_hw_params *params)
 {
@@ -440,9 +477,9 @@ static int snd_pcm_hw_params(struct snd_pcm_substream *substream,
         runtime->stop_threshold = runtime->buffer_size;
         runtime->silence_threshold = 0;
         runtime->silence_size = 0;
-        runtime->boundary = runtime->buffer_size;
-        while (runtime->boundary * 2 <= LONG_MAX - runtime->buffer_size)
-                runtime->boundary *= 2;
+        err = calc_boundary(runtime);
+        if (err < 0)
+                goto _error;
 
         snd_pcm_timer_resolution_change(substream);
         runtime->status->state = SNDRV_PCM_STATE_SETUP;
@@ -515,6 +552,7 @@ static int snd_pcm_sw_params(struct snd_pcm_substream *substream,
                              struct snd_pcm_sw_params *params)
 {
         struct snd_pcm_runtime *runtime;
+        int err;
 
         if (PCM_RUNTIME_CHECK(substream))
                 return -ENXIO;
@@ -539,6 +577,7 @@ static int snd_pcm_sw_params(struct snd_pcm_substream *substream,
                 if (params->silence_threshold > runtime->buffer_size)
                         return -EINVAL;
         }
+        err = 0;
         snd_pcm_stream_lock_irq(substream);
         runtime->tstamp_mode = params->tstamp_mode;
         runtime->period_step = params->period_step;
@@ -552,10 +591,10 @@ static int snd_pcm_sw_params(struct snd_pcm_substream *substream,
                 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
                     runtime->silence_size > 0)
                         snd_pcm_playback_silence(substream, ULONG_MAX);
-                wake_up(&runtime->sleep);
+                err = snd_pcm_update_state(substream, runtime);
         }
         snd_pcm_stream_unlock_irq(substream);
-        return 0;
+        return err;
 }
 
 static int snd_pcm_sw_params_user(struct snd_pcm_substream *substream,
@@ -916,6 +955,7 @@ static void snd_pcm_post_stop(struct snd_pcm_substream *substream, int state)
                 runtime->status->state = state;
         }
         wake_up(&runtime->sleep);
+        wake_up(&runtime->tsleep);
 }
 
 static struct action_ops snd_pcm_action_stop = {
@@ -1001,6 +1041,7 @@ static void snd_pcm_post_pause(struct snd_pcm_substream *substream, int push)
                                          SNDRV_TIMER_EVENT_MPAUSE,
                                          &runtime->trigger_tstamp);
                 wake_up(&runtime->sleep);
+                wake_up(&runtime->tsleep);
         } else {
                 runtime->status->state = SNDRV_PCM_STATE_RUNNING;
                 if (substream->timer)
@@ -1058,6 +1099,7 @@ static void snd_pcm_post_suspend(struct snd_pcm_substream *substream, int state)
         runtime->status->suspended_state = runtime->status->state;
         runtime->status->state = SNDRV_PCM_STATE_SUSPENDED;
         wake_up(&runtime->sleep);
+        wake_up(&runtime->tsleep);
 }
 
 static struct action_ops snd_pcm_action_suspend = {
@@ -1917,13 +1959,13 @@ int snd_pcm_hw_constraints_complete(struct snd_pcm_substream *substream)
 
         err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_RATE,
                                            hw->rate_min, hw->rate_max);
-         if (err < 0)
-                 return err;
+        if (err < 0)
+                return err;
 
         err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_BYTES,
                                            hw->period_bytes_min, hw->period_bytes_max);
-         if (err < 0)
-                 return err;
+        if (err < 0)
+                return err;
 
         err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIODS,
                                            hw->periods_min, hw->periods_max);
@@ -3061,6 +3103,27 @@ static int snd_pcm_mmap_control(struct snd_pcm_substream *substream, struct file
 }
 #endif /* coherent mmap */
 
+static inline struct page *
+snd_pcm_default_page_ops(struct snd_pcm_substream *substream, unsigned long ofs)
+{
+        void *vaddr = substream->runtime->dma_area + ofs;
+#if defined(CONFIG_MIPS) && defined(CONFIG_DMA_NONCOHERENT)
+        if (substream->dma_buffer.dev.type == SNDRV_DMA_TYPE_DEV)
+                return virt_to_page(CAC_ADDR(vaddr));
+#endif
+#if defined(CONFIG_PPC32) && defined(CONFIG_NOT_COHERENT_CACHE)
+        if (substream->dma_buffer.dev.type == SNDRV_DMA_TYPE_DEV) {
+                dma_addr_t addr = substream->runtime->dma_addr + ofs;
+                addr -= get_dma_offset(substream->dma_buffer.dev.dev);
+                /* assume dma_handle set via pfn_to_phys() in
+                 * mm/dma-noncoherent.c
+                 */
+                return pfn_to_page(addr >> PAGE_SHIFT);
+        }
+#endif
+        return virt_to_page(vaddr);
+}
+
 /*
  * fault callback for mmapping a RAM page
  */
@@ -3071,7 +3134,6 @@ static int snd_pcm_mmap_data_fault(struct vm_area_struct *area,
         struct snd_pcm_runtime *runtime;
         unsigned long offset;
         struct page * page;
-        void *vaddr;
         size_t dma_bytes;
         
         if (substream == NULL)
@@ -3081,36 +3143,57 @@ static int snd_pcm_mmap_data_fault(struct vm_area_struct *area,
         dma_bytes = PAGE_ALIGN(runtime->dma_bytes);
         if (offset > dma_bytes - PAGE_SIZE)
                 return VM_FAULT_SIGBUS;
-        if (substream->ops->page) {
+        if (substream->ops->page)
                 page = substream->ops->page(substream, offset);
-                if (!page)
-                        return VM_FAULT_SIGBUS;
-        } else {
-                vaddr = runtime->dma_area + offset;
-                page = virt_to_page(vaddr);
-        }
+        else
+                page = snd_pcm_default_page_ops(substream, offset);
+        if (!page)
+                return VM_FAULT_SIGBUS;
         get_page(page);
         vmf->page = page;
         return 0;
 }
 
-static const struct vm_operations_struct snd_pcm_vm_ops_data =
-{
+static const struct vm_operations_struct snd_pcm_vm_ops_data = {
+        .open =         snd_pcm_mmap_data_open,
+        .close =        snd_pcm_mmap_data_close,
+};
+
+static const struct vm_operations_struct snd_pcm_vm_ops_data_fault = {
         .open =         snd_pcm_mmap_data_open,
         .close =        snd_pcm_mmap_data_close,
         .fault =        snd_pcm_mmap_data_fault,
 };
 
+#ifndef ARCH_HAS_DMA_MMAP_COHERENT
+/* This should be defined / handled globally! */
+#ifdef CONFIG_ARM
+#define ARCH_HAS_DMA_MMAP_COHERENT
+#endif
+#endif
+
 /*
  * mmap the DMA buffer on RAM
  */
 static int snd_pcm_default_mmap(struct snd_pcm_substream *substream,
                                 struct vm_area_struct *area)
 {
-        area->vm_ops = &snd_pcm_vm_ops_data;
-        area->vm_private_data = substream;
         area->vm_flags |= VM_RESERVED;
-        atomic_inc(&substream->mmap_count);
+#ifdef ARCH_HAS_DMA_MMAP_COHERENT
+        if (!substream->ops->page &&
+            substream->dma_buffer.dev.type == SNDRV_DMA_TYPE_DEV)
+                return dma_mmap_coherent(substream->dma_buffer.dev.dev,
+                                         area,
+                                         substream->runtime->dma_area,
+                                         substream->runtime->dma_addr,
+                                         area->vm_end - area->vm_start);
+#elif defined(CONFIG_MIPS) && defined(CONFIG_DMA_NONCOHERENT)
+        if (substream->dma_buffer.dev.type == SNDRV_DMA_TYPE_DEV &&
+            !plat_device_is_coherent(substream->dma_buffer.dev.dev))
+                area->vm_page_prot = pgprot_noncached(area->vm_page_prot);
+#endif /* ARCH_HAS_DMA_MMAP_COHERENT */
+        /* mmap with fault handler */
+        area->vm_ops = &snd_pcm_vm_ops_data_fault;
         return 0;
 }
 
@@ -3118,23 +3201,13 @@ static int snd_pcm_default_mmap(struct snd_pcm_substream *substream,
  * mmap the DMA buffer on I/O memory area
  */
 #if SNDRV_PCM_INFO_MMAP_IOMEM
-static const struct vm_operations_struct snd_pcm_vm_ops_data_mmio =
-{
-        .open =         snd_pcm_mmap_data_open,
-        .close =        snd_pcm_mmap_data_close,
-};
-
 int snd_pcm_lib_mmap_iomem(struct snd_pcm_substream *substream,
                            struct vm_area_struct *area)
 {
         long size;
         unsigned long offset;
 
-#ifdef pgprot_noncached
         area->vm_page_prot = pgprot_noncached(area->vm_page_prot);
-#endif
-        area->vm_ops = &snd_pcm_vm_ops_data_mmio;
-        area->vm_private_data = substream;
         area->vm_flags |= VM_IO;
         size = area->vm_end - area->vm_start;
         offset = area->vm_pgoff << PAGE_SHIFT;
@@ -3142,13 +3215,21 @@ int snd_pcm_lib_mmap_iomem(struct snd_pcm_substream *substream,
                                 (substream->runtime->dma_addr + offset) >> PAGE_SHIFT,
                                 size, area->vm_page_prot))
                 return -EAGAIN;
-        atomic_inc(&substream->mmap_count);
         return 0;
 }
 
 EXPORT_SYMBOL(snd_pcm_lib_mmap_iomem);
 #endif /* SNDRV_PCM_INFO_MMAP */
 
+/* mmap callback with pgprot_noncached */
+int snd_pcm_lib_mmap_noncached(struct snd_pcm_substream *substream,
+                               struct vm_area_struct *area)
+{
+        area->vm_page_prot = pgprot_noncached(area->vm_page_prot);
+        return snd_pcm_default_mmap(substream, area);
+}
+EXPORT_SYMBOL(snd_pcm_lib_mmap_noncached);
+
 /*
  * mmap DMA buffer
  */
@@ -3159,6 +3240,7 @@ int snd_pcm_mmap_data(struct snd_pcm_substream *substream, struct file *file,
         long size;
         unsigned long offset;
         size_t dma_bytes;
+        int err;
 
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
                 if (!(area->vm_flags & (VM_WRITE|VM_READ)))
@@ -3183,10 +3265,15 @@ int snd_pcm_mmap_data(struct snd_pcm_substream *substream, struct file *file,
         if (offset > dma_bytes - size)
                 return -EINVAL;
 
+        area->vm_ops = &snd_pcm_vm_ops_data;
+        area->vm_private_data = substream;
         if (substream->ops->mmap)
-                return substream->ops->mmap(substream, area);
+                err = substream->ops->mmap(substream, area);
         else
-                return snd_pcm_default_mmap(substream, area);
+                err = snd_pcm_default_mmap(substream, area);
+        if (!err)
+                atomic_inc(&substream->mmap_count);
+        return err;
 }
 
 EXPORT_SYMBOL(snd_pcm_mmap_data);
diff --git a/sound/core/pcm_timer.c b/sound/core/pcm_timer.c
index ca8068b63d6c..b01d9481d632 100644
--- a/sound/core/pcm_timer.c
+++ b/sound/core/pcm_timer.c
@@ -20,6 +20,7 @@
  */
 
 #include <linux/time.h>
+#include <linux/gcd.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/timer.h>
@@ -28,22 +29,6 @@
  *  Timer functions
  */
 
-/* Greatest common divisor */
-static unsigned long gcd(unsigned long a, unsigned long b)
-{
-        unsigned long r;
-        if (a < b) {
-                r = a;
-                a = b;
-                b = r;
-        }
-        while ((r = a % b) != 0) {
-                a = b;
-                b = r;
-        }
-        return b;
-}
-
 void snd_pcm_timer_resolution_change(struct snd_pcm_substream *substream)
 {
         unsigned long rate, mult, fsize, l, post;
diff --git a/sound/core/rawmidi.c b/sound/core/rawmidi.c
index 70d6f25ba526..0f5a194695d9 100644
--- a/sound/core/rawmidi.c
+++ b/sound/core/rawmidi.c
@@ -242,8 +242,6 @@ static int assign_substream(struct snd_rawmidi *rmidi, int subdevice,
                 return -ENXIO;
         if (subdevice >= 0 && subdevice >= s->substream_count)
                 return -ENODEV;
-        if (s->substream_opened >= s->substream_count)
-                return -EAGAIN;
 
         list_for_each_entry(substream, &s->substreams, list) {
                 if (substream->opened) {
@@ -280,9 +278,10 @@ static int open_substream(struct snd_rawmidi *rmidi,
                 substream->active_sensing = 0;
                 if (mode & SNDRV_RAWMIDI_LFLG_APPEND)
                         substream->append = 1;
+                substream->pid = get_pid(task_pid(current));
+                rmidi->streams[substream->stream].substream_opened++;
         }
         substream->use_count++;
-        rmidi->streams[substream->stream].substream_opened++;
         return 0;
 }
 
@@ -413,7 +412,7 @@ static int snd_rawmidi_open(struct inode *inode, struct file *file)
                 subdevice = -1;
                 read_lock(&card->ctl_files_rwlock);
                 list_for_each_entry(kctl, &card->ctl_files, list) {
-                        if (kctl->pid == current->pid) {
+                        if (kctl->pid == task_pid(current)) {
                                 subdevice = kctl->prefer_rawmidi_subdevice;
                                 if (subdevice != -1)
                                         break;
@@ -466,7 +465,6 @@ static void close_substream(struct snd_rawmidi *rmidi,
                             struct snd_rawmidi_substream *substream,
                             int cleanup)
 {
-        rmidi->streams[substream->stream].substream_opened--;
         if (--substream->use_count)
                 return;
 
@@ -491,6 +489,9 @@ static void close_substream(struct snd_rawmidi *rmidi,
         snd_rawmidi_runtime_free(substream);
         substream->opened = 0;
         substream->append = 0;
+        put_pid(substream->pid);
+        substream->pid = NULL;
+        rmidi->streams[substream->stream].substream_opened--;
 }
 
 static void rawmidi_release_priv(struct snd_rawmidi_file *rfile)
@@ -1256,7 +1257,7 @@ static ssize_t snd_rawmidi_write(struct file *file, const char __user *buf,
                         break;
                 count -= count1;
         }
-        if (file->f_flags & O_SYNC) {
+        if (file->f_flags & O_DSYNC) {
                 spin_lock_irq(&runtime->lock);
                 while (runtime->avail != runtime->buffer_size) {
                         wait_queue_t wait;
@@ -1338,6 +1339,9 @@ static void snd_rawmidi_proc_info_read(struct snd_info_entry *entry,
                                     substream->number,
                                     (unsigned long) substream->bytes);
                         if (substream->opened) {
+                                snd_iprintf(buffer,
+                                    "  Owner PID    : %d\n",
+                                    pid_vnr(substream->pid));
                                 runtime = substream->runtime;
                                 snd_iprintf(buffer,
                                     "  Mode         : %s\n"
@@ -1359,6 +1363,9 @@ static void snd_rawmidi_proc_info_read(struct snd_info_entry *entry,
                                     substream->number,
                                     (unsigned long) substream->bytes);
                         if (substream->opened) {
+                                snd_iprintf(buffer,
+                                            "  Owner PID    : %d\n",
+                                            pid_vnr(substream->pid));
                                 runtime = substream->runtime;
                                 snd_iprintf(buffer,
                                             "  Buffer size  : %lu\n"
diff --git a/sound/core/seq/oss/seq_oss_init.c b/sound/core/seq/oss/seq_oss_init.c
index d0d721c22eac..685712276ac9 100644
--- a/sound/core/seq/oss/seq_oss_init.c
+++ b/sound/core/seq/oss/seq_oss_init.c
@@ -29,6 +29,7 @@
 #include "seq_oss_event.h"
 #include <linux/init.h>
 #include <linux/moduleparam.h>
+#include <linux/slab.h>
 
 /*
  * common variables
diff --git a/sound/core/seq/oss/seq_oss_midi.c b/sound/core/seq/oss/seq_oss_midi.c
index 9dfb2f77be60..677dc84590c7 100644
--- a/sound/core/seq/oss/seq_oss_midi.c
+++ b/sound/core/seq/oss/seq_oss_midi.c
@@ -28,6 +28,7 @@
 #include <sound/seq_midi_event.h>
 #include "../seq_lock.h"
 #include <linux/init.h>
+#include <linux/slab.h>
 
 
 /*
diff --git a/sound/core/seq/oss/seq_oss_readq.c b/sound/core/seq/oss/seq_oss_readq.c
index f5de79f29f1e..73661c4ab82a 100644
--- a/sound/core/seq/oss/seq_oss_readq.c
+++ b/sound/core/seq/oss/seq_oss_readq.c
@@ -25,6 +25,7 @@
 #include <sound/seq_oss_legacy.h>
 #include "../seq_lock.h"
 #include <linux/wait.h>
+#include <linux/slab.h>
 
 /*
  * constants
diff --git a/sound/core/seq/oss/seq_oss_synth.c b/sound/core/seq/oss/seq_oss_synth.c
index 945a27c34a9d..ee44ab9593c0 100644
--- a/sound/core/seq/oss/seq_oss_synth.c
+++ b/sound/core/seq/oss/seq_oss_synth.c
@@ -24,6 +24,7 @@
 #include "seq_oss_midi.h"
 #include "../seq_lock.h"
 #include <linux/init.h>
+#include <linux/slab.h>
 
 /*
  * constants
diff --git a/sound/core/seq/oss/seq_oss_timer.c b/sound/core/seq/oss/seq_oss_timer.c
index c440fdacec93..ab59cbfbcaf2 100644
--- a/sound/core/seq/oss/seq_oss_timer.c
+++ b/sound/core/seq/oss/seq_oss_timer.c
@@ -23,6 +23,7 @@
 #include "seq_oss_timer.h"
 #include "seq_oss_event.h"
 #include <sound/seq_oss_legacy.h>
+#include <linux/slab.h>
 
 /*
  */
diff --git a/sound/core/seq/oss/seq_oss_writeq.c b/sound/core/seq/oss/seq_oss_writeq.c
index 217424858191..d50338bbc21f 100644
--- a/sound/core/seq/oss/seq_oss_writeq.c
+++ b/sound/core/seq/oss/seq_oss_writeq.c
@@ -27,6 +27,7 @@
 #include "../seq_lock.h"
 #include "../seq_clientmgr.h"
 #include <linux/wait.h>
+#include <linux/slab.h>
 
 
 /*
diff --git a/sound/core/seq/seq_clientmgr.c b/sound/core/seq/seq_clientmgr.c
index 8ca2be339f3b..48eca9ff9ee7 100644
--- a/sound/core/seq/seq_clientmgr.c
+++ b/sound/core/seq/seq_clientmgr.c
@@ -2190,7 +2190,7 @@ static int snd_seq_do_ioctl(struct snd_seq_client *client, unsigned int cmd,
                 if (p->cmd == cmd)
                         return p->func(client, arg);
         }
-        snd_printd("seq unknown ioctl() 0x%x (type='%c', number=0x%2x)\n",
+        snd_printd("seq unknown ioctl() 0x%x (type='%c', number=0x%02x)\n",
                    cmd, _IOC_TYPE(cmd), _IOC_NR(cmd));
         return -ENOTTY;
 }
diff --git a/sound/core/seq/seq_compat.c b/sound/core/seq/seq_compat.c
index c956fe462569..81f7c109dc46 100644
--- a/sound/core/seq/seq_compat.c
+++ b/sound/core/seq/seq_compat.c
@@ -21,6 +21,7 @@
 /* This file included from seq.c */
 
 #include <linux/compat.h>
+#include <linux/slab.h>
 
 struct snd_seq_port_info32 {
         struct snd_seq_addr addr;       /* client/port numbers */
diff --git a/sound/core/seq/seq_system.c b/sound/core/seq/seq_system.c
index 77884e62b648..c38b90cf3cb0 100644
--- a/sound/core/seq/seq_system.c
+++ b/sound/core/seq/seq_system.c
@@ -20,6 +20,7 @@
  */
 
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include "seq_system.h"
 #include "seq_timer.h"
diff --git a/sound/core/seq/seq_timer.c b/sound/core/seq/seq_timer.c
index f745c317d6af..160b1bd0cd62 100644
--- a/sound/core/seq/seq_timer.c
+++ b/sound/core/seq/seq_timer.c
@@ -33,22 +33,21 @@
 
 #define SKEW_BASE       0x10000 /* 16bit shift */
 
-static void snd_seq_timer_set_tick_resolution(struct snd_seq_timer_tick *tick,
-                                              int tempo, int ppq)
+static void snd_seq_timer_set_tick_resolution(struct snd_seq_timer *tmr)
 {
-        if (tempo < 1000000)
-                tick->resolution = (tempo * 1000) / ppq;
+        if (tmr->tempo < 1000000)
+                tmr->tick.resolution = (tmr->tempo * 1000) / tmr->ppq;
         else {
                 /* might overflow.. */
                 unsigned int s;
-                s = tempo % ppq;
-                s = (s * 1000) / ppq;
-                tick->resolution = (tempo / ppq) * 1000;
-                tick->resolution += s;
+                s = tmr->tempo % tmr->ppq;
+                s = (s * 1000) / tmr->ppq;
+                tmr->tick.resolution = (tmr->tempo / tmr->ppq) * 1000;
+                tmr->tick.resolution += s;
         }
-        if (tick->resolution <= 0)
-                tick->resolution = 1;
-        snd_seq_timer_update_tick(tick, 0);
+        if (tmr->tick.resolution <= 0)
+                tmr->tick.resolution = 1;
+        snd_seq_timer_update_tick(&tmr->tick, 0);
 }
 
 /* create new timer (constructor) */
@@ -96,7 +95,7 @@ void snd_seq_timer_defaults(struct snd_seq_timer * tmr)
         /* setup defaults */
         tmr->ppq = 96;          /* 96 PPQ */
         tmr->tempo = 500000;    /* 120 BPM */
-        snd_seq_timer_set_tick_resolution(&tmr->tick, tmr->tempo, tmr->ppq);
+        snd_seq_timer_set_tick_resolution(tmr);
         tmr->running = 0;
 
         tmr->type = SNDRV_SEQ_TIMER_ALSA;
@@ -180,7 +179,7 @@ int snd_seq_timer_set_tempo(struct snd_seq_timer * tmr, int tempo)
         spin_lock_irqsave(&tmr->lock, flags);
         if ((unsigned int)tempo != tmr->tempo) {
                 tmr->tempo = tempo;
-                snd_seq_timer_set_tick_resolution(&tmr->tick, tmr->tempo, tmr->ppq);
+                snd_seq_timer_set_tick_resolution(tmr);
         }
         spin_unlock_irqrestore(&tmr->lock, flags);
         return 0;
@@ -205,7 +204,7 @@ int snd_seq_timer_set_ppq(struct snd_seq_timer * tmr, int ppq)
         }
 
         tmr->ppq = ppq;
-        snd_seq_timer_set_tick_resolution(&tmr->tick, tmr->tempo, tmr->ppq);
+        snd_seq_timer_set_tick_resolution(tmr);
         spin_unlock_irqrestore(&tmr->lock, flags);
         return 0;
 }
diff --git a/sound/core/sound.c b/sound/core/sound.c
index 7872a02f6ca9..563d1967a0ad 100644
--- a/sound/core/sound.c
+++ b/sound/core/sound.c
@@ -468,5 +468,5 @@ static void __exit alsa_sound_exit(void)
         unregister_chrdev(major, "alsa");
 }
 
-module_init(alsa_sound_init)
-module_exit(alsa_sound_exit)
+subsys_initcall(alsa_sound_init);
+module_exit(alsa_sound_exit);
diff --git a/sound/core/sound_oss.c b/sound/core/sound_oss.c
index 7fe12264ff80..0c164e5e4322 100644
--- a/sound/core/sound_oss.c
+++ b/sound/core/sound_oss.c
@@ -93,7 +93,7 @@ static int snd_oss_kernel_minor(int type, struct snd_card *card, int dev)
         default:
                 return -EINVAL;
         }
-        if (snd_BUG_ON(minor < 0 || minor >= SNDRV_OSS_MINORS))
+        if (minor < 0 || minor >= SNDRV_OSS_MINORS)
                 return -EINVAL;
         return minor;
 }
diff --git a/sound/core/timer.c b/sound/core/timer.c
index 8f8b17ac074d..5040c7b862fe 100644
--- a/sound/core/timer.c
+++ b/sound/core/timer.c
@@ -393,7 +393,7 @@ static void snd_timer_notify1(struct snd_timer_instance *ti, int event)
             event == SNDRV_TIMER_EVENT_CONTINUE)
                 resolution = snd_timer_resolution(ti);
         if (ti->ccallback)
-                ti->ccallback(ti, SNDRV_TIMER_EVENT_START, &tstamp, resolution);
+                ti->ccallback(ti, event, &tstamp, resolution);
         if (ti->flags & SNDRV_TIMER_IFLG_SLAVE)
                 return;
         timer = ti->timer;
@@ -1160,6 +1160,7 @@ static void snd_timer_user_ccallback(struct snd_timer_instance *timeri,
 {
         struct snd_timer_user *tu = timeri->callback_data;
         struct snd_timer_tread r1;
+        unsigned long flags;
 
         if (event >= SNDRV_TIMER_EVENT_START &&
             event <= SNDRV_TIMER_EVENT_PAUSE)
@@ -1169,9 +1170,9 @@ static void snd_timer_user_ccallback(struct snd_timer_instance *timeri,
         r1.event = event;
         r1.tstamp = *tstamp;
         r1.val = resolution;
-        spin_lock(&tu->qlock);
+        spin_lock_irqsave(&tu->qlock, flags);
         snd_timer_user_append_to_tqueue(tu, &r1);
-        spin_unlock(&tu->qlock);
+        spin_unlock_irqrestore(&tu->qlock, flags);
         kill_fasync(&tu->fasync, SIGIO, POLL_IN);
         wake_up(&tu->qchange_sleep);
 }
diff --git a/sound/drivers/dummy.c b/sound/drivers/dummy.c
index 252e04ce602f..7f41990ed68b 100644
--- a/sound/drivers/dummy.c
+++ b/sound/drivers/dummy.c
@@ -45,109 +45,23 @@ MODULE_SUPPORTED_DEVICE("{{ALSA,Dummy soundcard}}");
 #define MAX_PCM_SUBSTREAMS      128
 #define MAX_MIDI_DEVICES        2
 
-#if 0 /* emu10k1 emulation */
-#define MAX_BUFFER_SIZE         (128 * 1024)
-static int emu10k1_playback_constraints(struct snd_pcm_runtime *runtime)
-{
-        int err;
-        err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
-        if (err < 0)
-                return err;
-        err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 256, UINT_MAX);
-        if (err < 0)
-                return err;
-        return 0;
-}
-#define add_playback_constraints emu10k1_playback_constraints
-#endif
-
-#if 0 /* RME9652 emulation */
-#define MAX_BUFFER_SIZE         (26 * 64 * 1024)
-#define USE_FORMATS             SNDRV_PCM_FMTBIT_S32_LE
-#define USE_CHANNELS_MIN        26
-#define USE_CHANNELS_MAX        26
-#define USE_PERIODS_MIN         2
-#define USE_PERIODS_MAX         2
-#endif
-
-#if 0 /* ICE1712 emulation */
-#define MAX_BUFFER_SIZE         (256 * 1024)
-#define USE_FORMATS             SNDRV_PCM_FMTBIT_S32_LE
-#define USE_CHANNELS_MIN        10
-#define USE_CHANNELS_MAX        10
-#define USE_PERIODS_MIN         1
-#define USE_PERIODS_MAX         1024
-#endif
-
-#if 0 /* UDA1341 emulation */
-#define MAX_BUFFER_SIZE         (16380)
-#define USE_FORMATS             SNDRV_PCM_FMTBIT_S16_LE
-#define USE_CHANNELS_MIN        2
-#define USE_CHANNELS_MAX        2
-#define USE_PERIODS_MIN         2
-#define USE_PERIODS_MAX         255
-#endif
-
-#if 0 /* simple AC97 bridge (intel8x0) with 48kHz AC97 only codec */
-#define USE_FORMATS             SNDRV_PCM_FMTBIT_S16_LE
-#define USE_CHANNELS_MIN        2
-#define USE_CHANNELS_MAX        2
-#define USE_RATE                SNDRV_PCM_RATE_48000
-#define USE_RATE_MIN            48000
-#define USE_RATE_MAX            48000
-#endif
-
-#if 0 /* CA0106 */
-#define USE_FORMATS             SNDRV_PCM_FMTBIT_S16_LE
-#define USE_CHANNELS_MIN        2
-#define USE_CHANNELS_MAX        2
-#define USE_RATE                (SNDRV_PCM_RATE_48000|SNDRV_PCM_RATE_96000|SNDRV_PCM_RATE_192000) 
-#define USE_RATE_MIN            48000 
-#define USE_RATE_MAX            192000
-#define MAX_BUFFER_SIZE         ((65536-64)*8)
-#define MAX_PERIOD_SIZE         (65536-64)
-#define USE_PERIODS_MIN         2
-#define USE_PERIODS_MAX         8
-#endif
-
-
 /* defaults */
-#ifndef MAX_BUFFER_SIZE
 #define MAX_BUFFER_SIZE         (64*1024)
-#endif
-#ifndef MAX_PERIOD_SIZE
+#define MIN_PERIOD_SIZE         64
 #define MAX_PERIOD_SIZE         MAX_BUFFER_SIZE
-#endif
-#ifndef USE_FORMATS
 #define USE_FORMATS             (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE)
-#endif
-#ifndef USE_RATE
 #define USE_RATE                SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000
 #define USE_RATE_MIN            5500
 #define USE_RATE_MAX            48000
-#endif
-#ifndef USE_CHANNELS_MIN
 #define USE_CHANNELS_MIN        1
-#endif
-#ifndef USE_CHANNELS_MAX
 #define USE_CHANNELS_MAX        2
-#endif
-#ifndef USE_PERIODS_MIN
 #define USE_PERIODS_MIN         1
-#endif
-#ifndef USE_PERIODS_MAX
 #define USE_PERIODS_MAX         1024
-#endif
-#ifndef add_playback_constraints
-#define add_playback_constraints(x) 0
-#endif
-#ifndef add_capture_constraints
-#define add_capture_constraints(x) 0
-#endif
 
 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
 static int enable[SNDRV_CARDS] = {1, [1 ... (SNDRV_CARDS - 1)] = 0};
+static char *model[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = NULL};
 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};
@@ -162,6 +76,8 @@ module_param_array(id, charp, NULL, 0444);
 MODULE_PARM_DESC(id, "ID string for dummy soundcard.");
 module_param_array(enable, bool, NULL, 0444);
 MODULE_PARM_DESC(enable, "Enable this dummy soundcard.");
+module_param_array(model, charp, NULL, 0444);
+MODULE_PARM_DESC(model, "Soundcard model.");
 module_param_array(pcm_devs, int, NULL, 0444);
 MODULE_PARM_DESC(pcm_devs, "PCM devices # (0-4) for dummy driver.");
 module_param_array(pcm_substreams, int, NULL, 0444);
@@ -193,9 +109,28 @@ struct dummy_timer_ops {
         snd_pcm_uframes_t (*pointer)(struct snd_pcm_substream *);
 };
 
+struct dummy_model {
+        const char *name;
+        int (*playback_constraints)(struct snd_pcm_runtime *runtime);
+        int (*capture_constraints)(struct snd_pcm_runtime *runtime);
+        u64 formats;
+        size_t buffer_bytes_max;
+        size_t period_bytes_min;
+        size_t period_bytes_max;
+        unsigned int periods_min;
+        unsigned int periods_max;
+        unsigned int rates;
+        unsigned int rate_min;
+        unsigned int rate_max;
+        unsigned int channels_min;
+        unsigned int channels_max;
+};
+
 struct snd_dummy {
         struct snd_card *card;
+        struct dummy_model *model;
         struct snd_pcm *pcm;
+        struct snd_pcm_hardware pcm_hw;
         spinlock_t mixer_lock;
         int mixer_volume[MIXER_ADDR_LAST+1][2];
         int capture_source[MIXER_ADDR_LAST+1][2];
@@ -203,6 +138,92 @@ struct snd_dummy {
 };
 
 /*
+ * card models
+ */
+
+static int emu10k1_playback_constraints(struct snd_pcm_runtime *runtime)
+{
+        int err;
+        err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
+        if (err < 0)
+                return err;
+        err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 256, UINT_MAX);
+        if (err < 0)
+                return err;
+        return 0;
+}
+
+struct dummy_model model_emu10k1 = {
+        .name = "emu10k1",
+        .playback_constraints = emu10k1_playback_constraints,
+        .buffer_bytes_max = 128 * 1024,
+};
+
+struct dummy_model model_rme9652 = {
+        .name = "rme9652",
+        .buffer_bytes_max = 26 * 64 * 1024,
+        .formats = SNDRV_PCM_FMTBIT_S32_LE,
+        .channels_min = 26,
+        .channels_max = 26,
+        .periods_min = 2,
+        .periods_max = 2,
+};
+
+struct dummy_model model_ice1712 = {
+        .name = "ice1712",
+        .buffer_bytes_max = 256 * 1024,
+        .formats = SNDRV_PCM_FMTBIT_S32_LE,
+        .channels_min = 10,
+        .channels_max = 10,
+        .periods_min = 1,
+        .periods_max = 1024,
+};
+
+struct dummy_model model_uda1341 = {
+        .name = "uda1341",
+        .buffer_bytes_max = 16380,
+        .formats = SNDRV_PCM_FMTBIT_S16_LE,
+        .channels_min = 2,
+        .channels_max = 2,
+        .periods_min = 2,
+        .periods_max = 255,
+};
+
+struct dummy_model model_ac97 = {
+        .name = "ac97",
+        .formats = SNDRV_PCM_FMTBIT_S16_LE,
+        .channels_min = 2,
+        .channels_max = 2,
+        .rates = SNDRV_PCM_RATE_48000,
+        .rate_min = 48000,
+        .rate_max = 48000,
+};
+
+struct dummy_model model_ca0106 = {
+        .name = "ca0106",
+        .formats = SNDRV_PCM_FMTBIT_S16_LE,
+        .buffer_bytes_max = ((65536-64)*8),
+        .period_bytes_max = (65536-64),
+        .periods_min = 2,
+        .periods_max = 8,
+        .channels_min = 2,
+        .channels_max = 2,
+        .rates = SNDRV_PCM_RATE_48000|SNDRV_PCM_RATE_96000|SNDRV_PCM_RATE_192000,
+        .rate_min = 48000,
+        .rate_max = 192000,
+};
+
+struct dummy_model *dummy_models[] = {
+        &model_emu10k1,
+        &model_rme9652,
+        &model_ice1712,
+        &model_uda1341,
+        &model_ac97,
+        &model_ca0106,
+        NULL
+};
+
+/*
  * system timer interface
  */
 
@@ -509,7 +530,7 @@ static struct snd_pcm_hardware dummy_pcm_hardware = {
         .channels_min =         USE_CHANNELS_MIN,
         .channels_max =         USE_CHANNELS_MAX,
         .buffer_bytes_max =     MAX_BUFFER_SIZE,
-        .period_bytes_min =     64,
+        .period_bytes_min =     MIN_PERIOD_SIZE,
         .period_bytes_max =     MAX_PERIOD_SIZE,
         .periods_min =          USE_PERIODS_MIN,
         .periods_max =          USE_PERIODS_MAX,
@@ -538,6 +559,7 @@ static int dummy_pcm_hw_free(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 dummy_model *model = dummy->model;
         struct snd_pcm_runtime *runtime = substream->runtime;
         int err;
 
@@ -551,7 +573,7 @@ static int dummy_pcm_open(struct snd_pcm_substream *substream)
         if (err < 0)
                 return err;
 
-        runtime->hw = dummy_pcm_hardware;
+        runtime->hw = dummy->pcm_hw;
         if (substream->pcm->device & 1) {
                 runtime->hw.info &= ~SNDRV_PCM_INFO_INTERLEAVED;
                 runtime->hw.info |= SNDRV_PCM_INFO_NONINTERLEAVED;
@@ -560,10 +582,16 @@ static int dummy_pcm_open(struct snd_pcm_substream *substream)
                 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 (model == NULL)
+                return 0;
+
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+                if (model->playback_constraints)
+                        err = model->playback_constraints(substream->runtime);
+        } else {
+                if (model->capture_constraints)
+                        err = model->capture_constraints(substream->runtime);
+        }
         if (err < 0) {
                 dummy->timer_ops->free(substream);
                 return err;
@@ -823,17 +851,19 @@ static int __devinit snd_card_dummy_new_mixer(struct snd_dummy *dummy)
 /*
  * proc interface
  */
-static void print_formats(struct snd_info_buffer *buffer)
+static void print_formats(struct snd_dummy *dummy,
+                          struct snd_info_buffer *buffer)
 {
         int i;
 
         for (i = 0; i < SNDRV_PCM_FORMAT_LAST; i++) {
-                if (dummy_pcm_hardware.formats & (1ULL << i))
+                if (dummy->pcm_hw.formats & (1ULL << i))
                         snd_iprintf(buffer, " %s", snd_pcm_format_name(i));
         }
 }
 
-static void print_rates(struct snd_info_buffer *buffer)
+static void print_rates(struct snd_dummy *dummy,
+                        struct snd_info_buffer *buffer)
 {
         static int rates[] = {
                 5512, 8000, 11025, 16000, 22050, 32000, 44100, 48000,
@@ -841,19 +871,19 @@ static void print_rates(struct snd_info_buffer *buffer)
         };
         int i;
 
-        if (dummy_pcm_hardware.rates & SNDRV_PCM_RATE_CONTINUOUS)
+        if (dummy->pcm_hw.rates & SNDRV_PCM_RATE_CONTINUOUS)
                 snd_iprintf(buffer, " continuous");
-        if (dummy_pcm_hardware.rates & SNDRV_PCM_RATE_KNOT)
+        if (dummy->pcm_hw.rates & SNDRV_PCM_RATE_KNOT)
                 snd_iprintf(buffer, " knot");
         for (i = 0; i < ARRAY_SIZE(rates); i++)
-                if (dummy_pcm_hardware.rates & (1 << i))
+                if (dummy->pcm_hw.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))
+#define get_dummy_int_ptr(dummy, ofs) \
+        (unsigned int *)((char *)&((dummy)->pcm_hw) + (ofs))
+#define get_dummy_ll_ptr(dummy, ofs) \
+        (unsigned long long *)((char *)&((dummy)->pcm_hw) + (ofs))
 
 struct dummy_hw_field {
         const char *name;
@@ -884,20 +914,21 @@ static struct dummy_hw_field fields[] = {
 static void dummy_proc_read(struct snd_info_entry *entry,
                             struct snd_info_buffer *buffer)
 {
+        struct snd_dummy *dummy = entry->private_data;
         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));
+                                *get_dummy_int_ptr(dummy, fields[i].offset));
                 else
                         snd_iprintf(buffer, fields[i].format,
-                                    *get_dummy_ll_ptr(fields[i].offset));
+                                *get_dummy_ll_ptr(dummy, fields[i].offset));
                 if (!strcmp(fields[i].name, "formats"))
-                        print_formats(buffer);
+                        print_formats(dummy, buffer);
                 else if (!strcmp(fields[i].name, "rates"))
-                        print_rates(buffer);
+                        print_rates(dummy, buffer);
                 snd_iprintf(buffer, "\n");
         }
 }
@@ -905,6 +936,7 @@ static void dummy_proc_read(struct snd_info_entry *entry,
 static void dummy_proc_write(struct snd_info_entry *entry,
                              struct snd_info_buffer *buffer)
 {
+        struct snd_dummy *dummy = entry->private_data;
         char line[64];
 
         while (!snd_info_get_line(buffer, line, sizeof(line))) {
@@ -924,9 +956,9 @@ static void dummy_proc_write(struct snd_info_entry *entry,
                 if (strict_strtoull(item, 0, &val))
                         continue;
                 if (fields[i].size == sizeof(int))
-                        *get_dummy_int_ptr(fields[i].offset) = val;
+                        *get_dummy_int_ptr(dummy, fields[i].offset) = val;
                 else
-                        *get_dummy_ll_ptr(fields[i].offset) = val;
+                        *get_dummy_ll_ptr(dummy, fields[i].offset) = val;
         }
 }
 
@@ -938,6 +970,7 @@ static void __devinit dummy_proc_init(struct snd_dummy *chip)
                 snd_info_set_text_ops(entry, chip, dummy_proc_read);
                 entry->c.text.write = dummy_proc_write;
                 entry->mode |= S_IWUSR;
+                entry->private_data = chip;
         }
 }
 #else
@@ -948,6 +981,7 @@ static int __devinit snd_dummy_probe(struct platform_device *devptr)
 {
         struct snd_card *card;
         struct snd_dummy *dummy;
+        struct dummy_model *m = NULL, **mdl;
         int idx, err;
         int dev = devptr->id;
 
@@ -957,6 +991,15 @@ static int __devinit snd_dummy_probe(struct platform_device *devptr)
                 return err;
         dummy = card->private_data;
         dummy->card = card;
+        for (mdl = dummy_models; *mdl && model[dev]; mdl++) {
+                if (strcmp(model[dev], (*mdl)->name) == 0) {
+                        printk(KERN_INFO
+                                "snd-dummy: Using model '%s' for card %i\n",
+                                (*mdl)->name, card->number);
+                        m = dummy->model = *mdl;
+                        break;
+                }
+        }
         for (idx = 0; idx < MAX_PCM_DEVICES && idx < pcm_devs[dev]; idx++) {
                 if (pcm_substreams[dev] < 1)
                         pcm_substreams[dev] = 1;
@@ -966,6 +1009,33 @@ static int __devinit snd_dummy_probe(struct platform_device *devptr)
                 if (err < 0)
                         goto __nodev;
         }
+
+        dummy->pcm_hw = dummy_pcm_hardware;
+        if (m) {
+                if (m->formats)
+                        dummy->pcm_hw.formats = m->formats;
+                if (m->buffer_bytes_max)
+                        dummy->pcm_hw.buffer_bytes_max = m->buffer_bytes_max;
+                if (m->period_bytes_min)
+                        dummy->pcm_hw.period_bytes_min = m->period_bytes_min;
+                if (m->period_bytes_max)
+                        dummy->pcm_hw.period_bytes_max = m->period_bytes_max;
+                if (m->periods_min)
+                        dummy->pcm_hw.periods_min = m->periods_min;
+                if (m->periods_max)
+                        dummy->pcm_hw.periods_max = m->periods_max;
+                if (m->rates)
+                        dummy->pcm_hw.rates = m->rates;
+                if (m->rate_min)
+                        dummy->pcm_hw.rate_min = m->rate_min;
+                if (m->rate_max)
+                        dummy->pcm_hw.rate_max = m->rate_max;
+                if (m->channels_min)
+                        dummy->pcm_hw.channels_min = m->channels_min;
+                if (m->channels_max)
+                        dummy->pcm_hw.channels_max = m->channels_max;
+        }
+
         err = snd_card_dummy_new_mixer(dummy);
         if (err < 0)
                 goto __nodev;
diff --git a/sound/drivers/ml403-ac97cr.c b/sound/drivers/ml403-ac97cr.c
index 1950ffce2b54..a1282c1c0591 100644
--- a/sound/drivers/ml403-ac97cr.c
+++ b/sound/drivers/ml403-ac97cr.c
@@ -39,6 +39,7 @@
 #include <linux/platform_device.h>
 
 #include <linux/ioport.h>
+#include <linux/slab.h>
 #include <linux/io.h>
 #include <linux/interrupt.h>
 
diff --git a/sound/drivers/mtpav.c b/sound/drivers/mtpav.c
index 2f8f295d6b0c..da03597fc893 100644
--- a/sound/drivers/mtpav.c
+++ b/sound/drivers/mtpav.c
@@ -54,7 +54,6 @@
 #include <linux/interrupt.h>
 #include <linux/err.h>
 #include <linux/platform_device.h>
-#include <linux/slab.h>
 #include <linux/ioport.h>
 #include <linux/moduleparam.h>
 #include <sound/core.h>
diff --git a/sound/drivers/mts64.c b/sound/drivers/mts64.c
index 9284829bf927..8539ab0a0893 100644
--- a/sound/drivers/mts64.c
+++ b/sound/drivers/mts64.c
@@ -23,6 +23,7 @@
 #include <linux/parport.h>
 #include <linux/spinlock.h>
 #include <linux/delay.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/initval.h>
 #include <sound/rawmidi.h>
diff --git a/sound/drivers/opl3/opl3_oss.c b/sound/drivers/opl3/opl3_oss.c
index a54b1dc5cc78..ade3ca52422e 100644
--- a/sound/drivers/opl3/opl3_oss.c
+++ b/sound/drivers/opl3/opl3_oss.c
@@ -19,7 +19,6 @@
  */
 
 #include "opl3_voice.h"
-#include <linux/slab.h>
 
 static int snd_opl3_open_seq_oss(struct snd_seq_oss_arg *arg, void *closure);
 static int snd_opl3_close_seq_oss(struct snd_seq_oss_arg *arg);
diff --git a/sound/drivers/opl3/opl3_synth.c b/sound/drivers/opl3/opl3_synth.c
index 6d57b6441dec..301acb6b9cf9 100644
--- a/sound/drivers/opl3/opl3_synth.c
+++ b/sound/drivers/opl3/opl3_synth.c
@@ -19,6 +19,7 @@
  *
  */
 
+#include <linux/slab.h>
 #include <sound/opl3.h>
 #include <sound/asound_fm.h>
 
diff --git a/sound/drivers/opl4/opl4_lib.c b/sound/drivers/opl4/opl4_lib.c
index 01997f24c895..f07e38da59b8 100644
--- a/sound/drivers/opl4/opl4_lib.c
+++ b/sound/drivers/opl4/opl4_lib.c
@@ -20,6 +20,7 @@
 #include "opl4_local.h"
 #include <sound/initval.h>
 #include <linux/ioport.h>
+#include <linux/slab.h>
 #include <linux/init.h>
 #include <asm/io.h>
 
diff --git a/sound/drivers/pcsp/pcsp.c b/sound/drivers/pcsp/pcsp.c
index b60cef257b58..f165c77d6273 100644
--- a/sound/drivers/pcsp/pcsp.c
+++ b/sound/drivers/pcsp/pcsp.c
@@ -26,6 +26,7 @@ MODULE_ALIAS("platform:pcspkr");
 static int index = SNDRV_DEFAULT_IDX1;  /* Index 0-MAX */
 static char *id = SNDRV_DEFAULT_STR1;   /* ID for this card */
 static int enable = SNDRV_DEFAULT_ENABLE1;      /* Enable this card */
+static int nopcm;       /* Disable PCM capability of the driver */
 
 module_param(index, int, 0444);
 MODULE_PARM_DESC(index, "Index value for pcsp soundcard.");
@@ -33,6 +34,8 @@ module_param(id, charp, 0444);
 MODULE_PARM_DESC(id, "ID string for pcsp soundcard.");
 module_param(enable, bool, 0444);
 MODULE_PARM_DESC(enable, "Enable PC-Speaker sound.");
+module_param(nopcm, bool, 0444);
+MODULE_PARM_DESC(nopcm, "Disable PC-Speaker PCM sound. Only beeps remain.");
 
 struct snd_pcsp pcsp_chip;
 
@@ -43,13 +46,16 @@ static int __devinit snd_pcsp_create(struct snd_card *card)
         int err;
         int div, min_div, order;
 
-        hrtimer_get_res(CLOCK_MONOTONIC, &tp);
-        if (tp.tv_sec || tp.tv_nsec > PCSP_MAX_PERIOD_NS) {
-                printk(KERN_ERR "PCSP: Timer resolution is not sufficient "
-                       "(%linS)\n", tp.tv_nsec);
-                printk(KERN_ERR "PCSP: Make sure you have HPET and ACPI "
-                       "enabled.\n");
-                return -EIO;
+        if (!nopcm) {
+                hrtimer_get_res(CLOCK_MONOTONIC, &tp);
+                if (tp.tv_sec || tp.tv_nsec > PCSP_MAX_PERIOD_NS) {
+                        printk(KERN_ERR "PCSP: Timer resolution is not sufficient "
+                                "(%linS)\n", tp.tv_nsec);
+                        printk(KERN_ERR "PCSP: Make sure you have HPET and ACPI "
+                                "enabled.\n");
+                        printk(KERN_ERR "PCSP: Turned into nopcm mode.\n");
+                        nopcm = 1;
+                }
         }
 
         if (loops_per_jiffy >= PCSP_MIN_LPJ && tp.tv_nsec <= PCSP_MIN_PERIOD_NS)
@@ -107,12 +113,14 @@ static int __devinit snd_card_pcsp_probe(int devnum, struct device *dev)
                 snd_card_free(card);
                 return err;
         }
-        err = snd_pcsp_new_pcm(&pcsp_chip);
-        if (err < 0) {
-                snd_card_free(card);
-                return err;
+        if (!nopcm) {
+                err = snd_pcsp_new_pcm(&pcsp_chip);
+                if (err < 0) {
+                        snd_card_free(card);
+                        return err;
+                }
         }
-        err = snd_pcsp_new_mixer(&pcsp_chip);
+        err = snd_pcsp_new_mixer(&pcsp_chip, nopcm);
         if (err < 0) {
                 snd_card_free(card);
                 return err;
diff --git a/sound/drivers/pcsp/pcsp.h b/sound/drivers/pcsp/pcsp.h
index 174dd2ff0f22..1e123077923d 100644
--- a/sound/drivers/pcsp/pcsp.h
+++ b/sound/drivers/pcsp/pcsp.h
@@ -83,6 +83,6 @@ extern enum hrtimer_restart pcsp_do_timer(struct hrtimer *handle);
 extern void pcsp_sync_stop(struct snd_pcsp *chip);
 
 extern int snd_pcsp_new_pcm(struct snd_pcsp *chip);
-extern int snd_pcsp_new_mixer(struct snd_pcsp *chip);
+extern int snd_pcsp_new_mixer(struct snd_pcsp *chip, int nopcm);
 
 #endif
diff --git a/sound/drivers/pcsp/pcsp_lib.c b/sound/drivers/pcsp/pcsp_lib.c
index e1145ac6e908..d77ffa9a9387 100644
--- a/sound/drivers/pcsp/pcsp_lib.c
+++ b/sound/drivers/pcsp/pcsp_lib.c
@@ -7,6 +7,7 @@
  */
 
 #include <linux/module.h>
+#include <linux/gfp.h>
 #include <linux/moduleparam.h>
 #include <linux/interrupt.h>
 #include <sound/pcm.h>
diff --git a/sound/drivers/pcsp/pcsp_mixer.c b/sound/drivers/pcsp/pcsp_mixer.c
index 903bc846763f..6f633f4f3b96 100644
--- a/sound/drivers/pcsp/pcsp_mixer.c
+++ b/sound/drivers/pcsp/pcsp_mixer.c
@@ -119,24 +119,43 @@ static int pcsp_pcspkr_put(struct snd_kcontrol *kcontrol,
         .put =          pcsp_##ctl_type##_put, \
 }
 
-static struct snd_kcontrol_new __devinitdata snd_pcsp_controls[] = {
+static struct snd_kcontrol_new __devinitdata snd_pcsp_controls_pcm[] = {
         PCSP_MIXER_CONTROL(enable, "Master Playback Switch"),
         PCSP_MIXER_CONTROL(treble, "BaseFRQ Playback Volume"),
-        PCSP_MIXER_CONTROL(pcspkr, "PC Speaker Playback Switch"),
 };
 
-int __devinit snd_pcsp_new_mixer(struct snd_pcsp *chip)
+static struct snd_kcontrol_new __devinitdata snd_pcsp_controls_spkr[] = {
+        PCSP_MIXER_CONTROL(pcspkr, "Beep Playback Switch"),
+};
+
+static int __devinit snd_pcsp_ctls_add(struct snd_pcsp *chip,
+        struct snd_kcontrol_new *ctls, int num)
 {
-        struct snd_card *card = chip->card;
         int i, err;
+        struct snd_card *card = chip->card;
+        for (i = 0; i < num; i++) {
+                err = snd_ctl_add(card, snd_ctl_new1(ctls + i, chip));
+                if (err < 0)
+                        return err;
+        }
+        return 0;
+}
+
+int __devinit snd_pcsp_new_mixer(struct snd_pcsp *chip, int nopcm)
+{
+        int err;
+        struct snd_card *card = chip->card;
 
-        for (i = 0; i < ARRAY_SIZE(snd_pcsp_controls); i++) {
-                err = snd_ctl_add(card,
-                                 snd_ctl_new1(snd_pcsp_controls + i,
-                                              chip));
+        if (!nopcm) {
+                err = snd_pcsp_ctls_add(chip, snd_pcsp_controls_pcm,
+                        ARRAY_SIZE(snd_pcsp_controls_pcm));
                 if (err < 0)
                         return err;
         }
+        err = snd_pcsp_ctls_add(chip, snd_pcsp_controls_spkr,
+                ARRAY_SIZE(snd_pcsp_controls_spkr));
+        if (err < 0)
+                return err;
 
         strcpy(card->mixername, "PC-Speaker");
 
diff --git a/sound/drivers/portman2x4.c b/sound/drivers/portman2x4.c
index 60158e2e0eaf..f2b0ba22d9ce 100644
--- a/sound/drivers/portman2x4.c
+++ b/sound/drivers/portman2x4.c
@@ -42,6 +42,7 @@
 #include <linux/parport.h>
 #include <linux/spinlock.h>
 #include <linux/delay.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/initval.h>
 #include <sound/rawmidi.h>
diff --git a/sound/drivers/vx/vx_hwdep.c b/sound/drivers/vx/vx_hwdep.c
index 46df8817c18f..f7a6fbd313e3 100644
--- a/sound/drivers/vx/vx_hwdep.c
+++ b/sound/drivers/vx/vx_hwdep.c
@@ -22,6 +22,7 @@
 
 #include <linux/device.h>
 #include <linux/firmware.h>
+#include <linux/slab.h>
 #include <linux/vmalloc.h>
 #include <sound/core.h>
 #include <sound/hwdep.h>
diff --git a/sound/drivers/vx/vx_pcm.c b/sound/drivers/vx/vx_pcm.c
index 6644d0034fba..35a2f71a6af5 100644
--- a/sound/drivers/vx/vx_pcm.c
+++ b/sound/drivers/vx/vx_pcm.c
@@ -46,7 +46,6 @@
  */
 
 #include <linux/slab.h>
-#include <linux/vmalloc.h>
 #include <linux/delay.h>
 #include <sound/core.h>
 #include <sound/asoundef.h>
@@ -56,55 +55,6 @@
 
 
 /*
- * we use a vmalloc'ed (sg-)buffer
- */
-
-/* get the physical page pointer on the given offset */
-static struct page *snd_pcm_get_vmalloc_page(struct snd_pcm_substream *subs,
-                                             unsigned long offset)
-{
-        void *pageptr = subs->runtime->dma_area + offset;
-        return vmalloc_to_page(pageptr);
-}
-
-/*
- * allocate a buffer via vmalloc_32().
- * called from hw_params
- * NOTE: this may be called not only once per pcm open!
- */
-static int snd_pcm_alloc_vmalloc_buffer(struct snd_pcm_substream *subs, size_t size)
-{
-        struct snd_pcm_runtime *runtime = subs->runtime;
-        if (runtime->dma_area) {
-                /* already allocated */
-                if (runtime->dma_bytes >= size)
-                        return 0; /* already enough large */
-                vfree(runtime->dma_area);
-        }
-        runtime->dma_area = vmalloc_32(size);
-        if (! runtime->dma_area)
-                return -ENOMEM;
-        memset(runtime->dma_area, 0, size);
-        runtime->dma_bytes = size;
-        return 1; /* changed */
-}
-
-/*
- * free the buffer.
- * called from hw_free callback
- * NOTE: this may be called not only once per pcm open!
- */
-static int snd_pcm_free_vmalloc_buffer(struct snd_pcm_substream *subs)
-{
-        struct snd_pcm_runtime *runtime = subs->runtime;
-
-        vfree(runtime->dma_area);
-        runtime->dma_area = NULL;
-        return 0;
-}
-
-
-/*
  * read three pending pcm bytes via inb()
  */
 static void vx_pcm_read_per_bytes(struct vx_core *chip, struct snd_pcm_runtime *runtime,
@@ -865,7 +815,8 @@ static snd_pcm_uframes_t vx_pcm_playback_pointer(struct snd_pcm_substream *subs)
 static int vx_pcm_hw_params(struct snd_pcm_substream *subs,
                                      struct snd_pcm_hw_params *hw_params)
 {
-        return snd_pcm_alloc_vmalloc_buffer(subs, params_buffer_bytes(hw_params));
+        return snd_pcm_lib_alloc_vmalloc_32_buffer
+                                        (subs, params_buffer_bytes(hw_params));
 }
 
 /*
@@ -873,7 +824,7 @@ static int vx_pcm_hw_params(struct snd_pcm_substream *subs,
  */
 static int vx_pcm_hw_free(struct snd_pcm_substream *subs)
 {
-        return snd_pcm_free_vmalloc_buffer(subs);
+        return snd_pcm_lib_free_vmalloc_buffer(subs);
 }
 
 /*
@@ -953,7 +904,8 @@ static struct snd_pcm_ops vx_pcm_playback_ops = {
         .prepare =      vx_pcm_prepare,
         .trigger =      vx_pcm_trigger,
         .pointer =      vx_pcm_playback_pointer,
-        .page =         snd_pcm_get_vmalloc_page,
+        .page =         snd_pcm_lib_get_vmalloc_page,
+        .mmap =         snd_pcm_lib_mmap_vmalloc,
 };
 
 
@@ -1173,7 +1125,8 @@ static struct snd_pcm_ops vx_pcm_capture_ops = {
         .prepare =      vx_pcm_prepare,
         .trigger =      vx_pcm_trigger,
         .pointer =      vx_pcm_capture_pointer,
-        .page =         snd_pcm_get_vmalloc_page,
+        .page =         snd_pcm_lib_get_vmalloc_page,
+        .mmap =         snd_pcm_lib_mmap_vmalloc,
 };
 
 
diff --git a/sound/i2c/cs8427.c b/sound/i2c/cs8427.c
index 020a5d512472..04ae8704cdcd 100644
--- a/sound/i2c/cs8427.c
+++ b/sound/i2c/cs8427.c
@@ -23,6 +23,7 @@
 #include <linux/slab.h>
 #include <linux/delay.h>
 #include <linux/init.h>
+#include <linux/bitrev.h>
 #include <asm/unaligned.h>
 #include <sound/core.h>
 #include <sound/control.h>
@@ -55,18 +56,6 @@ struct cs8427 {
         struct cs8427_stream capture;
 };
 
-static unsigned char swapbits(unsigned char val)
-{
-        int bit;
-        unsigned char res = 0;
-        for (bit = 0; bit < 8; bit++) {
-                res <<= 1;
-                res |= val & 1;
-                val >>= 1;
-        }
-        return res;
-}
-
 int snd_cs8427_reg_write(struct snd_i2c_device *device, unsigned char reg,
                          unsigned char val)
 {
@@ -149,7 +138,7 @@ static int snd_cs8427_send_corudata(struct snd_i2c_device *device,
         }
         data[0] = CS8427_REG_AUTOINC | CS8427_REG_CORU_DATABUF;
         for (idx = 0; idx < count; idx++)
-                data[idx + 1] = swapbits(ndata[idx]);
+                data[idx + 1] = bitrev8(ndata[idx]);
         if (snd_i2c_sendbytes(device, data, count + 1) != count + 1)
                 return -EIO;
         return 1;
diff --git a/sound/i2c/other/Makefile b/sound/i2c/other/Makefile
index 703d954238f4..2dad40f3f622 100644
--- a/sound/i2c/other/Makefile
+++ b/sound/i2c/other/Makefile
@@ -5,6 +5,7 @@
 
 snd-ak4114-objs := ak4114.o
 snd-ak4117-objs := ak4117.o
+snd-ak4113-objs := ak4113.o
 snd-ak4xxx-adda-objs := ak4xxx-adda.o
 snd-pt2258-objs := pt2258.o
 snd-tea575x-tuner-objs := tea575x-tuner.o
@@ -12,5 +13,5 @@ snd-tea575x-tuner-objs := tea575x-tuner.o
 # Module Dependency
 obj-$(CONFIG_SND_PDAUDIOCF) += snd-ak4117.o
 obj-$(CONFIG_SND_ICE1712) += snd-ak4xxx-adda.o
-obj-$(CONFIG_SND_ICE1724) += snd-ak4114.o snd-ak4xxx-adda.o snd-pt2258.o
+obj-$(CONFIG_SND_ICE1724) += snd-ak4114.o snd-ak4113.o snd-ak4xxx-adda.o snd-pt2258.o
 obj-$(CONFIG_SND_FM801_TEA575X) += snd-tea575x-tuner.o
diff --git a/sound/i2c/other/ak4113.c b/sound/i2c/other/ak4113.c
new file mode 100644
index 000000000000..971a84a4fa77
--- /dev/null
+++ b/sound/i2c/other/ak4113.c
@@ -0,0 +1,639 @@
+/*
+ *  Routines for control of the AK4113 via I2C/4-wire serial interface
+ *  IEC958 (S/PDIF) receiver by Asahi Kasei
+ *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
+ *  Copyright (c) by Pavel Hofman <pavel.hofman@ivitera.com>
+ *
+ *
+ *   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
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program 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/slab.h>
+#include <linux/delay.h>
+#include <sound/core.h>
+#include <sound/control.h>
+#include <sound/pcm.h>
+#include <sound/ak4113.h>
+#include <sound/asoundef.h>
+#include <sound/info.h>
+
+MODULE_AUTHOR("Pavel Hofman <pavel.hofman@ivitera.com>");
+MODULE_DESCRIPTION("AK4113 IEC958 (S/PDIF) receiver by Asahi Kasei");
+MODULE_LICENSE("GPL");
+
+#define AK4113_ADDR                     0x00 /* fixed address */
+
+static void ak4113_stats(struct work_struct *work);
+static void ak4113_init_regs(struct ak4113 *chip);
+
+
+static void reg_write(struct ak4113 *ak4113, unsigned char reg,
+                unsigned char val)
+{
+        ak4113->write(ak4113->private_data, reg, val);
+        if (reg < sizeof(ak4113->regmap))
+                ak4113->regmap[reg] = val;
+}
+
+static inline unsigned char reg_read(struct ak4113 *ak4113, unsigned char reg)
+{
+        return ak4113->read(ak4113->private_data, reg);
+}
+
+static void snd_ak4113_free(struct ak4113 *chip)
+{
+        chip->init = 1; /* don't schedule new work */
+        mb();
+        cancel_delayed_work(&chip->work);
+        flush_scheduled_work();
+        kfree(chip);
+}
+
+static int snd_ak4113_dev_free(struct snd_device *device)
+{
+        struct ak4113 *chip = device->device_data;
+        snd_ak4113_free(chip);
+        return 0;
+}
+
+int snd_ak4113_create(struct snd_card *card, ak4113_read_t *read,
+                ak4113_write_t *write, const unsigned char *pgm,
+                void *private_data, struct ak4113 **r_ak4113)
+{
+        struct ak4113 *chip;
+        int err = 0;
+        unsigned char reg;
+        static struct snd_device_ops ops = {
+                .dev_free =     snd_ak4113_dev_free,
+        };
+
+        chip = kzalloc(sizeof(*chip), GFP_KERNEL);
+        if (chip == NULL)
+                return -ENOMEM;
+        spin_lock_init(&chip->lock);
+        chip->card = card;
+        chip->read = read;
+        chip->write = write;
+        chip->private_data = private_data;
+        INIT_DELAYED_WORK(&chip->work, ak4113_stats);
+
+        for (reg = 0; reg < AK4113_WRITABLE_REGS ; reg++)
+                chip->regmap[reg] = pgm[reg];
+        ak4113_init_regs(chip);
+
+        chip->rcs0 = reg_read(chip, AK4113_REG_RCS0) & ~(AK4113_QINT |
+                        AK4113_CINT | AK4113_STC);
+        chip->rcs1 = reg_read(chip, AK4113_REG_RCS1);
+        chip->rcs2 = reg_read(chip, AK4113_REG_RCS2);
+        err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
+        if (err < 0)
+                goto __fail;
+
+        if (r_ak4113)
+                *r_ak4113 = chip;
+        return 0;
+
+__fail:
+        snd_ak4113_free(chip);
+        return err < 0 ? err : -EIO;
+}
+EXPORT_SYMBOL_GPL(snd_ak4113_create);
+
+void snd_ak4113_reg_write(struct ak4113 *chip, unsigned char reg,
+                unsigned char mask, unsigned char val)
+{
+        if (reg >= AK4113_WRITABLE_REGS)
+                return;
+        reg_write(chip, reg, (chip->regmap[reg] & ~mask) | val);
+}
+EXPORT_SYMBOL_GPL(snd_ak4113_reg_write);
+
+static void ak4113_init_regs(struct ak4113 *chip)
+{
+        unsigned char old = chip->regmap[AK4113_REG_PWRDN], reg;
+
+        /* bring the chip to reset state and powerdown state */
+        reg_write(chip, AK4113_REG_PWRDN, old & ~(AK4113_RST|AK4113_PWN));
+        udelay(200);
+        /* release reset, but leave powerdown */
+        reg_write(chip, AK4113_REG_PWRDN, (old | AK4113_RST) & ~AK4113_PWN);
+        udelay(200);
+        for (reg = 1; reg < AK4113_WRITABLE_REGS; reg++)
+                reg_write(chip, reg, chip->regmap[reg]);
+        /* release powerdown, everything is initialized now */
+        reg_write(chip, AK4113_REG_PWRDN, old | AK4113_RST | AK4113_PWN);
+}
+
+void snd_ak4113_reinit(struct ak4113 *chip)
+{
+        chip->init = 1;
+        mb();
+        flush_scheduled_work();
+        ak4113_init_regs(chip);
+        /* bring up statistics / event queing */
+        chip->init = 0;
+        if (chip->kctls[0])
+                schedule_delayed_work(&chip->work, HZ / 10);
+}
+EXPORT_SYMBOL_GPL(snd_ak4113_reinit);
+
+static unsigned int external_rate(unsigned char rcs1)
+{
+        switch (rcs1 & (AK4113_FS0|AK4113_FS1|AK4113_FS2|AK4113_FS3)) {
+        case AK4113_FS_8000HZ:
+                return 8000;
+        case AK4113_FS_11025HZ:
+                return 11025;
+        case AK4113_FS_16000HZ:
+                return 16000;
+        case AK4113_FS_22050HZ:
+                return 22050;
+        case AK4113_FS_24000HZ:
+                return 24000;
+        case AK4113_FS_32000HZ:
+                return 32000;
+        case AK4113_FS_44100HZ:
+                return 44100;
+        case AK4113_FS_48000HZ:
+                return 48000;
+        case AK4113_FS_64000HZ:
+                return 64000;
+        case AK4113_FS_88200HZ:
+                return 88200;
+        case AK4113_FS_96000HZ:
+                return 96000;
+        case AK4113_FS_176400HZ:
+                return 176400;
+        case AK4113_FS_192000HZ:
+                return 192000;
+        default:
+                return 0;
+        }
+}
+
+static int snd_ak4113_in_error_info(struct snd_kcontrol *kcontrol,
+                                    struct snd_ctl_elem_info *uinfo)
+{
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+        uinfo->count = 1;
+        uinfo->value.integer.min = 0;
+        uinfo->value.integer.max = LONG_MAX;
+        return 0;
+}
+
+static int snd_ak4113_in_error_get(struct snd_kcontrol *kcontrol,
+                                   struct snd_ctl_elem_value *ucontrol)
+{
+        struct ak4113 *chip = snd_kcontrol_chip(kcontrol);
+        long *ptr;
+
+        spin_lock_irq(&chip->lock);
+        ptr = (long *)(((char *)chip) + kcontrol->private_value);
+        ucontrol->value.integer.value[0] = *ptr;
+        *ptr = 0;
+        spin_unlock_irq(&chip->lock);
+        return 0;
+}
+
+#define snd_ak4113_in_bit_info          snd_ctl_boolean_mono_info
+
+static int snd_ak4113_in_bit_get(struct snd_kcontrol *kcontrol,
+                                 struct snd_ctl_elem_value *ucontrol)
+{
+        struct ak4113 *chip = snd_kcontrol_chip(kcontrol);
+        unsigned char reg = kcontrol->private_value & 0xff;
+        unsigned char bit = (kcontrol->private_value >> 8) & 0xff;
+        unsigned char inv = (kcontrol->private_value >> 31) & 1;
+
+        ucontrol->value.integer.value[0] =
+                ((reg_read(chip, reg) & (1 << bit)) ? 1 : 0) ^ inv;
+        return 0;
+}
+
+static int snd_ak4113_rx_info(struct snd_kcontrol *kcontrol,
+                              struct snd_ctl_elem_info *uinfo)
+{
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+        uinfo->count = 1;
+        uinfo->value.integer.min = 0;
+        uinfo->value.integer.max = 5;
+        return 0;
+}
+
+static int snd_ak4113_rx_get(struct snd_kcontrol *kcontrol,
+                             struct snd_ctl_elem_value *ucontrol)
+{
+        struct ak4113 *chip = snd_kcontrol_chip(kcontrol);
+
+        ucontrol->value.integer.value[0] =
+                (AK4113_IPS(chip->regmap[AK4113_REG_IO1]));
+        return 0;
+}
+
+static int snd_ak4113_rx_put(struct snd_kcontrol *kcontrol,
+                             struct snd_ctl_elem_value *ucontrol)
+{
+        struct ak4113 *chip = snd_kcontrol_chip(kcontrol);
+        int change;
+        u8 old_val;
+
+        spin_lock_irq(&chip->lock);
+        old_val = chip->regmap[AK4113_REG_IO1];
+        change = ucontrol->value.integer.value[0] != AK4113_IPS(old_val);
+        if (change)
+                reg_write(chip, AK4113_REG_IO1,
+                                (old_val & (~AK4113_IPS(0xff))) |
+                                (AK4113_IPS(ucontrol->value.integer.value[0])));
+        spin_unlock_irq(&chip->lock);
+        return change;
+}
+
+static int snd_ak4113_rate_info(struct snd_kcontrol *kcontrol,
+                                struct snd_ctl_elem_info *uinfo)
+{
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+        uinfo->count = 1;
+        uinfo->value.integer.min = 0;
+        uinfo->value.integer.max = 192000;
+        return 0;
+}
+
+static int snd_ak4113_rate_get(struct snd_kcontrol *kcontrol,
+                               struct snd_ctl_elem_value *ucontrol)
+{
+        struct ak4113 *chip = snd_kcontrol_chip(kcontrol);
+
+        ucontrol->value.integer.value[0] = external_rate(reg_read(chip,
+                                AK4113_REG_RCS1));
+        return 0;
+}
+
+static int snd_ak4113_spdif_info(struct snd_kcontrol *kcontrol,
+                struct snd_ctl_elem_info *uinfo)
+{
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
+        uinfo->count = 1;
+        return 0;
+}
+
+static int snd_ak4113_spdif_get(struct snd_kcontrol *kcontrol,
+                                struct snd_ctl_elem_value *ucontrol)
+{
+        struct ak4113 *chip = snd_kcontrol_chip(kcontrol);
+        unsigned i;
+
+        for (i = 0; i < AK4113_REG_RXCSB_SIZE; i++)
+                ucontrol->value.iec958.status[i] = reg_read(chip,
+                                AK4113_REG_RXCSB0 + i);
+        return 0;
+}
+
+static int snd_ak4113_spdif_mask_info(struct snd_kcontrol *kcontrol,
+                struct snd_ctl_elem_info *uinfo)
+{
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
+        uinfo->count = 1;
+        return 0;
+}
+
+static int snd_ak4113_spdif_mask_get(struct snd_kcontrol *kcontrol,
+                                      struct snd_ctl_elem_value *ucontrol)
+{
+        memset(ucontrol->value.iec958.status, 0xff, AK4113_REG_RXCSB_SIZE);
+        return 0;
+}
+
+static int snd_ak4113_spdif_pinfo(struct snd_kcontrol *kcontrol,
+                struct snd_ctl_elem_info *uinfo)
+{
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+        uinfo->value.integer.min = 0;
+        uinfo->value.integer.max = 0xffff;
+        uinfo->count = 4;
+        return 0;
+}
+
+static int snd_ak4113_spdif_pget(struct snd_kcontrol *kcontrol,
+                                 struct snd_ctl_elem_value *ucontrol)
+{
+        struct ak4113 *chip = snd_kcontrol_chip(kcontrol);
+        unsigned short tmp;
+
+        ucontrol->value.integer.value[0] = 0xf8f2;
+        ucontrol->value.integer.value[1] = 0x4e1f;
+        tmp = reg_read(chip, AK4113_REG_Pc0) |
+                (reg_read(chip, AK4113_REG_Pc1) << 8);
+        ucontrol->value.integer.value[2] = tmp;
+        tmp = reg_read(chip, AK4113_REG_Pd0) |
+                (reg_read(chip, AK4113_REG_Pd1) << 8);
+        ucontrol->value.integer.value[3] = tmp;
+        return 0;
+}
+
+static int snd_ak4113_spdif_qinfo(struct snd_kcontrol *kcontrol,
+                struct snd_ctl_elem_info *uinfo)
+{
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES;
+        uinfo->count = AK4113_REG_QSUB_SIZE;
+        return 0;
+}
+
+static int snd_ak4113_spdif_qget(struct snd_kcontrol *kcontrol,
+                                 struct snd_ctl_elem_value *ucontrol)
+{
+        struct ak4113 *chip = snd_kcontrol_chip(kcontrol);
+        unsigned i;
+
+        for (i = 0; i < AK4113_REG_QSUB_SIZE; i++)
+                ucontrol->value.bytes.data[i] = reg_read(chip,
+                                AK4113_REG_QSUB_ADDR + i);
+        return 0;
+}
+
+/* Don't forget to change AK4113_CONTROLS define!!! */
+static struct snd_kcontrol_new snd_ak4113_iec958_controls[] = {
+{
+        .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
+        .name =         "IEC958 Parity Errors",
+        .access =       SNDRV_CTL_ELEM_ACCESS_READ |
+                SNDRV_CTL_ELEM_ACCESS_VOLATILE,
+        .info =         snd_ak4113_in_error_info,
+        .get =          snd_ak4113_in_error_get,
+        .private_value = offsetof(struct ak4113, parity_errors),
+},
+{
+        .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
+        .name =         "IEC958 V-Bit Errors",
+        .access =       SNDRV_CTL_ELEM_ACCESS_READ |
+                SNDRV_CTL_ELEM_ACCESS_VOLATILE,
+        .info =         snd_ak4113_in_error_info,
+        .get =          snd_ak4113_in_error_get,
+        .private_value = offsetof(struct ak4113, v_bit_errors),
+},
+{
+        .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
+        .name =         "IEC958 C-CRC Errors",
+        .access =       SNDRV_CTL_ELEM_ACCESS_READ |
+                SNDRV_CTL_ELEM_ACCESS_VOLATILE,
+        .info =         snd_ak4113_in_error_info,
+        .get =          snd_ak4113_in_error_get,
+        .private_value = offsetof(struct ak4113, ccrc_errors),
+},
+{
+        .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
+        .name =         "IEC958 Q-CRC Errors",
+        .access =       SNDRV_CTL_ELEM_ACCESS_READ |
+                SNDRV_CTL_ELEM_ACCESS_VOLATILE,
+        .info =         snd_ak4113_in_error_info,
+        .get =          snd_ak4113_in_error_get,
+        .private_value = offsetof(struct ak4113, qcrc_errors),
+},
+{
+        .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
+        .name =         "IEC958 External Rate",
+        .access =       SNDRV_CTL_ELEM_ACCESS_READ |
+                SNDRV_CTL_ELEM_ACCESS_VOLATILE,
+        .info =         snd_ak4113_rate_info,
+        .get =          snd_ak4113_rate_get,
+},
+{
+        .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
+        .name =         SNDRV_CTL_NAME_IEC958("", CAPTURE, MASK),
+        .access =       SNDRV_CTL_ELEM_ACCESS_READ,
+        .info =         snd_ak4113_spdif_mask_info,
+        .get =          snd_ak4113_spdif_mask_get,
+},
+{
+        .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
+        .name =         SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
+        .access =       SNDRV_CTL_ELEM_ACCESS_READ |
+                SNDRV_CTL_ELEM_ACCESS_VOLATILE,
+        .info =         snd_ak4113_spdif_info,
+        .get =          snd_ak4113_spdif_get,
+},
+{
+        .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
+        .name =         "IEC958 Preample Capture Default",
+        .access =       SNDRV_CTL_ELEM_ACCESS_READ |
+                SNDRV_CTL_ELEM_ACCESS_VOLATILE,
+        .info =         snd_ak4113_spdif_pinfo,
+        .get =          snd_ak4113_spdif_pget,
+},
+{
+        .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
+        .name =         "IEC958 Q-subcode Capture Default",
+        .access =       SNDRV_CTL_ELEM_ACCESS_READ |
+                SNDRV_CTL_ELEM_ACCESS_VOLATILE,
+        .info =         snd_ak4113_spdif_qinfo,
+        .get =          snd_ak4113_spdif_qget,
+},
+{
+        .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
+        .name =         "IEC958 Audio",
+        .access =       SNDRV_CTL_ELEM_ACCESS_READ |
+                SNDRV_CTL_ELEM_ACCESS_VOLATILE,
+        .info =         snd_ak4113_in_bit_info,
+        .get =          snd_ak4113_in_bit_get,
+        .private_value = (1<<31) | (1<<8) | AK4113_REG_RCS0,
+},
+{
+        .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
+        .name =         "IEC958 Non-PCM Bitstream",
+        .access =       SNDRV_CTL_ELEM_ACCESS_READ |
+                SNDRV_CTL_ELEM_ACCESS_VOLATILE,
+        .info =         snd_ak4113_in_bit_info,
+        .get =          snd_ak4113_in_bit_get,
+        .private_value = (0<<8) | AK4113_REG_RCS1,
+},
+{
+        .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
+        .name =         "IEC958 DTS Bitstream",
+        .access =       SNDRV_CTL_ELEM_ACCESS_READ |
+                SNDRV_CTL_ELEM_ACCESS_VOLATILE,
+        .info =         snd_ak4113_in_bit_info,
+        .get =          snd_ak4113_in_bit_get,
+        .private_value = (1<<8) | AK4113_REG_RCS1,
+},
+{
+        .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
+        .name =         "AK4113 Input Select",
+        .access =       SNDRV_CTL_ELEM_ACCESS_READ |
+                SNDRV_CTL_ELEM_ACCESS_WRITE,
+        .info =         snd_ak4113_rx_info,
+        .get =          snd_ak4113_rx_get,
+        .put =          snd_ak4113_rx_put,
+}
+};
+
+static void snd_ak4113_proc_regs_read(struct snd_info_entry *entry,
+                struct snd_info_buffer *buffer)
+{
+        struct ak4113 *ak4113 = entry->private_data;
+        int reg, val;
+        /* all ak4113 registers 0x00 - 0x1c */
+        for (reg = 0; reg < 0x1d; reg++) {
+                val = reg_read(ak4113, reg);
+                snd_iprintf(buffer, "0x%02x = 0x%02x\n", reg, val);
+        }
+}
+
+static void snd_ak4113_proc_init(struct ak4113 *ak4113)
+{
+        struct snd_info_entry *entry;
+        if (!snd_card_proc_new(ak4113->card, "ak4113", &entry))
+                snd_info_set_text_ops(entry, ak4113, snd_ak4113_proc_regs_read);
+}
+
+int snd_ak4113_build(struct ak4113 *ak4113,
+                struct snd_pcm_substream *cap_substream)
+{
+        struct snd_kcontrol *kctl;
+        unsigned int idx;
+        int err;
+
+        if (snd_BUG_ON(!cap_substream))
+                return -EINVAL;
+        ak4113->substream = cap_substream;
+        for (idx = 0; idx < AK4113_CONTROLS; idx++) {
+                kctl = snd_ctl_new1(&snd_ak4113_iec958_controls[idx], ak4113);
+                if (kctl == NULL)
+                        return -ENOMEM;
+                kctl->id.device = cap_substream->pcm->device;
+                kctl->id.subdevice = cap_substream->number;
+                err = snd_ctl_add(ak4113->card, kctl);
+                if (err < 0)
+                        return err;
+                ak4113->kctls[idx] = kctl;
+        }
+        snd_ak4113_proc_init(ak4113);
+        /* trigger workq */
+        schedule_delayed_work(&ak4113->work, HZ / 10);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(snd_ak4113_build);
+
+int snd_ak4113_external_rate(struct ak4113 *ak4113)
+{
+        unsigned char rcs1;
+
+        rcs1 = reg_read(ak4113, AK4113_REG_RCS1);
+        return external_rate(rcs1);
+}
+EXPORT_SYMBOL_GPL(snd_ak4113_external_rate);
+
+int snd_ak4113_check_rate_and_errors(struct ak4113 *ak4113, unsigned int flags)
+{
+        struct snd_pcm_runtime *runtime =
+                ak4113->substream ? ak4113->substream->runtime : NULL;
+        unsigned long _flags;
+        int res = 0;
+        unsigned char rcs0, rcs1, rcs2;
+        unsigned char c0, c1;
+
+        rcs1 = reg_read(ak4113, AK4113_REG_RCS1);
+        if (flags & AK4113_CHECK_NO_STAT)
+                goto __rate;
+        rcs0 = reg_read(ak4113, AK4113_REG_RCS0);
+        rcs2 = reg_read(ak4113, AK4113_REG_RCS2);
+        spin_lock_irqsave(&ak4113->lock, _flags);
+        if (rcs0 & AK4113_PAR)
+                ak4113->parity_errors++;
+        if (rcs0 & AK4113_V)
+                ak4113->v_bit_errors++;
+        if (rcs2 & AK4113_CCRC)
+                ak4113->ccrc_errors++;
+        if (rcs2 & AK4113_QCRC)
+                ak4113->qcrc_errors++;
+        c0 = (ak4113->rcs0 & (AK4113_QINT | AK4113_CINT | AK4113_STC |
+                                AK4113_AUDION | AK4113_AUTO | AK4113_UNLCK)) ^
+                (rcs0 & (AK4113_QINT | AK4113_CINT | AK4113_STC |
+                         AK4113_AUDION | AK4113_AUTO | AK4113_UNLCK));
+        c1 = (ak4113->rcs1 & (AK4113_DTSCD | AK4113_NPCM | AK4113_PEM |
+                                AK4113_DAT | 0xf0)) ^
+                (rcs1 & (AK4113_DTSCD | AK4113_NPCM | AK4113_PEM |
+                         AK4113_DAT | 0xf0));
+        ak4113->rcs0 = rcs0 & ~(AK4113_QINT | AK4113_CINT | AK4113_STC);
+        ak4113->rcs1 = rcs1;
+        ak4113->rcs2 = rcs2;
+        spin_unlock_irqrestore(&ak4113->lock, _flags);
+
+        if (rcs0 & AK4113_PAR)
+                snd_ctl_notify(ak4113->card, SNDRV_CTL_EVENT_MASK_VALUE,
+                                &ak4113->kctls[0]->id);
+        if (rcs0 & AK4113_V)
+                snd_ctl_notify(ak4113->card, SNDRV_CTL_EVENT_MASK_VALUE,
+                                &ak4113->kctls[1]->id);
+        if (rcs2 & AK4113_CCRC)
+                snd_ctl_notify(ak4113->card, SNDRV_CTL_EVENT_MASK_VALUE,
+                                &ak4113->kctls[2]->id);
+        if (rcs2 & AK4113_QCRC)
+                snd_ctl_notify(ak4113->card, SNDRV_CTL_EVENT_MASK_VALUE,
+                                &ak4113->kctls[3]->id);
+
+        /* rate change */
+        if (c1 & 0xf0)
+                snd_ctl_notify(ak4113->card, SNDRV_CTL_EVENT_MASK_VALUE,
+                                &ak4113->kctls[4]->id);
+
+        if ((c1 & AK4113_PEM) | (c0 & AK4113_CINT))
+                snd_ctl_notify(ak4113->card, SNDRV_CTL_EVENT_MASK_VALUE,
+                                &ak4113->kctls[6]->id);
+        if (c0 & AK4113_QINT)
+                snd_ctl_notify(ak4113->card, SNDRV_CTL_EVENT_MASK_VALUE,
+                                &ak4113->kctls[8]->id);
+
+        if (c0 & AK4113_AUDION)
+                snd_ctl_notify(ak4113->card, SNDRV_CTL_EVENT_MASK_VALUE,
+                                &ak4113->kctls[9]->id);
+        if (c1 & AK4113_NPCM)
+                snd_ctl_notify(ak4113->card, SNDRV_CTL_EVENT_MASK_VALUE,
+                                &ak4113->kctls[10]->id);
+        if (c1 & AK4113_DTSCD)
+                snd_ctl_notify(ak4113->card, SNDRV_CTL_EVENT_MASK_VALUE,
+                                &ak4113->kctls[11]->id);
+
+        if (ak4113->change_callback && (c0 | c1) != 0)
+                ak4113->change_callback(ak4113, c0, c1);
+
+__rate:
+        /* compare rate */
+        res = external_rate(rcs1);
+        if (!(flags & AK4113_CHECK_NO_RATE) && runtime &&
+                        (runtime->rate != res)) {
+                snd_pcm_stream_lock_irqsave(ak4113->substream, _flags);
+                if (snd_pcm_running(ak4113->substream)) {
+                        /*printk(KERN_DEBUG "rate changed (%i <- %i)\n",
+                         * runtime->rate, res); */
+                        snd_pcm_stop(ak4113->substream,
+                                        SNDRV_PCM_STATE_DRAINING);
+                        wake_up(&runtime->sleep);
+                        res = 1;
+                }
+                snd_pcm_stream_unlock_irqrestore(ak4113->substream, _flags);
+        }
+        return res;
+}
+EXPORT_SYMBOL_GPL(snd_ak4113_check_rate_and_errors);
+
+static void ak4113_stats(struct work_struct *work)
+{
+        struct ak4113 *chip = container_of(work, struct ak4113, work.work);
+
+        if (!chip->init)
+                snd_ak4113_check_rate_and_errors(chip, chip->check_flags);
+
+        schedule_delayed_work(&chip->work, HZ / 10);
+}
diff --git a/sound/i2c/other/ak4xxx-adda.c b/sound/i2c/other/ak4xxx-adda.c
index ee47abab764e..1adb8a3c2b62 100644
--- a/sound/i2c/other/ak4xxx-adda.c
+++ b/sound/i2c/other/ak4xxx-adda.c
@@ -19,7 +19,7 @@
  *   along with this program; if not, write to the Free Software
  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  *
- */      
+ */
 
 #include <asm/io.h>
 #include <linux/delay.h>
@@ -29,6 +29,7 @@
 #include <sound/control.h>
 #include <sound/tlv.h>
 #include <sound/ak4xxx-adda.h>
+#include <sound/info.h>
 
 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>, Takashi Iwai <tiwai@suse.de>");
 MODULE_DESCRIPTION("Routines for control of AK452x / AK43xx  AD/DA converters");
@@ -52,26 +53,21 @@ EXPORT_SYMBOL(snd_akm4xxx_write);
 static void ak4524_reset(struct snd_akm4xxx *ak, int state)
 {
         unsigned int chip;
-        unsigned char reg, maxreg;
+        unsigned char reg;
 
-        if (ak->type == SND_AK4528)
-                maxreg = 0x06;
-        else
-                maxreg = 0x08;
         for (chip = 0; chip < ak->num_dacs/2; chip++) {
                 snd_akm4xxx_write(ak, chip, 0x01, state ? 0x00 : 0x03);
                 if (state)
                         continue;
                 /* DAC volumes */
-                for (reg = 0x04; reg < maxreg; reg++)
+                for (reg = 0x04; reg < ak->total_regs; reg++)
                         snd_akm4xxx_write(ak, chip, reg,
                                           snd_akm4xxx_get(ak, chip, reg));
         }
 }
 
 /* reset procedure for AK4355 and AK4358 */
-static void ak435X_reset(struct snd_akm4xxx *ak, int state,
-                unsigned char total_regs)
+static void ak435X_reset(struct snd_akm4xxx *ak, int state)
 {
         unsigned char reg;
 
@@ -79,7 +75,7 @@ static void ak435X_reset(struct snd_akm4xxx *ak, int state,
                 snd_akm4xxx_write(ak, 0, 0x01, 0x02); /* reset and soft-mute */
                 return;
         }
-        for (reg = 0x00; reg < total_regs; reg++)
+        for (reg = 0x00; reg < ak->total_regs; reg++)
                 if (reg != 0x01)
                         snd_akm4xxx_write(ak, 0, reg,
                                           snd_akm4xxx_get(ak, 0, reg));
@@ -91,12 +87,11 @@ static void ak4381_reset(struct snd_akm4xxx *ak, int state)
 {
         unsigned int chip;
         unsigned char reg;
-
         for (chip = 0; chip < ak->num_dacs/2; chip++) {
                 snd_akm4xxx_write(ak, chip, 0x00, state ? 0x0c : 0x0f);
                 if (state)
                         continue;
-                for (reg = 0x01; reg < 0x05; reg++)
+                for (reg = 0x01; reg < ak->total_regs; reg++)
                         snd_akm4xxx_write(ak, chip, reg,
                                           snd_akm4xxx_get(ak, chip, reg));
         }
@@ -113,16 +108,17 @@ void snd_akm4xxx_reset(struct snd_akm4xxx *ak, int state)
         switch (ak->type) {
         case SND_AK4524:
         case SND_AK4528:
+        case SND_AK4620:
                 ak4524_reset(ak, state);
                 break;
         case SND_AK4529:
                 /* FIXME: needed for ak4529? */
                 break;
         case SND_AK4355:
-                ak435X_reset(ak, state, 0x0b);
+                ak435X_reset(ak, state);
                 break;
         case SND_AK4358:
-                ak435X_reset(ak, state, 0x10);
+                ak435X_reset(ak, state);
                 break;
         case SND_AK4381:
                 ak4381_reset(ak, state);
@@ -139,7 +135,7 @@ EXPORT_SYMBOL(snd_akm4xxx_reset);
  * Volume conversion table for non-linear volumes
  * from -63.5dB (mute) to 0dB step 0.5dB
  *
- * Used for AK4524 input/ouput attenuation, AK4528, and
+ * Used for AK4524/AK4620 input/ouput attenuation, AK4528, and
  * AK5365 input attenuation
  */
 static const unsigned char vol_cvt_datt[128] = {
@@ -259,8 +255,22 @@ void snd_akm4xxx_init(struct snd_akm4xxx *ak)
                 0x00, 0x0f, /* 0: power-up, un-reset */
                 0xff, 0xff
         };
+        static const unsigned char inits_ak4620[] = {
+                0x00, 0x07, /* 0: normal */
+                0x01, 0x00, /* 0: reset */
+                0x01, 0x02, /* 1: RSTAD */
+                0x01, 0x03, /* 1: RSTDA */
+                0x01, 0x0f, /* 1: normal */
+                0x02, 0x60, /* 2: 24bit I2S */
+                0x03, 0x01, /* 3: deemphasis off */
+                0x04, 0x00, /* 4: LIN muted */
+                0x05, 0x00, /* 5: RIN muted */
+                0x06, 0x00, /* 6: LOUT muted */
+                0x07, 0x00, /* 7: ROUT muted */
+                0xff, 0xff
+        };
 
-        int chip, num_chips;
+        int chip;
         const unsigned char *ptr, *inits;
         unsigned char reg, data;
 
@@ -270,42 +280,64 @@ void snd_akm4xxx_init(struct snd_akm4xxx *ak)
         switch (ak->type) {
         case SND_AK4524:
                 inits = inits_ak4524;
-                num_chips = ak->num_dacs / 2;
+                ak->num_chips = ak->num_dacs / 2;
+                ak->name = "ak4524";
+                ak->total_regs = 0x08;
                 break;
         case SND_AK4528:
                 inits = inits_ak4528;
-                num_chips = ak->num_dacs / 2;
+                ak->num_chips = ak->num_dacs / 2;
+                ak->name = "ak4528";
+                ak->total_regs = 0x06;
                 break;
         case SND_AK4529:
                 inits = inits_ak4529;
-                num_chips = 1;
+                ak->num_chips = 1;
+                ak->name = "ak4529";
+                ak->total_regs = 0x0d;
                 break;
         case SND_AK4355:
                 inits = inits_ak4355;
-                num_chips = 1;
+                ak->num_chips = 1;
+                ak->name = "ak4355";
+                ak->total_regs = 0x0b;
                 break;
         case SND_AK4358:
                 inits = inits_ak4358;
-                num_chips = 1;
+                ak->num_chips = 1;
+                ak->name = "ak4358";
+                ak->total_regs = 0x10;
                 break;
         case SND_AK4381:
                 inits = inits_ak4381;
-                num_chips = ak->num_dacs / 2;
+                ak->num_chips = ak->num_dacs / 2;
+                ak->name = "ak4381";
+                ak->total_regs = 0x05;
                 break;
         case SND_AK5365:
                 /* FIXME: any init sequence? */
+                ak->num_chips = 1;
+                ak->name = "ak5365";
+                ak->total_regs = 0x08;
                 return;
+        case SND_AK4620:
+                inits = inits_ak4620;
+                ak->num_chips = ak->num_dacs / 2;
+                ak->name = "ak4620";
+                ak->total_regs = 0x08;
+                break;
         default:
                 snd_BUG();
                 return;
         }
 
-        for (chip = 0; chip < num_chips; chip++) {
+        for (chip = 0; chip < ak->num_chips; chip++) {
                 ptr = inits;
                 while (*ptr != 0xff) {
                         reg = *ptr++;
                         data = *ptr++;
                         snd_akm4xxx_write(ak, chip, reg, data);
+                        udelay(10);
                 }
         }
 }
@@ -688,6 +720,12 @@ static int build_dac_controls(struct snd_akm4xxx *ak)
                                 AK_COMPOSE(idx/2, (idx%2) + 3, 0, 255);
                         knew.tlv.p = db_scale_linear;
                         break;
+                case SND_AK4620:
+                        /* register 6 & 7 */
+                        knew.private_value =
+                                AK_COMPOSE(idx/2, (idx%2) + 6, 0, 255);
+                        knew.tlv.p = db_scale_linear;
+                        break;
                 default:
                         return -EINVAL;
                 }
@@ -704,10 +742,12 @@ static int build_dac_controls(struct snd_akm4xxx *ak)
 
 static int build_adc_controls(struct snd_akm4xxx *ak)
 {
-        int idx, err, mixer_ch, num_stereo;
+        int idx, err, mixer_ch, num_stereo, max_steps;
         struct snd_kcontrol_new knew;
 
         mixer_ch = 0;
+        if (ak->type == SND_AK4528)
+                return 0;       /* no controls */
         for (idx = 0; idx < ak->num_adcs;) {
                 memset(&knew, 0, sizeof(knew));
                 if (! ak->adc_info || ! ak->adc_info[mixer_ch].name) {
@@ -733,13 +773,12 @@ static int build_adc_controls(struct snd_akm4xxx *ak)
                 }
                 /* register 4 & 5 */
                 if (ak->type == SND_AK5365)
-                        knew.private_value =
-                                AK_COMPOSE(idx/2, (idx%2) + 4, 0, 151) |
-                                AK_VOL_CVT | AK_IPGA;
+                        max_steps = 152;
                 else
-                        knew.private_value =
-                                AK_COMPOSE(idx/2, (idx%2) + 4, 0, 163) |
-                                AK_VOL_CVT | AK_IPGA;
+                        max_steps = 164;
+                knew.private_value =
+                        AK_COMPOSE(idx/2, (idx%2) + 4, 0, max_steps) |
+                        AK_VOL_CVT | AK_IPGA;
                 knew.tlv.p = db_scale_vol_datt;
                 err = snd_ctl_add(ak->card, snd_ctl_new1(&knew, ak));
                 if (err < 0)
@@ -808,6 +847,7 @@ static int build_deemphasis(struct snd_akm4xxx *ak, int num_emphs)
                 switch (ak->type) {
                 case SND_AK4524:
                 case SND_AK4528:
+                case SND_AK4620:
                         /* register 3 */
                         knew.private_value = AK_COMPOSE(idx, 3, 0, 0);
                         break;
@@ -834,6 +874,35 @@ static int build_deemphasis(struct snd_akm4xxx *ak, int num_emphs)
         return 0;
 }
 
+#ifdef CONFIG_PROC_FS
+static void proc_regs_read(struct snd_info_entry *entry,
+                struct snd_info_buffer *buffer)
+{
+        struct snd_akm4xxx *ak = (struct snd_akm4xxx *)entry->private_data;
+        int reg, val, chip;
+        for (chip = 0; chip < ak->num_chips; chip++) {
+                for (reg = 0; reg < ak->total_regs; reg++) {
+                        val =  snd_akm4xxx_get(ak, chip, reg);
+                        snd_iprintf(buffer, "chip %d: 0x%02x = 0x%02x\n", chip,
+                                        reg, val);
+                }
+        }
+}
+
+static int proc_init(struct snd_akm4xxx *ak)
+{
+        struct snd_info_entry *entry;
+        int err;
+        err = snd_card_proc_new(ak->card, ak->name, &entry);
+        if (err < 0)
+                return err;
+        snd_info_set_text_ops(entry, ak, proc_regs_read);
+        return 0;
+}
+#else /* !CONFIG_PROC_FS */
+static int proc_init(struct snd_akm4xxx *ak) {}
+#endif
+
 int snd_akm4xxx_build_controls(struct snd_akm4xxx *ak)
 {
         int err, num_emphs;
@@ -845,18 +914,21 @@ int snd_akm4xxx_build_controls(struct snd_akm4xxx *ak)
         err = build_adc_controls(ak);
         if (err < 0)
                 return err;
-
         if (ak->type == SND_AK4355 || ak->type == SND_AK4358)
                 num_emphs = 1;
+        else if (ak->type == SND_AK4620)
+                num_emphs = 0;
         else
                 num_emphs = ak->num_dacs / 2;
         err = build_deemphasis(ak, num_emphs);
         if (err < 0)
                 return err;
+        err = proc_init(ak);
+        if (err < 0)
+                return err;
 
         return 0;
 }
-        
 EXPORT_SYMBOL(snd_akm4xxx_build_controls);
 
 static int __init alsa_akm4xxx_module_init(void)
diff --git a/sound/i2c/other/tea575x-tuner.c b/sound/i2c/other/tea575x-tuner.c
index d31c373e076d..ee538f1ae846 100644
--- a/sound/i2c/other/tea575x-tuner.c
+++ b/sound/i2c/other/tea575x-tuner.c
@@ -24,6 +24,7 @@
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <linux/version.h>
 #include <sound/core.h>
 #include <sound/tea575x-tuner.h>
@@ -225,7 +226,7 @@ static int vidioc_s_ctrl(struct file *file, void *priv,
         case V4L2_CID_AUDIO_MUTE:
                 if (tea->ops->mute) {
                         tea->ops->mute(tea, ctrl->value);
-                        tea->mute = 1;
+                        tea->mute = ctrl->value;
                         return 0;
                 }
         }
diff --git a/sound/isa/Kconfig b/sound/isa/Kconfig
index 51a7e3777e17..755a0a5f0e3f 100644
--- a/sound/isa/Kconfig
+++ b/sound/isa/Kconfig
@@ -63,15 +63,16 @@ config SND_AD1848
           will be called snd-ad1848.
 
 config SND_ALS100
-        tristate "Avance Logic ALS100/ALS120"
+        tristate "Diamond Tech. DT-019x and Avance Logic ALSxxx"
         depends on PNP
         select ISAPNP
         select SND_OPL3_LIB
         select SND_MPU401_UART
         select SND_SB16_DSP
         help
-          Say Y here to include support for soundcards based on Avance
-          Logic ALS100, ALS110, ALS120 and ALS200 chips.
+          Say Y here to include support for soundcards based on the
+          Diamond Technologies DT-019X or Avance Logic chips: ALS007,
+          ALS100, ALS110, ALS120 and ALS200 chips.
 
           To compile this driver as a module, choose M here: the module
           will be called snd-als100.
@@ -127,20 +128,6 @@ config SND_CS4236
           To compile this driver as a module, choose M here: the module
           will be called snd-cs4236.
 
-config SND_DT019X
-        tristate "Diamond Technologies DT-019X, Avance Logic ALS-007"
-        depends on PNP
-        select ISAPNP
-        select SND_OPL3_LIB
-        select SND_MPU401_UART
-        select SND_SB16_DSP
-        help
-          Say Y here to include support for soundcards based on the
-          Diamond Technologies DT-019X or Avance Logic ALS-007 chips.
-
-          To compile this driver as a module, choose M here: the module
-          will be called snd-dt019x.
-
 config SND_ES968
         tristate "Generic ESS ES968 driver"
         depends on PNP
@@ -252,6 +239,22 @@ config SND_INTERWAVE_STB
           To compile this driver as a module, choose M here: the module
           will be called snd-interwave-stb.
 
+config SND_JAZZ16
+        tristate "Media Vision Jazz16 card and compatibles"
+        select SND_OPL3_LIB
+        select SND_MPU401_UART
+        select SND_SB8_DSP
+        help
+          Say Y here to include support for soundcards based on the
+          Media Vision Jazz16 chipset: digital chip MVD1216 (Jazz16),
+          codec MVA416 (CS4216) and mixer MVA514 (ICS2514).
+          Media Vision's Jazz16 cards were sold under names Pro Sonic 16,
+          Premium 3-D and Pro 3-D. There were also OEMs cards with the
+          Jazz16 chipset.
+
+          To compile this driver as a module, choose M here: the module
+          will be called snd-jazz16.
+
 config SND_OPL3SA2
         tristate "Yamaha OPL3-SA2/SA3"
         select SND_OPL3_LIB
@@ -372,15 +375,21 @@ config SND_SGALAXY
 
 config SND_SSCAPE
         tristate "Ensoniq SoundScape driver"
-        select SND_HWDEP
         select SND_MPU401_UART
         select SND_WSS_LIB
+        select FW_LOADER
         help
           Say Y here to include support for Ensoniq SoundScape 
-          soundcards.
+          and Ensoniq OEM soundcards.
 
           The PCM audio is supported on SoundScape Classic, Elite, PnP
-          and VIVO cards. The MIDI support is very experimental.
+          and VIVO cards. The supported OEM cards are SPEA Media FX and
+          Reveal SC-600.
+          The MIDI support is very experimental and requires binary
+          firmware files called "scope.cod" and "sndscape.co?" where the
+          ? is digit 0, 1, 2, 3 or 4. The firmware files can be found
+          in DOS or Windows driver packages. One has to put the firmware
+          files into the /lib/firmware directory.
 
           To compile this driver as a module, choose M here: the module
           will be called snd-sscape.
diff --git a/sound/isa/Makefile b/sound/isa/Makefile
index b906b9a1a81e..c73d30c4f462 100644
--- a/sound/isa/Makefile
+++ b/sound/isa/Makefile
@@ -7,7 +7,6 @@ snd-adlib-objs := adlib.o
 snd-als100-objs := als100.o
 snd-azt2320-objs := azt2320.o
 snd-cmi8330-objs := cmi8330.o
-snd-dt019x-objs := dt019x.o
 snd-es18xx-objs := es18xx.o
 snd-opl3sa2-objs := opl3sa2.o
 snd-sc6000-objs := sc6000.o
@@ -19,7 +18,6 @@ obj-$(CONFIG_SND_ADLIB) += snd-adlib.o
 obj-$(CONFIG_SND_ALS100) += snd-als100.o
 obj-$(CONFIG_SND_AZT2320) += snd-azt2320.o
 obj-$(CONFIG_SND_CMI8330) += snd-cmi8330.o
-obj-$(CONFIG_SND_DT019X) += snd-dt019x.o
 obj-$(CONFIG_SND_ES18XX) += snd-es18xx.o
 obj-$(CONFIG_SND_OPL3SA2) += snd-opl3sa2.o
 obj-$(CONFIG_SND_SC6000) += snd-sc6000.o
diff --git a/sound/isa/als100.c b/sound/isa/als100.c
index 5fd52e4d7079..20becc89f6f6 100644
--- a/sound/isa/als100.c
+++ b/sound/isa/als100.c
@@ -2,9 +2,13 @@
 /*
     card-als100.c - driver for Avance Logic ALS100 based soundcards.
     Copyright (C) 1999-2000 by Massimo Piccioni <dafastidio@libero.it>
+    Copyright (C) 1999-2002 by Massimo Piccioni <dafastidio@libero.it>
 
     Thanks to Pierfrancesco 'qM2' Passerini.
 
+    Generalised for soundcards based on DT-0196 and ALS-007 chips
+    by Jonathan Woithe <jwoithe@physics.adelaide.edu.au>: June 2002.
+
     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
     the Free Software Foundation; either version 2 of the License, or
@@ -33,10 +37,10 @@
 
 #define PFX "als100: "
 
-MODULE_AUTHOR("Massimo Piccioni <dafastidio@libero.it>");
-MODULE_DESCRIPTION("Avance Logic ALS1X0");
-MODULE_LICENSE("GPL");
-MODULE_SUPPORTED_DEVICE("{{Avance Logic,ALS100 - PRO16PNP},"
+MODULE_DESCRIPTION("Avance Logic ALS007/ALS1X0");
+MODULE_SUPPORTED_DEVICE("{{Diamond Technologies DT-019X},"
+                "{Avance Logic ALS-007}}"
+                "{{Avance Logic,ALS100 - PRO16PNP},"
                 "{Avance Logic,ALS110},"
                 "{Avance Logic,ALS120},"
                 "{Avance Logic,ALS200},"
@@ -45,9 +49,12 @@ MODULE_SUPPORTED_DEVICE("{{Avance Logic,ALS100 - PRO16PNP},"
                 "{Avance Logic,ALS120},"
                 "{RTL,RTL3000}}");
 
+MODULE_AUTHOR("Massimo Piccioni <dafastidio@libero.it>");
+MODULE_LICENSE("GPL");
+
 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
-static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_ISAPNP; /* Enable this card */
+static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE;  /* Enable this card */
 static long port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;     /* PnP setup */
 static long mpu_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; /* PnP setup */
 static long fm_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;  /* PnP setup */
@@ -57,14 +64,15 @@ static int dma8[SNDRV_CARDS] = SNDRV_DEFAULT_DMA;	/* PnP setup */
 static int dma16[SNDRV_CARDS] = SNDRV_DEFAULT_DMA;      /* PnP setup */
 
 module_param_array(index, int, NULL, 0444);
-MODULE_PARM_DESC(index, "Index value for als100 based soundcard.");
+MODULE_PARM_DESC(index, "Index value for Avance Logic based soundcard.");
 module_param_array(id, charp, NULL, 0444);
-MODULE_PARM_DESC(id, "ID string for als100 based soundcard.");
+MODULE_PARM_DESC(id, "ID string for Avance Logic based soundcard.");
 module_param_array(enable, bool, NULL, 0444);
-MODULE_PARM_DESC(enable, "Enable als100 based soundcard.");
+MODULE_PARM_DESC(enable, "Enable Avance Logic based soundcard.");
+
+MODULE_ALIAS("snd-dt019x");
 
 struct snd_card_als100 {
-        int dev_no;
         struct pnp_dev *dev;
         struct pnp_dev *devmpu;
         struct pnp_dev *devopl;
@@ -72,25 +80,43 @@ struct snd_card_als100 {
 };
 
 static struct pnp_card_device_id snd_als100_pnpids[] = {
+        /* DT197A30 */
+        { .id = "RWB1688",
+          .devs = { { "@@@0001" }, { "@X@0001" }, { "@H@0001" } },
+          .driver_data = SB_HW_DT019X },
+        /* DT0196 / ALS-007 */
+        { .id = "ALS0007",
+          .devs = { { "@@@0001" }, { "@X@0001" }, { "@H@0001" } },
+          .driver_data = SB_HW_DT019X },
         /* ALS100 - PRO16PNP */
-        { .id = "ALS0001", .devs = { { "@@@0001" }, { "@X@0001" }, { "@H@0001" } } },
+        { .id = "ALS0001",
+          .devs = { { "@@@0001" }, { "@X@0001" }, { "@H@0001" } },
+          .driver_data = SB_HW_ALS100 },
         /* ALS110 - MF1000 - Digimate 3D Sound */
-        { .id = "ALS0110", .devs = { { "@@@1001" }, { "@X@1001" }, { "@H@1001" } } },
+        { .id = "ALS0110",
+          .devs = { { "@@@1001" }, { "@X@1001" }, { "@H@1001" } },
+          .driver_data = SB_HW_ALS100 },
         /* ALS120 */
-        { .id = "ALS0120", .devs = { { "@@@2001" }, { "@X@2001" }, { "@H@2001" } } },
+        { .id = "ALS0120",
+          .devs = { { "@@@2001" }, { "@X@2001" }, { "@H@2001" } },
+          .driver_data = SB_HW_ALS100 },
         /* ALS200 */
-        { .id = "ALS0200", .devs = { { "@@@0020" }, { "@X@0020" }, { "@H@0001" } } },
+        { .id = "ALS0200",
+          .devs = { { "@@@0020" }, { "@X@0020" }, { "@H@0001" } },
+          .driver_data = SB_HW_ALS100 },
         /* ALS200 OEM */
-        { .id = "ALS0200", .devs = { { "@@@0020" }, { "@X@0020" }, { "@H@0020" } } },
+        { .id = "ALS0200",
+          .devs = { { "@@@0020" }, { "@X@0020" }, { "@H@0020" } },
+          .driver_data = SB_HW_ALS100 },
         /* RTL3000 */
-        { .id = "RTL3000", .devs = { { "@@@2001" }, { "@X@2001" }, { "@H@2001" } } },
-        { .id = "", } /* end */
+        { .id = "RTL3000",
+          .devs = { { "@@@2001" }, { "@X@2001" }, { "@H@2001" } },
+          .driver_data = SB_HW_ALS100 },
+        { .id = "" } /* end */
 };
 
 MODULE_DEVICE_TABLE(pnp_card, snd_als100_pnpids);
 
-#define DRIVER_NAME     "snd-card-als100"
-
 static int __devinit snd_card_als100_pnp(int dev, struct snd_card_als100 *acard,
                                          struct pnp_card_link *card,
                                          const struct pnp_card_device_id *id)
@@ -113,8 +139,12 @@ static int __devinit snd_card_als100_pnp(int dev, struct snd_card_als100 *acard,
                 return err;
         }
         port[dev] = pnp_port_start(pdev, 0);
-        dma8[dev] = pnp_dma(pdev, 1);
-        dma16[dev] = pnp_dma(pdev, 0);
+        if (id->driver_data == SB_HW_DT019X)
+                dma8[dev] = pnp_dma(pdev, 0);
+        else {
+                dma8[dev] = pnp_dma(pdev, 1);
+                dma16[dev] = pnp_dma(pdev, 0);
+        }
         irq[dev] = pnp_irq(pdev, 0);
 
         pdev = acard->devmpu;
@@ -175,22 +205,33 @@ static int __devinit snd_card_als100_probe(int dev,
         }
         snd_card_set_dev(card, &pcard->card->dev);
 
-        if ((error = snd_sbdsp_create(card, port[dev],
-                                      irq[dev],
-                                      snd_sb16dsp_interrupt,
-                                      dma8[dev],
-                                      dma16[dev],
-                                      SB_HW_ALS100, &chip)) < 0) {
+        if (pid->driver_data == SB_HW_DT019X)
+                dma16[dev] = -1;
+
+        error = snd_sbdsp_create(card, port[dev], irq[dev],
+                                  snd_sb16dsp_interrupt,
+                                  dma8[dev], dma16[dev],
+                                  pid->driver_data,
+                                  &chip);
+        if (error < 0) {
                 snd_card_free(card);
                 return error;
         }
         acard->chip = chip;
 
-        strcpy(card->driver, "ALS100");
-        strcpy(card->shortname, "Avance Logic ALS100");
-        sprintf(card->longname, "%s, %s at 0x%lx, irq %d, dma %d&%d",
-                card->shortname, chip->name, chip->port,
-                irq[dev], dma8[dev], dma16[dev]);
+        if (pid->driver_data == SB_HW_DT019X) {
+                strcpy(card->driver, "DT-019X");
+                strcpy(card->shortname, "Diamond Tech. DT-019X");
+                sprintf(card->longname, "%s, %s at 0x%lx, irq %d, dma %d",
+                        card->shortname, chip->name, chip->port,
+                        irq[dev], dma8[dev]);
+        } else {
+                strcpy(card->driver, "ALS100");
+                strcpy(card->shortname, "Avance Logic ALS100");
+                sprintf(card->longname, "%s, %s at 0x%lx, irq %d, dma %d&%d",
+                        card->shortname, chip->name, chip->port,
+                        irq[dev], dma8[dev], dma16[dev]);
+        }
 
         if ((error = snd_sb16dsp_pcm(chip, 0, NULL)) < 0) {
                 snd_card_free(card);
@@ -203,9 +244,19 @@ static int __devinit snd_card_als100_probe(int dev,
         }
 
         if (mpu_port[dev] > 0 && mpu_port[dev] != SNDRV_AUTO_PORT) {
-                if (snd_mpu401_uart_new(card, 0, MPU401_HW_ALS100,
+                int mpu_type = MPU401_HW_ALS100;
+
+                if (mpu_irq[dev] == SNDRV_AUTO_IRQ)
+                        mpu_irq[dev] = -1;
+
+                if (pid->driver_data == SB_HW_DT019X)
+                        mpu_type = MPU401_HW_MPU401;
+
+                if (snd_mpu401_uart_new(card, 0,
+                                        mpu_type,
                                         mpu_port[dev], 0, 
-                                        mpu_irq[dev], IRQF_DISABLED,
+                                        mpu_irq[dev],
+                                        mpu_irq[dev] >= 0 ? IRQF_DISABLED : 0,
                                         NULL) < 0)
                         snd_printk(KERN_ERR PFX "no MPU-401 device at 0x%lx\n", mpu_port[dev]);
         }
@@ -291,7 +342,7 @@ static int snd_als100_pnp_resume(struct pnp_card_link *pcard)
 
 static struct pnp_card_driver als100_pnpc_driver = {
         .flags          = PNP_DRIVER_RES_DISABLE,
-        .name           = "als100",
+        .name           = "als100",
         .id_table       = snd_als100_pnpids,
         .probe          = snd_als100_pnp_detect,
         .remove         = __devexit_p(snd_als100_pnp_remove),
@@ -312,7 +363,7 @@ static int __init alsa_card_als100_init(void)
         if (!als100_devices) {
                 pnp_unregister_card_driver(&als100_pnpc_driver);
 #ifdef MODULE
-                snd_printk(KERN_ERR "no ALS100 based soundcards found\n");
+                snd_printk(KERN_ERR "no Avance Logic based soundcards found\n");
 #endif
                 return -ENODEV;
         }
diff --git a/sound/isa/cmi8330.c b/sound/isa/cmi8330.c
index 02f79d252718..fe79a169acb5 100644
--- a/sound/isa/cmi8330.c
+++ b/sound/isa/cmi8330.c
@@ -46,7 +46,6 @@
 #include <linux/init.h>
 #include <linux/err.h>
 #include <linux/isa.h>
-#include <linux/slab.h>
 #include <linux/pnp.h>
 #include <linux/moduleparam.h>
 #include <sound/core.h>
@@ -237,7 +236,7 @@ WSS_DOUBLE("Wavetable Capture Volume", 0,
                 CMI8330_WAVGAIN, CMI8330_WAVGAIN, 4, 0, 15, 0),
 WSS_SINGLE("3D Control - Switch", 0,
                 CMI8330_RMUX3D, 5, 1, 1),
-WSS_SINGLE("PC Speaker Playback Volume", 0,
+WSS_SINGLE("Beep Playback Volume", 0,
                 CMI8330_OUTPUTVOL, 3, 3, 0),
 WSS_DOUBLE("FM Playback Switch", 0,
                 CS4231_AUX2_LEFT_INPUT, CS4231_AUX2_RIGHT_INPUT, 7, 7, 1, 1),
@@ -262,7 +261,7 @@ SB_DOUBLE("SB Line Playback Switch", SB_DSP4_OUTPUT_SW, SB_DSP4_OUTPUT_SW, 4, 3,
 SB_DOUBLE("SB Line Playback Volume", SB_DSP4_LINE_DEV, (SB_DSP4_LINE_DEV + 1), 3, 3, 31),
 SB_SINGLE("SB Mic Playback Switch", SB_DSP4_OUTPUT_SW, 0, 1),
 SB_SINGLE("SB Mic Playback Volume", SB_DSP4_MIC_DEV, 3, 31),
-SB_SINGLE("SB PC Speaker Volume", SB_DSP4_SPEAKER_DEV, 6, 3),
+SB_SINGLE("SB Beep Volume", SB_DSP4_SPEAKER_DEV, 6, 3),
 SB_DOUBLE("SB Capture Volume", SB_DSP4_IGAIN_DEV, (SB_DSP4_IGAIN_DEV + 1), 6, 6, 3),
 SB_DOUBLE("SB Playback Volume", SB_DSP4_OGAIN_DEV, (SB_DSP4_OGAIN_DEV + 1), 6, 6, 3),
 SB_SINGLE("SB Mic Auto Gain", SB_DSP4_MIC_AGC, 0, 1),
diff --git a/sound/isa/cs423x/cs4236.c b/sound/isa/cs423x/cs4236.c
index a076a6ce8071..999dc1e0fdbd 100644
--- a/sound/isa/cs423x/cs4236.c
+++ b/sound/isa/cs423x/cs4236.c
@@ -22,7 +22,6 @@
 #include <linux/init.h>
 #include <linux/err.h>
 #include <linux/isa.h>
-#include <linux/slab.h>
 #include <linux/pnp.h>
 #include <linux/moduleparam.h>
 #include <sound/core.h>
@@ -177,7 +176,7 @@ static struct pnp_card_device_id snd_cs423x_pnpids[] = {
         { .id = "CSC0437", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
         /* Digital PC 5000 Onboard - CS4236B */
         { .id = "CSC0735", .devs = { { "CSC0000" }, { "CSC0010" } } },
-        /* some uknown CS4236B */
+        /* some unknown CS4236B */
         { .id = "CSC0b35", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
         /* Intel PR440FX Onboard sound */
         { .id = "CSC0b36", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
@@ -394,21 +393,15 @@ static int __devinit snd_cs423x_probe(struct snd_card *card, int dev)
                         return -EBUSY;
                 }
 
-        err = snd_wss_create(card, port[dev], cport[dev],
+        err = snd_cs4236_create(card, port[dev], cport[dev],
                              irq[dev],
                              dma1[dev], dma2[dev],
                              WSS_HW_DETECT3, 0, &chip);
         if (err < 0)
                 return err;
+
+        acard->chip = chip;
         if (chip->hardware & WSS_HW_CS4236B_MASK) {
-                snd_wss_free(chip);
-                err = snd_cs4236_create(card,
-                                        port[dev], cport[dev],
-                                        irq[dev], dma1[dev], dma2[dev],
-                                        WSS_HW_DETECT, 0, &chip);
-                if (err < 0)
-                        return err;
-                acard->chip = chip;
 
                 err = snd_cs4236_pcm(chip, 0, &pcm);
                 if (err < 0)
@@ -418,7 +411,6 @@ static int __devinit snd_cs423x_probe(struct snd_card *card, int dev)
                 if (err < 0)
                         return err;
         } else {
-                acard->chip = chip;
                 err = snd_wss_pcm(chip, 0, &pcm);
                 if (err < 0)
                         return err;
diff --git a/sound/isa/cs423x/cs4236_lib.c b/sound/isa/cs423x/cs4236_lib.c
index 38835f31298b..c5adca300632 100644
--- a/sound/isa/cs423x/cs4236_lib.c
+++ b/sound/isa/cs423x/cs4236_lib.c
@@ -87,6 +87,8 @@
 #include <sound/core.h>
 #include <sound/wss.h>
 #include <sound/asoundef.h>
+#include <sound/initval.h>
+#include <sound/tlv.h>
 
 /*
  *
@@ -264,7 +266,10 @@ static void snd_cs4236_resume(struct snd_wss *chip)
 }
 
 #endif /* CONFIG_PM */
-
+/*
+ * This function does no fail if the chip is not CS4236B or compatible.
+ * It just an equivalent to the snd_wss_create() then.
+ */
 int snd_cs4236_create(struct snd_card *card,
                       unsigned long port,
                       unsigned long cport,
@@ -281,21 +286,17 @@ int snd_cs4236_create(struct snd_card *card,
         *rchip = NULL;
         if (hardware == WSS_HW_DETECT)
                 hardware = WSS_HW_DETECT3;
-        if (cport < 0x100) {
-                snd_printk(KERN_ERR "please, specify control port "
-                           "for CS4236+ chips\n");
-                return -ENODEV;
-        }
+
         err = snd_wss_create(card, port, cport,
                              irq, dma1, dma2, hardware, hwshare, &chip);
         if (err < 0)
                 return err;
 
-        if (!(chip->hardware & WSS_HW_CS4236B_MASK)) {
-                snd_printk(KERN_ERR "CS4236+: MODE3 and extended registers "
-                           "not available, hardware=0x%x\n", chip->hardware);
-                snd_device_free(card, chip);
-                return -ENODEV;
+        if ((chip->hardware & WSS_HW_CS4236B_MASK) == 0) {
+                snd_printd("chip is not CS4236+, hardware=0x%x\n",
+                           chip->hardware);
+                *rchip = chip;
+                return 0;
         }
 #if 0
         {
@@ -308,9 +309,16 @@ int snd_cs4236_create(struct snd_card *card,
                                    idx, snd_cs4236_ctrl_in(chip, idx));
         }
 #endif
+        if (cport < 0x100 || cport == SNDRV_AUTO_PORT) {
+                snd_printk(KERN_ERR "please, specify control port "
+                           "for CS4236+ chips\n");
+                snd_device_free(card, chip);
+                return -ENODEV;
+        }
         ver1 = snd_cs4236_ctrl_in(chip, 1);
         ver2 = snd_cs4236_ext_in(chip, CS4236_VERSION);
-        snd_printdd("CS4236: [0x%lx] C1 (version) = 0x%x, ext = 0x%x\n", cport, ver1, ver2);
+        snd_printdd("CS4236: [0x%lx] C1 (version) = 0x%x, ext = 0x%x\n",
+                        cport, ver1, ver2);
         if (ver1 != ver2) {
                 snd_printk(KERN_ERR "CS4236+ chip detected, but "
                            "control port 0x%lx is not valid\n", cport);
@@ -321,13 +329,17 @@ int snd_cs4236_create(struct snd_card *card,
         snd_cs4236_ctrl_out(chip, 2, 0xff);
         snd_cs4236_ctrl_out(chip, 3, 0x00);
         snd_cs4236_ctrl_out(chip, 4, 0x80);
-        snd_cs4236_ctrl_out(chip, 5, ((IEC958_AES1_CON_PCM_CODER & 3) << 6) | IEC958_AES0_CON_EMPHASIS_NONE);
+        reg = ((IEC958_AES1_CON_PCM_CODER & 3) << 6) |
+              IEC958_AES0_CON_EMPHASIS_NONE;
+        snd_cs4236_ctrl_out(chip, 5, reg);
         snd_cs4236_ctrl_out(chip, 6, IEC958_AES1_CON_PCM_CODER >> 2);
         snd_cs4236_ctrl_out(chip, 7, 0x00);
-        /* 0x8c for C8 is valid for Turtle Beach Malibu - the IEC-958 output */
-        /* is working with this setup, other hardware should have */
-        /* different signal paths and this value should be selectable */
-        /* in the future */
+        /*
+         * 0x8c for C8 is valid for Turtle Beach Malibu - the IEC-958
+         * output is working with this setup, other hardware should
+         * have different signal paths and this value should be
+         * selectable in the future
+         */
         snd_cs4236_ctrl_out(chip, 8, 0x8c);
         chip->rate_constraint = snd_cs4236_xrate;
         chip->set_playback_format = snd_cs4236_playback_format;
@@ -339,9 +351,10 @@ int snd_cs4236_create(struct snd_card *card,
 
         /* initialize extended registers */
         for (reg = 0; reg < sizeof(snd_cs4236_ext_map); reg++)
-                snd_cs4236_ext_out(chip, CS4236_I23VAL(reg), snd_cs4236_ext_map[reg]);
+                snd_cs4236_ext_out(chip, CS4236_I23VAL(reg),
+                                   snd_cs4236_ext_map[reg]);
 
-        /* initialize compatible but more featured registers */
+        /* initialize compatible but more featured registers */
         snd_wss_out(chip, CS4231_LEFT_INPUT, 0x40);
         snd_wss_out(chip, CS4231_RIGHT_INPUT, 0x40);
         snd_wss_out(chip, CS4231_AUX1_LEFT_INPUT, 0xff);
@@ -387,6 +400,14 @@ int snd_cs4236_pcm(struct snd_wss *chip, int device, struct snd_pcm **rpcm)
   .get = snd_cs4236_get_single, .put = snd_cs4236_put_single, \
   .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24) }
 
+#define CS4236_SINGLE_TLV(xname, xindex, reg, shift, mask, invert, xtlv) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
+  .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ, \
+  .info = snd_cs4236_info_single, \
+  .get = snd_cs4236_get_single, .put = snd_cs4236_put_single, \
+  .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24), \
+  .tlv = { .p = (xtlv) } }
+
 static int snd_cs4236_info_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 {
         int mask = (kcontrol->private_value >> 16) & 0xff;
@@ -490,6 +511,16 @@ static int snd_cs4236_put_singlec(struct snd_kcontrol *kcontrol, struct snd_ctl_
   .get = snd_cs4236_get_double, .put = snd_cs4236_put_double, \
   .private_value = left_reg | (right_reg << 8) | (shift_left << 16) | (shift_right << 19) | (mask << 24) | (invert << 22) }
 
+#define CS4236_DOUBLE_TLV(xname, xindex, left_reg, right_reg, shift_left, \
+                          shift_right, mask, invert, xtlv) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
+  .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ, \
+  .info = snd_cs4236_info_double, \
+  .get = snd_cs4236_get_double, .put = snd_cs4236_put_double, \
+  .private_value = left_reg | (right_reg << 8) | (shift_left << 16) | \
+                   (shift_right << 19) | (mask << 24) | (invert << 22), \
+  .tlv = { .p = (xtlv) } }
+
 static int snd_cs4236_info_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 {
         int mask = (kcontrol->private_value >> 24) & 0xff;
@@ -560,12 +591,23 @@ static int snd_cs4236_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_e
         return change;
 }
 
-#define CS4236_DOUBLE1(xname, xindex, left_reg, right_reg, shift_left, shift_right, mask, invert) \
+#define CS4236_DOUBLE1(xname, xindex, left_reg, right_reg, shift_left, \
+                        shift_right, mask, invert) \
 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
   .info = snd_cs4236_info_double, \
   .get = snd_cs4236_get_double1, .put = snd_cs4236_put_double1, \
   .private_value = left_reg | (right_reg << 8) | (shift_left << 16) | (shift_right << 19) | (mask << 24) | (invert << 22) }
 
+#define CS4236_DOUBLE1_TLV(xname, xindex, left_reg, right_reg, shift_left, \
+                           shift_right, mask, invert, xtlv) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
+  .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ, \
+  .info = snd_cs4236_info_double, \
+  .get = snd_cs4236_get_double1, .put = snd_cs4236_put_double1, \
+  .private_value = left_reg | (right_reg << 8) | (shift_left << 16) | \
+                   (shift_right << 19) | (mask << 24) | (invert << 22), \
+  .tlv = { .p = (xtlv) } }
+
 static int snd_cs4236_get_double1(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
         struct snd_wss *chip = snd_kcontrol_chip(kcontrol);
@@ -619,16 +661,18 @@ static int snd_cs4236_put_double1(struct snd_kcontrol *kcontrol, struct snd_ctl_
         return change;
 }
 
-#define CS4236_MASTER_DIGITAL(xname, xindex) \
+#define CS4236_MASTER_DIGITAL(xname, xindex, xtlv) \
 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
+  .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ, \
   .info = snd_cs4236_info_double, \
   .get = snd_cs4236_get_master_digital, .put = snd_cs4236_put_master_digital, \
-  .private_value = 71 << 24 }
+  .private_value = 71 << 24, \
+  .tlv = { .p = (xtlv) } }
 
 static inline int snd_cs4236_mixer_master_digital_invert_volume(int vol)
 {
         return (vol < 64) ? 63 - vol : 64 + (71 - vol);
-}        
+}
 
 static int snd_cs4236_get_master_digital(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
@@ -661,11 +705,13 @@ static int snd_cs4236_put_master_digital(struct snd_kcontrol *kcontrol, struct s
         return change;
 }
 
-#define CS4235_OUTPUT_ACCU(xname, xindex) \
+#define CS4235_OUTPUT_ACCU(xname, xindex, xtlv) \
 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
+  .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ, \
   .info = snd_cs4236_info_double, \
   .get = snd_cs4235_get_output_accu, .put = snd_cs4235_put_output_accu, \
-  .private_value = 3 << 24 }
+  .private_value = 3 << 24, \
+  .tlv = { .p = (xtlv) } }
 
 static inline int snd_cs4235_mixer_output_accu_get_volume(int vol)
 {
@@ -720,41 +766,56 @@ static int snd_cs4235_put_output_accu(struct snd_kcontrol *kcontrol, struct snd_
         return change;
 }
 
+static const DECLARE_TLV_DB_SCALE(db_scale_7bit, -9450, 150, 0);
+static const DECLARE_TLV_DB_SCALE(db_scale_6bit, -9450, 150, 0);
+static const DECLARE_TLV_DB_SCALE(db_scale_6bit_12db_max, -8250, 150, 0);
+static const DECLARE_TLV_DB_SCALE(db_scale_5bit_12db_max, -3450, 150, 0);
+static const DECLARE_TLV_DB_SCALE(db_scale_5bit_22db_max, -2400, 150, 0);
+static const DECLARE_TLV_DB_SCALE(db_scale_4bit, -4500, 300, 0);
+static const DECLARE_TLV_DB_SCALE(db_scale_2bit, -1800, 600, 0);
+static const DECLARE_TLV_DB_SCALE(db_scale_rec_gain, 0, 150, 0);
+
 static struct snd_kcontrol_new snd_cs4236_controls[] = {
 
 CS4236_DOUBLE("Master Digital Playback Switch", 0,
                 CS4236_LEFT_MASTER, CS4236_RIGHT_MASTER, 7, 7, 1, 1),
 CS4236_DOUBLE("Master Digital Capture Switch", 0,
                 CS4236_DAC_MUTE, CS4236_DAC_MUTE, 7, 6, 1, 1),
-CS4236_MASTER_DIGITAL("Master Digital Volume", 0),
+CS4236_MASTER_DIGITAL("Master Digital Volume", 0, db_scale_7bit),
 
-CS4236_DOUBLE("Capture Boost Volume", 0,
-                CS4236_LEFT_MIX_CTRL, CS4236_RIGHT_MIX_CTRL, 5, 5, 3, 1),
+CS4236_DOUBLE_TLV("Capture Boost Volume", 0,
+                  CS4236_LEFT_MIX_CTRL, CS4236_RIGHT_MIX_CTRL, 5, 5, 3, 1,
+                  db_scale_2bit),
 
 WSS_DOUBLE("PCM Playback Switch", 0,
                 CS4231_LEFT_OUTPUT, CS4231_RIGHT_OUTPUT, 7, 7, 1, 1),
-WSS_DOUBLE("PCM Playback Volume", 0,
-                CS4231_LEFT_OUTPUT, CS4231_RIGHT_OUTPUT, 0, 0, 63, 1),
+WSS_DOUBLE_TLV("PCM Playback Volume", 0,
+                CS4231_LEFT_OUTPUT, CS4231_RIGHT_OUTPUT, 0, 0, 63, 1,
+                db_scale_6bit),
 
 CS4236_DOUBLE("DSP Playback Switch", 0,
                 CS4236_LEFT_DSP, CS4236_RIGHT_DSP, 7, 7, 1, 1),
-CS4236_DOUBLE("DSP Playback Volume", 0,
-                CS4236_LEFT_DSP, CS4236_RIGHT_DSP, 0, 0, 63, 1),
+CS4236_DOUBLE_TLV("DSP Playback Volume", 0,
+                  CS4236_LEFT_DSP, CS4236_RIGHT_DSP, 0, 0, 63, 1,
+                  db_scale_6bit),
 
 CS4236_DOUBLE("FM Playback Switch", 0,
                 CS4236_LEFT_FM, CS4236_RIGHT_FM, 7, 7, 1, 1),
-CS4236_DOUBLE("FM Playback Volume", 0,
-                CS4236_LEFT_FM, CS4236_RIGHT_FM, 0, 0, 63, 1),
+CS4236_DOUBLE_TLV("FM Playback Volume", 0,
+                  CS4236_LEFT_FM, CS4236_RIGHT_FM, 0, 0, 63, 1,
+                  db_scale_6bit),
 
 CS4236_DOUBLE("Wavetable Playback Switch", 0,
                 CS4236_LEFT_WAVE, CS4236_RIGHT_WAVE, 7, 7, 1, 1),
-CS4236_DOUBLE("Wavetable Playback Volume", 0,
-                CS4236_LEFT_WAVE, CS4236_RIGHT_WAVE, 0, 0, 63, 1),
+CS4236_DOUBLE_TLV("Wavetable Playback Volume", 0,
+                  CS4236_LEFT_WAVE, CS4236_RIGHT_WAVE, 0, 0, 63, 1,
+                  db_scale_6bit_12db_max),
 
 WSS_DOUBLE("Synth Playback Switch", 0,
                 CS4231_LEFT_LINE_IN, CS4231_RIGHT_LINE_IN, 7, 7, 1, 1),
-WSS_DOUBLE("Synth Volume", 0,
-                CS4231_LEFT_LINE_IN, CS4231_RIGHT_LINE_IN, 0, 0, 31, 1),
+WSS_DOUBLE_TLV("Synth Volume", 0,
+                CS4231_LEFT_LINE_IN, CS4231_RIGHT_LINE_IN, 0, 0, 31, 1,
+                db_scale_5bit_12db_max),
 WSS_DOUBLE("Synth Capture Switch", 0,
                 CS4231_LEFT_LINE_IN, CS4231_RIGHT_LINE_IN, 6, 6, 1, 1),
 WSS_DOUBLE("Synth Capture Bypass", 0,
@@ -764,14 +825,16 @@ CS4236_DOUBLE("Mic Playback Switch", 0,
                 CS4236_LEFT_MIC, CS4236_RIGHT_MIC, 6, 6, 1, 1),
 CS4236_DOUBLE("Mic Capture Switch", 0,
                 CS4236_LEFT_MIC, CS4236_RIGHT_MIC, 7, 7, 1, 1),
-CS4236_DOUBLE("Mic Volume", 0, CS4236_LEFT_MIC, CS4236_RIGHT_MIC, 0, 0, 31, 1),
-CS4236_DOUBLE("Mic Playback Boost", 0,
+CS4236_DOUBLE_TLV("Mic Volume", 0, CS4236_LEFT_MIC, CS4236_RIGHT_MIC,
+                  0, 0, 31, 1, db_scale_5bit_22db_max),
+CS4236_DOUBLE("Mic Playback Boost (+20dB)", 0,
                 CS4236_LEFT_MIC, CS4236_RIGHT_MIC, 5, 5, 1, 0),
 
 WSS_DOUBLE("Line Playback Switch", 0,
                 CS4231_AUX1_LEFT_INPUT, CS4231_AUX1_RIGHT_INPUT, 7, 7, 1, 1),
-WSS_DOUBLE("Line Volume", 0,
-                CS4231_AUX1_LEFT_INPUT, CS4231_AUX1_RIGHT_INPUT, 0, 0, 31, 1),
+WSS_DOUBLE_TLV("Line Volume", 0,
+                CS4231_AUX1_LEFT_INPUT, CS4231_AUX1_RIGHT_INPUT, 0, 0, 31, 1,
+                db_scale_5bit_12db_max),
 WSS_DOUBLE("Line Capture Switch", 0,
                 CS4231_AUX1_LEFT_INPUT, CS4231_AUX1_RIGHT_INPUT, 6, 6, 1, 1),
 WSS_DOUBLE("Line Capture Bypass", 0,
@@ -779,57 +842,63 @@ WSS_DOUBLE("Line Capture Bypass", 0,
 
 WSS_DOUBLE("CD Playback Switch", 0,
                 CS4231_AUX2_LEFT_INPUT, CS4231_AUX2_RIGHT_INPUT, 7, 7, 1, 1),
-WSS_DOUBLE("CD Volume", 0,
-                CS4231_AUX2_LEFT_INPUT, CS4231_AUX2_RIGHT_INPUT, 0, 0, 31, 1),
+WSS_DOUBLE_TLV("CD Volume", 0,
+                CS4231_AUX2_LEFT_INPUT, CS4231_AUX2_RIGHT_INPUT, 0, 0, 31, 1,
+                db_scale_5bit_12db_max),
 WSS_DOUBLE("CD Capture Switch", 0,
                 CS4231_AUX2_LEFT_INPUT, CS4231_AUX2_RIGHT_INPUT, 6, 6, 1, 1),
 
 CS4236_DOUBLE1("Mono Output Playback Switch", 0,
                 CS4231_MONO_CTRL, CS4236_RIGHT_MIX_CTRL, 6, 7, 1, 1),
-CS4236_DOUBLE1("Mono Playback Switch", 0,
+CS4236_DOUBLE1("Beep Playback Switch", 0,
                 CS4231_MONO_CTRL, CS4236_LEFT_MIX_CTRL, 7, 7, 1, 1),
-WSS_SINGLE("Mono Playback Volume", 0, CS4231_MONO_CTRL, 0, 15, 1),
-WSS_SINGLE("Mono Playback Bypass", 0, CS4231_MONO_CTRL, 5, 1, 0),
+WSS_SINGLE_TLV("Beep Playback Volume", 0, CS4231_MONO_CTRL, 0, 15, 1,
+                db_scale_4bit),
+WSS_SINGLE("Beep Bypass Playback Switch", 0, CS4231_MONO_CTRL, 5, 1, 0),
 
-WSS_DOUBLE("Capture Volume", 0,
-                CS4231_LEFT_INPUT, CS4231_RIGHT_INPUT, 0, 0, 15, 0),
+WSS_DOUBLE_TLV("Capture Volume", 0, CS4231_LEFT_INPUT, CS4231_RIGHT_INPUT,
+                0, 0, 15, 0, db_scale_rec_gain),
 WSS_DOUBLE("Analog Loopback Capture Switch", 0,
                 CS4231_LEFT_INPUT, CS4231_RIGHT_INPUT, 7, 7, 1, 0),
 
-WSS_SINGLE("Digital Loopback Playback Switch", 0, CS4231_LOOPBACK, 0, 1, 0),
-CS4236_DOUBLE1("Digital Loopback Playback Volume", 0,
-                CS4231_LOOPBACK, CS4236_RIGHT_LOOPBACK, 2, 0, 63, 1)
+WSS_SINGLE("Loopback Digital Playback Switch", 0, CS4231_LOOPBACK, 0, 1, 0),
+CS4236_DOUBLE1_TLV("Loopback Digital Playback Volume", 0,
+                   CS4231_LOOPBACK, CS4236_RIGHT_LOOPBACK, 2, 0, 63, 1,
+                   db_scale_6bit),
 };
 
+static const DECLARE_TLV_DB_SCALE(db_scale_5bit_6db_max, -5600, 200, 0);
+static const DECLARE_TLV_DB_SCALE(db_scale_2bit_16db_max, -2400, 800, 0);
+
 static struct snd_kcontrol_new snd_cs4235_controls[] = {
 
-WSS_DOUBLE("Master Switch", 0,
+WSS_DOUBLE("Master Playback Switch", 0,
                 CS4235_LEFT_MASTER, CS4235_RIGHT_MASTER, 7, 7, 1, 1),
-WSS_DOUBLE("Master Volume", 0,
-                CS4235_LEFT_MASTER, CS4235_RIGHT_MASTER, 0, 0, 31, 1),
-
-CS4235_OUTPUT_ACCU("Playback Volume", 0),
+WSS_DOUBLE_TLV("Master Playback Volume", 0,
+                CS4235_LEFT_MASTER, CS4235_RIGHT_MASTER, 0, 0, 31, 1,
+                db_scale_5bit_6db_max),
 
-CS4236_DOUBLE("Master Digital Playback Switch", 0,
-                CS4236_LEFT_MASTER, CS4236_RIGHT_MASTER, 7, 7, 1, 1),
-CS4236_DOUBLE("Master Digital Capture Switch", 0,
-                CS4236_DAC_MUTE, CS4236_DAC_MUTE, 7, 6, 1, 1),
-CS4236_MASTER_DIGITAL("Master Digital Volume", 0),
+CS4235_OUTPUT_ACCU("Playback Volume", 0, db_scale_2bit_16db_max),
 
-WSS_DOUBLE("Master Digital Playback Switch", 1,
+WSS_DOUBLE("Synth Playback Switch", 1,
                 CS4231_LEFT_LINE_IN, CS4231_RIGHT_LINE_IN, 7, 7, 1, 1),
-WSS_DOUBLE("Master Digital Capture Switch", 1,
+WSS_DOUBLE("Synth Capture Switch", 1,
                 CS4231_LEFT_LINE_IN, CS4231_RIGHT_LINE_IN, 6, 6, 1, 1),
-WSS_DOUBLE("Master Digital Volume", 1,
-                CS4231_LEFT_LINE_IN, CS4231_RIGHT_LINE_IN, 0, 0, 31, 1),
+WSS_DOUBLE_TLV("Synth Volume", 1,
+                CS4231_LEFT_LINE_IN, CS4231_RIGHT_LINE_IN, 0, 0, 31, 1,
+                db_scale_5bit_12db_max),
 
-CS4236_DOUBLE("Capture Volume", 0,
-                CS4236_LEFT_MIX_CTRL, CS4236_RIGHT_MIX_CTRL, 5, 5, 3, 1),
+CS4236_DOUBLE_TLV("Capture Volume", 0,
+                  CS4236_LEFT_MIX_CTRL, CS4236_RIGHT_MIX_CTRL, 5, 5, 3, 1,
+                  db_scale_2bit),
 
-WSS_DOUBLE("PCM Switch", 0,
+WSS_DOUBLE("PCM Playback Switch", 0,
                 CS4231_LEFT_OUTPUT, CS4231_RIGHT_OUTPUT, 7, 7, 1, 1),
-WSS_DOUBLE("PCM Volume", 0,
-                CS4231_LEFT_OUTPUT, CS4231_RIGHT_OUTPUT, 0, 0, 63, 1),
+WSS_DOUBLE("PCM Capture Switch", 0,
+                CS4236_DAC_MUTE, CS4236_DAC_MUTE, 7, 6, 1, 1),
+WSS_DOUBLE_TLV("PCM Volume", 0,
+                CS4231_LEFT_OUTPUT, CS4231_RIGHT_OUTPUT, 0, 0, 63, 1,
+                db_scale_6bit),
 
 CS4236_DOUBLE("DSP Switch", 0, CS4236_LEFT_DSP, CS4236_RIGHT_DSP, 7, 7, 1, 1),
 
@@ -842,29 +911,29 @@ CS4236_DOUBLE("Mic Capture Switch", 0,
                 CS4236_LEFT_MIC, CS4236_RIGHT_MIC, 7, 7, 1, 1),
 CS4236_DOUBLE("Mic Playback Switch", 0,
                 CS4236_LEFT_MIC, CS4236_RIGHT_MIC, 6, 6, 1, 1),
-CS4236_SINGLE("Mic Volume", 0, CS4236_LEFT_MIC, 0, 31, 1),
-CS4236_SINGLE("Mic Playback Boost", 0, CS4236_LEFT_MIC, 5, 1, 0),
+CS4236_SINGLE_TLV("Mic Volume", 0, CS4236_LEFT_MIC, 0, 31, 1,
+                  db_scale_5bit_22db_max),
+CS4236_SINGLE("Mic Boost (+20dB)", 0, CS4236_LEFT_MIC, 5, 1, 0),
 
-WSS_DOUBLE("Aux Playback Switch", 0,
+WSS_DOUBLE("Line Playback Switch", 0,
                 CS4231_AUX1_LEFT_INPUT, CS4231_AUX1_RIGHT_INPUT, 7, 7, 1, 1),
-WSS_DOUBLE("Aux Capture Switch", 0,
+WSS_DOUBLE("Line Capture Switch", 0,
                 CS4231_AUX1_LEFT_INPUT, CS4231_AUX1_RIGHT_INPUT, 6, 6, 1, 1),
-WSS_DOUBLE("Aux Volume", 0,
-                CS4231_AUX1_LEFT_INPUT, CS4231_AUX1_RIGHT_INPUT, 0, 0, 31, 1),
+WSS_DOUBLE_TLV("Line Volume", 0,
+                CS4231_AUX1_LEFT_INPUT, CS4231_AUX1_RIGHT_INPUT, 0, 0, 31, 1,
+                db_scale_5bit_12db_max),
 
-WSS_DOUBLE("Aux Playback Switch", 1,
+WSS_DOUBLE("CD Playback Switch", 1,
                 CS4231_AUX2_LEFT_INPUT, CS4231_AUX2_RIGHT_INPUT, 7, 7, 1, 1),
-WSS_DOUBLE("Aux Capture Switch", 1,
+WSS_DOUBLE("CD Capture Switch", 1,
                 CS4231_AUX2_LEFT_INPUT, CS4231_AUX2_RIGHT_INPUT, 6, 6, 1, 1),
-WSS_DOUBLE("Aux Volume", 1,
-                CS4231_AUX2_LEFT_INPUT, CS4231_AUX2_RIGHT_INPUT, 0, 0, 31, 1),
-
-CS4236_DOUBLE1("Master Mono Switch", 0,
-                CS4231_MONO_CTRL, CS4236_RIGHT_MIX_CTRL, 6, 7, 1, 1),
+WSS_DOUBLE_TLV("CD Volume", 1,
+                CS4231_AUX2_LEFT_INPUT, CS4231_AUX2_RIGHT_INPUT, 0, 0, 31, 1,
+                db_scale_5bit_12db_max),
 
-CS4236_DOUBLE1("Mono Switch", 0,
+CS4236_DOUBLE1("Beep Playback Switch", 0,
                 CS4231_MONO_CTRL, CS4236_LEFT_MIX_CTRL, 7, 7, 1, 1),
-WSS_SINGLE("Mono Volume", 0, CS4231_MONO_CTRL, 0, 15, 1),
+WSS_SINGLE("Beep Playback Volume", 0, CS4231_MONO_CTRL, 0, 15, 1),
 
 WSS_DOUBLE("Analog Loopback Switch", 0,
                 CS4231_LEFT_INPUT, CS4231_RIGHT_INPUT, 7, 7, 1, 0),
diff --git a/sound/isa/dt019x.c b/sound/isa/dt019x.c
deleted file mode 100644
index 80f5b1af9be8..000000000000
--- a/sound/isa/dt019x.c
+++ /dev/null
@@ -1,321 +0,0 @@
-
-/*
-    dt019x.c - driver for Diamond Technologies DT-0197H based soundcards.
-    Copyright (C) 1999, 2002 by Massimo Piccioni <dafastidio@libero.it>
-
-    Generalised for soundcards based on DT-0196 and ALS-007 chips 
-    by Jonathan Woithe <jwoithe@physics.adelaide.edu.au>: June 2002.
-
-    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
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program 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/wait.h>
-#include <linux/pnp.h>
-#include <linux/moduleparam.h>
-#include <sound/core.h>
-#include <sound/initval.h>
-#include <sound/mpu401.h>
-#include <sound/opl3.h>
-#include <sound/sb.h>
-
-#define PFX "dt019x: "
-
-MODULE_AUTHOR("Massimo Piccioni <dafastidio@libero.it>");
-MODULE_DESCRIPTION("Diamond Technologies DT-019X / Avance Logic ALS-007");
-MODULE_LICENSE("GPL");
-MODULE_SUPPORTED_DEVICE("{{Diamond Technologies DT-019X},"
-               "{Avance Logic ALS-007}}");
-
-static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
-static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
-static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE;  /* Enable this card */
-static long port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;     /* PnP setup */
-static long mpu_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; /* PnP setup */
-static long fm_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;  /* PnP setup */
-static int irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ;        /* PnP setup */
-static int mpu_irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ;    /* PnP setup */
-static int dma8[SNDRV_CARDS] = SNDRV_DEFAULT_DMA;       /* PnP setup */
-
-module_param_array(index, int, NULL, 0444);
-MODULE_PARM_DESC(index, "Index value for DT-019X based soundcard.");
-module_param_array(id, charp, NULL, 0444);
-MODULE_PARM_DESC(id, "ID string for DT-019X based soundcard.");
-module_param_array(enable, bool, NULL, 0444);
-MODULE_PARM_DESC(enable, "Enable DT-019X based soundcard.");
-
-struct snd_card_dt019x {
-        struct pnp_dev *dev;
-        struct pnp_dev *devmpu;
-        struct pnp_dev *devopl;
-        struct snd_sb *chip;
-};
-
-static struct pnp_card_device_id snd_dt019x_pnpids[] = {
-        /* DT197A30 */
-        { .id = "RWB1688", .devs = { { "@@@0001" }, { "@X@0001" }, { "@H@0001" }, } },
-        /* DT0196 / ALS-007 */
-        { .id = "ALS0007", .devs = { { "@@@0001" }, { "@X@0001" }, { "@H@0001" }, } },
-        { .id = "",  }
-};
-
-MODULE_DEVICE_TABLE(pnp_card, snd_dt019x_pnpids);
-
-
-#define DRIVER_NAME     "snd-card-dt019x"
-
-
-static int __devinit snd_card_dt019x_pnp(int dev, struct snd_card_dt019x *acard,
-                                         struct pnp_card_link *card,
-                                         const struct pnp_card_device_id *pid)
-{
-        struct pnp_dev *pdev;
-        int err;
-
-        acard->dev = pnp_request_card_device(card, pid->devs[0].id, NULL);
-        if (acard->dev == NULL)
-                return -ENODEV;
-
-        acard->devmpu = pnp_request_card_device(card, pid->devs[1].id, NULL);
-        acard->devopl = pnp_request_card_device(card, pid->devs[2].id, NULL);
-
-        pdev = acard->dev;
-
-        err = pnp_activate_dev(pdev);
-        if (err < 0) {
-                snd_printk(KERN_ERR PFX "DT-019X AUDIO pnp configure failure\n");
-                return err;
-        }
-
-        port[dev] = pnp_port_start(pdev, 0);
-        dma8[dev] = pnp_dma(pdev, 0);
-        irq[dev] = pnp_irq(pdev, 0);
-        snd_printdd("dt019x: found audio interface: port=0x%lx, irq=0x%x, dma=0x%x\n",
-                        port[dev],irq[dev],dma8[dev]);
-
-        pdev = acard->devmpu;
-        if (pdev != NULL) {
-                err = pnp_activate_dev(pdev);
-                if (err < 0) {
-                        pnp_release_card_device(pdev);
-                        snd_printk(KERN_ERR PFX "DT-019X MPU401 pnp configure failure, skipping\n");
-                        goto __mpu_error;
-                }
-                mpu_port[dev] = pnp_port_start(pdev, 0);
-                mpu_irq[dev] = pnp_irq(pdev, 0);
-                snd_printdd("dt019x: found MPU-401: port=0x%lx, irq=0x%x\n",
-                                mpu_port[dev],mpu_irq[dev]);
-        } else {
-        __mpu_error:
-                acard->devmpu = NULL;
-                mpu_port[dev] = -1;
-        }
-
-        pdev = acard->devopl;
-        if (pdev != NULL) {
-                err = pnp_activate_dev(pdev);
-                if (err < 0) {
-                        pnp_release_card_device(pdev);
-                        snd_printk(KERN_ERR PFX "DT-019X OPL3 pnp configure failure, skipping\n");
-                        goto __fm_error;
-                }
-                fm_port[dev] = pnp_port_start(pdev, 0);
-                snd_printdd("dt019x: found OPL3 synth: port=0x%lx\n",fm_port[dev]);
-        } else {
-        __fm_error:
-                acard->devopl = NULL;
-                fm_port[dev] = -1;
-        }
-
-        return 0;
-}
-
-static int __devinit snd_card_dt019x_probe(int dev, struct pnp_card_link *pcard, const struct pnp_card_device_id *pid)
-{
-        int error;
-        struct snd_sb *chip;
-        struct snd_card *card;
-        struct snd_card_dt019x *acard;
-        struct snd_opl3 *opl3;
-
-        error = snd_card_create(index[dev], id[dev], THIS_MODULE,
-                                sizeof(struct snd_card_dt019x), &card);
-        if (error < 0)
-                return error;
-        acard = card->private_data;
-
-        snd_card_set_dev(card, &pcard->card->dev);
-        if ((error = snd_card_dt019x_pnp(dev, acard, pcard, pid))) {
-                snd_card_free(card);
-                return error;
-        }
-
-        if ((error = snd_sbdsp_create(card, port[dev],
-                                      irq[dev],
-                                      snd_sb16dsp_interrupt,
-                                      dma8[dev],
-                                      -1,
-                                      SB_HW_DT019X,
-                                      &chip)) < 0) {
-                snd_card_free(card);
-                return error;
-        }
-        acard->chip = chip;
-
-        strcpy(card->driver, "DT-019X");
-        strcpy(card->shortname, "Diamond Tech. DT-019X");
-        sprintf(card->longname, "%s, %s at 0x%lx, irq %d, dma %d",
-                card->shortname, chip->name, chip->port,
-                irq[dev], dma8[dev]);
-
-        if ((error = snd_sb16dsp_pcm(chip, 0, NULL)) < 0) {
-                snd_card_free(card);
-                return error;
-        }
-        if ((error = snd_sbmixer_new(chip)) < 0) {
-                snd_card_free(card);
-                return error;
-        }
-
-        if (mpu_port[dev] > 0 && mpu_port[dev] != SNDRV_AUTO_PORT) {
-                if (mpu_irq[dev] == SNDRV_AUTO_IRQ)
-                        mpu_irq[dev] = -1;
-                if (snd_mpu401_uart_new(card, 0,
-/*                                      MPU401_HW_SB,*/
-                                        MPU401_HW_MPU401,
-                                        mpu_port[dev], 0,
-                                        mpu_irq[dev],
-                                        mpu_irq[dev] >= 0 ? IRQF_DISABLED : 0,
-                                        NULL) < 0)
-                        snd_printk(KERN_ERR PFX "no MPU-401 device at 0x%lx ?\n", mpu_port[dev]);
-        }
-
-        if (fm_port[dev] > 0 && fm_port[dev] != SNDRV_AUTO_PORT) {
-                if (snd_opl3_create(card,
-                                    fm_port[dev],
-                                    fm_port[dev] + 2,
-                                    OPL3_HW_AUTO, 0, &opl3) < 0) {
-                        snd_printk(KERN_ERR PFX "no OPL device at 0x%lx-0x%lx ?\n",
-                                   fm_port[dev], fm_port[dev] + 2);
-                } else {
-                        if ((error = snd_opl3_timer_new(opl3, 0, 1)) < 0) {
-                                snd_card_free(card);
-                                return error;
-                        }
-                        if ((error = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0) {
-                                snd_card_free(card);
-                                return error;
-                        }
-                }
-        }
-
-        if ((error = snd_card_register(card)) < 0) {
-                snd_card_free(card);
-                return error;
-        }
-        pnp_set_card_drvdata(pcard, card);
-        return 0;
-}
-
-static unsigned int __devinitdata dt019x_devices;
-
-static int __devinit snd_dt019x_pnp_probe(struct pnp_card_link *card,
-                                          const struct pnp_card_device_id *pid)
-{
-        static int dev;
-        int res;
-
-        for ( ; dev < SNDRV_CARDS; dev++) {
-                if (!enable[dev])
-                        continue;
-                res = snd_card_dt019x_probe(dev, card, pid);
-                if (res < 0)
-                        return res;
-                dev++;
-                dt019x_devices++;
-                return 0;
-        }
-        return -ENODEV;
-}
-
-static void __devexit snd_dt019x_pnp_remove(struct pnp_card_link * pcard)
-{
-        snd_card_free(pnp_get_card_drvdata(pcard));
-        pnp_set_card_drvdata(pcard, NULL);
-}
-
-#ifdef CONFIG_PM
-static int snd_dt019x_pnp_suspend(struct pnp_card_link *pcard, pm_message_t state)
-{
-        struct snd_card *card = pnp_get_card_drvdata(pcard);
-        struct snd_card_dt019x *acard = card->private_data;
-        struct snd_sb *chip = acard->chip;
-
-        snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
-        snd_pcm_suspend_all(chip->pcm);
-        snd_sbmixer_suspend(chip);
-        return 0;
-}
-
-static int snd_dt019x_pnp_resume(struct pnp_card_link *pcard)
-{
-        struct snd_card *card = pnp_get_card_drvdata(pcard);
-        struct snd_card_dt019x *acard = card->private_data;
-        struct snd_sb *chip = acard->chip;
-
-        snd_sbdsp_reset(chip);
-        snd_sbmixer_resume(chip);
-        snd_power_change_state(card, SNDRV_CTL_POWER_D0);
-        return 0;
-}
-#endif
-
-static struct pnp_card_driver dt019x_pnpc_driver = {
-        .flags          = PNP_DRIVER_RES_DISABLE,
-        .name           = "dt019x",
-        .id_table       = snd_dt019x_pnpids,
-        .probe          = snd_dt019x_pnp_probe,
-        .remove         = __devexit_p(snd_dt019x_pnp_remove),
-#ifdef CONFIG_PM
-        .suspend        = snd_dt019x_pnp_suspend,
-        .resume         = snd_dt019x_pnp_resume,
-#endif
-};
-
-static int __init alsa_card_dt019x_init(void)
-{
-        int err;
-
-        err = pnp_register_card_driver(&dt019x_pnpc_driver);
-        if (err)
-                return err;
-
-        if (!dt019x_devices) {
-                pnp_unregister_card_driver(&dt019x_pnpc_driver);
-#ifdef MODULE
-                snd_printk(KERN_ERR "no DT-019X / ALS-007 based soundcards found\n");
-#endif
-                return -ENODEV;
-        }
-        return 0;
-}
-
-static void __exit alsa_card_dt019x_exit(void)
-{
-        pnp_unregister_card_driver(&dt019x_pnpc_driver);
-}
-
-module_init(alsa_card_dt019x_init)
-module_exit(alsa_card_dt019x_exit)
diff --git a/sound/isa/es1688/es1688_lib.c b/sound/isa/es1688/es1688_lib.c
index 4c6e14f87f2d..c76bb00c9d15 100644
--- a/sound/isa/es1688/es1688_lib.c
+++ b/sound/isa/es1688/es1688_lib.c
@@ -982,7 +982,7 @@ ES1688_DOUBLE("CD Playback Volume", 0, ES1688_CD_DEV, ES1688_CD_DEV, 4, 0, 15, 0
 ES1688_DOUBLE("FM Playback Volume", 0, ES1688_FM_DEV, ES1688_FM_DEV, 4, 0, 15, 0),
 ES1688_DOUBLE("Mic Playback Volume", 0, ES1688_MIC_DEV, ES1688_MIC_DEV, 4, 0, 15, 0),
 ES1688_DOUBLE("Aux Playback Volume", 0, ES1688_AUX_DEV, ES1688_AUX_DEV, 4, 0, 15, 0),
-ES1688_SINGLE("PC Speaker Playback Volume", 0, ES1688_SPEAKER_DEV, 0, 7, 0),
+ES1688_SINGLE("Beep Playback Volume", 0, ES1688_SPEAKER_DEV, 0, 7, 0),
 ES1688_DOUBLE("Capture Volume", 0, ES1688_RECLEV_DEV, ES1688_RECLEV_DEV, 4, 0, 15, 0),
 ES1688_SINGLE("Capture Switch", 0, ES1688_REC_DEV, 4, 1, 1),
 {
diff --git a/sound/isa/es18xx.c b/sound/isa/es18xx.c
index 8cfbff73a835..fb4d6b34bbca 100644
--- a/sound/isa/es18xx.c
+++ b/sound/isa/es18xx.c
@@ -80,7 +80,6 @@
 #include <linux/init.h>
 #include <linux/err.h>
 #include <linux/isa.h>
-#include <linux/slab.h>
 #include <linux/pnp.h>
 #include <linux/isapnp.h>
 #include <linux/moduleparam.h>
@@ -102,8 +101,6 @@
 
 struct snd_es18xx {
         unsigned long port;             /* port of ESS chip */
-        unsigned long mpu_port;         /* MPU-401 port of ESS chip */
-        unsigned long fm_port;          /* FM port */
         unsigned long ctrl_port;        /* Control port of ESS chip */
         struct resource *res_port;
         struct resource *res_mpu_port;
@@ -116,12 +113,9 @@ struct snd_es18xx {
         unsigned short audio2_vol;      /* volume level of audio2 */
 
         unsigned short active;          /* active channel mask */
-        unsigned int dma1_size;
-        unsigned int dma2_size;
         unsigned int dma1_shift;
         unsigned int dma2_shift;
 
-        struct snd_card *card;
         struct snd_pcm *pcm;
         struct snd_pcm_substream *playback_a_substream;
         struct snd_pcm_substream *capture_a_substream;
@@ -136,14 +130,9 @@ struct snd_es18xx {
 
         spinlock_t reg_lock;
         spinlock_t mixer_lock;
-        spinlock_t ctrl_lock;
 #ifdef CONFIG_PM
         unsigned char pm_reg;
 #endif
-};
-
-struct snd_audiodrive {
-        struct snd_es18xx *chip;
 #ifdef CONFIG_PNP
         struct pnp_dev *dev;
         struct pnp_dev *devc;
@@ -359,7 +348,7 @@ static inline int snd_es18xx_mixer_writable(struct snd_es18xx *chip, unsigned ch
 }
 
 
-static int snd_es18xx_reset(struct snd_es18xx *chip)
+static int __devinit snd_es18xx_reset(struct snd_es18xx *chip)
 {
         int i;
         outb(0x03, chip->port + 0x06);
@@ -495,8 +484,6 @@ static int snd_es18xx_playback1_prepare(struct snd_es18xx *chip,
         unsigned int size = snd_pcm_lib_buffer_bytes(substream);
         unsigned int count = snd_pcm_lib_period_bytes(substream);
 
-        chip->dma2_size = size;
-
         snd_es18xx_rate_set(chip, substream, DAC2);
 
         /* Transfer Count Reload */
@@ -596,8 +583,6 @@ static int snd_es18xx_capture_prepare(struct snd_pcm_substream *substream)
         unsigned int size = snd_pcm_lib_buffer_bytes(substream);
         unsigned int count = snd_pcm_lib_period_bytes(substream);
 
-        chip->dma1_size = size;
-
         snd_es18xx_reset_fifo(chip);
 
         /* Set stereo/mono */
@@ -664,8 +649,6 @@ static int snd_es18xx_playback2_prepare(struct snd_es18xx *chip,
         unsigned int size = snd_pcm_lib_buffer_bytes(substream);
         unsigned int count = snd_pcm_lib_period_bytes(substream);
 
-        chip->dma1_size = size;
-
         snd_es18xx_reset_fifo(chip);
 
         /* Set stereo/mono */
@@ -755,7 +738,8 @@ static int snd_es18xx_playback_trigger(struct snd_pcm_substream *substream,
 
 static irqreturn_t snd_es18xx_interrupt(int irq, void *dev_id)
 {
-        struct snd_es18xx *chip = dev_id;
+        struct snd_card *card = dev_id;
+        struct snd_es18xx *chip = card->private_data;
         unsigned char status;
 
         if (chip->caps & ES18XX_CONTROL) {
@@ -805,12 +789,16 @@ static irqreturn_t snd_es18xx_interrupt(int irq, void *dev_id)
                 int split = 0;
                 if (chip->caps & ES18XX_HWV) {
                         split = snd_es18xx_mixer_read(chip, 0x64) & 0x80;
-                        snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_switch->id);
-                        snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_volume->id);
+                        snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
+                                        &chip->hw_switch->id);
+                        snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
+                                        &chip->hw_volume->id);
                 }
                 if (!split) {
-                        snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->master_switch->id);
-                        snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->master_volume->id);
+                        snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
+                                        &chip->master_switch->id);
+                        snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
+                                        &chip->master_volume->id);
                 }
                 /* ack interrupt */
                 snd_es18xx_mixer_write(chip, 0x66, 0x00);
@@ -821,17 +809,18 @@ static irqreturn_t snd_es18xx_interrupt(int irq, void *dev_id)
 static snd_pcm_uframes_t snd_es18xx_playback_pointer(struct snd_pcm_substream *substream)
 {
         struct snd_es18xx *chip = snd_pcm_substream_chip(substream);
+        unsigned int size = snd_pcm_lib_buffer_bytes(substream);
         int pos;
 
         if (substream->number == 0 && (chip->caps & ES18XX_PCM2)) {
                 if (!(chip->active & DAC2))
                         return 0;
-                pos = snd_dma_pointer(chip->dma2, chip->dma2_size);
+                pos = snd_dma_pointer(chip->dma2, size);
                 return pos >> chip->dma2_shift;
         } else {
                 if (!(chip->active & DAC1))
                         return 0;
-                pos = snd_dma_pointer(chip->dma1, chip->dma1_size);
+                pos = snd_dma_pointer(chip->dma1, size);
                 return pos >> chip->dma1_shift;
         }
 }
@@ -839,11 +828,12 @@ static snd_pcm_uframes_t snd_es18xx_playback_pointer(struct snd_pcm_substream *s
 static snd_pcm_uframes_t snd_es18xx_capture_pointer(struct snd_pcm_substream *substream)
 {
         struct snd_es18xx *chip = snd_pcm_substream_chip(substream);
+        unsigned int size = snd_pcm_lib_buffer_bytes(substream);
         int pos;
 
         if (!(chip->active & ADC1))
                 return 0;
-        pos = snd_dma_pointer(chip->dma1, chip->dma1_size);
+        pos = snd_dma_pointer(chip->dma1, size);
         return pos >> chip->dma1_shift;
 }
 
@@ -974,9 +964,6 @@ static int snd_es18xx_capture_close(struct snd_pcm_substream *substream)
 
 static int snd_es18xx_info_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 {
-        static char *texts4Source[4] = {
-                "Mic", "CD", "Line", "Master"
-        };
         static char *texts5Source[5] = {
                 "Mic", "CD", "Line", "Master", "Mix"
         };
@@ -994,7 +981,8 @@ static int snd_es18xx_info_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_ele
                 uinfo->value.enumerated.items = 4;
                 if (uinfo->value.enumerated.item > 3)
                         uinfo->value.enumerated.item = 3;
-                strcpy(uinfo->value.enumerated.name, texts4Source[uinfo->value.enumerated.item]);
+                strcpy(uinfo->value.enumerated.name,
+                        texts5Source[uinfo->value.enumerated.item]);
                 break;
         case 0x1887:
         case 0x1888:
@@ -1313,7 +1301,7 @@ ES18XX_DOUBLE("Aux Capture Volume", 0, 0x6c, 0x6c, 4, 0, 15, 0)
  * The chipset specific mixer controls
  */
 static struct snd_kcontrol_new snd_es18xx_opt_speaker =
-        ES18XX_SINGLE("PC Speaker Playback Volume", 0, 0x3c, 0, 7, 0);
+        ES18XX_SINGLE("Beep Playback Volume", 0, 0x3c, 0, 7, 0);
 
 static struct snd_kcontrol_new snd_es18xx_opt_1869[] = {
 ES18XX_SINGLE("Capture Switch", 0, 0x1c, 4, 1, 1),
@@ -1378,11 +1366,9 @@ ES18XX_SINGLE("Hardware Master Volume Split", 0, 0x64, 7, 1, 0),
 static int __devinit snd_es18xx_config_read(struct snd_es18xx *chip, unsigned char reg)
 {
         int data;
-        unsigned long flags;
-        spin_lock_irqsave(&chip->ctrl_lock, flags);
+
         outb(reg, chip->ctrl_port);
         data = inb(chip->ctrl_port + 1);
-        spin_unlock_irqrestore(&chip->ctrl_lock, flags);
         return data;
 }
 
@@ -1398,7 +1384,9 @@ static void __devinit snd_es18xx_config_write(struct snd_es18xx *chip,
 #endif
 }
 
-static int __devinit snd_es18xx_initialize(struct snd_es18xx *chip)
+static int __devinit snd_es18xx_initialize(struct snd_es18xx *chip,
+                                           unsigned long mpu_port,
+                                           unsigned long fm_port)
 {
         int mask = 0;
 
@@ -1412,15 +1400,15 @@ static int __devinit snd_es18xx_initialize(struct snd_es18xx *chip)
         if (chip->caps & ES18XX_CONTROL) {
                 /* Hardware volume IRQ */
                 snd_es18xx_config_write(chip, 0x27, chip->irq);
-                if (chip->fm_port > 0 && chip->fm_port != SNDRV_AUTO_PORT) {
+                if (fm_port > 0 && fm_port != SNDRV_AUTO_PORT) {
                         /* FM I/O */
-                        snd_es18xx_config_write(chip, 0x62, chip->fm_port >> 8);
-                        snd_es18xx_config_write(chip, 0x63, chip->fm_port & 0xff);
+                        snd_es18xx_config_write(chip, 0x62, fm_port >> 8);
+                        snd_es18xx_config_write(chip, 0x63, fm_port & 0xff);
                 }
-                if (chip->mpu_port > 0 && chip->mpu_port != SNDRV_AUTO_PORT) {
+                if (mpu_port > 0 && mpu_port != SNDRV_AUTO_PORT) {
                         /* MPU-401 I/O */
-                        snd_es18xx_config_write(chip, 0x64, chip->mpu_port >> 8);
-                        snd_es18xx_config_write(chip, 0x65, chip->mpu_port & 0xff);
+                        snd_es18xx_config_write(chip, 0x64, mpu_port >> 8);
+                        snd_es18xx_config_write(chip, 0x65, mpu_port & 0xff);
                         /* MPU-401 IRQ */
                         snd_es18xx_config_write(chip, 0x28, chip->irq);
                 }
@@ -1507,11 +1495,12 @@ static int __devinit snd_es18xx_initialize(struct snd_es18xx *chip)
                 snd_es18xx_mixer_write(chip, 0x7A, 0x68);
                 /* Enable and set hardware volume interrupt */
                 snd_es18xx_mixer_write(chip, 0x64, 0x06);
-                if (chip->mpu_port > 0 && chip->mpu_port != SNDRV_AUTO_PORT) {
+                if (mpu_port > 0 && mpu_port != SNDRV_AUTO_PORT) {
                         /* MPU401 share irq with audio
                            Joystick enabled
                            FM enabled */
-                        snd_es18xx_mixer_write(chip, 0x40, 0x43 | (chip->mpu_port & 0xf0) >> 1);
+                        snd_es18xx_mixer_write(chip, 0x40,
+                                               0x43 | (mpu_port & 0xf0) >> 1);
                 }
                 snd_es18xx_mixer_write(chip, 0x7f, ((irqmask + 1) << 1) | 0x01);
         }
@@ -1629,7 +1618,9 @@ static int __devinit snd_es18xx_identify(struct snd_es18xx *chip)
         return 0;
 }
 
-static int __devinit snd_es18xx_probe(struct snd_es18xx *chip)
+static int __devinit snd_es18xx_probe(struct snd_es18xx *chip,
+                                        unsigned long mpu_port,
+                                        unsigned long fm_port)
 {
         if (snd_es18xx_identify(chip) < 0) {
                 snd_printk(KERN_ERR PFX "[0x%lx] ESS chip not found\n", chip->port);
@@ -1650,8 +1641,6 @@ static int __devinit snd_es18xx_probe(struct snd_es18xx *chip)
                 chip->caps = ES18XX_PCM2 | ES18XX_SPATIALIZER | ES18XX_RECMIX | ES18XX_NEW_RATE | ES18XX_AUXB | ES18XX_I2S | ES18XX_CONTROL | ES18XX_HWV;
                 break;
         case 0x1887:
-                chip->caps = ES18XX_PCM2 | ES18XX_RECMIX | ES18XX_AUXB | ES18XX_DUPLEX_SAME;
-                break;
         case 0x1888:
                 chip->caps = ES18XX_PCM2 | ES18XX_RECMIX | ES18XX_AUXB | ES18XX_DUPLEX_SAME;
                 break;
@@ -1666,7 +1655,7 @@ static int __devinit snd_es18xx_probe(struct snd_es18xx *chip)
         if (chip->dma1 == chip->dma2)
                 chip->caps &= ~(ES18XX_PCM2 | ES18XX_DUPLEX_SAME);
 
-        return snd_es18xx_initialize(chip);
+        return snd_es18xx_initialize(chip, mpu_port, fm_port);
 }
 
 static struct snd_pcm_ops snd_es18xx_playback_ops = {
@@ -1691,8 +1680,10 @@ static struct snd_pcm_ops snd_es18xx_capture_ops = {
         .pointer =      snd_es18xx_capture_pointer,
 };
 
-static int __devinit snd_es18xx_pcm(struct snd_es18xx *chip, int device, struct snd_pcm ** rpcm)
+static int __devinit snd_es18xx_pcm(struct snd_card *card, int device,
+                                    struct snd_pcm **rpcm)
 {
+        struct snd_es18xx *chip = card->private_data;
         struct snd_pcm *pcm;
         char str[16];
         int err;
@@ -1701,9 +1692,9 @@ static int __devinit snd_es18xx_pcm(struct snd_es18xx *chip, int device, struct
                 *rpcm = NULL;
         sprintf(str, "ES%x", chip->version);
         if (chip->caps & ES18XX_PCM2)
-                err = snd_pcm_new(chip->card, str, device, 2, 1, &pcm);
+                err = snd_pcm_new(card, str, device, 2, 1, &pcm);
         else
-                err = snd_pcm_new(chip->card, str, device, 1, 1, &pcm);
+                err = snd_pcm_new(card, str, device, 1, 1, &pcm);
         if (err < 0)
                 return err;
 
@@ -1734,10 +1725,9 @@ static int __devinit snd_es18xx_pcm(struct snd_es18xx *chip, int device, struct
 #ifdef CONFIG_PM
 static int snd_es18xx_suspend(struct snd_card *card, pm_message_t state)
 {
-        struct snd_audiodrive *acard = card->private_data;
-        struct snd_es18xx *chip = acard->chip;
+        struct snd_es18xx *chip = card->private_data;
 
-        snd_power_change_state(chip->card, SNDRV_CTL_POWER_D3hot);
+        snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
 
         snd_pcm_suspend_all(chip->pcm);
 
@@ -1752,24 +1742,25 @@ static int snd_es18xx_suspend(struct snd_card *card, pm_message_t state)
 
 static int snd_es18xx_resume(struct snd_card *card)
 {
-        struct snd_audiodrive *acard = card->private_data;
-        struct snd_es18xx *chip = acard->chip;
+        struct snd_es18xx *chip = card->private_data;
 
         /* restore PM register, we won't wake till (not 0x07) i/o activity though */
         snd_es18xx_write(chip, ES18XX_PM, chip->pm_reg ^= ES18XX_PM_FM);
 
-        snd_power_change_state(chip->card, SNDRV_CTL_POWER_D0);
+        snd_power_change_state(card, SNDRV_CTL_POWER_D0);
         return 0;
 }
 #endif /* CONFIG_PM */
 
-static int snd_es18xx_free(struct snd_es18xx *chip)
+static int snd_es18xx_free(struct snd_card *card)
 {
+        struct snd_es18xx *chip = card->private_data;
+
         release_and_free_resource(chip->res_port);
         release_and_free_resource(chip->res_ctrl_port);
         release_and_free_resource(chip->res_mpu_port);
         if (chip->irq >= 0)
-                free_irq(chip->irq, (void *) chip);
+                free_irq(chip->irq, (void *) card);
         if (chip->dma1 >= 0) {
                 disable_dma(chip->dma1);
                 free_dma(chip->dma1);
@@ -1778,93 +1769,82 @@ static int snd_es18xx_free(struct snd_es18xx *chip)
                 disable_dma(chip->dma2);
                 free_dma(chip->dma2);
         }
-        kfree(chip);
         return 0;
 }
 
 static int snd_es18xx_dev_free(struct snd_device *device)
 {
-        struct snd_es18xx *chip = device->device_data;
-        return snd_es18xx_free(chip);
+        return snd_es18xx_free(device->card);
 }
 
 static int __devinit snd_es18xx_new_device(struct snd_card *card,
                                            unsigned long port,
                                            unsigned long mpu_port,
                                            unsigned long fm_port,
-                                           int irq, int dma1, int dma2,
-                                           struct snd_es18xx ** rchip)
+                                           int irq, int dma1, int dma2)
 {
-        struct snd_es18xx *chip;
+        struct snd_es18xx *chip = card->private_data;
         static struct snd_device_ops ops = {
                 .dev_free =     snd_es18xx_dev_free,
         };
         int err;
 
-        *rchip = NULL;
-        chip = kzalloc(sizeof(*chip), GFP_KERNEL);
-        if (chip == NULL)
-                return -ENOMEM;
         spin_lock_init(&chip->reg_lock);
         spin_lock_init(&chip->mixer_lock);
-        spin_lock_init(&chip->ctrl_lock);
-        chip->card = card;
         chip->port = port;
-        chip->mpu_port = mpu_port;
-        chip->fm_port = fm_port;
         chip->irq = -1;
         chip->dma1 = -1;
         chip->dma2 = -1;
         chip->audio2_vol = 0x00;
         chip->active = 0;
 
-        if ((chip->res_port = request_region(port, 16, "ES18xx")) == NULL) {
-                snd_es18xx_free(chip);
+        chip->res_port = request_region(port, 16, "ES18xx");
+        if (chip->res_port == NULL) {
+                snd_es18xx_free(card);
                 snd_printk(KERN_ERR PFX "unable to grap ports 0x%lx-0x%lx\n", port, port + 16 - 1);
                 return -EBUSY;
         }
 
-        if (request_irq(irq, snd_es18xx_interrupt, IRQF_DISABLED, "ES18xx", (void *) chip)) {
-                snd_es18xx_free(chip);
+        if (request_irq(irq, snd_es18xx_interrupt, IRQF_DISABLED, "ES18xx",
+                        (void *) card)) {
+                snd_es18xx_free(card);
                 snd_printk(KERN_ERR PFX "unable to grap IRQ %d\n", irq);
                 return -EBUSY;
         }
         chip->irq = irq;
 
         if (request_dma(dma1, "ES18xx DMA 1")) {
-                snd_es18xx_free(chip);
+                snd_es18xx_free(card);
                 snd_printk(KERN_ERR PFX "unable to grap DMA1 %d\n", dma1);
                 return -EBUSY;
         }
         chip->dma1 = dma1;
 
         if (dma2 != dma1 && request_dma(dma2, "ES18xx DMA 2")) {
-                snd_es18xx_free(chip);
+                snd_es18xx_free(card);
                 snd_printk(KERN_ERR PFX "unable to grap DMA2 %d\n", dma2);
                 return -EBUSY;
         }
         chip->dma2 = dma2;
 
-        if (snd_es18xx_probe(chip) < 0) {
-                snd_es18xx_free(chip);
-                return -ENODEV;
-        }
-        if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
-                snd_es18xx_free(chip);
+        if (snd_es18xx_probe(chip, mpu_port, fm_port) < 0) {
+                snd_es18xx_free(card);
+                return -ENODEV;
+        }
+        err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
+        if (err < 0) {
+                snd_es18xx_free(card);
                 return err;
         }
-        *rchip = chip;
         return 0;
 }
 
-static int __devinit snd_es18xx_mixer(struct snd_es18xx *chip)
+static int __devinit snd_es18xx_mixer(struct snd_card *card)
 {
-        struct snd_card *card;
+        struct snd_es18xx *chip = card->private_data;
         int err;
         unsigned int idx;
 
-        card = chip->card;
-
         strcpy(card->mixername, chip->pcm->name);
 
         for (idx = 0; idx < ARRAY_SIZE(snd_es18xx_base_controls); idx++) {
@@ -1986,7 +1966,7 @@ static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;	/* Index 0-MAX */
 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_ISAPNP; /* Enable this card */
 #ifdef CONFIG_PNP
-static int isapnp[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1};
+static int isapnp[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_ISAPNP;
 #endif
 static long port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;     /* 0x220,0x240,0x260,0x280 */
 #ifndef CONFIG_PNP
@@ -2063,11 +2043,11 @@ static int __devinit snd_audiodrive_pnp_init_main(int dev, struct pnp_dev *pdev)
         return 0;
 }
 
-static int __devinit snd_audiodrive_pnp(int dev, struct snd_audiodrive *acard,
+static int __devinit snd_audiodrive_pnp(int dev, struct snd_es18xx *chip,
                                         struct pnp_dev *pdev)
 {
-        acard->dev = pdev;
-        if (snd_audiodrive_pnp_init_main(dev, acard->dev) < 0)
+        chip->dev = pdev;
+        if (snd_audiodrive_pnp_init_main(dev, chip->dev) < 0)
                 return -EBUSY;
         return 0;
 }
@@ -2093,26 +2073,26 @@ static struct pnp_card_device_id snd_audiodrive_pnpids[] = {
 
 MODULE_DEVICE_TABLE(pnp_card, snd_audiodrive_pnpids);
 
-static int __devinit snd_audiodrive_pnpc(int dev, struct snd_audiodrive *acard,
+static int __devinit snd_audiodrive_pnpc(int dev, struct snd_es18xx *chip,
                                         struct pnp_card_link *card,
                                         const struct pnp_card_device_id *id)
 {
-        acard->dev = pnp_request_card_device(card, id->devs[0].id, NULL);
-        if (acard->dev == NULL)
+        chip->dev = pnp_request_card_device(card, id->devs[0].id, NULL);
+        if (chip->dev == NULL)
                 return -EBUSY;
 
-        acard->devc = pnp_request_card_device(card, id->devs[1].id, NULL);
-        if (acard->devc == NULL)
+        chip->devc = pnp_request_card_device(card, id->devs[1].id, NULL);
+        if (chip->devc == NULL)
                 return -EBUSY;
 
         /* Control port initialization */
-        if (pnp_activate_dev(acard->devc) < 0) {
+        if (pnp_activate_dev(chip->devc) < 0) {
                 snd_printk(KERN_ERR PFX "PnP control configure failure (out of resources?)\n");
                 return -EAGAIN;
         }
         snd_printdd("pnp: port=0x%llx\n",
-                        (unsigned long long)pnp_port_start(acard->devc, 0));
-        if (snd_audiodrive_pnp_init_main(dev, acard->dev) < 0)
+                        (unsigned long long)pnp_port_start(chip->devc, 0));
+        if (snd_audiodrive_pnp_init_main(dev, chip->dev) < 0)
                 return -EBUSY;
 
         return 0;
@@ -2128,24 +2108,20 @@ static int __devinit snd_audiodrive_pnpc(int dev, struct snd_audiodrive *acard,
 static int snd_es18xx_card_new(int dev, struct snd_card **cardp)
 {
         return snd_card_create(index[dev], id[dev], THIS_MODULE,
-                               sizeof(struct snd_audiodrive), cardp);
+                               sizeof(struct snd_es18xx), cardp);
 }
 
 static int __devinit snd_audiodrive_probe(struct snd_card *card, int dev)
 {
-        struct snd_audiodrive *acard = card->private_data;
-        struct snd_es18xx *chip;
+        struct snd_es18xx *chip = card->private_data;
         struct snd_opl3 *opl3;
         int err;
 
-        if ((err = snd_es18xx_new_device(card,
-                                         port[dev],
-                                         mpu_port[dev],
-                                         fm_port[dev],
-                                         irq[dev], dma1[dev], dma2[dev],
-                                         &chip)) < 0)
+        err = snd_es18xx_new_device(card,
+                                    port[dev], mpu_port[dev], fm_port[dev],
+                                    irq[dev], dma1[dev], dma2[dev]);
+        if (err < 0)
                 return err;
-        acard->chip = chip;
 
         sprintf(card->driver, "ES%x", chip->version);
         
@@ -2161,26 +2137,32 @@ static int __devinit snd_audiodrive_probe(struct snd_card *card, int dev)
                         chip->port,
                         irq[dev], dma1[dev]);
 
-        if ((err = snd_es18xx_pcm(chip, 0, NULL)) < 0)
+        err = snd_es18xx_pcm(card, 0, NULL);
+        if (err < 0)
                 return err;
 
-        if ((err = snd_es18xx_mixer(chip)) < 0)
+        err = snd_es18xx_mixer(card);
+        if (err < 0)
                 return err;
 
         if (fm_port[dev] > 0 && fm_port[dev] != SNDRV_AUTO_PORT) {
-                if (snd_opl3_create(card, chip->fm_port, chip->fm_port + 2, OPL3_HW_OPL3, 0, &opl3) < 0) {
-                        snd_printk(KERN_WARNING PFX "opl3 not detected at 0x%lx\n", chip->fm_port);
+                if (snd_opl3_create(card, fm_port[dev], fm_port[dev] + 2,
+                                    OPL3_HW_OPL3, 0, &opl3) < 0) {
+                        snd_printk(KERN_WARNING PFX
+                                   "opl3 not detected at 0x%lx\n",
+                                   fm_port[dev]);
                 } else {
-                        if ((err = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0)
+                        err = snd_opl3_hwdep_new(opl3, 0, 1, NULL);
+                        if (err < 0)
                                 return err;
                 }
         }
 
         if (mpu_port[dev] > 0 && mpu_port[dev] != SNDRV_AUTO_PORT) {
-                if ((err = snd_mpu401_uart_new(card, 0, MPU401_HW_ES18XX,
-                                               chip->mpu_port, 0,
-                                               irq[dev], 0,
-                                               &chip->rmidi)) < 0)
+                err = snd_mpu401_uart_new(card, 0, MPU401_HW_ES18XX,
+                                          mpu_port[dev], 0,
+                                          irq[dev], 0, &chip->rmidi);
+                if (err < 0)
                         return err;
         }
 
diff --git a/sound/isa/gus/gus_mem.c b/sound/isa/gus/gus_mem.c
index 661205c4dcea..af888a022fc0 100644
--- a/sound/isa/gus/gus_mem.c
+++ b/sound/isa/gus/gus_mem.c
@@ -127,7 +127,8 @@ static struct snd_gf1_mem_block *snd_gf1_mem_share(struct snd_gf1_mem * alloc,
             !share_id[2] && !share_id[3])
                 return NULL;
         for (block = alloc->first; block; block = block->next)
-                if (!memcmp(share_id, block->share_id, sizeof(share_id)))
+                if (!memcmp(share_id, block->share_id,
+                                sizeof(block->share_id)))
                         return block;
         return NULL;
 }
diff --git a/sound/isa/gus/interwave.c b/sound/isa/gus/interwave.c
index 534a6eced2b8..c7b80e4730fc 100644
--- a/sound/isa/gus/interwave.c
+++ b/sound/isa/gus/interwave.c
@@ -26,7 +26,6 @@
 #include <linux/err.h>
 #include <linux/isa.h>
 #include <linux/delay.h>
-#include <linux/slab.h>
 #include <linux/pnp.h>
 #include <linux/moduleparam.h>
 #include <asm/dma.h>
diff --git a/sound/isa/msnd/msnd_midi.c b/sound/isa/msnd/msnd_midi.c
index cb9aa4c4edd0..787495674235 100644
--- a/sound/isa/msnd/msnd_midi.c
+++ b/sound/isa/msnd/msnd_midi.c
@@ -25,6 +25,7 @@
  */
 
 #include <linux/io.h>
+#include <linux/slab.h>
 #include <linux/delay.h>
 #include <linux/ioport.h>
 #include <linux/errno.h>
@@ -162,7 +163,7 @@ int snd_msndmidi_new(struct snd_card *card, int device)
         err = snd_rawmidi_new(card, "MSND-MIDI", device, 1, 1, &rmidi);
         if (err < 0)
                 return err;
-        mpu = kcalloc(1, sizeof(*mpu), GFP_KERNEL);
+        mpu = kzalloc(sizeof(*mpu), GFP_KERNEL);
         if (mpu == NULL) {
                 snd_device_free(card, rmidi);
                 return -ENOMEM;
diff --git a/sound/isa/opl3sa2.c b/sound/isa/opl3sa2.c
index 0481a55334b9..265abcce9dba 100644
--- a/sound/isa/opl3sa2.c
+++ b/sound/isa/opl3sa2.c
@@ -24,7 +24,6 @@
 #include <linux/isa.h>
 #include <linux/interrupt.h>
 #include <linux/pm.h>
-#include <linux/slab.h>
 #include <linux/pnp.h>
 #include <linux/moduleparam.h>
 #include <sound/core.h>
diff --git a/sound/isa/opti9xx/miro.c b/sound/isa/opti9xx/miro.c
index 02e30d7c6a93..8c24102d0d93 100644
--- a/sound/isa/opti9xx/miro.c
+++ b/sound/isa/opti9xx/miro.c
@@ -25,8 +25,8 @@
 #include <linux/init.h>
 #include <linux/err.h>
 #include <linux/isa.h>
+#include <linux/pnp.h>
 #include <linux/delay.h>
-#include <linux/slab.h>
 #include <linux/ioport.h>
 #include <linux/moduleparam.h>
 #include <asm/io.h>
@@ -40,7 +40,7 @@
 #define SNDRV_LEGACY_FIND_FREE_IRQ
 #define SNDRV_LEGACY_FIND_FREE_DMA
 #include <sound/initval.h>
-#include "miro.h"
+#include <sound/aci.h>
 
 MODULE_AUTHOR("Martin Langer <martin-langer@gmx.de>");
 MODULE_LICENSE("GPL");
@@ -60,6 +60,9 @@ static int dma1 = SNDRV_DEFAULT_DMA1;		/* 0,1,3 */
 static int dma2 = SNDRV_DEFAULT_DMA1;           /* 0,1,3 */
 static int wss;
 static int ide;
+#ifdef CONFIG_PNP
+static int isapnp = 1;                          /* Enable ISA PnP detection */
+#endif
 
 module_param(index, int, 0444);
 MODULE_PARM_DESC(index, "Index value for miro soundcard.");
@@ -83,6 +86,10 @@ module_param(wss, int, 0444);
 MODULE_PARM_DESC(wss, "wss mode");
 module_param(ide, int, 0444);
 MODULE_PARM_DESC(ide, "enable ide port");
+#ifdef CONFIG_PNP
+module_param(isapnp, bool, 0444);
+MODULE_PARM_DESC(isapnp, "Enable ISA PnP detection for specified soundcard.");
+#endif
 
 #define OPTi9XX_HW_DETECT       0
 #define OPTi9XX_HW_82C928       1
@@ -96,7 +103,6 @@ MODULE_PARM_DESC(ide, "enable ide port");
 
 #define OPTi9XX_MC_REG(n)       n
 
-
 struct snd_miro {
         unsigned short hardware;
         unsigned char password;
@@ -110,7 +116,6 @@ struct snd_miro {
         unsigned long pwd_reg;
 
         spinlock_t lock;
-        struct snd_card *card;
         struct snd_pcm *pcm;
 
         long wss_base;
@@ -118,42 +123,48 @@ struct snd_miro {
         int dma1;
         int dma2;
 
-        long fm_port;
-
         long mpu_port;
         int mpu_irq;
 
-        unsigned long aci_port;
-        int aci_vendor;
-        int aci_product;
-        int aci_version;
-        int aci_amp;
-        int aci_preamp;
-        int aci_solomode;
-
-        struct mutex aci_mutex;
+        struct snd_miro_aci *aci;
 };
 
-static void snd_miro_proc_init(struct snd_miro * miro);
+static struct snd_miro_aci aci_device;
 
 static char * snd_opti9xx_names[] = {
-        "unkown",
+        "unknown",
         "82C928", "82C929",
         "82C924", "82C925",
         "82C930", "82C931", "82C933"
 };
 
+static int snd_miro_pnp_is_probed;
+
+#ifdef CONFIG_PNP
+
+static struct pnp_card_device_id snd_miro_pnpids[] = {
+        /* PCM20 and PCM12 in PnP mode */
+        { .id = "MIR0924",
+          .devs = { { "MIR0000" }, { "MIR0002" }, { "MIR0005" } }, },
+        { .id = "" }
+};
+
+MODULE_DEVICE_TABLE(pnp_card, snd_miro_pnpids);
+
+#endif  /* CONFIG_PNP */
+
 /* 
  *  ACI control
  */
 
-static int aci_busy_wait(struct snd_miro * miro)
+static int aci_busy_wait(struct snd_miro_aci *aci)
 {
         long timeout;
         unsigned char byte;
 
-        for (timeout = 1; timeout <= ACI_MINTIME+30; timeout++) {
-                if (((byte=inb(miro->aci_port + ACI_REG_BUSY)) & 1) == 0) {
+        for (timeout = 1; timeout <= ACI_MINTIME + 30; timeout++) {
+                byte = inb(aci->aci_port + ACI_REG_BUSY);
+                if ((byte & 1) == 0) {
                         if (timeout >= ACI_MINTIME)
                                 snd_printd("aci ready in round %ld.\n",
                                            timeout-ACI_MINTIME);
@@ -179,10 +190,10 @@ static int aci_busy_wait(struct snd_miro * miro)
         return -EBUSY;
 }
 
-static inline int aci_write(struct snd_miro * miro, unsigned char byte)
+static inline int aci_write(struct snd_miro_aci *aci, unsigned char byte)
 {
-        if (aci_busy_wait(miro) >= 0) {
-                outb(byte, miro->aci_port + ACI_REG_COMMAND);
+        if (aci_busy_wait(aci) >= 0) {
+                outb(byte, aci->aci_port + ACI_REG_COMMAND);
                 return 0;
         } else {
                 snd_printk(KERN_ERR "aci busy, aci_write(0x%x) stopped.\n", byte);
@@ -190,12 +201,12 @@ static inline int aci_write(struct snd_miro * miro, unsigned char byte)
         }
 }
 
-static inline int aci_read(struct snd_miro * miro)
+static inline int aci_read(struct snd_miro_aci *aci)
 {
         unsigned char byte;
 
-        if (aci_busy_wait(miro) >= 0) {
-                byte=inb(miro->aci_port + ACI_REG_STATUS);
+        if (aci_busy_wait(aci) >= 0) {
+                byte = inb(aci->aci_port + ACI_REG_STATUS);
                 return byte;
         } else {
                 snd_printk(KERN_ERR "aci busy, aci_read() stopped.\n");
@@ -203,39 +214,49 @@ static inline int aci_read(struct snd_miro * miro)
         }
 }
 
-static int aci_cmd(struct snd_miro * miro, int write1, int write2, int write3)
+int snd_aci_cmd(struct snd_miro_aci *aci, int write1, int write2, int write3)
 {
         int write[] = {write1, write2, write3};
         int value, i;
 
-        if (mutex_lock_interruptible(&miro->aci_mutex))
+        if (mutex_lock_interruptible(&aci->aci_mutex))
                 return -EINTR;
 
         for (i=0; i<3; i++) {
                 if (write[i]< 0 || write[i] > 255)
                         break;
                 else {
-                        value = aci_write(miro, write[i]);
+                        value = aci_write(aci, write[i]);
                         if (value < 0)
                                 goto out;
                 }
         }
 
-        value = aci_read(miro);
+        value = aci_read(aci);
 
-out:    mutex_unlock(&miro->aci_mutex);
+out:    mutex_unlock(&aci->aci_mutex);
         return value;
 }
+EXPORT_SYMBOL(snd_aci_cmd);
+
+static int aci_getvalue(struct snd_miro_aci *aci, unsigned char index)
+{
+        return snd_aci_cmd(aci, ACI_STATUS, index, -1);
+}
 
-static int aci_getvalue(struct snd_miro * miro, unsigned char index)
+static int aci_setvalue(struct snd_miro_aci *aci, unsigned char index,
+                        int value)
 {
-        return aci_cmd(miro, ACI_STATUS, index, -1);
+        return snd_aci_cmd(aci, index, value, -1);
 }
 
-static int aci_setvalue(struct snd_miro * miro, unsigned char index, int value)
+struct snd_miro_aci *snd_aci_get_aci(void)
 {
-        return aci_cmd(miro, index, value, -1);
+        if (aci_device.aci_port == 0)
+                return NULL;
+        return &aci_device;
 }
+EXPORT_SYMBOL(snd_aci_get_aci);
 
 /*
  *  MIXER part
@@ -249,8 +270,10 @@ static int snd_miro_get_capture(struct snd_kcontrol *kcontrol,
         struct snd_miro *miro = snd_kcontrol_chip(kcontrol);
         int value;
 
-        if ((value = aci_getvalue(miro, ACI_S_GENERAL)) < 0) {
-                snd_printk(KERN_ERR "snd_miro_get_capture() failed: %d\n", value);
+        value = aci_getvalue(miro->aci, ACI_S_GENERAL);
+        if (value < 0) {
+                snd_printk(KERN_ERR "snd_miro_get_capture() failed: %d\n",
+                           value);
                 return value;
         }
 
@@ -267,13 +290,15 @@ static int snd_miro_put_capture(struct snd_kcontrol *kcontrol,
 
         value = !(ucontrol->value.integer.value[0]);
 
-        if ((error = aci_setvalue(miro, ACI_SET_SOLOMODE, value)) < 0) {
-                snd_printk(KERN_ERR "snd_miro_put_capture() failed: %d\n", error);
+        error = aci_setvalue(miro->aci, ACI_SET_SOLOMODE, value);
+        if (error < 0) {
+                snd_printk(KERN_ERR "snd_miro_put_capture() failed: %d\n",
+                           error);
                 return error;
         }
 
-        change = (value != miro->aci_solomode);
-        miro->aci_solomode = value;
+        change = (value != miro->aci->aci_solomode);
+        miro->aci->aci_solomode = value;
         
         return change;
 }
@@ -295,7 +320,7 @@ static int snd_miro_get_preamp(struct snd_kcontrol *kcontrol,
         struct snd_miro *miro = snd_kcontrol_chip(kcontrol);
         int value;
 
-        if (miro->aci_version <= 176) {
+        if (miro->aci->aci_version <= 176) {
 
                 /* 
                    OSS says it's not readable with versions < 176.
@@ -303,12 +328,14 @@ static int snd_miro_get_preamp(struct snd_kcontrol *kcontrol,
                    which is a PCM12 with aci_version = 176.
                 */
 
-                ucontrol->value.integer.value[0] = miro->aci_preamp;
+                ucontrol->value.integer.value[0] = miro->aci->aci_preamp;
                 return 0;
         }
 
-        if ((value = aci_getvalue(miro, ACI_GET_PREAMP)) < 0) {
-                snd_printk(KERN_ERR "snd_miro_get_preamp() failed: %d\n", value);
+        value = aci_getvalue(miro->aci, ACI_GET_PREAMP);
+        if (value < 0) {
+                snd_printk(KERN_ERR "snd_miro_get_preamp() failed: %d\n",
+                           value);
                 return value;
         }
         
@@ -325,13 +352,15 @@ static int snd_miro_put_preamp(struct snd_kcontrol *kcontrol,
 
         value = ucontrol->value.integer.value[0];
 
-        if ((error = aci_setvalue(miro, ACI_SET_PREAMP, value)) < 0) {
-                snd_printk(KERN_ERR "snd_miro_put_preamp() failed: %d\n", error);
+        error = aci_setvalue(miro->aci, ACI_SET_PREAMP, value);
+        if (error < 0) {
+                snd_printk(KERN_ERR "snd_miro_put_preamp() failed: %d\n",
+                           error);
                 return error;
         }
 
-        change = (value != miro->aci_preamp);
-        miro->aci_preamp = value;
+        change = (value != miro->aci->aci_preamp);
+        miro->aci->aci_preamp = value;
 
         return change;
 }
@@ -342,7 +371,7 @@ static int snd_miro_get_amp(struct snd_kcontrol *kcontrol,
                             struct snd_ctl_elem_value *ucontrol)
 {
         struct snd_miro *miro = snd_kcontrol_chip(kcontrol);
-        ucontrol->value.integer.value[0] = miro->aci_amp;
+        ucontrol->value.integer.value[0] = miro->aci->aci_amp;
 
         return 0;
 }
@@ -355,13 +384,14 @@ static int snd_miro_put_amp(struct snd_kcontrol *kcontrol,
 
         value = ucontrol->value.integer.value[0];
 
-        if ((error = aci_setvalue(miro, ACI_SET_POWERAMP, value)) < 0) {
+        error = aci_setvalue(miro->aci, ACI_SET_POWERAMP, value);
+        if (error < 0) {
                 snd_printk(KERN_ERR "snd_miro_put_amp() to %d failed: %d\n", value, error);
                 return error;
         }
 
-        change = (value != miro->aci_amp);
-        miro->aci_amp = value;
+        change = (value != miro->aci->aci_amp);
+        miro->aci->aci_amp = value;
 
         return change;
 }
@@ -410,12 +440,14 @@ static int snd_miro_get_double(struct snd_kcontrol *kcontrol,
         int right_reg = kcontrol->private_value & 0xff;
         int left_reg = right_reg + 1;
 
-        if ((right_val = aci_getvalue(miro, right_reg)) < 0) {
+        right_val = aci_getvalue(miro->aci, right_reg);
+        if (right_val < 0) {
                 snd_printk(KERN_ERR "aci_getvalue(%d) failed: %d\n", right_reg, right_val);
                 return right_val;
         }
 
-        if ((left_val = aci_getvalue(miro, left_reg)) < 0) {
+        left_val = aci_getvalue(miro->aci, left_reg);
+        if (left_val < 0) {
                 snd_printk(KERN_ERR "aci_getvalue(%d) failed: %d\n", left_reg, left_val);
                 return left_val;
         }
@@ -451,6 +483,7 @@ static int snd_miro_put_double(struct snd_kcontrol *kcontrol,
                                struct snd_ctl_elem_value *ucontrol)
 {
         struct snd_miro *miro = snd_kcontrol_chip(kcontrol);
+        struct snd_miro_aci *aci = miro->aci;
         int left, right, left_old, right_old;
         int setreg_left, setreg_right, getreg_left, getreg_right;
         int change, error;
@@ -459,21 +492,21 @@ static int snd_miro_put_double(struct snd_kcontrol *kcontrol,
         right = ucontrol->value.integer.value[1];
 
         setreg_right = (kcontrol->private_value >> 8) & 0xff;
-        if (setreg_right == ACI_SET_MASTER) {
-                setreg_left = setreg_right + 1;
-        } else {
-                setreg_left = setreg_right + 8;
-        }
+        setreg_left = setreg_right + 8;
+        if (setreg_right == ACI_SET_MASTER)
+                setreg_left -= 7;
 
         getreg_right = kcontrol->private_value & 0xff;
         getreg_left = getreg_right + 1;
 
-        if ((left_old = aci_getvalue(miro, getreg_left)) < 0) {
+        left_old = aci_getvalue(aci, getreg_left);
+        if (left_old < 0) {
                 snd_printk(KERN_ERR "aci_getvalue(%d) failed: %d\n", getreg_left, left_old);
                 return left_old;
         }
 
-        if ((right_old = aci_getvalue(miro, getreg_right)) < 0) {
+        right_old = aci_getvalue(aci, getreg_right);
+        if (right_old < 0) {
                 snd_printk(KERN_ERR "aci_getvalue(%d) failed: %d\n", getreg_right, right_old);
                 return right_old;
         }
@@ -492,13 +525,15 @@ static int snd_miro_put_double(struct snd_kcontrol *kcontrol,
                         right_old = 0x80 - right_old;
 
                 if (left >= 0) {
-                        if ((error = aci_setvalue(miro, setreg_left, left)) < 0) {
+                        error = aci_setvalue(aci, setreg_left, left);
+                        if (error < 0) {
                                 snd_printk(KERN_ERR "aci_setvalue(%d) failed: %d\n",
                                            left, error);
                                 return error;
                         }
                 } else {
-                        if ((error = aci_setvalue(miro, setreg_left, 0x80 - left)) < 0) {
+                        error = aci_setvalue(aci, setreg_left, 0x80 - left);
+                        if (error < 0) {
                                 snd_printk(KERN_ERR "aci_setvalue(%d) failed: %d\n",
                                            0x80 - left, error);
                                 return error;
@@ -506,13 +541,15 @@ static int snd_miro_put_double(struct snd_kcontrol *kcontrol,
                 }
 
                 if (right >= 0) {
-                        if ((error = aci_setvalue(miro, setreg_right, right)) < 0) {
+                        error = aci_setvalue(aci, setreg_right, right);
+                        if (error < 0) {
                                 snd_printk(KERN_ERR "aci_setvalue(%d) failed: %d\n",
                                            right, error);
                                 return error;
                         }
                 } else {
-                        if ((error = aci_setvalue(miro, setreg_right, 0x80 - right)) < 0) {
+                        error = aci_setvalue(aci, setreg_right, 0x80 - right);
+                        if (error < 0) {
                                 snd_printk(KERN_ERR "aci_setvalue(%d) failed: %d\n",
                                            0x80 - right, error);
                                 return error;
@@ -530,12 +567,14 @@ static int snd_miro_put_double(struct snd_kcontrol *kcontrol,
                 left_old = 0x20 - left_old;
                 right_old = 0x20 - right_old;
 
-                if ((error = aci_setvalue(miro, setreg_left, 0x20 - left)) < 0) {
+                error = aci_setvalue(aci, setreg_left, 0x20 - left);
+                if (error < 0) {
                         snd_printk(KERN_ERR "aci_setvalue(%d) failed: %d\n",
                                    0x20 - left, error);
                         return error;
                 }
-                if ((error = aci_setvalue(miro, setreg_right, 0x20 - right)) < 0) {
+                error = aci_setvalue(aci, setreg_right, 0x20 - right);
+                if (error < 0) {
                         snd_printk(KERN_ERR "aci_setvalue(%d) failed: %d\n",
                                    0x20 - right, error);
                         return error;
@@ -633,11 +672,13 @@ static unsigned char aci_init_values[][2] __devinitdata = {
 static int __devinit snd_set_aci_init_values(struct snd_miro *miro)
 {
         int idx, error;
+        struct snd_miro_aci *aci = miro->aci;
 
         /* enable WSS on PCM1 */
 
-        if ((miro->aci_product == 'A') && wss) {
-                if ((error = aci_setvalue(miro, ACI_SET_WSS, wss)) < 0) {
+        if ((aci->aci_product == 'A') && wss) {
+                error = aci_setvalue(aci, ACI_SET_WSS, wss);
+                if (error < 0) {
                         snd_printk(KERN_ERR "enabling WSS mode failed\n");
                         return error;
                 }
@@ -646,7 +687,8 @@ static int __devinit snd_set_aci_init_values(struct snd_miro *miro)
         /* enable IDE port */
 
         if (ide) {
-                if ((error = aci_setvalue(miro, ACI_SET_IDE, ide)) < 0) {
+                error = aci_setvalue(aci, ACI_SET_IDE, ide);
+                if (error < 0) {
                         snd_printk(KERN_ERR "enabling IDE port failed\n");
                         return error;
                 }
@@ -654,32 +696,31 @@ static int __devinit snd_set_aci_init_values(struct snd_miro *miro)
 
         /* set common aci values */
 
-        for (idx = 0; idx < ARRAY_SIZE(aci_init_values); idx++)
-                if ((error = aci_setvalue(miro, aci_init_values[idx][0], 
-                                          aci_init_values[idx][1])) < 0) {
+        for (idx = 0; idx < ARRAY_SIZE(aci_init_values); idx++) {
+                error = aci_setvalue(aci, aci_init_values[idx][0],
+                                     aci_init_values[idx][1]);
+                if (error < 0) {
                         snd_printk(KERN_ERR "aci_setvalue(%d) failed: %d\n", 
                                    aci_init_values[idx][0], error);
                         return error;
                 }
-
-        miro->aci_amp = 0;
-        miro->aci_preamp = 0;
-        miro->aci_solomode = 1;
+        }
+        aci->aci_amp = 0;
+        aci->aci_preamp = 0;
+        aci->aci_solomode = 1;
 
         return 0;
 }
 
-static int __devinit snd_miro_mixer(struct snd_miro *miro)
+static int __devinit snd_miro_mixer(struct snd_card *card,
+                                    struct snd_miro *miro)
 {
-        struct snd_card *card;
         unsigned int idx;
         int err;
 
-        if (snd_BUG_ON(!miro || !miro->card))
+        if (snd_BUG_ON(!miro || !card))
                 return -EINVAL;
 
-        card = miro->card;
-
         switch (miro->hardware) {
         case OPTi9XX_HW_82C924:
                 strcpy(card->mixername, "ACI & OPTi924");
@@ -697,7 +738,8 @@ static int __devinit snd_miro_mixer(struct snd_miro *miro)
                         return err;
         }
 
-        if ((miro->aci_product == 'A') || (miro->aci_product == 'B')) {
+        if ((miro->aci->aci_product == 'A') ||
+            (miro->aci->aci_product == 'B')) {
                 /* PCM1/PCM12 with power-amp and Line 2 */
                 if ((err = snd_ctl_add(card, snd_ctl_new1(&snd_miro_line_control[0], miro))) < 0)
                         return err;
@@ -705,16 +747,17 @@ static int __devinit snd_miro_mixer(struct snd_miro *miro)
                         return err;
         }
 
-        if ((miro->aci_product == 'B') || (miro->aci_product == 'C')) {
+        if ((miro->aci->aci_product == 'B') ||
+            (miro->aci->aci_product == 'C')) {
                 /* PCM12/PCM20 with mic-preamp */
                 if ((err = snd_ctl_add(card, snd_ctl_new1(&snd_miro_preamp_control[0], miro))) < 0)
                         return err;
-                if (miro->aci_version >= 176)
+                if (miro->aci->aci_version >= 176)
                         if ((err = snd_ctl_add(card, snd_ctl_new1(&snd_miro_capture_control[0], miro))) < 0)
                                 return err;
         }
 
-        if (miro->aci_product == 'C') {
+        if (miro->aci->aci_product == 'C') {
                 /* PCM20 with radio and 7 band equalizer */
                 if ((err = snd_ctl_add(card, snd_ctl_new1(&snd_miro_radio_control[0], miro))) < 0)
                         return err;
@@ -757,21 +800,26 @@ static int __devinit snd_miro_init(struct snd_miro *chip,
         chip->irq = -1;
         chip->dma1 = -1;
         chip->dma2 = -1;
-        chip->fm_port = -1;
         chip->mpu_port = -1;
         chip->mpu_irq = -1;
 
+        chip->pwd_reg = 3;
+
+#ifdef CONFIG_PNP
+        if (isapnp && chip->mc_base)
+                /* PnP resource gives the least 10 bits */
+                chip->mc_base |= 0xc00;
+        else
+#endif
+                chip->mc_base = 0xf8c;
+
         switch (hardware) {
         case OPTi9XX_HW_82C929:
-                chip->mc_base = 0xf8c;
                 chip->password = 0xe3;
-                chip->pwd_reg = 3;
                 break;
 
         case OPTi9XX_HW_82C924:
-                chip->mc_base = 0xf8c;
                 chip->password = 0xe5;
-                chip->pwd_reg = 3;
                 break;
 
         default:
@@ -853,14 +901,15 @@ static void snd_miro_proc_read(struct snd_info_entry * entry,
                                struct snd_info_buffer *buffer)
 {
         struct snd_miro *miro = (struct snd_miro *) entry->private_data;
+        struct snd_miro_aci *aci = miro->aci;
         char* model = "unknown";
 
         /* miroSOUND PCM1 pro, early PCM12 */
 
         if ((miro->hardware == OPTi9XX_HW_82C929) &&
-            (miro->aci_vendor == 'm') && 
-            (miro->aci_product == 'A')) {
-                switch(miro->aci_version) {
+            (aci->aci_vendor == 'm') &&
+            (aci->aci_product == 'A')) {
+                switch (aci->aci_version) {
                 case 3:
                         model = "miroSOUND PCM1 pro";
                         break;
@@ -873,9 +922,9 @@ static void snd_miro_proc_read(struct snd_info_entry * entry,
         /* miroSOUND PCM12, PCM12 (Rev. E), PCM12 pnp */
 
         if ((miro->hardware == OPTi9XX_HW_82C924) &&
-            (miro->aci_vendor == 'm') && 
-            (miro->aci_product == 'B')) {
-                switch(miro->aci_version) {
+            (aci->aci_vendor == 'm') &&
+            (aci->aci_product == 'B')) {
+                switch (aci->aci_version) {
                 case 4:
                         model = "miroSOUND PCM12";
                         break;
@@ -891,9 +940,9 @@ static void snd_miro_proc_read(struct snd_info_entry * entry,
         /* miroSOUND PCM20 radio */
 
         if ((miro->hardware == OPTi9XX_HW_82C924) &&
-            (miro->aci_vendor == 'm') && 
-            (miro->aci_product == 'C')) {
-                switch(miro->aci_version) {
+            (aci->aci_vendor == 'm') &&
+            (aci->aci_product == 'C')) {
+                switch (aci->aci_version) {
                 case 7:
                         model = "miroSOUND PCM20 radio (Rev. E)";
                         break;
@@ -917,17 +966,17 @@ static void snd_miro_proc_read(struct snd_info_entry * entry,
 
         snd_iprintf(buffer, "ACI information:\n");
         snd_iprintf(buffer, "  vendor  : ");
-        switch(miro->aci_vendor) {
+        switch (aci->aci_vendor) {
         case 'm':
                 snd_iprintf(buffer, "Miro\n");
                 break;
         default:
-                snd_iprintf(buffer, "unknown (0x%x)\n", miro->aci_vendor);
+                snd_iprintf(buffer, "unknown (0x%x)\n", aci->aci_vendor);
                 break;
         }
 
         snd_iprintf(buffer, "  product : ");
-        switch(miro->aci_product) {
+        switch (aci->aci_product) {
         case 'A':
                 snd_iprintf(buffer, "miroSOUND PCM1 pro / (early) PCM12\n");
                 break;
@@ -938,26 +987,27 @@ static void snd_miro_proc_read(struct snd_info_entry * entry,
                 snd_iprintf(buffer, "miroSOUND PCM20 radio\n");
                 break;
         default:
-                snd_iprintf(buffer, "unknown (0x%x)\n", miro->aci_product);
+                snd_iprintf(buffer, "unknown (0x%x)\n", aci->aci_product);
                 break;
         }
 
         snd_iprintf(buffer, "  firmware: %d (0x%x)\n",
-                    miro->aci_version, miro->aci_version);
+                    aci->aci_version, aci->aci_version);
         snd_iprintf(buffer, "  port    : 0x%lx-0x%lx\n", 
-                    miro->aci_port, miro->aci_port+2);
+                    aci->aci_port, aci->aci_port+2);
         snd_iprintf(buffer, "  wss     : 0x%x\n", wss);
         snd_iprintf(buffer, "  ide     : 0x%x\n", ide);
-        snd_iprintf(buffer, "  solomode: 0x%x\n", miro->aci_solomode);
-        snd_iprintf(buffer, "  amp     : 0x%x\n", miro->aci_amp);
-        snd_iprintf(buffer, "  preamp  : 0x%x\n", miro->aci_preamp);
+        snd_iprintf(buffer, "  solomode: 0x%x\n", aci->aci_solomode);
+        snd_iprintf(buffer, "  amp     : 0x%x\n", aci->aci_amp);
+        snd_iprintf(buffer, "  preamp  : 0x%x\n", aci->aci_preamp);
 }
 
-static void __devinit snd_miro_proc_init(struct snd_miro * miro)
+static void __devinit snd_miro_proc_init(struct snd_card *card,
+                                         struct snd_miro *miro)
 {
         struct snd_info_entry *entry;
 
-        if (! snd_card_proc_new(miro->card, "miro", &entry))
+        if (!snd_card_proc_new(card, "miro", &entry))
                 snd_info_set_text_ops(entry, miro, snd_miro_proc_read);
 }
 
@@ -974,37 +1024,40 @@ static int __devinit snd_miro_configure(struct snd_miro *chip)
         unsigned char mpu_irq_bits;
         unsigned long flags;
 
+        snd_miro_write_mask(chip, OPTi9XX_MC_REG(1), 0x80, 0x80);
+        snd_miro_write_mask(chip, OPTi9XX_MC_REG(2), 0x20, 0x20); /* OPL4 */
+        snd_miro_write_mask(chip, OPTi9XX_MC_REG(5), 0x02, 0x02);
+
         switch (chip->hardware) {
         case OPTi9XX_HW_82C924:
                 snd_miro_write_mask(chip, OPTi9XX_MC_REG(6), 0x02, 0x02);
-                snd_miro_write_mask(chip, OPTi9XX_MC_REG(1), 0x80, 0x80);
-                snd_miro_write_mask(chip, OPTi9XX_MC_REG(2), 0x20, 0x20); /* OPL4 */
                 snd_miro_write_mask(chip, OPTi9XX_MC_REG(3), 0xf0, 0xff);
-                snd_miro_write_mask(chip, OPTi9XX_MC_REG(5), 0x02, 0x02);
                 break;
         case OPTi9XX_HW_82C929:
                 /* untested init commands for OPTi929 */
-                snd_miro_write_mask(chip, OPTi9XX_MC_REG(1), 0x80, 0x80);
-                snd_miro_write_mask(chip, OPTi9XX_MC_REG(2), 0x20, 0x20); /* OPL4 */
                 snd_miro_write_mask(chip, OPTi9XX_MC_REG(4), 0x00, 0x0c);
-                snd_miro_write_mask(chip, OPTi9XX_MC_REG(5), 0x02, 0x02);
                 break;
         default:
                 snd_printk(KERN_ERR "chip %d not supported\n", chip->hardware);
                 return -EINVAL;
         }
 
-        switch (chip->wss_base) {
-        case 0x530:
+        /* PnP resource says it decodes only 10 bits of address */
+        switch (chip->wss_base & 0x3ff) {
+        case 0x130:
+                chip->wss_base = 0x530;
                 wss_base_bits = 0x00;
                 break;
-        case 0x604:
+        case 0x204:
+                chip->wss_base = 0x604;
                 wss_base_bits = 0x03;
                 break;
-        case 0xe80:
+        case 0x280:
+                chip->wss_base = 0xe80;
                 wss_base_bits = 0x01;
                 break;
-        case 0xf40:
+        case 0x340:
+                chip->wss_base = 0xf40;
                 wss_base_bits = 0x02;
                 break;
         default:
@@ -1122,75 +1175,92 @@ __skip_mpu:
         return 0;
 }
 
+static int __devinit snd_miro_opti_check(struct snd_miro *chip)
+{
+        unsigned char value;
+
+        chip->res_mc_base = request_region(chip->mc_base, chip->mc_base_size,
+                                           "OPTi9xx MC");
+        if (chip->res_mc_base == NULL)
+                return -ENOMEM;
+
+        value = snd_miro_read(chip, OPTi9XX_MC_REG(1));
+        if (value != 0xff && value != inb(chip->mc_base + OPTi9XX_MC_REG(1)))
+                if (value == snd_miro_read(chip, OPTi9XX_MC_REG(1)))
+                        return 0;
+
+        release_and_free_resource(chip->res_mc_base);
+        chip->res_mc_base = NULL;
+
+        return -ENODEV;
+}
+
 static int __devinit snd_card_miro_detect(struct snd_card *card,
                                           struct snd_miro *chip)
 {
         int i, err;
-        unsigned char value;
 
         for (i = OPTi9XX_HW_82C929; i <= OPTi9XX_HW_82C924; i++) {
 
                 if ((err = snd_miro_init(chip, i)) < 0)
                         return err;
 
-                if ((chip->res_mc_base = request_region(chip->mc_base, chip->mc_base_size, "OPTi9xx MC")) == NULL)
-                        continue;
-
-                value = snd_miro_read(chip, OPTi9XX_MC_REG(1));
-                if ((value != 0xff) && (value != inb(chip->mc_base + 1)))
-                        if (value == snd_miro_read(chip, OPTi9XX_MC_REG(1)))
-                                return 1;
-
-                release_and_free_resource(chip->res_mc_base);
-                chip->res_mc_base = NULL;
-
+                err = snd_miro_opti_check(chip);
+                if (err == 0)
+                        return 1;
         }
 
         return -ENODEV;
 }
 
 static int __devinit snd_card_miro_aci_detect(struct snd_card *card,
-                                              struct snd_miro * miro)
+                                              struct snd_miro *miro)
 {
         unsigned char regval;
         int i;
+        struct snd_miro_aci *aci = &aci_device;
+
+        miro->aci = aci;
 
-        mutex_init(&miro->aci_mutex);
+        mutex_init(&aci->aci_mutex);
 
         /* get ACI port from OPTi9xx MC 4 */
 
-        miro->mc_base = 0xf8c;
         regval=inb(miro->mc_base + 4);
-        miro->aci_port = (regval & 0x10) ? 0x344: 0x354;
+        aci->aci_port = (regval & 0x10) ? 0x344 : 0x354;
 
-        if ((miro->res_aci_port = request_region(miro->aci_port, 3, "miro aci")) == NULL) {
+        miro->res_aci_port = request_region(aci->aci_port, 3, "miro aci");
+        if (miro->res_aci_port == NULL) {
                 snd_printk(KERN_ERR "aci i/o area 0x%lx-0x%lx already used.\n", 
-                           miro->aci_port, miro->aci_port+2);
+                           aci->aci_port, aci->aci_port+2);
                 return -ENOMEM;
         }
 
         /* force ACI into a known state */
         for (i = 0; i < 3; i++)
-                if (aci_cmd(miro, ACI_ERROR_OP, -1, -1) < 0) {
+                if (snd_aci_cmd(aci, ACI_ERROR_OP, -1, -1) < 0) {
                         snd_printk(KERN_ERR "can't force aci into known state.\n");
                         return -ENXIO;
                 }
 
-        if ((miro->aci_vendor=aci_cmd(miro, ACI_READ_IDCODE, -1, -1)) < 0 ||
-            (miro->aci_product=aci_cmd(miro, ACI_READ_IDCODE, -1, -1)) < 0) {
-                snd_printk(KERN_ERR "can't read aci id on 0x%lx.\n", miro->aci_port);
+        aci->aci_vendor = snd_aci_cmd(aci, ACI_READ_IDCODE, -1, -1);
+        aci->aci_product = snd_aci_cmd(aci, ACI_READ_IDCODE, -1, -1);
+        if (aci->aci_vendor < 0 || aci->aci_product < 0) {
+                snd_printk(KERN_ERR "can't read aci id on 0x%lx.\n",
+                           aci->aci_port);
                 return -ENXIO;
         }
 
-        if ((miro->aci_version=aci_cmd(miro, ACI_READ_VERSION, -1, -1)) < 0) {
+        aci->aci_version = snd_aci_cmd(aci, ACI_READ_VERSION, -1, -1);
+        if (aci->aci_version < 0) {
                 snd_printk(KERN_ERR "can't read aci version on 0x%lx.\n", 
-                           miro->aci_port);
+                           aci->aci_port);
                 return -ENXIO;
         }
 
-        if (aci_cmd(miro, ACI_INIT, -1, -1) < 0 ||
-            aci_cmd(miro, ACI_ERROR_OP, ACI_ERROR_OP, ACI_ERROR_OP) < 0 ||
-            aci_cmd(miro, ACI_ERROR_OP, ACI_ERROR_OP, ACI_ERROR_OP) < 0) {
+        if (snd_aci_cmd(aci, ACI_INIT, -1, -1) < 0 ||
+            snd_aci_cmd(aci, ACI_ERROR_OP, ACI_ERROR_OP, ACI_ERROR_OP) < 0 ||
+            snd_aci_cmd(aci, ACI_ERROR_OP, ACI_ERROR_OP, ACI_ERROR_OP) < 0) {
                 snd_printk(KERN_ERR "can't initialize aci.\n"); 
                 return -ENXIO;
         }
@@ -1201,157 +1271,80 @@ static int __devinit snd_card_miro_aci_detect(struct snd_card *card,
 static void snd_card_miro_free(struct snd_card *card)
 {
         struct snd_miro *miro = card->private_data;
-        
+
         release_and_free_resource(miro->res_aci_port);
+        if (miro->aci)
+                miro->aci->aci_port = 0;
         release_and_free_resource(miro->res_mc_base);
 }
 
-static int __devinit snd_miro_match(struct device *devptr, unsigned int n)
-{
-        return 1;
-}
-
-static int __devinit snd_miro_probe(struct device *devptr, unsigned int n)
+static int __devinit snd_miro_probe(struct snd_card *card)
 {
-        static long possible_ports[] = {0x530, 0xe80, 0xf40, 0x604, -1};
-        static long possible_mpu_ports[] = {0x330, 0x300, 0x310, 0x320, -1};
-        static int possible_irqs[] = {11, 9, 10, 7, -1};
-        static int possible_mpu_irqs[] = {10, 5, 9, 7, -1};
-        static int possible_dma1s[] = {3, 1, 0, -1};
-        static int possible_dma2s[][2] = {{1,-1}, {0,-1}, {-1,-1}, {0,-1}};
-
         int error;
-        struct snd_miro *miro;
+        struct snd_miro *miro = card->private_data;
         struct snd_wss *codec;
         struct snd_timer *timer;
-        struct snd_card *card;
         struct snd_pcm *pcm;
         struct snd_rawmidi *rmidi;
 
-        error = snd_card_create(index, id, THIS_MODULE,
-                                sizeof(struct snd_miro), &card);
-        if (error < 0)
-                return error;
-
-        card->private_free = snd_card_miro_free;
-        miro = card->private_data;
-        miro->card = card;
-
-        if ((error = snd_card_miro_aci_detect(card, miro)) < 0) {
-                snd_card_free(card);
-                snd_printk(KERN_ERR "unable to detect aci chip\n");
-                return -ENODEV;
+        if (!miro->res_mc_base) {
+                miro->res_mc_base = request_region(miro->mc_base,
+                                                miro->mc_base_size,
+                                                "miro (OPTi9xx MC)");
+                if (miro->res_mc_base == NULL) {
+                        snd_printk(KERN_ERR "request for OPTI9xx MC failed\n");
+                        return -ENOMEM;
+                }
         }
 
-        /* init proc interface */
-        snd_miro_proc_init(miro);
-
-        if ((error = snd_card_miro_detect(card, miro)) < 0) {
+        error = snd_card_miro_aci_detect(card, miro);
+        if (error < 0) {
                 snd_card_free(card);
-                snd_printk(KERN_ERR "unable to detect OPTi9xx chip\n");
+                snd_printk(KERN_ERR "unable to detect aci chip\n");
                 return -ENODEV;
         }
 
-        if (! miro->res_mc_base &&
-            (miro->res_mc_base = request_region(miro->mc_base, miro->mc_base_size,
-                                                "miro (OPTi9xx MC)")) == NULL) {
-                snd_card_free(card);
-                snd_printk(KERN_ERR "request for OPTI9xx MC failed\n");
-                return -ENOMEM;
-        }
-
         miro->wss_base = port;
-        miro->fm_port = fm_port;
         miro->mpu_port = mpu_port;
         miro->irq = irq;
         miro->mpu_irq = mpu_irq;
         miro->dma1 = dma1;
         miro->dma2 = dma2;
 
-        if (miro->wss_base == SNDRV_AUTO_PORT) {
-                if ((miro->wss_base = snd_legacy_find_free_ioport(possible_ports, 4)) < 0) {
-                        snd_card_free(card);
-                        snd_printk(KERN_ERR "unable to find a free WSS port\n");
-                        return -EBUSY;
-                }
-        }
-
-        if (miro->mpu_port == SNDRV_AUTO_PORT) {
-                if ((miro->mpu_port = snd_legacy_find_free_ioport(possible_mpu_ports, 2)) < 0) {
-                        snd_card_free(card);
-                        snd_printk(KERN_ERR "unable to find a free MPU401 port\n");
-                        return -EBUSY;
-                }
-        }
-        if (miro->irq == SNDRV_AUTO_IRQ) {
-                if ((miro->irq = snd_legacy_find_free_irq(possible_irqs)) < 0) {
-                        snd_card_free(card);
-                        snd_printk(KERN_ERR "unable to find a free IRQ\n");
-                        return -EBUSY;
-                }
-        }
-        if (miro->mpu_irq == SNDRV_AUTO_IRQ) {
-                if ((miro->mpu_irq = snd_legacy_find_free_irq(possible_mpu_irqs)) < 0) {
-                        snd_card_free(card);
-                        snd_printk(KERN_ERR "unable to find a free MPU401 IRQ\n");
-                        return -EBUSY;
-                }
-        }
-        if (miro->dma1 == SNDRV_AUTO_DMA) {
-                if ((miro->dma1 = snd_legacy_find_free_dma(possible_dma1s)) < 0) {
-                        snd_card_free(card);
-                        snd_printk(KERN_ERR "unable to find a free DMA1\n");
-                        return -EBUSY;
-                }
-        }
-        if (miro->dma2 == SNDRV_AUTO_DMA) {
-                if ((miro->dma2 = snd_legacy_find_free_dma(possible_dma2s[miro->dma1 % 4])) < 0) {
-                        snd_card_free(card);
-                        snd_printk(KERN_ERR "unable to find a free DMA2\n");
-                        return -EBUSY;
-                }
-        }
+        /* init proc interface */
+        snd_miro_proc_init(card, miro);
 
         error = snd_miro_configure(miro);
-        if (error) {
-                snd_card_free(card);
+        if (error)
                 return error;
-        }
 
         error = snd_wss_create(card, miro->wss_base + 4, -1,
-                                miro->irq, miro->dma1, miro->dma2,
-                                WSS_HW_AD1845, 0, &codec);
-        if (error < 0) {
-                snd_card_free(card);
+                               miro->irq, miro->dma1, miro->dma2,
+                               WSS_HW_DETECT, 0, &codec);
+        if (error < 0)
                 return error;
-        }
 
         error = snd_wss_pcm(codec, 0, &pcm);
-        if (error < 0)  {
-                snd_card_free(card);
+        if (error < 0)
                 return error;
-        }
+
         error = snd_wss_mixer(codec);
-        if (error < 0) {
-                snd_card_free(card);
+        if (error < 0)
                 return error;
-        }
+
         error = snd_wss_timer(codec, 0, &timer);
-        if (error < 0) {
-                snd_card_free(card);
+        if (error < 0)
                 return error;
-        }
 
         miro->pcm = pcm;
 
-        if ((error = snd_miro_mixer(miro)) < 0) {
-                snd_card_free(card);
+        error = snd_miro_mixer(card, miro);
+        if (error < 0)
                 return error;
-        }
 
-        if (miro->aci_vendor == 'm') {
+        if (miro->aci->aci_vendor == 'm') {
                 /* It looks like a miro sound card. */
-                switch (miro->aci_product) {
+                switch (miro->aci->aci_product) {
                 case 'A':
                         sprintf(card->shortname, 
                                 "miroSOUND PCM1 pro / PCM12");
@@ -1380,30 +1373,131 @@ static int __devinit snd_miro_probe(struct device *devptr, unsigned int n)
                 card->shortname, miro->name, pcm->name, miro->wss_base + 4,
                 miro->irq, miro->dma1, miro->dma2);
 
-        if (miro->mpu_port <= 0 || miro->mpu_port == SNDRV_AUTO_PORT)
+        if (mpu_port <= 0 || mpu_port == SNDRV_AUTO_PORT)
                 rmidi = NULL;
-        else
-                if ((error = snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401,
-                                miro->mpu_port, 0, miro->mpu_irq, IRQF_DISABLED,
-                                &rmidi)))
-                        snd_printk(KERN_WARNING "no MPU-401 device at 0x%lx?\n", miro->mpu_port);
+        else {
+                error = snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401,
+                                mpu_port, 0, miro->mpu_irq, IRQF_DISABLED,
+                                &rmidi);
+                if (error < 0)
+                        snd_printk(KERN_WARNING "no MPU-401 device at 0x%lx?\n",
+                                   mpu_port);
+        }
 
-        if (miro->fm_port > 0 && miro->fm_port != SNDRV_AUTO_PORT) {
+        if (fm_port > 0 && fm_port != SNDRV_AUTO_PORT) {
                 struct snd_opl3 *opl3 = NULL;
                 struct snd_opl4 *opl4;
-                if (snd_opl4_create(card, miro->fm_port, miro->fm_port - 8, 
+
+                if (snd_opl4_create(card, fm_port, fm_port - 8,
                                     2, &opl3, &opl4) < 0)
-                        snd_printk(KERN_WARNING "no OPL4 device at 0x%lx\n", miro->fm_port);
+                        snd_printk(KERN_WARNING "no OPL4 device at 0x%lx\n",
+                                   fm_port);
         }
 
-        if ((error = snd_set_aci_init_values(miro)) < 0) {
-                snd_card_free(card);
+        error = snd_set_aci_init_values(miro);
+        if (error < 0)
                 return error;
+
+        return snd_card_register(card);
+}
+
+static int __devinit snd_miro_isa_match(struct device *devptr, unsigned int n)
+{
+#ifdef CONFIG_PNP
+        if (snd_miro_pnp_is_probed)
+                return 0;
+        if (isapnp)
+                return 0;
+#endif
+        return 1;
+}
+
+static int __devinit snd_miro_isa_probe(struct device *devptr, unsigned int n)
+{
+        static long possible_ports[] = {0x530, 0xe80, 0xf40, 0x604, -1};
+        static long possible_mpu_ports[] = {0x330, 0x300, 0x310, 0x320, -1};
+        static int possible_irqs[] = {11, 9, 10, 7, -1};
+        static int possible_mpu_irqs[] = {10, 5, 9, 7, -1};
+        static int possible_dma1s[] = {3, 1, 0, -1};
+        static int possible_dma2s[][2] = { {1, -1}, {0, -1}, {-1, -1},
+                                           {0, -1} };
+
+        int error;
+        struct snd_miro *miro;
+        struct snd_card *card;
+
+        error = snd_card_create(index, id, THIS_MODULE,
+                                sizeof(struct snd_miro), &card);
+        if (error < 0)
+                return error;
+
+        card->private_free = snd_card_miro_free;
+        miro = card->private_data;
+
+        error = snd_card_miro_detect(card, miro);
+        if (error < 0) {
+                snd_card_free(card);
+                snd_printk(KERN_ERR "unable to detect OPTi9xx chip\n");
+                return -ENODEV;
+        }
+
+        if (port == SNDRV_AUTO_PORT) {
+                port = snd_legacy_find_free_ioport(possible_ports, 4);
+                if (port < 0) {
+                        snd_card_free(card);
+                        snd_printk(KERN_ERR "unable to find a free WSS port\n");
+                        return -EBUSY;
+                }
+        }
+
+        if (mpu_port == SNDRV_AUTO_PORT) {
+                mpu_port = snd_legacy_find_free_ioport(possible_mpu_ports, 2);
+                if (mpu_port < 0) {
+                        snd_card_free(card);
+                        snd_printk(KERN_ERR
+                                   "unable to find a free MPU401 port\n");
+                        return -EBUSY;
+                }
+        }
+
+        if (irq == SNDRV_AUTO_IRQ) {
+                irq = snd_legacy_find_free_irq(possible_irqs);
+                if (irq < 0) {
+                        snd_card_free(card);
+                        snd_printk(KERN_ERR "unable to find a free IRQ\n");
+                        return -EBUSY;
+                }
+        }
+        if (mpu_irq == SNDRV_AUTO_IRQ) {
+                mpu_irq = snd_legacy_find_free_irq(possible_mpu_irqs);
+                if (mpu_irq < 0) {
+                        snd_card_free(card);
+                        snd_printk(KERN_ERR
+                                   "unable to find a free MPU401 IRQ\n");
+                        return -EBUSY;
+                }
+        }
+        if (dma1 == SNDRV_AUTO_DMA) {
+                dma1 = snd_legacy_find_free_dma(possible_dma1s);
+                if (dma1 < 0) {
+                        snd_card_free(card);
+                        snd_printk(KERN_ERR "unable to find a free DMA1\n");
+                        return -EBUSY;
+                }
+        }
+        if (dma2 == SNDRV_AUTO_DMA) {
+                dma2 = snd_legacy_find_free_dma(possible_dma2s[dma1 % 4]);
+                if (dma2 < 0) {
+                        snd_card_free(card);
+                        snd_printk(KERN_ERR "unable to find a free DMA2\n");
+                        return -EBUSY;
+                }
         }
 
         snd_card_set_dev(card, devptr);
 
-        if ((error = snd_card_register(card))) {
+        error = snd_miro_probe(card);
+        if (error < 0) {
                 snd_card_free(card);
                 return error;
         }
@@ -1412,7 +1506,8 @@ static int __devinit snd_miro_probe(struct device *devptr, unsigned int n)
         return 0;
 }
 
-static int __devexit snd_miro_remove(struct device *devptr, unsigned int dev)
+static int __devexit snd_miro_isa_remove(struct device *devptr,
+                                         unsigned int dev)
 {
         snd_card_free(dev_get_drvdata(devptr));
         dev_set_drvdata(devptr, NULL);
@@ -1422,23 +1517,164 @@ static int __devexit snd_miro_remove(struct device *devptr, unsigned int dev)
 #define DEV_NAME "miro"
 
 static struct isa_driver snd_miro_driver = {
-        .match          = snd_miro_match,
-        .probe          = snd_miro_probe,
-        .remove         = __devexit_p(snd_miro_remove),
+        .match          = snd_miro_isa_match,
+        .probe          = snd_miro_isa_probe,
+        .remove         = __devexit_p(snd_miro_isa_remove),
         /* FIXME: suspend/resume */
         .driver         = {
                 .name   = DEV_NAME
         },
 };
 
+#ifdef CONFIG_PNP
+
+static int __devinit snd_card_miro_pnp(struct snd_miro *chip,
+                                        struct pnp_card_link *card,
+                                        const struct pnp_card_device_id *pid)
+{
+        struct pnp_dev *pdev;
+        int err;
+        struct pnp_dev *devmpu;
+        struct pnp_dev *devmc;
+
+        pdev = pnp_request_card_device(card, pid->devs[0].id, NULL);
+        if (pdev == NULL)
+                return -EBUSY;
+
+        devmpu = pnp_request_card_device(card, pid->devs[1].id, NULL);
+        if (devmpu == NULL)
+                return -EBUSY;
+
+        devmc = pnp_request_card_device(card, pid->devs[2].id, NULL);
+        if (devmc == NULL)
+                return -EBUSY;
+
+        err = pnp_activate_dev(pdev);
+        if (err < 0) {
+                snd_printk(KERN_ERR "AUDIO pnp configure failure: %d\n", err);
+                return err;
+        }
+
+        err = pnp_activate_dev(devmc);
+        if (err < 0) {
+                snd_printk(KERN_ERR "MC pnp configure failure: %d\n",
+                                    err);
+                return err;
+        }
+
+        port = pnp_port_start(pdev, 1);
+        fm_port = pnp_port_start(pdev, 2) + 8;
+
+        /*
+         * The MC(0) is never accessed and the miroSOUND PCM20 card does not
+         * include it in the PnP resource range. OPTI93x include it.
+         */
+        chip->mc_base = pnp_port_start(devmc, 0) - 1;
+        chip->mc_base_size = pnp_port_len(devmc, 0) + 1;
+
+        irq = pnp_irq(pdev, 0);
+        dma1 = pnp_dma(pdev, 0);
+        dma2 = pnp_dma(pdev, 1);
+
+        if (mpu_port > 0) {
+                err = pnp_activate_dev(devmpu);
+                if (err < 0) {
+                        snd_printk(KERN_ERR "MPU401 pnp configure failure\n");
+                        mpu_port = -1;
+                        return err;
+                }
+                mpu_port = pnp_port_start(devmpu, 0);
+                mpu_irq = pnp_irq(devmpu, 0);
+        }
+        return 0;
+}
+
+static int __devinit snd_miro_pnp_probe(struct pnp_card_link *pcard,
+                                        const struct pnp_card_device_id *pid)
+{
+        struct snd_card *card;
+        int err;
+        struct snd_miro *miro;
+
+        if (snd_miro_pnp_is_probed)
+                return -EBUSY;
+        if (!isapnp)
+                return -ENODEV;
+        err = snd_card_create(index, id, THIS_MODULE,
+                                sizeof(struct snd_miro), &card);
+        if (err < 0)
+                return err;
+
+        card->private_free = snd_card_miro_free;
+        miro = card->private_data;
+
+        err = snd_card_miro_pnp(miro, pcard, pid);
+        if (err) {
+                snd_card_free(card);
+                return err;
+        }
+
+        /* only miroSOUND PCM20 and PCM12 == OPTi924 */
+        err = snd_miro_init(miro, OPTi9XX_HW_82C924);
+        if (err) {
+                snd_card_free(card);
+                return err;
+        }
+
+        err = snd_miro_opti_check(miro);
+        if (err) {
+                snd_printk(KERN_ERR "OPTI chip not found\n");
+                snd_card_free(card);
+                return err;
+        }
+
+        snd_card_set_dev(card, &pcard->card->dev);
+        err = snd_miro_probe(card);
+        if (err < 0) {
+                snd_card_free(card);
+                return err;
+        }
+        pnp_set_card_drvdata(pcard, card);
+        snd_miro_pnp_is_probed = 1;
+        return 0;
+}
+
+static void __devexit snd_miro_pnp_remove(struct pnp_card_link * pcard)
+{
+        snd_card_free(pnp_get_card_drvdata(pcard));
+        pnp_set_card_drvdata(pcard, NULL);
+        snd_miro_pnp_is_probed = 0;
+}
+
+static struct pnp_card_driver miro_pnpc_driver = {
+        .flags          = PNP_DRIVER_RES_DISABLE,
+        .name           = "miro",
+        .id_table       = snd_miro_pnpids,
+        .probe          = snd_miro_pnp_probe,
+        .remove         = __devexit_p(snd_miro_pnp_remove),
+};
+#endif
+
 static int __init alsa_card_miro_init(void)
 {
+#ifdef CONFIG_PNP
+        pnp_register_card_driver(&miro_pnpc_driver);
+        if (snd_miro_pnp_is_probed)
+                return 0;
+        pnp_unregister_card_driver(&miro_pnpc_driver);
+#endif
         return isa_register_driver(&snd_miro_driver, 1);
 }
 
 static void __exit alsa_card_miro_exit(void)
 {
-        isa_unregister_driver(&snd_miro_driver);
+        if (!snd_miro_pnp_is_probed) {
+                isa_unregister_driver(&snd_miro_driver);
+                return;
+        }
+#ifdef CONFIG_PNP
+        pnp_unregister_card_driver(&miro_pnpc_driver);
+#endif
 }
 
 module_init(alsa_card_miro_init)
diff --git a/sound/isa/opti9xx/miro.h b/sound/isa/opti9xx/miro.h
deleted file mode 100644
index 6e1385b8e07e..000000000000
--- a/sound/isa/opti9xx/miro.h
+++ /dev/null
@@ -1,73 +0,0 @@
-#ifndef _MIRO_H_
-#define _MIRO_H_
-
-#define ACI_REG_COMMAND         0       /* write register offset */
-#define ACI_REG_STATUS          1       /* read register offset */
-#define ACI_REG_BUSY            2       /* busy register offset */
-#define ACI_REG_RDS             2       /* PCM20: RDS register offset */
-#define ACI_MINTIME             500     /* ACI time out limit */
-
-#define ACI_SET_MUTE            0x0d
-#define ACI_SET_POWERAMP        0x0f
-#define ACI_SET_TUNERMUTE       0xa3
-#define ACI_SET_TUNERMONO       0xa4
-#define ACI_SET_IDE             0xd0
-#define ACI_SET_WSS             0xd1
-#define ACI_SET_SOLOMODE        0xd2
-#define ACI_SET_PREAMP          0x03
-#define ACI_GET_PREAMP          0x21
-#define ACI_WRITE_TUNE          0xa7
-#define ACI_READ_TUNERSTEREO    0xa8
-#define ACI_READ_TUNERSTATION   0xa9
-#define ACI_READ_VERSION        0xf1
-#define ACI_READ_IDCODE         0xf2
-#define ACI_INIT                0xff
-#define ACI_STATUS              0xf0
-#define ACI_S_GENERAL           0x00
-#define ACI_ERROR_OP            0xdf
-
-/* ACI Mixer */
-
-/* These are the values for the right channel GET registers.
-   Add an offset of 0x01 for the left channel register.
-   (left=right+0x01) */
-
-#define ACI_GET_MASTER          0x03
-#define ACI_GET_MIC             0x05
-#define ACI_GET_LINE            0x07
-#define ACI_GET_CD              0x09
-#define ACI_GET_SYNTH           0x0b
-#define ACI_GET_PCM             0x0d
-#define ACI_GET_LINE1           0x10    /* Radio on PCM20 */
-#define ACI_GET_LINE2           0x12
-
-#define ACI_GET_EQ1             0x22    /* from Bass ... */
-#define ACI_GET_EQ2             0x24
-#define ACI_GET_EQ3             0x26
-#define ACI_GET_EQ4             0x28
-#define ACI_GET_EQ5             0x2a
-#define ACI_GET_EQ6             0x2c
-#define ACI_GET_EQ7             0x2e    /* ... to Treble */
-
-/* And these are the values for the right channel SET registers.
-   For left channel access you have to add an offset of 0x08.
-   MASTER is an exception, which needs an offset of 0x01 */
-
-#define ACI_SET_MASTER          0x00
-#define ACI_SET_MIC             0x30
-#define ACI_SET_LINE            0x31
-#define ACI_SET_CD              0x34
-#define ACI_SET_SYNTH           0x33
-#define ACI_SET_PCM             0x32
-#define ACI_SET_LINE1           0x35    /* Radio on PCM20 */
-#define ACI_SET_LINE2           0x36
-
-#define ACI_SET_EQ1             0x40    /* from Bass ... */
-#define ACI_SET_EQ2             0x41
-#define ACI_SET_EQ3             0x42
-#define ACI_SET_EQ4             0x43
-#define ACI_SET_EQ5             0x44
-#define ACI_SET_EQ6             0x45
-#define ACI_SET_EQ7             0x46    /* ... to Treble */
-
-#endif  /* _MIRO_H_ */
diff --git a/sound/isa/opti9xx/opti92x-ad1848.c b/sound/isa/opti9xx/opti92x-ad1848.c
index 5cd555325b9d..c35dc68930dc 100644
--- a/sound/isa/opti9xx/opti92x-ad1848.c
+++ b/sound/isa/opti9xx/opti92x-ad1848.c
@@ -27,12 +27,12 @@
 #include <linux/err.h>
 #include <linux/isa.h>
 #include <linux/delay.h>
-#include <linux/slab.h>
 #include <linux/pnp.h>
 #include <linux/moduleparam.h>
 #include <asm/io.h>
 #include <asm/dma.h>
 #include <sound/core.h>
+#include <sound/tlv.h>
 #include <sound/wss.h>
 #include <sound/mpu401.h>
 #include <sound/opl3.h>
@@ -135,6 +135,8 @@ struct snd_opti9xx {
         unsigned long mc_base_size;
 #ifdef OPTi93X
         unsigned long mc_indir_index;
+        unsigned long mc_indir_size;
+        struct resource *res_mc_indir;
         struct snd_wss *codec;
 #endif  /* OPTi93X */
         unsigned long pwd_reg;
@@ -143,18 +145,6 @@ struct snd_opti9xx {
 
         long wss_base;
         int irq;
-        int dma1;
-        int dma2;
-
-        long fm_port;
-
-        long mpu_port;
-        int mpu_irq;
-
-#ifdef CONFIG_PNP
-        struct pnp_dev *dev;
-        struct pnp_dev *devmpu;
-#endif  /* CONFIG_PNP */
 };
 
 static int snd_opti9xx_pnp_is_probed;
@@ -164,12 +154,17 @@ static int snd_opti9xx_pnp_is_probed;
 static struct pnp_card_device_id snd_opti9xx_pnpids[] = {
 #ifndef OPTi93X
         /* OPTi 82C924 */
-        { .id = "OPT0924", .devs = { { "OPT0000" }, { "OPT0002" } }, .driver_data = 0x0924 },
+        { .id = "OPT0924",
+          .devs = { { "OPT0000" }, { "OPT0002" }, { "OPT0005" } },
+          .driver_data = 0x0924 },
         /* OPTi 82C925 */
-        { .id = "OPT0925", .devs = { { "OPT9250" }, { "OPT0002" } }, .driver_data = 0x0925 },
+        { .id = "OPT0925",
+          .devs = { { "OPT9250" }, { "OPT0002" }, { "OPT0005" } },
+          .driver_data = 0x0925 },
 #else
         /* OPTi 82C931/3 */
-        { .id = "OPT0931", .devs = { { "OPT9310" }, { "OPT0002" } }, .driver_data = 0x0931 },
+        { .id = "OPT0931", .devs = { { "OPT9310" }, { "OPT0002" } },
+          .driver_data = 0x0931 },
 #endif  /* OPTi93X */
         { .id = "" }
 };
@@ -185,7 +180,7 @@ MODULE_DEVICE_TABLE(pnp_card, snd_opti9xx_pnpids);
 #endif
 
 static char * snd_opti9xx_names[] = {
-        "unkown",
+        "unknown",
         "82C928",       "82C929",
         "82C924",       "82C925",
         "82C930",       "82C931",       "82C933"
@@ -212,30 +207,35 @@ static int __devinit snd_opti9xx_init(struct snd_opti9xx *chip,
         chip->hardware = hardware;
         strcpy(chip->name, snd_opti9xx_names[hardware]);
 
-        chip->mc_base_size = opti9xx_mc_size[hardware];  
-
         spin_lock_init(&chip->lock);
 
-        chip->wss_base = -1;
         chip->irq = -1;
-        chip->dma1 = -1;
-        chip->dma2 = -1;
-        chip->fm_port = -1;
-        chip->mpu_port = -1;
-        chip->mpu_irq = -1;
+
+#ifndef OPTi93X
+#ifdef CONFIG_PNP
+        if (isapnp && chip->mc_base)
+                /* PnP resource gives the least 10 bits */
+                chip->mc_base |= 0xc00;
+        else
+#endif  /* CONFIG_PNP */
+        {
+                chip->mc_base = 0xf8c;
+                chip->mc_base_size = opti9xx_mc_size[hardware];
+        }
+#else
+                chip->mc_base_size = opti9xx_mc_size[hardware];
+#endif
 
         switch (hardware) {
 #ifndef OPTi93X
         case OPTi9XX_HW_82C928:
         case OPTi9XX_HW_82C929:
-                chip->mc_base = 0xf8c;
                 chip->password = (hardware == OPTi9XX_HW_82C928) ? 0xe2 : 0xe3;
                 chip->pwd_reg = 3;
                 break;
 
         case OPTi9XX_HW_82C924:
         case OPTi9XX_HW_82C925:
-                chip->mc_base = 0xf8c;
                 chip->password = 0xe5;
                 chip->pwd_reg = 3;
                 break;
@@ -245,7 +245,10 @@ static int __devinit snd_opti9xx_init(struct snd_opti9xx *chip,
         case OPTi9XX_HW_82C931:
         case OPTi9XX_HW_82C933:
                 chip->mc_base = (hardware == OPTi9XX_HW_82C930) ? 0xf8f : 0xf8d;
-                chip->mc_indir_index = 0xe0e;
+                if (!chip->mc_indir_index) {
+                        chip->mc_indir_index = 0xe0e;
+                        chip->mc_indir_size = 2;
+                }
                 chip->password = 0xe4;
                 chip->pwd_reg = 0;
                 break;
@@ -300,7 +303,7 @@ static unsigned char snd_opti9xx_read(struct snd_opti9xx *chip,
         spin_unlock_irqrestore(&chip->lock, flags);
         return retval;
 }
-        
+
 static void snd_opti9xx_write(struct snd_opti9xx *chip, unsigned char reg,
                               unsigned char value)
 {
@@ -348,7 +351,10 @@ static void snd_opti9xx_write(struct snd_opti9xx *chip, unsigned char reg,
                 (snd_opti9xx_read(chip, reg) & ~(mask)) | ((value) & (mask)))
 
 
-static int __devinit snd_opti9xx_configure(struct snd_opti9xx *chip)
+static int __devinit snd_opti9xx_configure(struct snd_opti9xx *chip,
+                                           long port,
+                                           int irq, int dma1, int dma2,
+                                           long mpu_port, int mpu_irq)
 {
         unsigned char wss_base_bits;
         unsigned char irq_bits;
@@ -359,16 +365,23 @@ static int __devinit snd_opti9xx_configure(struct snd_opti9xx *chip)
         switch (chip->hardware) {
 #ifndef OPTi93X
         case OPTi9XX_HW_82C924:
+                /* opti 929 mode (?), OPL3 clock output, audio enable */
                 snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(4), 0xf0, 0xfc);
+                /* enable wave audio */
                 snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(6), 0x02, 0x02);
 
         case OPTi9XX_HW_82C925:
+                /* enable WSS mode */
                 snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(1), 0x80, 0x80);
+                /* OPL3 FM synthesis */
                 snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(2), 0x00, 0x20);
+                /* disable Sound Blaster IRQ and DMA */
                 snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(3), 0xf0, 0xff);
 #ifdef CS4231
+                /* cs4231/4248 fix enabled */
                 snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(5), 0x02, 0x02);
 #else
+                /* cs4231/4248 fix disabled */
                 snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(5), 0x00, 0x02);
 #endif  /* CS4231 */
                 break;
@@ -416,28 +429,32 @@ static int __devinit snd_opti9xx_configure(struct snd_opti9xx *chip)
                 return -EINVAL;
         }
 
-        switch (chip->wss_base) {
-        case 0x530:
+        /* PnP resource says it decodes only 10 bits of address */
+        switch (port & 0x3ff) {
+        case 0x130:
+                chip->wss_base = 0x530;
                 wss_base_bits = 0x00;
                 break;
-        case 0x604:
+        case 0x204:
+                chip->wss_base = 0x604;
                 wss_base_bits = 0x03;
                 break;
-        case 0xe80:
+        case 0x280:
+                chip->wss_base = 0xe80;
                 wss_base_bits = 0x01;
                 break;
-        case 0xf40:
+        case 0x340:
+                chip->wss_base = 0xf40;
                 wss_base_bits = 0x02;
                 break;
         default:
-                snd_printk(KERN_WARNING "WSS port 0x%lx not valid\n",
-                           chip->wss_base);
+                snd_printk(KERN_WARNING "WSS port 0x%lx not valid\n", port);
                 goto __skip_base;
         }
         snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(1), wss_base_bits << 4, 0x30);
 
 __skip_base:
-        switch (chip->irq) {
+        switch (irq) {
 //#ifdef OPTi93X
         case 5:
                 irq_bits = 0x05;
@@ -456,11 +473,11 @@ __skip_base:
                 irq_bits = 0x04;
                 break;
         default:
-                snd_printk(KERN_WARNING "WSS irq # %d not valid\n", chip->irq);
+                snd_printk(KERN_WARNING "WSS irq # %d not valid\n", irq);
                 goto __skip_resources;
         }
 
-        switch (chip->dma1) {
+        switch (dma1) {
         case 0:
                 dma_bits = 0x01;
                 break;
@@ -471,24 +488,22 @@ __skip_base:
                 dma_bits = 0x03;
                 break;
         default:
-                snd_printk(KERN_WARNING "WSS dma1 # %d not valid\n",
-                           chip->dma1);
+                snd_printk(KERN_WARNING "WSS dma1 # %d not valid\n", dma1);
                 goto __skip_resources;
         }
 
 #if defined(CS4231) || defined(OPTi93X)
-        if (chip->dma1 == chip->dma2) {
+        if (dma1 == dma2) {
                 snd_printk(KERN_ERR "don't want to share dmas\n");
                 return -EBUSY;
         }
 
-        switch (chip->dma2) {
+        switch (dma2) {
         case 0:
         case 1:
                 break;
         default:
-                snd_printk(KERN_WARNING "WSS dma2 # %d not valid\n",
-                           chip->dma2);
+                snd_printk(KERN_WARNING "WSS dma2 # %d not valid\n", dma2);
                 goto __skip_resources;
         }
         dma_bits |= 0x04;
@@ -502,7 +517,7 @@ __skip_base:
 
 __skip_resources:
         if (chip->hardware > OPTi9XX_HW_82C928) {
-                switch (chip->mpu_port) {
+                switch (mpu_port) {
                 case 0:
                 case -1:
                         break;
@@ -520,12 +535,11 @@ __skip_resources:
                         break;
                 default:
                         snd_printk(KERN_WARNING
-                                   "MPU-401 port 0x%lx not valid\n",
-                                chip->mpu_port);
+                                   "MPU-401 port 0x%lx not valid\n", mpu_port);
                         goto __skip_mpu;
                 }
 
-                switch (chip->mpu_irq) {
+                switch (mpu_irq) {
                 case 5:
                         mpu_irq_bits = 0x02;
                         break;
@@ -540,12 +554,12 @@ __skip_resources:
                         break;
                 default:
                         snd_printk(KERN_WARNING "MPU-401 irq # %d not valid\n",
-                                chip->mpu_irq);
+                                mpu_irq);
                         goto __skip_mpu;
                 }
 
                 snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(6),
-                        (chip->mpu_port <= 0) ? 0x00 :
+                        (mpu_port <= 0) ? 0x00 :
                                 0x80 | mpu_port_bits << 5 | mpu_irq_bits << 3,
                         0xf8);
         }
@@ -556,12 +570,102 @@ __skip_mpu:
 
 #ifdef OPTi93X
 
+static const DECLARE_TLV_DB_SCALE(db_scale_5bit_3db_step, -9300, 300, 0);
+static const DECLARE_TLV_DB_SCALE(db_scale_5bit, -4650, 150, 0);
+static const DECLARE_TLV_DB_SCALE(db_scale_4bit_12db_max, -3300, 300, 0);
+
+static struct snd_kcontrol_new snd_opti93x_controls[] = {
+WSS_DOUBLE("Master Playback Switch", 0,
+                OPTi93X_OUT_LEFT, OPTi93X_OUT_RIGHT, 7, 7, 1, 1),
+WSS_DOUBLE_TLV("Master Playback Volume", 0,
+                OPTi93X_OUT_LEFT, OPTi93X_OUT_RIGHT, 1, 1, 31, 1,
+                db_scale_5bit_3db_step),
+WSS_DOUBLE_TLV("PCM Playback Volume", 0,
+                CS4231_LEFT_OUTPUT, CS4231_RIGHT_OUTPUT, 0, 0, 31, 1,
+                db_scale_5bit),
+WSS_DOUBLE_TLV("FM Playback Volume", 0,
+                CS4231_AUX2_LEFT_INPUT, CS4231_AUX2_RIGHT_INPUT, 1, 1, 15, 1,
+                db_scale_4bit_12db_max),
+WSS_DOUBLE("Line Playback Switch", 0,
+                CS4231_LEFT_LINE_IN, CS4231_RIGHT_LINE_IN, 7, 7, 1, 1),
+WSS_DOUBLE_TLV("Line Playback Volume", 0,
+                CS4231_LEFT_LINE_IN, CS4231_RIGHT_LINE_IN, 0, 0, 15, 1,
+                db_scale_4bit_12db_max),
+WSS_DOUBLE("Mic Playback Switch", 0,
+                OPTi93X_MIC_LEFT_INPUT, OPTi93X_MIC_RIGHT_INPUT, 7, 7, 1, 1),
+WSS_DOUBLE_TLV("Mic Playback Volume", 0,
+                OPTi93X_MIC_LEFT_INPUT, OPTi93X_MIC_RIGHT_INPUT, 1, 1, 15, 1,
+                db_scale_4bit_12db_max),
+WSS_DOUBLE_TLV("CD Playback Volume", 0,
+                CS4231_AUX1_LEFT_INPUT, CS4231_AUX1_RIGHT_INPUT, 1, 1, 15, 1,
+                db_scale_4bit_12db_max),
+WSS_DOUBLE("Aux Playback Switch", 0,
+                OPTi931_AUX_LEFT_INPUT, OPTi931_AUX_RIGHT_INPUT, 7, 7, 1, 1),
+WSS_DOUBLE_TLV("Aux Playback Volume", 0,
+                OPTi931_AUX_LEFT_INPUT, OPTi931_AUX_RIGHT_INPUT, 1, 1, 15, 1,
+                db_scale_4bit_12db_max),
+};
+
+static int __devinit snd_opti93x_mixer(struct snd_wss *chip)
+{
+        struct snd_card *card;
+        unsigned int idx;
+        struct snd_ctl_elem_id id1, id2;
+        int err;
+
+        if (snd_BUG_ON(!chip || !chip->pcm))
+                return -EINVAL;
+
+        card = chip->card;
+
+        strcpy(card->mixername, chip->pcm->name);
+
+        memset(&id1, 0, sizeof(id1));
+        memset(&id2, 0, sizeof(id2));
+        id1.iface = id2.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
+        /* reassign AUX0 switch to CD */
+        strcpy(id1.name, "Aux Playback Switch");
+        strcpy(id2.name, "CD Playback Switch");
+        err = snd_ctl_rename_id(card, &id1, &id2);
+        if (err < 0) {
+                snd_printk(KERN_ERR "Cannot rename opti93x control\n");
+                return err;
+        }
+        /* reassign AUX1 switch to FM */
+        strcpy(id1.name, "Aux Playback Switch"); id1.index = 1;
+        strcpy(id2.name, "FM Playback Switch");
+        err = snd_ctl_rename_id(card, &id1, &id2);
+        if (err < 0) {
+                snd_printk(KERN_ERR "Cannot rename opti93x control\n");
+                return err;
+        }
+        /* remove AUX1 volume */
+        strcpy(id1.name, "Aux Playback Volume"); id1.index = 1;
+        snd_ctl_remove_id(card, &id1);
+
+        /* Replace WSS volume controls with OPTi93x volume controls */
+        id1.index = 0;
+        for (idx = 0; idx < ARRAY_SIZE(snd_opti93x_controls); idx++) {
+                strcpy(id1.name, snd_opti93x_controls[idx].name);
+                snd_ctl_remove_id(card, &id1);
+
+                err = snd_ctl_add(card,
+                                snd_ctl_new1(&snd_opti93x_controls[idx], chip));
+                if (err < 0)
+                        return err;
+        }
+        return 0;
+}
+
 static irqreturn_t snd_opti93x_interrupt(int irq, void *dev_id)
 {
-        struct snd_wss *codec = dev_id;
-        struct snd_opti9xx *chip = codec->card->private_data;
+        struct snd_opti9xx *chip = dev_id;
+        struct snd_wss *codec = chip->codec;
         unsigned char status;
 
+        if (!codec)
+                return IRQ_HANDLED;
+
         status = snd_opti9xx_read(chip, OPTi9XX_MC_REG(11));
         if ((status & OPTi93X_IRQ_PLAYBACK) && codec->playback_substream)
                 snd_pcm_period_elapsed(codec->playback_substream);
@@ -575,57 +679,69 @@ static irqreturn_t snd_opti93x_interrupt(int irq, void *dev_id)
 
 #endif /* OPTi93X */
 
-static int __devinit snd_card_opti9xx_detect(struct snd_card *card,
-                                             struct snd_opti9xx *chip)
+static int __devinit snd_opti9xx_read_check(struct snd_opti9xx *chip)
 {
-        int i, err;
+        unsigned char value;
+#ifdef OPTi93X
+        unsigned long flags;
+#endif
 
+        chip->res_mc_base = request_region(chip->mc_base, chip->mc_base_size,
+                                           "OPTi9xx MC");
+        if (chip->res_mc_base == NULL)
+                return -EBUSY;
 #ifndef OPTi93X
-        for (i = OPTi9XX_HW_82C928; i < OPTi9XX_HW_82C930; i++) {
-                unsigned char value;
+        value = snd_opti9xx_read(chip, OPTi9XX_MC_REG(1));
+        if (value != 0xff && value != inb(chip->mc_base + OPTi9XX_MC_REG(1)))
+                if (value == snd_opti9xx_read(chip, OPTi9XX_MC_REG(1)))
+                        return 0;
+#else   /* OPTi93X */
+        chip->res_mc_indir = request_region(chip->mc_indir_index,
+                                            chip->mc_indir_size,
+                                            "OPTi93x MC");
+        if (chip->res_mc_indir == NULL)
+                return -EBUSY;
 
-                if ((err = snd_opti9xx_init(chip, i)) < 0)
-                        return err;
+        spin_lock_irqsave(&chip->lock, flags);
+        outb(chip->password, chip->mc_base + chip->pwd_reg);
+        outb(((chip->mc_indir_index & 0x1f0) >> 4), chip->mc_base);
+        spin_unlock_irqrestore(&chip->lock, flags);
 
-                if ((chip->res_mc_base = request_region(chip->mc_base, chip->mc_base_size, "OPTi9xx MC")) == NULL)
-                        continue;
+        value = snd_opti9xx_read(chip, OPTi9XX_MC_REG(7));
+        snd_opti9xx_write(chip, OPTi9XX_MC_REG(7), 0xff - value);
+        if (snd_opti9xx_read(chip, OPTi9XX_MC_REG(7)) == 0xff - value)
+                return 0;
 
-                value = snd_opti9xx_read(chip, OPTi9XX_MC_REG(1));
-                if ((value != 0xff) && (value != inb(chip->mc_base + 1)))
-                        if (value == snd_opti9xx_read(chip, OPTi9XX_MC_REG(1)))
-                                return 1;
+        release_and_free_resource(chip->res_mc_indir);
+        chip->res_mc_indir = NULL;
+#endif  /* OPTi93X */
+        release_and_free_resource(chip->res_mc_base);
+        chip->res_mc_base = NULL;
 
-                release_and_free_resource(chip->res_mc_base);
-                chip->res_mc_base = NULL;
+        return -ENODEV;
+}
 
-        }
-#else   /* OPTi93X */
-        for (i = OPTi9XX_HW_82C931; i >= OPTi9XX_HW_82C930; i--) {
-                unsigned long flags;
-                unsigned char value;
+static int __devinit snd_card_opti9xx_detect(struct snd_card *card,
+                                             struct snd_opti9xx *chip)
+{
+        int i, err;
 
-                if ((err = snd_opti9xx_init(chip, i)) < 0)
+#ifndef OPTi93X
+        for (i = OPTi9XX_HW_82C928; i < OPTi9XX_HW_82C930; i++) {
+#else
+        for (i = OPTi9XX_HW_82C931; i >= OPTi9XX_HW_82C930; i--) {
+#endif
+                err = snd_opti9xx_init(chip, i);
+                if (err < 0)
                         return err;
 
-                if ((chip->res_mc_base = request_region(chip->mc_base, chip->mc_base_size, "OPTi9xx MC")) == NULL)
-                        continue;
-
-                spin_lock_irqsave(&chip->lock, flags);
-                outb(chip->password, chip->mc_base + chip->pwd_reg);
-                outb(((chip->mc_indir_index & (1 << 8)) >> 4) |
-                        ((chip->mc_indir_index & 0xf0) >> 4), chip->mc_base);
-                spin_unlock_irqrestore(&chip->lock, flags);
-
-                value = snd_opti9xx_read(chip, OPTi9XX_MC_REG(7));
-                snd_opti9xx_write(chip, OPTi9XX_MC_REG(7), 0xff - value);
-                if (snd_opti9xx_read(chip, OPTi9XX_MC_REG(7)) == 0xff - value)
+                err = snd_opti9xx_read_check(chip);
+                if (err == 0)
                         return 1;
-
-                release_and_free_resource(chip->res_mc_base);
-                chip->res_mc_base = NULL;
+#ifdef OPTi93X
+                chip->mc_indir_index = 0;
+#endif
         }
-#endif  /* OPTi93X */
-
         return -ENODEV;
 }
 
@@ -636,15 +752,15 @@ static int __devinit snd_card_opti9xx_pnp(struct snd_opti9xx *chip,
 {
         struct pnp_dev *pdev;
         int err;
+        struct pnp_dev *devmpu;
+#ifndef OPTi93X
+        struct pnp_dev *devmc;
+#endif
 
-        chip->dev = pnp_request_card_device(card, pid->devs[0].id, NULL);
-        if (chip->dev == NULL)
+        pdev = pnp_request_card_device(card, pid->devs[0].id, NULL);
+        if (pdev == NULL)
                 return -EBUSY;
 
-        chip->devmpu = pnp_request_card_device(card, pid->devs[1].id, NULL);
-
-        pdev = chip->dev;
-
         err = pnp_activate_dev(pdev);
         if (err < 0) {
                 snd_printk(KERN_ERR "AUDIO pnp configure failure: %d\n", err);
@@ -654,10 +770,27 @@ static int __devinit snd_card_opti9xx_pnp(struct snd_opti9xx *chip,
 #ifdef OPTi93X
         port = pnp_port_start(pdev, 0) - 4;
         fm_port = pnp_port_start(pdev, 1) + 8;
+        chip->mc_indir_index = pnp_port_start(pdev, 3) + 2;
+        chip->mc_indir_size = pnp_port_len(pdev, 3) - 2;
 #else
-        if (pid->driver_data != 0x0924)
-                port = pnp_port_start(pdev, 1);
+        devmc = pnp_request_card_device(card, pid->devs[2].id, NULL);
+        if (devmc == NULL)
+                return -EBUSY;
+
+        err = pnp_activate_dev(devmc);
+        if (err < 0) {
+                snd_printk(KERN_ERR "MC pnp configure failure: %d\n", err);
+                return err;
+        }
+
+        port = pnp_port_start(pdev, 1);
         fm_port = pnp_port_start(pdev, 2) + 8;
+        /*
+         * The MC(0) is never accessed and card does not
+         * include it in the PnP resource range. OPTI93x include it.
+         */
+        chip->mc_base = pnp_port_start(devmc, 0) - 1;
+        chip->mc_base_size = pnp_port_len(devmc, 0) + 1;
 #endif  /* OPTi93X */
         irq = pnp_irq(pdev, 0);
         dma1 = pnp_dma(pdev, 0);
@@ -665,16 +798,16 @@ static int __devinit snd_card_opti9xx_pnp(struct snd_opti9xx *chip,
         dma2 = pnp_dma(pdev, 1);
 #endif  /* CS4231 || OPTi93X */
 
-        pdev = chip->devmpu;
-        if (pdev && mpu_port > 0) {
-                err = pnp_activate_dev(pdev);
+        devmpu = pnp_request_card_device(card, pid->devs[1].id, NULL);
+
+        if (devmpu && mpu_port > 0) {
+                err = pnp_activate_dev(devmpu);
                 if (err < 0) {
-                        snd_printk(KERN_ERR "AUDIO pnp configure failure\n");
+                        snd_printk(KERN_ERR "MPU401 pnp configure failure\n");
                         mpu_port = -1;
-                        chip->devmpu = NULL;
                 } else {
-                        mpu_port = pnp_port_start(pdev, 0);
-                        mpu_irq = pnp_irq(pdev, 0);
+                        mpu_port = pnp_port_start(devmpu, 0);
+                        mpu_irq = pnp_irq(devmpu, 0);
                 }
         }
         return pid->driver_data;
@@ -684,14 +817,14 @@ static int __devinit snd_card_opti9xx_pnp(struct snd_opti9xx *chip,
 static void snd_card_opti9xx_free(struct snd_card *card)
 {
         struct snd_opti9xx *chip = card->private_data;
-        
+
         if (chip) {
 #ifdef OPTi93X
-                struct snd_wss *codec = chip->codec;
-                if (codec && codec->irq > 0) {
-                        disable_irq(codec->irq);
-                        free_irq(codec->irq, codec);
+                if (chip->irq > 0) {
+                        disable_irq(chip->irq);
+                        free_irq(chip->irq, chip);
                 }
+                release_and_free_resource(chip->res_mc_indir);
 #endif
                 release_and_free_resource(chip->res_mc_base);
         }
@@ -701,6 +834,7 @@ static int __devinit snd_opti9xx_probe(struct snd_card *card)
 {
         static long possible_ports[] = {0x530, 0xe80, 0xf40, 0x604, -1};
         int error;
+        int xdma2;
         struct snd_opti9xx *chip = card->private_data;
         struct snd_wss *codec;
 #ifdef CS4231
@@ -710,36 +844,25 @@ static int __devinit snd_opti9xx_probe(struct snd_card *card)
         struct snd_rawmidi *rmidi;
         struct snd_hwdep *synth;
 
-        if (! chip->res_mc_base &&
-            (chip->res_mc_base = request_region(chip->mc_base, chip->mc_base_size,
-                                                "OPTi9xx MC")) == NULL)
-                return -ENOMEM;
-
-        chip->wss_base = port;
-        chip->fm_port = fm_port;
-        chip->mpu_port = mpu_port;
-        chip->irq = irq;
-        chip->mpu_irq = mpu_irq;
-        chip->dma1 = dma1;
 #if defined(CS4231) || defined(OPTi93X)
-        chip->dma2 = dma2;
+        xdma2 = dma2;
 #else
-        chip->dma2 = -1;
+        xdma2 = -1;
 #endif
 
-        if (chip->wss_base == SNDRV_AUTO_PORT) {
-                chip->wss_base = snd_legacy_find_free_ioport(possible_ports, 4);
-                if (chip->wss_base < 0) {
+        if (port == SNDRV_AUTO_PORT) {
+                port = snd_legacy_find_free_ioport(possible_ports, 4);
+                if (port < 0) {
                         snd_printk(KERN_ERR "unable to find a free WSS port\n");
                         return -EBUSY;
                 }
         }
-        error = snd_opti9xx_configure(chip);
+        error = snd_opti9xx_configure(chip, port, irq, dma1, xdma2,
+                                      mpu_port, mpu_irq);
         if (error)
                 return error;
 
-        error = snd_wss_create(card, chip->wss_base + 4, -1,
-                               chip->irq, chip->dma1, chip->dma2,
+        error = snd_wss_create(card, chip->wss_base + 4, -1, irq, dma1, xdma2,
 #ifdef OPTi93X
                                WSS_HW_OPTI93X, WSS_HWSHARE_IRQ,
 #else
@@ -757,41 +880,47 @@ static int __devinit snd_opti9xx_probe(struct snd_card *card)
         error = snd_wss_mixer(codec);
         if (error < 0)
                 return error;
+#ifdef OPTi93X
+        error = snd_opti93x_mixer(codec);
+        if (error < 0)
+                return error;
+#endif
 #ifdef CS4231
         error = snd_wss_timer(codec, 0, &timer);
         if (error < 0)
                 return error;
 #endif
 #ifdef OPTi93X
-        error = request_irq(chip->irq, snd_opti93x_interrupt,
-                            IRQF_DISABLED, DEV_NAME" - WSS", codec);
+        error = request_irq(irq, snd_opti93x_interrupt,
+                            IRQF_DISABLED, DEV_NAME" - WSS", chip);
         if (error < 0) {
-                snd_printk(KERN_ERR "opti9xx: can't grab IRQ %d\n", chip->irq);
+                snd_printk(KERN_ERR "opti9xx: can't grab IRQ %d\n", irq);
                 return error;
         }
 #endif
+        chip->irq = irq;
         strcpy(card->driver, chip->name);
         sprintf(card->shortname, "OPTi %s", card->driver);
 #if defined(CS4231) || defined(OPTi93X)
         sprintf(card->longname, "%s, %s at 0x%lx, irq %d, dma %d&%d",
-                card->shortname, pcm->name, chip->wss_base + 4,
-                chip->irq, chip->dma1, chip->dma2);
+                card->shortname, pcm->name,
+                chip->wss_base + 4, irq, dma1, xdma2);
 #else
         sprintf(card->longname, "%s, %s at 0x%lx, irq %d, dma %d",
-                card->shortname, pcm->name, chip->wss_base + 4,
-                chip->irq, chip->dma1);
+                card->shortname, pcm->name, chip->wss_base + 4, irq, dma1);
 #endif  /* CS4231 || OPTi93X */
 
-        if (chip->mpu_port <= 0 || chip->mpu_port == SNDRV_AUTO_PORT)
+        if (mpu_port <= 0 || mpu_port == SNDRV_AUTO_PORT)
                 rmidi = NULL;
-        else
-                if ((error = snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401,
-                                chip->mpu_port, 0, chip->mpu_irq, IRQF_DISABLED,
-                                &rmidi)))
+        else {
+                error = snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401,
+                                mpu_port, 0, mpu_irq, IRQF_DISABLED, &rmidi);
+                if (error)
                         snd_printk(KERN_WARNING "no MPU-401 device at 0x%lx?\n",
-                                   chip->mpu_port);
+                                   mpu_port);
+        }
 
-        if (chip->fm_port > 0 && chip->fm_port != SNDRV_AUTO_PORT) {
+        if (fm_port > 0 && fm_port != SNDRV_AUTO_PORT) {
                 struct snd_opl3 *opl3 = NULL;
 #ifndef OPTi93X
                 if (chip->hardware == OPTi9XX_HW_82C928 ||
@@ -801,9 +930,7 @@ static int __devinit snd_opti9xx_probe(struct snd_card *card)
                         /* assume we have an OPL4 */
                         snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(2),
                                                0x20, 0x20);
-                        if (snd_opl4_create(card,
-                                            chip->fm_port,
-                                            chip->fm_port - 8,
+                        if (snd_opl4_create(card, fm_port, fm_port - 8,
                                             2, &opl3, &opl4) < 0) {
                                 /* no luck, use OPL3 instead */
                                 snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(2),
@@ -811,12 +938,10 @@ static int __devinit snd_opti9xx_probe(struct snd_card *card)
                         }
                 }
 #endif  /* !OPTi93X */
-                if (!opl3 && snd_opl3_create(card,
-                                             chip->fm_port,
-                                             chip->fm_port + 2,
+                if (!opl3 && snd_opl3_create(card, fm_port, fm_port + 2,
                                              OPL3_HW_AUTO, 0, &opl3) < 0) {
                         snd_printk(KERN_WARNING "no OPL device at 0x%lx-0x%lx\n",
-                                   chip->fm_port, chip->fm_port + 4 - 1);
+                                   fm_port, fm_port + 4 - 1);
                 }
                 if (opl3) {
                         error = snd_opl3_hwdep_new(opl3, 0, 1, &synth);
@@ -976,8 +1101,12 @@ static int __devinit snd_opti9xx_pnp_probe(struct pnp_card_link *pcard,
                 snd_card_free(card);
                 return error;
         }
-        if (hw <= OPTi9XX_HW_82C930)
-                chip->mc_base -= 0x80;
+        error = snd_opti9xx_read_check(chip);
+        if (error) {
+                snd_printk(KERN_ERR "OPTI chip not found\n");
+                snd_card_free(card);
+                return error;
+        }
         snd_card_set_dev(card, &pcard->card->dev);
         if ((error = snd_opti9xx_probe(card)) < 0) {
                 snd_card_free(card);
diff --git a/sound/isa/sb/Makefile b/sound/isa/sb/Makefile
index faeffceb01b7..af3669681788 100644
--- a/sound/isa/sb/Makefile
+++ b/sound/isa/sb/Makefile
@@ -12,6 +12,7 @@ snd-sb16-objs := sb16.o
 snd-sbawe-objs := sbawe.o emu8000.o
 snd-emu8000-synth-objs := emu8000_synth.o emu8000_callback.o emu8000_patch.o emu8000_pcm.o
 snd-es968-objs := es968.o
+snd-jazz16-objs := jazz16.o
 
 # Toplevel Module Dependency
 obj-$(CONFIG_SND_SB_COMMON) += snd-sb-common.o
@@ -21,6 +22,7 @@ obj-$(CONFIG_SND_SB8) += snd-sb8.o
 obj-$(CONFIG_SND_SB16) += snd-sb16.o
 obj-$(CONFIG_SND_SBAWE) += snd-sbawe.o
 obj-$(CONFIG_SND_ES968) += snd-es968.o
+obj-$(CONFIG_SND_JAZZ16) += snd-jazz16.o
 ifeq ($(CONFIG_SND_SB16_CSP),y)
   obj-$(CONFIG_SND_SB16) += snd-sb16-csp.o
   obj-$(CONFIG_SND_SBAWE) += snd-sb16-csp.o
diff --git a/sound/isa/sb/emu8000.c b/sound/isa/sb/emu8000.c
index 96678d5d3834..0c40951b6523 100644
--- a/sound/isa/sb/emu8000.c
+++ b/sound/isa/sb/emu8000.c
@@ -377,12 +377,13 @@ init_arrays(struct snd_emu8000 *emu)
 static void __devinit
 size_dram(struct snd_emu8000 *emu)
 {
-        int i, size;
+        int i, size, detected_size;
 
         if (emu->dram_checked)
                 return;
 
         size = 0;
+        detected_size = 0;
 
         /* write out a magic number */
         snd_emu8000_dma_chan(emu, 0, EMU8000_RAM_WRITE);
@@ -414,7 +415,9 @@ size_dram(struct snd_emu8000 *emu)
                 /*snd_emu8000_read_wait(emu);*/
                 EMU8000_SMLD_READ(emu); /* discard stale data  */
                 if (EMU8000_SMLD_READ(emu) != UNIQUE_ID2)
-                        break; /* we must have wrapped around */
+                        break; /* no memory at this address */
+
+                detected_size = size;
 
                 snd_emu8000_read_wait(emu);
 
@@ -442,9 +445,9 @@ size_dram(struct snd_emu8000 *emu)
         snd_emu8000_dma_chan(emu, 1, EMU8000_RAM_CLOSE);
 
         snd_printdd("EMU8000 [0x%lx]: %d Kb on-board memory detected\n",
-                    emu->port1, size/1024);
+                    emu->port1, detected_size/1024);
 
-        emu->mem_size = size;
+        emu->mem_size = detected_size;
         emu->dram_checked = 1;
 }
 
diff --git a/sound/isa/sb/emu8000_pcm.c b/sound/isa/sb/emu8000_pcm.c
index 91dc3d83e2cf..ccedbfed061a 100644
--- a/sound/isa/sb/emu8000_pcm.c
+++ b/sound/isa/sb/emu8000_pcm.c
@@ -20,6 +20,7 @@
 
 #include "emu8000_local.h"
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <sound/initval.h>
 #include <sound/pcm.h>
 
diff --git a/sound/isa/sb/es968.c b/sound/isa/sb/es968.c
index cafc3a7316a8..ff18286fef9d 100644
--- a/sound/isa/sb/es968.c
+++ b/sound/isa/sb/es968.c
@@ -93,7 +93,7 @@ static int __devinit snd_card_es968_pnp(int dev, struct snd_card_es968 *acard,
                 return err;
         }
         port[dev] = pnp_port_start(pdev, 0);
-        dma8[dev] = pnp_dma(pdev, 1);
+        dma8[dev] = pnp_dma(pdev, 0);
         irq[dev] = pnp_irq(pdev, 0);
 
         return 0;
diff --git a/sound/isa/sb/jazz16.c b/sound/isa/sb/jazz16.c
new file mode 100644
index 000000000000..8ccbcddf08e1
--- /dev/null
+++ b/sound/isa/sb/jazz16.c
@@ -0,0 +1,405 @@
+
+/*
+ * jazz16.c - driver for Media Vision Jazz16 based soundcards.
+ * Copyright (C) 2009 Krzysztof Helt <krzysztof.h1@wp.pl>
+ * Based on patches posted by Rask Ingemann Lambertsen and Rene Herman.
+ * Based on OSS Sound Blaster driver.
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file COPYING in the main directory of this archive for
+ * more details.
+ *
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/io.h>
+#include <linux/delay.h>
+#include <asm/dma.h>
+#include <linux/isa.h>
+#include <sound/core.h>
+#include <sound/mpu401.h>
+#include <sound/opl3.h>
+#include <sound/sb.h>
+#define SNDRV_LEGACY_FIND_FREE_IRQ
+#define SNDRV_LEGACY_FIND_FREE_DMA
+#include <sound/initval.h>
+
+#define PFX "jazz16: "
+
+MODULE_DESCRIPTION("Media Vision Jazz16");
+MODULE_SUPPORTED_DEVICE("{{Media Vision ??? },"
+                "{RTL,RTL3000}}");
+
+MODULE_AUTHOR("Krzysztof Helt <krzysztof.h1@wp.pl>");
+MODULE_LICENSE("GPL");
+
+static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
+static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
+static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE;  /* Enable this card */
+static unsigned long port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
+static unsigned long mpu_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
+static int irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ;
+static int mpu_irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ;
+static int dma8[SNDRV_CARDS] = SNDRV_DEFAULT_DMA;
+static int dma16[SNDRV_CARDS] = SNDRV_DEFAULT_DMA;
+
+module_param_array(index, int, NULL, 0444);
+MODULE_PARM_DESC(index, "Index value for Media Vision Jazz16 based soundcard.");
+module_param_array(id, charp, NULL, 0444);
+MODULE_PARM_DESC(id, "ID string for Media Vision Jazz16 based soundcard.");
+module_param_array(enable, bool, NULL, 0444);
+MODULE_PARM_DESC(enable, "Enable Media Vision Jazz16 based soundcard.");
+module_param_array(port, long, NULL, 0444);
+MODULE_PARM_DESC(port, "Port # for jazz16 driver.");
+module_param_array(mpu_port, long, NULL, 0444);
+MODULE_PARM_DESC(mpu_port, "MPU-401 port # for jazz16 driver.");
+module_param_array(irq, int, NULL, 0444);
+MODULE_PARM_DESC(irq, "IRQ # for jazz16 driver.");
+module_param_array(mpu_irq, int, NULL, 0444);
+MODULE_PARM_DESC(mpu_irq, "MPU-401 IRQ # for jazz16 driver.");
+module_param_array(dma8, int, NULL, 0444);
+MODULE_PARM_DESC(dma8, "DMA8 # for jazz16 driver.");
+module_param_array(dma16, int, NULL, 0444);
+MODULE_PARM_DESC(dma16, "DMA16 # for jazz16 driver.");
+
+#define SB_JAZZ16_WAKEUP        0xaf
+#define SB_JAZZ16_SET_PORTS     0x50
+#define SB_DSP_GET_JAZZ_BRD_REV 0xfa
+#define SB_JAZZ16_SET_DMAINTR   0xfb
+#define SB_DSP_GET_JAZZ_MODEL   0xfe
+
+struct snd_card_jazz16 {
+        struct snd_sb *chip;
+};
+
+static irqreturn_t jazz16_interrupt(int irq, void *chip)
+{
+        return snd_sb8dsp_interrupt(chip);
+}
+
+static int __devinit jazz16_configure_ports(unsigned long port,
+                                            unsigned long mpu_port, int idx)
+{
+        unsigned char val;
+
+        if (!request_region(0x201, 1, "jazz16 config")) {
+                snd_printk(KERN_ERR "config port region is already in use.\n");
+                return -EBUSY;
+        }
+        outb(SB_JAZZ16_WAKEUP - idx, 0x201);
+        udelay(100);
+        outb(SB_JAZZ16_SET_PORTS + idx, 0x201);
+        udelay(100);
+        val = port & 0x70;
+        val |= (mpu_port & 0x30) >> 4;
+        outb(val, 0x201);
+
+        release_region(0x201, 1);
+        return 0;
+}
+
+static int __devinit jazz16_detect_board(unsigned long port,
+                                         unsigned long mpu_port)
+{
+        int err;
+        int val;
+        struct snd_sb chip;
+
+        if (!request_region(port, 0x10, "jazz16")) {
+                snd_printk(KERN_ERR "I/O port region is already in use.\n");
+                return -EBUSY;
+        }
+        /* just to call snd_sbdsp_command/reset/get_byte() */
+        chip.port = port;
+
+        err = snd_sbdsp_reset(&chip);
+        if (err < 0)
+                for (val = 0; val < 4; val++) {
+                        err = jazz16_configure_ports(port, mpu_port, val);
+                        if (err < 0)
+                                break;
+
+                        err = snd_sbdsp_reset(&chip);
+                        if (!err)
+                                break;
+                }
+        if (err < 0) {
+                err = -ENODEV;
+                goto err_unmap;
+        }
+        if (!snd_sbdsp_command(&chip, SB_DSP_GET_JAZZ_BRD_REV)) {
+                err = -EBUSY;
+                goto err_unmap;
+        }
+        val = snd_sbdsp_get_byte(&chip);
+        if (val >= 0x30)
+                snd_sbdsp_get_byte(&chip);
+
+        if ((val & 0xf0) != 0x10) {
+                err = -ENODEV;
+                goto err_unmap;
+        }
+        if (!snd_sbdsp_command(&chip, SB_DSP_GET_JAZZ_MODEL)) {
+                err = -EBUSY;
+                goto err_unmap;
+        }
+        snd_sbdsp_get_byte(&chip);
+        err = snd_sbdsp_get_byte(&chip);
+        snd_printd("Media Vision Jazz16 board detected: rev 0x%x, model 0x%x\n",
+                   val, err);
+
+        err = 0;
+
+err_unmap:
+        release_region(port, 0x10);
+        return err;
+}
+
+static int __devinit jazz16_configure_board(struct snd_sb *chip, int mpu_irq)
+{
+        static unsigned char jazz_irq_bits[] = { 0, 0, 2, 3, 0, 1, 0, 4,
+                                                 0, 2, 5, 0, 0, 0, 0, 6 };
+        static unsigned char jazz_dma_bits[] = { 0, 1, 0, 2, 0, 3, 0, 4 };
+
+        if (jazz_dma_bits[chip->dma8] == 0 ||
+            jazz_dma_bits[chip->dma16] == 0 ||
+            jazz_irq_bits[chip->irq] == 0)
+                return -EINVAL;
+
+        if (!snd_sbdsp_command(chip, SB_JAZZ16_SET_DMAINTR))
+                return -EBUSY;
+
+        if (!snd_sbdsp_command(chip,
+                               jazz_dma_bits[chip->dma8] |
+                               (jazz_dma_bits[chip->dma16] << 4)))
+                return -EBUSY;
+
+        if (!snd_sbdsp_command(chip,
+                               jazz_irq_bits[chip->irq] |
+                               (jazz_irq_bits[mpu_irq] << 4)))
+                return -EBUSY;
+
+        return 0;
+}
+
+static int __devinit snd_jazz16_match(struct device *devptr, unsigned int dev)
+{
+        if (!enable[dev])
+                return 0;
+        if (port[dev] == SNDRV_AUTO_PORT) {
+                snd_printk(KERN_ERR "please specify port\n");
+                return 0;
+        } else if (port[dev] == 0x200 || (port[dev] & ~0x270)) {
+                snd_printk(KERN_ERR "incorrect port specified\n");
+                return 0;
+        }
+        if (dma8[dev] != SNDRV_AUTO_DMA &&
+            dma8[dev] != 1 && dma8[dev] != 3) {
+                snd_printk(KERN_ERR "dma8 must be 1 or 3\n");
+                return 0;
+        }
+        if (dma16[dev] != SNDRV_AUTO_DMA &&
+            dma16[dev] != 5 && dma16[dev] != 7) {
+                snd_printk(KERN_ERR "dma16 must be 5 or 7\n");
+                return 0;
+        }
+        if (mpu_port[dev] != SNDRV_AUTO_PORT &&
+            (mpu_port[dev] & ~0x030) != 0x300) {
+                snd_printk(KERN_ERR "incorrect mpu_port specified\n");
+                return 0;
+        }
+        if (mpu_irq[dev] != SNDRV_AUTO_DMA &&
+            mpu_irq[dev] != 2 && mpu_irq[dev] != 3 &&
+            mpu_irq[dev] != 5 && mpu_irq[dev] != 7) {
+                snd_printk(KERN_ERR "mpu_irq must be 2, 3, 5 or 7\n");
+                return 0;
+        }
+        return 1;
+}
+
+static int __devinit snd_jazz16_probe(struct device *devptr, unsigned int dev)
+{
+        struct snd_card *card;
+        struct snd_card_jazz16 *jazz16;
+        struct snd_sb *chip;
+        struct snd_opl3 *opl3;
+        static int possible_irqs[] = {2, 3, 5, 7, 9, 10, 15, -1};
+        static int possible_dmas8[] = {1, 3, -1};
+        static int possible_dmas16[] = {5, 7, -1};
+        int err, xirq, xdma8, xdma16, xmpu_port, xmpu_irq;
+
+        err = snd_card_create(index[dev], id[dev], THIS_MODULE,
+                              sizeof(struct snd_card_jazz16), &card);
+        if (err < 0)
+                return err;
+
+        jazz16 = card->private_data;
+
+        xirq = irq[dev];
+        if (xirq == SNDRV_AUTO_IRQ) {
+                xirq = snd_legacy_find_free_irq(possible_irqs);
+                if (xirq < 0) {
+                        snd_printk(KERN_ERR "unable to find a free IRQ\n");
+                        err = -EBUSY;
+                        goto err_free;
+                }
+        }
+        xdma8 = dma8[dev];
+        if (xdma8 == SNDRV_AUTO_DMA) {
+                xdma8 = snd_legacy_find_free_dma(possible_dmas8);
+                if (xdma8 < 0) {
+                        snd_printk(KERN_ERR "unable to find a free DMA8\n");
+                        err = -EBUSY;
+                        goto err_free;
+                }
+        }
+        xdma16 = dma16[dev];
+        if (xdma16 == SNDRV_AUTO_DMA) {
+                xdma16 = snd_legacy_find_free_dma(possible_dmas16);
+                if (xdma16 < 0) {
+                        snd_printk(KERN_ERR "unable to find a free DMA16\n");
+                        err = -EBUSY;
+                        goto err_free;
+                }
+        }
+
+        xmpu_port = mpu_port[dev];
+        if (xmpu_port == SNDRV_AUTO_PORT)
+                xmpu_port = 0;
+        err = jazz16_detect_board(port[dev], xmpu_port);
+        if (err < 0) {
+                printk(KERN_ERR "Media Vision Jazz16 board not detected\n");
+                goto err_free;
+        }
+        err = snd_sbdsp_create(card, port[dev], irq[dev],
+                               jazz16_interrupt,
+                               dma8[dev], dma16[dev],
+                               SB_HW_JAZZ16,
+                               &chip);
+        if (err < 0)
+                goto err_free;
+
+        xmpu_irq = mpu_irq[dev];
+        if (xmpu_irq == SNDRV_AUTO_IRQ || mpu_port[dev] == SNDRV_AUTO_PORT)
+                xmpu_irq = 0;
+        err = jazz16_configure_board(chip, xmpu_irq);
+        if (err < 0) {
+                printk(KERN_ERR "Media Vision Jazz16 configuration failed\n");
+                goto err_free;
+        }
+
+        jazz16->chip = chip;
+
+        strcpy(card->driver, "jazz16");
+        strcpy(card->shortname, "Media Vision Jazz16");
+        sprintf(card->longname,
+                "Media Vision Jazz16 at 0x%lx, irq %d, dma8 %d, dma16 %d",
+                port[dev], xirq, xdma8, xdma16);
+
+        err = snd_sb8dsp_pcm(chip, 0, NULL);
+        if (err < 0)
+                goto err_free;
+        err = snd_sbmixer_new(chip);
+        if (err < 0)
+                goto err_free;
+
+        err = snd_opl3_create(card, chip->port, chip->port + 2,
+                              OPL3_HW_AUTO, 1, &opl3);
+        if (err < 0)
+                snd_printk(KERN_WARNING "no OPL device at 0x%lx-0x%lx\n",
+                           chip->port, chip->port + 2);
+        else {
+                err = snd_opl3_hwdep_new(opl3, 0, 1, NULL);
+                if (err < 0)
+                        goto err_free;
+        }
+        if (mpu_port[dev] > 0 && mpu_port[dev] != SNDRV_AUTO_PORT) {
+                if (mpu_irq[dev] == SNDRV_AUTO_IRQ)
+                        mpu_irq[dev] = -1;
+
+                if (snd_mpu401_uart_new(card, 0,
+                                        MPU401_HW_MPU401,
+                                        mpu_port[dev], 0,
+                                        mpu_irq[dev],
+                                        mpu_irq[dev] >= 0 ? IRQF_DISABLED : 0,
+                                        NULL) < 0)
+                        snd_printk(KERN_ERR "no MPU-401 device at 0x%lx\n",
+                                        mpu_port[dev]);
+        }
+
+        snd_card_set_dev(card, devptr);
+
+        err = snd_card_register(card);
+        if (err < 0)
+                goto err_free;
+
+        dev_set_drvdata(devptr, card);
+        return 0;
+
+err_free:
+        snd_card_free(card);
+        return err;
+}
+
+static int __devexit snd_jazz16_remove(struct device *devptr, unsigned int dev)
+{
+        struct snd_card *card = dev_get_drvdata(devptr);
+
+        dev_set_drvdata(devptr, NULL);
+        snd_card_free(card);
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int snd_jazz16_suspend(struct device *pdev, unsigned int n,
+                               pm_message_t state)
+{
+        struct snd_card *card = dev_get_drvdata(pdev);
+        struct snd_card_jazz16 *acard = card->private_data;
+        struct snd_sb *chip = acard->chip;
+
+        snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
+        snd_pcm_suspend_all(chip->pcm);
+        snd_sbmixer_suspend(chip);
+        return 0;
+}
+
+static int snd_jazz16_resume(struct device *pdev, unsigned int n)
+{
+        struct snd_card *card = dev_get_drvdata(pdev);
+        struct snd_card_jazz16 *acard = card->private_data;
+        struct snd_sb *chip = acard->chip;
+
+        snd_sbdsp_reset(chip);
+        snd_sbmixer_resume(chip);
+        snd_power_change_state(card, SNDRV_CTL_POWER_D0);
+        return 0;
+}
+#endif
+
+static struct isa_driver snd_jazz16_driver = {
+        .match          = snd_jazz16_match,
+        .probe          = snd_jazz16_probe,
+        .remove         = __devexit_p(snd_jazz16_remove),
+#ifdef CONFIG_PM
+        .suspend        = snd_jazz16_suspend,
+        .resume         = snd_jazz16_resume,
+#endif
+        .driver         = {
+                .name   = "jazz16"
+        },
+};
+
+static int __init alsa_card_jazz16_init(void)
+{
+        return isa_register_driver(&snd_jazz16_driver, SNDRV_CARDS);
+}
+
+static void __exit alsa_card_jazz16_exit(void)
+{
+        isa_unregister_driver(&snd_jazz16_driver);
+}
+
+module_init(alsa_card_jazz16_init)
+module_exit(alsa_card_jazz16_exit)
diff --git a/sound/isa/sb/sb16.c b/sound/isa/sb/sb16.c
index 519c36346dec..4d1c5a300ff8 100644
--- a/sound/isa/sb/sb16.c
+++ b/sound/isa/sb/sb16.c
@@ -21,7 +21,6 @@
 
 #include <asm/dma.h>
 #include <linux/init.h>
-#include <linux/slab.h>
 #include <linux/pnp.h>
 #include <linux/err.h>
 #include <linux/isa.h>
diff --git a/sound/isa/sb/sb8.c b/sound/isa/sb/sb8.c
index 3cd57ee54660..81284a8fa0ce 100644
--- a/sound/isa/sb/sb8.c
+++ b/sound/isa/sb/sb8.c
@@ -22,7 +22,6 @@
 #include <linux/init.h>
 #include <linux/err.h>
 #include <linux/isa.h>
-#include <linux/slab.h>
 #include <linux/ioport.h>
 #include <linux/moduleparam.h>
 #include <sound/core.h>
diff --git a/sound/isa/sb/sb8_main.c b/sound/isa/sb/sb8_main.c
index 658d55769c9c..7d84c9f34dc9 100644
--- a/sound/isa/sb/sb8_main.c
+++ b/sound/isa/sb/sb8_main.c
@@ -106,9 +106,21 @@ static int snd_sb8_playback_prepare(struct snd_pcm_substream *substream)
         struct snd_sb *chip = snd_pcm_substream_chip(substream);
         struct snd_pcm_runtime *runtime = substream->runtime;
         unsigned int mixreg, rate, size, count;
+        unsigned char format;
+        unsigned char stereo = runtime->channels > 1;
+        int dma;
 
         rate = runtime->rate;
         switch (chip->hardware) {
+        case SB_HW_JAZZ16:
+                if (runtime->format == SNDRV_PCM_FORMAT_S16_LE) {
+                        if (chip->mode & SB_MODE_CAPTURE_16)
+                                return -EBUSY;
+                        else
+                                chip->mode |= SB_MODE_PLAYBACK_16;
+                }
+                chip->playback_format = SB_DSP_LO_OUTPUT_AUTO;
+                break;
         case SB_HW_PRO:
                 if (runtime->channels > 1) {
                         if (snd_BUG_ON(rate != SB8_RATE(11025) &&
@@ -133,11 +145,21 @@ static int snd_sb8_playback_prepare(struct snd_pcm_substream *substream)
         default:
                 return -EINVAL;
         }
+        if (chip->mode & SB_MODE_PLAYBACK_16) {
+                format = stereo ? SB_DSP_STEREO_16BIT : SB_DSP_MONO_16BIT;
+                dma = chip->dma16;
+        } else {
+                format = stereo ? SB_DSP_STEREO_8BIT : SB_DSP_MONO_8BIT;
+                chip->mode |= SB_MODE_PLAYBACK_8;
+                dma = chip->dma8;
+        }
         size = chip->p_dma_size = snd_pcm_lib_buffer_bytes(substream);
         count = chip->p_period_size = snd_pcm_lib_period_bytes(substream);
         spin_lock_irqsave(&chip->reg_lock, flags);
         snd_sbdsp_command(chip, SB_DSP_SPEAKER_ON);
-        if (runtime->channels > 1) {
+        if (chip->hardware == SB_HW_JAZZ16)
+                snd_sbdsp_command(chip, format);
+        else if (stereo) {
                 /* set playback stereo mode */
                 spin_lock(&chip->mixer_lock);
                 mixreg = snd_sbmixer_read(chip, SB_DSP_STEREO_SW);
@@ -147,15 +169,14 @@ static int snd_sb8_playback_prepare(struct snd_pcm_substream *substream)
                 /* Soundblaster hardware programming reference guide, 3-23 */
                 snd_sbdsp_command(chip, SB_DSP_DMA8_EXIT);
                 runtime->dma_area[0] = 0x80;
-                snd_dma_program(chip->dma8, runtime->dma_addr, 1, DMA_MODE_WRITE);
+                snd_dma_program(dma, runtime->dma_addr, 1, DMA_MODE_WRITE);
                 /* force interrupt */
-                chip->mode = SB_MODE_HALT;
                 snd_sbdsp_command(chip, SB_DSP_OUTPUT);
                 snd_sbdsp_command(chip, 0);
                 snd_sbdsp_command(chip, 0);
         }
         snd_sbdsp_command(chip, SB_DSP_SAMPLE_RATE);
-        if (runtime->channels > 1) {
+        if (stereo) {
                 snd_sbdsp_command(chip, 256 - runtime->rate_den / 2);
                 spin_lock(&chip->mixer_lock);
                 /* save output filter status and turn it off */
@@ -168,13 +189,15 @@ static int snd_sb8_playback_prepare(struct snd_pcm_substream *substream)
                 snd_sbdsp_command(chip, 256 - runtime->rate_den);
         }
         if (chip->playback_format != SB_DSP_OUTPUT) {
+                if (chip->mode & SB_MODE_PLAYBACK_16)
+                        count /= 2;
                 count--;
                 snd_sbdsp_command(chip, SB_DSP_BLOCK_SIZE);
                 snd_sbdsp_command(chip, count & 0xff);
                 snd_sbdsp_command(chip, count >> 8);
         }
         spin_unlock_irqrestore(&chip->reg_lock, flags);
-        snd_dma_program(chip->dma8, runtime->dma_addr,
+        snd_dma_program(dma, runtime->dma_addr,
                         size, DMA_MODE_WRITE | DMA_AUTOINIT);
         return 0;
 }
@@ -212,7 +235,6 @@ static int snd_sb8_playback_trigger(struct snd_pcm_substream *substream,
                 snd_sbdsp_command(chip, SB_DSP_SPEAKER_OFF);
         }
         spin_unlock_irqrestore(&chip->reg_lock, flags);
-        chip->mode = (cmd == SNDRV_PCM_TRIGGER_START) ? SB_MODE_PLAYBACK_8 : SB_MODE_HALT;
         return 0;
 }
 
@@ -234,9 +256,21 @@ static int snd_sb8_capture_prepare(struct snd_pcm_substream *substream)
         struct snd_sb *chip = snd_pcm_substream_chip(substream);
         struct snd_pcm_runtime *runtime = substream->runtime;
         unsigned int mixreg, rate, size, count;
+        unsigned char format;
+        unsigned char stereo = runtime->channels > 1;
+        int dma;
 
         rate = runtime->rate;
         switch (chip->hardware) {
+        case SB_HW_JAZZ16:
+                if (runtime->format == SNDRV_PCM_FORMAT_S16_LE) {
+                        if (chip->mode & SB_MODE_PLAYBACK_16)
+                                return -EBUSY;
+                        else
+                                chip->mode |= SB_MODE_CAPTURE_16;
+                }
+                chip->capture_format = SB_DSP_LO_INPUT_AUTO;
+                break;
         case SB_HW_PRO:
                 if (runtime->channels > 1) {
                         if (snd_BUG_ON(rate != SB8_RATE(11025) &&
@@ -262,14 +296,24 @@ static int snd_sb8_capture_prepare(struct snd_pcm_substream *substream)
         default:
                 return -EINVAL;
         }
+        if (chip->mode & SB_MODE_CAPTURE_16) {
+                format = stereo ? SB_DSP_STEREO_16BIT : SB_DSP_MONO_16BIT;
+                dma = chip->dma16;
+        } else {
+                format = stereo ? SB_DSP_STEREO_8BIT : SB_DSP_MONO_8BIT;
+                chip->mode |= SB_MODE_CAPTURE_8;
+                dma = chip->dma8;
+        }
         size = chip->c_dma_size = snd_pcm_lib_buffer_bytes(substream);
         count = chip->c_period_size = snd_pcm_lib_period_bytes(substream);
         spin_lock_irqsave(&chip->reg_lock, flags);
         snd_sbdsp_command(chip, SB_DSP_SPEAKER_OFF);
-        if (runtime->channels > 1)
+        if (chip->hardware == SB_HW_JAZZ16)
+                snd_sbdsp_command(chip, format);
+        else if (stereo)
                 snd_sbdsp_command(chip, SB_DSP_STEREO_8BIT);
         snd_sbdsp_command(chip, SB_DSP_SAMPLE_RATE);
-        if (runtime->channels > 1) {
+        if (stereo) {
                 snd_sbdsp_command(chip, 256 - runtime->rate_den / 2);
                 spin_lock(&chip->mixer_lock);
                 /* save input filter status and turn it off */
@@ -282,13 +326,15 @@ static int snd_sb8_capture_prepare(struct snd_pcm_substream *substream)
                 snd_sbdsp_command(chip, 256 - runtime->rate_den);
         }
         if (chip->capture_format != SB_DSP_INPUT) {
+                if (chip->mode & SB_MODE_PLAYBACK_16)
+                        count /= 2;
                 count--;
                 snd_sbdsp_command(chip, SB_DSP_BLOCK_SIZE);
                 snd_sbdsp_command(chip, count & 0xff);
                 snd_sbdsp_command(chip, count >> 8);
         }
         spin_unlock_irqrestore(&chip->reg_lock, flags);
-        snd_dma_program(chip->dma8, runtime->dma_addr,
+        snd_dma_program(dma, runtime->dma_addr,
                         size, DMA_MODE_READ | DMA_AUTOINIT);
         return 0;
 }
@@ -328,7 +374,6 @@ static int snd_sb8_capture_trigger(struct snd_pcm_substream *substream,
                 snd_sbdsp_command(chip, SB_DSP_SPEAKER_OFF);
         }
         spin_unlock_irqrestore(&chip->reg_lock, flags);
-        chip->mode = (cmd == SNDRV_PCM_TRIGGER_START) ? SB_MODE_CAPTURE_8 : SB_MODE_HALT;
         return 0;
 }
 
@@ -339,13 +384,21 @@ irqreturn_t snd_sb8dsp_interrupt(struct snd_sb *chip)
 
         snd_sb_ack_8bit(chip);
         switch (chip->mode) {
-        case SB_MODE_PLAYBACK_8:        /* ok.. playback is active */
+        case SB_MODE_PLAYBACK_16:       /* ok.. playback is active */
+                if (chip->hardware != SB_HW_JAZZ16)
+                        break;
+                /* fallthru */
+        case SB_MODE_PLAYBACK_8:
                 substream = chip->playback_substream;
                 runtime = substream->runtime;
                 if (chip->playback_format == SB_DSP_OUTPUT)
                         snd_sb8_playback_trigger(substream, SNDRV_PCM_TRIGGER_START);
                 snd_pcm_period_elapsed(substream);
                 break;
+        case SB_MODE_CAPTURE_16:
+                if (chip->hardware != SB_HW_JAZZ16)
+                        break;
+                /* fallthru */
         case SB_MODE_CAPTURE_8:
                 substream = chip->capture_substream;
                 runtime = substream->runtime;
@@ -361,10 +414,15 @@ static snd_pcm_uframes_t snd_sb8_playback_pointer(struct snd_pcm_substream *subs
 {
         struct snd_sb *chip = snd_pcm_substream_chip(substream);
         size_t ptr;
+        int dma;
 
-        if (chip->mode != SB_MODE_PLAYBACK_8)
+        if (chip->mode & SB_MODE_PLAYBACK_8)
+                dma = chip->dma8;
+        else if (chip->mode & SB_MODE_PLAYBACK_16)
+                dma = chip->dma16;
+        else
                 return 0;
-        ptr = snd_dma_pointer(chip->dma8, chip->p_dma_size);
+        ptr = snd_dma_pointer(dma, chip->p_dma_size);
         return bytes_to_frames(substream->runtime, ptr);
 }
 
@@ -372,10 +430,15 @@ static snd_pcm_uframes_t snd_sb8_capture_pointer(struct snd_pcm_substream *subst
 {
         struct snd_sb *chip = snd_pcm_substream_chip(substream);
         size_t ptr;
+        int dma;
 
-        if (chip->mode != SB_MODE_CAPTURE_8)
+        if (chip->mode & SB_MODE_CAPTURE_8)
+                dma = chip->dma8;
+        else if (chip->mode & SB_MODE_CAPTURE_16)
+                dma = chip->dma16;
+        else
                 return 0;
-        ptr = snd_dma_pointer(chip->dma8, chip->c_dma_size);
+        ptr = snd_dma_pointer(dma, chip->c_dma_size);
         return bytes_to_frames(substream->runtime, ptr);
 }
 
@@ -446,6 +509,14 @@ static int snd_sb8_open(struct snd_pcm_substream *substream)
                 runtime->hw = snd_sb8_capture;
         }
         switch (chip->hardware) {
+        case SB_HW_JAZZ16:
+                if (chip->dma16 == 5 || chip->dma16 == 7)
+                        runtime->hw.formats |= SNDRV_PCM_FMTBIT_S16_LE;
+                runtime->hw.rates |= SNDRV_PCM_RATE_8000_48000;
+                runtime->hw.rate_min = 4000;
+                runtime->hw.rate_max = 50000;
+                runtime->hw.channels_max = 2;
+                break;
         case SB_HW_PRO:
                 runtime->hw.rate_max = 44100;
                 runtime->hw.channels_max = 2;
@@ -468,6 +539,14 @@ static int snd_sb8_open(struct snd_pcm_substream *substream)
         }
         snd_pcm_hw_constraint_ratnums(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
                                       &hw_constraints_clock);
+        if (chip->dma8 > 3 || chip->dma16 >= 0) {
+                snd_pcm_hw_constraint_step(runtime, 0,
+                                           SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 2);
+                snd_pcm_hw_constraint_step(runtime, 0,
+                                           SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 2);
+                runtime->hw.buffer_bytes_max = 128 * 1024 * 1024;
+                runtime->hw.period_bytes_max = 128 * 1024 * 1024;
+        }
         return 0;       
 }
 
@@ -480,6 +559,10 @@ static int snd_sb8_close(struct snd_pcm_substream *substream)
         chip->capture_substream = NULL;
         spin_lock_irqsave(&chip->open_lock, flags);
         chip->open &= ~SB_OPEN_PCM;
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+                chip->mode &= ~SB_MODE_PLAYBACK;
+        else
+                chip->mode &= ~SB_MODE_CAPTURE;
         spin_unlock_irqrestore(&chip->open_lock, flags);
         return 0;
 }
@@ -515,6 +598,7 @@ int snd_sb8dsp_pcm(struct snd_sb *chip, int device, struct snd_pcm ** rpcm)
         struct snd_card *card = chip->card;
         struct snd_pcm *pcm;
         int err;
+        size_t max_prealloc = 64 * 1024;
 
         if (rpcm)
                 *rpcm = NULL;
@@ -527,9 +611,11 @@ int snd_sb8dsp_pcm(struct snd_sb *chip, int device, struct snd_pcm ** rpcm)
         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_sb8_playback_ops);
         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_sb8_capture_ops);
 
+        if (chip->dma8 > 3 || chip->dma16 >= 0)
+                max_prealloc = 128 * 1024;
         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
                                               snd_dma_isa_data(),
-                                              64*1024, 64*1024);
+                                              64*1024, max_prealloc);
 
         if (rpcm)
                 *rpcm = pcm;
diff --git a/sound/isa/sb/sb_common.c b/sound/isa/sb/sb_common.c
index 27a651502251..eae6c1c0eff9 100644
--- a/sound/isa/sb/sb_common.c
+++ b/sound/isa/sb/sb_common.c
@@ -170,6 +170,9 @@ static int snd_sbdsp_probe(struct snd_sb * chip)
         case SB_HW_CS5530:
                 str = "16 (CS5530)";
                 break;
+        case SB_HW_JAZZ16:
+                str = "Pro (Jazz16)";
+                break;
         default:
                 return -ENODEV;
         }
diff --git a/sound/isa/sb/sb_mixer.c b/sound/isa/sb/sb_mixer.c
index 475220bbcc96..6496822c1808 100644
--- a/sound/isa/sb/sb_mixer.c
+++ b/sound/isa/sb/sb_mixer.c
@@ -528,20 +528,11 @@ int snd_sbmixer_add_ctl(struct snd_sb *chip, const char *name, int index, int ty
  * SB 2.0 specific mixer elements
  */
 
-static struct sbmix_elem snd_sb20_ctl_master_play_vol =
-        SB_SINGLE("Master Playback Volume", SB_DSP20_MASTER_DEV, 1, 7);
-static struct sbmix_elem snd_sb20_ctl_pcm_play_vol =
-        SB_SINGLE("PCM Playback Volume", SB_DSP20_PCM_DEV, 1, 3);
-static struct sbmix_elem snd_sb20_ctl_synth_play_vol =
-        SB_SINGLE("Synth Playback Volume", SB_DSP20_FM_DEV, 1, 7);
-static struct sbmix_elem snd_sb20_ctl_cd_play_vol =
-        SB_SINGLE("CD Playback Volume", SB_DSP20_CD_DEV, 1, 7);
-
-static struct sbmix_elem *snd_sb20_controls[] = {
-        &snd_sb20_ctl_master_play_vol,
-        &snd_sb20_ctl_pcm_play_vol,
-        &snd_sb20_ctl_synth_play_vol,
-        &snd_sb20_ctl_cd_play_vol
+static struct sbmix_elem snd_sb20_controls[] = {
+        SB_SINGLE("Master Playback Volume", SB_DSP20_MASTER_DEV, 1, 7),
+        SB_SINGLE("PCM Playback Volume", SB_DSP20_PCM_DEV, 1, 3),
+        SB_SINGLE("Synth Playback Volume", SB_DSP20_FM_DEV, 1, 7),
+        SB_SINGLE("CD Playback Volume", SB_DSP20_CD_DEV, 1, 7)
 };
 
 static unsigned char snd_sb20_init_values[][2] = {
@@ -552,41 +543,24 @@ static unsigned char snd_sb20_init_values[][2] = {
 /*
  * SB Pro specific mixer elements
  */
-static struct sbmix_elem snd_sbpro_ctl_master_play_vol =
-        SB_DOUBLE("Master Playback Volume", SB_DSP_MASTER_DEV, SB_DSP_MASTER_DEV, 5, 1, 7);
-static struct sbmix_elem snd_sbpro_ctl_pcm_play_vol =
-        SB_DOUBLE("PCM Playback Volume", SB_DSP_PCM_DEV, SB_DSP_PCM_DEV, 5, 1, 7);
-static struct sbmix_elem snd_sbpro_ctl_pcm_play_filter =
-        SB_SINGLE("PCM Playback Filter", SB_DSP_PLAYBACK_FILT, 5, 1);
-static struct sbmix_elem snd_sbpro_ctl_synth_play_vol =
-        SB_DOUBLE("Synth Playback Volume", SB_DSP_FM_DEV, SB_DSP_FM_DEV, 5, 1, 7);
-static struct sbmix_elem snd_sbpro_ctl_cd_play_vol =
-        SB_DOUBLE("CD Playback Volume", SB_DSP_CD_DEV, SB_DSP_CD_DEV, 5, 1, 7);
-static struct sbmix_elem snd_sbpro_ctl_line_play_vol =
-        SB_DOUBLE("Line Playback Volume", SB_DSP_LINE_DEV, SB_DSP_LINE_DEV, 5, 1, 7);
-static struct sbmix_elem snd_sbpro_ctl_mic_play_vol =
-        SB_SINGLE("Mic Playback Volume", SB_DSP_MIC_DEV, 1, 3);
-static struct sbmix_elem snd_sbpro_ctl_capture_source =
+static struct sbmix_elem snd_sbpro_controls[] = {
+        SB_DOUBLE("Master Playback Volume",
+                  SB_DSP_MASTER_DEV, SB_DSP_MASTER_DEV, 5, 1, 7),
+        SB_DOUBLE("PCM Playback Volume",
+                  SB_DSP_PCM_DEV, SB_DSP_PCM_DEV, 5, 1, 7),
+        SB_SINGLE("PCM Playback Filter", SB_DSP_PLAYBACK_FILT, 5, 1),
+        SB_DOUBLE("Synth Playback Volume",
+                  SB_DSP_FM_DEV, SB_DSP_FM_DEV, 5, 1, 7),
+        SB_DOUBLE("CD Playback Volume", SB_DSP_CD_DEV, SB_DSP_CD_DEV, 5, 1, 7),
+        SB_DOUBLE("Line Playback Volume",
+                  SB_DSP_LINE_DEV, SB_DSP_LINE_DEV, 5, 1, 7),
+        SB_SINGLE("Mic Playback Volume", SB_DSP_MIC_DEV, 1, 3),
         {
                 .name = "Capture Source",
                 .type = SB_MIX_CAPTURE_PRO
-        };
-static struct sbmix_elem snd_sbpro_ctl_capture_filter =
-        SB_SINGLE("Capture Filter", SB_DSP_CAPTURE_FILT, 5, 1);
-static struct sbmix_elem snd_sbpro_ctl_capture_low_filter =
-        SB_SINGLE("Capture Low-Pass Filter", SB_DSP_CAPTURE_FILT, 3, 1);
-
-static struct sbmix_elem *snd_sbpro_controls[] = {
-        &snd_sbpro_ctl_master_play_vol,
-        &snd_sbpro_ctl_pcm_play_vol,
-        &snd_sbpro_ctl_pcm_play_filter,
-        &snd_sbpro_ctl_synth_play_vol,
-        &snd_sbpro_ctl_cd_play_vol,
-        &snd_sbpro_ctl_line_play_vol,
-        &snd_sbpro_ctl_mic_play_vol,
-        &snd_sbpro_ctl_capture_source,
-        &snd_sbpro_ctl_capture_filter,
-        &snd_sbpro_ctl_capture_low_filter
+        },
+        SB_SINGLE("Capture Filter", SB_DSP_CAPTURE_FILT, 5, 1),
+        SB_SINGLE("Capture Low-Pass Filter", SB_DSP_CAPTURE_FILT, 3, 1)
 };
 
 static unsigned char snd_sbpro_init_values[][2] = {
@@ -598,68 +572,42 @@ static unsigned char snd_sbpro_init_values[][2] = {
 /*
  * SB16 specific mixer elements
  */
-static struct sbmix_elem snd_sb16_ctl_master_play_vol =
-        SB_DOUBLE("Master Playback Volume", SB_DSP4_MASTER_DEV, (SB_DSP4_MASTER_DEV + 1), 3, 3, 31);
-static struct sbmix_elem snd_sb16_ctl_3d_enhance_switch =
-        SB_SINGLE("3D Enhancement Switch", SB_DSP4_3DSE, 0, 1);
-static struct sbmix_elem snd_sb16_ctl_tone_bass =
-        SB_DOUBLE("Tone Control - Bass", SB_DSP4_BASS_DEV, (SB_DSP4_BASS_DEV + 1), 4, 4, 15);
-static struct sbmix_elem snd_sb16_ctl_tone_treble =
-        SB_DOUBLE("Tone Control - Treble", SB_DSP4_TREBLE_DEV, (SB_DSP4_TREBLE_DEV + 1), 4, 4, 15);
-static struct sbmix_elem snd_sb16_ctl_pcm_play_vol =
-        SB_DOUBLE("PCM Playback Volume", SB_DSP4_PCM_DEV, (SB_DSP4_PCM_DEV + 1), 3, 3, 31);
-static struct sbmix_elem snd_sb16_ctl_synth_capture_route =
-        SB16_INPUT_SW("Synth Capture Route", SB_DSP4_INPUT_LEFT, SB_DSP4_INPUT_RIGHT, 6, 5);
-static struct sbmix_elem snd_sb16_ctl_synth_play_vol =
-        SB_DOUBLE("Synth Playback Volume", SB_DSP4_SYNTH_DEV, (SB_DSP4_SYNTH_DEV + 1), 3, 3, 31);
-static struct sbmix_elem snd_sb16_ctl_cd_capture_route =
-        SB16_INPUT_SW("CD Capture Route", SB_DSP4_INPUT_LEFT, SB_DSP4_INPUT_RIGHT, 2, 1);
-static struct sbmix_elem snd_sb16_ctl_cd_play_switch =
-        SB_DOUBLE("CD Playback Switch", SB_DSP4_OUTPUT_SW, SB_DSP4_OUTPUT_SW, 2, 1, 1);
-static struct sbmix_elem snd_sb16_ctl_cd_play_vol =
-        SB_DOUBLE("CD Playback Volume", SB_DSP4_CD_DEV, (SB_DSP4_CD_DEV + 1), 3, 3, 31);
-static struct sbmix_elem snd_sb16_ctl_line_capture_route =
-        SB16_INPUT_SW("Line Capture Route", SB_DSP4_INPUT_LEFT, SB_DSP4_INPUT_RIGHT, 4, 3);
-static struct sbmix_elem snd_sb16_ctl_line_play_switch =
-        SB_DOUBLE("Line Playback Switch", SB_DSP4_OUTPUT_SW, SB_DSP4_OUTPUT_SW, 4, 3, 1);
-static struct sbmix_elem snd_sb16_ctl_line_play_vol =
-        SB_DOUBLE("Line Playback Volume", SB_DSP4_LINE_DEV, (SB_DSP4_LINE_DEV + 1), 3, 3, 31);
-static struct sbmix_elem snd_sb16_ctl_mic_capture_route =
-        SB16_INPUT_SW("Mic Capture Route", SB_DSP4_INPUT_LEFT, SB_DSP4_INPUT_RIGHT, 0, 0);
-static struct sbmix_elem snd_sb16_ctl_mic_play_switch =
-        SB_SINGLE("Mic Playback Switch", SB_DSP4_OUTPUT_SW, 0, 1);
-static struct sbmix_elem snd_sb16_ctl_mic_play_vol =
-        SB_SINGLE("Mic Playback Volume", SB_DSP4_MIC_DEV, 3, 31);
-static struct sbmix_elem snd_sb16_ctl_pc_speaker_vol =
-        SB_SINGLE("PC Speaker Volume", SB_DSP4_SPEAKER_DEV, 6, 3);
-static struct sbmix_elem snd_sb16_ctl_capture_vol =
-        SB_DOUBLE("Capture Volume", SB_DSP4_IGAIN_DEV, (SB_DSP4_IGAIN_DEV + 1), 6, 6, 3);
-static struct sbmix_elem snd_sb16_ctl_play_vol =
-        SB_DOUBLE("Playback Volume", SB_DSP4_OGAIN_DEV, (SB_DSP4_OGAIN_DEV + 1), 6, 6, 3);
-static struct sbmix_elem snd_sb16_ctl_auto_mic_gain =
-        SB_SINGLE("Mic Auto Gain", SB_DSP4_MIC_AGC, 0, 1);
-
-static struct sbmix_elem *snd_sb16_controls[] = {
-        &snd_sb16_ctl_master_play_vol,
-        &snd_sb16_ctl_3d_enhance_switch,
-        &snd_sb16_ctl_tone_bass,
-        &snd_sb16_ctl_tone_treble,
-        &snd_sb16_ctl_pcm_play_vol,
-        &snd_sb16_ctl_synth_capture_route,
-        &snd_sb16_ctl_synth_play_vol,
-        &snd_sb16_ctl_cd_capture_route,
-        &snd_sb16_ctl_cd_play_switch,
-        &snd_sb16_ctl_cd_play_vol,
-        &snd_sb16_ctl_line_capture_route,
-        &snd_sb16_ctl_line_play_switch,
-        &snd_sb16_ctl_line_play_vol,
-        &snd_sb16_ctl_mic_capture_route,
-        &snd_sb16_ctl_mic_play_switch,
-        &snd_sb16_ctl_mic_play_vol,
-        &snd_sb16_ctl_pc_speaker_vol,
-        &snd_sb16_ctl_capture_vol,
-        &snd_sb16_ctl_play_vol,
-        &snd_sb16_ctl_auto_mic_gain
+static struct sbmix_elem snd_sb16_controls[] = {
+        SB_DOUBLE("Master Playback Volume",
+                  SB_DSP4_MASTER_DEV, (SB_DSP4_MASTER_DEV + 1), 3, 3, 31),
+        SB_DOUBLE("PCM Playback Volume",
+                  SB_DSP4_PCM_DEV, (SB_DSP4_PCM_DEV + 1), 3, 3, 31),
+        SB16_INPUT_SW("Synth Capture Route",
+                      SB_DSP4_INPUT_LEFT, SB_DSP4_INPUT_RIGHT, 6, 5),
+        SB_DOUBLE("Synth Playback Volume",
+                  SB_DSP4_SYNTH_DEV, (SB_DSP4_SYNTH_DEV + 1), 3, 3, 31),
+        SB16_INPUT_SW("CD Capture Route",
+                      SB_DSP4_INPUT_LEFT, SB_DSP4_INPUT_RIGHT, 2, 1),
+        SB_DOUBLE("CD Playback Switch",
+                  SB_DSP4_OUTPUT_SW, SB_DSP4_OUTPUT_SW, 2, 1, 1),
+        SB_DOUBLE("CD Playback Volume",
+                  SB_DSP4_CD_DEV, (SB_DSP4_CD_DEV + 1), 3, 3, 31),
+        SB16_INPUT_SW("Mic Capture Route",
+                      SB_DSP4_INPUT_LEFT, SB_DSP4_INPUT_RIGHT, 0, 0),
+        SB_SINGLE("Mic Playback Switch", SB_DSP4_OUTPUT_SW, 0, 1),
+        SB_SINGLE("Mic Playback Volume", SB_DSP4_MIC_DEV, 3, 31),
+        SB_SINGLE("Beep Volume", SB_DSP4_SPEAKER_DEV, 6, 3),
+        SB_DOUBLE("Capture Volume",
+                  SB_DSP4_IGAIN_DEV, (SB_DSP4_IGAIN_DEV + 1), 6, 6, 3),
+        SB_DOUBLE("Playback Volume",
+                  SB_DSP4_OGAIN_DEV, (SB_DSP4_OGAIN_DEV + 1), 6, 6, 3),
+        SB16_INPUT_SW("Line Capture Route",
+                      SB_DSP4_INPUT_LEFT, SB_DSP4_INPUT_RIGHT, 4, 3),
+        SB_DOUBLE("Line Playback Switch",
+                  SB_DSP4_OUTPUT_SW, SB_DSP4_OUTPUT_SW, 4, 3, 1),
+        SB_DOUBLE("Line Playback Volume",
+                  SB_DSP4_LINE_DEV, (SB_DSP4_LINE_DEV + 1), 3, 3, 31),
+        SB_SINGLE("Mic Auto Gain", SB_DSP4_MIC_AGC, 0, 1),
+        SB_SINGLE("3D Enhancement Switch", SB_DSP4_3DSE, 0, 1),
+        SB_DOUBLE("Tone Control - Bass",
+                  SB_DSP4_BASS_DEV, (SB_DSP4_BASS_DEV + 1), 4, 4, 15),
+        SB_DOUBLE("Tone Control - Treble",
+                  SB_DSP4_TREBLE_DEV, (SB_DSP4_TREBLE_DEV + 1), 4, 4, 15)
 };
 
 static unsigned char snd_sb16_init_values[][2] = {
@@ -678,46 +626,34 @@ static unsigned char snd_sb16_init_values[][2] = {
 /*
  * DT019x specific mixer elements
  */
-static struct sbmix_elem snd_dt019x_ctl_master_play_vol =
-        SB_DOUBLE("Master Playback Volume", SB_DT019X_MASTER_DEV, SB_DT019X_MASTER_DEV, 4,0, 15);
-static struct sbmix_elem snd_dt019x_ctl_pcm_play_vol =
-        SB_DOUBLE("PCM Playback Volume", SB_DT019X_PCM_DEV, SB_DT019X_PCM_DEV, 4,0, 15);
-static struct sbmix_elem snd_dt019x_ctl_synth_play_vol =
-        SB_DOUBLE("Synth Playback Volume", SB_DT019X_SYNTH_DEV, SB_DT019X_SYNTH_DEV, 4,0, 15);
-static struct sbmix_elem snd_dt019x_ctl_cd_play_vol =
-        SB_DOUBLE("CD Playback Volume", SB_DT019X_CD_DEV, SB_DT019X_CD_DEV, 4,0, 15);
-static struct sbmix_elem snd_dt019x_ctl_mic_play_vol =
-        SB_SINGLE("Mic Playback Volume", SB_DT019X_MIC_DEV, 4, 7);
-static struct sbmix_elem snd_dt019x_ctl_pc_speaker_vol =
-        SB_SINGLE("PC Speaker Volume", SB_DT019X_SPKR_DEV, 0,  7);
-static struct sbmix_elem snd_dt019x_ctl_line_play_vol =
-        SB_DOUBLE("Line Playback Volume", SB_DT019X_LINE_DEV, SB_DT019X_LINE_DEV, 4,0, 15);
-static struct sbmix_elem snd_dt019x_ctl_pcm_play_switch =
-        SB_DOUBLE("PCM Playback Switch", SB_DT019X_OUTPUT_SW2, SB_DT019X_OUTPUT_SW2, 2,1, 1);
-static struct sbmix_elem snd_dt019x_ctl_synth_play_switch =
-        SB_DOUBLE("Synth Playback Switch", SB_DT019X_OUTPUT_SW2, SB_DT019X_OUTPUT_SW2, 4,3, 1);
-static struct sbmix_elem snd_dt019x_ctl_capture_source =
+static struct sbmix_elem snd_dt019x_controls[] = {
+        /* ALS4000 below has some parts which we might be lacking,
+         * e.g. snd_als4000_ctl_mono_playback_switch - check it! */
+        SB_DOUBLE("Master Playback Volume",
+                  SB_DT019X_MASTER_DEV, SB_DT019X_MASTER_DEV, 4, 0, 15),
+        SB_DOUBLE("PCM Playback Switch",
+                  SB_DT019X_OUTPUT_SW2, SB_DT019X_OUTPUT_SW2, 2, 1, 1),
+        SB_DOUBLE("PCM Playback Volume",
+                  SB_DT019X_PCM_DEV, SB_DT019X_PCM_DEV, 4, 0, 15),
+        SB_DOUBLE("Synth Playback Switch",
+                  SB_DT019X_OUTPUT_SW2, SB_DT019X_OUTPUT_SW2, 4, 3, 1),
+        SB_DOUBLE("Synth Playback Volume",
+                  SB_DT019X_SYNTH_DEV, SB_DT019X_SYNTH_DEV, 4, 0, 15),
+        SB_DOUBLE("CD Playback Switch",
+                  SB_DSP4_OUTPUT_SW, SB_DSP4_OUTPUT_SW, 2, 1, 1),
+        SB_DOUBLE("CD Playback Volume",
+                  SB_DT019X_CD_DEV, SB_DT019X_CD_DEV, 4, 0, 15),
+        SB_SINGLE("Mic Playback Switch", SB_DSP4_OUTPUT_SW, 0, 1),
+        SB_SINGLE("Mic Playback Volume", SB_DT019X_MIC_DEV, 4, 7),
+        SB_SINGLE("Beep Volume", SB_DT019X_SPKR_DEV, 0,  7),
+        SB_DOUBLE("Line Playback Switch",
+                  SB_DSP4_OUTPUT_SW, SB_DSP4_OUTPUT_SW, 4, 3, 1),
+        SB_DOUBLE("Line Playback Volume",
+                  SB_DT019X_LINE_DEV, SB_DT019X_LINE_DEV, 4, 0, 15),
         {
                 .name = "Capture Source",
                 .type = SB_MIX_CAPTURE_DT019X
-        };
-
-static struct sbmix_elem *snd_dt019x_controls[] = {
-        /* ALS4000 below has some parts which we might be lacking,
-         * e.g. snd_als4000_ctl_mono_playback_switch - check it! */
-        &snd_dt019x_ctl_master_play_vol,
-        &snd_dt019x_ctl_pcm_play_vol,
-        &snd_dt019x_ctl_synth_play_vol,
-        &snd_dt019x_ctl_cd_play_vol,
-        &snd_dt019x_ctl_mic_play_vol,
-        &snd_dt019x_ctl_pc_speaker_vol,
-        &snd_dt019x_ctl_line_play_vol,
-        &snd_sb16_ctl_mic_play_switch,
-        &snd_sb16_ctl_cd_play_switch,
-        &snd_sb16_ctl_line_play_switch,
-        &snd_dt019x_ctl_pcm_play_switch,
-        &snd_dt019x_ctl_synth_play_switch,
-        &snd_dt019x_ctl_capture_source
+        }
 };
 
 static unsigned char snd_dt019x_init_values[][2] = {
@@ -735,82 +671,37 @@ static unsigned char snd_dt019x_init_values[][2] = {
 /*
  * ALS4000 specific mixer elements
  */
-static struct sbmix_elem snd_als4000_ctl_master_mono_playback_switch =
-        SB_SINGLE("Master Mono Playback Switch", SB_ALS4000_MONO_IO_CTRL, 5, 1);
-static struct sbmix_elem snd_als4k_ctl_master_mono_capture_route = {
+static struct sbmix_elem snd_als4000_controls[] = {
+        SB_DOUBLE("PCM Playback Switch",
+                  SB_DT019X_OUTPUT_SW2, SB_DT019X_OUTPUT_SW2, 2, 1, 1),
+        SB_DOUBLE("Synth Playback Switch",
+                  SB_DT019X_OUTPUT_SW2, SB_DT019X_OUTPUT_SW2, 4, 3, 1),
+        SB_SINGLE("Mic Boost (+20dB)", SB_ALS4000_MIC_IN_GAIN, 0, 0x03),
+        SB_SINGLE("Master Mono Playback Switch", SB_ALS4000_MONO_IO_CTRL, 5, 1),
+        {
                 .name = "Master Mono Capture Route",
                 .type = SB_MIX_MONO_CAPTURE_ALS4K
-        };
-static struct sbmix_elem snd_als4000_ctl_mono_playback_switch =
-        SB_SINGLE("Mono Playback Switch", SB_DT019X_OUTPUT_SW2, 0, 1);
-static struct sbmix_elem snd_als4000_ctl_mic_20db_boost =
-        SB_SINGLE("Mic Boost (+20dB)", SB_ALS4000_MIC_IN_GAIN, 0, 0x03);
-static struct sbmix_elem snd_als4000_ctl_mixer_analog_loopback =
-        SB_SINGLE("Analog Loopback Switch", SB_ALS4000_MIC_IN_GAIN, 7, 0x01);
-static struct sbmix_elem snd_als4000_ctl_mixer_digital_loopback =
+        },
+        SB_SINGLE("Mono Playback Switch", SB_DT019X_OUTPUT_SW2, 0, 1),
+        SB_SINGLE("Analog Loopback Switch", SB_ALS4000_MIC_IN_GAIN, 7, 0x01),
+        SB_SINGLE("3D Control - Switch", SB_ALS4000_3D_SND_FX, 6, 0x01),
         SB_SINGLE("Digital Loopback Switch",
-                  SB_ALS4000_CR3_CONFIGURATION, 7, 0x01);
-/* FIXME: functionality of 3D controls might be swapped, I didn't find
- * a description of how to identify what is supposed to be what */
-static struct sbmix_elem snd_als4000_3d_control_switch =
-        SB_SINGLE("3D Control - Switch", SB_ALS4000_3D_SND_FX, 6, 0x01);
-static struct sbmix_elem snd_als4000_3d_control_ratio =
-        SB_SINGLE("3D Control - Level", SB_ALS4000_3D_SND_FX, 0, 0x07);
-static struct sbmix_elem snd_als4000_3d_control_freq =
+                  SB_ALS4000_CR3_CONFIGURATION, 7, 0x01),
+        /* FIXME: functionality of 3D controls might be swapped, I didn't find
+         * a description of how to identify what is supposed to be what */
+        SB_SINGLE("3D Control - Level", SB_ALS4000_3D_SND_FX, 0, 0x07),
         /* FIXME: maybe there's actually some standard 3D ctrl name for it?? */
-        SB_SINGLE("3D Control - Freq", SB_ALS4000_3D_SND_FX, 4, 0x03);
-static struct sbmix_elem snd_als4000_3d_control_delay =
+        SB_SINGLE("3D Control - Freq", SB_ALS4000_3D_SND_FX, 4, 0x03),
         /* FIXME: ALS4000a.pdf mentions BBD (Bucket Brigade Device) time delay,
          * but what ALSA 3D attribute is that actually? "Center", "Depth",
          * "Wide" or "Space" or even "Level"? Assuming "Wide" for now... */
-        SB_SINGLE("3D Control - Wide", SB_ALS4000_3D_TIME_DELAY, 0, 0x0f);
-static struct sbmix_elem snd_als4000_3d_control_poweroff_switch =
-        SB_SINGLE("3D PowerOff Switch", SB_ALS4000_3D_TIME_DELAY, 4, 0x01);
-static struct sbmix_elem snd_als4000_ctl_3db_freq_control_switch =
+        SB_SINGLE("3D Control - Wide", SB_ALS4000_3D_TIME_DELAY, 0, 0x0f),
+        SB_SINGLE("3D PowerOff Switch", SB_ALS4000_3D_TIME_DELAY, 4, 0x01),
         SB_SINGLE("Master Playback 8kHz / 20kHz LPF Switch",
-                  SB_ALS4000_FMDAC, 5, 0x01);
+                  SB_ALS4000_FMDAC, 5, 0x01),
 #ifdef NOT_AVAILABLE
-static struct sbmix_elem snd_als4000_ctl_fmdac =
-        SB_SINGLE("FMDAC Switch (Option ?)", SB_ALS4000_FMDAC, 0, 0x01);
-static struct sbmix_elem snd_als4000_ctl_qsound =
-        SB_SINGLE("QSound Mode", SB_ALS4000_QSOUND, 1, 0x1f);
-#endif
-
-static struct sbmix_elem *snd_als4000_controls[] = {
-                                                /* ALS4000a.PDF regs page */
-        &snd_sb16_ctl_master_play_vol,          /* MX30/31 12 */
-        &snd_dt019x_ctl_pcm_play_switch,        /* MX4C    16 */
-        &snd_sb16_ctl_pcm_play_vol,             /* MX32/33 12 */
-        &snd_sb16_ctl_synth_capture_route,      /* MX3D/3E 14 */
-        &snd_dt019x_ctl_synth_play_switch,      /* MX4C    16 */
-        &snd_sb16_ctl_synth_play_vol,           /* MX34/35 12/13 */
-        &snd_sb16_ctl_cd_capture_route,         /* MX3D/3E 14 */
-        &snd_sb16_ctl_cd_play_switch,           /* MX3C    14 */
-        &snd_sb16_ctl_cd_play_vol,              /* MX36/37 13 */
-        &snd_sb16_ctl_line_capture_route,       /* MX3D/3E 14 */
-        &snd_sb16_ctl_line_play_switch,         /* MX3C    14 */
-        &snd_sb16_ctl_line_play_vol,            /* MX38/39 13 */
-        &snd_sb16_ctl_mic_capture_route,        /* MX3D/3E 14 */
-        &snd_als4000_ctl_mic_20db_boost,        /* MX4D    16 */
-        &snd_sb16_ctl_mic_play_switch,          /* MX3C    14 */
-        &snd_sb16_ctl_mic_play_vol,             /* MX3A    13 */
-        &snd_sb16_ctl_pc_speaker_vol,           /* MX3B    14 */
-        &snd_sb16_ctl_capture_vol,              /* MX3F/40 15 */
-        &snd_sb16_ctl_play_vol,                 /* MX41/42 15 */
-        &snd_als4000_ctl_master_mono_playback_switch, /* MX4C 16 */
-        &snd_als4k_ctl_master_mono_capture_route, /* MX4B  16 */
-        &snd_als4000_ctl_mono_playback_switch,  /* MX4C    16 */
-        &snd_als4000_ctl_mixer_analog_loopback, /* MX4D    16 */
-        &snd_als4000_ctl_mixer_digital_loopback, /* CR3    21 */
-        &snd_als4000_3d_control_switch,          /* MX50   17 */
-        &snd_als4000_3d_control_ratio,           /* MX50   17 */
-        &snd_als4000_3d_control_freq,            /* MX50   17 */
-        &snd_als4000_3d_control_delay,           /* MX51   18 */
-        &snd_als4000_3d_control_poweroff_switch,        /* MX51    18 */
-        &snd_als4000_ctl_3db_freq_control_switch,       /* MX4F    17 */
-#ifdef NOT_AVAILABLE
-        &snd_als4000_ctl_fmdac,
-        &snd_als4000_ctl_qsound,
+        SB_SINGLE("FMDAC Switch (Option ?)", SB_ALS4000_FMDAC, 0, 0x01),
+        SB_SINGLE("QSound Mode", SB_ALS4000_QSOUND, 1, 0x1f),
 #endif
 };
 
@@ -829,11 +720,10 @@ static unsigned char snd_als4000_init_values[][2] = {
         { SB_ALS4000_MIC_IN_GAIN, 0 },
 };
 
-
 /*
  */
 static int snd_sbmixer_init(struct snd_sb *chip,
-                            struct sbmix_elem **controls,
+                            struct sbmix_elem *controls,
                             int controls_count,
                             unsigned char map[][2],
                             int map_count,
@@ -856,7 +746,8 @@ static int snd_sbmixer_init(struct snd_sb *chip,
         }
 
         for (idx = 0; idx < controls_count; idx++) {
-                if ((err = snd_sbmixer_add_ctl_elem(chip, controls[idx])) < 0)
+                err = snd_sbmixer_add_ctl_elem(chip, &controls[idx]);
+                if (err < 0)
                         return err;
         }
         snd_component_add(card, name);
@@ -888,6 +779,7 @@ int snd_sbmixer_new(struct snd_sb *chip)
                         return err;
                 break;
         case SB_HW_PRO:
+        case SB_HW_JAZZ16:
                 if ((err = snd_sbmixer_init(chip,
                                             snd_sbpro_controls,
                                             ARRAY_SIZE(snd_sbpro_controls),
@@ -908,6 +800,15 @@ int snd_sbmixer_new(struct snd_sb *chip)
                         return err;
                 break;
         case SB_HW_ALS4000:
+                /* use only the first 16 controls from SB16 */
+                err = snd_sbmixer_init(chip,
+                                        snd_sb16_controls,
+                                        16,
+                                        snd_sb16_init_values,
+                                        ARRAY_SIZE(snd_sb16_init_values),
+                                        "ALS4000");
+                if (err < 0)
+                        return err;
                 if ((err = snd_sbmixer_init(chip,
                                             snd_als4000_controls,
                                             ARRAY_SIZE(snd_als4000_controls),
@@ -1029,6 +930,7 @@ void snd_sbmixer_suspend(struct snd_sb *chip)
                 save_mixer(chip, sb20_saved_regs, ARRAY_SIZE(sb20_saved_regs));
                 break;
         case SB_HW_PRO:
+        case SB_HW_JAZZ16:
                 save_mixer(chip, sbpro_saved_regs, ARRAY_SIZE(sbpro_saved_regs));
                 break;
         case SB_HW_16:
@@ -1055,6 +957,7 @@ void snd_sbmixer_resume(struct snd_sb *chip)
                 restore_mixer(chip, sb20_saved_regs, ARRAY_SIZE(sb20_saved_regs));
                 break;
         case SB_HW_PRO:
+        case SB_HW_JAZZ16:
                 restore_mixer(chip, sbpro_saved_regs, ARRAY_SIZE(sbpro_saved_regs));
                 break;
         case SB_HW_16:
diff --git a/sound/isa/sscape.c b/sound/isa/sscape.c
index 66187122377c..e2d5d2d3ed96 100644
--- a/sound/isa/sscape.c
+++ b/sound/isa/sscape.c
@@ -1,5 +1,5 @@
 /*
- *   Low-level ALSA driver for the ENSONIQ SoundScape PnP
+ *   Low-level ALSA driver for the ENSONIQ SoundScape
  *   Copyright (c) by Chris Rankin
  *
  *   This driver was written in part using information obtained from
@@ -25,31 +25,36 @@
 #include <linux/err.h>
 #include <linux/isa.h>
 #include <linux/delay.h>
+#include <linux/firmware.h>
 #include <linux/pnp.h>
 #include <linux/spinlock.h>
 #include <linux/moduleparam.h>
 #include <asm/dma.h>
 #include <sound/core.h>
-#include <sound/hwdep.h>
 #include <sound/wss.h>
 #include <sound/mpu401.h>
 #include <sound/initval.h>
 
-#include <sound/sscape_ioctl.h>
-
 
 MODULE_AUTHOR("Chris Rankin");
-MODULE_DESCRIPTION("ENSONIQ SoundScape PnP driver");
+MODULE_DESCRIPTION("ENSONIQ SoundScape driver");
 MODULE_LICENSE("GPL");
-
-static int index[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_IDX;
-static char* id[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_STR;
-static long port[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PORT;
-static long wss_port[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PORT;
-static int irq[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_IRQ;
-static int mpu_irq[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_IRQ;
-static int dma[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_DMA;
-static int dma2[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_DMA;
+MODULE_FIRMWARE("sndscape.co0");
+MODULE_FIRMWARE("sndscape.co1");
+MODULE_FIRMWARE("sndscape.co2");
+MODULE_FIRMWARE("sndscape.co3");
+MODULE_FIRMWARE("sndscape.co4");
+MODULE_FIRMWARE("scope.cod");
+
+static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
+static char* id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
+static long port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
+static long wss_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
+static int irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ;
+static int mpu_irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ;
+static int dma[SNDRV_CARDS] = SNDRV_DEFAULT_DMA;
+static int dma2[SNDRV_CARDS] = SNDRV_DEFAULT_DMA;
+static bool joystick[SNDRV_CARDS];
 
 module_param_array(index, int, NULL, 0444);
 MODULE_PARM_DESC(index, "Index number for SoundScape soundcard");
@@ -75,6 +80,9 @@ MODULE_PARM_DESC(dma, "DMA # for SoundScape driver.");
 module_param_array(dma2, int, NULL, 0444);
 MODULE_PARM_DESC(dma2, "DMA2 # for SoundScape driver.");
 
+module_param_array(joystick, bool, NULL, 0444);
+MODULE_PARM_DESC(joystick, "Enable gameport.");
+
 #ifdef CONFIG_PNP
 static int isa_registered;
 static int pnp_registered;
@@ -101,14 +109,14 @@ MODULE_DEVICE_TABLE(pnp_card, sscape_pnpids);
 #define RX_READY 0x01
 #define TX_READY 0x02
 
-#define CMD_ACK           0x80
-#define CMD_SET_MIDI_VOL  0x84
-#define CMD_GET_MIDI_VOL  0x85
-#define CMD_XXX_MIDI_VOL  0x86
-#define CMD_SET_EXTMIDI   0x8a
-#define CMD_GET_EXTMIDI   0x8b
-#define CMD_SET_MT32      0x8c
-#define CMD_GET_MT32      0x8d
+#define CMD_ACK                 0x80
+#define CMD_SET_MIDI_VOL        0x84
+#define CMD_GET_MIDI_VOL        0x85
+#define CMD_XXX_MIDI_VOL        0x86
+#define CMD_SET_EXTMIDI         0x8a
+#define CMD_GET_EXTMIDI         0x8b
+#define CMD_SET_MT32            0x8c
+#define CMD_GET_MT32            0x8d
 
 enum GA_REG {
         GA_INTSTAT_REG = 0,
@@ -127,7 +135,8 @@ enum GA_REG {
 
 
 enum card_type {
-        SSCAPE,
+        MEDIA_FX,       /* Sequoia S-1000 */
+        SSCAPE,         /* Sequoia S-2000 */
         SSCAPE_PNP,
         SSCAPE_VIVO,
 };
@@ -140,16 +149,7 @@ struct soundscape {
         struct resource *io_res;
         struct resource *wss_res;
         struct snd_wss *chip;
-        struct snd_mpu401 *mpu;
-        struct snd_hwdep *hw;
 
-        /*
-         * The MIDI device won't work until we've loaded
-         * its firmware via a hardware-dependent device IOCTL
-         */
-        spinlock_t fwlock;
-        int hw_in_use;
-        unsigned long midi_usage;
         unsigned char midi_vol;
 };
 
@@ -161,28 +161,21 @@ static inline struct soundscape *get_card_soundscape(struct snd_card *c)
         return (struct soundscape *) (c->private_data);
 }
 
-static inline struct soundscape *get_mpu401_soundscape(struct snd_mpu401 * mpu)
-{
-        return (struct soundscape *) (mpu->private_data);
-}
-
-static inline struct soundscape *get_hwdep_soundscape(struct snd_hwdep * hw)
-{
-        return (struct soundscape *) (hw->private_data);
-}
-
-
 /*
  * Allocates some kernel memory that we can use for DMA.
  * I think this means that the memory has to map to
  * contiguous pages of physical memory.
  */
-static struct snd_dma_buffer *get_dmabuf(struct snd_dma_buffer *buf, unsigned long size)
+static struct snd_dma_buffer *get_dmabuf(struct snd_dma_buffer *buf,
+                                         unsigned long size)
 {
         if (buf) {
-                if (snd_dma_alloc_pages_fallback(SNDRV_DMA_TYPE_DEV, snd_dma_isa_data(),
+                if (snd_dma_alloc_pages_fallback(SNDRV_DMA_TYPE_DEV,
+                                                 snd_dma_isa_data(),
                                                  size, buf) < 0) {
-                        snd_printk(KERN_ERR "sscape: Failed to allocate %lu bytes for DMA\n", size);
+                        snd_printk(KERN_ERR "sscape: Failed to allocate "
+                                            "%lu bytes for DMA\n",
+                                            size);
                         return NULL;
                 }
         }
@@ -199,13 +192,13 @@ static void free_dmabuf(struct snd_dma_buffer *buf)
                 snd_dma_free_pages(buf);
 }
 
-
 /*
  * This function writes to the SoundScape's control registers,
  * but doesn't do any locking. It's up to the caller to do that.
  * This is why this function is "unsafe" ...
  */
-static inline void sscape_write_unsafe(unsigned io_base, enum GA_REG reg, unsigned char val)
+static inline void sscape_write_unsafe(unsigned io_base, enum GA_REG reg,
+                                       unsigned char val)
 {
         outb(reg, ODIE_ADDR_IO(io_base));
         outb(val, ODIE_DATA_IO(io_base));
@@ -215,7 +208,8 @@ static inline void sscape_write_unsafe(unsigned io_base, enum GA_REG reg, unsign
  * Write to the SoundScape's control registers, and do the
  * necessary locking ...
  */
-static void sscape_write(struct soundscape *s, enum GA_REG reg, unsigned char val)
+static void sscape_write(struct soundscape *s, enum GA_REG reg,
+                         unsigned char val)
 {
         unsigned long flags;
 
@@ -228,7 +222,8 @@ static void sscape_write(struct soundscape *s, enum GA_REG reg, unsigned char va
  * Read from the SoundScape's control registers, but leave any
  * locking to the caller. This is why the function is "unsafe" ...
  */
-static inline unsigned char sscape_read_unsafe(unsigned io_base, enum GA_REG reg)
+static inline unsigned char sscape_read_unsafe(unsigned io_base,
+                                               enum GA_REG reg)
 {
         outb(reg, ODIE_ADDR_IO(io_base));
         return inb(ODIE_DATA_IO(io_base));
@@ -257,9 +252,8 @@ static inline void set_midi_mode_unsafe(unsigned io_base)
 static inline int host_read_unsafe(unsigned io_base)
 {
         int data = -1;
-        if ((inb(HOST_CTRL_IO(io_base)) & RX_READY) != 0) {
+        if ((inb(HOST_CTRL_IO(io_base)) & RX_READY) != 0)
                 data = inb(HOST_DATA_IO(io_base));
-        }
 
         return data;
 }
@@ -301,7 +295,7 @@ static inline int host_write_unsafe(unsigned io_base, unsigned char data)
  * Also leaves all locking-issues to the caller ...
  */
 static int host_write_ctrl_unsafe(unsigned io_base, unsigned char data,
-                                  unsigned timeout)
+                                  unsigned timeout)
 {
         int err;
 
@@ -320,7 +314,7 @@ static int host_write_ctrl_unsafe(unsigned io_base, unsigned char data,
  *
  * NOTE: This check is based upon observation, not documentation.
  */
-static inline int verify_mpu401(const struct snd_mpu401 * mpu)
+static inline int verify_mpu401(const struct snd_mpu401 *mpu)
 {
         return ((inb(MPU401C(mpu)) & 0xc0) == 0x80);
 }
@@ -328,7 +322,7 @@ static inline int verify_mpu401(const struct snd_mpu401 * mpu)
 /*
  * This is apparently the standard way to initailise an MPU-401
  */
-static inline void initialise_mpu401(const struct snd_mpu401 * mpu)
+static inline void initialise_mpu401(const struct snd_mpu401 *mpu)
 {
         outb(0, MPU401D(mpu));
 }
@@ -338,9 +332,10 @@ static inline void initialise_mpu401(const struct snd_mpu401 * mpu)
  * The AD1845 detection fails if we *don't* do this, so I
  * think that this is a good idea ...
  */
-static inline void activate_ad1845_unsafe(unsigned io_base)
+static void activate_ad1845_unsafe(unsigned io_base)
 {
-        sscape_write_unsafe(io_base, GA_HMCTL_REG, (sscape_read_unsafe(io_base, GA_HMCTL_REG) & 0xcf) | 0x10);
+        unsigned char val = sscape_read_unsafe(io_base, GA_HMCTL_REG);
+        sscape_write_unsafe(io_base, GA_HMCTL_REG, (val & 0xcf) | 0x10);
         sscape_write_unsafe(io_base, GA_CDCFG_REG, 0x80);
 }
 
@@ -359,24 +354,27 @@ static void soundscape_free(struct snd_card *c)
  * Tell the SoundScape to begin a DMA tranfer using the given channel.
  * All locking issues are left to the caller.
  */
-static inline void sscape_start_dma_unsafe(unsigned io_base, enum GA_REG reg)
+static void sscape_start_dma_unsafe(unsigned io_base, enum GA_REG reg)
 {
-        sscape_write_unsafe(io_base, reg, sscape_read_unsafe(io_base, reg) | 0x01);
-        sscape_write_unsafe(io_base, reg, sscape_read_unsafe(io_base, reg) & 0xfe);
+        sscape_write_unsafe(io_base, reg,
+                            sscape_read_unsafe(io_base, reg) | 0x01);
+        sscape_write_unsafe(io_base, reg,
+                            sscape_read_unsafe(io_base, reg) & 0xfe);
 }
 
 /*
  * Wait for a DMA transfer to complete. This is a "limited busy-wait",
  * and all locking issues are left to the caller.
  */
-static int sscape_wait_dma_unsafe(unsigned io_base, enum GA_REG reg, unsigned timeout)
+static int sscape_wait_dma_unsafe(unsigned io_base, enum GA_REG reg,
+                                  unsigned timeout)
 {
         while (!(sscape_read_unsafe(io_base, reg) & 0x01) && (timeout != 0)) {
                 udelay(100);
                 --timeout;
         } /* while */
 
-        return (sscape_read_unsafe(io_base, reg) & 0x01);
+        return sscape_read_unsafe(io_base, reg) & 0x01;
 }
 
 /*
@@ -392,12 +390,12 @@ static int obp_startup_ack(struct soundscape *s, unsigned timeout)
 
         do {
                 unsigned long flags;
-                unsigned char x;
+                int x;
 
                 spin_lock_irqsave(&s->lock, flags);
-                x = inb(HOST_DATA_IO(s->io_base));
+                x = host_read_unsafe(s->io_base);
                 spin_unlock_irqrestore(&s->lock, flags);
-                if ((x & 0xfe) == 0xfe)
+                if (x == 0xfe || x == 0xff)
                         return 1;
 
                 msleep(10);
@@ -419,10 +417,10 @@ static int host_startup_ack(struct soundscape *s, unsigned timeout)
 
         do {
                 unsigned long flags;
-                unsigned char x;
+                int x;
 
                 spin_lock_irqsave(&s->lock, flags);
-                x = inb(HOST_DATA_IO(s->io_base));
+                x = host_read_unsafe(s->io_base);
                 spin_unlock_irqrestore(&s->lock, flags);
                 if (x == 0xfe)
                         return 1;
@@ -436,15 +434,15 @@ static int host_startup_ack(struct soundscape *s, unsigned timeout)
 /*
  * Upload a byte-stream into the SoundScape using DMA channel A.
  */
-static int upload_dma_data(struct soundscape *s,
-                           const unsigned char __user *data,
-                           size_t size)
+static int upload_dma_data(struct soundscape *s, const unsigned char *data,
+                           size_t size)
 {
         unsigned long flags;
         struct snd_dma_buffer dma;
         int ret;
+        unsigned char val;
 
-        if (!get_dmabuf(&dma, PAGE_ALIGN(size)))
+        if (!get_dmabuf(&dma, PAGE_ALIGN(32 * 1024)))
                 return -ENOMEM;
 
         spin_lock_irqsave(&s->lock, flags);
@@ -452,70 +450,57 @@ static int upload_dma_data(struct soundscape *s,
         /*
          * Reset the board ...
          */
-        sscape_write_unsafe(s->io_base, GA_HMCTL_REG, sscape_read_unsafe(s->io_base, GA_HMCTL_REG) & 0x3f);
+        val = sscape_read_unsafe(s->io_base, GA_HMCTL_REG);
+        sscape_write_unsafe(s->io_base, GA_HMCTL_REG, val & 0x3f);
 
         /*
          * Enable the DMA channels and configure them ...
          */
-        sscape_write_unsafe(s->io_base, GA_DMACFG_REG, 0x50);
-        sscape_write_unsafe(s->io_base, GA_DMAA_REG, (s->chip->dma1 << 4) | DMA_8BIT);
+        val = (s->chip->dma1 << 4) | DMA_8BIT;
+        sscape_write_unsafe(s->io_base, GA_DMAA_REG, val);
         sscape_write_unsafe(s->io_base, GA_DMAB_REG, 0x20);
 
         /*
          * Take the board out of reset ...
          */
-        sscape_write_unsafe(s->io_base, GA_HMCTL_REG, sscape_read_unsafe(s->io_base, GA_HMCTL_REG) | 0x80);
+        val = sscape_read_unsafe(s->io_base, GA_HMCTL_REG);
+        sscape_write_unsafe(s->io_base, GA_HMCTL_REG, val | 0x80);
 
         /*
-         * Upload the user's data (firmware?) to the SoundScape
+         * Upload the firmware to the SoundScape
          * board through the DMA channel ...
          */
         while (size != 0) {
                 unsigned long len;
 
-                /*
-                 * Apparently, copying to/from userspace can sleep.
-                 * We are therefore forbidden from holding any
-                 * spinlocks while we copy ...
-                 */
-                spin_unlock_irqrestore(&s->lock, flags);
-
-                /*
-                 * Remember that the data that we want to DMA
-                 * comes from USERSPACE. We have already verified
-                 * the userspace pointer ...
-                 */
                 len = min(size, dma.bytes);
-                len -= __copy_from_user(dma.area, data, len);
+                memcpy(dma.area, data, len);
                 data += len;
                 size -= len;
 
-                /*
-                 * Grab that spinlock again, now that we've
-                 * finished copying!
-                 */
-                spin_lock_irqsave(&s->lock, flags);
-
                 snd_dma_program(s->chip->dma1, dma.addr, len, DMA_MODE_WRITE);
                 sscape_start_dma_unsafe(s->io_base, GA_DMAA_REG);
                 if (!sscape_wait_dma_unsafe(s->io_base, GA_DMAA_REG, 5000)) {
                         /*
-                         * Don't forget to release this spinlock we're holding ...
+                         * Don't forget to release this spinlock we're holding
                          */
                         spin_unlock_irqrestore(&s->lock, flags);
 
-                        snd_printk(KERN_ERR "sscape: DMA upload has timed out\n");
+                        snd_printk(KERN_ERR
+                                        "sscape: DMA upload has timed out\n");
                         ret = -EAGAIN;
                         goto _release_dma;
                 }
         } /* while */
 
         set_host_mode_unsafe(s->io_base);
+        outb(0x0, s->io_base);
 
         /*
          * Boot the board ... (I think)
          */
-        sscape_write_unsafe(s->io_base, GA_HMCTL_REG, sscape_read_unsafe(s->io_base, GA_HMCTL_REG) | 0x40);
+        val = sscape_read_unsafe(s->io_base, GA_HMCTL_REG);
+        sscape_write_unsafe(s->io_base, GA_HMCTL_REG, val | 0x40);
         spin_unlock_irqrestore(&s->lock, flags);
 
         /*
@@ -525,10 +510,12 @@ static int upload_dma_data(struct soundscape *s,
          */
         ret = 0;
         if (!obp_startup_ack(s, 5000)) {
-                snd_printk(KERN_ERR "sscape: No response from on-board processor after upload\n");
+                snd_printk(KERN_ERR "sscape: No response "
+                                    "from on-board processor after upload\n");
                 ret = -EAGAIN;
         } else if (!host_startup_ack(s, 5000)) {
-                snd_printk(KERN_ERR "sscape: SoundScape failed to initialise\n");
+                snd_printk(KERN_ERR
+                                "sscape: SoundScape failed to initialise\n");
                 ret = -EAGAIN;
         }
 
@@ -536,7 +523,7 @@ _release_dma:
         /*
          * NOTE!!! We are NOT holding any spinlocks at this point !!!
          */
-        sscape_write(s, GA_DMAA_REG, (s->ic_type == IC_ODIE ? 0x70 : 0x40));
+        sscape_write(s, GA_DMAA_REG, (s->ic_type == IC_OPUS ? 0x40 : 0x70));
         free_dmabuf(&dma);
 
         return ret;
@@ -546,167 +533,76 @@ _release_dma:
  * Upload the bootblock(?) into the SoundScape. The only
  * purpose of this block of code seems to be to tell
  * us which version of the microcode we should be using.
- *
- * NOTE: The boot-block data resides in USER-SPACE!!!
- *       However, we have already verified its memory
- *       addresses by the time we get here.
  */
-static int sscape_upload_bootblock(struct soundscape *sscape, struct sscape_bootblock __user *bb)
+static int sscape_upload_bootblock(struct snd_card *card)
 {
+        struct soundscape *sscape = get_card_soundscape(card);
         unsigned long flags;
+        const struct firmware *init_fw = NULL;
         int data = 0;
         int ret;
 
-        ret = upload_dma_data(sscape, bb->code, sizeof(bb->code));
-
-        spin_lock_irqsave(&sscape->lock, flags);
-        if (ret == 0) {
-                data = host_read_ctrl_unsafe(sscape->io_base, 100);
-        }
-        set_midi_mode_unsafe(sscape->io_base);
-        spin_unlock_irqrestore(&sscape->lock, flags);
-
-        if (ret == 0) {
-                if (data < 0) {
-                        snd_printk(KERN_ERR "sscape: timeout reading firmware version\n");
-                        ret = -EAGAIN;
-                }
-                else if (__copy_to_user(&bb->version, &data, sizeof(bb->version))) {
-                        ret = -EFAULT;
-                }
+        ret = request_firmware(&init_fw, "scope.cod", card->dev);
+        if (ret < 0) {
+                snd_printk(KERN_ERR "sscape: Error loading scope.cod");
+                return ret;
         }
+        ret = upload_dma_data(sscape, init_fw->data, init_fw->size);
 
-        return ret;
-}
-
-/*
- * Upload the microcode into the SoundScape. The
- * microcode is 64K of data, and if we try to copy
- * it into a local variable then we will SMASH THE
- * KERNEL'S STACK! We therefore leave it in USER
- * SPACE, and save ourselves from copying it at all.
- */
-static int sscape_upload_microcode(struct soundscape *sscape,
-                                   const struct sscape_microcode __user *mc)
-{
-        unsigned long flags;
-        char __user *code;
-        int err;
+        release_firmware(init_fw);
 
-        /*
-         * We are going to have to copy this data into a special
-         * DMA-able buffer before we can upload it. We shall therefore
-         * just check that the data pointer is valid for now.
-         *
-         * NOTE: This buffer is 64K long! That's WAY too big to
-         *       copy into a stack-temporary anyway.
-         */
-        if ( get_user(code, &mc->code) ||
-             !access_ok(VERIFY_READ, code, SSCAPE_MICROCODE_SIZE) )
-                return -EFAULT;
+        spin_lock_irqsave(&sscape->lock, flags);
+        if (ret == 0)
+                data = host_read_ctrl_unsafe(sscape->io_base, 100);
 
-        if ((err = upload_dma_data(sscape, code, SSCAPE_MICROCODE_SIZE)) == 0) {
-                snd_printk(KERN_INFO "sscape: MIDI firmware loaded\n");
-        }
+        if (data & 0x10)
+                sscape_write_unsafe(sscape->io_base, GA_SMCFGA_REG, 0x2f);
 
-        spin_lock_irqsave(&sscape->lock, flags);
-        set_midi_mode_unsafe(sscape->io_base);
         spin_unlock_irqrestore(&sscape->lock, flags);
 
-        initialise_mpu401(sscape->mpu);
+        data &= 0xf;
+        if (ret == 0 && data > 7) {
+                snd_printk(KERN_ERR
+                                "sscape: timeout reading firmware version\n");
+                ret = -EAGAIN;
+        }
 
-        return err;
+        return (ret == 0) ? data : ret;
 }
 
 /*
- * Hardware-specific device functions, to implement special
- * IOCTLs for the SoundScape card. This is how we upload
- * the microcode into the card, for example, and so we
- * must ensure that no two processes can open this device
- * simultaneously, and that we can't open it at all if
- * someone is using the MIDI device.
+ * Upload the microcode into the SoundScape.
  */
-static int sscape_hw_open(struct snd_hwdep * hw, struct file *file)
+static int sscape_upload_microcode(struct snd_card *card, int version)
 {
-        register struct soundscape *sscape = get_hwdep_soundscape(hw);
-        unsigned long flags;
+        struct soundscape *sscape = get_card_soundscape(card);
+        const struct firmware *init_fw = NULL;
+        char name[14];
         int err;
 
-        spin_lock_irqsave(&sscape->fwlock, flags);
+        snprintf(name, sizeof(name), "sndscape.co%d", version);
 
-        if ((sscape->midi_usage != 0) || sscape->hw_in_use) {
-                err = -EBUSY;
-        } else {
-                sscape->hw_in_use = 1;
-                err = 0;
+        err = request_firmware(&init_fw, name, card->dev);
+        if (err < 0) {
+                snd_printk(KERN_ERR "sscape: Error loading sndscape.co%d",
+                                version);
+                return err;
         }
+        err = upload_dma_data(sscape, init_fw->data, init_fw->size);
+        if (err == 0)
+                snd_printk(KERN_INFO "sscape: MIDI firmware loaded %d KBs\n",
+                                init_fw->size >> 10);
 
-        spin_unlock_irqrestore(&sscape->fwlock, flags);
-        return err;
-}
-
-static int sscape_hw_release(struct snd_hwdep * hw, struct file *file)
-{
-        register struct soundscape *sscape = get_hwdep_soundscape(hw);
-        unsigned long flags;
-
-        spin_lock_irqsave(&sscape->fwlock, flags);
-        sscape->hw_in_use = 0;
-        spin_unlock_irqrestore(&sscape->fwlock, flags);
-        return 0;
-}
-
-static int sscape_hw_ioctl(struct snd_hwdep * hw, struct file *file,
-                           unsigned int cmd, unsigned long arg)
-{
-        struct soundscape *sscape = get_hwdep_soundscape(hw);
-        int err = -EBUSY;
-
-        switch (cmd) {
-        case SND_SSCAPE_LOAD_BOOTB:
-                {
-                        register struct sscape_bootblock __user *bb = (struct sscape_bootblock __user *) arg;
-
-                        /*
-                         * We are going to have to copy this data into a special
-                         * DMA-able buffer before we can upload it. We shall therefore
-                         * just check that the data pointer is valid for now ...
-                         */
-                        if ( !access_ok(VERIFY_READ, bb->code, sizeof(bb->code)) )
-                                return -EFAULT;
-
-                        /*
-                         * Now check that we can write the firmware version number too...
-                         */
-                        if ( !access_ok(VERIFY_WRITE, &bb->version, sizeof(bb->version)) )
-                                return -EFAULT;
-
-                        err = sscape_upload_bootblock(sscape, bb);
-                }
-                break;
-
-        case SND_SSCAPE_LOAD_MCODE:
-                {
-                        register const struct sscape_microcode __user *mc = (const struct sscape_microcode __user *) arg;
-
-                        err = sscape_upload_microcode(sscape, mc);
-                }
-                break;
-
-        default:
-                err = -EINVAL;
-                break;
-        } /* switch */
+        release_firmware(init_fw);
 
         return err;
 }
 
-
 /*
  * Mixer control for the SoundScape's MIDI device.
  */
 static int sscape_midi_info(struct snd_kcontrol *ctl,
-                            struct snd_ctl_elem_info *uinfo)
+                            struct snd_ctl_elem_info *uinfo)
 {
         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
         uinfo->count = 1;
@@ -716,7 +612,7 @@ static int sscape_midi_info(struct snd_kcontrol *ctl,
 }
 
 static int sscape_midi_get(struct snd_kcontrol *kctl,
-                           struct snd_ctl_elem_value *uctl)
+                           struct snd_ctl_elem_value *uctl)
 {
         struct snd_wss *chip = snd_kcontrol_chip(kctl);
         struct snd_card *card = chip->card;
@@ -730,16 +626,18 @@ static int sscape_midi_get(struct snd_kcontrol *kctl,
 }
 
 static int sscape_midi_put(struct snd_kcontrol *kctl,
-                           struct snd_ctl_elem_value *uctl)
+                           struct snd_ctl_elem_value *uctl)
 {
         struct snd_wss *chip = snd_kcontrol_chip(kctl);
         struct snd_card *card = chip->card;
-        register struct soundscape *s = get_card_soundscape(card);
+        struct soundscape *s = get_card_soundscape(card);
         unsigned long flags;
         int change;
+        unsigned char new_val;
 
         spin_lock_irqsave(&s->lock, flags);
 
+        new_val = uctl->value.integer.value[0] & 127;
         /*
          * We need to put the board into HOST mode before we
          * can send any volume-changing HOST commands ...
@@ -752,15 +650,16 @@ static int sscape_midi_put(struct snd_kcontrol *kctl,
          * and then perform another volume-related command. Perhaps the
          * first command is an "open" and the second command is a "close"?
          */
-        if (s->midi_vol == ((unsigned char) uctl->value.integer. value[0] & 127)) {
+        if (s->midi_vol == new_val) {
                 change = 0;
                 goto __skip_change;
         }
-        change = (host_write_ctrl_unsafe(s->io_base, CMD_SET_MIDI_VOL, 100)
-                  && host_write_ctrl_unsafe(s->io_base, ((unsigned char) uctl->value.integer. value[0]) & 127, 100)
-                  && host_write_ctrl_unsafe(s->io_base, CMD_XXX_MIDI_VOL, 100));
-        s->midi_vol = (unsigned char) uctl->value.integer.value[0] & 127;
-      __skip_change:
+        change = host_write_ctrl_unsafe(s->io_base, CMD_SET_MIDI_VOL, 100)
+                 && host_write_ctrl_unsafe(s->io_base, new_val, 100)
+                 && host_write_ctrl_unsafe(s->io_base, CMD_XXX_MIDI_VOL, 100)
+                 && host_write_ctrl_unsafe(s->io_base, new_val, 100);
+        s->midi_vol = new_val;
+__skip_change:
 
         /*
          * Take the board out of HOST mode and back into MIDI mode ...
@@ -784,20 +683,25 @@ static struct snd_kcontrol_new midi_mixer_ctl = {
  * These IRQs are encoded as bit patterns so that they can be
  * written to the control registers.
  */
-static unsigned __devinit get_irq_config(int irq)
+static unsigned __devinit get_irq_config(int sscape_type, int irq)
 {
         static const int valid_irq[] = { 9, 5, 7, 10 };
+        static const int old_irq[] = { 9, 7, 5, 15 };
         unsigned cfg;
 
-        for (cfg = 0; cfg < ARRAY_SIZE(valid_irq); ++cfg) {
-                if (irq == valid_irq[cfg])
-                        return cfg;
-        } /* for */
+        if (sscape_type == MEDIA_FX) {
+                for (cfg = 0; cfg < ARRAY_SIZE(old_irq); ++cfg)
+                        if (irq == old_irq[cfg])
+                                return cfg;
+        } else {
+                for (cfg = 0; cfg < ARRAY_SIZE(valid_irq); ++cfg)
+                        if (irq == valid_irq[cfg])
+                                return cfg;
+        }
 
         return INVALID_IRQ;
 }
 
-
 /*
  * Perform certain arcane port-checks to see whether there
  * is a SoundScape board lurking behind the given ports.
@@ -842,11 +746,38 @@ static int __devinit detect_sscape(struct soundscape *s, long wss_io)
         if (s->type != SSCAPE_VIVO && (d & 0x9f) != 0x0e)
                 goto _done;
 
-        d  = sscape_read_unsafe(s->io_base, GA_HMCTL_REG) & 0x3f;
-        sscape_write_unsafe(s->io_base, GA_HMCTL_REG, d | 0xc0);
+        if (s->ic_type == IC_OPUS)
+                activate_ad1845_unsafe(s->io_base);
 
         if (s->type == SSCAPE_VIVO)
                 wss_io += 4;
+
+        d  = sscape_read_unsafe(s->io_base, GA_HMCTL_REG);
+        sscape_write_unsafe(s->io_base, GA_HMCTL_REG, d | 0xc0);
+
+        /* wait for WSS codec */
+        for (d = 0; d < 500; d++) {
+                if ((inb(wss_io) & 0x80) == 0)
+                        break;
+                spin_unlock_irqrestore(&s->lock, flags);
+                msleep(1);
+                spin_lock_irqsave(&s->lock, flags);
+        }
+
+        if ((inb(wss_io) & 0x80) != 0)
+                goto _done;
+
+        if (inb(wss_io + 2) == 0xff)
+                goto _done;
+
+        d  = sscape_read_unsafe(s->io_base, GA_HMCTL_REG) & 0x3f;
+        sscape_write_unsafe(s->io_base, GA_HMCTL_REG, d);
+
+        if ((inb(wss_io) & 0x80) != 0)
+                s->type = MEDIA_FX;
+
+        d = sscape_read_unsafe(s->io_base, GA_HMCTL_REG);
+        sscape_write_unsafe(s->io_base, GA_HMCTL_REG, d | 0xc0);
         /* wait for WSS codec */
         for (d = 0; d < 500; d++) {
                 if ((inb(wss_io) & 0x80) == 0)
@@ -855,14 +786,13 @@ static int __devinit detect_sscape(struct soundscape *s, long wss_io)
                 msleep(1);
                 spin_lock_irqsave(&s->lock, flags);
         }
-        snd_printd(KERN_INFO "init delay = %d ms\n", d);
 
         /*
          * SoundScape successfully detected!
          */
         retval = 1;
 
-        _done:
+_done:
         spin_unlock_irqrestore(&s->lock, flags);
         return retval;
 }
@@ -873,63 +803,35 @@ static int __devinit detect_sscape(struct soundscape *s, long wss_io)
  * to crash the machine. Also check that someone isn't using the hardware
  * IOCTL device.
  */
-static int mpu401_open(struct snd_mpu401 * mpu)
+static int mpu401_open(struct snd_mpu401 *mpu)
 {
-        int err;
-
         if (!verify_mpu401(mpu)) {
-                snd_printk(KERN_ERR "sscape: MIDI disabled, please load firmware\n");
-                err = -ENODEV;
-        } else {
-                register struct soundscape *sscape = get_mpu401_soundscape(mpu);
-                unsigned long flags;
-
-                spin_lock_irqsave(&sscape->fwlock, flags);
-
-                if (sscape->hw_in_use || (sscape->midi_usage == ULONG_MAX)) {
-                        err = -EBUSY;
-                } else {
-                        ++(sscape->midi_usage);
-                        err = 0;
-                }
-
-                spin_unlock_irqrestore(&sscape->fwlock, flags);
+                snd_printk(KERN_ERR "sscape: MIDI disabled, "
+                                    "please load firmware\n");
+                return -ENODEV;
         }
 
-        return err;
-}
-
-static void mpu401_close(struct snd_mpu401 * mpu)
-{
-        register struct soundscape *sscape = get_mpu401_soundscape(mpu);
-        unsigned long flags;
-
-        spin_lock_irqsave(&sscape->fwlock, flags);
-        --(sscape->midi_usage);
-        spin_unlock_irqrestore(&sscape->fwlock, flags);
+        return 0;
 }
 
 /*
  * Initialse an MPU-401 subdevice for MIDI support on the SoundScape.
  */
-static int __devinit create_mpu401(struct snd_card *card, int devnum, unsigned long port, int irq)
+static int __devinit create_mpu401(struct snd_card *card, int devnum,
+                                   unsigned long port, int irq)
 {
         struct soundscape *sscape = get_card_soundscape(card);
         struct snd_rawmidi *rawmidi;
         int err;
 
-        if ((err = snd_mpu401_uart_new(card, devnum,
-                                       MPU401_HW_MPU401,
-                                       port, MPU401_INFO_INTEGRATED,
-                                       irq, IRQF_DISABLED,
-                                       &rawmidi)) == 0) {
-                struct snd_mpu401 *mpu = (struct snd_mpu401 *) rawmidi->private_data;
+        err = snd_mpu401_uart_new(card, devnum, MPU401_HW_MPU401, port,
+                                  MPU401_INFO_INTEGRATED, irq, IRQF_DISABLED,
+                                  &rawmidi);
+        if (err == 0) {
+                struct snd_mpu401 *mpu = rawmidi->private_data;
                 mpu->open_input = mpu401_open;
                 mpu->open_output = mpu401_open;
-                mpu->close_input = mpu401_close;
-                mpu->close_output = mpu401_close;
                 mpu->private_data = sscape;
-                sscape->mpu = mpu;
 
                 initialise_mpu401(mpu);
         }
@@ -950,32 +852,34 @@ static int __devinit create_ad1845(struct snd_card *card, unsigned port,
         register struct soundscape *sscape = get_card_soundscape(card);
         struct snd_wss *chip;
         int err;
+        int codec_type = WSS_HW_DETECT;
 
-        if (sscape->type == SSCAPE_VIVO)
-                port += 4;
+        switch (sscape->type) {
+        case MEDIA_FX:
+        case SSCAPE:
+                /*
+                 * There are some freak examples of early Soundscape cards
+                 * with CS4231 instead of AD1848/CS4248. Unfortunately, the
+                 * CS4231 works only in CS4248 compatibility mode on
+                 * these cards so force it.
+                 */
+                if (sscape->ic_type != IC_OPUS)
+                        codec_type = WSS_HW_AD1848;
+                break;
 
-        if (dma1 == dma2)
-                dma2 = -1;
+        case SSCAPE_VIVO:
+                port += 4;
+                break;
+        default:
+                break;
+        }
 
         err = snd_wss_create(card, port, -1, irq, dma1, dma2,
-                             WSS_HW_DETECT, WSS_HWSHARE_DMA1, &chip);
+                             codec_type, WSS_HWSHARE_DMA1, &chip);
         if (!err) {
                 unsigned long flags;
                 struct snd_pcm *pcm;
 
-/*
- * It turns out that the PLAYBACK_ENABLE bit is set
- * by the lowlevel driver ...
- *
-#define AD1845_IFACE_CONFIG  \
-           (CS4231_AUTOCALIB | CS4231_RECORD_ENABLE | CS4231_PLAYBACK_ENABLE)
-    snd_wss_mce_up(chip);
-    spin_lock_irqsave(&chip->reg_lock, flags);
-    snd_wss_out(chip, CS4231_IFACE_CTRL, AD1845_IFACE_CONFIG);
-    spin_unlock_irqrestore(&chip->reg_lock, flags);
-    snd_wss_mce_down(chip);
- */
-
                 if (sscape->type != SSCAPE_VIVO) {
                         /*
                          * The input clock frequency on the SoundScape must
@@ -1022,17 +926,10 @@ static int __devinit create_ad1845(struct snd_card *card, unsigned port,
                         }
                 }
 
-                strcpy(card->driver, "SoundScape");
-                strcpy(card->shortname, pcm->name);
-                snprintf(card->longname, sizeof(card->longname),
-                         "%s at 0x%lx, IRQ %d, DMA1 %d, DMA2 %d\n",
-                         pcm->name, chip->port, chip->irq,
-                         chip->dma1, chip->dma2);
-
                 sscape->chip = chip;
         }
 
-        _error:
+_error:
         return err;
 }
 
@@ -1051,21 +948,8 @@ static int __devinit create_sscape(int dev, struct snd_card *card)
         struct resource *wss_res;
         unsigned long flags;
         int err;
-
-        /*
-         * Check that the user didn't pass us garbage data ...
-         */
-        irq_cfg = get_irq_config(irq[dev]);
-        if (irq_cfg == INVALID_IRQ) {
-                snd_printk(KERN_ERR "sscape: Invalid IRQ %d\n", irq[dev]);
-                return -ENXIO;
-        }
-
-        mpu_irq_cfg = get_irq_config(mpu_irq[dev]);
-        if (mpu_irq_cfg == INVALID_IRQ) {
-                printk(KERN_ERR "sscape: Invalid IRQ %d\n", mpu_irq[dev]);
-                return -ENXIO;
-        }
+        int val;
+        const char *name;
 
         /*
          * Grab IO ports that we will need to probe so that we
@@ -1098,41 +982,51 @@ static int __devinit create_sscape(int dev, struct snd_card *card)
         }
 
         spin_lock_init(&sscape->lock);
-        spin_lock_init(&sscape->fwlock);
         sscape->io_res = io_res;
         sscape->wss_res = wss_res;
         sscape->io_base = port[dev];
 
         if (!detect_sscape(sscape, wss_port[dev])) {
-                printk(KERN_ERR "sscape: hardware not detected at 0x%x\n", sscape->io_base);
+                printk(KERN_ERR "sscape: hardware not detected at 0x%x\n",
+                        sscape->io_base);
                 err = -ENODEV;
                 goto _release_dma;
         }
 
-        printk(KERN_INFO "sscape: hardware detected at 0x%x, using IRQ %d, DMA %d\n",
-                         sscape->io_base, irq[dev], dma[dev]);
+        switch (sscape->type) {
+        case MEDIA_FX:
+                name = "MediaFX/SoundFX";
+                break;
+        case SSCAPE:
+                name = "Soundscape";
+                break;
+        case SSCAPE_PNP:
+                name = "Soundscape PnP";
+                break;
+        case SSCAPE_VIVO:
+                name = "Soundscape VIVO";
+                break;
+        default:
+                name = "unknown Soundscape";
+                break;
+        }
 
-        if (sscape->type != SSCAPE_VIVO) {
-                /*
-                 * Now create the hardware-specific device so that we can
-                 * load the microcode into the on-board processor.
-                 * We cannot use the MPU-401 MIDI system until this firmware
-                 * has been loaded into the card.
-                 */
-                err = snd_hwdep_new(card, "MC68EC000", 0, &(sscape->hw));
-                if (err < 0) {
-                        printk(KERN_ERR "sscape: Failed to create "
-                                        "firmware device\n");
-                        goto _release_dma;
-                }
-                strlcpy(sscape->hw->name, "SoundScape M68K",
-                        sizeof(sscape->hw->name));
-                sscape->hw->name[sizeof(sscape->hw->name) - 1] = '\0';
-                sscape->hw->iface = SNDRV_HWDEP_IFACE_SSCAPE;
-                sscape->hw->ops.open = sscape_hw_open;
-                sscape->hw->ops.release = sscape_hw_release;
-                sscape->hw->ops.ioctl = sscape_hw_ioctl;
-                sscape->hw->private_data = sscape;
+        printk(KERN_INFO "sscape: %s card detected at 0x%x, using IRQ %d, DMA %d\n",
+                         name, sscape->io_base, irq[dev], dma[dev]);
+
+        /*
+         * Check that the user didn't pass us garbage data ...
+         */
+        irq_cfg = get_irq_config(sscape->type, irq[dev]);
+        if (irq_cfg == INVALID_IRQ) {
+                snd_printk(KERN_ERR "sscape: Invalid IRQ %d\n", irq[dev]);
+                return -ENXIO;
+        }
+
+        mpu_irq_cfg = get_irq_config(sscape->type, mpu_irq[dev]);
+        if (mpu_irq_cfg == INVALID_IRQ) {
+                snd_printk(KERN_ERR "sscape: Invalid IRQ %d\n", mpu_irq[dev]);
+                return -ENXIO;
         }
 
         /*
@@ -1141,9 +1035,6 @@ static int __devinit create_sscape(int dev, struct snd_card *card)
          */
         spin_lock_irqsave(&sscape->lock, flags);
 
-        activate_ad1845_unsafe(sscape->io_base);
-
-        sscape_write_unsafe(sscape->io_base, GA_INTENA_REG, 0x00); /* disable */
         sscape_write_unsafe(sscape->io_base, GA_SMCFGA_REG, 0x2e);
         sscape_write_unsafe(sscape->io_base, GA_SMCFGB_REG, 0x00);
 
@@ -1151,15 +1042,23 @@ static int __devinit create_sscape(int dev, struct snd_card *card)
          * Enable and configure the DMA channels ...
          */
         sscape_write_unsafe(sscape->io_base, GA_DMACFG_REG, 0x50);
-        dma_cfg = (sscape->ic_type == IC_ODIE ? 0x70 : 0x40);
+        dma_cfg = (sscape->ic_type == IC_OPUS ? 0x40 : 0x70);
         sscape_write_unsafe(sscape->io_base, GA_DMAA_REG, dma_cfg);
         sscape_write_unsafe(sscape->io_base, GA_DMAB_REG, 0x20);
 
-        sscape_write_unsafe(sscape->io_base,
-                            GA_INTCFG_REG, 0xf0 | (mpu_irq_cfg << 2) | mpu_irq_cfg);
+        mpu_irq_cfg |= mpu_irq_cfg << 2;
+        val = sscape_read_unsafe(sscape->io_base, GA_HMCTL_REG) & 0xF7;
+        if (joystick[dev])
+                val |= 8;
+        sscape_write_unsafe(sscape->io_base, GA_HMCTL_REG, val | 0x10);
+        sscape_write_unsafe(sscape->io_base, GA_INTCFG_REG, 0xf0 | mpu_irq_cfg);
         sscape_write_unsafe(sscape->io_base,
                             GA_CDCFG_REG, 0x09 | DMA_8BIT
                             | (dma[dev] << 4) | (irq_cfg << 1));
+        /*
+         * Enable the master IRQ ...
+         */
+        sscape_write_unsafe(sscape->io_base, GA_INTENA_REG, 0x80);
 
         spin_unlock_irqrestore(&sscape->lock, flags);
 
@@ -1170,32 +1069,56 @@ static int __devinit create_sscape(int dev, struct snd_card *card)
         err = create_ad1845(card, wss_port[dev], irq[dev],
                             dma[dev], dma2[dev]);
         if (err < 0) {
-                printk(KERN_ERR "sscape: No AD1845 device at 0x%lx, IRQ %d\n",
-                       wss_port[dev], irq[dev]);
+                snd_printk(KERN_ERR
+                                "sscape: No AD1845 device at 0x%lx, IRQ %d\n",
+                                wss_port[dev], irq[dev]);
                 goto _release_dma;
         }
+        strcpy(card->driver, "SoundScape");
+        strcpy(card->shortname, name);
+        snprintf(card->longname, sizeof(card->longname),
+                 "%s at 0x%lx, IRQ %d, DMA1 %d, DMA2 %d\n",
+                 name, sscape->chip->port, sscape->chip->irq,
+                 sscape->chip->dma1, sscape->chip->dma2);
+
 #define MIDI_DEVNUM  0
         if (sscape->type != SSCAPE_VIVO) {
-                err = create_mpu401(card, MIDI_DEVNUM, port[dev], mpu_irq[dev]);
-                if (err < 0) {
-                        printk(KERN_ERR "sscape: Failed to create "
-                                        "MPU-401 device at 0x%lx\n",
-                                        port[dev]);
-                        goto _release_dma;
-                }
+                err = sscape_upload_bootblock(card);
+                if (err >= 0)
+                        err = sscape_upload_microcode(card, err);
 
-                /*
-                 * Enable the master IRQ ...
-                 */
-                sscape_write(sscape, GA_INTENA_REG, 0x80);
+                if (err == 0) {
+                        err = create_mpu401(card, MIDI_DEVNUM, port[dev],
+                                            mpu_irq[dev]);
+                        if (err < 0) {
+                                snd_printk(KERN_ERR "sscape: Failed to create "
+                                                "MPU-401 device at 0x%lx\n",
+                                                port[dev]);
+                                goto _release_dma;
+                        }
 
-                /*
-                 * Initialize mixer
-                 */
-                sscape->midi_vol = 0;
-                host_write_ctrl_unsafe(sscape->io_base, CMD_SET_MIDI_VOL, 100);
-                host_write_ctrl_unsafe(sscape->io_base, 0, 100);
-                host_write_ctrl_unsafe(sscape->io_base, CMD_XXX_MIDI_VOL, 100);
+                        /*
+                         * Initialize mixer
+                         */
+                        spin_lock_irqsave(&sscape->lock, flags);
+                        sscape->midi_vol = 0;
+                        host_write_ctrl_unsafe(sscape->io_base,
+                                                CMD_SET_MIDI_VOL, 100);
+                        host_write_ctrl_unsafe(sscape->io_base,
+                                                sscape->midi_vol, 100);
+                        host_write_ctrl_unsafe(sscape->io_base,
+                                                CMD_XXX_MIDI_VOL, 100);
+                        host_write_ctrl_unsafe(sscape->io_base,
+                                                sscape->midi_vol, 100);
+                        host_write_ctrl_unsafe(sscape->io_base,
+                                                CMD_SET_EXTMIDI, 100);
+                        host_write_ctrl_unsafe(sscape->io_base,
+                                                0, 100);
+                        host_write_ctrl_unsafe(sscape->io_base, CMD_ACK, 100);
+
+                        set_midi_mode_unsafe(sscape->io_base);
+                        spin_unlock_irqrestore(&sscape->lock, flags);
+                }
         }
 
         /*
@@ -1231,7 +1154,8 @@ static int __devinit snd_sscape_match(struct device *pdev, unsigned int i)
             mpu_irq[i] == SNDRV_AUTO_IRQ ||
             dma[i] == SNDRV_AUTO_DMA) {
                 printk(KERN_INFO
-                       "sscape: insufficient parameters, need IO, IRQ, MPU-IRQ and DMA\n");
+                       "sscape: insufficient parameters, "
+                       "need IO, IRQ, MPU-IRQ and DMA\n");
                 return 0;
         }
 
@@ -1253,13 +1177,15 @@ static int __devinit snd_sscape_probe(struct device *pdev, unsigned int dev)
         sscape->type = SSCAPE;
 
         dma[dev] &= 0x03;
+        snd_card_set_dev(card, pdev);
+
         ret = create_sscape(dev, card);
         if (ret < 0)
                 goto _release_card;
 
-        snd_card_set_dev(card, pdev);
-        if ((ret = snd_card_register(card)) < 0) {
-                printk(KERN_ERR "sscape: Failed to register sound card\n");
+        ret = snd_card_register(card);
+        if (ret < 0) {
+                snd_printk(KERN_ERR "sscape: Failed to register sound card\n");
                 goto _release_card;
         }
         dev_set_drvdata(pdev, card);
@@ -1311,36 +1237,20 @@ static int __devinit sscape_pnp_detect(struct pnp_card_link *pcard,
          * Allow this function to fail *quietly* if all the ISA PnP
          * devices were configured using module parameters instead.
          */
-        if ((idx = get_next_autoindex(idx)) >= SNDRV_CARDS)
+        idx = get_next_autoindex(idx);
+        if (idx >= SNDRV_CARDS)
                 return -ENOSPC;
 
         /*
-         * We have found a candidate ISA PnP card. Now we
-         * have to check that it has the devices that we
-         * expect it to have.
-         *
-         * We will NOT try and autoconfigure all of the resources
-         * needed and then activate the card as we are assuming that
-         * has already been done at boot-time using /proc/isapnp.
-         * We shall simply try to give each active card the resources
-         * that it wants. This is a sensible strategy for a modular
-         * system where unused modules are unloaded regularly.
-         *
-         * This strategy is utterly useless if we compile the driver
-         * into the kernel, of course.
-         */
-        // printk(KERN_INFO "sscape: %s\n", card->name);
-
-        /*
          * Check that we still have room for another sound card ...
          */
         dev = pnp_request_card_device(pcard, pid->devs[0].id, NULL);
-        if (! dev)
+        if (!dev)
                 return -ENODEV;
 
         if (!pnp_is_active(dev)) {
                 if (pnp_activate_dev(dev) < 0) {
-                        printk(KERN_INFO "sscape: device is inactive\n");
+                        snd_printk(KERN_INFO "sscape: device is inactive\n");
                         return -EBUSY;
                 }
         }
@@ -1378,14 +1288,15 @@ static int __devinit sscape_pnp_detect(struct pnp_card_link *pcard,
                 wss_port[idx] = pnp_port_start(dev, 1);
                 dma2[idx] = pnp_dma(dev, 1);
         }
+        snd_card_set_dev(card, &pcard->card->dev);
 
         ret = create_sscape(idx, card);
         if (ret < 0)
                 goto _release_card;
 
-        snd_card_set_dev(card, &pcard->card->dev);
-        if ((ret = snd_card_register(card)) < 0) {
-                printk(KERN_ERR "sscape: Failed to register sound card\n");
+        ret = snd_card_register(card);
+        if (ret < 0) {
+                snd_printk(KERN_ERR "sscape: Failed to register sound card\n");
                 goto _release_card;
         }
 
diff --git a/sound/isa/wavefront/wavefront.c b/sound/isa/wavefront/wavefront.c
index a34ae7b1f7d0..711670e4a425 100644
--- a/sound/isa/wavefront/wavefront.c
+++ b/sound/isa/wavefront/wavefront.c
@@ -21,7 +21,6 @@
 
 #include <linux/init.h>
 #include <linux/interrupt.h>
-#include <linux/slab.h>
 #include <linux/err.h>
 #include <linux/isa.h>
 #include <linux/pnp.h>
diff --git a/sound/isa/wavefront/wavefront_fx.c b/sound/isa/wavefront/wavefront_fx.c
index 2bb1cee09255..657e2d6c01ac 100644
--- a/sound/isa/wavefront/wavefront_fx.c
+++ b/sound/isa/wavefront/wavefront_fx.c
@@ -20,6 +20,7 @@
 #include <linux/init.h>
 #include <linux/time.h>
 #include <linux/wait.h>
+#include <linux/slab.h>
 #include <linux/firmware.h>
 #include <sound/core.h>
 #include <sound/snd_wavefront.h>
diff --git a/sound/isa/wavefront/wavefront_synth.c b/sound/isa/wavefront/wavefront_synth.c
index 5d4ff48c4345..4fb7b19ff393 100644
--- a/sound/isa/wavefront/wavefront_synth.c
+++ b/sound/isa/wavefront/wavefront_synth.c
@@ -28,6 +28,7 @@
 #include <linux/wait.h>
 #include <linux/firmware.h>
 #include <linux/moduleparam.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/snd_wavefront.h>
 #include <sound/initval.h>
diff --git a/sound/isa/wss/wss_lib.c b/sound/isa/wss/wss_lib.c
index 5d2ba1b749ab..9191b32d9130 100644
--- a/sound/isa/wss/wss_lib.c
+++ b/sound/isa/wss/wss_lib.c
@@ -1682,7 +1682,7 @@ static void snd_wss_resume(struct snd_wss *chip)
 }
 #endif /* CONFIG_PM */
 
-int snd_wss_free(struct snd_wss *chip)
+static int snd_wss_free(struct snd_wss *chip)
 {
         release_and_free_resource(chip->res_port);
         release_and_free_resource(chip->res_cport);
@@ -1705,7 +1705,6 @@ int snd_wss_free(struct snd_wss *chip)
         kfree(chip);
         return 0;
 }
-EXPORT_SYMBOL(snd_wss_free);
 
 static int snd_wss_dev_free(struct snd_device *device)
 {
@@ -2015,6 +2014,7 @@ static int snd_wss_info_mux(struct snd_kcontrol *kcontrol,
         case WSS_HW_INTERWAVE:
                 ptexts = gusmax_texts;
                 break;
+        case WSS_HW_OPTI93X:
         case WSS_HW_OPL3SA2:
                 ptexts = opl3sa_texts;
                 break;
@@ -2198,64 +2198,26 @@ EXPORT_SYMBOL(snd_wss_put_double);
 static const DECLARE_TLV_DB_SCALE(db_scale_6bit, -9450, 150, 0);
 static const DECLARE_TLV_DB_SCALE(db_scale_5bit_12db_max, -3450, 150, 0);
 static const DECLARE_TLV_DB_SCALE(db_scale_rec_gain, 0, 150, 0);
-
-static struct snd_kcontrol_new snd_ad1848_controls[] = {
-WSS_DOUBLE("PCM Playback Switch", 0, CS4231_LEFT_OUTPUT, CS4231_RIGHT_OUTPUT,
-           7, 7, 1, 1),
-WSS_DOUBLE_TLV("PCM Playback Volume", 0,
-               CS4231_LEFT_OUTPUT, CS4231_RIGHT_OUTPUT, 0, 0, 63, 1,
-               db_scale_6bit),
-WSS_DOUBLE("Aux Playback Switch", 0,
-           CS4231_AUX1_LEFT_INPUT, CS4231_AUX1_RIGHT_INPUT, 7, 7, 1, 1),
-WSS_DOUBLE_TLV("Aux Playback Volume", 0,
-               CS4231_AUX1_LEFT_INPUT, CS4231_AUX1_RIGHT_INPUT, 0, 0, 31, 1,
-               db_scale_5bit_12db_max),
-WSS_DOUBLE("Aux Playback Switch", 1,
-           CS4231_AUX2_LEFT_INPUT, CS4231_AUX2_RIGHT_INPUT, 7, 7, 1, 1),
-WSS_DOUBLE_TLV("Aux Playback Volume", 1,
-               CS4231_AUX2_LEFT_INPUT, CS4231_AUX2_RIGHT_INPUT, 0, 0, 31, 1,
-               db_scale_5bit_12db_max),
-WSS_DOUBLE_TLV("Capture Volume", 0, CS4231_LEFT_INPUT, CS4231_RIGHT_INPUT,
-                0, 0, 15, 0, db_scale_rec_gain),
-{
-        .name = "Capture Source",
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .info = snd_wss_info_mux,
-        .get = snd_wss_get_mux,
-        .put = snd_wss_put_mux,
-},
-WSS_SINGLE("Loopback Capture Switch", 0, CS4231_LOOPBACK, 0, 1, 0),
-WSS_SINGLE_TLV("Loopback Capture Volume", 0, CS4231_LOOPBACK, 1, 63, 0,
-               db_scale_6bit),
-};
+static const DECLARE_TLV_DB_SCALE(db_scale_4bit, -4500, 300, 0);
 
 static struct snd_kcontrol_new snd_wss_controls[] = {
 WSS_DOUBLE("PCM Playback Switch", 0,
                 CS4231_LEFT_OUTPUT, CS4231_RIGHT_OUTPUT, 7, 7, 1, 1),
-WSS_DOUBLE("PCM Playback Volume", 0,
-                CS4231_LEFT_OUTPUT, CS4231_RIGHT_OUTPUT, 0, 0, 63, 1),
-WSS_DOUBLE("Line Playback Switch", 0,
-                CS4231_LEFT_LINE_IN, CS4231_RIGHT_LINE_IN, 7, 7, 1, 1),
-WSS_DOUBLE("Line Playback Volume", 0,
-                CS4231_LEFT_LINE_IN, CS4231_RIGHT_LINE_IN, 0, 0, 31, 1),
+WSS_DOUBLE_TLV("PCM Playback Volume", 0,
+                CS4231_LEFT_OUTPUT, CS4231_RIGHT_OUTPUT, 0, 0, 63, 1,
+                db_scale_6bit),
 WSS_DOUBLE("Aux Playback Switch", 0,
                 CS4231_AUX1_LEFT_INPUT, CS4231_AUX1_RIGHT_INPUT, 7, 7, 1, 1),
-WSS_DOUBLE("Aux Playback Volume", 0,
-                CS4231_AUX1_LEFT_INPUT, CS4231_AUX1_RIGHT_INPUT, 0, 0, 31, 1),
+WSS_DOUBLE_TLV("Aux Playback Volume", 0,
+                CS4231_AUX1_LEFT_INPUT, CS4231_AUX1_RIGHT_INPUT, 0, 0, 31, 1,
+                db_scale_5bit_12db_max),
 WSS_DOUBLE("Aux Playback Switch", 1,
                 CS4231_AUX2_LEFT_INPUT, CS4231_AUX2_RIGHT_INPUT, 7, 7, 1, 1),
-WSS_DOUBLE("Aux Playback Volume", 1,
-                CS4231_AUX2_LEFT_INPUT, CS4231_AUX2_RIGHT_INPUT, 0, 0, 31, 1),
-WSS_SINGLE("Mono Playback Switch", 0,
-                CS4231_MONO_CTRL, 7, 1, 1),
-WSS_SINGLE("Mono Playback Volume", 0,
-                CS4231_MONO_CTRL, 0, 15, 1),
-WSS_SINGLE("Mono Output Playback Switch", 0,
-                CS4231_MONO_CTRL, 6, 1, 1),
-WSS_SINGLE("Mono Output Playback Bypass", 0,
-                CS4231_MONO_CTRL, 5, 1, 0),
-WSS_DOUBLE("Capture Volume", 0,
-                CS4231_LEFT_INPUT, CS4231_RIGHT_INPUT, 0, 0, 15, 0),
+WSS_DOUBLE_TLV("Aux Playback Volume", 1,
+                CS4231_AUX2_LEFT_INPUT, CS4231_AUX2_RIGHT_INPUT, 0, 0, 31, 1,
+                db_scale_5bit_12db_max),
+WSS_DOUBLE_TLV("Capture Volume", 0, CS4231_LEFT_INPUT, CS4231_RIGHT_INPUT,
+                0, 0, 15, 0, db_scale_rec_gain),
 {
         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
         .name = "Capture Source",
@@ -2263,54 +2225,26 @@ WSS_DOUBLE("Capture Volume", 0,
         .get = snd_wss_get_mux,
         .put = snd_wss_put_mux,
 },
-WSS_DOUBLE("Mic Boost", 0,
+WSS_DOUBLE("Mic Boost (+20dB)", 0,
                 CS4231_LEFT_INPUT, CS4231_RIGHT_INPUT, 5, 5, 1, 0),
 WSS_SINGLE("Loopback Capture Switch", 0,
                 CS4231_LOOPBACK, 0, 1, 0),
-WSS_SINGLE("Loopback Capture Volume", 0,
-                CS4231_LOOPBACK, 2, 63, 1)
-};
-
-static struct snd_kcontrol_new snd_opti93x_controls[] = {
-WSS_DOUBLE("Master Playback Switch", 0,
-                OPTi93X_OUT_LEFT, OPTi93X_OUT_RIGHT, 7, 7, 1, 1),
-WSS_DOUBLE("Master Playback Volume", 0,
-                OPTi93X_OUT_LEFT, OPTi93X_OUT_RIGHT, 1, 1, 31, 1),
-WSS_DOUBLE("PCM Playback Switch", 0,
-                CS4231_LEFT_OUTPUT, CS4231_RIGHT_OUTPUT, 7, 7, 1, 1),
-WSS_DOUBLE("PCM Playback Volume", 0,
-                CS4231_LEFT_OUTPUT, CS4231_RIGHT_OUTPUT, 0, 0, 31, 1),
-WSS_DOUBLE("FM Playback Switch", 0,
-                CS4231_AUX2_LEFT_INPUT, CS4231_AUX2_RIGHT_INPUT, 7, 7, 1, 1),
-WSS_DOUBLE("FM Playback Volume", 0,
-                CS4231_AUX2_LEFT_INPUT, CS4231_AUX2_RIGHT_INPUT, 1, 1, 15, 1),
+WSS_SINGLE_TLV("Loopback Capture Volume", 0, CS4231_LOOPBACK, 2, 63, 1,
+                db_scale_6bit),
 WSS_DOUBLE("Line Playback Switch", 0,
                 CS4231_LEFT_LINE_IN, CS4231_RIGHT_LINE_IN, 7, 7, 1, 1),
-WSS_DOUBLE("Line Playback Volume", 0,
-                CS4231_LEFT_LINE_IN, CS4231_RIGHT_LINE_IN, 0, 0, 15, 1),
-WSS_DOUBLE("Mic Playback Switch", 0,
-                OPTi93X_MIC_LEFT_INPUT, OPTi93X_MIC_RIGHT_INPUT, 7, 7, 1, 1),
-WSS_DOUBLE("Mic Playback Volume", 0,
-                OPTi93X_MIC_LEFT_INPUT, OPTi93X_MIC_RIGHT_INPUT, 1, 1, 15, 1),
-WSS_DOUBLE("Mic Boost", 0,
-                CS4231_LEFT_INPUT, CS4231_RIGHT_INPUT, 5, 5, 1, 0),
-WSS_DOUBLE("CD Playback Switch", 0,
-                CS4231_AUX1_LEFT_INPUT, CS4231_AUX1_RIGHT_INPUT, 7, 7, 1, 1),
-WSS_DOUBLE("CD Playback Volume", 0,
-                CS4231_AUX1_LEFT_INPUT, CS4231_AUX1_RIGHT_INPUT, 1, 1, 15, 1),
-WSS_DOUBLE("Aux Playback Switch", 0,
-                OPTi931_AUX_LEFT_INPUT, OPTi931_AUX_RIGHT_INPUT, 7, 7, 1, 1),
-WSS_DOUBLE("Aux Playback Volume", 0,
-                OPTi931_AUX_LEFT_INPUT, OPTi931_AUX_RIGHT_INPUT, 1, 1, 15, 1),
-WSS_DOUBLE("Capture Volume", 0,
-                CS4231_LEFT_INPUT, CS4231_RIGHT_INPUT, 0, 0, 15, 0),
-{
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "Capture Source",
-        .info = snd_wss_info_mux,
-        .get = snd_wss_get_mux,
-        .put = snd_wss_put_mux,
-}
+WSS_DOUBLE_TLV("Line Playback Volume", 0,
+                CS4231_LEFT_LINE_IN, CS4231_RIGHT_LINE_IN, 0, 0, 31, 1,
+                db_scale_5bit_12db_max),
+WSS_SINGLE("Beep Playback Switch", 0,
+                CS4231_MONO_CTRL, 7, 1, 1),
+WSS_SINGLE_TLV("Beep Playback Volume", 0,
+                CS4231_MONO_CTRL, 0, 15, 1,
+                db_scale_4bit),
+WSS_SINGLE("Mono Output Playback Switch", 0,
+                CS4231_MONO_CTRL, 6, 1, 1),
+WSS_SINGLE("Beep Bypass Playback Switch", 0,
+                CS4231_MONO_CTRL, 5, 1, 0),
 };
 
 int snd_wss_mixer(struct snd_wss *chip)
@@ -2318,6 +2252,7 @@ int snd_wss_mixer(struct snd_wss *chip)
         struct snd_card *card;
         unsigned int idx;
         int err;
+        int count = ARRAY_SIZE(snd_wss_controls);
 
         if (snd_BUG_ON(!chip || !chip->pcm))
                 return -EINVAL;
@@ -2326,30 +2261,20 @@ int snd_wss_mixer(struct snd_wss *chip)
 
         strcpy(card->mixername, chip->pcm->name);
 
-        if (chip->hardware == WSS_HW_OPTI93X)
-                for (idx = 0; idx < ARRAY_SIZE(snd_opti93x_controls); idx++) {
-                        err = snd_ctl_add(card,
-                                        snd_ctl_new1(&snd_opti93x_controls[idx],
-                                                     chip));
-                        if (err < 0)
-                                return err;
-                }
-        else if (chip->hardware & WSS_HW_AD1848_MASK)
-                for (idx = 0; idx < ARRAY_SIZE(snd_ad1848_controls); idx++) {
-                        err = snd_ctl_add(card,
-                                        snd_ctl_new1(&snd_ad1848_controls[idx],
-                                                     chip));
-                        if (err < 0)
-                                return err;
-                }
-        else
-                for (idx = 0; idx < ARRAY_SIZE(snd_wss_controls); idx++) {
-                        err = snd_ctl_add(card,
-                                        snd_ctl_new1(&snd_wss_controls[idx],
-                                                     chip));
-                        if (err < 0)
-                                return err;
-                }
+        /* Use only the first 11 entries on AD1848 */
+        if (chip->hardware & WSS_HW_AD1848_MASK)
+                count = 11;
+        /* There is no loopback on OPTI93X */
+        else if (chip->hardware == WSS_HW_OPTI93X)
+                count = 9;
+
+        for (idx = 0; idx < count; idx++) {
+                err = snd_ctl_add(card,
+                                snd_ctl_new1(&snd_wss_controls[idx],
+                                             chip));
+                if (err < 0)
+                        return err;
+        }
         return 0;
 }
 EXPORT_SYMBOL(snd_wss_mixer);
diff --git a/sound/mips/hal2.c b/sound/mips/hal2.c
index 9a88cdfd952a..453d343550a8 100644
--- a/sound/mips/hal2.c
+++ b/sound/mips/hal2.c
@@ -25,6 +25,7 @@
 #include <linux/dma-mapping.h>
 #include <linux/platform_device.h>
 #include <linux/io.h>
+#include <linux/slab.h>
 
 #include <asm/sgi/hpc3.h>
 #include <asm/sgi/ip22.h>
diff --git a/sound/mips/sgio2audio.c b/sound/mips/sgio2audio.c
index 8691f4cf6191..717604c00f0a 100644
--- a/sound/mips/sgio2audio.c
+++ b/sound/mips/sgio2audio.c
@@ -25,12 +25,11 @@
 #include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/spinlock.h>
-#include <linux/gfp.h>
-#include <linux/vmalloc.h>
 #include <linux/interrupt.h>
 #include <linux/dma-mapping.h>
 #include <linux/platform_device.h>
 #include <linux/io.h>
+#include <linux/slab.h>
 
 #include <asm/ip32/ip32_ints.h>
 #include <asm/ip32/mace.h>
@@ -603,25 +602,14 @@ static int snd_sgio2audio_pcm_close(struct snd_pcm_substream *substream)
 static int snd_sgio2audio_pcm_hw_params(struct snd_pcm_substream *substream,
                                         struct snd_pcm_hw_params *hw_params)
 {
-        struct snd_pcm_runtime *runtime = substream->runtime;
-        int size = params_buffer_bytes(hw_params);
-
-        /* alloc virtual 'dma' area */
-        if (runtime->dma_area)
-                vfree(runtime->dma_area);
-        runtime->dma_area = vmalloc(size);
-        if (runtime->dma_area == NULL)
-                return -ENOMEM;
-        runtime->dma_bytes = size;
-        return 0;
+        return snd_pcm_lib_alloc_vmalloc_buffer(substream,
+                                                params_buffer_bytes(hw_params));
 }
 
 /* hw_free callback */
 static int snd_sgio2audio_pcm_hw_free(struct snd_pcm_substream *substream)
 {
-        vfree(substream->runtime->dma_area);
-        substream->runtime->dma_area = NULL;
-        return 0;
+        return snd_pcm_lib_free_vmalloc_buffer(substream);
 }
 
 /* prepare callback */
@@ -692,13 +680,6 @@ snd_sgio2audio_pcm_pointer(struct snd_pcm_substream *substream)
                                chip->channel[chan->idx].pos);
 }
 
-/* get the physical page pointer on the given offset */
-static struct page *snd_sgio2audio_page(struct snd_pcm_substream *substream,
-                                        unsigned long offset)
-{
-        return vmalloc_to_page(substream->runtime->dma_area + offset);
-}
-
 /* operators */
 static struct snd_pcm_ops snd_sgio2audio_playback1_ops = {
         .open =        snd_sgio2audio_playback1_open,
@@ -709,7 +690,8 @@ static struct snd_pcm_ops snd_sgio2audio_playback1_ops = {
         .prepare =     snd_sgio2audio_pcm_prepare,
         .trigger =     snd_sgio2audio_pcm_trigger,
         .pointer =     snd_sgio2audio_pcm_pointer,
-        .page =        snd_sgio2audio_page,
+        .page =        snd_pcm_lib_get_vmalloc_page,
+        .mmap =        snd_pcm_lib_mmap_vmalloc,
 };
 
 static struct snd_pcm_ops snd_sgio2audio_playback2_ops = {
@@ -721,7 +703,8 @@ static struct snd_pcm_ops snd_sgio2audio_playback2_ops = {
         .prepare =     snd_sgio2audio_pcm_prepare,
         .trigger =     snd_sgio2audio_pcm_trigger,
         .pointer =     snd_sgio2audio_pcm_pointer,
-        .page =        snd_sgio2audio_page,
+        .page =        snd_pcm_lib_get_vmalloc_page,
+        .mmap =        snd_pcm_lib_mmap_vmalloc,
 };
 
 static struct snd_pcm_ops snd_sgio2audio_capture_ops = {
@@ -733,7 +716,8 @@ static struct snd_pcm_ops snd_sgio2audio_capture_ops = {
         .prepare =     snd_sgio2audio_pcm_prepare,
         .trigger =     snd_sgio2audio_pcm_trigger,
         .pointer =     snd_sgio2audio_pcm_pointer,
-        .page =        snd_sgio2audio_page,
+        .page =        snd_pcm_lib_get_vmalloc_page,
+        .mmap =        snd_pcm_lib_mmap_vmalloc,
 };
 
 /*
diff --git a/sound/oss/Kconfig b/sound/oss/Kconfig
index bcf2a0698d54..a513651fa149 100644
--- a/sound/oss/Kconfig
+++ b/sound/oss/Kconfig
@@ -1,5 +1,3 @@
-# drivers/sound/Config.in
-#
 # 18 Apr 1998, Michael Elizabeth Chastain, <mailto:mec@shout.net>
 # More hacking for modularisation.
 #
@@ -287,18 +285,6 @@ config SOUND_DMAP
 
           Say Y unless you have 16MB or more RAM or a PCI sound card.
 
-config SOUND_SSCAPE
-        tristate "Ensoniq SoundScape support"
-        help
-          Answer Y if you have a sound card based on the Ensoniq SoundScape
-          chipset. Such cards are being manufactured at least by Ensoniq, Spea
-          and Reveal (Reveal makes also other cards).
-
-          If you compile the driver into the kernel, you have to add
-          "sscape=<io>,<irq>,<dma>,<mpuio>,<mpuirq>" to the kernel command
-          line.
-
-
 config SOUND_VMIDI
         tristate "Loopback MIDI device support"
         help
diff --git a/sound/oss/Makefile b/sound/oss/Makefile
index e0ae4d4d6a5c..567b8a74178a 100644
--- a/sound/oss/Makefile
+++ b/sound/oss/Makefile
@@ -13,7 +13,6 @@ obj-$(CONFIG_SOUND_SH_DAC_AUDIO)	+= sh_dac_audio.o
 obj-$(CONFIG_SOUND_AEDSP16)     += aedsp16.o
 obj-$(CONFIG_SOUND_PSS)         += pss.o ad1848.o mpu401.o
 obj-$(CONFIG_SOUND_TRIX)        += trix.o ad1848.o sb_lib.o uart401.o
-obj-$(CONFIG_SOUND_SSCAPE)      += sscape.o ad1848.o mpu401.o
 obj-$(CONFIG_SOUND_MSS)         += ad1848.o
 obj-$(CONFIG_SOUND_PAS)         += pas2.o sb.o sb_lib.o uart401.o
 obj-$(CONFIG_SOUND_SB)          += sb.o sb_lib.o uart401.o
diff --git a/sound/oss/ad1848.c b/sound/oss/ad1848.c
index d12bd98a37ba..24793c5b65ac 100644
--- a/sound/oss/ad1848.c
+++ b/sound/oss/ad1848.c
@@ -45,6 +45,7 @@
 #include <linux/interrupt.h>
 #include <linux/module.h>
 #include <linux/stddef.h>
+#include <linux/slab.h>
 #include <linux/isapnp.h>
 #include <linux/pnp.h>
 #include <linux/spinlock.h>
diff --git a/sound/oss/au1550_ac97.c b/sound/oss/au1550_ac97.c
index 4191acccbcdb..c1070e33b32f 100644
--- a/sound/oss/au1550_ac97.c
+++ b/sound/oss/au1550_ac97.c
@@ -614,7 +614,8 @@ start_adc(struct au1550_state *s)
         /* Put two buffers on the ring to get things started.
         */
         for (i=0; i<2; i++) {
-                au1xxx_dbdma_put_dest(db->dmanr, db->nextIn, db->dma_fragsize);
+                au1xxx_dbdma_put_dest(db->dmanr, virt_to_phys(db->nextIn),
+                                db->dma_fragsize, DDMA_FLAGS_IE);
 
                 db->nextIn += db->dma_fragsize;
                 if (db->nextIn >= db->rawbuf + db->dmasize)
@@ -732,8 +733,9 @@ static void dac_dma_interrupt(int irq, void *dev_id)
         db->dma_qcount--;
 
         if (db->count >= db->fragsize) {
-                if (au1xxx_dbdma_put_source(db->dmanr, db->nextOut,
-                                                        db->fragsize) == 0) {
+                if (au1xxx_dbdma_put_source(db->dmanr,
+                                virt_to_phys(db->nextOut), db->fragsize,
+                                DDMA_FLAGS_IE) == 0) {
                         err("qcount < 2 and no ring room!");
                 }
                 db->nextOut += db->fragsize;
@@ -777,7 +779,8 @@ static void adc_dma_interrupt(int irq, void *dev_id)
 
         /* Put a new empty buffer on the destination DMA.
         */
-        au1xxx_dbdma_put_dest(dp->dmanr, dp->nextIn, dp->dma_fragsize);
+        au1xxx_dbdma_put_dest(dp->dmanr, virt_to_phys(dp->nextIn),
+                              dp->dma_fragsize, DDMA_FLAGS_IE);
 
         dp->nextIn += dp->dma_fragsize;
         if (dp->nextIn >= dp->rawbuf + dp->dmasize)
@@ -1177,8 +1180,9 @@ au1550_write(struct file *file, const char *buffer, size_t count, loff_t * ppos)
                  * we know the dma has stopped.
                  */
                 while ((db->dma_qcount < 2) && (db->count >= db->fragsize)) {
-                        if (au1xxx_dbdma_put_source(db->dmanr, db->nextOut,
-                                                        db->fragsize) == 0) {
+                        if (au1xxx_dbdma_put_source(db->dmanr,
+                                virt_to_phys(db->nextOut), db->fragsize,
+                                DDMA_FLAGS_IE) == 0) {
                                 err("qcount < 2 and no ring room!");
                         }
                         db->nextOut += db->fragsize;
diff --git a/sound/oss/audio.c b/sound/oss/audio.c
index b69c05b7ea7b..7df48a25c4ee 100644
--- a/sound/oss/audio.c
+++ b/sound/oss/audio.c
@@ -838,7 +838,7 @@ static int dma_ioctl(int dev, unsigned int cmd, void __user *arg)
                                         if ((err = audio_devs[dev]->d->prepare_for_input(dev,
                                                      dmap_in->fragment_size, dmap_in->nbufs)) < 0) {
                                                 spin_unlock_irqrestore(&dmap_in->lock,flags);
-                                                return -err;
+                                                return err;
                                         }
                                         dmap_in->dma_mode = DMODE_INPUT;
                                         audio_devs[dev]->enable_bits |= PCM_ENABLE_INPUT;
diff --git a/sound/oss/coproc.h b/sound/oss/coproc.h
index 7306346e9ac4..7bec21bbdd88 100644
--- a/sound/oss/coproc.h
+++ b/sound/oss/coproc.h
@@ -4,7 +4,7 @@
  */
 
 /*
- * Coprocessor access types 
+ * Coprocessor access types
  */
 #define COPR_CUSTOM             0x0001  /* Custom applications */
 #define COPR_MIDI               0x0002  /* MIDI (MPU-401) emulation */
diff --git a/sound/oss/dev_table.c b/sound/oss/dev_table.c
index 08274c995d06..727bdb9ba2dc 100644
--- a/sound/oss/dev_table.c
+++ b/sound/oss/dev_table.c
@@ -67,14 +67,15 @@ int sound_install_audiodrv(int vers, char *name, struct audio_driver *driver,
                 return -(EBUSY);
         }
         d = (struct audio_driver *) (sound_mem_blocks[sound_nblocks] = vmalloc(sizeof(struct audio_driver)));
-
-        if (sound_nblocks < 1024)
-                sound_nblocks++;
+        sound_nblocks++;
+        if (sound_nblocks >= MAX_MEM_BLOCKS)
+                sound_nblocks = MAX_MEM_BLOCKS - 1;
 
         op = (struct audio_operations *) (sound_mem_blocks[sound_nblocks] = vmalloc(sizeof(struct audio_operations)));
+        sound_nblocks++;
+        if (sound_nblocks >= MAX_MEM_BLOCKS)
+                sound_nblocks = MAX_MEM_BLOCKS - 1;
 
-        if (sound_nblocks < 1024)
-                sound_nblocks++;
         if (d == NULL || op == NULL) {
                 printk(KERN_ERR "Sound: Can't allocate driver for (%s)\n", name);
                 sound_unload_audiodev(num);
@@ -128,9 +129,10 @@ int sound_install_mixer(int vers, char *name, struct mixer_operations *driver,
            until you unload sound! */
            
         op = (struct mixer_operations *) (sound_mem_blocks[sound_nblocks] = vmalloc(sizeof(struct mixer_operations)));
+        sound_nblocks++;
+        if (sound_nblocks >= MAX_MEM_BLOCKS)
+                sound_nblocks = MAX_MEM_BLOCKS - 1;
 
-        if (sound_nblocks < 1024)
-                sound_nblocks++;
         if (op == NULL) {
                 printk(KERN_ERR "Sound: Can't allocate mixer driver for (%s)\n", name);
                 return -ENOMEM;
diff --git a/sound/oss/dmabuf.c b/sound/oss/dmabuf.c
index 1bfcf7e88546..bcc3e8e07122 100644
--- a/sound/oss/dmabuf.c
+++ b/sound/oss/dmabuf.c
@@ -26,6 +26,7 @@
 #define SAMPLE_ROUNDUP 0
 
 #include <linux/mm.h>
+#include <linux/gfp.h>
 #include "sound_config.h"
 
 #define DMAP_FREE_ON_CLOSE      0
diff --git a/sound/oss/dmasound/dmasound_paula.c b/sound/oss/dmasound/dmasound_paula.c
index 06e9e88e4c05..bb14e4c67e89 100644
--- a/sound/oss/dmasound/dmasound_paula.c
+++ b/sound/oss/dmasound/dmasound_paula.c
@@ -657,7 +657,7 @@ static int AmiStateInfo(char *buffer, size_t space)
         len += sprintf(buffer+len, "\tsound.volume_right = %d [0...64]\n",
                        dmasound.volume_right);
         if (len >= space) {
-                printk(KERN_ERR "dmasound_paula: overlowed state buffer alloc.\n") ;
+                printk(KERN_ERR "dmasound_paula: overflowed state buffer alloc.\n") ;
                 len = space ;
         }
         return len;
diff --git a/sound/oss/kahlua.c b/sound/oss/kahlua.c
index 89466b056be7..52d06a334e8f 100644
--- a/sound/oss/kahlua.c
+++ b/sound/oss/kahlua.c
@@ -31,6 +31,7 @@
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/pci.h>
+#include <linux/slab.h>
 
 #include "sound_config.h"
 
@@ -198,7 +199,7 @@ MODULE_LICENSE("GPL");
  *      5530 only. The 5510/5520 decode is different.
  */
 
-static struct pci_device_id id_tbl[] = {
+static DEFINE_PCI_DEVICE_TABLE(id_tbl) = {
         { PCI_VDEVICE(CYRIX, PCI_DEVICE_ID_CYRIX_5530_AUDIO), 0 },
         { }
 };
diff --git a/sound/oss/midi_synth.c b/sound/oss/midi_synth.c
index 9e450988ed36..3bc7104c5379 100644
--- a/sound/oss/midi_synth.c
+++ b/sound/oss/midi_synth.c
@@ -426,7 +426,7 @@ midi_synth_open(int dev, int mode)
         int             err;
         struct midi_input_info *inc;
 
-        if (orig_dev < 0 || orig_dev > num_midis || midi_devs[orig_dev] == NULL)
+        if (orig_dev < 0 || orig_dev >= num_midis || midi_devs[orig_dev] == NULL)
                 return -ENXIO;
 
         midi2synth[orig_dev] = dev;
diff --git a/sound/oss/mpu401.c b/sound/oss/mpu401.c
index 734b8f9e2f78..25e4609f8339 100644
--- a/sound/oss/mpu401.c
+++ b/sound/oss/mpu401.c
@@ -19,6 +19,7 @@
  */
 
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/spinlock.h>
@@ -770,7 +771,7 @@ static int mpu_synth_ioctl(int dev, unsigned int cmd, void __user *arg)
 
         midi_dev = synth_devs[dev]->midi_dev;
 
-        if (midi_dev < 0 || midi_dev > num_midis || midi_devs[midi_dev] == NULL)
+        if (midi_dev < 0 || midi_dev >= num_midis || midi_devs[midi_dev] == NULL)
                 return -ENXIO;
 
         devc = &dev_conf[midi_dev];
diff --git a/sound/oss/msnd.c b/sound/oss/msnd.c
index 21eb6dce46df..c0cc951ba97d 100644
--- a/sound/oss/msnd.c
+++ b/sound/oss/msnd.c
@@ -24,7 +24,6 @@
 
 #include <linux/module.h>
 #include <linux/kernel.h>
-#include <linux/slab.h>
 #include <linux/vmalloc.h>
 #include <linux/types.h>
 #include <linux/delay.h>
diff --git a/sound/oss/msnd_pinnacle.c b/sound/oss/msnd_pinnacle.c
index bf27e008f465..a1e3f9671bea 100644
--- a/sound/oss/msnd_pinnacle.c
+++ b/sound/oss/msnd_pinnacle.c
@@ -35,12 +35,12 @@
 
 #include <linux/kernel.h>
 #include <linux/module.h>
-#include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/delay.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/smp_lock.h>
+#include <linux/gfp.h>
 #include <asm/irq.h>
 #include <asm/io.h>
 #include "sound_config.h"
diff --git a/sound/oss/opl3.c b/sound/oss/opl3.c
index 7781c13c1476..938c48c43585 100644
--- a/sound/oss/opl3.c
+++ b/sound/oss/opl3.c
@@ -24,6 +24,7 @@
  */
 
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/delay.h>
 
diff --git a/sound/oss/pss.c b/sound/oss/pss.c
index 83f5ee236b12..e19dd5dcc2de 100644
--- a/sound/oss/pss.c
+++ b/sound/oss/pss.c
@@ -269,7 +269,7 @@ static int pss_reset_dsp(pss_confdata * devc)
         unsigned long   i, limit = jiffies + HZ/10;
 
         outw(0x2000, REG(PSS_CONTROL));
-        for (i = 0; i < 32768 && (limit-jiffies >= 0); i++)
+        for (i = 0; i < 32768 && time_after_eq(limit, jiffies); i++)
                 inw(REG(PSS_CONTROL));
         outw(0x0000, REG(PSS_CONTROL));
         return 1;
@@ -369,11 +369,11 @@ static int pss_download_boot(pss_confdata * devc, unsigned char *block, int size
                 outw(0, REG(PSS_DATA));
 
                 limit = jiffies + HZ/10;
-                for (i = 0; i < 32768 && (limit - jiffies >= 0); i++)
+                for (i = 0; i < 32768 && time_after_eq(limit, jiffies); i++)
                         val = inw(REG(PSS_STATUS));
 
                 limit = jiffies + HZ/10;
-                for (i = 0; i < 32768 && (limit-jiffies >= 0); i++)
+                for (i = 0; i < 32768 && time_after_eq(limit, jiffies); i++)
                 {
                         val = inw(REG(PSS_STATUS));
                         if (val & 0x4000)
diff --git a/sound/oss/sb_card.c b/sound/oss/sb_card.c
index 7de18b58f2cd..84ef4d06c1c2 100644
--- a/sound/oss/sb_card.c
+++ b/sound/oss/sb_card.c
@@ -24,6 +24,7 @@
 
 #include <linux/module.h>
 #include <linux/moduleparam.h>
+#include <linux/slab.h>
 #include <linux/init.h>
 #include "sound_config.h"
 #include "sb_mixer.h"
diff --git a/sound/oss/sb_common.c b/sound/oss/sb_common.c
index ce4db49291f7..7d42c5418d1b 100644
--- a/sound/oss/sb_common.c
+++ b/sound/oss/sb_common.c
@@ -31,6 +31,7 @@
 #include <linux/module.h>
 #include <linux/delay.h>
 #include <linux/spinlock.h>
+#include <linux/slab.h>
 
 #include "sound_config.h"
 #include "sound_firmware.h"
diff --git a/sound/oss/sb_midi.c b/sound/oss/sb_midi.c
index 8b796704e112..f139028e85c0 100644
--- a/sound/oss/sb_midi.c
+++ b/sound/oss/sb_midi.c
@@ -12,6 +12,7 @@
  */
 
 #include <linux/spinlock.h>
+#include <linux/slab.h>
 
 #include "sound_config.h"
 
diff --git a/sound/oss/sb_mixer.c b/sound/oss/sb_mixer.c
index fad1a4f25ad6..2039d31b7e22 100644
--- a/sound/oss/sb_mixer.c
+++ b/sound/oss/sb_mixer.c
@@ -16,6 +16,8 @@
  * Stanislav Voronyi <stas@esc.kharkov.com>     : Support for AWE 3DSE device (Jun 7 1999)
  */
 
+#include <linux/slab.h>
+
 #include "sound_config.h"
 
 #define __SB_MIXER_C__
diff --git a/sound/oss/sequencer.c b/sound/oss/sequencer.c
index c79874696bec..e85789e53816 100644
--- a/sound/oss/sequencer.c
+++ b/sound/oss/sequencer.c
@@ -1631,8 +1631,6 @@ unsigned long compute_finetune(unsigned long base_freq, int bend, int range,
         }
 
         semitones = bend / 100;
-        if (semitones > 99)
-                semitones = 99;
         cents = bend % 100;
 
         amount = (int) (semitone_tuning[semitones] * multiplier * cent_tuning[cents]) / 10000;
diff --git a/sound/oss/sh_dac_audio.c b/sound/oss/sh_dac_audio.c
index b2ed8757542a..4153752507e3 100644
--- a/sound/oss/sh_dac_audio.c
+++ b/sound/oss/sh_dac_audio.c
@@ -164,9 +164,6 @@ static ssize_t dac_audio_write(struct file *file, const char *buf, size_t count,
         int free;
         int nbytes;
 
-        if (count < 0)
-                return -EINVAL;
-
         if (!count) {
                 dac_audio_sync();
                 return 0;
diff --git a/sound/oss/sound_config.h b/sound/oss/sound_config.h
index 55271fbe7f49..9d35c4c65b9b 100644
--- a/sound/oss/sound_config.h
+++ b/sound/oss/sound_config.h
@@ -142,4 +142,6 @@ static inline int translate_mode(struct file *file)
 #define TIMER_ARMED     121234
 #define TIMER_NOT_ARMED 1
 
+#define MAX_MEM_BLOCKS 1024
+
 #endif
diff --git a/sound/oss/soundcard.c b/sound/oss/soundcard.c
index 61aaedae6b7e..2d9c51312622 100644
--- a/sound/oss/soundcard.c
+++ b/sound/oss/soundcard.c
@@ -36,7 +36,6 @@
 #include <asm/dma.h>
 #include <asm/io.h>
 #include <linux/wait.h>
-#include <linux/slab.h>
 #include <linux/ioport.h>
 #include <linux/major.h>
 #include <linux/delay.h>
@@ -56,7 +55,7 @@
 /*
  * Table for permanently allocated memory (used when unloading the module)
  */
-void *          sound_mem_blocks[1024];
+void *          sound_mem_blocks[MAX_MEM_BLOCKS];
 int             sound_nblocks = 0;
 
 /* Persistent DMA buffers */
@@ -328,11 +327,11 @@ static int sound_mixer_ioctl(int mixdev, unsigned int cmd, void __user *arg)
         return mixer_devs[mixdev]->ioctl(mixdev, cmd, arg);
 }
 
-static int sound_ioctl(struct inode *inode, struct file *file,
-                       unsigned int cmd, unsigned long arg)
+static long sound_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
         int len = 0, dtype;
-        int dev = iminor(inode);
+        int dev = iminor(file->f_dentry->d_inode);
+        long ret = -EINVAL;
         void __user *p = (void __user *)arg;
 
         if (_SIOC_DIR(cmd) != _SIOC_NONE && _SIOC_DIR(cmd) != 0) {
@@ -353,6 +352,7 @@ static int sound_ioctl(struct inode *inode, struct file *file,
         if (cmd == OSS_GETVERSION)
                 return __put_user(SOUND_VERSION, (int __user *)p);
         
+        lock_kernel();
         if (_IOC_TYPE(cmd) == 'M' && num_mixers > 0 &&   /* Mixer ioctl */
             (dev & 0x0f) != SND_DEV_CTL) {              
                 dtype = dev & 0x0f;
@@ -360,24 +360,31 @@ static int sound_ioctl(struct inode *inode, struct file *file,
                 case SND_DEV_DSP:
                 case SND_DEV_DSP16:
                 case SND_DEV_AUDIO:
-                        return sound_mixer_ioctl(audio_devs[dev >> 4]->mixer_dev,
+                        ret = sound_mixer_ioctl(audio_devs[dev >> 4]->mixer_dev,
                                                  cmd, p);
-                        
+                        break;                  
                 default:
-                        return sound_mixer_ioctl(dev >> 4, cmd, p);
+                        ret = sound_mixer_ioctl(dev >> 4, cmd, p);
+                        break;
                 }
+                unlock_kernel();
+                return ret;
         }
+
         switch (dev & 0x0f) {
         case SND_DEV_CTL:
                 if (cmd == SOUND_MIXER_GETLEVELS)
-                        return get_mixer_levels(p);
-                if (cmd == SOUND_MIXER_SETLEVELS)
-                        return set_mixer_levels(p);
-                return sound_mixer_ioctl(dev >> 4, cmd, p);
+                        ret = get_mixer_levels(p);
+                else if (cmd == SOUND_MIXER_SETLEVELS)
+                        ret = set_mixer_levels(p);
+                else
+                        ret = sound_mixer_ioctl(dev >> 4, cmd, p);
+                break;
 
         case SND_DEV_SEQ:
         case SND_DEV_SEQ2:
-                return sequencer_ioctl(dev, file, cmd, p);
+                ret = sequencer_ioctl(dev, file, cmd, p);
+                break;
 
         case SND_DEV_DSP:
         case SND_DEV_DSP16:
@@ -390,7 +397,8 @@ static int sound_ioctl(struct inode *inode, struct file *file,
                 break;
 
         }
-        return -EINVAL;
+        unlock_kernel();
+        return ret;
 }
 
 static unsigned int sound_poll(struct file *file, poll_table * wait)
@@ -490,7 +498,7 @@ const struct file_operations oss_sound_fops = {
         .read           = sound_read,
         .write          = sound_write,
         .poll           = sound_poll,
-        .ioctl          = sound_ioctl,
+        .unlocked_ioctl = sound_ioctl,
         .mmap           = sound_mmap,
         .open           = sound_open,
         .release        = sound_release,
@@ -574,7 +582,7 @@ static int __init oss_init(void)
                                       NULL, "%s%d", dev_list[i].name, j);
         }
 
-        if (sound_nblocks >= 1024)
+        if (sound_nblocks >= MAX_MEM_BLOCKS - 1)
                 printk(KERN_ERR "Sound warning: Deallocation table was too small.\n");
         
         return 0;
diff --git a/sound/oss/sscape.c b/sound/oss/sscape.c
deleted file mode 100644
index 30c36d1f35d7..000000000000
--- a/sound/oss/sscape.c
+++ /dev/null
@@ -1,1480 +0,0 @@
-/*
- * sound/oss/sscape.c
- *
- * Low level driver for Ensoniq SoundScape
- *
- *
- * Copyright (C) by Hannu Savolainen 1993-1997
- *
- * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
- * Version 2 (June 1991). See the "COPYING" file distributed with this software
- * for more info.
- *
- *
- * Thomas Sailer        : ioctl code reworked (vmalloc/vfree removed)
- * Sergey Smitienko     : ensoniq p'n'p support
- * Christoph Hellwig    : adapted to module_init/module_exit
- * Bartlomiej Zolnierkiewicz : added __init to attach_sscape()
- * Chris Rankin         : Specify that this module owns the coprocessor
- * Arnaldo C. de Melo   : added missing restore_flags in sscape_pnp_upload_file
- */
-
-#include <linux/init.h>
-#include <linux/module.h>
-
-#include "sound_config.h"
-#include "sound_firmware.h"
-
-#include <linux/types.h>
-#include <linux/errno.h>
-#include <linux/signal.h>
-#include <linux/fcntl.h>
-#include <linux/ctype.h>
-#include <linux/stddef.h>
-#include <linux/kmod.h>
-#include <asm/dma.h>
-#include <asm/io.h>
-#include <linux/wait.h>
-#include <linux/slab.h>
-#include <linux/ioport.h>
-#include <linux/delay.h>
-#include <linux/proc_fs.h>
-#include <linux/mm.h>
-#include <linux/spinlock.h>
-
-#include "coproc.h"
-
-#include "ad1848.h"
-#include "mpu401.h"
-
-/*
- *    I/O ports
- */
-#define MIDI_DATA       0
-#define MIDI_CTRL       1
-#define HOST_CTRL       2
-#define TX_READY        0x02
-#define RX_READY        0x01
-#define HOST_DATA       3
-#define ODIE_ADDR       4
-#define ODIE_DATA       5
-
-/*
- *    Indirect registers
- */
-
-#define GA_INTSTAT_REG  0
-#define GA_INTENA_REG   1
-#define GA_DMAA_REG     2
-#define GA_DMAB_REG     3
-#define GA_INTCFG_REG   4
-#define GA_DMACFG_REG   5
-#define GA_CDCFG_REG    6
-#define GA_SMCFGA_REG   7
-#define GA_SMCFGB_REG   8
-#define GA_HMCTL_REG    9
-
-/*
- * DMA channel identifiers (A and B)
- */
-
-#define SSCAPE_DMA_A    0
-#define SSCAPE_DMA_B    1
-
-#define PORT(name)      (devc->base+name)
-
-/*
- * Host commands recognized by the OBP microcode
- */
- 
-#define CMD_GEN_HOST_ACK        0x80
-#define CMD_GEN_MPU_ACK         0x81
-#define CMD_GET_BOARD_TYPE      0x82
-#define CMD_SET_CONTROL         0x88    /* Old firmware only */
-#define CMD_GET_CONTROL         0x89    /* Old firmware only */
-#define CTL_MASTER_VOL          0
-#define CTL_MIC_MODE            2
-#define CTL_SYNTH_VOL           4
-#define CTL_WAVE_VOL            7
-#define CMD_SET_EXTMIDI         0x8a
-#define CMD_GET_EXTMIDI         0x8b
-#define CMD_SET_MT32            0x8c
-#define CMD_GET_MT32            0x8d
-
-#define CMD_ACK                 0x80
-
-#define IC_ODIE                 1
-#define IC_OPUS                 2
-
-typedef struct sscape_info
-{
-        int     base, irq, dma;
-        
-        int     codec, codec_irq;       /* required to setup pnp cards*/
-        int     codec_type;
-        int     ic_type;
-        char*   raw_buf;
-        unsigned long   raw_buf_phys;
-        int     buffsize;               /* -------------------------- */
-        spinlock_t lock;
-        int     ok;     /* Properly detected */
-        int     failed;
-        int     dma_allocated;
-        int     codec_audiodev;
-        int     opened;
-        int     *osp;
-        int     my_audiodev;
-} sscape_info;
-
-static struct sscape_info adev_info = {
-        0
-};
-
-static struct sscape_info *devc = &adev_info;
-static int sscape_mididev = -1;
-
-/* Some older cards have assigned interrupt bits differently than new ones */
-static char valid_interrupts_old[] = {
-        9, 7, 5, 15
-};
-
-static char valid_interrupts_new[] = {
-        9, 5, 7, 10
-};
-
-static char *valid_interrupts = valid_interrupts_new;
-
-/*
- *      See the bottom of the driver. This can be set by spea =0/1.
- */
- 
-#ifdef REVEAL_SPEA
-static char old_hardware = 1;
-#else
-static char old_hardware;
-#endif
-
-static void sleep(unsigned howlong)
-{
-        current->state = TASK_INTERRUPTIBLE;
-        schedule_timeout(howlong);
-}
-
-static unsigned char sscape_read(struct sscape_info *devc, int reg)
-{
-        unsigned long flags;
-        unsigned char val;
-
-        spin_lock_irqsave(&devc->lock,flags);
-        outb(reg, PORT(ODIE_ADDR));
-        val = inb(PORT(ODIE_DATA));
-        spin_unlock_irqrestore(&devc->lock,flags);
-        return val;
-}
-
-static void __sscape_write(int reg, int data)
-{
-        outb(reg, PORT(ODIE_ADDR));
-        outb(data, PORT(ODIE_DATA));
-}
-
-static void sscape_write(struct sscape_info *devc, int reg, int data)
-{
-        unsigned long flags;
-
-        spin_lock_irqsave(&devc->lock,flags);
-        __sscape_write(reg, data);
-        spin_unlock_irqrestore(&devc->lock,flags);
-}
-
-static unsigned char sscape_pnp_read_codec(sscape_info* devc, unsigned char reg)
-{
-        unsigned char res;
-        unsigned long flags;
-
-        spin_lock_irqsave(&devc->lock,flags);
-        outb( reg, devc -> codec);
-        res = inb (devc -> codec + 1);
-        spin_unlock_irqrestore(&devc->lock,flags);
-        return res;
-
-}
-
-static void sscape_pnp_write_codec(sscape_info* devc, unsigned char reg, unsigned char data)
-{
-        unsigned long flags;
-        
-        spin_lock_irqsave(&devc->lock,flags);
-        outb( reg, devc -> codec);
-        outb( data, devc -> codec + 1);
-        spin_unlock_irqrestore(&devc->lock,flags);
-}
-
-static void host_open(struct sscape_info *devc)
-{
-        outb((0x00), PORT(HOST_CTRL));  /* Put the board to the host mode */
-}
-
-static void host_close(struct sscape_info *devc)
-{
-        outb((0x03), PORT(HOST_CTRL));  /* Put the board to the MIDI mode */
-}
-
-static int host_write(struct sscape_info *devc, unsigned char *data, int count)
-{
-        unsigned long flags;
-        int i, timeout_val;
-
-        spin_lock_irqsave(&devc->lock,flags);
-        /*
-         * Send the command and data bytes
-         */
-
-        for (i = 0; i < count; i++)
-        {
-                for (timeout_val = 10000; timeout_val > 0; timeout_val--)
-                        if (inb(PORT(HOST_CTRL)) & TX_READY)
-                                break;
-
-                if (timeout_val <= 0)
-                {
-                                spin_unlock_irqrestore(&devc->lock,flags);
-                            return 0;
-                }
-                outb(data[i], PORT(HOST_DATA));
-        }
-        spin_unlock_irqrestore(&devc->lock,flags);
-        return 1;
-}
-
-static int host_read(struct sscape_info *devc)
-{
-        unsigned long flags;
-        int timeout_val;
-        unsigned char data;
-
-        spin_lock_irqsave(&devc->lock,flags);
-        /*
-         * Read a byte
-         */
-
-        for (timeout_val = 10000; timeout_val > 0; timeout_val--)
-                if (inb(PORT(HOST_CTRL)) & RX_READY)
-                        break;
-
-        if (timeout_val <= 0)
-        {
-                spin_unlock_irqrestore(&devc->lock,flags);
-                return -1;
-        }
-        data = inb(PORT(HOST_DATA));
-        spin_unlock_irqrestore(&devc->lock,flags);
-        return data;
-}
-
-#if 0 /* unused */
-static int host_command1(struct sscape_info *devc, int cmd)
-{
-        unsigned char buf[10];
-        buf[0] = (unsigned char) (cmd & 0xff);
-        return host_write(devc, buf, 1);
-}
-#endif /* unused */
-
-
-static int host_command2(struct sscape_info *devc, int cmd, int parm1)
-{
-        unsigned char buf[10];
-
-        buf[0] = (unsigned char) (cmd & 0xff);
-        buf[1] = (unsigned char) (parm1 & 0xff);
-
-        return host_write(devc, buf, 2);
-}
-
-static int host_command3(struct sscape_info *devc, int cmd, int parm1, int parm2)
-{
-        unsigned char buf[10];
-
-        buf[0] = (unsigned char) (cmd & 0xff);
-        buf[1] = (unsigned char) (parm1 & 0xff);
-        buf[2] = (unsigned char) (parm2 & 0xff);
-        return host_write(devc, buf, 3);
-}
-
-static void set_mt32(struct sscape_info *devc, int value)
-{
-        host_open(devc);
-        host_command2(devc, CMD_SET_MT32, value ? 1 : 0);
-        if (host_read(devc) != CMD_ACK)
-        {
-                /* printk( "SNDSCAPE: Setting MT32 mode failed\n"); */
-        }
-        host_close(devc);
-}
-
-static void set_control(struct sscape_info *devc, int ctrl, int value)
-{
-        host_open(devc);
-        host_command3(devc, CMD_SET_CONTROL, ctrl, value);
-        if (host_read(devc) != CMD_ACK)
-        {
-                /* printk( "SNDSCAPE: Setting control (%d) failed\n",  ctrl); */
-        }
-        host_close(devc);
-}
-
-static void do_dma(struct sscape_info *devc, int dma_chan, unsigned long buf, int blk_size, int mode)
-{
-        unsigned char temp;
-
-        if (dma_chan != SSCAPE_DMA_A)
-        {
-                printk(KERN_WARNING "soundscape: Tried to use DMA channel  != A. Why?\n");
-                return;
-        }
-        audio_devs[devc->codec_audiodev]->flags &= ~DMA_AUTOMODE;
-        DMAbuf_start_dma(devc->codec_audiodev, buf, blk_size, mode);
-        audio_devs[devc->codec_audiodev]->flags |= DMA_AUTOMODE;
-
-        temp = devc->dma << 4;  /* Setup DMA channel select bits */
-        if (devc->dma <= 3)
-                temp |= 0x80;   /* 8 bit DMA channel */
-
-        temp |= 1;              /* Trigger DMA */
-        sscape_write(devc, GA_DMAA_REG, temp);
-        temp &= 0xfe;           /* Clear DMA trigger */
-        sscape_write(devc, GA_DMAA_REG, temp);
-}
-
-static int verify_mpu(struct sscape_info *devc)
-{
-        /*
-         * The SoundScape board could be in three modes (MPU, 8250 and host).
-         * If the card is not in the MPU mode, enabling the MPU driver will
-         * cause infinite loop (the driver believes that there is always some
-         * received data in the buffer.
-         *
-         * Detect this by looking if there are more than 10 received MIDI bytes
-         * (0x00) in the buffer.
-         */
-
-        int i;
-
-        for (i = 0; i < 10; i++)
-        {
-                if (inb(devc->base + HOST_CTRL) & 0x80)
-                        return 1;
-
-                if (inb(devc->base) != 0x00)
-                        return 1;
-        }
-        printk(KERN_WARNING "SoundScape: The device is not in the MPU-401 mode\n");
-        return 0;
-}
-
-static int sscape_coproc_open(void *dev_info, int sub_device)
-{
-        if (sub_device == COPR_MIDI)
-        {
-                set_mt32(devc, 0);
-                if (!verify_mpu(devc))
-                        return -EIO;
-        }
-        return 0;
-}
-
-static void sscape_coproc_close(void *dev_info, int sub_device)
-{
-        struct sscape_info *devc = dev_info;
-        unsigned long   flags;
-
-        spin_lock_irqsave(&devc->lock,flags);
-        if (devc->dma_allocated)
-        {
-                __sscape_write(GA_DMAA_REG, 0x20);      /* DMA channel disabled */
-                devc->dma_allocated = 0;
-        }
-        spin_unlock_irqrestore(&devc->lock,flags);
-        return;
-}
-
-static void sscape_coproc_reset(void *dev_info)
-{
-}
-
-static int sscape_download_boot(struct sscape_info *devc, unsigned char *block, int size, int flag)
-{
-        unsigned long flags;
-        unsigned char temp;
-        volatile int done, timeout_val;
-        static unsigned char codec_dma_bits;
-
-        if (flag & CPF_FIRST)
-        {
-                /*
-                 * First block. Have to allocate DMA and to reset the board
-                 * before continuing.
-                 */
-
-                spin_lock_irqsave(&devc->lock,flags);
-                codec_dma_bits = sscape_read(devc, GA_CDCFG_REG);
-
-                if (devc->dma_allocated == 0)
-                        devc->dma_allocated = 1;
-
-                spin_unlock_irqrestore(&devc->lock,flags);
-
-                sscape_write(devc, GA_HMCTL_REG, 
-                        (temp = sscape_read(devc, GA_HMCTL_REG)) & 0x3f);       /*Reset */
-
-                for (timeout_val = 10000; timeout_val > 0; timeout_val--)
-                        sscape_read(devc, GA_HMCTL_REG);        /* Delay */
-
-                /* Take board out of reset */
-                sscape_write(devc, GA_HMCTL_REG,
-                        (temp = sscape_read(devc, GA_HMCTL_REG)) | 0x80);
-        }
-        /*
-         * Transfer one code block using DMA
-         */
-        if (audio_devs[devc->codec_audiodev]->dmap_out->raw_buf == NULL)
-        {
-                printk(KERN_WARNING "soundscape: DMA buffer not available\n");
-                return 0;
-        }
-        memcpy(audio_devs[devc->codec_audiodev]->dmap_out->raw_buf, block, size);
-
-        spin_lock_irqsave(&devc->lock,flags);
-        
-        /******** INTERRUPTS DISABLED NOW ********/
-        
-        do_dma(devc, SSCAPE_DMA_A,
-               audio_devs[devc->codec_audiodev]->dmap_out->raw_buf_phys,
-               size, DMA_MODE_WRITE);
-
-        /*
-         * Wait until transfer completes.
-         */
-        
-        done = 0;
-        timeout_val = 30;
-        while (!done && timeout_val-- > 0)
-        {
-                int resid;
-
-                if (HZ / 50)
-                        sleep(HZ / 50);
-                clear_dma_ff(devc->dma);
-                if ((resid = get_dma_residue(devc->dma)) == 0)
-                        done = 1;
-        }
-
-        spin_unlock_irqrestore(&devc->lock,flags);
-        if (!done)
-                return 0;
-
-        if (flag & CPF_LAST)
-        {
-                /*
-                 * Take the board out of reset
-                 */
-                outb((0x00), PORT(HOST_CTRL));
-                outb((0x00), PORT(MIDI_CTRL));
-
-                temp = sscape_read(devc, GA_HMCTL_REG);
-                temp |= 0x40;
-                sscape_write(devc, GA_HMCTL_REG, temp); /* Kickstart the board */
-
-                /*
-                 * Wait until the ODB wakes up
-                 */
-                spin_lock_irqsave(&devc->lock,flags);
-                done = 0;
-                timeout_val = 5 * HZ;
-                while (!done && timeout_val-- > 0)
-                {
-                        unsigned char x;
-                        
-                        sleep(1);
-                        x = inb(PORT(HOST_DATA));
-                        if (x == 0xff || x == 0xfe)             /* OBP startup acknowledge */
-                        {
-                                DDB(printk("Soundscape: Acknowledge = %x\n", x));
-                                done = 1;
-                        }
-                }
-                sscape_write(devc, GA_CDCFG_REG, codec_dma_bits);
-
-                spin_unlock_irqrestore(&devc->lock,flags);
-                if (!done)
-                {
-                        printk(KERN_ERR "soundscape: The OBP didn't respond after code download\n");
-                        return 0;
-                }
-                spin_lock_irqsave(&devc->lock,flags);
-                done = 0;
-                timeout_val = 5 * HZ;
-                while (!done && timeout_val-- > 0)
-                {
-                        sleep(1);
-                        if (inb(PORT(HOST_DATA)) == 0xfe)       /* Host startup acknowledge */
-                                done = 1;
-                }
-                spin_unlock_irqrestore(&devc->lock,flags);
-                if (!done)
-                {
-                        printk(KERN_ERR "soundscape: OBP Initialization failed.\n");
-                        return 0;
-                }
-                printk(KERN_INFO "SoundScape board initialized OK\n");
-                set_control(devc, CTL_MASTER_VOL, 100);
-                set_control(devc, CTL_SYNTH_VOL, 100);
-
-#ifdef SSCAPE_DEBUG3
-                /*
-                 * Temporary debugging aid. Print contents of the registers after
-                 * downloading the code.
-                 */
-                {
-                        int i;
-
-                        for (i = 0; i < 13; i++)
-                                printk("I%d = %02x (new value)\n", i, sscape_read(devc, i));
-                }
-#endif
-
-        }
-        return 1;
-}
-
-static int download_boot_block(void *dev_info, copr_buffer * buf)
-{
-        if (buf->len <= 0 || buf->len > sizeof(buf->data))
-                return -EINVAL;
-
-        if (!sscape_download_boot(devc, buf->data, buf->len, buf->flags))
-        {
-                printk(KERN_ERR "soundscape: Unable to load microcode block to the OBP.\n");
-                return -EIO;
-        }
-        return 0;
-}
-
-static int sscape_coproc_ioctl(void *dev_info, unsigned int cmd, void __user *arg, int local)
-{
-        copr_buffer *buf;
-        int err;
-
-        switch (cmd) 
-        {
-                case SNDCTL_COPR_RESET:
-                        sscape_coproc_reset(dev_info);
-                        return 0;
-
-                case SNDCTL_COPR_LOAD:
-                        buf = (copr_buffer *) vmalloc(sizeof(copr_buffer));
-                        if (buf == NULL)
-                                return -ENOSPC;
-                        if (copy_from_user(buf, arg, sizeof(copr_buffer))) 
-                        {
-                                vfree(buf);
-                                return -EFAULT;
-                        }
-                        err = download_boot_block(dev_info, buf);
-                        vfree(buf);
-                        return err;
-                
-                default:
-                        return -EINVAL;
-        }
-}
-
-static coproc_operations sscape_coproc_operations =
-{
-        "SoundScape M68K",
-        THIS_MODULE,
-        sscape_coproc_open,
-        sscape_coproc_close,
-        sscape_coproc_ioctl,
-        sscape_coproc_reset,
-        &adev_info
-};
-
-static struct resource *sscape_ports;
-static int sscape_is_pnp;
-
-static void __init attach_sscape(struct address_info *hw_config)
-{
-#ifndef SSCAPE_REGS
-        /*
-         * Config register values for Spea/V7 Media FX and Ensoniq S-2000.
-         * These values are card
-         * dependent. If you have another SoundScape based card, you have to
-         * find the correct values. Do the following:
-         *  - Compile this driver with SSCAPE_DEBUG1 defined.
-         *  - Shut down and power off your machine.
-         *  - Boot with DOS so that the SSINIT.EXE program is run.
-         *  - Warm boot to {Linux|SYSV|BSD} and write down the lines displayed
-         *    when detecting the SoundScape.
-         *  - Modify the following list to use the values printed during boot.
-         *    Undefine the SSCAPE_DEBUG1
-         */
-#define SSCAPE_REGS { \
-/* I0 */        0x00, \
-/* I1 */        0xf0, /* Note! Ignored. Set always to 0xf0 */ \
-/* I2 */        0x20, /* Note! Ignored. Set always to 0x20 */ \
-/* I3 */        0x20, /* Note! Ignored. Set always to 0x20 */ \
-/* I4 */        0xf5, /* Ignored */ \
-/* I5 */        0x10, \
-/* I6 */        0x00, \
-/* I7 */        0x2e, /* I7 MEM config A. Likely to vary between models */ \
-/* I8 */        0x00, /* I8 MEM config B. Likely to vary between models */ \
-/* I9 */        0x40 /* Ignored */ \
-        }
-#endif
-
-        unsigned long   flags;
-        static unsigned char regs[10] = SSCAPE_REGS;
-
-        int i, irq_bits = 0xff;
-
-        if (old_hardware)
-        {
-                valid_interrupts = valid_interrupts_old;
-                conf_printf("Ensoniq SoundScape (old)", hw_config);
-        }
-        else
-                conf_printf("Ensoniq SoundScape", hw_config);
-
-        for (i = 0; i < 4; i++)
-        {
-                if (hw_config->irq == valid_interrupts[i])
-                {
-                        irq_bits = i;
-                        break;
-                }
-        }
-        if (hw_config->irq > 15 || (regs[4] = irq_bits == 0xff))
-        {
-                printk(KERN_ERR "Invalid IRQ%d\n", hw_config->irq);
-                release_region(devc->base, 2);
-                release_region(devc->base + 2, 6);
-                if (sscape_is_pnp)
-                        release_region(devc->codec, 2);
-                return;
-        }
-        
-        if (!sscape_is_pnp) {
-        
-                spin_lock_irqsave(&devc->lock,flags);
-                /* Host interrupt enable */
-                sscape_write(devc, 1, 0xf0);    /* All interrupts enabled */
-                /* DMA A status/trigger register */
-                sscape_write(devc, 2, 0x20);    /* DMA channel disabled */
-                /* DMA B status/trigger register */
-                sscape_write(devc, 3, 0x20);    /* DMA channel disabled */
-                /* Host interrupt config reg */
-                sscape_write(devc, 4, 0xf0 | (irq_bits << 2) | irq_bits);
-                /* Don't destroy CD-ROM DMA config bits (0xc0) */
-                sscape_write(devc, 5, (regs[5] & 0x3f) | (sscape_read(devc, 5) & 0xc0));
-                /* CD-ROM config (WSS codec actually) */
-                sscape_write(devc, 6, regs[6]);
-                sscape_write(devc, 7, regs[7]);
-                sscape_write(devc, 8, regs[8]);
-                /* Master control reg. Don't modify CR-ROM bits. Disable SB emul */
-                sscape_write(devc, 9, (sscape_read(devc, 9) & 0xf0) | 0x08);
-                spin_unlock_irqrestore(&devc->lock,flags);
-        }
-#ifdef SSCAPE_DEBUG2
-        /*
-         * Temporary debugging aid. Print contents of the registers after
-         * changing them.
-         */
-        {
-                int i;
-
-                for (i = 0; i < 13; i++)
-                        printk("I%d = %02x (new value)\n", i, sscape_read(devc, i));
-        }
-#endif
-
-        if (probe_mpu401(hw_config, sscape_ports))
-                hw_config->always_detect = 1;
-        hw_config->name = "SoundScape";
-
-        hw_config->irq *= -1;   /* Negative value signals IRQ sharing */
-        attach_mpu401(hw_config, THIS_MODULE);
-        hw_config->irq *= -1;   /* Restore it */
-
-        if (hw_config->slots[1] != -1)  /* The MPU driver installed itself */
-        {
-                sscape_mididev = hw_config->slots[1];
-                midi_devs[hw_config->slots[1]]->coproc = &sscape_coproc_operations;
-        }
-        sscape_write(devc, GA_INTENA_REG, 0x80);        /* Master IRQ enable */
-        devc->ok = 1;
-        devc->failed = 0;
-}
-
-static int detect_ga(sscape_info * devc)
-{
-        unsigned char save;
-
-        DDB(printk("Entered Soundscape detect_ga(%x)\n", devc->base));
-
-        /*
-         * First check that the address register of "ODIE" is
-         * there and that it has exactly 4 writable bits.
-         * First 4 bits
-         */
-        
-        if ((save = inb(PORT(ODIE_ADDR))) & 0xf0)
-        {
-                DDB(printk("soundscape: Detect error A\n"));
-                return 0;
-        }
-        outb((0x00), PORT(ODIE_ADDR));
-        if (inb(PORT(ODIE_ADDR)) != 0x00)
-        {
-                DDB(printk("soundscape: Detect error B\n"));
-                return 0;
-        }
-        outb((0xff), PORT(ODIE_ADDR));
-        if (inb(PORT(ODIE_ADDR)) != 0x0f)
-        {
-                DDB(printk("soundscape: Detect error C\n"));
-                return 0;
-        }
-        outb((save), PORT(ODIE_ADDR));
-
-        /*
-         * Now verify that some indirect registers return zero on some bits.
-         * This may break the driver with some future revisions of "ODIE" but...
-         */
-
-        if (sscape_read(devc, 0) & 0x0c)
-        {
-                DDB(printk("soundscape: Detect error D (%x)\n", sscape_read(devc, 0)));
-                return 0;
-        }
-        if (sscape_read(devc, 1) & 0x0f)
-        {
-                DDB(printk("soundscape: Detect error E\n"));
-                return 0;
-        }
-        if (sscape_read(devc, 5) & 0x0f)
-        {
-                DDB(printk("soundscape: Detect error F\n"));
-                return 0;
-        }
-        return 1;
-}
-
-static  int sscape_read_host_ctrl(sscape_info* devc)
-{
-        return host_read(devc);
-}
-
-static  void sscape_write_host_ctrl2(sscape_info *devc, int a, int b)
-{
-        host_command2(devc, a, b);
-}
-
-static int sscape_alloc_dma(sscape_info *devc)
-{
-        char *start_addr, *end_addr;
-        int dma_pagesize;
-        int sz, size;
-        struct page *page;
-
-        if (devc->raw_buf != NULL) return 0;    /* Already done */
-        dma_pagesize = (devc->dma < 4) ? (64 * 1024) : (128 * 1024);
-        devc->raw_buf = NULL;
-        devc->buffsize = 8192*4;
-        if (devc->buffsize > dma_pagesize) devc->buffsize = dma_pagesize;
-        start_addr = NULL;
-        /*
-         * Now loop until we get a free buffer. Try to get smaller buffer if
-         * it fails. Don't accept smaller than 8k buffer for performance
-         * reasons.
-         */
-        while (start_addr == NULL && devc->buffsize > PAGE_SIZE) {
-                for (sz = 0, size = PAGE_SIZE; size < devc->buffsize; sz++, size <<= 1);
-                devc->buffsize = PAGE_SIZE * (1 << sz);
-                start_addr = (char *) __get_free_pages(GFP_ATOMIC|GFP_DMA, sz);
-                if (start_addr == NULL) devc->buffsize /= 2;
-        }
-
-        if (start_addr == NULL) {
-                printk(KERN_ERR "sscape pnp init error: Couldn't allocate DMA buffer\n");
-                return 0;
-        } else {
-                /* make some checks */
-                end_addr = start_addr + devc->buffsize - 1;             
-                /* now check if it fits into the same dma-pagesize */
-
-                if (((long) start_addr & ~(dma_pagesize - 1)) != ((long) end_addr & ~(dma_pagesize - 1))
-                    || end_addr >= (char *) (MAX_DMA_ADDRESS)) {
-                        printk(KERN_ERR "sscape pnp: Got invalid address 0x%lx for %db DMA-buffer\n", (long) start_addr, devc->buffsize);
-                        return 0;
-                }
-        }
-        devc->raw_buf = start_addr;
-        devc->raw_buf_phys = virt_to_bus(start_addr);
-
-        for (page = virt_to_page(start_addr); page <= virt_to_page(end_addr); page++)
-                SetPageReserved(page);
-        return 1;
-}
-
-static void sscape_free_dma(sscape_info *devc)
-{
-        int sz, size;
-        unsigned long start_addr, end_addr;
-        struct page *page;
-
-        if (devc->raw_buf == NULL) return;
-        for (sz = 0, size = PAGE_SIZE; size < devc->buffsize; sz++, size <<= 1);
-        start_addr = (unsigned long) devc->raw_buf;
-        end_addr = start_addr + devc->buffsize;
-
-        for (page = virt_to_page(start_addr); page <= virt_to_page(end_addr); page++)
-                ClearPageReserved(page);
-
-        free_pages((unsigned long) devc->raw_buf, sz);
-        devc->raw_buf = NULL;
-}
-
-/* Intel version !!!!!!!!! */
-
-static int sscape_start_dma(int chan, unsigned long physaddr, int count, int dma_mode)
-{
-        unsigned long flags;
-
-        flags = claim_dma_lock();
-        disable_dma(chan);
-        clear_dma_ff(chan);
-        set_dma_mode(chan, dma_mode);
-        set_dma_addr(chan, physaddr);
-        set_dma_count(chan, count);
-        enable_dma(chan);
-        release_dma_lock(flags);
-        return 0;
-}
-
-static void sscape_pnp_start_dma(sscape_info* devc, int arg )
-{
-        int reg;
-        if (arg == 0) reg = 2;
-        else reg = 3;
-
-        sscape_write(devc, reg, sscape_read( devc, reg) | 0x01);
-        sscape_write(devc, reg, sscape_read( devc, reg) & 0xFE);
-}
-
-static int sscape_pnp_wait_dma (sscape_info* devc, int arg )
-{
-        int             reg;
-        unsigned long   i;
-        unsigned char   d;
-
-        if (arg == 0) reg = 2;
-        else reg = 3;
-
-        sleep ( 1 );
-        i = 0;
-        do {
-                d = sscape_read(devc, reg) & 1;
-                if ( d == 1)  break;
-                i++;
-        } while (i < 500000);
-        d = sscape_read(devc, reg) & 1; 
-        return d;
-}
-
-static  int     sscape_pnp_alloc_dma(sscape_info* devc)
-{
-        /* printk(KERN_INFO "sscape: requesting dma\n"); */
-        if (request_dma(devc -> dma, "sscape")) return 0;
-        /* printk(KERN_INFO "sscape: dma channel allocated\n"); */
-        if (!sscape_alloc_dma(devc)) {
-                free_dma(devc -> dma);
-                return 0;
-        };
-        return 1;
-}
-
-static  void    sscape_pnp_free_dma(sscape_info* devc)
-{
-        sscape_free_dma( devc);
-        free_dma(devc -> dma ); 
-        /* printk(KERN_INFO "sscape: dma released\n"); */
-}
-
-static  int     sscape_pnp_upload_file(sscape_info* devc, char* fn)
-{       
-        int             done = 0;
-        int             timeout_val;
-        char*           data,*dt;
-        int             len,l;
-        unsigned long   flags;
-
-        sscape_write( devc, 9, sscape_read(devc, 9 )  & 0x3F );
-        sscape_write( devc, 2, (devc -> dma << 4) | 0x80 );
-        sscape_write( devc, 3, 0x20 );
-        sscape_write( devc, 9, sscape_read( devc, 9 )  | 0x80 );
-        
-        len = mod_firmware_load(fn, &data);
-        if (len == 0) {
-                    printk(KERN_ERR "sscape: file not found: %s\n", fn);
-                    return 0;
-        }
-        dt = data;
-        spin_lock_irqsave(&devc->lock,flags);
-        while ( len > 0 ) {
-                if (len > devc -> buffsize) l = devc->buffsize;
-                else l = len;
-                len -= l;               
-                memcpy(devc->raw_buf, dt, l); dt += l;
-                sscape_start_dma(devc->dma, devc->raw_buf_phys, l, 0x48);
-                sscape_pnp_start_dma ( devc, 0 );
-                if (sscape_pnp_wait_dma ( devc, 0 ) == 0) {
-                        spin_unlock_irqrestore(&devc->lock,flags);
-                        return 0;
-                }
-        }
-        
-        spin_unlock_irqrestore(&devc->lock,flags);
-        vfree(data);
-        
-        outb(0, devc -> base + 2);
-        outb(0, devc -> base);
-
-        sscape_write ( devc, 9, sscape_read( devc, 9 ) | 0x40);
-
-        timeout_val = 5 * HZ; 
-        while (!done && timeout_val-- > 0)
-        {
-                unsigned char x;
-                sleep(1);
-                x = inb( devc -> base + 3);
-                if (x == 0xff || x == 0xfe)             /* OBP startup acknowledge */
-                {
-                        //printk(KERN_ERR "Soundscape: Acknowledge = %x\n", x);
-                        done = 1;
-                }
-        }
-        timeout_val = 5 * HZ;
-        done = 0;
-        while (!done && timeout_val-- > 0)
-        {
-                unsigned char x;
-                sleep(1);
-                x = inb( devc -> base + 3);
-                if (x == 0xfe)          /* OBP startup acknowledge */
-                {
-                        //printk(KERN_ERR "Soundscape: Acknowledge = %x\n", x);
-                        done = 1;
-                }
-        }
-
-        if ( !done ) printk(KERN_ERR "soundscape: OBP Initialization failed.\n");
-
-        sscape_write( devc, 2, devc->ic_type == IC_ODIE ? 0x70 : 0x40);
-        sscape_write( devc, 3, (devc -> dma << 4) + 0x80);
-        return 1;
-}
-
-static void __init sscape_pnp_init_hw(sscape_info* devc)
-{       
-        unsigned char midi_irq = 0, sb_irq = 0;
-        unsigned i;
-        static  char code_file_name[23] = "/sndscape/sndscape.cox";
-        
-        int sscape_joystic_enable       = 0x7f;
-        int sscape_mic_enable           = 0;
-        int sscape_ext_midi             = 0;            
-
-        if ( !sscape_pnp_alloc_dma(devc) ) {
-                printk(KERN_ERR "sscape: faild to allocate dma\n");
-                return;
-        }
-
-        for (i = 0; i < 4; i++) {
-                if ( devc -> irq   == valid_interrupts[i] ) 
-                        midi_irq = i;
-                if ( devc -> codec_irq == valid_interrupts[i] ) 
-                        sb_irq = i;
-        }
-
-        sscape_write( devc, 5, 0x50);
-        sscape_write( devc, 7, 0x2e);
-        sscape_write( devc, 8, 0x00);
-
-        sscape_write( devc, 2, devc->ic_type == IC_ODIE ? 0x70 : 0x40);
-        sscape_write( devc, 3, ( devc -> dma << 4) | 0x80);
-
-        sscape_write (devc, 4, 0xF0 | (midi_irq<<2) | midi_irq);
-
-        i = 0x10; //sscape_read(devc, 9) & (devc->ic_type == IC_ODIE ? 0xf0 : 0xc0);
-        if (sscape_joystic_enable) i |= 8;
-        
-        sscape_write (devc, 9, i);
-        sscape_write (devc, 6, 0x80);
-        sscape_write (devc, 1, 0x80);
-
-        if (devc -> codec_type == 2) {
-                sscape_pnp_write_codec( devc, 0x0C, 0x50);
-                sscape_pnp_write_codec( devc, 0x10, sscape_pnp_read_codec( devc, 0x10) & 0x3F);
-                sscape_pnp_write_codec( devc, 0x11, sscape_pnp_read_codec( devc, 0x11) | 0xC0);
-                sscape_pnp_write_codec( devc, 29, 0x20);
-        }
-
-        if (sscape_pnp_upload_file(devc, "/sndscape/scope.cod") == 0 ) {
-                printk(KERN_ERR "sscape: faild to upload file /sndscape/scope.cod\n");
-                sscape_pnp_free_dma(devc);
-                return;
-        }
-
-        i = sscape_read_host_ctrl( devc );
-        
-        if ( (i & 0x0F) >  7 ) {
-                printk(KERN_ERR "sscape: scope.cod faild\n");
-                sscape_pnp_free_dma(devc);
-                return;
-        }
-        if ( i & 0x10 ) sscape_write( devc, 7, 0x2F);
-        code_file_name[21] = (char) ( i & 0x0F) + 0x30;
-        if (sscape_pnp_upload_file( devc, code_file_name) == 0) {
-                printk(KERN_ERR "sscape: faild to upload file %s\n", code_file_name);
-                sscape_pnp_free_dma(devc);
-                return;
-        }
-        
-        if (devc->ic_type != IC_ODIE) {
-                sscape_pnp_write_codec( devc, 10, (sscape_pnp_read_codec(devc, 10) & 0x7f) |
-                 ( sscape_mic_enable == 0 ? 0x00 : 0x80) );
-        }
-        sscape_write_host_ctrl2( devc, 0x84, 0x64 );  /* MIDI volume */
-        sscape_write_host_ctrl2( devc, 0x86, 0x64 );  /* MIDI volume?? */
-        sscape_write_host_ctrl2( devc, 0x8A, sscape_ext_midi);
-
-        sscape_pnp_write_codec ( devc, 6, 0x3f ); //WAV_VOL
-        sscape_pnp_write_codec ( devc, 7, 0x3f ); //WAV_VOL
-        sscape_pnp_write_codec ( devc, 2, 0x1F ); //WD_CDXVOLL
-        sscape_pnp_write_codec ( devc, 3, 0x1F ); //WD_CDXVOLR
-
-        if (devc -> codec_type == 1) {
-                sscape_pnp_write_codec ( devc, 4, 0x1F );
-                sscape_pnp_write_codec ( devc, 5, 0x1F );
-                sscape_write_host_ctrl2( devc, 0x88, sscape_mic_enable);
-        } else {
-                int t;
-                sscape_pnp_write_codec ( devc, 0x10, 0x1F << 1);
-                sscape_pnp_write_codec ( devc, 0x11, 0xC0 | (0x1F << 1));
-
-                t = sscape_pnp_read_codec( devc, 0x00) & 0xDF;
-                if ( (sscape_mic_enable == 0)) t |= 0;
-                else t |= 0x20;
-                sscape_pnp_write_codec ( devc, 0x00, t);
-                t = sscape_pnp_read_codec( devc, 0x01) & 0xDF;
-                if ( (sscape_mic_enable == 0) ) t |= 0;
-                else t |= 0x20;
-                sscape_pnp_write_codec ( devc, 0x01, t);
-                sscape_pnp_write_codec ( devc, 0x40 | 29 , 0x20);
-                outb(0, devc -> codec);
-        }
-        if (devc -> ic_type == IC_OPUS ) {
-                int i = sscape_read( devc, 9 );
-                sscape_write( devc, 9, i | 3 );
-                sscape_write( devc, 3, 0x40);
-
-                if (request_region(0x228, 1, "sscape setup junk")) {
-                        outb(0, 0x228);
-                        release_region(0x228,1);
-                }
-                sscape_write( devc, 3, (devc -> dma << 4) | 0x80);
-                sscape_write( devc, 9, i );
-        }
-        
-        host_close ( devc );
-        sscape_pnp_free_dma(devc);
-}
-
-static int __init detect_sscape_pnp(sscape_info* devc)
-{
-        long     i, irq_bits = 0xff;
-        unsigned int d;
-
-        DDB(printk("Entered detect_sscape_pnp(%x)\n", devc->base));
-
-        if (!request_region(devc->codec, 2, "sscape codec")) {
-                printk(KERN_ERR "detect_sscape_pnp: port %x is not free\n", devc->codec);       
-                return 0;
-        }
-
-        if ((inb(devc->base + 2) & 0x78) != 0)
-                goto fail;
-
-        d = inb ( devc -> base + 4) & 0xF0;
-        if (d & 0x80)
-                goto fail;
-        
-        if (d == 0) {
-                devc->codec_type = 1;
-                devc->ic_type = IC_ODIE;
-        } else if ( (d & 0x60) != 0) {
-                devc->codec_type = 2;
-                devc->ic_type = IC_OPUS;
-        } else if ( (d & 0x40) != 0) {  /* WTF? */
-                devc->codec_type = 2;
-                devc->ic_type = IC_ODIE;
-        } else
-                goto fail;
-        
-        sscape_is_pnp = 1;
-                
-        outb(0xFA, devc -> base+4);
-        if  ((inb( devc -> base+4) & 0x9F) != 0x0A)
-                goto fail;
-        outb(0xFE, devc -> base+4);
-        if  ( (inb(devc -> base+4) & 0x9F) != 0x0E)
-                goto fail;
-        if  ( (inb(devc -> base+5) & 0x9F) != 0x0E)
-                goto fail;
-
-        if (devc->codec_type == 2) {
-                if (devc->codec != devc->base + 8) {
-                        printk("soundscape warning: incorrect codec port specified\n");
-                        goto fail;
-                }
-                d = 0x10 | (sscape_read(devc, 9)  & 0xCF);
-                sscape_write(devc, 9, d);
-                sscape_write(devc, 6, 0x80);
-        } else {
-                //todo: check codec is not base + 8
-        }
-
-        d  = (sscape_read(devc, 9) & 0x3F) | 0xC0;
-        sscape_write(devc, 9, d);
-
-        for (i = 0; i < 550000; i++)
-                if ( !(inb(devc -> codec) & 0x80) ) break;
-
-        d = inb(devc -> codec);
-        if (d & 0x80)
-                goto fail;
-        if ( inb(devc -> codec + 2) == 0xFF)
-                goto fail;
-
-        sscape_write(devc, 9, sscape_read(devc, 9)  & 0x3F );
-
-        d  = inb(devc -> codec) & 0x80;
-        if ( d == 0) {
-                printk(KERN_INFO "soundscape: hardware detected\n");
-                valid_interrupts = valid_interrupts_new;
-        } else  {
-                printk(KERN_INFO "soundscape: board looks like media fx\n");
-                valid_interrupts = valid_interrupts_old;
-                old_hardware = 1;
-        }
-
-        sscape_write( devc, 9, 0xC0 | (sscape_read(devc, 9)  & 0x3F) );
-
-        for (i = 0; i < 550000; i++)
-                if ( !(inb(devc -> codec) & 0x80)) 
-                        break;
-                
-        sscape_pnp_init_hw(devc);
-
-        for (i = 0; i < 4; i++)
-        {
-                if (devc->codec_irq == valid_interrupts[i]) {
-                        irq_bits = i;
-                        break;
-                }
-        }       
-        sscape_write(devc, GA_INTENA_REG, 0x00);
-        sscape_write(devc, GA_DMACFG_REG, 0x50);
-        sscape_write(devc, GA_DMAA_REG, 0x70);
-        sscape_write(devc, GA_DMAB_REG, 0x20);
-        sscape_write(devc, GA_INTCFG_REG, 0xf0);
-        sscape_write(devc, GA_CDCFG_REG, 0x89 | (devc->dma << 4) | (irq_bits << 1));
-
-        sscape_pnp_write_codec( devc, 0, sscape_pnp_read_codec( devc, 0) | 0x20);
-        sscape_pnp_write_codec( devc, 0, sscape_pnp_read_codec( devc, 1) | 0x20);
-
-        return 1;
-fail:
-        release_region(devc->codec, 2);
-        return 0;
-}
-
-static int __init probe_sscape(struct address_info *hw_config)
-{
-        devc->base = hw_config->io_base;
-        devc->irq = hw_config->irq;
-        devc->dma = hw_config->dma;
-        devc->osp = hw_config->osp;
-
-#ifdef SSCAPE_DEBUG1
-        /*
-         * Temporary debugging aid. Print contents of the registers before
-         * changing them.
-         */
-        {
-                int i;
-
-                for (i = 0; i < 13; i++)
-                        printk("I%d = %02x (old value)\n", i, sscape_read(devc, i));
-        }
-#endif
-        devc->failed = 1;
-
-        sscape_ports = request_region(devc->base, 2, "mpu401");
-        if (!sscape_ports)
-                return 0;
-
-        if (!request_region(devc->base + 2, 6, "SoundScape")) {
-                release_region(devc->base, 2);
-                return 0;
-        }
-
-        if (!detect_ga(devc)) {
-                if (detect_sscape_pnp(devc))
-                        return 1;
-                release_region(devc->base, 2);
-                release_region(devc->base + 2, 6);
-                return 0;
-        }
-
-        if (old_hardware)       /* Check that it's really an old Spea/Reveal card. */
-        {
-                unsigned char   tmp;
-                int             cc;
-
-                if (!((tmp = sscape_read(devc, GA_HMCTL_REG)) & 0xc0))
-                {
-                        sscape_write(devc, GA_HMCTL_REG, tmp | 0x80);
-                        for (cc = 0; cc < 200000; ++cc)
-                                inb(devc->base + ODIE_ADDR);
-                }
-        }
-        return 1;
-}
-
-static int __init init_ss_ms_sound(struct address_info *hw_config)
-{
-        int i, irq_bits = 0xff;
-        int ad_flags = 0;
-        struct resource *ports;
-        
-        if (devc->failed)
-        {
-                printk(KERN_ERR "soundscape: Card not detected\n");
-                return 0;
-        }
-        if (devc->ok == 0)
-        {
-                printk(KERN_ERR "soundscape: Invalid initialization order.\n");
-                return 0;
-        }
-        for (i = 0; i < 4; i++)
-        {
-                if (hw_config->irq == valid_interrupts[i])
-                {
-                        irq_bits = i;
-                        break;
-                }
-        }
-        if (irq_bits == 0xff) {
-                printk(KERN_ERR "soundscape: Invalid MSS IRQ%d\n", hw_config->irq);
-                return 0;
-        }
-        
-        if (old_hardware)
-                ad_flags = 0x12345677;  /* Tell that we may have a CS4248 chip (Spea-V7 Media FX) */
-        else if (sscape_is_pnp)
-                ad_flags = 0x87654321;  /* Tell that we have a soundscape pnp with 1845 chip */
-
-        ports = request_region(hw_config->io_base, 4, "ad1848");
-        if (!ports) {
-                printk(KERN_ERR "soundscape: ports busy\n");
-                return 0;
-        }
-
-        if (!ad1848_detect(ports, &ad_flags, hw_config->osp)) {
-                release_region(hw_config->io_base, 4);
-                return 0;
-        }
-
-        if (!sscape_is_pnp)  /*pnp is already setup*/
-        {
-                /*
-                 * Setup the DMA polarity.
-                 */
-                sscape_write(devc, GA_DMACFG_REG, 0x50);
-        
-                /*
-                 * Take the gate-array off of the DMA channel.
-                 */
-                sscape_write(devc, GA_DMAB_REG, 0x20);
-        
-                /*
-                 * Init the AD1848 (CD-ROM) config reg.
-                 */
-                sscape_write(devc, GA_CDCFG_REG, 0x89 | (hw_config->dma << 4) | (irq_bits << 1));
-        }
-        
-        if (hw_config->irq == devc->irq)
-                printk(KERN_WARNING "soundscape: Warning! The WSS mode can't share IRQ with MIDI\n");
-                                
-        hw_config->slots[0] = ad1848_init(
-                        sscape_is_pnp ? "SoundScape" : "SoundScape PNP",
-                        ports,
-                        hw_config->irq,
-                        hw_config->dma,
-                        hw_config->dma,
-                        0,
-                        devc->osp,
-                        THIS_MODULE);
-
-                                          
-        if (hw_config->slots[0] != -1)  /* The AD1848 driver installed itself */
-        {
-                audio_devs[hw_config->slots[0]]->coproc = &sscape_coproc_operations;
-                devc->codec_audiodev = hw_config->slots[0];
-                devc->my_audiodev = hw_config->slots[0];
-
-                /* Set proper routings here (what are they) */
-                AD1848_REROUTE(SOUND_MIXER_LINE1, SOUND_MIXER_LINE);
-        }
-                
-#ifdef SSCAPE_DEBUG5
-        /*
-         * Temporary debugging aid. Print contents of the registers
-         * after the AD1848 device has been initialized.
-         */
-        {
-                int i;
-
-                for (i = 0; i < 13; i++)
-                        printk("I%d = %02x\n", i, sscape_read(devc, i));
-        }
-#endif
-        return 1;
-}
-
-static void __exit unload_sscape(struct address_info *hw_config)
-{
-        release_region(devc->base + 2, 6);
-        unload_mpu401(hw_config);
-        if (sscape_is_pnp)
-                release_region(devc->codec, 2);
-}
-
-static void __exit unload_ss_ms_sound(struct address_info *hw_config)
-{
-        ad1848_unload(hw_config->io_base,
-                      hw_config->irq,
-                      devc->dma,
-                      devc->dma,
-                      0);
-        sound_unload_audiodev(hw_config->slots[0]);
-}
-
-static struct address_info cfg;
-static struct address_info cfg_mpu;
-
-static int __initdata spea = -1;
-static int mss = 0;
-static int __initdata dma = -1;
-static int __initdata irq = -1;
-static int __initdata io = -1;
-static int __initdata mpu_irq = -1;
-static int __initdata mpu_io = -1;
-
-module_param(dma, int, 0);
-module_param(irq, int, 0);
-module_param(io, int, 0);
-module_param(spea, int, 0);             /* spea=0/1 set the old_hardware */
-module_param(mpu_irq, int, 0);
-module_param(mpu_io, int, 0);
-module_param(mss, int, 0);
-
-static int __init init_sscape(void)
-{
-        printk(KERN_INFO "Soundscape driver Copyright (C) by Hannu Savolainen 1993-1996\n");
-        
-        cfg.irq = irq;
-        cfg.dma = dma;
-        cfg.io_base = io;
-
-        cfg_mpu.irq = mpu_irq;
-        cfg_mpu.io_base = mpu_io;
-        /* WEH - Try to get right dma channel */
-        cfg_mpu.dma = dma;
-        
-        devc->codec = cfg.io_base;
-        devc->codec_irq = cfg.irq;
-        devc->codec_type = 0;
-        devc->ic_type = 0;
-        devc->raw_buf = NULL;
-        spin_lock_init(&devc->lock);
-
-        if (cfg.dma == -1 || cfg.irq == -1 || cfg.io_base == -1) {
-                printk(KERN_ERR "DMA, IRQ, and IO port must be specified.\n");
-                return -EINVAL;
-        }
-        
-        if (cfg_mpu.irq == -1 && cfg_mpu.io_base != -1) {
-                printk(KERN_ERR "MPU_IRQ must be specified if MPU_IO is set.\n");
-                return -EINVAL;
-        }
-        
-        if(spea != -1) {
-                old_hardware = spea;
-                printk(KERN_INFO "Forcing %s hardware support.\n",
-                        spea?"new":"old");
-        }       
-        if (probe_sscape(&cfg_mpu) == 0)
-                return -ENODEV;
-
-        attach_sscape(&cfg_mpu);
-        
-        mss = init_ss_ms_sound(&cfg);
-
-        return 0;
-}
-
-static void __exit cleanup_sscape(void)
-{
-        if (mss)
-                unload_ss_ms_sound(&cfg);
-        unload_sscape(&cfg_mpu);
-}
-
-module_init(init_sscape);
-module_exit(cleanup_sscape);
-
-#ifndef MODULE
-static int __init setup_sscape(char *str)
-{
-        /* io, irq, dma, mpu_io, mpu_irq */
-        int ints[6];
-        
-        str = get_options(str, ARRAY_SIZE(ints), ints);
-        
-        io      = ints[1];
-        irq     = ints[2];
-        dma     = ints[3];
-        mpu_io  = ints[4];
-        mpu_irq = ints[5];
-
-        return 1;
-}
-
-__setup("sscape=", setup_sscape);
-#endif
-MODULE_LICENSE("GPL");
diff --git a/sound/oss/uart401.c b/sound/oss/uart401.c
index a446b826d5fc..8e514a676a0d 100644
--- a/sound/oss/uart401.c
+++ b/sound/oss/uart401.c
@@ -24,6 +24,7 @@
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/spinlock.h>
 #include "sound_config.h"
 
diff --git a/sound/oss/v_midi.c b/sound/oss/v_midi.c
index 103940fd5b4f..f0b4151d9b17 100644
--- a/sound/oss/v_midi.c
+++ b/sound/oss/v_midi.c
@@ -21,6 +21,7 @@
 
 #include <linux/init.h>
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/spinlock.h>
 #include "sound_config.h"
 
diff --git a/sound/oss/v_midi.h b/sound/oss/v_midi.h
index 1b86cb45c607..08e2185ee816 100644
--- a/sound/oss/v_midi.h
+++ b/sound/oss/v_midi.h
@@ -2,9 +2,9 @@ typedef struct vmidi_devc {
            int dev;
 
         /* State variables */
-           int opened;
+           int opened;
            spinlock_t lock;
-        
+
         /* MIDI fields */
            int my_mididev;
            int pair_mididev;
@@ -12,4 +12,3 @@ typedef struct vmidi_devc {
            int intr_active;
            void (*midi_input_intr) (int dev, unsigned char data);
         } vmidi_devc;
-
diff --git a/sound/oss/vidc.c b/sound/oss/vidc.c
index 725fef0f59a3..ac39a531df19 100644
--- a/sound/oss/vidc.c
+++ b/sound/oss/vidc.c
@@ -17,6 +17,7 @@
  * We currently support a mixer device, but it is currently non-functional.
  */
 
+#include <linux/gfp.h>
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
@@ -363,13 +364,13 @@ static void vidc_audio_trigger(int dev, int enable_bits)
         struct audio_operations *adev = audio_devs[dev];
 
         if (enable_bits & PCM_ENABLE_OUTPUT) {
-                if (!(adev->flags & DMA_ACTIVE)) {
+                if (!(adev->dmap_out->flags & DMA_ACTIVE)) {
                         unsigned long flags;
 
                         local_irq_save(flags);
 
                         /* prevent recusion */
-                        adev->flags |= DMA_ACTIVE;
+                        adev->dmap_out->flags |= DMA_ACTIVE;
 
                         dma_interrupt = vidc_audio_dma_interrupt;
                         vidc_sound_dma_irq(0, NULL);
diff --git a/sound/oss/vwsnd.c b/sound/oss/vwsnd.c
index 6713110bdc75..20b3b325aa80 100644
--- a/sound/oss/vwsnd.c
+++ b/sound/oss/vwsnd.c
@@ -149,6 +149,7 @@
 #include <linux/wait.h>
 #include <linux/interrupt.h>
 #include <linux/mutex.h>
+#include <linux/slab.h>
 
 #include <asm/visws/cobalt.h>
 
diff --git a/sound/oss/waveartist.c b/sound/oss/waveartist.c
index 2c63bb9da74a..e688dde6bbde 100644
--- a/sound/oss/waveartist.c
+++ b/sound/oss/waveartist.c
@@ -35,6 +35,7 @@
 
 #include <linux/module.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <linux/sched.h>
 #include <linux/interrupt.h>
 #include <linux/delay.h>
diff --git a/sound/pci/Kconfig b/sound/pci/Kconfig
index 75c602b5b132..1298c68d6bf0 100644
--- a/sound/pci/Kconfig
+++ b/sound/pci/Kconfig
@@ -570,6 +570,7 @@ config SND_ICE1712
         tristate "ICEnsemble ICE1712 (Envy24)"
         select SND_MPU401_UART
         select SND_AC97_CODEC
+        select BITREVERSE
         help
           Say Y here to include support for soundcards based on the
           ICE1712 (Envy24) chip.
@@ -788,6 +789,7 @@ config SND_VIRTUOSO
           Say Y here to include support for sound cards based on the
           Asus AV100/AV200 chips, i.e., Xonar D1, DX, D2, D2X,
           Essence ST (Deluxe), and Essence STX.
+          Support for the DS is experimental.
           Support for the HDAV1.3 (Deluxe) is very experimental.
 
           To compile this driver as a module, choose M here: the module
diff --git a/sound/pci/ac97/ac97_codec.c b/sound/pci/ac97/ac97_codec.c
index 78288dbfc17a..a7630e9edf8a 100644
--- a/sound/pci/ac97/ac97_codec.c
+++ b/sound/pci/ac97/ac97_codec.c
@@ -83,6 +83,7 @@ static const struct ac97_codec_id snd_ac97_codec_id_vendors[] = {
 { 0x4e534300, 0xffffff00, "National Semiconductor", NULL, NULL },
 { 0x50534300, 0xffffff00, "Philips",            NULL,   NULL },
 { 0x53494c00, 0xffffff00, "Silicon Laboratory", NULL,   NULL },
+{ 0x53544d00, 0xffffff00, "STMicroelectronics", NULL,   NULL },
 { 0x54524100, 0xffffff00, "TriTech",            NULL,   NULL },
 { 0x54584e00, 0xffffff00, "Texas Instruments",  NULL,   NULL },
 { 0x56494100, 0xffffff00, "VIA Technologies",   NULL,   NULL },
@@ -161,6 +162,7 @@ static const struct ac97_codec_id snd_ac97_codec_ids[] = {
 { 0x4e534350, 0xffffffff, "LM4550",             patch_lm4550,   NULL }, // volume wrap fix 
 { 0x50534304, 0xffffffff, "UCB1400",            patch_ucb1400,  NULL },
 { 0x53494c20, 0xffffffe0, "Si3036,8",           mpatch_si3036,  mpatch_si3036, AC97_MODEM_PATCH },
+{ 0x53544d02, 0xffffffff, "ST7597",             NULL,           NULL },
 { 0x54524102, 0xffffffff, "TR28022",            NULL,           NULL },
 { 0x54524103, 0xffffffff, "TR28023",            NULL,           NULL },
 { 0x54524106, 0xffffffff, "TR28026",            NULL,           NULL },
@@ -213,6 +215,14 @@ static int snd_ac97_valid_reg(struct snd_ac97 *ac97, unsigned short reg)
 {
         /* filter some registers for buggy codecs */
         switch (ac97->id) {
+        case AC97_ID_ST_AC97_ID4:
+                if (reg == 0x08)
+                        return 0;
+                /* fall through */
+        case AC97_ID_ST7597:
+                if (reg == 0x22 || reg == 0x7a)
+                        return 1;
+                /* fall through */
         case AC97_ID_AK4540:
         case AC97_ID_AK4542:
                 if (reg <= 0x1c || reg == 0x20 || reg == 0x26 || reg >= 0x7c)
@@ -603,8 +613,8 @@ AC97_SINGLE("Tone Control - Treble", AC97_MASTER_TONE, 0, 15, 1)
 };
 
 static const struct snd_kcontrol_new snd_ac97_controls_pc_beep[2] = {
-AC97_SINGLE("PC Speaker Playback Switch", AC97_PC_BEEP, 15, 1, 1),
-AC97_SINGLE("PC Speaker Playback Volume", AC97_PC_BEEP, 1, 15, 1)
+AC97_SINGLE("Beep Playback Switch", AC97_PC_BEEP, 15, 1, 1),
+AC97_SINGLE("Beep Playback Volume", AC97_PC_BEEP, 1, 15, 1)
 };
 
 static const struct snd_kcontrol_new snd_ac97_controls_mic_boost =
@@ -1393,7 +1403,7 @@ static int snd_ac97_mixer_build(struct snd_ac97 * ac97)
                 }
         }
         
-        /* build PC Speaker controls */
+        /* build Beep controls */
         if (!(ac97->flags & AC97_HAS_NO_PC_BEEP) && 
                 ((ac97->flags & AC97_HAS_PC_BEEP) ||
             snd_ac97_try_volume_mix(ac97, AC97_PC_BEEP))) {
@@ -2122,7 +2132,7 @@ int snd_ac97_mixer(struct snd_ac97_bus *bus, struct snd_ac97_template *template,
                 }
                 /* nothing should be in powerdown mode */
                 snd_ac97_write_cache(ac97, AC97_GENERAL_PURPOSE, 0);
-                end_time = jiffies + msecs_to_jiffies(120);
+                end_time = jiffies + msecs_to_jiffies(5000);
                 do {
                         if ((snd_ac97_read(ac97, AC97_POWERDOWN) & 0x0f) == 0x0f)
                                 goto __ready_ok;
diff --git a/sound/pci/ac97/ac97_id.h b/sound/pci/ac97/ac97_id.h
index c129492c82b3..d603147c4a96 100644
--- a/sound/pci/ac97/ac97_id.h
+++ b/sound/pci/ac97/ac97_id.h
@@ -62,3 +62,5 @@
 #define AC97_ID_CM9761_78       0x434d4978
 #define AC97_ID_CM9761_82       0x434d4982
 #define AC97_ID_CM9761_83       0x434d4983
+#define AC97_ID_ST7597          0x53544d02
+#define AC97_ID_ST_AC97_ID4     0x53544d04
diff --git a/sound/pci/ac97/ac97_patch.c b/sound/pci/ac97/ac97_patch.c
index 7337abdbe4e3..e68c98ef4041 100644
--- a/sound/pci/ac97/ac97_patch.c
+++ b/sound/pci/ac97/ac97_patch.c
@@ -544,25 +544,10 @@ static int patch_wolfson04(struct snd_ac97 * ac97)
         return 0;
 }
 
-static int patch_wolfson_wm9705_specific(struct snd_ac97 * ac97)
-{
-        int err, i;
-        for (i = 0; i < ARRAY_SIZE(wm97xx_snd_ac97_controls); i++) {
-                if ((err = snd_ctl_add(ac97->bus->card, snd_ac97_cnew(&wm97xx_snd_ac97_controls[i], ac97))) < 0)
-                        return err;
-        }
-        snd_ac97_write_cache(ac97,  0x72, 0x0808);
-        return 0;
-}
-
-static struct snd_ac97_build_ops patch_wolfson_wm9705_ops = {
-        .build_specific = patch_wolfson_wm9705_specific,
-};
-
 static int patch_wolfson05(struct snd_ac97 * ac97)
 {
         /* WM9705, WM9710 */
-        ac97->build_ops = &patch_wolfson_wm9705_ops;
+        ac97->build_ops = &patch_wolfson_wm9703_ops;
 #ifdef CONFIG_TOUCHSCREEN_WM9705
         /* WM9705 touchscreen uses AUX and VIDEO for touch */
         ac97->flags |= AC97_HAS_NO_VIDEO | AC97_HAS_NO_AUX;
@@ -800,12 +785,12 @@ AC97_SINGLE("Mono Switch", AC97_MASTER_TONE, 7, 1, 1),
 AC97_SINGLE("Mono ZC Switch", AC97_MASTER_TONE, 6, 1, 0),
 AC97_SINGLE("Mono Volume", AC97_MASTER_TONE, 0, 31, 1),
 
-AC97_SINGLE("PC Beep to Headphone Switch", AC97_AUX, 15, 1, 1),
-AC97_SINGLE("PC Beep to Headphone Volume", AC97_AUX, 12, 7, 1),
-AC97_SINGLE("PC Beep to Master Switch", AC97_AUX, 11, 1, 1),
-AC97_SINGLE("PC Beep to Master Volume", AC97_AUX, 8, 7, 1),
-AC97_SINGLE("PC Beep to Mono Switch", AC97_AUX, 7, 1, 1),
-AC97_SINGLE("PC Beep to Mono Volume", AC97_AUX, 4, 7, 1),
+AC97_SINGLE("Beep to Headphone Switch", AC97_AUX, 15, 1, 1),
+AC97_SINGLE("Beep to Headphone Volume", AC97_AUX, 12, 7, 1),
+AC97_SINGLE("Beep to Master Switch", AC97_AUX, 11, 1, 1),
+AC97_SINGLE("Beep to Master Volume", AC97_AUX, 8, 7, 1),
+AC97_SINGLE("Beep to Mono Switch", AC97_AUX, 7, 1, 1),
+AC97_SINGLE("Beep to Mono Volume", AC97_AUX, 4, 7, 1),
 
 AC97_SINGLE("Voice to Headphone Switch", AC97_PCM, 15, 1, 1),
 AC97_SINGLE("Voice to Headphone Volume", AC97_PCM, 12, 7, 1),
@@ -1867,11 +1852,14 @@ static unsigned int ad1981_jacks_blacklist[] = {
         0x10140523, /* Thinkpad R40 */
         0x10140534, /* Thinkpad X31 */
         0x10140537, /* Thinkpad T41p */
+        0x1014053e, /* Thinkpad R40e */
         0x10140554, /* Thinkpad T42p/R50p */
         0x10140567, /* Thinkpad T43p 2668-G7U */
         0x10140581, /* Thinkpad X41-2527 */
+        0x10280160, /* Dell Dimension 2400 */
         0x104380b0, /* Asus A7V8X-MX */
         0x11790241, /* Toshiba Satellite A-15 S127 */
+        0x1179ff10, /* Toshiba P500 */
         0x144dc01a, /* Samsung NP-X20C004/SEG */
         0 /* end */
 };
diff --git a/sound/pci/ac97/ac97_proc.c b/sound/pci/ac97/ac97_proc.c
index 73b17d526c8b..6320bf084e47 100644
--- a/sound/pci/ac97/ac97_proc.c
+++ b/sound/pci/ac97/ac97_proc.c
@@ -22,7 +22,6 @@
  *
  */
 
-#include <linux/slab.h>
 #include <linux/mutex.h>
 
 #include <sound/core.h>
diff --git a/sound/pci/ad1889.c b/sound/pci/ad1889.c
index 8f5098f92c37..4382d0fa6b9a 100644
--- a/sound/pci/ad1889.c
+++ b/sound/pci/ad1889.c
@@ -1048,7 +1048,7 @@ snd_ad1889_remove(struct pci_dev *pci)
         pci_set_drvdata(pci, NULL);
 }
 
-static struct pci_device_id snd_ad1889_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_ad1889_ids) = {
         { PCI_DEVICE(PCI_VENDOR_ID_ANALOG_DEVICES, PCI_DEVICE_ID_AD1889JS) },
         { 0, },
 };
diff --git a/sound/pci/ali5451/ali5451.c b/sound/pci/ali5451/ali5451.c
index aaf4da68969c..5c6e322a48f0 100644
--- a/sound/pci/ali5451/ali5451.c
+++ b/sound/pci/ali5451/ali5451.c
@@ -275,7 +275,7 @@ struct snd_ali {
 #endif
 };
 
-static struct pci_device_id snd_ali_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_ali_ids) = {
         {PCI_DEVICE(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M5451), 0, 0, 0},
         {0, }
 };
diff --git a/sound/pci/als300.c b/sound/pci/als300.c
index 3aa35af7ca91..d7653cb7ac60 100644
--- a/sound/pci/als300.c
+++ b/sound/pci/als300.c
@@ -145,7 +145,7 @@ struct snd_als300_substream_data {
         int block_counter_register;
 };
 
-static struct pci_device_id snd_als300_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_als300_ids) = {
         { 0x4005, 0x0300, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_ALS300 },
         { 0x4005, 0x0308, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEVICE_ALS300_PLUS },
         { 0, }
diff --git a/sound/pci/als4000.c b/sound/pci/als4000.c
index 3dbacde1a5af..6cf1de8042e8 100644
--- a/sound/pci/als4000.c
+++ b/sound/pci/als4000.c
@@ -68,7 +68,6 @@
 #include <asm/io.h>
 #include <linux/init.h>
 #include <linux/pci.h>
-#include <linux/slab.h>
 #include <linux/gameport.h>
 #include <linux/moduleparam.h>
 #include <linux/dma-mapping.h>
@@ -117,7 +116,7 @@ struct snd_card_als4000 {
 #endif
 };
 
-static struct pci_device_id snd_als4000_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_als4000_ids) = {
         { 0x4005, 0x4000, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },   /* ALS4000 */
         { 0, }
 };
diff --git a/sound/pci/atiixp.c b/sound/pci/atiixp.c
index d6752dff2a44..49d572a7b235 100644
--- a/sound/pci/atiixp.c
+++ b/sound/pci/atiixp.c
@@ -286,7 +286,7 @@ struct atiixp {
 
 /*
  */
-static struct pci_device_id snd_atiixp_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_atiixp_ids) = {
         { PCI_VDEVICE(ATI, 0x4341), 0 }, /* SB200 */
         { PCI_VDEVICE(ATI, 0x4361), 0 }, /* SB300 */
         { PCI_VDEVICE(ATI, 0x4370), 0 }, /* SB400 */
@@ -297,6 +297,7 @@ static struct pci_device_id snd_atiixp_ids[] = {
 MODULE_DEVICE_TABLE(pci, snd_atiixp_ids);
 
 static struct snd_pci_quirk atiixp_quirks[] __devinitdata = {
+        SND_PCI_QUIRK(0x105b, 0x0c81, "Foxconn RC4107MA-RS2", 0),
         SND_PCI_QUIRK(0x15bd, 0x3100, "DFI RS482", 0),
         { } /* terminator */
 };
diff --git a/sound/pci/atiixp_modem.c b/sound/pci/atiixp_modem.c
index e7e147bf8eb2..91d7036b6411 100644
--- a/sound/pci/atiixp_modem.c
+++ b/sound/pci/atiixp_modem.c
@@ -261,7 +261,7 @@ struct atiixp_modem {
 
 /*
  */
-static struct pci_device_id snd_atiixp_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_atiixp_ids) = {
         { 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 c0e8c6b295cb..aa51cc7771dd 100644
--- a/sound/pci/au88x0/au8810.c
+++ b/sound/pci/au88x0/au8810.c
@@ -1,6 +1,6 @@
 #include "au8810.h"
 #include "au88x0.h"
-static struct pci_device_id snd_vortex_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_vortex_ids) = {
         {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 a6527330df58..2f321e7306cd 100644
--- a/sound/pci/au88x0/au8820.c
+++ b/sound/pci/au88x0/au8820.c
@@ -1,6 +1,6 @@
 #include "au8820.h"
 #include "au88x0.h"
-static struct pci_device_id snd_vortex_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_vortex_ids) = {
         {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 6c702ad4352a..279b78f06d22 100644
--- a/sound/pci/au88x0/au8830.c
+++ b/sound/pci/au88x0/au8830.c
@@ -1,6 +1,6 @@
 #include "au8830.h"
 #include "au88x0.h"
-static struct pci_device_id snd_vortex_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_vortex_ids) = {
         {PCI_VDEVICE(AUREAL, PCI_DEVICE_ID_AUREAL_VORTEX_2), 0,},
         {0,}
 };
diff --git a/sound/pci/aw2/aw2-alsa.c b/sound/pci/aw2/aw2-alsa.c
index 4d34bb0d99d3..67921f93a41e 100644
--- a/sound/pci/aw2/aw2-alsa.c
+++ b/sound/pci/aw2/aw2-alsa.c
@@ -164,7 +164,7 @@ MODULE_PARM_DESC(id, "ID string for the Audiowerk2 soundcard.");
 module_param_array(enable, bool, NULL, 0444);
 MODULE_PARM_DESC(enable, "Enable Audiowerk2 soundcard.");
 
-static struct pci_device_id snd_aw2_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_aw2_ids) = {
         {PCI_VENDOR_ID_SAA7146, PCI_DEVICE_ID_SAA7146, 0, 0,
          0, 0, 0},
         {0}
diff --git a/sound/pci/aw2/aw2-saa7146.c b/sound/pci/aw2/aw2-saa7146.c
index 296123ab74f7..8afd8b5d1ac7 100644
--- a/sound/pci/aw2/aw2-saa7146.c
+++ b/sound/pci/aw2/aw2-saa7146.c
@@ -25,7 +25,6 @@
 
 #include <linux/init.h>
 #include <linux/pci.h>
-#include <linux/slab.h>
 #include <linux/interrupt.h>
 #include <linux/delay.h>
 #include <asm/system.h>
diff --git a/sound/pci/azt3328.c b/sound/pci/azt3328.c
index 8451a0169f32..4679ed83a43b 100644
--- a/sound/pci/azt3328.c
+++ b/sound/pci/azt3328.c
@@ -350,7 +350,7 @@ struct snd_azf3328 {
 #endif
 };
 
-static const struct pci_device_id snd_azf3328_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_azf3328_ids) = {
         { 0x122D, 0x50DC, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },   /* PCI168/3328 */
         { 0x122D, 0x80DA, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },   /* 3328 */
         { 0, }
@@ -830,8 +830,8 @@ static struct snd_kcontrol_new snd_azf3328_mixer_controls[] __devinitdata = {
         AZF3328_MIXER_SWITCH("Mic Boost (+20dB)", IDX_MIXER_MIC, 6, 0),
         AZF3328_MIXER_SWITCH("Line Playback Switch", IDX_MIXER_LINEIN, 15, 1),
         AZF3328_MIXER_VOL_STEREO("Line Playback Volume", IDX_MIXER_LINEIN, 0x1f, 1),
-        AZF3328_MIXER_SWITCH("PC Speaker Playback Switch", IDX_MIXER_PCBEEP, 15, 1),
-        AZF3328_MIXER_VOL_SPECIAL("PC Speaker Playback Volume", IDX_MIXER_PCBEEP, 0x0f, 1, 1),
+        AZF3328_MIXER_SWITCH("Beep Playback Switch", IDX_MIXER_PCBEEP, 15, 1),
+        AZF3328_MIXER_VOL_SPECIAL("Beep Playback Volume", IDX_MIXER_PCBEEP, 0x0f, 1, 1),
         AZF3328_MIXER_SWITCH("Video Playback Switch", IDX_MIXER_VIDEO, 15, 1),
         AZF3328_MIXER_VOL_STEREO("Video Playback Volume", IDX_MIXER_VIDEO, 0x1f, 1),
         AZF3328_MIXER_SWITCH("Aux Playback Switch", IDX_MIXER_AUX, 15, 1),
diff --git a/sound/pci/bt87x.c b/sound/pci/bt87x.c
index 4e2b925a94cc..37e1b5df5ab8 100644
--- a/sound/pci/bt87x.c
+++ b/sound/pci/bt87x.c
@@ -795,7 +795,7 @@ fail:
           .driver_data = SND_BT87X_BOARD_ ## id }
 /* driver_data is the card id for that device */
 
-static struct pci_device_id snd_bt87x_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_bt87x_ids) = {
         /* Hauppauge WinTV series */
         BT_DEVICE(PCI_DEVICE_ID_BROOKTREE_878, 0x0070, 0x13eb, GENERIC),
         /* Hauppauge WinTV series */
@@ -964,7 +964,7 @@ static void __devexit snd_bt87x_remove(struct pci_dev *pci)
 
 /* default entries for all Bt87x cards - it's not exported */
 /* driver_data is set to 0 to call detection */
-static struct pci_device_id snd_bt87x_default_ids[] __devinitdata = {
+static DEFINE_PCI_DEVICE_TABLE(snd_bt87x_default_ids) = {
         BT_DEVICE(PCI_DEVICE_ID_BROOKTREE_878, PCI_ANY_ID, PCI_ANY_ID, UNKNOWN),
         BT_DEVICE(PCI_DEVICE_ID_BROOKTREE_879, PCI_ANY_ID, PCI_ANY_ID, UNKNOWN),
         { }
diff --git a/sound/pci/ca0106/ca0106_main.c b/sound/pci/ca0106/ca0106_main.c
index 15e4138bce17..0a3d3d6e77b4 100644
--- a/sound/pci/ca0106/ca0106_main.c
+++ b/sound/pci/ca0106/ca0106_main.c
@@ -1875,7 +1875,7 @@ static int snd_ca0106_resume(struct pci_dev *pci)
 #endif
 
 // PCI IDs
-static struct pci_device_id snd_ca0106_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_ca0106_ids) = {
         { PCI_VDEVICE(CREATIVE, 0x0007), 0 },   /* Audigy LS or Live 24bit */
         { 0, }
 };
diff --git a/sound/pci/ca0106/ca0106_mixer.c b/sound/pci/ca0106/ca0106_mixer.c
index c8c6f437f5b3..85fd315d9999 100644
--- a/sound/pci/ca0106/ca0106_mixer.c
+++ b/sound/pci/ca0106/ca0106_mixer.c
@@ -63,7 +63,6 @@
 #include <linux/delay.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
-#include <linux/slab.h>
 #include <linux/moduleparam.h>
 #include <sound/core.h>
 #include <sound/initval.h>
@@ -792,8 +791,8 @@ int __devinit snd_ca0106_mixer(struct snd_ca0106 *emu)
                 "Phone Playback Volume",
                 "Video Playback Switch",
                 "Video Playback Volume",
-                "PC Speaker Playback Switch",
-                "PC Speaker Playback Volume",
+                "Beep Playback Switch",
+                "Beep Playback Volume",
                 "Mono Output Select",
                 "Capture Source",
                 "Capture Switch",
diff --git a/sound/pci/ca0106/ca0106_proc.c b/sound/pci/ca0106/ca0106_proc.c
index c62b7d10ec61..ba96428c9f4c 100644
--- a/sound/pci/ca0106/ca0106_proc.c
+++ b/sound/pci/ca0106/ca0106_proc.c
@@ -63,7 +63,6 @@
 #include <linux/delay.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
-#include <linux/slab.h>
 #include <linux/moduleparam.h>
 #include <sound/core.h>
 #include <sound/initval.h>
@@ -233,7 +232,7 @@ static void snd_ca0106_proc_dump_iec958( struct snd_info_buffer *buffer, u32 val
                         snd_iprintf(buffer, "user-defined\n");
                         break;
                 default:
-                        snd_iprintf(buffer, "unkown\n");
+                        snd_iprintf(buffer, "unknown\n");
                         break;
                 }
                 snd_iprintf(buffer, "Sample Bits: ");
@@ -304,7 +303,7 @@ static void snd_ca0106_proc_reg_write32(struct snd_info_entry *entry,
         while (!snd_info_get_line(buffer, line, sizeof(line))) {
                 if (sscanf(line, "%x %x", &reg, &val) != 2)
                         continue;
-                if ((reg < 0x40) && (reg >=0) && (val <= 0xffffffff) ) {
+                if (reg < 0x40 && val <= 0xffffffff) {
                         spin_lock_irqsave(&emu->emu_lock, flags);
                         outl(val, emu->port + (reg & 0xfffffffc));
                         spin_unlock_irqrestore(&emu->emu_lock, flags);
@@ -405,7 +404,7 @@ static void snd_ca0106_proc_reg_write(struct snd_info_entry *entry,
         while (!snd_info_get_line(buffer, line, sizeof(line))) {
                 if (sscanf(line, "%x %x %x", &reg, &channel_id, &val) != 3)
                         continue;
-                if ((reg < 0x80) && (reg >=0) && (val <= 0xffffffff) && (channel_id >=0) && (channel_id <= 3) )
+                if (reg < 0x80 && val <= 0xffffffff && channel_id <= 3)
                         snd_ca0106_ptr_write(emu, reg, channel_id, val);
         }
 }
diff --git a/sound/pci/cmipci.c b/sound/pci/cmipci.c
index ddcd4a9fd7e6..329968edca9b 100644
--- a/sound/pci/cmipci.c
+++ b/sound/pci/cmipci.c
@@ -941,13 +941,21 @@ static snd_pcm_uframes_t snd_cmipci_pcm_pointer(struct cmipci *cm, struct cmipci
                                                 struct snd_pcm_substream *substream)
 {
         size_t ptr;
-        unsigned int reg;
+        unsigned int reg, rem, tries;
+
         if (!rec->running)
                 return 0;
 #if 1 // this seems better..
         reg = rec->ch ? CM_REG_CH1_FRAME2 : CM_REG_CH0_FRAME2;
-        ptr = rec->dma_size - (snd_cmipci_read_w(cm, reg) + 1);
-        ptr >>= rec->shift;
+        for (tries = 0; tries < 3; tries++) {
+                rem = snd_cmipci_read_w(cm, reg);
+                if (rem < rec->dma_size)
+                        goto ok;
+        } 
+        printk(KERN_ERR "cmipci: invalid PCM pointer: %#x\n", rem);
+        return SNDRV_PCM_POS_XRUN;
+ok:
+        ptr = (rec->dma_size - (rem + 1)) >> rec->shift;
 #else
         reg = rec->ch ? CM_REG_CH1_FRAME1 : CM_REG_CH0_FRAME1;
         ptr = snd_cmipci_read(cm, reg) - rec->offset;
@@ -2302,7 +2310,7 @@ static struct snd_kcontrol_new snd_cmipci_mixers[] __devinitdata = {
         CMIPCI_SB_VOL_MONO("Mic Playback Volume", SB_DSP4_MIC_DEV, 3, 31),
         CMIPCI_SB_SW_MONO("Mic Playback Switch", 0),
         CMIPCI_DOUBLE("Mic Capture Switch", SB_DSP4_INPUT_LEFT, SB_DSP4_INPUT_RIGHT, 0, 0, 1, 0, 0),
-        CMIPCI_SB_VOL_MONO("PC Speaker Playback Volume", SB_DSP4_SPEAKER_DEV, 6, 3),
+        CMIPCI_SB_VOL_MONO("Beep Playback Volume", SB_DSP4_SPEAKER_DEV, 6, 3),
         CMIPCI_MIXER_VOL_STEREO("Aux Playback Volume", CM_REG_AUX_VOL, 4, 0, 15),
         CMIPCI_MIXER_SW_STEREO("Aux Playback Switch", CM_REG_MIXER2, CM_VAUXLM_SHIFT, CM_VAUXRM_SHIFT, 0),
         CMIPCI_MIXER_SW_STEREO("Aux Capture Switch", CM_REG_MIXER2, CM_RAUXLEN_SHIFT, CM_RAUXREN_SHIFT, 0),
@@ -2310,7 +2318,7 @@ static struct snd_kcontrol_new snd_cmipci_mixers[] __devinitdata = {
         CMIPCI_MIXER_VOL_MONO("Mic Capture Volume", CM_REG_MIXER2, CM_VADMIC_SHIFT, 7),
         CMIPCI_SB_VOL_MONO("Phone Playback Volume", CM_REG_EXTENT_IND, 5, 7),
         CMIPCI_DOUBLE("Phone Playback Switch", CM_REG_EXTENT_IND, CM_REG_EXTENT_IND, 4, 4, 1, 0, 0),
-        CMIPCI_DOUBLE("PC Speaker Playback Switch", CM_REG_EXTENT_IND, CM_REG_EXTENT_IND, 3, 3, 1, 0, 0),
+        CMIPCI_DOUBLE("Beep Playback Switch", CM_REG_EXTENT_IND, CM_REG_EXTENT_IND, 3, 3, 1, 0, 0),
         CMIPCI_DOUBLE("Mic Boost Capture Switch", CM_REG_EXTENT_IND, CM_REG_EXTENT_IND, 0, 0, 1, 0, 0),
 };
 
@@ -2796,7 +2804,7 @@ static inline void snd_cmipci_proc_init(struct cmipci *cm) {}
 #endif
 
 
-static struct pci_device_id snd_cmipci_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_cmipci_ids) = {
         {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},
@@ -3018,7 +3026,7 @@ static int __devinit snd_cmipci_create(struct snd_card *card, struct pci_dev *pc
         int integrated_midi = 0;
         char modelstr[16];
         int pcm_index, pcm_spdif_index;
-        static struct pci_device_id intel_82437vx[] = {
+        static DEFINE_PCI_DEVICE_TABLE(intel_82437vx) = {
                 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82437VX) },
                 { },
         };
diff --git a/sound/pci/cs4281.c b/sound/pci/cs4281.c
index e2e0359bb056..9edc65059e3e 100644
--- a/sound/pci/cs4281.c
+++ b/sound/pci/cs4281.c
@@ -494,7 +494,7 @@ struct cs4281 {
 
 static irqreturn_t snd_cs4281_interrupt(int irq, void *dev_id);
 
-static struct pci_device_id snd_cs4281_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_cs4281_ids) = {
         { PCI_VDEVICE(CIRRUS, 0x6005), 0, },    /* CS4281 */
         { 0, }
 };
diff --git a/sound/pci/cs46xx/cs46xx.c b/sound/pci/cs46xx/cs46xx.c
index 033aec430117..767fa7f06cd0 100644
--- a/sound/pci/cs46xx/cs46xx.c
+++ b/sound/pci/cs46xx/cs46xx.c
@@ -64,7 +64,7 @@ MODULE_PARM_DESC(thinkpad, "Force to enable Thinkpad's CLKRUN control.");
 module_param_array(mmap_valid, bool, NULL, 0444);
 MODULE_PARM_DESC(mmap_valid, "Support OSS mmap.");
 
-static struct pci_device_id snd_cs46xx_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_cs46xx_ids) = {
         { PCI_VDEVICE(CIRRUS, 0x6001), 0, },   /* CS4280 */
         { PCI_VDEVICE(CIRRUS, 0x6003), 0, },   /* CS4612 */
         { PCI_VDEVICE(CIRRUS, 0x6004), 0, },   /* CS4615 */
diff --git a/sound/pci/cs46xx/cs46xx_lib.c b/sound/pci/cs46xx/cs46xx_lib.c
index 1be96ead4244..3f99a5e8528c 100644
--- a/sound/pci/cs46xx/cs46xx_lib.c
+++ b/sound/pci/cs46xx/cs46xx_lib.c
@@ -2238,11 +2238,11 @@ static void snd_cs46xx_codec_reset (struct snd_ac97 * ac97)
 
         /* set the desired CODEC mode */
         if (ac97->num == CS46XX_PRIMARY_CODEC_INDEX) {
-                snd_printdd("cs46xx: CODOEC1 mode %04x\n",0x0);
-                snd_cs46xx_ac97_write(ac97,AC97_CSR_ACMODE,0x0);
+                snd_printdd("cs46xx: CODEC1 mode %04x\n", 0x0);
+                snd_cs46xx_ac97_write(ac97, AC97_CSR_ACMODE, 0x0);
         } else if (ac97->num == CS46XX_SECONDARY_CODEC_INDEX) {
-                snd_printdd("cs46xx: CODOEC2 mode %04x\n",0x3);
-                snd_cs46xx_ac97_write(ac97,AC97_CSR_ACMODE,0x3);
+                snd_printdd("cs46xx: CODEC2 mode %04x\n", 0x3);
+                snd_cs46xx_ac97_write(ac97, AC97_CSR_ACMODE, 0x3);
         } else {
                 snd_BUG(); /* should never happen ... */
         }
@@ -2266,7 +2266,7 @@ static void snd_cs46xx_codec_reset (struct snd_ac97 * ac97)
                         return;
 
                 /* test if we can write to the record gain volume register */
-                snd_ac97_write_cache(ac97, AC97_REC_GAIN, 0x8a05);
+                snd_ac97_write(ac97, AC97_REC_GAIN, 0x8a05);
                 if ((err = snd_ac97_read(ac97, AC97_REC_GAIN)) == 0x8a05)
                         return;
 
@@ -3597,7 +3597,7 @@ static struct cs_card_type __devinitdata cards[] = {
 #ifdef CONFIG_PM
 static unsigned int saved_regs[] = {
         BA0_ACOSV,
-        BA0_ASER_FADDR,
+        /*BA0_ASER_FADDR,*/
         BA0_ASER_MASTER,
         BA1_PVOL,
         BA1_CVOL,
@@ -3644,6 +3644,7 @@ int snd_cs46xx_resume(struct pci_dev *pci)
 #ifdef CONFIG_SND_CS46XX_NEW_DSP
         int i;
 #endif
+        unsigned int tmp;
 
         pci_set_power_state(pci, PCI_D0);
         pci_restore_state(pci);
@@ -3685,6 +3686,15 @@ int snd_cs46xx_resume(struct pci_dev *pci)
         snd_ac97_resume(chip->ac97[CS46XX_PRIMARY_CODEC_INDEX]);
         snd_ac97_resume(chip->ac97[CS46XX_SECONDARY_CODEC_INDEX]);
 
+        /*
+         *  Stop capture DMA.
+         */
+        tmp = snd_cs46xx_peek(chip, BA1_CCTL);
+        chip->capt.ctl = tmp & 0x0000ffff;
+        snd_cs46xx_poke(chip, BA1_CCTL, tmp & 0xffff0000);
+
+        mdelay(5);
+
         /* reset playback/capture */
         snd_cs46xx_set_play_sample_rate(chip, 8000);
         snd_cs46xx_set_capture_sample_rate(chip, 8000);
diff --git a/sound/pci/cs46xx/dsp_spos.c b/sound/pci/cs46xx/dsp_spos.c
index f4f0c8f5dad7..3e5ca8fb519f 100644
--- a/sound/pci/cs46xx/dsp_spos.c
+++ b/sound/pci/cs46xx/dsp_spos.c
@@ -298,6 +298,9 @@ void  cs46xx_dsp_spos_destroy (struct snd_cs46xx * chip)
                 if (ins->scbs[i].deleted) continue;
 
                 cs46xx_dsp_proc_free_scb_desc ( (ins->scbs + i) );
+#ifdef CONFIG_PM
+                kfree(ins->scbs[i].data);
+#endif
         }
 
         kfree(ins->code.data);
@@ -974,13 +977,11 @@ static struct dsp_scb_descriptor * _map_scb (struct snd_cs46xx *chip, char * nam
 
         index = find_free_scb_index (ins);
 
+        memset(&ins->scbs[index], 0, sizeof(ins->scbs[index]));
         strcpy(ins->scbs[index].scb_name, name);
         ins->scbs[index].address = dest;
         ins->scbs[index].index = index;
-        ins->scbs[index].proc_info = NULL;
         ins->scbs[index].ref_count = 1;
-        ins->scbs[index].deleted = 0;
-        spin_lock_init(&ins->scbs[index].lock);
 
         desc = (ins->scbs + index);
         ins->scbs[index].scb_symbol = add_symbol (chip, name, dest, SYMBOL_PARAMETER);
@@ -1022,17 +1023,29 @@ _map_task_tree (struct snd_cs46xx *chip, char * name, u32 dest, u32 size)
         return desc;
 }
 
+#define SCB_BYTES       (0x10 * 4)
+
 struct dsp_scb_descriptor *
 cs46xx_dsp_create_scb (struct snd_cs46xx *chip, char * name, u32 * scb_data, u32 dest)
 {
         struct dsp_scb_descriptor * desc;
 
+#ifdef CONFIG_PM
+        /* copy the data for resume */
+        scb_data = kmemdup(scb_data, SCB_BYTES, GFP_KERNEL);
+        if (!scb_data)
+                return NULL;
+#endif
+
         desc = _map_scb (chip,name,dest);
         if (desc) {
                 desc->data = scb_data;
                 _dsp_create_scb(chip,scb_data,dest);
         } else {
                 snd_printk(KERN_ERR "dsp_spos: failed to map SCB\n");
+#ifdef CONFIG_PM
+                kfree(scb_data);
+#endif
         }
 
         return desc;
@@ -1988,7 +2001,28 @@ int cs46xx_dsp_resume(struct snd_cs46xx * chip)
                         continue;
                 _dsp_create_scb(chip, s->data, s->address);
         }
-
+        for (i = 0; i < ins->nscb; i++) {
+                struct dsp_scb_descriptor *s = &ins->scbs[i];
+                if (s->deleted)
+                        continue;
+                if (s->updated)
+                        cs46xx_dsp_spos_update_scb(chip, s);
+                if (s->volume_set)
+                        cs46xx_dsp_scb_set_volume(chip, s,
+                                                  s->volume[0], s->volume[1]);
+        }
+        if (ins->spdif_status_out & DSP_SPDIF_STATUS_HW_ENABLED) {
+                cs46xx_dsp_enable_spdif_hw(chip);
+                snd_cs46xx_poke(chip, (ins->ref_snoop_scb->address + 2) << 2,
+                                (OUTPUT_SNOOP_BUFFER + 0x10) << 0x10);
+                if (ins->spdif_status_out & DSP_SPDIF_STATUS_PLAYBACK_OPEN)
+                        cs46xx_poke_via_dsp(chip, SP_SPDOUT_CSUV,
+                                            ins->spdif_csuv_stream);
+        }
+        if (chip->dsp_spos_instance->spdif_status_in) {
+                cs46xx_poke_via_dsp(chip, SP_ASER_COUNTDOWN, 0x80000005);
+                cs46xx_poke_via_dsp(chip, SP_SPDIN_CONTROL, 0x800003ff);
+        }
         return 0;
 }
 #endif
diff --git a/sound/pci/cs46xx/dsp_spos.h b/sound/pci/cs46xx/dsp_spos.h
index f9e169d33c03..ca47a8114c7f 100644
--- a/sound/pci/cs46xx/dsp_spos.h
+++ b/sound/pci/cs46xx/dsp_spos.h
@@ -212,6 +212,7 @@ static inline void cs46xx_dsp_spos_update_scb (struct snd_cs46xx * chip,
                         (scb->address + SCBsubListPtr) << 2,
                         (scb->sub_list_ptr->address << 0x10) |
                         (scb->next_scb_ptr->address));  
+        scb->updated = 1;
 }
 
 static inline void cs46xx_dsp_scb_set_volume (struct snd_cs46xx * chip,
@@ -222,6 +223,9 @@ static inline void cs46xx_dsp_scb_set_volume (struct snd_cs46xx * chip,
 
         snd_cs46xx_poke(chip, (scb->address + SCBVolumeCtrl) << 2, val);
         snd_cs46xx_poke(chip, (scb->address + SCBVolumeCtrl + 1) << 2, val);
+        scb->volume_set = 1;
+        scb->volume[0] = left;
+        scb->volume[1] = right;
 }
 #endif /* __DSP_SPOS_H__ */
 #endif /* CONFIG_SND_CS46XX_NEW_DSP  */
diff --git a/sound/pci/cs46xx/dsp_spos_scb_lib.c b/sound/pci/cs46xx/dsp_spos_scb_lib.c
index dd7c41b037b4..00b148a10239 100644
--- a/sound/pci/cs46xx/dsp_spos_scb_lib.c
+++ b/sound/pci/cs46xx/dsp_spos_scb_lib.c
@@ -115,7 +115,6 @@ static void cs46xx_dsp_proc_scb_info_read (struct snd_info_entry *entry,
 static void _dsp_unlink_scb (struct snd_cs46xx *chip, struct dsp_scb_descriptor * scb)
 {
         struct dsp_spos_instance * ins = chip->dsp_spos_instance;
-        unsigned long flags;
 
         if ( scb->parent_scb_ptr ) {
                 /* unlink parent SCB */
@@ -153,8 +152,6 @@ static void _dsp_unlink_scb (struct snd_cs46xx *chip, struct dsp_scb_descriptor
                         scb->next_scb_ptr = ins->the_null_scb;
                 }
 
-                spin_lock_irqsave(&chip->reg_lock, flags);    
-
                 /* update parent first entry in DSP RAM */
                 cs46xx_dsp_spos_update_scb(chip,scb->parent_scb_ptr);
 
@@ -162,7 +159,6 @@ static void _dsp_unlink_scb (struct snd_cs46xx *chip, struct dsp_scb_descriptor
                 cs46xx_dsp_spos_update_scb(chip,scb);
 
                 scb->parent_scb_ptr = NULL;
-                spin_unlock_irqrestore(&chip->reg_lock, flags);
         }
 }
 
@@ -197,9 +193,9 @@ void cs46xx_dsp_remove_scb (struct snd_cs46xx *chip, struct dsp_scb_descriptor *
                 goto _end;
 #endif
 
-        spin_lock_irqsave(&scb->lock, flags);
+        spin_lock_irqsave(&chip->reg_lock, flags);    
         _dsp_unlink_scb (chip,scb);
-        spin_unlock_irqrestore(&scb->lock, flags);
+        spin_unlock_irqrestore(&chip->reg_lock, flags);
 
         cs46xx_dsp_proc_free_scb_desc(scb);
         if (snd_BUG_ON(!scb->scb_symbol))
@@ -207,6 +203,10 @@ void cs46xx_dsp_remove_scb (struct snd_cs46xx *chip, struct dsp_scb_descriptor *
         remove_symbol (chip,scb->scb_symbol);
 
         ins->scbs[scb->index].deleted = 1;
+#ifdef CONFIG_PM
+        kfree(ins->scbs[scb->index].data);
+        ins->scbs[scb->index].data = NULL;
+#endif
 
         if (scb->index < ins->scb_highest_frag_index)
                 ins->scb_highest_frag_index = scb->index;
@@ -1508,20 +1508,17 @@ int cs46xx_dsp_pcm_unlink (struct snd_cs46xx * chip,
                        chip->dsp_spos_instance->npcm_channels <= 0))
                 return -EIO;
 
-        spin_lock(&pcm_channel->src_scb->lock);
-
+        spin_lock_irqsave(&chip->reg_lock, flags);
         if (pcm_channel->unlinked) {
-                spin_unlock(&pcm_channel->src_scb->lock);
+                spin_unlock_irqrestore(&chip->reg_lock, flags);
                 return -EIO;
         }
 
-        spin_lock_irqsave(&chip->reg_lock, flags);
         pcm_channel->unlinked = 1;
-        spin_unlock_irqrestore(&chip->reg_lock, flags);
 
         _dsp_unlink_scb (chip,pcm_channel->pcm_reader_scb);
+        spin_unlock_irqrestore(&chip->reg_lock, flags);
 
-        spin_unlock(&pcm_channel->src_scb->lock);
         return 0;
 }
 
@@ -1533,10 +1530,10 @@ int cs46xx_dsp_pcm_link (struct snd_cs46xx * chip,
         struct dsp_scb_descriptor * src_scb = pcm_channel->src_scb;
         unsigned long flags;
 
-        spin_lock(&pcm_channel->src_scb->lock);
+        spin_lock_irqsave(&chip->reg_lock, flags);
 
         if (pcm_channel->unlinked == 0) {
-                spin_unlock(&pcm_channel->src_scb->lock);
+                spin_unlock_irqrestore(&chip->reg_lock, flags);
                 return -EIO;
         }
 
@@ -1552,8 +1549,6 @@ int cs46xx_dsp_pcm_link (struct snd_cs46xx * chip,
         snd_BUG_ON(pcm_channel->pcm_reader_scb->parent_scb_ptr);
         pcm_channel->pcm_reader_scb->parent_scb_ptr = parent_scb;
 
-        spin_lock_irqsave(&chip->reg_lock, flags);
-
         /* update SCB entry in DSP RAM */
         cs46xx_dsp_spos_update_scb(chip,pcm_channel->pcm_reader_scb);
 
@@ -1562,8 +1557,6 @@ int cs46xx_dsp_pcm_link (struct snd_cs46xx * chip,
 
         pcm_channel->unlinked = 0;
         spin_unlock_irqrestore(&chip->reg_lock, flags);
-
-        spin_unlock(&pcm_channel->src_scb->lock);
         return 0;
 }
 
@@ -1596,13 +1589,17 @@ cs46xx_add_record_source (struct snd_cs46xx *chip, struct dsp_scb_descriptor * s
 
 int cs46xx_src_unlink(struct snd_cs46xx *chip, struct dsp_scb_descriptor * src)
 {
+        unsigned long flags;
+
         if (snd_BUG_ON(!src->parent_scb_ptr))
                 return -EINVAL;
 
         /* mute SCB */
         cs46xx_dsp_scb_set_volume (chip,src,0,0);
 
+        spin_lock_irqsave(&chip->reg_lock, flags);
         _dsp_unlink_scb (chip,src);
+        spin_unlock_irqrestore(&chip->reg_lock, flags);
 
         return 0;
 }
diff --git a/sound/pci/cs46xx/imgs/cwcdma.asp b/sound/pci/cs46xx/imgs/cwcdma.asp
index 09d24c76f034..a65e1193c89a 100644
--- a/sound/pci/cs46xx/imgs/cwcdma.asp
+++ b/sound/pci/cs46xx/imgs/cwcdma.asp
@@ -26,10 +26,11 @@
 //
 //
 // The purpose of this code is very simple: make it possible to tranfser
-// the samples 'as they are' with no alteration from a PCMreader SCB (DMA from host)
-// to any other SCB. This is useful for AC3 throug SPDIF. SRC (source rate converters) 
-// task always alters the samples in some how, however it's from 48khz -> 48khz. The
-// alterations are not audible, but AC3 wont work. 
+// the samples 'as they are' with no alteration from a PCMreader
+// SCB (DMA from host) to any other SCB. This is useful for AC3 through SPDIF.
+// SRC (source rate converters) task always alters the samples in somehow,
+// however it's from 48khz -> 48khz.
+// The alterations are not audible, but AC3 wont work. 
 //
 //        ...
 //         |
diff --git a/sound/pci/cs5530.c b/sound/pci/cs5530.c
index dc464321d0f3..bc07e275d4d4 100644
--- a/sound/pci/cs5530.c
+++ b/sound/pci/cs5530.c
@@ -39,6 +39,7 @@
 #include <linux/delay.h>
 #include <linux/moduleparam.h>
 #include <linux/pci.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/sb.h>
 #include <sound/initval.h>
@@ -58,7 +59,7 @@ struct snd_cs5530 {
         unsigned long pci_base;
 };
 
-static struct pci_device_id snd_cs5530_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_cs5530_ids) = {
         {PCI_VENDOR_ID_CYRIX, PCI_DEVICE_ID_CYRIX_5530_AUDIO, PCI_ANY_ID,
                                                         PCI_ANY_ID, 0, 0},
         {0,}
diff --git a/sound/pci/cs5535audio/Makefile b/sound/pci/cs5535audio/Makefile
index fda7a94c992f..ccc642269b9e 100644
--- a/sound/pci/cs5535audio/Makefile
+++ b/sound/pci/cs5535audio/Makefile
@@ -4,9 +4,7 @@
 
 snd-cs5535audio-y := cs5535audio.o cs5535audio_pcm.o
 snd-cs5535audio-$(CONFIG_PM) += cs5535audio_pm.o
-ifdef CONFIG_MGEODE_LX
 snd-cs5535audio-$(CONFIG_OLPC) += cs5535audio_olpc.o
-endif
 
 # Toplevel Module Dependency
 obj-$(CONFIG_SND_CS5535AUDIO) += snd-cs5535audio.o
diff --git a/sound/pci/cs5535audio/cs5535audio.c b/sound/pci/cs5535audio/cs5535audio.c
index 05f56e04849b..afb803708416 100644
--- a/sound/pci/cs5535audio/cs5535audio.c
+++ b/sound/pci/cs5535audio/cs5535audio.c
@@ -66,7 +66,7 @@ MODULE_PARM_DESC(id, "ID string for " DRIVER_NAME);
 module_param_array(enable, bool, NULL, 0444);
 MODULE_PARM_DESC(enable, "Enable " DRIVER_NAME);
 
-static struct pci_device_id snd_cs5535audio_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_cs5535audio_ids) = {
         { PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_CS5535_AUDIO) },
         { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_CS5536_AUDIO) },
         {}
@@ -389,6 +389,7 @@ probefail_out:
 
 static void __devexit snd_cs5535audio_remove(struct pci_dev *pci)
 {
+        olpc_quirks_cleanup();
         snd_card_free(pci_get_drvdata(pci));
         pci_set_drvdata(pci, NULL);
 }
diff --git a/sound/pci/cs5535audio/cs5535audio.h b/sound/pci/cs5535audio/cs5535audio.h
index 7a298ac662e3..51966d782a3c 100644
--- a/sound/pci/cs5535audio/cs5535audio.h
+++ b/sound/pci/cs5535audio/cs5535audio.h
@@ -99,10 +99,11 @@ int snd_cs5535audio_suspend(struct pci_dev *pci, pm_message_t state);
 int snd_cs5535audio_resume(struct pci_dev *pci);
 #endif
 
-#if defined(CONFIG_OLPC) && defined(CONFIG_MGEODE_LX)
+#ifdef CONFIG_OLPC
 void __devinit olpc_prequirks(struct snd_card *card,
                 struct snd_ac97_template *ac97);
 int __devinit olpc_quirks(struct snd_card *card, struct snd_ac97 *ac97);
+void __devexit olpc_quirks_cleanup(void);
 void olpc_analog_input(struct snd_ac97 *ac97, int on);
 void olpc_mic_bias(struct snd_ac97 *ac97, int on);
 
@@ -128,6 +129,7 @@ static inline int olpc_quirks(struct snd_card *card, struct snd_ac97 *ac97)
 {
         return 0;
 }
+static inline void olpc_quirks_cleanup(void) { }
 static inline void olpc_analog_input(struct snd_ac97 *ac97, int on) { }
 static inline void olpc_mic_bias(struct snd_ac97 *ac97, int on) { }
 static inline void olpc_capture_open(struct snd_ac97 *ac97) { }
diff --git a/sound/pci/cs5535audio/cs5535audio_olpc.c b/sound/pci/cs5535audio/cs5535audio_olpc.c
index 5c6814335cd7..50da49be9ae5 100644
--- a/sound/pci/cs5535audio/cs5535audio_olpc.c
+++ b/sound/pci/cs5535audio/cs5535audio_olpc.c
@@ -13,10 +13,13 @@
 #include <sound/info.h>
 #include <sound/control.h>
 #include <sound/ac97_codec.h>
+#include <linux/gpio.h>
 
 #include <asm/olpc.h>
 #include "cs5535audio.h"
 
+#define DRV_NAME "cs5535audio-olpc"
+
 /*
  * OLPC has an additional feature on top of the regular AD1888 codec features.
  * It has an Analog Input mode that is switched into (after disabling the
@@ -38,10 +41,7 @@ void olpc_analog_input(struct snd_ac97 *ac97, int on)
         }
 
         /* set Analog Input through GPIO */
-        if (on)
-                geode_gpio_set(OLPC_GPIO_MIC_AC, GPIO_OUTPUT_VAL);
-        else
-                geode_gpio_clear(OLPC_GPIO_MIC_AC, GPIO_OUTPUT_VAL);
+        gpio_set_value(OLPC_GPIO_MIC_AC, on);
 }
 
 /*
@@ -73,8 +73,7 @@ static int olpc_dc_info(struct snd_kcontrol *kctl,
 
 static int olpc_dc_get(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *v)
 {
-        v->value.integer.value[0] = geode_gpio_isset(OLPC_GPIO_MIC_AC,
-                        GPIO_OUTPUT_VAL);
+        v->value.integer.value[0] = gpio_get_value(OLPC_GPIO_MIC_AC);
         return 0;
 }
 
@@ -153,6 +152,12 @@ int __devinit olpc_quirks(struct snd_card *card, struct snd_ac97 *ac97)
         if (!machine_is_olpc())
                 return 0;
 
+        if (gpio_request(OLPC_GPIO_MIC_AC, DRV_NAME)) {
+                printk(KERN_ERR DRV_NAME ": unable to allocate MIC GPIO\n");
+                return -EIO;
+        }
+        gpio_direction_output(OLPC_GPIO_MIC_AC, 0);
+
         /* drop the original AD1888 HPF control */
         memset(&elem, 0, sizeof(elem));
         elem.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
@@ -169,11 +174,18 @@ int __devinit olpc_quirks(struct snd_card *card, struct snd_ac97 *ac97)
         for (i = 0; i < ARRAY_SIZE(olpc_cs5535audio_ctls); i++) {
                 err = snd_ctl_add(card, snd_ctl_new1(&olpc_cs5535audio_ctls[i],
                                 ac97->private_data));
-                if (err < 0)
+                if (err < 0) {
+                        gpio_free(OLPC_GPIO_MIC_AC);
                         return err;
+                }
         }
 
         /* turn off the mic by default */
         olpc_mic_bias(ac97, 0);
         return 0;
 }
+
+void __devexit olpc_quirks_cleanup(void)
+{
+        gpio_free(OLPC_GPIO_MIC_AC);
+}
diff --git a/sound/pci/cs5535audio/cs5535audio_pcm.c b/sound/pci/cs5535audio/cs5535audio_pcm.c
index 0f48a871f17b..f16bc8aad6ed 100644
--- a/sound/pci/cs5535audio/cs5535audio_pcm.c
+++ b/sound/pci/cs5535audio/cs5535audio_pcm.c
@@ -23,7 +23,6 @@
  */
 
 #include <linux/init.h>
-#include <linux/slab.h>
 #include <linux/pci.h>
 #include <sound/core.h>
 #include <sound/control.h>
diff --git a/sound/pci/cs5535audio/cs5535audio_pm.c b/sound/pci/cs5535audio/cs5535audio_pm.c
index 564c33b60953..a3301cc4ab82 100644
--- a/sound/pci/cs5535audio/cs5535audio_pm.c
+++ b/sound/pci/cs5535audio/cs5535audio_pm.c
@@ -19,7 +19,6 @@
  */
 
 #include <linux/init.h>
-#include <linux/slab.h>
 #include <linux/pci.h>
 #include <linux/delay.h>
 #include <sound/core.h>
diff --git a/sound/pci/ctxfi/ctatc.c b/sound/pci/ctxfi/ctatc.c
index 75454648d50c..1bff80cde0a2 100644
--- a/sound/pci/ctxfi/ctatc.c
+++ b/sound/pci/ctxfi/ctatc.c
@@ -24,6 +24,7 @@
 #include "ctdaio.h"
 #include "cttimer.h"
 #include <linux/delay.h>
+#include <linux/slab.h>
 #include <sound/pcm.h>
 #include <sound/control.h>
 #include <sound/asoundef.h>
@@ -166,18 +167,7 @@ static void ct_unmap_audio_buffer(struct ct_atc *atc, struct ct_atc_pcm *apcm)
 
 static unsigned long atc_get_ptp_phys(struct ct_atc *atc, int index)
 {
-        struct ct_vm *vm;
-        void *kvirt_addr;
-        unsigned long phys_addr;
-
-        vm = atc->vm;
-        kvirt_addr = vm->get_ptp_virt(vm, index);
-        if (kvirt_addr == NULL)
-                phys_addr = (~0UL);
-        else
-                phys_addr = virt_to_phys(kvirt_addr);
-
-        return phys_addr;
+        return atc->vm->get_ptp_phys(atc->vm, index);
 }
 
 static unsigned int convert_format(snd_pcm_format_t snd_format)
@@ -240,7 +230,7 @@ static int select_rom(unsigned int pitch)
         } else if (pitch == 0x02000000) {
                 /* pitch == 2 */
                 return 3;
-        } else if (pitch >= 0x0 && pitch <= 0x08000000) {
+        } else if (pitch <= 0x08000000) {
                 /* 0 <= pitch <= 8 */
                 return 0;
         } else {
@@ -1225,10 +1215,11 @@ static int atc_dev_free(struct snd_device *dev)
         return ct_atc_destroy(atc);
 }
 
-static int __devinit atc_identify_card(struct ct_atc *atc)
+static int __devinit atc_identify_card(struct ct_atc *atc, unsigned int ssid)
 {
         const struct snd_pci_quirk *p;
         const struct snd_pci_quirk *list;
+        u16 vendor_id, device_id;
 
         switch (atc->chip_type) {
         case ATC20K1:
@@ -1242,13 +1233,19 @@ static int __devinit atc_identify_card(struct ct_atc *atc)
         default:
                 return -ENOENT;
         }
-        p = snd_pci_quirk_lookup(atc->pci, list);
+        if (ssid) {
+                vendor_id = ssid >> 16;
+                device_id = ssid & 0xffff;
+        } else {
+                vendor_id = atc->pci->subsystem_vendor;
+                device_id = atc->pci->subsystem_device;
+        }
+        p = snd_pci_quirk_lookup_id(vendor_id, device_id, list);
         if (p) {
                 if (p->value < 0) {
                         printk(KERN_ERR "ctxfi: "
                                "Device %04x:%04x is black-listed\n",
-                               atc->pci->subsystem_vendor,
-                               atc->pci->subsystem_device);
+                               vendor_id, device_id);
                         return -ENOENT;
                 }
                 atc->model = p->value;
@@ -1261,8 +1258,7 @@ static int __devinit atc_identify_card(struct ct_atc *atc)
         atc->model_name = ct_subsys_name[atc->model];
         snd_printd("ctxfi: chip %s model %s (%04x:%04x) is found\n",
                    atc->chip_name, atc->model_name,
-                   atc->pci->subsystem_vendor,
-                   atc->pci->subsystem_device);
+                   vendor_id, device_id);
         return 0;
 }
 
@@ -1636,7 +1632,8 @@ static struct ct_atc atc_preset __devinitdata = {
 
 int __devinit ct_atc_create(struct snd_card *card, struct pci_dev *pci,
                             unsigned int rsr, unsigned int msr,
-                            int chip_type, struct ct_atc **ratc)
+                            int chip_type, unsigned int ssid,
+                            struct ct_atc **ratc)
 {
         struct ct_atc *atc;
         static struct snd_device_ops ops = {
@@ -1662,14 +1659,14 @@ int __devinit ct_atc_create(struct snd_card *card, struct pci_dev *pci,
         mutex_init(&atc->atc_mutex);
 
         /* Find card model */
-        err = atc_identify_card(atc);
+        err = atc_identify_card(atc, ssid);
         if (err < 0) {
                 printk(KERN_ERR "ctatc: Card not recognised\n");
                 goto error1;
         }
 
         /* Set up device virtual memory management object */
-        err = ct_vm_create(&atc->vm);
+        err = ct_vm_create(&atc->vm, pci);
         if (err < 0)
                 goto error1;
 
diff --git a/sound/pci/ctxfi/ctatc.h b/sound/pci/ctxfi/ctatc.h
index 9fd8a5708943..7167c0185d52 100644
--- a/sound/pci/ctxfi/ctatc.h
+++ b/sound/pci/ctxfi/ctatc.h
@@ -148,7 +148,7 @@ struct ct_atc {
 
 int __devinit ct_atc_create(struct snd_card *card, struct pci_dev *pci,
                             unsigned int rsr, unsigned int msr, int chip_type,
-                            struct ct_atc **ratc);
+                            unsigned int subsysid, struct ct_atc **ratc);
 int __devinit ct_atc_create_alsa_devs(struct ct_atc *atc);
 
 #endif /* CTATC_H */
diff --git a/sound/pci/ctxfi/ctpcm.c b/sound/pci/ctxfi/ctpcm.c
index d0dc227fbdd3..85ab43e89212 100644
--- a/sound/pci/ctxfi/ctpcm.c
+++ b/sound/pci/ctxfi/ctpcm.c
@@ -17,6 +17,7 @@
 
 #include "ctpcm.h"
 #include "cttimer.h"
+#include <linux/slab.h>
 #include <sound/pcm.h>
 
 /* Hardware descriptions for playback */
diff --git a/sound/pci/ctxfi/ctvmem.c b/sound/pci/ctxfi/ctvmem.c
index 6b78752e9503..65da6e466f80 100644
--- a/sound/pci/ctxfi/ctvmem.c
+++ b/sound/pci/ctxfi/ctvmem.c
@@ -138,7 +138,7 @@ ct_vm_map(struct ct_vm *vm, struct snd_pcm_substream *substream, int size)
                 return NULL;
         }
 
-        ptp = vm->ptp[0];
+        ptp = (unsigned long *)vm->ptp[0].area;
         pte_start = (block->addr >> CT_PAGE_SHIFT);
         pages = block->size >> CT_PAGE_SHIFT;
         for (i = 0; i < pages; i++) {
@@ -158,25 +158,25 @@ static void ct_vm_unmap(struct ct_vm *vm, struct ct_vm_block *block)
 }
 
 /* *
- * return the host (kmalloced) addr of the @index-th device
- * page talbe page on success, or NULL on failure.
- * The first returned NULL indicates the termination.
+ * return the host physical addr of the @index-th device
+ * page table page on success, or ~0UL on failure.
+ * The first returned ~0UL indicates the termination.
  * */
-static void *
-ct_get_ptp_virt(struct ct_vm *vm, int index)
+static dma_addr_t
+ct_get_ptp_phys(struct ct_vm *vm, int index)
 {
-        void *addr;
+        dma_addr_t addr;
 
-        addr = (index >= CT_PTP_NUM) ? NULL : vm->ptp[index];
+        addr = (index >= CT_PTP_NUM) ? ~0UL : vm->ptp[index].addr;
 
         return addr;
 }
 
-int ct_vm_create(struct ct_vm **rvm)
+int ct_vm_create(struct ct_vm **rvm, struct pci_dev *pci)
 {
         struct ct_vm *vm;
         struct ct_vm_block *block;
-        int i;
+        int i, err = 0;
 
         *rvm = NULL;
 
@@ -188,23 +188,21 @@ 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 (!vm->ptp[i])
+                err = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV,
+                                          snd_dma_pci_data(pci),
+                                          PAGE_SIZE, &vm->ptp[i]);
+                if (err < 0)
                         break;
         }
-        if (!i) {
+        if (err < 0) {
                 /* no page table pages are allocated */
-                kfree(vm);
+                ct_vm_destroy(vm);
                 return -ENOMEM;
         }
         vm->size = CT_ADDRS_PER_PAGE * i;
-        /* Initialise remaining ptps */
-        for (; i < CT_PTP_NUM; i++)
-                vm->ptp[i] = NULL;
-
         vm->map = ct_vm_map;
         vm->unmap = ct_vm_unmap;
-        vm->get_ptp_virt = ct_get_ptp_virt;
+        vm->get_ptp_phys = ct_get_ptp_phys;
         INIT_LIST_HEAD(&vm->unused);
         INIT_LIST_HEAD(&vm->used);
         block = kzalloc(sizeof(*block), GFP_KERNEL);
@@ -242,7 +240,7 @@ void ct_vm_destroy(struct ct_vm *vm)
 
         /* free allocated page table pages */
         for (i = 0; i < CT_PTP_NUM; i++)
-                kfree(vm->ptp[i]);
+                snd_dma_free_pages(&vm->ptp[i]);
 
         vm->size = 0;
 
diff --git a/sound/pci/ctxfi/ctvmem.h b/sound/pci/ctxfi/ctvmem.h
index 01e4fd0386a3..b23adfca4de6 100644
--- a/sound/pci/ctxfi/ctvmem.h
+++ b/sound/pci/ctxfi/ctvmem.h
@@ -22,6 +22,8 @@
 
 #include <linux/mutex.h>
 #include <linux/list.h>
+#include <linux/pci.h>
+#include <sound/memalloc.h>
 
 /* The chip can handle the page table of 4k pages
  * (emu20k1 can handle even 8k pages, but we don't use it right now)
@@ -41,7 +43,7 @@ struct snd_pcm_substream;
 
 /* Virtual memory management object for card device */
 struct ct_vm {
-        void *ptp[CT_PTP_NUM];          /* Device page table pages */
+        struct snd_dma_buffer ptp[CT_PTP_NUM];  /* Device page table pages */
         unsigned int size;              /* Available addr space in bytes */
         struct list_head unused;        /* List of unused blocks */
         struct list_head used;          /* List of used blocks */
@@ -52,10 +54,10 @@ struct ct_vm {
                                    int size);
         /* Unmap device logical addr area. */
         void (*unmap)(struct ct_vm *, struct ct_vm_block *block);
-        void *(*get_ptp_virt)(struct ct_vm *vm, int index);
+        dma_addr_t (*get_ptp_phys)(struct ct_vm *vm, int index);
 };
 
-int ct_vm_create(struct ct_vm **rvm);
+int ct_vm_create(struct ct_vm **rvm, struct pci_dev *pci);
 void ct_vm_destroy(struct ct_vm *vm);
 
 #endif /* CTVMEM_H */
diff --git a/sound/pci/ctxfi/xfi.c b/sound/pci/ctxfi/xfi.c
index 76541748e7bc..f42e7e1a1074 100644
--- a/sound/pci/ctxfi/xfi.c
+++ b/sound/pci/ctxfi/xfi.c
@@ -32,6 +32,7 @@ module_param(multiple, uint, S_IRUGO);
 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
+static unsigned int subsystem[SNDRV_CARDS];
 
 module_param_array(index, int, NULL, 0444);
 MODULE_PARM_DESC(index, "Index value for Creative X-Fi driver");
@@ -39,8 +40,10 @@ module_param_array(id, charp, NULL, 0444);
 MODULE_PARM_DESC(id, "ID string for Creative X-Fi driver");
 module_param_array(enable, bool, NULL, 0444);
 MODULE_PARM_DESC(enable, "Enable Creative X-Fi driver");
+module_param_array(subsystem, int, NULL, 0444);
+MODULE_PARM_DESC(subsystem, "Override subsystem ID for Creative X-Fi driver");
 
-static struct pci_device_id ct_pci_dev_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(ct_pci_dev_ids) = {
         /* only X-Fi is supported, so... */
         { PCI_DEVICE(PCI_VENDOR_ID_CREATIVE, PCI_DEVICE_ID_CREATIVE_20K1),
           .driver_data = ATC20K1,
@@ -85,7 +88,7 @@ ct_card_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)
                 multiple = 2;
         }
         err = ct_atc_create(card, pci, reference_rate, multiple,
-                            pci_id->driver_data, &atc);
+                            pci_id->driver_data, subsystem[dev], &atc);
         if (err < 0)
                 goto error;
 
diff --git a/sound/pci/echoaudio/darla20.c b/sound/pci/echoaudio/darla20.c
index 8c6db3aa3c1a..fe7ad64dccd7 100644
--- a/sound/pci/echoaudio/darla20.c
+++ b/sound/pci/echoaudio/darla20.c
@@ -40,9 +40,9 @@
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/pci.h>
-#include <linux/slab.h>
 #include <linux/moduleparam.h>
 #include <linux/firmware.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -63,7 +63,7 @@ static const struct firmware card_fw[] = {
         {0, "darla20_dsp.fw"}
 };
 
-static struct pci_device_id snd_echo_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_echo_ids) = {
         {0x1057, 0x1801, 0xECC0, 0x0010, 0, 0, 0},      /* DSP 56301 Darla20 rev.0 */
         {0,}
 };
diff --git a/sound/pci/echoaudio/darla20_dsp.c b/sound/pci/echoaudio/darla20_dsp.c
index 29043301ebb8..20c7cbc89bb3 100644
--- a/sound/pci/echoaudio/darla20_dsp.c
+++ b/sound/pci/echoaudio/darla20_dsp.c
@@ -45,7 +45,7 @@ static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
         chip->device_id = device_id;
         chip->subdevice_id = subdevice_id;
         chip->bad_board = TRUE;
-        chip->dsp_code_to_load = &card_fw[FW_DARLA20_DSP];
+        chip->dsp_code_to_load = FW_DARLA20_DSP;
         chip->spdif_status = GD_SPDIF_STATUS_UNDEF;
         chip->clock_state = GD_CLOCK_UNDEF;
         /* Since this card has no ASIC, mark it as loaded so everything
@@ -57,15 +57,19 @@ static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
                 return err;
         chip->bad_board = FALSE;
 
-        if ((err = init_line_levels(chip)) < 0)
-                return err;
-
         DE_INIT(("init_hw done\n"));
         return err;
 }
 
 
 
+static int set_mixer_defaults(struct echoaudio *chip)
+{
+        return init_line_levels(chip);
+}
+
+
+
 /* The Darla20 has no external clock sources */
 static u32 detect_input_clocks(const struct echoaudio *chip)
 {
diff --git a/sound/pci/echoaudio/darla24.c b/sound/pci/echoaudio/darla24.c
index 04cbf3eaf05a..d1fd34b1a8e3 100644
--- a/sound/pci/echoaudio/darla24.c
+++ b/sound/pci/echoaudio/darla24.c
@@ -44,9 +44,9 @@
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/pci.h>
-#include <linux/slab.h>
 #include <linux/moduleparam.h>
 #include <linux/firmware.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -67,7 +67,7 @@ static const struct firmware card_fw[] = {
         {0, "darla24_dsp.fw"}
 };
 
-static struct pci_device_id snd_echo_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_echo_ids) = {
         {0x1057, 0x1801, 0xECC0, 0x0040, 0, 0, 0},      /* DSP 56301 Darla24 rev.0 */
         {0x1057, 0x1801, 0xECC0, 0x0041, 0, 0, 0},      /* DSP 56301 Darla24 rev.1 */
         {0,}
diff --git a/sound/pci/echoaudio/darla24_dsp.c b/sound/pci/echoaudio/darla24_dsp.c
index 60228731841f..6da6663e9176 100644
--- a/sound/pci/echoaudio/darla24_dsp.c
+++ b/sound/pci/echoaudio/darla24_dsp.c
@@ -45,7 +45,7 @@ static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
         chip->device_id = device_id;
         chip->subdevice_id = subdevice_id;
         chip->bad_board = TRUE;
-        chip->dsp_code_to_load = &card_fw[FW_DARLA24_DSP];
+        chip->dsp_code_to_load = FW_DARLA24_DSP;
         /* Since this card has no ASIC, mark it as loaded so everything
            works OK */
         chip->asic_loaded = TRUE;
@@ -56,15 +56,19 @@ static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
                 return err;
         chip->bad_board = FALSE;
 
-        if ((err = init_line_levels(chip)) < 0)
-                return err;
-
         DE_INIT(("init_hw done\n"));
         return err;
 }
 
 
 
+static int set_mixer_defaults(struct echoaudio *chip)
+{
+        return init_line_levels(chip);
+}
+
+
+
 static u32 detect_input_clocks(const struct echoaudio *chip)
 {
         u32 clocks_from_dsp, clock_bits;
diff --git a/sound/pci/echoaudio/echo3g.c b/sound/pci/echoaudio/echo3g.c
index 4022e43a0053..1dffdc54416d 100644
--- a/sound/pci/echoaudio/echo3g.c
+++ b/sound/pci/echoaudio/echo3g.c
@@ -51,9 +51,9 @@
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/pci.h>
-#include <linux/slab.h>
 #include <linux/moduleparam.h>
 #include <linux/firmware.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -81,7 +81,7 @@ static const struct firmware card_fw[] = {
         {0, "3g_asic.fw"}
 };
 
-static struct pci_device_id snd_echo_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_echo_ids) = {
         {0x1057, 0x3410, 0xECC0, 0x0100, 0, 0, 0},      /* Echo 3G */
         {0,}
 };
diff --git a/sound/pci/echoaudio/echo3g_dsp.c b/sound/pci/echoaudio/echo3g_dsp.c
index 57967e580571..3cdc2ee2d1dd 100644
--- a/sound/pci/echoaudio/echo3g_dsp.c
+++ b/sound/pci/echoaudio/echo3g_dsp.c
@@ -61,7 +61,7 @@ static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
         chip->subdevice_id = subdevice_id;
         chip->bad_board = TRUE;
         chip->has_midi = TRUE;
-        chip->dsp_code_to_load = &card_fw[FW_ECHO3G_DSP];
+        chip->dsp_code_to_load = FW_ECHO3G_DSP;
 
         /* Load the DSP code and the ASIC on the PCI card and get
         what type of external box is attached */
@@ -97,20 +97,6 @@ static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
         chip->digital_modes =   ECHOCAPS_HAS_DIGITAL_MODE_SPDIF_RCA |
                                 ECHOCAPS_HAS_DIGITAL_MODE_SPDIF_OPTICAL |
                                 ECHOCAPS_HAS_DIGITAL_MODE_ADAT;
-        chip->digital_mode =    DIGITAL_MODE_SPDIF_RCA;
-        chip->professional_spdif = FALSE;
-        chip->non_audio_spdif = FALSE;
-        chip->bad_board = FALSE;
-
-        if ((err = init_line_levels(chip)) < 0)
-                return err;
-        err = set_digital_mode(chip, DIGITAL_MODE_SPDIF_RCA);
-        if (err < 0)
-                return err;
-        err = set_phantom_power(chip, 0);
-        if (err < 0)
-                return err;
-        err = set_professional_spdif(chip, TRUE);
 
         DE_INIT(("init_hw done\n"));
         return err;
@@ -118,6 +104,18 @@ static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
 
 
 
+static int set_mixer_defaults(struct echoaudio *chip)
+{
+        chip->digital_mode = DIGITAL_MODE_SPDIF_RCA;
+        chip->professional_spdif = FALSE;
+        chip->non_audio_spdif = FALSE;
+        chip->bad_board = FALSE;
+        chip->phantom_power = FALSE;
+        return init_line_levels(chip);
+}
+
+
+
 static int set_phantom_power(struct echoaudio *chip, char on)
 {
         u32 control_reg = le32_to_cpu(chip->comm_page->control_register);
diff --git a/sound/pci/echoaudio/echoaudio.c b/sound/pci/echoaudio/echoaudio.c
index 1305f7ca02c3..668a5ec04499 100644
--- a/sound/pci/echoaudio/echoaudio.c
+++ b/sound/pci/echoaudio/echoaudio.c
@@ -36,22 +36,61 @@ MODULE_PARM_DESC(enable, "Enable " ECHOCARD_NAME " soundcard.");
 static unsigned int channels_list[10] = {1, 2, 4, 6, 8, 10, 12, 14, 16, 999999};
 static const DECLARE_TLV_DB_SCALE(db_scale_output_gain, -12800, 100, 1);
 
+
+
 static int get_firmware(const struct firmware **fw_entry,
-                        const struct firmware *frm, struct echoaudio *chip)
+                        struct echoaudio *chip, const short fw_index)
 {
         int err;
         char name[30];
-        DE_ACT(("firmware requested: %s\n", frm->data));
-        snprintf(name, sizeof(name), "ea/%s", frm->data);
-        if ((err = request_firmware(fw_entry, name, pci_device(chip))) < 0)
+
+#ifdef CONFIG_PM
+        if (chip->fw_cache[fw_index]) {
+                DE_ACT(("firmware requested: %s is cached\n", card_fw[fw_index].data));
+                *fw_entry = chip->fw_cache[fw_index];
+                return 0;
+        }
+#endif
+
+        DE_ACT(("firmware requested: %s\n", card_fw[fw_index].data));
+        snprintf(name, sizeof(name), "ea/%s", card_fw[fw_index].data);
+        err = request_firmware(fw_entry, name, pci_device(chip));
+        if (err < 0)
                 snd_printk(KERN_ERR "get_firmware(): Firmware not available (%d)\n", err);
+#ifdef CONFIG_PM
+        else
+                chip->fw_cache[fw_index] = *fw_entry;
+#endif
         return err;
 }
 
+
+
 static void free_firmware(const struct firmware *fw_entry)
 {
+#ifdef CONFIG_PM
+        DE_ACT(("firmware not released (kept in cache)\n"));
+#else
         release_firmware(fw_entry);
         DE_ACT(("firmware released\n"));
+#endif
+}
+
+
+
+static void free_firmware_cache(struct echoaudio *chip)
+{
+#ifdef CONFIG_PM
+        int i;
+
+        for (i = 0; i < 8 ; i++)
+                if (chip->fw_cache[i]) {
+                        release_firmware(chip->fw_cache[i]);
+                        DE_ACT(("release_firmware(%d)\n", i));
+                }
+
+        DE_ACT(("firmware_cache released\n"));
+#endif
 }
 
 
@@ -714,6 +753,8 @@ static int pcm_trigger(struct snd_pcm_substream *substream, int cmd)
 
         spin_lock(&chip->lock);
         switch (cmd) {
+        case SNDRV_PCM_TRIGGER_RESUME:
+                DE_ACT(("pcm_trigger resume\n"));
         case SNDRV_PCM_TRIGGER_START:
         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
                 DE_ACT(("pcm_trigger start\n"));
@@ -737,6 +778,8 @@ static int pcm_trigger(struct snd_pcm_substream *substream, int cmd)
                 err = start_transport(chip, channelmask,
                                       chip->pipe_cyclic_mask);
                 break;
+        case SNDRV_PCM_TRIGGER_SUSPEND:
+                DE_ACT(("pcm_trigger suspend\n"));
         case SNDRV_PCM_TRIGGER_STOP:
                 DE_ACT(("pcm_trigger stop\n"));
                 for (i = 0; i < DSP_MAXPIPES; i++) {
@@ -1821,7 +1864,9 @@ static irqreturn_t snd_echo_interrupt(int irq, void *dev_id)
         /* The hardware doesn't tell us which substream caused the irq,
         thus we have to check all running substreams. */
         for (ss = 0; ss < DSP_MAXPIPES; ss++) {
-                if ((substream = chip->substream[ss])) {
+                substream = chip->substream[ss];
+                if (substream && ((struct audiopipe *)substream->runtime->
+                                private_data)->state == PIPE_STATE_STARTED) {
                         period = pcm_pointer(substream) /
                                 substream->runtime->period_size;
                         if (period != chip->last_period[ss]) {
@@ -1874,6 +1919,7 @@ static int snd_echo_free(struct echoaudio *chip)
         pci_disable_device(chip->pci);
 
         /* release chip data */
+        free_firmware_cache(chip);
         kfree(chip);
         DE_INIT(("Chip freed.\n"));
         return 0;
@@ -1911,18 +1957,27 @@ static __devinit int snd_echo_create(struct snd_card *card,
                 return err;
         pci_set_master(pci);
 
-        /* allocate a chip-specific data */
-        chip = kzalloc(sizeof(*chip), GFP_KERNEL);
-        if (!chip) {
-                pci_disable_device(pci);
-                return -ENOMEM;
+        /* Allocate chip if needed */
+        if (!*rchip) {
+                chip = kzalloc(sizeof(*chip), GFP_KERNEL);
+                if (!chip) {
+                        pci_disable_device(pci);
+                        return -ENOMEM;
+                }
+                DE_INIT(("chip=%p\n", chip));
+                spin_lock_init(&chip->lock);
+                chip->card = card;
+                chip->pci = pci;
+                chip->irq = -1;
+                atomic_set(&chip->opencount, 0);
+                mutex_init(&chip->mode_mutex);
+                chip->can_set_rate = 1;
+        } else {
+                /* If this was called from the resume function, chip is
+                 * already allocated and it contains current card settings.
+                 */
+                chip = *rchip;
         }
-        DE_INIT(("chip=%p\n", chip));
-
-        spin_lock_init(&chip->lock);
-        chip->card = card;
-        chip->pci = pci;
-        chip->irq = -1;
 
         /* PCI resource allocation */
         chip->dsp_registers_phys = pci_resource_start(pci, 0);
@@ -1962,7 +2017,9 @@ static __devinit int snd_echo_create(struct snd_card *card,
         chip->comm_page = (struct comm_page *)chip->commpage_dma_buf.area;
 
         err = init_hw(chip, chip->pci->device, chip->pci->subsystem_device);
-        if (err) {
+        if (err >= 0)
+                err = set_mixer_defaults(chip);
+        if (err < 0) {
                 DE_INIT(("init_hw err=%d\n", err));
                 snd_echo_free(chip);
                 return err;
@@ -1973,9 +2030,6 @@ static __devinit int snd_echo_create(struct snd_card *card,
                 snd_echo_free(chip);
                 return err;
         }
-        atomic_set(&chip->opencount, 0);
-        mutex_init(&chip->mode_mutex);
-        chip->can_set_rate = 1;
         *rchip = chip;
         /* Init done ! */
         return 0;
@@ -2008,6 +2062,7 @@ static int __devinit snd_echo_probe(struct pci_dev *pci,
 
         snd_card_set_dev(card, &pci->dev);
 
+        chip = NULL;    /* Tells snd_echo_create to allocate chip */
         if ((err = snd_echo_create(card, pci, &chip)) < 0) {
                 snd_card_free(card);
                 return err;
@@ -2129,10 +2184,9 @@ static int __devinit snd_echo_probe(struct pci_dev *pci,
                         goto ctl_error;
 #endif
 
-        if ((err = snd_card_register(card)) < 0) {
-                snd_card_free(card);
+        err = snd_card_register(card);
+        if (err < 0)
                 goto ctl_error;
-        }
         snd_printk(KERN_INFO "Card registered: %s\n", card->longname);
 
         pci_set_drvdata(pci, chip);
@@ -2147,6 +2201,112 @@ ctl_error:
 
 
 
+#if defined(CONFIG_PM)
+
+static int snd_echo_suspend(struct pci_dev *pci, pm_message_t state)
+{
+        struct echoaudio *chip = pci_get_drvdata(pci);
+
+        DE_INIT(("suspend start\n"));
+        snd_pcm_suspend_all(chip->analog_pcm);
+        snd_pcm_suspend_all(chip->digital_pcm);
+
+#ifdef ECHOCARD_HAS_MIDI
+        /* This call can sleep */
+        if (chip->midi_out)
+                snd_echo_midi_output_trigger(chip->midi_out, 0);
+#endif
+        spin_lock_irq(&chip->lock);
+        if (wait_handshake(chip)) {
+                spin_unlock_irq(&chip->lock);
+                return -EIO;
+        }
+        clear_handshake(chip);
+        if (send_vector(chip, DSP_VC_GO_COMATOSE) < 0) {
+                spin_unlock_irq(&chip->lock);
+                return -EIO;
+        }
+        spin_unlock_irq(&chip->lock);
+
+        chip->dsp_code = NULL;
+        free_irq(chip->irq, chip);
+        chip->irq = -1;
+        pci_save_state(pci);
+        pci_disable_device(pci);
+
+        DE_INIT(("suspend done\n"));
+        return 0;
+}
+
+
+
+static int snd_echo_resume(struct pci_dev *pci)
+{
+        struct echoaudio *chip = pci_get_drvdata(pci);
+        struct comm_page *commpage, *commpage_bak;
+        u32 pipe_alloc_mask;
+        int err;
+
+        DE_INIT(("resume start\n"));
+        pci_restore_state(pci);
+        commpage_bak = kmalloc(sizeof(struct echoaudio), GFP_KERNEL);
+        commpage = chip->comm_page;
+        memcpy(commpage_bak, commpage, sizeof(struct comm_page));
+
+        err = init_hw(chip, chip->pci->device, chip->pci->subsystem_device);
+        if (err < 0) {
+                kfree(commpage_bak);
+                DE_INIT(("resume init_hw err=%d\n", err));
+                snd_echo_free(chip);
+                return err;
+        }
+        DE_INIT(("resume init OK\n"));
+
+        /* Temporarily set chip->pipe_alloc_mask=0 otherwise
+         * restore_dsp_settings() fails.
+         */
+        pipe_alloc_mask = chip->pipe_alloc_mask;
+        chip->pipe_alloc_mask = 0;
+        err = restore_dsp_rettings(chip);
+        chip->pipe_alloc_mask = pipe_alloc_mask;
+        if (err < 0) {
+                kfree(commpage_bak);
+                return err;
+        }
+        DE_INIT(("resume restore OK\n"));
+
+        memcpy(&commpage->audio_format, &commpage_bak->audio_format,
+                sizeof(commpage->audio_format));
+        memcpy(&commpage->sglist_addr, &commpage_bak->sglist_addr,
+                sizeof(commpage->sglist_addr));
+        memcpy(&commpage->midi_output, &commpage_bak->midi_output,
+                sizeof(commpage->midi_output));
+        kfree(commpage_bak);
+
+        if (request_irq(pci->irq, snd_echo_interrupt, IRQF_SHARED,
+                        ECHOCARD_NAME, chip)) {
+                snd_echo_free(chip);
+                snd_printk(KERN_ERR "cannot grab irq\n");
+                return -EBUSY;
+        }
+        chip->irq = pci->irq;
+        DE_INIT(("resume irq=%d\n", chip->irq));
+
+#ifdef ECHOCARD_HAS_MIDI
+        if (chip->midi_input_enabled)
+                enable_midi_input(chip, TRUE);
+        if (chip->midi_out)
+                snd_echo_midi_output_trigger(chip->midi_out, 1);
+#endif
+
+        DE_INIT(("resume done\n"));
+        return 0;
+}
+
+#endif /* CONFIG_PM */
+
+
+
 static void __devexit snd_echo_remove(struct pci_dev *pci)
 {
         struct echoaudio *chip;
@@ -2169,6 +2329,10 @@ static struct pci_driver driver = {
         .id_table = snd_echo_ids,
         .probe = snd_echo_probe,
         .remove = __devexit_p(snd_echo_remove),
+#ifdef CONFIG_PM
+        .suspend = snd_echo_suspend,
+        .resume = snd_echo_resume,
+#endif /* CONFIG_PM */
 };
 
 
diff --git a/sound/pci/echoaudio/echoaudio.h b/sound/pci/echoaudio/echoaudio.h
index f9490ae36c2e..1df974dcb5f4 100644
--- a/sound/pci/echoaudio/echoaudio.h
+++ b/sound/pci/echoaudio/echoaudio.h
@@ -442,13 +442,16 @@ struct echoaudio {
         u16 device_id, subdevice_id;
         u16 *dsp_code;                  /* Current DSP code loaded,
                                          * NULL if nothing loaded */
-        const struct firmware *dsp_code_to_load;/* DSP code to load */
-        const struct firmware *asic_code;       /* Current ASIC code */
+        short dsp_code_to_load;         /* DSP code to load */
+        short asic_code;                /* Current ASIC code */
         u32 comm_page_phys;                     /* Physical address of the
                                                  * memory seen by DSP */
         volatile u32 __iomem *dsp_registers;    /* DSP's register base */
         u32 active_mask;                        /* Chs. active mask or
                                                  * punks out */
+#ifdef CONFIG_PM
+        const struct firmware *fw_cache[8];     /* Cached firmwares */
+#endif
 
 #ifdef ECHOCARD_HAS_MIDI
         u16 mtc_state;                          /* State for MIDI input parsing state machine */
@@ -464,11 +467,13 @@ static int load_firmware(struct echoaudio *chip);
 static int wait_handshake(struct echoaudio *chip);
 static int send_vector(struct echoaudio *chip, u32 command);
 static int get_firmware(const struct firmware **fw_entry,
-                        const struct firmware *frm, struct echoaudio *chip);
+                        struct echoaudio *chip, const short fw_index);
 static void free_firmware(const struct firmware *fw_entry);
 
 #ifdef ECHOCARD_HAS_MIDI
 static int enable_midi_input(struct echoaudio *chip, char enable);
+static void snd_echo_midi_output_trigger(
+                        struct snd_rawmidi_substream *substream, int up);
 static int midi_service_irq(struct echoaudio *chip);
 static int __devinit snd_echo_midi_create(struct snd_card *card,
                                           struct echoaudio *chip);
diff --git a/sound/pci/echoaudio/echoaudio_3g.c b/sound/pci/echoaudio/echoaudio_3g.c
index e32a74897921..658db44ef746 100644
--- a/sound/pci/echoaudio/echoaudio_3g.c
+++ b/sound/pci/echoaudio/echoaudio_3g.c
@@ -227,12 +227,11 @@ static int load_asic(struct echoaudio *chip)
         /* Give the DSP a few milliseconds to settle down */
         mdelay(2);
 
-        err = load_asic_generic(chip, DSP_FNC_LOAD_3G_ASIC,
-                                &card_fw[FW_3G_ASIC]);
+        err = load_asic_generic(chip, DSP_FNC_LOAD_3G_ASIC, FW_3G_ASIC);
         if (err < 0)
                 return err;
 
-        chip->asic_code = &card_fw[FW_3G_ASIC];
+        chip->asic_code = FW_3G_ASIC;
 
         /* Now give the new ASIC some time to set up */
         msleep(1000);
diff --git a/sound/pci/echoaudio/echoaudio_dsp.c b/sound/pci/echoaudio/echoaudio_dsp.c
index 4df51ef5e095..64417a733220 100644
--- a/sound/pci/echoaudio/echoaudio_dsp.c
+++ b/sound/pci/echoaudio/echoaudio_dsp.c
@@ -175,15 +175,15 @@ static inline int check_asic_status(struct echoaudio *chip)
 #ifdef ECHOCARD_HAS_ASIC
 
 /* Load ASIC code - done after the DSP is loaded */
-static int load_asic_generic(struct echoaudio *chip, u32 cmd,
-                             const struct firmware *asic)
+static int load_asic_generic(struct echoaudio *chip, u32 cmd, short asic)
 {
         const struct firmware *fw;
         int err;
         u32 i, size;
         u8 *code;
 
-        if ((err = get_firmware(&fw, asic, chip)) < 0) {
+        err = get_firmware(&fw, chip, asic);
+        if (err < 0) {
                 snd_printk(KERN_WARNING "Firmware not found !\n");
                 return err;
         }
@@ -245,7 +245,8 @@ static int install_resident_loader(struct echoaudio *chip)
                 return 0;
         }
 
-        if ((i = get_firmware(&fw, &card_fw[FW_361_LOADER], chip)) < 0) {
+        i = get_firmware(&fw, chip, FW_361_LOADER);
+        if (i < 0) {
                 snd_printk(KERN_WARNING "Firmware not found !\n");
                 return i;
         }
@@ -485,7 +486,8 @@ static int load_firmware(struct echoaudio *chip)
                 chip->dsp_code = NULL;
         }
 
-        if ((err = get_firmware(&fw, chip->dsp_code_to_load, chip)) < 0)
+        err = get_firmware(&fw, chip, chip->dsp_code_to_load);
+        if (err < 0)
                 return err;
         err = load_dsp(chip, (u16 *)fw->data);
         free_firmware(fw);
@@ -495,9 +497,6 @@ static int load_firmware(struct echoaudio *chip)
         if ((box_type = load_asic(chip)) < 0)
                 return box_type;        /* error */
 
-        if ((err = restore_dsp_rettings(chip)) < 0)
-                return err;
-
         return box_type;
 }
 
@@ -657,51 +656,106 @@ static void get_audio_meters(struct echoaudio *chip, long *meters)
 
 static int restore_dsp_rettings(struct echoaudio *chip)
 {
-        int err;
+        int i, o, err;
         DE_INIT(("restore_dsp_settings\n"));
 
         if ((err = check_asic_status(chip)) < 0)
                 return err;
 
-        /* @ Gina20/Darla20 only. Should be harmless for other cards. */
+        /* Gina20/Darla20 only. Should be harmless for other cards. */
         chip->comm_page->gd_clock_state = GD_CLOCK_UNDEF;
         chip->comm_page->gd_spdif_status = GD_SPDIF_STATUS_UNDEF;
         chip->comm_page->handshake = 0xffffffff;
 
-        if ((err = set_sample_rate(chip, chip->sample_rate)) < 0)
+        /* Restore output busses */
+        for (i = 0; i < num_busses_out(chip); i++) {
+                err = set_output_gain(chip, i, chip->output_gain[i]);
+                if (err < 0)
+                        return err;
+        }
+
+#ifdef ECHOCARD_HAS_VMIXER
+        for (i = 0; i < num_pipes_out(chip); i++)
+                for (o = 0; o < num_busses_out(chip); o++) {
+                        err = set_vmixer_gain(chip, o, i,
+                                                chip->vmixer_gain[o][i]);
+                        if (err < 0)
+                                return err;
+                }
+        if (update_vmixer_level(chip) < 0)
+                return -EIO;
+#endif /* ECHOCARD_HAS_VMIXER */
+
+#ifdef ECHOCARD_HAS_MONITOR
+        for (o = 0; o < num_busses_out(chip); o++)
+                for (i = 0; i < num_busses_in(chip); i++) {
+                        err = set_monitor_gain(chip, o, i,
+                                                chip->monitor_gain[o][i]);
+                        if (err < 0)
+                                return err;
+                }
+#endif /* ECHOCARD_HAS_MONITOR */
+
+#ifdef ECHOCARD_HAS_INPUT_GAIN
+        for (i = 0; i < num_busses_in(chip); i++) {
+                err = set_input_gain(chip, i, chip->input_gain[i]);
+                if (err < 0)
+                        return err;
+        }
+#endif /* ECHOCARD_HAS_INPUT_GAIN */
+
+        err = update_output_line_level(chip);
+        if (err < 0)
                 return err;
 
-        if (chip->meters_enabled)
-                if (send_vector(chip, DSP_VC_METERS_ON) < 0)
-                        return -EIO;
+        err = update_input_line_level(chip);
+        if (err < 0)
+                return err;
 
-#ifdef ECHOCARD_HAS_EXTERNAL_CLOCK
-        if (set_input_clock(chip, chip->input_clock) < 0)
+        err = set_sample_rate(chip, chip->sample_rate);
+        if (err < 0)
+                return err;
+
+        if (chip->meters_enabled) {
+                err = send_vector(chip, DSP_VC_METERS_ON);
+                if (err < 0)
+                        return err;
+        }
+
+#ifdef ECHOCARD_HAS_DIGITAL_MODE_SWITCH
+        if (set_digital_mode(chip, chip->digital_mode) < 0)
                 return -EIO;
 #endif
 
-#ifdef ECHOCARD_HAS_OUTPUT_CLOCK_SWITCH
-        if (set_output_clock(chip, chip->output_clock) < 0)
+#ifdef ECHOCARD_HAS_DIGITAL_IO
+        if (set_professional_spdif(chip, chip->professional_spdif) < 0)
                 return -EIO;
 #endif
 
-        if (update_output_line_level(chip) < 0)
+#ifdef ECHOCARD_HAS_PHANTOM_POWER
+        if (set_phantom_power(chip, chip->phantom_power) < 0)
                 return -EIO;
+#endif
 
-        if (update_input_line_level(chip) < 0)
+#ifdef ECHOCARD_HAS_EXTERNAL_CLOCK
+        /* set_input_clock() also restores automute setting */
+        if (set_input_clock(chip, chip->input_clock) < 0)
                 return -EIO;
+#endif
 
-#ifdef ECHOCARD_HAS_VMIXER
-        if (update_vmixer_level(chip) < 0)
+#ifdef ECHOCARD_HAS_OUTPUT_CLOCK_SWITCH
+        if (set_output_clock(chip, chip->output_clock) < 0)
                 return -EIO;
 #endif
 
         if (wait_handshake(chip) < 0)
                 return -EIO;
         clear_handshake(chip);
+        if (send_vector(chip, DSP_VC_UPDATE_FLAGS) < 0)
+                return -EIO;
 
         DE_INIT(("restore_dsp_rettings done\n"));
-        return send_vector(chip, DSP_VC_UPDATE_FLAGS);
+        return 0;
 }
 
 
@@ -918,9 +972,6 @@ static int init_dsp_comm_page(struct echoaudio *chip)
         chip->card_name = ECHOCARD_NAME;
         chip->bad_board = TRUE; /* Set TRUE until DSP loaded */
         chip->dsp_code = NULL;  /* Current DSP code not loaded */
-        chip->digital_mode = DIGITAL_MODE_NONE;
-        chip->input_clock = ECHO_CLOCK_INTERNAL;
-        chip->output_clock = ECHO_CLOCK_WORD;
         chip->asic_loaded = FALSE;
         memset(chip->comm_page, 0, sizeof(struct comm_page));
 
@@ -931,7 +982,6 @@ static int init_dsp_comm_page(struct echoaudio *chip)
         chip->comm_page->midi_out_free_count =
                 cpu_to_le32(DSP_MIDI_OUT_FIFO_SIZE);
         chip->comm_page->sample_rate = cpu_to_le32(44100);
-        chip->sample_rate = 44100;
 
         /* Set line levels so we don't blast any inputs on startup */
         memset(chip->comm_page->monitors, ECHOGAIN_MUTED, MONITOR_ARRAY_SIZE);
@@ -942,50 +992,21 @@ static int init_dsp_comm_page(struct echoaudio *chip)
 
 
 
-/* This function initializes the several volume controls for busses and pipes.
-This MUST be called after the DSP is up and running ! */
+/* This function initializes the chip structure with default values, ie. all
+ * muted and internal clock source. Then it copies the settings to the DSP.
+ * This MUST be called after the DSP is up and running !
+ */
 static int init_line_levels(struct echoaudio *chip)
 {
-        int st, i, o;
-
         DE_INIT(("init_line_levels\n"));
-
-        /* Mute output busses */
-        for (i = 0; i < num_busses_out(chip); i++)
-                if ((st = set_output_gain(chip, i, ECHOGAIN_MUTED)))
-                        return st;
-        if ((st = update_output_line_level(chip)))
-                return st;
-
-#ifdef ECHOCARD_HAS_VMIXER
-        /* Mute the Vmixer */
-        for (i = 0; i < num_pipes_out(chip); i++)
-                for (o = 0; o < num_busses_out(chip); o++)
-                        if ((st = set_vmixer_gain(chip, o, i, ECHOGAIN_MUTED)))
-                                return st;
-        if ((st = update_vmixer_level(chip)))
-                return st;
-#endif /* ECHOCARD_HAS_VMIXER */
-
-#ifdef ECHOCARD_HAS_MONITOR
-        /* Mute the monitor mixer */
-        for (o = 0; o < num_busses_out(chip); o++)
-                for (i = 0; i < num_busses_in(chip); i++)
-                        if ((st = set_monitor_gain(chip, o, i, ECHOGAIN_MUTED)))
-                                return st;
-        if ((st = update_output_line_level(chip)))
-                return st;
-#endif /* ECHOCARD_HAS_MONITOR */
-
-#ifdef ECHOCARD_HAS_INPUT_GAIN
-        for (i = 0; i < num_busses_in(chip); i++)
-                if ((st = set_input_gain(chip, i, ECHOGAIN_MUTED)))
-                        return st;
-        if ((st = update_input_line_level(chip)))
-                return st;
-#endif /* ECHOCARD_HAS_INPUT_GAIN */
-
-        return 0;
+        memset(chip->output_gain, ECHOGAIN_MUTED, sizeof(chip->output_gain));
+        memset(chip->input_gain, ECHOGAIN_MUTED, sizeof(chip->input_gain));
+        memset(chip->monitor_gain, ECHOGAIN_MUTED, sizeof(chip->monitor_gain));
+        memset(chip->vmixer_gain, ECHOGAIN_MUTED, sizeof(chip->vmixer_gain));
+        chip->input_clock = ECHO_CLOCK_INTERNAL;
+        chip->output_clock = ECHO_CLOCK_WORD;
+        chip->sample_rate = 44100;
+        return restore_dsp_rettings(chip);
 }
 
 
diff --git a/sound/pci/echoaudio/gina20.c b/sound/pci/echoaudio/gina20.c
index c0e64b8f52a4..050e54aa693f 100644
--- a/sound/pci/echoaudio/gina20.c
+++ b/sound/pci/echoaudio/gina20.c
@@ -44,9 +44,9 @@
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/pci.h>
-#include <linux/slab.h>
 #include <linux/moduleparam.h>
 #include <linux/firmware.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -67,7 +67,7 @@ static const struct firmware card_fw[] = {
         {0, "gina20_dsp.fw"}
 };
 
-static struct pci_device_id snd_echo_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_echo_ids) = {
         {0x1057, 0x1801, 0xECC0, 0x0020, 0, 0, 0},      /* DSP 56301 Gina20 rev.0 */
         {0,}
 };
diff --git a/sound/pci/echoaudio/gina20_dsp.c b/sound/pci/echoaudio/gina20_dsp.c
index 3f1e7475faea..d1615a0579d1 100644
--- a/sound/pci/echoaudio/gina20_dsp.c
+++ b/sound/pci/echoaudio/gina20_dsp.c
@@ -49,7 +49,7 @@ static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
         chip->device_id = device_id;
         chip->subdevice_id = subdevice_id;
         chip->bad_board = TRUE;
-        chip->dsp_code_to_load = &card_fw[FW_GINA20_DSP];
+        chip->dsp_code_to_load = FW_GINA20_DSP;
         chip->spdif_status = GD_SPDIF_STATUS_UNDEF;
         chip->clock_state = GD_CLOCK_UNDEF;
         /* Since this card has no ASIC, mark it as loaded so everything
@@ -62,17 +62,20 @@ static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
                 return err;
         chip->bad_board = FALSE;
 
-        if ((err = init_line_levels(chip)) < 0)
-                return err;
-
-        err = set_professional_spdif(chip, TRUE);
-
         DE_INIT(("init_hw done\n"));
         return err;
 }
 
 
 
+static int set_mixer_defaults(struct echoaudio *chip)
+{
+        chip->professional_spdif = FALSE;
+        return init_line_levels(chip);
+}
+
+
+
 static u32 detect_input_clocks(const struct echoaudio *chip)
 {
         u32 clocks_from_dsp, clock_bits;
diff --git a/sound/pci/echoaudio/gina24.c b/sound/pci/echoaudio/gina24.c
index c36a78dd0b5e..5748fc6d29d6 100644
--- a/sound/pci/echoaudio/gina24.c
+++ b/sound/pci/echoaudio/gina24.c
@@ -50,9 +50,9 @@
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/pci.h>
-#include <linux/slab.h>
 #include <linux/moduleparam.h>
 #include <linux/firmware.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -85,7 +85,7 @@ static const struct firmware card_fw[] = {
         {0, "gina24_361_asic.fw"}
 };
 
-static struct pci_device_id snd_echo_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_echo_ids) = {
         {0x1057, 0x1801, 0xECC0, 0x0050, 0, 0, 0},      /* DSP 56301 Gina24 rev.0 */
         {0x1057, 0x1801, 0xECC0, 0x0051, 0, 0, 0},      /* DSP 56301 Gina24 rev.1 */
         {0x1057, 0x3410, 0xECC0, 0x0050, 0, 0, 0},      /* DSP 56361 Gina24 rev.0 */
diff --git a/sound/pci/echoaudio/gina24_dsp.c b/sound/pci/echoaudio/gina24_dsp.c
index 2fef37a2a5b9..98f7cfa81b5f 100644
--- a/sound/pci/echoaudio/gina24_dsp.c
+++ b/sound/pci/echoaudio/gina24_dsp.c
@@ -33,8 +33,7 @@ static int write_control_reg(struct echoaudio *chip, u32 value, char force);
 static int set_input_clock(struct echoaudio *chip, u16 clock);
 static int set_professional_spdif(struct echoaudio *chip, char prof);
 static int set_digital_mode(struct echoaudio *chip, u8 mode);
-static int load_asic_generic(struct echoaudio *chip, u32 cmd,
-                             const struct firmware *asic);
+static int load_asic_generic(struct echoaudio *chip, u32 cmd, short asic);
 static int check_asic_status(struct echoaudio *chip);
 
 
@@ -58,19 +57,16 @@ static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
                 ECHO_CLOCK_BIT_INTERNAL | ECHO_CLOCK_BIT_SPDIF |
                 ECHO_CLOCK_BIT_ESYNC | ECHO_CLOCK_BIT_ESYNC96 |
                 ECHO_CLOCK_BIT_ADAT;
-        chip->professional_spdif = FALSE;
-        chip->digital_in_automute = TRUE;
-        chip->digital_mode = DIGITAL_MODE_SPDIF_RCA;
 
         /* Gina24 comes in both '301 and '361 flavors */
         if (chip->device_id == DEVICE_ID_56361) {
-                chip->dsp_code_to_load = &card_fw[FW_GINA24_361_DSP];
+                chip->dsp_code_to_load = FW_GINA24_361_DSP;
                 chip->digital_modes =
                         ECHOCAPS_HAS_DIGITAL_MODE_SPDIF_RCA |
                         ECHOCAPS_HAS_DIGITAL_MODE_SPDIF_OPTICAL |
                         ECHOCAPS_HAS_DIGITAL_MODE_ADAT;
         } else {
-                chip->dsp_code_to_load = &card_fw[FW_GINA24_301_DSP];
+                chip->dsp_code_to_load = FW_GINA24_301_DSP;
                 chip->digital_modes =
                         ECHOCAPS_HAS_DIGITAL_MODE_SPDIF_RCA |
                         ECHOCAPS_HAS_DIGITAL_MODE_SPDIF_OPTICAL |
@@ -82,19 +78,22 @@ static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
                 return err;
         chip->bad_board = FALSE;
 
-        if ((err = init_line_levels(chip)) < 0)
-                return err;
-        err = set_digital_mode(chip, DIGITAL_MODE_SPDIF_RCA);
-        if (err < 0)
-                return err;
-        err = set_professional_spdif(chip, TRUE);
-
         DE_INIT(("init_hw done\n"));
         return err;
 }
 
 
 
+static int set_mixer_defaults(struct echoaudio *chip)
+{
+        chip->digital_mode = DIGITAL_MODE_SPDIF_RCA;
+        chip->professional_spdif = FALSE;
+        chip->digital_in_automute = TRUE;
+        return init_line_levels(chip);
+}
+
+
+
 static u32 detect_input_clocks(const struct echoaudio *chip)
 {
         u32 clocks_from_dsp, clock_bits;
@@ -125,7 +124,7 @@ static int load_asic(struct echoaudio *chip)
 {
         u32 control_reg;
         int err;
-        const struct firmware *fw;
+        short asic;
 
         if (chip->asic_loaded)
                 return 1;
@@ -135,14 +134,15 @@ static int load_asic(struct echoaudio *chip)
 
         /* Pick the correct ASIC for '301 or '361 Gina24 */
         if (chip->device_id == DEVICE_ID_56361)
-                fw = &card_fw[FW_GINA24_361_ASIC];
+                asic = FW_GINA24_361_ASIC;
         else
-                fw = &card_fw[FW_GINA24_301_ASIC];
+                asic = FW_GINA24_301_ASIC;
 
-        if ((err = load_asic_generic(chip, DSP_FNC_LOAD_GINA24_ASIC, fw)) < 0)
+        err = load_asic_generic(chip, DSP_FNC_LOAD_GINA24_ASIC, asic);
+        if (err < 0)
                 return err;
 
-        chip->asic_code = fw;
+        chip->asic_code = asic;
 
         /* Now give the new ASIC a little time to set up */
         mdelay(10);
diff --git a/sound/pci/echoaudio/indigo.c b/sound/pci/echoaudio/indigo.c
index 0a58a7c1fd7c..4ae5e35cb5f1 100644
--- a/sound/pci/echoaudio/indigo.c
+++ b/sound/pci/echoaudio/indigo.c
@@ -42,9 +42,9 @@
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/pci.h>
-#include <linux/slab.h>
 #include <linux/moduleparam.h>
 #include <linux/firmware.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -68,7 +68,7 @@ static const struct firmware card_fw[] = {
         {0, "indigo_dsp.fw"}
 };
 
-static struct pci_device_id snd_echo_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_echo_ids) = {
         {0x1057, 0x3410, 0xECC0, 0x0090, 0, 0, 0},      /* Indigo */
         {0,}
 };
diff --git a/sound/pci/echoaudio/indigo_dsp.c b/sound/pci/echoaudio/indigo_dsp.c
index 0b2cd9c86277..5e85f14fe5a8 100644
--- a/sound/pci/echoaudio/indigo_dsp.c
+++ b/sound/pci/echoaudio/indigo_dsp.c
@@ -50,7 +50,7 @@ static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
         chip->device_id = device_id;
         chip->subdevice_id = subdevice_id;
         chip->bad_board = TRUE;
-        chip->dsp_code_to_load = &card_fw[FW_INDIGO_DSP];
+        chip->dsp_code_to_load = FW_INDIGO_DSP;
         /* Since this card has no ASIC, mark it as loaded so everything
            works OK */
         chip->asic_loaded = TRUE;
@@ -60,15 +60,19 @@ static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
                 return err;
         chip->bad_board = FALSE;
 
-        if ((err = init_line_levels(chip)) < 0)
-                return err;
-
         DE_INIT(("init_hw done\n"));
         return err;
 }
 
 
 
+static int set_mixer_defaults(struct echoaudio *chip)
+{
+        return init_line_levels(chip);
+}
+
+
+
 static u32 detect_input_clocks(const struct echoaudio *chip)
 {
         return ECHO_CLOCK_BIT_INTERNAL;
diff --git a/sound/pci/echoaudio/indigo_express_dsp.c b/sound/pci/echoaudio/indigo_express_dsp.c
index 9ab625e15652..2e4ab3e34a74 100644
--- a/sound/pci/echoaudio/indigo_express_dsp.c
+++ b/sound/pci/echoaudio/indigo_express_dsp.c
@@ -61,6 +61,7 @@ static int set_sample_rate(struct echoaudio *chip, u32 rate)
 
         control_reg |= clock;
         if (control_reg != old_control_reg) {
+                DE_ACT(("set_sample_rate: %d clock %d\n", rate, clock));
                 chip->comm_page->control_register = cpu_to_le32(control_reg);
                 chip->sample_rate = rate;
                 clear_handshake(chip);
diff --git a/sound/pci/echoaudio/indigodj.c b/sound/pci/echoaudio/indigodj.c
index 2db24d29332b..3550715bab1c 100644
--- a/sound/pci/echoaudio/indigodj.c
+++ b/sound/pci/echoaudio/indigodj.c
@@ -42,9 +42,9 @@
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/pci.h>
-#include <linux/slab.h>
 #include <linux/moduleparam.h>
 #include <linux/firmware.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -68,7 +68,7 @@ static const struct firmware card_fw[] = {
         {0, "indigo_dj_dsp.fw"}
 };
 
-static struct pci_device_id snd_echo_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_echo_ids) = {
         {0x1057, 0x3410, 0xECC0, 0x00B0, 0, 0, 0},      /* Indigo DJ*/
         {0,}
 };
diff --git a/sound/pci/echoaudio/indigodj_dsp.c b/sound/pci/echoaudio/indigodj_dsp.c
index 08392916691e..68f3c8ccc1bf 100644
--- a/sound/pci/echoaudio/indigodj_dsp.c
+++ b/sound/pci/echoaudio/indigodj_dsp.c
@@ -50,7 +50,7 @@ static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
         chip->device_id = device_id;
         chip->subdevice_id = subdevice_id;
         chip->bad_board = TRUE;
-        chip->dsp_code_to_load = &card_fw[FW_INDIGO_DJ_DSP];
+        chip->dsp_code_to_load = FW_INDIGO_DJ_DSP;
         /* Since this card has no ASIC, mark it as loaded so everything
            works OK */
         chip->asic_loaded = TRUE;
@@ -60,15 +60,19 @@ static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
                 return err;
         chip->bad_board = FALSE;
 
-        if ((err = init_line_levels(chip)) < 0)
-                return err;
-
         DE_INIT(("init_hw done\n"));
         return err;
 }
 
 
 
+static int set_mixer_defaults(struct echoaudio *chip)
+{
+        return init_line_levels(chip);
+}
+
+
+
 static u32 detect_input_clocks(const struct echoaudio *chip)
 {
         return ECHO_CLOCK_BIT_INTERNAL;
diff --git a/sound/pci/echoaudio/indigodjx.c b/sound/pci/echoaudio/indigodjx.c
index 2e44316530a2..19b191fd0120 100644
--- a/sound/pci/echoaudio/indigodjx.c
+++ b/sound/pci/echoaudio/indigodjx.c
@@ -42,10 +42,10 @@
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/pci.h>
-#include <linux/slab.h>
 #include <linux/moduleparam.h>
 #include <linux/firmware.h>
 #include <linux/io.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -68,7 +68,7 @@ static const struct firmware card_fw[] = {
         {0, "indigo_djx_dsp.fw"}
 };
 
-static struct pci_device_id snd_echo_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_echo_ids) = {
         {0x1057, 0x3410, 0xECC0, 0x00E0, 0, 0, 0},      /* Indigo DJx*/
         {0,}
 };
diff --git a/sound/pci/echoaudio/indigodjx_dsp.c b/sound/pci/echoaudio/indigodjx_dsp.c
index f591fc2ed960..bb9632c752a9 100644
--- a/sound/pci/echoaudio/indigodjx_dsp.c
+++ b/sound/pci/echoaudio/indigodjx_dsp.c
@@ -48,7 +48,7 @@ static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
         chip->device_id = device_id;
         chip->subdevice_id = subdevice_id;
         chip->bad_board = TRUE;
-        chip->dsp_code_to_load = &card_fw[FW_INDIGO_DJX_DSP];
+        chip->dsp_code_to_load = FW_INDIGO_DJX_DSP;
         /* Since this card has no ASIC, mark it as loaded so everything
            works OK */
         chip->asic_loaded = TRUE;
@@ -59,10 +59,13 @@ static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
                 return err;
         chip->bad_board = FALSE;
 
-        err = init_line_levels(chip);
-        if (err < 0)
-                return err;
-
         DE_INIT(("init_hw done\n"));
         return err;
 }
+
+
+
+static int set_mixer_defaults(struct echoaudio *chip)
+{
+        return init_line_levels(chip);
+}
diff --git a/sound/pci/echoaudio/indigoio.c b/sound/pci/echoaudio/indigoio.c
index a60c0a0a89b7..a9fcedf317a4 100644
--- a/sound/pci/echoaudio/indigoio.c
+++ b/sound/pci/echoaudio/indigoio.c
@@ -43,9 +43,9 @@
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/pci.h>
-#include <linux/slab.h>
 #include <linux/moduleparam.h>
 #include <linux/firmware.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -69,7 +69,7 @@ static const struct firmware card_fw[] = {
         {0, "indigo_io_dsp.fw"}
 };
 
-static struct pci_device_id snd_echo_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_echo_ids) = {
         {0x1057, 0x3410, 0xECC0, 0x00A0, 0, 0, 0},      /* Indigo IO*/
         {0,}
 };
diff --git a/sound/pci/echoaudio/indigoio_dsp.c b/sound/pci/echoaudio/indigoio_dsp.c
index 0604c8a85223..beb9a5b69892 100644
--- a/sound/pci/echoaudio/indigoio_dsp.c
+++ b/sound/pci/echoaudio/indigoio_dsp.c
@@ -50,7 +50,7 @@ static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
         chip->device_id = device_id;
         chip->subdevice_id = subdevice_id;
         chip->bad_board = TRUE;
-        chip->dsp_code_to_load = &card_fw[FW_INDIGO_IO_DSP];
+        chip->dsp_code_to_load = FW_INDIGO_IO_DSP;
         /* Since this card has no ASIC, mark it as loaded so everything
            works OK */
         chip->asic_loaded = TRUE;
@@ -60,15 +60,19 @@ static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
                 return err;
         chip->bad_board = FALSE;
 
-        if ((err = init_line_levels(chip)) < 0)
-                return err;
-
         DE_INIT(("init_hw done\n"));
         return err;
 }
 
 
 
+static int set_mixer_defaults(struct echoaudio *chip)
+{
+        return init_line_levels(chip);
+}
+
+
+
 static u32 detect_input_clocks(const struct echoaudio *chip)
 {
         return ECHO_CLOCK_BIT_INTERNAL;
diff --git a/sound/pci/echoaudio/indigoiox.c b/sound/pci/echoaudio/indigoiox.c
index eb3819f9654a..bcdfac63212c 100644
--- a/sound/pci/echoaudio/indigoiox.c
+++ b/sound/pci/echoaudio/indigoiox.c
@@ -43,10 +43,10 @@
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/pci.h>
-#include <linux/slab.h>
 #include <linux/moduleparam.h>
 #include <linux/firmware.h>
 #include <linux/io.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -69,7 +69,7 @@ static const struct firmware card_fw[] = {
         {0, "indigo_iox_dsp.fw"}
 };
 
-static struct pci_device_id snd_echo_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_echo_ids) = {
         {0x1057, 0x3410, 0xECC0, 0x00D0, 0, 0, 0},      /* Indigo IOx */
         {0,}
 };
diff --git a/sound/pci/echoaudio/indigoiox_dsp.c b/sound/pci/echoaudio/indigoiox_dsp.c
index f357521c79e6..394c6e76bcbc 100644
--- a/sound/pci/echoaudio/indigoiox_dsp.c
+++ b/sound/pci/echoaudio/indigoiox_dsp.c
@@ -48,7 +48,7 @@ static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
         chip->device_id = device_id;
         chip->subdevice_id = subdevice_id;
         chip->bad_board = TRUE;
-        chip->dsp_code_to_load = &card_fw[FW_INDIGO_IOX_DSP];
+        chip->dsp_code_to_load = FW_INDIGO_IOX_DSP;
         /* Since this card has no ASIC, mark it as loaded so everything
            works OK */
         chip->asic_loaded = TRUE;
@@ -59,10 +59,13 @@ static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
                 return err;
         chip->bad_board = FALSE;
 
-        err = init_line_levels(chip);
-        if (err < 0)
-                return err;
-
         DE_INIT(("init_hw done\n"));
         return err;
 }
+
+
+
+static int set_mixer_defaults(struct echoaudio *chip)
+{
+        return init_line_levels(chip);
+}
diff --git a/sound/pci/echoaudio/layla20.c b/sound/pci/echoaudio/layla20.c
index 506194688995..d3a98c5dac86 100644
--- a/sound/pci/echoaudio/layla20.c
+++ b/sound/pci/echoaudio/layla20.c
@@ -49,9 +49,9 @@
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/pci.h>
-#include <linux/slab.h>
 #include <linux/moduleparam.h>
 #include <linux/firmware.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -76,7 +76,7 @@ static const struct firmware card_fw[] = {
         {0, "layla20_asic.fw"}
 };
 
-static struct pci_device_id snd_echo_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_echo_ids) = {
         {0x1057, 0x1801, 0xECC0, 0x0030, 0, 0, 0},      /* DSP 56301 Layla20 rev.0 */
         {0x1057, 0x1801, 0xECC0, 0x0031, 0, 0, 0},      /* DSP 56301 Layla20 rev.1 */
         {0,}
diff --git a/sound/pci/echoaudio/layla20_dsp.c b/sound/pci/echoaudio/layla20_dsp.c
index 83750e9fd7b4..53ce94605044 100644
--- a/sound/pci/echoaudio/layla20_dsp.c
+++ b/sound/pci/echoaudio/layla20_dsp.c
@@ -31,8 +31,7 @@
 
 static int read_dsp(struct echoaudio *chip, u32 *data);
 static int set_professional_spdif(struct echoaudio *chip, char prof);
-static int load_asic_generic(struct echoaudio *chip, u32 cmd,
-                             const struct firmware *asic);
+static int load_asic_generic(struct echoaudio *chip, u32 cmd, short asic);
 static int check_asic_status(struct echoaudio *chip);
 static int update_flags(struct echoaudio *chip);
 
@@ -54,7 +53,7 @@ static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
         chip->subdevice_id = subdevice_id;
         chip->bad_board = TRUE;
         chip->has_midi = TRUE;
-        chip->dsp_code_to_load = &card_fw[FW_LAYLA20_DSP];
+        chip->dsp_code_to_load = FW_LAYLA20_DSP;
         chip->input_clock_types =
                 ECHO_CLOCK_BIT_INTERNAL | ECHO_CLOCK_BIT_SPDIF |
                 ECHO_CLOCK_BIT_WORD | ECHO_CLOCK_BIT_SUPER;
@@ -65,17 +64,20 @@ static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
                 return err;
         chip->bad_board = FALSE;
 
-        if ((err = init_line_levels(chip)) < 0)
-                return err;
-
-        err = set_professional_spdif(chip, TRUE);
-
         DE_INIT(("init_hw done\n"));
         return err;
 }
 
 
 
+static int set_mixer_defaults(struct echoaudio *chip)
+{
+        chip->professional_spdif = FALSE;
+        return init_line_levels(chip);
+}
+
+
+
 static u32 detect_input_clocks(const struct echoaudio *chip)
 {
         u32 clocks_from_dsp, clock_bits;
@@ -144,7 +146,7 @@ static int load_asic(struct echoaudio *chip)
                 return 0;
 
         err = load_asic_generic(chip, DSP_FNC_LOAD_LAYLA_ASIC,
-                                &card_fw[FW_LAYLA20_ASIC]);
+                                FW_LAYLA20_ASIC);
         if (err < 0)
                 return err;
 
diff --git a/sound/pci/echoaudio/layla24.c b/sound/pci/echoaudio/layla24.c
index e09e3ea7781e..2a1dca6dce17 100644
--- a/sound/pci/echoaudio/layla24.c
+++ b/sound/pci/echoaudio/layla24.c
@@ -51,9 +51,9 @@
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/pci.h>
-#include <linux/slab.h>
 #include <linux/moduleparam.h>
 #include <linux/firmware.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -87,7 +87,7 @@ static const struct firmware card_fw[] = {
         {0, "layla24_2S_asic.fw"}
 };
 
-static struct pci_device_id snd_echo_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_echo_ids) = {
         {0x1057, 0x3410, 0xECC0, 0x0060, 0, 0, 0},      /* DSP 56361 Layla24 rev.0 */
         {0,}
 };
diff --git a/sound/pci/echoaudio/layla24_dsp.c b/sound/pci/echoaudio/layla24_dsp.c
index d61b5cbcccad..8c041647f285 100644
--- a/sound/pci/echoaudio/layla24_dsp.c
+++ b/sound/pci/echoaudio/layla24_dsp.c
@@ -32,8 +32,7 @@ static int write_control_reg(struct echoaudio *chip, u32 value, char force);
 static int set_input_clock(struct echoaudio *chip, u16 clock);
 static int set_professional_spdif(struct echoaudio *chip, char prof);
 static int set_digital_mode(struct echoaudio *chip, u8 mode);
-static int load_asic_generic(struct echoaudio *chip, u32 cmd,
-                             const struct firmware *asic);
+static int load_asic_generic(struct echoaudio *chip, u32 cmd, short asic);
 static int check_asic_status(struct echoaudio *chip);
 
 
@@ -54,7 +53,7 @@ static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
         chip->subdevice_id = subdevice_id;
         chip->bad_board = TRUE;
         chip->has_midi = TRUE;
-        chip->dsp_code_to_load = &card_fw[FW_LAYLA24_DSP];
+        chip->dsp_code_to_load = FW_LAYLA24_DSP;
         chip->input_clock_types =
                 ECHO_CLOCK_BIT_INTERNAL | ECHO_CLOCK_BIT_SPDIF |
                 ECHO_CLOCK_BIT_WORD | ECHO_CLOCK_BIT_ADAT;
@@ -62,9 +61,6 @@ static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
                 ECHOCAPS_HAS_DIGITAL_MODE_SPDIF_RCA |
                 ECHOCAPS_HAS_DIGITAL_MODE_SPDIF_OPTICAL |
                 ECHOCAPS_HAS_DIGITAL_MODE_ADAT;
-        chip->digital_mode =            DIGITAL_MODE_SPDIF_RCA;
-        chip->professional_spdif = FALSE;
-        chip->digital_in_automute = TRUE;
 
         if ((err = load_firmware(chip)) < 0)
                 return err;
@@ -73,17 +69,22 @@ static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
         if ((err = init_line_levels(chip)) < 0)
                 return err;
 
-        err = set_digital_mode(chip, DIGITAL_MODE_SPDIF_RCA);
-        if (err < 0)
-                return err;
-        err = set_professional_spdif(chip, TRUE);
-
         DE_INIT(("init_hw done\n"));
         return err;
 }
 
 
 
+static int set_mixer_defaults(struct echoaudio *chip)
+{
+        chip->digital_mode = DIGITAL_MODE_SPDIF_RCA;
+        chip->professional_spdif = FALSE;
+        chip->digital_in_automute = TRUE;
+        return init_line_levels(chip);
+}
+
+
+
 static u32 detect_input_clocks(const struct echoaudio *chip)
 {
         u32 clocks_from_dsp, clock_bits;
@@ -123,18 +124,18 @@ static int load_asic(struct echoaudio *chip)
 
         /* Load the ASIC for the PCI card */
         err = load_asic_generic(chip, DSP_FNC_LOAD_LAYLA24_PCI_CARD_ASIC,
-                                &card_fw[FW_LAYLA24_1_ASIC]);
+                                FW_LAYLA24_1_ASIC);
         if (err < 0)
                 return err;
 
-        chip->asic_code = &card_fw[FW_LAYLA24_2S_ASIC];
+        chip->asic_code = FW_LAYLA24_2S_ASIC;
 
         /* Now give the new ASIC a little time to set up */
         mdelay(10);
 
         /* Do the external one */
         err = load_asic_generic(chip, DSP_FNC_LOAD_LAYLA24_EXTERNAL_ASIC,
-                                &card_fw[FW_LAYLA24_2S_ASIC]);
+                                FW_LAYLA24_2S_ASIC);
         if (err < 0)
                 return FALSE;
 
@@ -299,7 +300,7 @@ static int set_input_clock(struct echoaudio *chip, u16 clock)
 /* Depending on what digital mode you want, Layla24 needs different ASICs
 loaded.  This function checks the ASIC needed for the new mode and sees
 if it matches the one already loaded. */
-static int switch_asic(struct echoaudio *chip, const struct firmware *asic)
+static int switch_asic(struct echoaudio *chip, short asic)
 {
         s8 *monitors;
 
@@ -335,7 +336,7 @@ static int dsp_set_digital_mode(struct echoaudio *chip, u8 mode)
 {
         u32 control_reg;
         int err, incompatible_clock;
-        const struct firmware *asic;
+        short asic;
 
         /* Set clock to "internal" if it's not compatible with the new mode */
         incompatible_clock = FALSE;
@@ -344,12 +345,12 @@ static int dsp_set_digital_mode(struct echoaudio *chip, u8 mode)
         case DIGITAL_MODE_SPDIF_RCA:
                 if (chip->input_clock == ECHO_CLOCK_ADAT)
                         incompatible_clock = TRUE;
-                asic = &card_fw[FW_LAYLA24_2S_ASIC];
+                asic = FW_LAYLA24_2S_ASIC;
                 break;
         case DIGITAL_MODE_ADAT:
                 if (chip->input_clock == ECHO_CLOCK_SPDIF)
                         incompatible_clock = TRUE;
-                asic = &card_fw[FW_LAYLA24_2A_ASIC];
+                asic = FW_LAYLA24_2A_ASIC;
                 break;
         default:
                 DE_ACT(("Digital mode not supported: %d\n", mode));
diff --git a/sound/pci/echoaudio/mia.c b/sound/pci/echoaudio/mia.c
index f05c8c097aa8..9cdf14cfdd74 100644
--- a/sound/pci/echoaudio/mia.c
+++ b/sound/pci/echoaudio/mia.c
@@ -50,9 +50,9 @@
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/pci.h>
-#include <linux/slab.h>
 #include <linux/moduleparam.h>
 #include <linux/firmware.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -77,7 +77,7 @@ static const struct firmware card_fw[] = {
         {0, "mia_dsp.fw"}
 };
 
-static struct pci_device_id snd_echo_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_echo_ids) = {
         {0x1057, 0x3410, 0xECC0, 0x0080, 0, 0, 0},      /* DSP 56361 Mia rev.0 */
         {0x1057, 0x3410, 0xECC0, 0x0081, 0, 0, 0},      /* DSP 56361 Mia rev.1 */
         {0,}
diff --git a/sound/pci/echoaudio/mia_dsp.c b/sound/pci/echoaudio/mia_dsp.c
index 551405114cbc..6ebfa6e7ab9e 100644
--- a/sound/pci/echoaudio/mia_dsp.c
+++ b/sound/pci/echoaudio/mia_dsp.c
@@ -53,7 +53,7 @@ static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
         chip->device_id = device_id;
         chip->subdevice_id = subdevice_id;
         chip->bad_board = TRUE;
-        chip->dsp_code_to_load = &card_fw[FW_MIA_DSP];
+        chip->dsp_code_to_load = FW_MIA_DSP;
         /* Since this card has no ASIC, mark it as loaded so everything
            works OK */
         chip->asic_loaded = TRUE;
@@ -66,15 +66,19 @@ static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
                 return err;
         chip->bad_board = FALSE;
 
-        if ((err = init_line_levels(chip)))
-                return err;
-
         DE_INIT(("init_hw done\n"));
         return err;
 }
 
 
 
+static int set_mixer_defaults(struct echoaudio *chip)
+{
+        return init_line_levels(chip);
+}
+
+
+
 static u32 detect_input_clocks(const struct echoaudio *chip)
 {
         u32 clocks_from_dsp, clock_bits;
diff --git a/sound/pci/echoaudio/mona.c b/sound/pci/echoaudio/mona.c
index b05bad944901..1047be405ebe 100644
--- a/sound/pci/echoaudio/mona.c
+++ b/sound/pci/echoaudio/mona.c
@@ -48,9 +48,9 @@
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/pci.h>
-#include <linux/slab.h>
 #include <linux/moduleparam.h>
 #include <linux/firmware.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -92,7 +92,7 @@ static const struct firmware card_fw[] = {
         {0, "mona_2_asic.fw"}
 };
 
-static struct pci_device_id snd_echo_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_echo_ids) = {
         {0x1057, 0x1801, 0xECC0, 0x0070, 0, 0, 0},      /* DSP 56301 Mona rev.0 */
         {0x1057, 0x1801, 0xECC0, 0x0071, 0, 0, 0},      /* DSP 56301 Mona rev.1 */
         {0x1057, 0x1801, 0xECC0, 0x0072, 0, 0, 0},      /* DSP 56301 Mona rev.2 */
diff --git a/sound/pci/echoaudio/mona_dsp.c b/sound/pci/echoaudio/mona_dsp.c
index eaa619bd2a03..6e6a7eb555b8 100644
--- a/sound/pci/echoaudio/mona_dsp.c
+++ b/sound/pci/echoaudio/mona_dsp.c
@@ -33,8 +33,7 @@ static int write_control_reg(struct echoaudio *chip, u32 value, char force);
 static int set_input_clock(struct echoaudio *chip, u16 clock);
 static int set_professional_spdif(struct echoaudio *chip, char prof);
 static int set_digital_mode(struct echoaudio *chip, u8 mode);
-static int load_asic_generic(struct echoaudio *chip, u32 cmd,
-                             const struct firmware *asic);
+static int load_asic_generic(struct echoaudio *chip, u32 cmd, short asic);
 static int check_asic_status(struct echoaudio *chip);
 
 
@@ -64,32 +63,30 @@ static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
 
         /* Mona comes in both '301 and '361 flavors */
         if (chip->device_id == DEVICE_ID_56361)
-                chip->dsp_code_to_load = &card_fw[FW_MONA_361_DSP];
+                chip->dsp_code_to_load = FW_MONA_361_DSP;
         else
-                chip->dsp_code_to_load = &card_fw[FW_MONA_301_DSP];
-
-        chip->digital_mode = DIGITAL_MODE_SPDIF_RCA;
-        chip->professional_spdif = FALSE;
-        chip->digital_in_automute = TRUE;
+                chip->dsp_code_to_load = FW_MONA_301_DSP;
 
         if ((err = load_firmware(chip)) < 0)
                 return err;
         chip->bad_board = FALSE;
 
-        if ((err = init_line_levels(chip)) < 0)
-                return err;
-
-        err = set_digital_mode(chip, DIGITAL_MODE_SPDIF_RCA);
-        if (err < 0)
-                return err;
-        err = set_professional_spdif(chip, TRUE);
-
         DE_INIT(("init_hw done\n"));
         return err;
 }
 
 
 
+static int set_mixer_defaults(struct echoaudio *chip)
+{
+        chip->digital_mode = DIGITAL_MODE_SPDIF_RCA;
+        chip->professional_spdif = FALSE;
+        chip->digital_in_automute = TRUE;
+        return init_line_levels(chip);
+}
+
+
+
 static u32 detect_input_clocks(const struct echoaudio *chip)
 {
         u32 clocks_from_dsp, clock_bits;
@@ -120,7 +117,7 @@ static int load_asic(struct echoaudio *chip)
 {
         u32 control_reg;
         int err;
-        const struct firmware *asic;
+        short asic;
 
         if (chip->asic_loaded)
                 return 0;
@@ -128,9 +125,9 @@ static int load_asic(struct echoaudio *chip)
         mdelay(10);
 
         if (chip->device_id == DEVICE_ID_56361)
-                asic = &card_fw[FW_MONA_361_1_ASIC48];
+                asic = FW_MONA_361_1_ASIC48;
         else
-                asic = &card_fw[FW_MONA_301_1_ASIC48];
+                asic = FW_MONA_301_1_ASIC48;
 
         err = load_asic_generic(chip, DSP_FNC_LOAD_MONA_PCI_CARD_ASIC, asic);
         if (err < 0)
@@ -141,7 +138,7 @@ static int load_asic(struct echoaudio *chip)
 
         /* Do the external one */
         err = load_asic_generic(chip, DSP_FNC_LOAD_MONA_EXTERNAL_ASIC,
-                                &card_fw[FW_MONA_2_ASIC]);
+                                FW_MONA_2_ASIC);
         if (err < 0)
                 return err;
 
@@ -165,22 +162,22 @@ loaded.  This function checks the ASIC needed for the new mode and sees
 if it matches the one already loaded. */
 static int switch_asic(struct echoaudio *chip, char double_speed)
 {
-        const struct firmware *asic;
         int err;
+        short asic;
 
         /* Check the clock detect bits to see if this is
         a single-speed clock or a double-speed clock; load
         a new ASIC if necessary. */
         if (chip->device_id == DEVICE_ID_56361) {
                 if (double_speed)
-                        asic = &card_fw[FW_MONA_361_1_ASIC96];
+                        asic = FW_MONA_361_1_ASIC96;
                 else
-                        asic = &card_fw[FW_MONA_361_1_ASIC48];
+                        asic = FW_MONA_361_1_ASIC48;
         } else {
                 if (double_speed)
-                        asic = &card_fw[FW_MONA_301_1_ASIC96];
+                        asic = FW_MONA_301_1_ASIC96;
                 else
-                        asic = &card_fw[FW_MONA_301_1_ASIC48];
+                        asic = FW_MONA_301_1_ASIC48;
         }
 
         if (asic != chip->asic_code) {
@@ -200,7 +197,7 @@ static int switch_asic(struct echoaudio *chip, char double_speed)
 static int set_sample_rate(struct echoaudio *chip, u32 rate)
 {
         u32 control_reg, clock;
-        const struct firmware *asic;
+        short asic;
         char force_write;
 
         /* Only set the clock for internal mode. */
@@ -218,14 +215,14 @@ static int set_sample_rate(struct echoaudio *chip, u32 rate)
                 if (chip->digital_mode == DIGITAL_MODE_ADAT)
                         return -EINVAL;
                 if (chip->device_id == DEVICE_ID_56361)
-                        asic = &card_fw[FW_MONA_361_1_ASIC96];
+                        asic = FW_MONA_361_1_ASIC96;
                 else
-                        asic = &card_fw[FW_MONA_301_1_ASIC96];
+                        asic = FW_MONA_301_1_ASIC96;
         } else {
                 if (chip->device_id == DEVICE_ID_56361)
-                        asic = &card_fw[FW_MONA_361_1_ASIC48];
+                        asic = FW_MONA_361_1_ASIC48;
                 else
-                        asic = &card_fw[FW_MONA_301_1_ASIC48];
+                        asic = FW_MONA_301_1_ASIC48;
         }
 
         force_write = 0;
@@ -410,8 +407,8 @@ static int dsp_set_digital_mode(struct echoaudio *chip, u8 mode)
         case DIGITAL_MODE_ADAT:
                 /* If the current ASIC is the 96KHz ASIC, switch the ASIC
                    and set to 48 KHz */
-                if (chip->asic_code == &card_fw[FW_MONA_361_1_ASIC96] ||
-                    chip->asic_code == &card_fw[FW_MONA_301_1_ASIC96]) {
+                if (chip->asic_code == FW_MONA_361_1_ASIC96 ||
+                    chip->asic_code == FW_MONA_301_1_ASIC96) {
                         set_sample_rate(chip, 48000);
                 }
                 control_reg |= GML_ADAT_MODE;
diff --git a/sound/pci/emu10k1/emu10k1.c b/sound/pci/emu10k1/emu10k1.c
index 168af67d938e..4203782d7cb7 100644
--- a/sound/pci/emu10k1/emu10k1.c
+++ b/sound/pci/emu10k1/emu10k1.c
@@ -76,7 +76,7 @@ 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[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_emu10k1_ids) = {
         { PCI_VDEVICE(CREATIVE, 0x0002), 0 },   /* EMU10K1 */
         { PCI_VDEVICE(CREATIVE, 0x0004), 1 },   /* Audigy */
         { PCI_VDEVICE(CREATIVE, 0x0008), 1 },   /* Audigy 2 Value SB0400 */
diff --git a/sound/pci/emu10k1/emu10k1x.c b/sound/pci/emu10k1/emu10k1x.c
index 36e08bd2b3cc..df47f738098d 100644
--- a/sound/pci/emu10k1/emu10k1x.c
+++ b/sound/pci/emu10k1/emu10k1x.c
@@ -184,7 +184,7 @@ MODULE_PARM_DESC(enable, "Enable the EMU10K1X soundcard.");
  * The hardware has 3 channels for playback and 1 for capture.
  *  - channel 0 is the front channel
  *  - channel 1 is the rear channel
- *  - channel 2 is the center/lfe chanel
+ *  - channel 2 is the center/lfe channel
  * Volume is controlled by the AC97 for the front and rear channels by
  * the PCM Playback Volume, Sigmatel Surround Playback Volume and 
  * Surround Playback Volume. The Sigmatel 4-Speaker Stereo switch affects
@@ -1040,8 +1040,7 @@ static void snd_emu10k1x_proc_reg_write(struct snd_info_entry *entry,
                 if (sscanf(line, "%x %x %x", &reg, &channel_id, &val) != 3)
                         continue;
 
-                if ((reg < 0x49) && (reg >= 0) && (val <= 0xffffffff) 
-                    && (channel_id >= 0) && (channel_id <= 2) )
+                if (reg < 0x49 && val <= 0xffffffff && channel_id <= 2)
                         snd_emu10k1x_ptr_write(emu, reg, channel_id, val);
         }
 }
@@ -1606,7 +1605,7 @@ static void __devexit snd_emu10k1x_remove(struct pci_dev *pci)
 }
 
 // PCI IDs
-static struct pci_device_id snd_emu10k1x_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_emu10k1x_ids) = {
         { PCI_VDEVICE(CREATIVE, 0x0006), 0 },   /* Dell OEM version (EMU10K1) */
         { 0, }
 };
diff --git a/sound/pci/emu10k1/emumixer.c b/sound/pci/emu10k1/emumixer.c
index b0fb6c917c38..05afe06e353a 100644
--- a/sound/pci/emu10k1/emumixer.c
+++ b/sound/pci/emu10k1/emumixer.c
@@ -1818,8 +1818,8 @@ int __devinit snd_emu10k1_mixer(struct snd_emu10k1 *emu,
                 "Master Playback Switch", "Master Capture Switch",
                 "Master Playback Volume", "Master Capture Volume",
                 "Wave Master Playback Volume", "Master Playback Volume",
-                "PC Speaker Playback Switch", "PC Speaker Capture Switch",
-                "PC Speaker Playback Volume", "PC Speaker Capture Volume",
+                "Beep Playback Switch", "Beep Capture Switch",
+                "Beep Playback Volume", "Beep Capture Volume",
                 "Phone Playback Switch", "Phone Capture Switch",
                 "Phone Playback Volume", "Phone Capture Volume",
                 "Mic Playback Switch", "Mic Capture Switch",
diff --git a/sound/pci/emu10k1/emuproc.c b/sound/pci/emu10k1/emuproc.c
index 216f9748aff5..baa7cd508cd8 100644
--- a/sound/pci/emu10k1/emuproc.c
+++ b/sound/pci/emu10k1/emuproc.c
@@ -451,7 +451,7 @@ static void snd_emu_proc_io_reg_write(struct snd_info_entry *entry,
         while (!snd_info_get_line(buffer, line, sizeof(line))) {
                 if (sscanf(line, "%x %x", &reg, &val) != 2)
                         continue;
-                if ((reg < 0x40) && (reg >= 0) && (val <= 0xffffffff) ) {
+                if (reg < 0x40 && val <= 0xffffffff) {
                         spin_lock_irqsave(&emu->emu_lock, flags);
                         outl(val, emu->port + (reg & 0xfffffffc));
                         spin_unlock_irqrestore(&emu->emu_lock, flags);
@@ -527,7 +527,7 @@ static void snd_emu_proc_ptr_reg_write(struct snd_info_entry *entry,
         while (!snd_info_get_line(buffer, line, sizeof(line))) {
                 if (sscanf(line, "%x %x %x", &reg, &channel_id, &val) != 3)
                         continue;
-                if ((reg < 0xa0) && (reg >= 0) && (val <= 0xffffffff) && (channel_id >= 0) && (channel_id <= 3) )
+                if (reg < 0xa0 && val <= 0xffffffff && channel_id <= 3)
                         snd_ptr_write(emu, iobase, reg, channel_id, val);
         }
 }
diff --git a/sound/pci/emu10k1/io.c b/sound/pci/emu10k1/io.c
index c1a5aa15af8f..5ef7080e14d0 100644
--- a/sound/pci/emu10k1/io.c
+++ b/sound/pci/emu10k1/io.c
@@ -256,7 +256,7 @@ int snd_emu1010_fpga_write(struct snd_emu10k1 * emu, u32 reg, u32 value)
         if (reg > 0x3f)
                 return 1;
         reg += 0x40; /* 0x40 upwards are registers. */
-        if (value < 0 || value > 0x3f) /* 0 to 0x3f are values */
+        if (value > 0x3f) /* 0 to 0x3f are values */
                 return 1;
         spin_lock_irqsave(&emu->emu_lock, flags);
         outl(reg, emu->port + A_IOCFG);
diff --git a/sound/pci/emu10k1/memory.c b/sound/pci/emu10k1/memory.c
index 6a47672f930a..ffb1ddb8dc28 100644
--- a/sound/pci/emu10k1/memory.c
+++ b/sound/pci/emu10k1/memory.c
@@ -22,6 +22,7 @@
  */
 
 #include <linux/pci.h>
+#include <linux/gfp.h>
 #include <linux/time.h>
 #include <linux/mutex.h>
 
diff --git a/sound/pci/ens1370.c b/sound/pci/ens1370.c
index 2b82c5c723e1..c7fba5379813 100644
--- a/sound/pci/ens1370.c
+++ b/sound/pci/ens1370.c
@@ -443,7 +443,7 @@ struct ensoniq {
 
 static irqreturn_t snd_audiopci_interrupt(int irq, void *dev_id);
 
-static struct pci_device_id snd_audiopci_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_audiopci_ids) = {
 #ifdef CHIP1370
         { PCI_VDEVICE(ENSONIQ, 0x5000), 0, },   /* ES1370 */
 #endif
diff --git a/sound/pci/es1938.c b/sound/pci/es1938.c
index 820318ee62c1..553b75217259 100644
--- a/sound/pci/es1938.c
+++ b/sound/pci/es1938.c
@@ -243,7 +243,7 @@ struct es1938 {
 
 static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id);
 
-static struct pci_device_id snd_es1938_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_es1938_ids) = {
         { PCI_VDEVICE(ESS, 0x1969), 0, },   /* Solo-1 */
         { 0, }
 };
@@ -1387,7 +1387,7 @@ ES1938_DOUBLE_TLV("Aux Playback Volume", 0, 0x3a, 0x3a, 4, 0, 15, 0,
                   db_scale_line),
 ES1938_DOUBLE_TLV("Capture Volume", 0, 0xb4, 0xb4, 4, 0, 15, 0,
                   db_scale_capture),
-ES1938_SINGLE("PC Speaker Volume", 0, 0x3c, 0, 7, 0),
+ES1938_SINGLE("Beep Volume", 0, 0x3c, 0, 7, 0),
 ES1938_SINGLE("Record Monitor", 0, 0xa8, 3, 1, 0),
 ES1938_SINGLE("Capture Switch", 0, 0x1c, 4, 1, 1),
 {
diff --git a/sound/pci/es1968.c b/sound/pci/es1968.c
index a11f453a6b6d..ecaea9fb48ec 100644
--- a/sound/pci/es1968.c
+++ b/sound/pci/es1968.c
@@ -551,7 +551,7 @@ struct es1968 {
 
 static irqreturn_t snd_es1968_interrupt(int irq, void *dev_id);
 
-static struct pci_device_id snd_es1968_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_es1968_ids) = {
         /* Maestro 1 */
         { 0x1285, 0x0100, PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_MULTIMEDIA_AUDIO << 8, 0xffff00, TYPE_MAESTRO },
         /* Maestro 2 */
diff --git a/sound/pci/fm801.c b/sound/pci/fm801.c
index 60cdb9e0b68d..e1baad74ea4b 100644
--- a/sound/pci/fm801.c
+++ b/sound/pci/fm801.c
@@ -55,7 +55,7 @@ static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;	/* Enable this card *
  *    1 = MediaForte 256-PCS
  *    2 = MediaForte 256-PCPR
  *    3 = MediaForte 64-PCR
- *   16 = setup tuner only (this is additional bit), i.e. SF-64-PCR FM card
+ *   16 = setup tuner only (this is additional bit), i.e. SF64-PCR FM card
  *  High 16-bits are video (radio) device number + 1
  */
 static int tea575x_tuner[SNDRV_CARDS];
@@ -67,7 +67,10 @@ MODULE_PARM_DESC(id, "ID string for the FM801 soundcard.");
 module_param_array(enable, bool, NULL, 0444);
 MODULE_PARM_DESC(enable, "Enable FM801 soundcard.");
 module_param_array(tea575x_tuner, int, NULL, 0444);
-MODULE_PARM_DESC(tea575x_tuner, "Enable TEA575x tuner.");
+MODULE_PARM_DESC(tea575x_tuner, "TEA575x tuner access method (1 = SF256-PCS, 2=SF256-PCPR, 3=SF64-PCR, +16=tuner-only).");
+
+#define TUNER_ONLY              (1<<4)
+#define TUNER_TYPE_MASK         (~TUNER_ONLY & 0xFFFF)
 
 /*
  *  Direct registers
@@ -160,7 +163,7 @@ struct fm801 {
         unsigned int multichannel: 1,   /* multichannel support */
                      secondary: 1;      /* secondary codec */
         unsigned char secondary_addr;   /* address of the secondary codec */
-        unsigned int tea575x_tuner;     /* tuner flags */
+        unsigned int tea575x_tuner;     /* tuner access method & flags */
 
         unsigned short ply_ctrl; /* playback control */
         unsigned short cap_ctrl; /* capture control */
@@ -202,7 +205,7 @@ struct fm801 {
 #endif
 };
 
-static struct pci_device_id snd_fm801_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_fm801_ids) = {
         { 0x1319, 0x0801, PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_MULTIMEDIA_AUDIO << 8, 0xffff00, 0, },   /* FM801 */
         { 0x5213, 0x0510, PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_MULTIMEDIA_AUDIO << 8, 0xffff00, 0, },   /* Gallant Odyssey Sound 4 */
         { 0, }
@@ -1287,7 +1290,7 @@ static int snd_fm801_chip_init(struct fm801 *chip, int resume)
 {
         unsigned short cmdw;
 
-        if (chip->tea575x_tuner & 0x0010)
+        if (chip->tea575x_tuner & TUNER_ONLY)
                 goto __ac97_ok;
 
         /* codec cold reset + AC'97 warm reset */
@@ -1296,11 +1299,13 @@ static int snd_fm801_chip_init(struct fm801 *chip, int resume)
         udelay(100);
         outw(0, FM801_REG(chip, CODEC_CTRL));
 
-        if (wait_for_codec(chip, 0, AC97_RESET, msecs_to_jiffies(750)) < 0) {
-                snd_printk(KERN_ERR "Primary AC'97 codec not found\n");
-                if (! resume)
-                        return -EIO;
-        }
+        if (wait_for_codec(chip, 0, AC97_RESET, msecs_to_jiffies(750)) < 0)
+                if (!resume) {
+                        snd_printk(KERN_INFO "Primary AC'97 codec not found, "
+                                            "assume SF64-PCR (tuner-only)\n");
+                        chip->tea575x_tuner = 3 | TUNER_ONLY;
+                        goto __ac97_ok;
+                }
 
         if (chip->multichannel) {
                 if (chip->secondary_addr) {
@@ -1414,7 +1419,7 @@ static int __devinit snd_fm801_create(struct snd_card *card,
                 return err;
         }
         chip->port = pci_resource_start(pci, 0);
-        if ((tea575x_tuner & 0x0010) == 0) {
+        if ((tea575x_tuner & TUNER_ONLY) == 0) {
                 if (request_irq(pci->irq, snd_fm801_interrupt, IRQF_SHARED,
                                 "FM801", chip)) {
                         snd_printk(KERN_ERR "unable to grab IRQ %d\n", chip->irq);
@@ -1429,6 +1434,14 @@ static int __devinit snd_fm801_create(struct snd_card *card,
                 chip->multichannel = 1;
 
         snd_fm801_chip_init(chip, 0);
+        /* init might set tuner access method */
+        tea575x_tuner = chip->tea575x_tuner;
+
+        if (chip->irq >= 0 && (tea575x_tuner & TUNER_ONLY)) {
+                pci_clear_master(pci);
+                free_irq(chip->irq, chip);
+                chip->irq = -1;
+        }
 
         if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
                 snd_fm801_free(chip);
@@ -1438,12 +1451,13 @@ static int __devinit snd_fm801_create(struct snd_card *card,
         snd_card_set_dev(card, &pci->dev);
 
 #ifdef TEA575X_RADIO
-        if (tea575x_tuner > 0 && (tea575x_tuner & 0x000f) < 4) {
+        if ((tea575x_tuner & TUNER_TYPE_MASK) > 0 &&
+            (tea575x_tuner & TUNER_TYPE_MASK) < 4) {
                 chip->tea.dev_nr = tea575x_tuner >> 16;
                 chip->tea.card = card;
                 chip->tea.freq_fixup = 10700;
                 chip->tea.private_data = chip;
-                chip->tea.ops = &snd_fm801_tea_ops[(tea575x_tuner & 0x000f) - 1];
+                chip->tea.ops = &snd_fm801_tea_ops[(tea575x_tuner & TUNER_TYPE_MASK) - 1];
                 snd_tea575x_init(&chip->tea);
         }
 #endif
@@ -1483,7 +1497,7 @@ static int __devinit snd_card_fm801_probe(struct pci_dev *pci,
         sprintf(card->longname, "%s at 0x%lx, irq %i",
                 card->shortname, chip->port, chip->irq);
 
-        if (tea575x_tuner[dev] & 0x0010)
+        if (chip->tea575x_tuner & TUNER_ONLY)
                 goto __fm801_tuner_only;
 
         if ((err = snd_fm801_pcm(chip, 0, NULL)) < 0) {
diff --git a/sound/pci/hda/Kconfig b/sound/pci/hda/Kconfig
index 55545e0818b5..567348b05b5a 100644
--- a/sound/pci/hda/Kconfig
+++ b/sound/pci/hda/Kconfig
@@ -38,9 +38,20 @@ config SND_HDA_INPUT_BEEP
           Say Y here to build a digital beep interface for HD-audio
           driver. This interface is used to generate digital beeps.
 
+config SND_HDA_INPUT_BEEP_MODE
+        int "Digital beep registration mode (0=off, 1=on, 2=mute sw on/off)"
+        depends on SND_HDA_INPUT_BEEP=y
+        default "1"
+        range 0 2
+        help
+          Set 0 to disable the digital beep interface for HD-audio by default.
+          Set 1 to always enable the digital beep interface for HD-audio by
+          default. Set 2 to control the beep device registration to input
+          layer using a "Beep Switch" in mixer applications.
+
 config SND_HDA_INPUT_JACK
         bool "Support jack plugging notification via input layer"
-        depends on INPUT=y || INPUT=SND_HDA_INTEL
+        depends on INPUT=y || INPUT=SND
         select SND_JACK
         help
           Say Y here to enable the jack plugging notification via
@@ -146,7 +157,7 @@ config SND_HDA_CODEC_INTELHDMI
 
 config SND_HDA_ELD
         def_bool y
-        depends on SND_HDA_CODEC_INTELHDMI
+        depends on SND_HDA_CODEC_INTELHDMI || SND_HDA_CODEC_NVHDMI
 
 config SND_HDA_CODEC_CIRRUS
         bool "Build Cirrus Logic codec support"
diff --git a/sound/pci/hda/Makefile b/sound/pci/hda/Makefile
index 315a1c4f8998..24bc195b02da 100644
--- a/sound/pci/hda/Makefile
+++ b/sound/pci/hda/Makefile
@@ -3,7 +3,7 @@ snd-hda-intel-objs := hda_intel.o
 snd-hda-codec-y := hda_codec.o
 snd-hda-codec-$(CONFIG_SND_HDA_GENERIC) += hda_generic.o
 snd-hda-codec-$(CONFIG_PROC_FS) += hda_proc.o
-# snd-hda-codec-$(CONFIG_SND_HDA_ELD) += hda_eld.o
+snd-hda-codec-$(CONFIG_SND_HDA_ELD) += hda_eld.o
 snd-hda-codec-$(CONFIG_SND_HDA_HWDEP) += hda_hwdep.o
 snd-hda-codec-$(CONFIG_SND_HDA_INPUT_BEEP) += hda_beep.o
 
@@ -18,7 +18,7 @@ snd-hda-codec-ca0110-objs :=	patch_ca0110.o
 snd-hda-codec-conexant-objs :=  patch_conexant.o
 snd-hda-codec-via-objs :=       patch_via.o
 snd-hda-codec-nvhdmi-objs :=    patch_nvhdmi.o
-snd-hda-codec-intelhdmi-objs := patch_intelhdmi.o hda_eld.o
+snd-hda-codec-intelhdmi-objs := patch_intelhdmi.o
 
 # common driver
 obj-$(CONFIG_SND_HDA_INTEL) := snd-hda-codec.o
diff --git a/sound/pci/hda/hda_beep.c b/sound/pci/hda/hda_beep.c
index 3f51a981e604..29714c818b53 100644
--- a/sound/pci/hda/hda_beep.c
+++ b/sound/pci/hda/hda_beep.c
@@ -21,6 +21,7 @@
 
 #include <linux/input.h>
 #include <linux/pci.h>
+#include <linux/slab.h>
 #include <linux/workqueue.h>
 #include <sound/core.h>
 #include "hda_beep.h"
@@ -42,7 +43,7 @@ static void snd_hda_generate_beep(struct work_struct *work)
                 return;
 
         /* generate tone */
-        snd_hda_codec_write_cache(codec, beep->nid, 0,
+        snd_hda_codec_write(codec, beep->nid, 0,
                         AC_VERB_SET_BEEP_CONTROL, beep->tone);
 }
 
@@ -113,23 +114,25 @@ static int snd_hda_beep_event(struct input_dev *dev, unsigned int type,
         return 0;
 }
 
-int snd_hda_attach_beep_device(struct hda_codec *codec, int nid)
+static void snd_hda_do_detach(struct hda_beep *beep)
+{
+        input_unregister_device(beep->dev);
+        beep->dev = NULL;
+        cancel_work_sync(&beep->beep_work);
+        /* turn off beep for sure */
+        snd_hda_codec_write(beep->codec, beep->nid, 0,
+                                  AC_VERB_SET_BEEP_CONTROL, 0);
+}
+
+static int snd_hda_do_attach(struct hda_beep *beep)
 {
         struct input_dev *input_dev;
-        struct hda_beep *beep;
+        struct hda_codec *codec = beep->codec;
         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;
-        snprintf(beep->phys, sizeof(beep->phys),
-                "card%d/codec#%d/beep0", codec->bus->card->number, codec->addr);
         input_dev = input_allocate_device();
         if (!input_dev) {
-                kfree(beep);
+                printk(KERN_INFO "hda_beep: unable to allocate input device\n");
                 return -ENOMEM;
         }
 
@@ -151,21 +154,100 @@ int snd_hda_attach_beep_device(struct hda_codec *codec, int nid)
         err = input_register_device(input_dev);
         if (err < 0) {
                 input_free_device(input_dev);
-                kfree(beep);
+                printk(KERN_INFO "hda_beep: unable to register input device\n");
                 return err;
         }
+        beep->dev = input_dev;
+        return 0;
+}
+
+static void snd_hda_do_register(struct work_struct *work)
+{
+        struct hda_beep *beep =
+                container_of(work, struct hda_beep, register_work);
+
+        mutex_lock(&beep->mutex);
+        if (beep->enabled && !beep->dev)
+                snd_hda_do_attach(beep);
+        mutex_unlock(&beep->mutex);
+}
+
+static void snd_hda_do_unregister(struct work_struct *work)
+{
+        struct hda_beep *beep =
+                container_of(work, struct hda_beep, unregister_work.work);
+
+        mutex_lock(&beep->mutex);
+        if (!beep->enabled && beep->dev)
+                snd_hda_do_detach(beep);
+        mutex_unlock(&beep->mutex);
+}
 
+int snd_hda_enable_beep_device(struct hda_codec *codec, int enable)
+{
+        struct hda_beep *beep = codec->beep;
+        enable = !!enable;
+        if (beep == NULL)
+                return 0;
+        if (beep->enabled != enable) {
+                beep->enabled = enable;
+                if (!enable) {
+                        /* turn off beep */
+                        snd_hda_codec_write(beep->codec, beep->nid, 0,
+                                                  AC_VERB_SET_BEEP_CONTROL, 0);
+                }
+                if (beep->mode == HDA_BEEP_MODE_SWREG) {
+                        if (enable) {
+                                cancel_delayed_work(&beep->unregister_work);
+                                schedule_work(&beep->register_work);
+                        } else {
+                                schedule_delayed_work(&beep->unregister_work,
+                                                                           HZ);
+                        }
+                }
+                return 1;
+        }
+        return 0;
+}
+EXPORT_SYMBOL_HDA(snd_hda_enable_beep_device);
+
+int snd_hda_attach_beep_device(struct hda_codec *codec, int nid)
+{
+        struct hda_beep *beep;
+
+        if (!snd_hda_get_bool_hint(codec, "beep"))
+                return 0; /* disabled explicitly by hints */
+        if (codec->beep_mode == HDA_BEEP_MODE_OFF)
+                return 0; /* disabled by module option */
+
+        beep = kzalloc(sizeof(*beep), GFP_KERNEL);
+        if (beep == NULL)
+                return -ENOMEM;
+        snprintf(beep->phys, sizeof(beep->phys),
+                "card%d/codec#%d/beep0", codec->bus->card->number, codec->addr);
         /* enable linear scale */
         snd_hda_codec_write(codec, nid, 0,
                 AC_VERB_SET_DIGI_CONVERT_2, 0x01);
 
         beep->nid = nid;
-        beep->dev = input_dev;
         beep->codec = codec;
-        beep->enabled = 1;
+        beep->mode = codec->beep_mode;
         codec->beep = beep;
 
+        INIT_WORK(&beep->register_work, &snd_hda_do_register);
+        INIT_DELAYED_WORK(&beep->unregister_work, &snd_hda_do_unregister);
         INIT_WORK(&beep->beep_work, &snd_hda_generate_beep);
+        mutex_init(&beep->mutex);
+
+        if (beep->mode == HDA_BEEP_MODE_ON) {
+                int err = snd_hda_do_attach(beep);
+                if (err < 0) {
+                        kfree(beep);
+                        codec->beep = NULL;
+                        return err;
+                }
+        }
+
         return 0;
 }
 EXPORT_SYMBOL_HDA(snd_hda_attach_beep_device);
@@ -174,11 +256,12 @@ void snd_hda_detach_beep_device(struct hda_codec *codec)
 {
         struct hda_beep *beep = codec->beep;
         if (beep) {
-                cancel_work_sync(&beep->beep_work);
-
-                input_unregister_device(beep->dev);
-                kfree(beep);
+                cancel_work_sync(&beep->register_work);
+                cancel_delayed_work(&beep->unregister_work);
+                if (beep->dev)
+                        snd_hda_do_detach(beep);
                 codec->beep = NULL;
+                kfree(beep);
         }
 }
 EXPORT_SYMBOL_HDA(snd_hda_detach_beep_device);
diff --git a/sound/pci/hda/hda_beep.h b/sound/pci/hda/hda_beep.h
index 0c3de787c717..f1de1bac042c 100644
--- a/sound/pci/hda/hda_beep.h
+++ b/sound/pci/hda/hda_beep.h
@@ -24,19 +24,29 @@
 
 #include "hda_codec.h"
 
+#define HDA_BEEP_MODE_OFF       0
+#define HDA_BEEP_MODE_ON        1
+#define HDA_BEEP_MODE_SWREG     2
+
 /* beep information */
 struct hda_beep {
         struct input_dev *dev;
         struct hda_codec *codec;
+        unsigned int mode;
         char phys[32];
         int tone;
         hda_nid_t nid;
         unsigned int enabled:1;
+        unsigned int request_enable:1;
         unsigned int linear_tone:1;     /* linear tone for IDT/STAC codec */
+        struct work_struct register_work; /* registration work */
+        struct delayed_work unregister_work; /* unregistration work */
         struct work_struct beep_work; /* scheduled task for beep event */
+        struct mutex mutex;
 };
 
 #ifdef CONFIG_SND_HDA_INPUT_BEEP
+int snd_hda_enable_beep_device(struct hda_codec *codec, int enable);
 int snd_hda_attach_beep_device(struct hda_codec *codec, int nid);
 void snd_hda_detach_beep_device(struct hda_codec *codec);
 #else
diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c
index af989f660cca..0e76ac2b2ace 100644
--- a/sound/pci/hda/hda_codec.c
+++ b/sound/pci/hda/hda_codec.c
@@ -30,6 +30,7 @@
 #include <sound/tlv.h>
 #include <sound/initval.h>
 #include "hda_local.h"
+#include "hda_beep.h"
 #include <sound/hda_hwdep.h>
 
 /*
@@ -93,6 +94,13 @@ static void hda_keep_power_on(struct hda_codec *codec);
 static inline void hda_keep_power_on(struct hda_codec *codec) {}
 #endif
 
+/**
+ * snd_hda_get_jack_location - Give a location string of the jack
+ * @cfg: pin default config value
+ *
+ * Parse the pin default config value and returns the string of the
+ * jack location, e.g. "Rear", "Front", etc.
+ */
 const char *snd_hda_get_jack_location(u32 cfg)
 {
         static char *bases[7] = {
@@ -120,6 +128,13 @@ const char *snd_hda_get_jack_location(u32 cfg)
 }
 EXPORT_SYMBOL_HDA(snd_hda_get_jack_location);
 
+/**
+ * snd_hda_get_jack_connectivity - Give a connectivity string of the jack
+ * @cfg: pin default config value
+ *
+ * Parse the pin default config value and returns the string of the
+ * jack connectivity, i.e. external or internal connection.
+ */
 const char *snd_hda_get_jack_connectivity(u32 cfg)
 {
         static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" };
@@ -128,6 +143,13 @@ const char *snd_hda_get_jack_connectivity(u32 cfg)
 }
 EXPORT_SYMBOL_HDA(snd_hda_get_jack_connectivity);
 
+/**
+ * snd_hda_get_jack_type - Give a type string of the jack
+ * @cfg: pin default config value
+ *
+ * Parse the pin default config value and returns the string of the
+ * jack type, i.e. the purpose of the jack, such as Line-Out or CD.
+ */
 const char *snd_hda_get_jack_type(u32 cfg)
 {
         static char *jack_types[16] = {
@@ -515,6 +537,7 @@ static int snd_hda_bus_dev_register(struct snd_device *device)
         struct hda_codec *codec;
         list_for_each_entry(codec, &bus->codec_list, list) {
                 snd_hda_hwdep_add_sysfs(codec);
+                snd_hda_hwdep_add_power_sysfs(codec);
         }
         return 0;
 }
@@ -801,6 +824,9 @@ int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
         struct hda_pincfg *pin;
         unsigned int oldcfg;
 
+        if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
+                return -EINVAL;
+
         oldcfg = snd_hda_codec_get_pincfg(codec, nid);
         pin = look_up_pincfg(codec, list, nid);
         if (!pin) {
@@ -820,6 +846,16 @@ int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
         return 0;
 }
 
+/**
+ * snd_hda_codec_set_pincfg - Override a pin default configuration
+ * @codec: the HDA codec
+ * @nid: NID to set the pin config
+ * @cfg: the pin default config value
+ *
+ * Override a pin default configuration value in the cache.
+ * This value can be read by snd_hda_codec_get_pincfg() in a higher
+ * priority than the real hardware value.
+ */
 int snd_hda_codec_set_pincfg(struct hda_codec *codec,
                              hda_nid_t nid, unsigned int cfg)
 {
@@ -827,7 +863,15 @@ int snd_hda_codec_set_pincfg(struct hda_codec *codec,
 }
 EXPORT_SYMBOL_HDA(snd_hda_codec_set_pincfg);
 
-/* get the current pin config value of the given pin NID */
+/**
+ * snd_hda_codec_get_pincfg - Obtain a pin-default configuration
+ * @codec: the HDA codec
+ * @nid: NID to get the pin config
+ *
+ * Get the current pin config value of the given pin NID.
+ * If the pincfg value is cached or overridden via sysfs or driver,
+ * returns the cached value.
+ */
 unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
 {
         struct hda_pincfg *pin;
@@ -858,6 +902,25 @@ static void restore_pincfgs(struct hda_codec *codec)
         }
 }
 
+/**
+ * snd_hda_shutup_pins - Shut up all pins
+ * @codec: the HDA codec
+ *
+ * Clear all pin controls to shup up before suspend for avoiding click noise.
+ * The controls aren't cached so that they can be resumed properly.
+ */
+void snd_hda_shutup_pins(struct hda_codec *codec)
+{
+        int i;
+        for (i = 0; i < codec->init_pins.used; i++) {
+                struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
+                /* use read here for syncing after issuing each verb */
+                snd_hda_codec_read(codec, pin->nid, 0,
+                                   AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
+        }
+}
+EXPORT_SYMBOL_HDA(snd_hda_shutup_pins);
+
 static void init_hda_cache(struct hda_cache_rec *cache,
                            unsigned int record_size);
 static void free_hda_cache(struct hda_cache_rec *cache);
@@ -890,6 +953,7 @@ static void snd_hda_codec_free(struct hda_codec *codec)
 #endif
         list_del(&codec->list);
         snd_array_free(&codec->mixers);
+        snd_array_free(&codec->nids);
         codec->bus->caddr_tbl[codec->addr] = NULL;
         if (codec->patch_ops.free)
                 codec->patch_ops.free(codec);
@@ -914,8 +978,9 @@ 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,
-                                    struct hda_codec **codecp)
+int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus,
+                                unsigned int codec_addr,
+                                struct hda_codec **codecp)
 {
         struct hda_codec *codec;
         char component[31];
@@ -944,7 +1009,8 @@ int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr
         mutex_init(&codec->control_mutex);
         init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
         init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
-        snd_array_init(&codec->mixers, sizeof(struct snd_kcontrol *), 32);
+        snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 32);
+        snd_array_init(&codec->nids, sizeof(struct hda_nid_item), 32);
         snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
         snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
         if (codec->bus->modelname) {
@@ -1026,6 +1092,15 @@ int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr
 }
 EXPORT_SYMBOL_HDA(snd_hda_codec_new);
 
+/**
+ * snd_hda_codec_configure - (Re-)configure the HD-audio codec
+ * @codec: the HDA codec
+ *
+ * Start parsing of the given codec tree and (re-)initialize the whole
+ * patch instance.
+ *
+ * Returns 0 if successful or a negative error code.
+ */
 int snd_hda_codec_configure(struct hda_codec *codec)
 {
         int err;
@@ -1036,11 +1111,6 @@ int snd_hda_codec_configure(struct hda_codec *codec)
                 if (err < 0)
                         return err;
         }
-        /* audio codec should override the mixer name */
-        if (codec->afg || !*codec->bus->card->mixername)
-                snprintf(codec->bus->card->mixername,
-                         sizeof(codec->bus->card->mixername),
-                         "%s %s", codec->vendor_name, codec->chip_name);
 
         if (is_generic_config(codec)) {
                 err = snd_hda_parse_generic_codec(codec);
@@ -1059,6 +1129,11 @@ int snd_hda_codec_configure(struct hda_codec *codec)
  patched:
         if (!err && codec->patch_ops.unsol_event)
                 err = init_unsol_queue(codec->bus);
+        /* audio codec should override the mixer name */
+        if (!err && (codec->afg || !*codec->bus->card->mixername))
+                snprintf(codec->bus->card->mixername,
+                         sizeof(codec->bus->card->mixername),
+                         "%s %s", codec->vendor_name, codec->chip_name);
         return err;
 }
 EXPORT_SYMBOL_HDA(snd_hda_codec_configure);
@@ -1088,6 +1163,11 @@ void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
 }
 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
 
+/**
+ * snd_hda_codec_cleanup_stream - clean up the codec for closing
+ * @codec: the CODEC to clean up
+ * @nid: the NID to clean up
+ */
 void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid)
 {
         if (!nid)
@@ -1107,7 +1187,7 @@ EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup_stream);
  */
 
 /* FIXME: more better hash key? */
-#define HDA_HASH_KEY(nid,dir,idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
+#define HDA_HASH_KEY(nid, dir, idx) (u32)((nid) + ((idx) << 16) + ((dir) << 24))
 #define HDA_HASH_PINCAP_KEY(nid) (u32)((nid) + (0x02 << 24))
 #define HDA_HASH_PARPCM_KEY(nid) (u32)((nid) + (0x03 << 24))
 #define HDA_HASH_PARSTR_KEY(nid) (u32)((nid) + (0x04 << 24))
@@ -1163,8 +1243,17 @@ get_alloc_amp_hash(struct hda_codec *codec, u32 key)
         return (struct hda_amp_info *)get_alloc_hash(&codec->amp_cache, key);
 }
 
-/*
- * query AMP capabilities for the given widget and direction
+/**
+ * query_amp_caps - query AMP capabilities
+ * @codec: the HD-auio codec
+ * @nid: the NID to query
+ * @direction: either #HDA_INPUT or #HDA_OUTPUT
+ *
+ * Query AMP capabilities for the given widget and direction.
+ * Returns the obtained capability bits.
+ *
+ * When cap bits have been already read, this doesn't read again but
+ * returns the cached value.
  */
 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
 {
@@ -1187,6 +1276,19 @@ u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
 }
 EXPORT_SYMBOL_HDA(query_amp_caps);
 
+/**
+ * snd_hda_override_amp_caps - Override the AMP capabilities
+ * @codec: the CODEC to clean up
+ * @nid: the NID to clean up
+ * @direction: either #HDA_INPUT or #HDA_OUTPUT
+ * @caps: the capability bits to set
+ *
+ * Override the cached AMP caps bits value by the given one.
+ * This function is useful if the driver needs to adjust the AMP ranges,
+ * e.g. limit to 0dB, etc.
+ *
+ * Returns zero if successful or a negative error code.
+ */
 int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
                               unsigned int caps)
 {
@@ -1222,6 +1324,17 @@ static unsigned int read_pin_cap(struct hda_codec *codec, hda_nid_t nid)
         return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
 }
 
+/**
+ * snd_hda_query_pin_caps - Query PIN capabilities
+ * @codec: the HD-auio codec
+ * @nid: the NID to query
+ *
+ * Query PIN capabilities for the given widget.
+ * Returns the obtained capability bits.
+ *
+ * When cap bits have been already read, this doesn't read again but
+ * returns the cached value.
+ */
 u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
 {
         return query_caps_hash(codec, nid, HDA_HASH_PINCAP_KEY(nid),
@@ -1229,6 +1342,43 @@ u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
 }
 EXPORT_SYMBOL_HDA(snd_hda_query_pin_caps);
 
+/**
+ * snd_hda_pin_sense - execute pin sense measurement
+ * @codec: the CODEC to sense
+ * @nid: the pin NID to sense
+ *
+ * Execute necessary pin sense measurement and return its Presence Detect,
+ * Impedance, ELD Valid etc. status bits.
+ */
+u32 snd_hda_pin_sense(struct hda_codec *codec, hda_nid_t nid)
+{
+        u32 pincap;
+
+        if (!codec->no_trigger_sense) {
+                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);
+        }
+        return snd_hda_codec_read(codec, nid, 0,
+                                  AC_VERB_GET_PIN_SENSE, 0);
+}
+EXPORT_SYMBOL_HDA(snd_hda_pin_sense);
+
+/**
+ * snd_hda_jack_detect - query pin Presence Detect status
+ * @codec: the CODEC to sense
+ * @nid: the pin NID to sense
+ *
+ * Query and return the pin's Presence Detect status.
+ */
+int snd_hda_jack_detect(struct hda_codec *codec, hda_nid_t nid)
+{
+        u32 sense = snd_hda_pin_sense(codec, nid);
+        return !!(sense & AC_PINSENSE_PRESENCE);
+}
+EXPORT_SYMBOL_HDA(snd_hda_jack_detect);
+
 /*
  * read the current volume to info
  * if the cache exists, read the cache value.
@@ -1269,8 +1419,15 @@ static void put_vol_mute(struct hda_codec *codec, struct hda_amp_info *info,
         info->vol[ch] = val;
 }
 
-/*
- * read AMP value.  The volume is between 0 to 0x7f, 0x80 = mute bit.
+/**
+ * snd_hda_codec_amp_read - Read AMP value
+ * @codec: HD-audio codec
+ * @nid: NID to read the AMP value
+ * @ch: channel (left=0 or right=1)
+ * @direction: #HDA_INPUT or #HDA_OUTPUT
+ * @index: the index value (only for input direction)
+ *
+ * Read AMP value.  The volume is between 0 to 0x7f, 0x80 = mute bit.
  */
 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
                            int direction, int index)
@@ -1283,8 +1440,18 @@ int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
 }
 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_read);
 
-/*
- * update the AMP value, mask = bit mask to set, val = the value
+/**
+ * snd_hda_codec_amp_update - update the AMP value
+ * @codec: HD-audio codec
+ * @nid: NID to read the AMP value
+ * @ch: channel (left=0 or right=1)
+ * @direction: #HDA_INPUT or #HDA_OUTPUT
+ * @idx: the index value (only for input direction)
+ * @mask: bit mask to set
+ * @val: the bits value to set
+ *
+ * Update the AMP value with a bit mask.
+ * Returns 0 if the value is unchanged, 1 if changed.
  */
 int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
                              int direction, int idx, int mask, int val)
@@ -1303,8 +1470,17 @@ int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int ch,
 }
 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_update);
 
-/*
- * update the AMP stereo with the same mask and value
+/**
+ * snd_hda_codec_amp_stereo - update the AMP stereo values
+ * @codec: HD-audio codec
+ * @nid: NID to read the AMP value
+ * @direction: #HDA_INPUT or #HDA_OUTPUT
+ * @idx: the index value (only for input direction)
+ * @mask: bit mask to set
+ * @val: the bits value to set
+ *
+ * Update the AMP values like snd_hda_codec_amp_update(), but for a
+ * stereo widget with the same mask and value.
  */
 int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
                              int direction, int idx, int mask, int val)
@@ -1318,7 +1494,12 @@ int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
 EXPORT_SYMBOL_HDA(snd_hda_codec_amp_stereo);
 
 #ifdef SND_HDA_NEEDS_RESUME
-/* resume the all amp commands from the cache */
+/**
+ * snd_hda_codec_resume_amp - Resume all AMP commands from the cache
+ * @codec: HD-audio codec
+ *
+ * Resume the all amp commands from the cache.
+ */
 void snd_hda_codec_resume_amp(struct hda_codec *codec)
 {
         struct hda_amp_info *buffer = codec->amp_cache.buf.list;
@@ -1344,7 +1525,12 @@ void snd_hda_codec_resume_amp(struct hda_codec *codec)
 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
 #endif /* SND_HDA_NEEDS_RESUME */
 
-/* volume */
+/**
+ * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
+ *
+ * The control element is supposed to have the private_value field
+ * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
+ */
 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
                                   struct snd_ctl_elem_info *uinfo)
 {
@@ -1400,6 +1586,12 @@ update_amp_value(struct hda_codec *codec, hda_nid_t nid,
                                         HDA_AMP_VOLMASK, val);
 }
 
+/**
+ * snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
+ *
+ * The control element is supposed to have the private_value field
+ * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
+ */
 int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
                                  struct snd_ctl_elem_value *ucontrol)
 {
@@ -1419,6 +1611,12 @@ int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
 }
 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_get);
 
+/**
+ * snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
+ *
+ * The control element is supposed to have the private_value field
+ * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
+ */
 int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
                                  struct snd_ctl_elem_value *ucontrol)
 {
@@ -1443,6 +1641,12 @@ int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
 }
 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_put);
 
+/**
+ * snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume
+ *
+ * The control element is supposed to have the private_value field
+ * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
+ */
 int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
                           unsigned int size, unsigned int __user *_tlv)
 {
@@ -1472,8 +1676,16 @@ int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
 }
 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_tlv);
 
-/*
- * set (static) TLV for virtual master volume; recalculated as max 0dB
+/**
+ * snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
+ * @codec: HD-audio codec
+ * @nid: NID of a reference widget
+ * @dir: #HDA_INPUT or #HDA_OUTPUT
+ * @tlv: TLV data to be stored, at least 4 elements
+ *
+ * Set (static) TLV data for a virtual master volume using the AMP caps
+ * obtained from the reference NID.
+ * The volume range is recalculated as if the max volume is 0dB.
  */
 void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
                              unsigned int *tlv)
@@ -1507,6 +1719,13 @@ _snd_hda_find_mixer_ctl(struct hda_codec *codec,
         return snd_ctl_find_id(codec->bus->card, &id);
 }
 
+/**
+ * snd_hda_find_mixer_ctl - Find a mixer control element with the given name
+ * @codec: HD-audio codec
+ * @name: ctl id name string
+ *
+ * Get the control element with the given id string and IFACE_MIXER.
+ */
 struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
                                             const char *name)
 {
@@ -1514,31 +1733,97 @@ struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
 }
 EXPORT_SYMBOL_HDA(snd_hda_find_mixer_ctl);
 
-/* Add a control element and assign to the codec */
-int snd_hda_ctl_add(struct hda_codec *codec, struct snd_kcontrol *kctl)
+/**
+ * snd_hda_ctl_add - Add a control element and assign to the codec
+ * @codec: HD-audio codec
+ * @nid: corresponding NID (optional)
+ * @kctl: the control element to assign
+ *
+ * Add the given control element to an array inside the codec instance.
+ * All control elements belonging to a codec are supposed to be added
+ * by this function so that a proper clean-up works at the free or
+ * reconfiguration time.
+ *
+ * If non-zero @nid is passed, the NID is assigned to the control element.
+ * The assignment is shown in the codec proc file.
+ *
+ * snd_hda_ctl_add() checks the control subdev id field whether
+ * #HDA_SUBDEV_NID_FLAG bit is set.  If set (and @nid is zero), the lower
+ * bits value is taken as the NID to assign. The #HDA_NID_ITEM_AMP bit
+ * specifies if kctl->private_value is a HDA amplifier value.
+ */
+int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
+                    struct snd_kcontrol *kctl)
 {
         int err;
-        struct snd_kcontrol **knewp;
+        unsigned short flags = 0;
+        struct hda_nid_item *item;
 
+        if (kctl->id.subdevice & HDA_SUBDEV_AMP_FLAG) {
+                flags |= HDA_NID_ITEM_AMP;
+                if (nid == 0)
+                        nid = get_amp_nid_(kctl->private_value);
+        }
+        if ((kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) != 0 && nid == 0)
+                nid = kctl->id.subdevice & 0xffff;
+        if (kctl->id.subdevice & (HDA_SUBDEV_NID_FLAG|HDA_SUBDEV_AMP_FLAG))
+                kctl->id.subdevice = 0;
         err = snd_ctl_add(codec->bus->card, kctl);
         if (err < 0)
                 return err;
-        knewp = snd_array_new(&codec->mixers);
-        if (!knewp)
+        item = snd_array_new(&codec->mixers);
+        if (!item)
                 return -ENOMEM;
-        *knewp = kctl;
+        item->kctl = kctl;
+        item->nid = nid;
+        item->flags = flags;
         return 0;
 }
 EXPORT_SYMBOL_HDA(snd_hda_ctl_add);
 
-/* Clear all controls assigned to the given codec */
+/**
+ * snd_hda_add_nid - Assign a NID to a control element
+ * @codec: HD-audio codec
+ * @nid: corresponding NID (optional)
+ * @kctl: the control element to assign
+ * @index: index to kctl
+ *
+ * Add the given control element to an array inside the codec instance.
+ * This function is used when #snd_hda_ctl_add cannot be used for 1:1
+ * NID:KCTL mapping - for example "Capture Source" selector.
+ */
+int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl,
+                    unsigned int index, hda_nid_t nid)
+{
+        struct hda_nid_item *item;
+
+        if (nid > 0) {
+                item = snd_array_new(&codec->nids);
+                if (!item)
+                        return -ENOMEM;
+                item->kctl = kctl;
+                item->index = index;
+                item->nid = nid;
+                return 0;
+        }
+        printk(KERN_ERR "hda-codec: no NID for mapping control %s:%d:%d\n",
+               kctl->id.name, kctl->id.index, index);
+        return -EINVAL;
+}
+EXPORT_SYMBOL_HDA(snd_hda_add_nid);
+
+/**
+ * snd_hda_ctls_clear - Clear all controls assigned to the given codec
+ * @codec: HD-audio codec
+ */
 void snd_hda_ctls_clear(struct hda_codec *codec)
 {
         int i;
-        struct snd_kcontrol **kctls = codec->mixers.list;
+        struct hda_nid_item *items = codec->mixers.list;
         for (i = 0; i < codec->mixers.used; i++)
-                snd_ctl_remove(codec->bus->card, kctls[i]);
+                snd_ctl_remove(codec->bus->card, items[i].kctl);
         snd_array_free(&codec->mixers);
+        snd_array_free(&codec->nids);
 }
 
 /* pseudo device locking
@@ -1563,6 +1848,16 @@ static void hda_unlock_devices(struct snd_card *card)
         spin_unlock(&card->files_lock);
 }
 
+/**
+ * snd_hda_codec_reset - Clear all objects assigned to the codec
+ * @codec: HD-audio codec
+ *
+ * This frees the all PCM and control elements assigned to the codec, and
+ * clears the caches and restores the pin default configurations.
+ *
+ * When a device is being used, it returns -EBSY.  If successfully freed,
+ * returns zero.
+ */
 int snd_hda_codec_reset(struct hda_codec *codec)
 {
         struct snd_card *card = codec->bus->card;
@@ -1626,7 +1921,22 @@ int snd_hda_codec_reset(struct hda_codec *codec)
         return 0;
 }
 
-/* create a virtual master control and add slaves */
+/**
+ * snd_hda_add_vmaster - create a virtual master control and add slaves
+ * @codec: HD-audio codec
+ * @name: vmaster control name
+ * @tlv: TLV data (optional)
+ * @slaves: slave control names (optional)
+ *
+ * Create a virtual master control with the given name.  The TLV data
+ * must be either NULL or a valid data.
+ *
+ * @slaves is a NULL-terminated array of strings, each of which is a
+ * slave control name.  All controls with these names are assigned to
+ * the new virtual master control.
+ *
+ * This function returns zero if successful or a negative error code.
+ */
 int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
                         unsigned int *tlv, const char **slaves)
 {
@@ -1643,10 +1953,10 @@ int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
         kctl = snd_ctl_make_virtual_master(name, tlv);
         if (!kctl)
                 return -ENOMEM;
-        err = snd_hda_ctl_add(codec, kctl);
+        err = snd_hda_ctl_add(codec, 0, kctl);
         if (err < 0)
                 return err;
-        
+
         for (s = slaves; *s; s++) {
                 struct snd_kcontrol *sctl;
                 int i = 0;
@@ -1668,7 +1978,12 @@ int snd_hda_add_vmaster(struct hda_codec *codec, char *name,
 }
 EXPORT_SYMBOL_HDA(snd_hda_add_vmaster);
 
-/* switch */
+/**
+ * snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
+ *
+ * The control element is supposed to have the private_value field
+ * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
+ */
 int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
                                   struct snd_ctl_elem_info *uinfo)
 {
@@ -1682,6 +1997,12 @@ int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
 }
 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_info);
 
+/**
+ * snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
+ *
+ * The control element is supposed to have the private_value field
+ * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
+ */
 int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
                                  struct snd_ctl_elem_value *ucontrol)
 {
@@ -1702,6 +2023,12 @@ int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
 }
 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_get);
 
+/**
+ * snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
+ *
+ * The control element is supposed to have the private_value field
+ * set up via HDA_COMPOSE_AMP_VAL*() or related macros.
+ */
 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
                                  struct snd_ctl_elem_value *ucontrol)
 {
@@ -1733,6 +2060,25 @@ int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
 }
 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
 
+#ifdef CONFIG_SND_HDA_INPUT_BEEP
+/**
+ * snd_hda_mixer_amp_switch_put_beep - Put callback for a beep AMP switch
+ *
+ * This function calls snd_hda_enable_beep_device(), which behaves differently
+ * depending on beep_mode option.
+ */
+int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol *kcontrol,
+                                      struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        long *valp = ucontrol->value.integer.value;
+
+        snd_hda_enable_beep_device(codec, *valp);
+        return snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
+}
+EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put_beep);
+#endif /* CONFIG_SND_HDA_INPUT_BEEP */
+
 /*
  * bound volume controls
  *
@@ -1742,6 +2088,12 @@ EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_switch_put);
 #define AMP_VAL_IDX_SHIFT       19
 #define AMP_VAL_IDX_MASK        (0x0f<<19)
 
+/**
+ * snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
+ *
+ * The control element is supposed to have the private_value field
+ * set up via HDA_BIND_MUTE*() macros.
+ */
 int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
                                   struct snd_ctl_elem_value *ucontrol)
 {
@@ -1759,6 +2111,12 @@ int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
 }
 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_get);
 
+/**
+ * snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
+ *
+ * The control element is supposed to have the private_value field
+ * set up via HDA_BIND_MUTE*() macros.
+ */
 int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
                                   struct snd_ctl_elem_value *ucontrol)
 {
@@ -1783,8 +2141,11 @@ int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
 }
 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_switch_put);
 
-/*
- * generic bound volume/swtich controls
+/**
+ * snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
+ *
+ * The control element is supposed to have the private_value field
+ * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
  */
 int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
                                  struct snd_ctl_elem_info *uinfo)
@@ -1803,6 +2164,12 @@ int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
 }
 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_info);
 
+/**
+ * snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
+ *
+ * The control element is supposed to have the private_value field
+ * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
+ */
 int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
                                 struct snd_ctl_elem_value *ucontrol)
 {
@@ -1820,6 +2187,12 @@ int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
 }
 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_get);
 
+/**
+ * snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
+ *
+ * The control element is supposed to have the private_value field
+ * set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
+ */
 int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
                                 struct snd_ctl_elem_value *ucontrol)
 {
@@ -1843,6 +2216,12 @@ int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
 }
 EXPORT_SYMBOL_HDA(snd_hda_mixer_bind_ctls_put);
 
+/**
+ * snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
+ *
+ * The control element is supposed to have the private_value field
+ * set up via HDA_BIND_VOL() macro.
+ */
 int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
                            unsigned int size, unsigned int __user *tlv)
 {
@@ -2064,27 +2443,27 @@ static struct snd_kcontrol_new dig_mixes[] = {
         {
                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-                .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
+                .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
                 .info = snd_hda_spdif_mask_info,
                 .get = snd_hda_spdif_cmask_get,
         },
         {
                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-                .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
+                .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK),
                 .info = snd_hda_spdif_mask_info,
                 .get = snd_hda_spdif_pmask_get,
         },
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-                .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
+                .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
                 .info = snd_hda_spdif_mask_info,
                 .get = snd_hda_spdif_default_get,
                 .put = snd_hda_spdif_default_put,
         },
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-                .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
+                .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
                 .info = snd_hda_spdif_out_switch_info,
                 .get = snd_hda_spdif_out_switch_get,
                 .put = snd_hda_spdif_out_switch_put,
@@ -2126,7 +2505,7 @@ int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
                         return -ENOMEM;
                 kctl->id.index = idx;
                 kctl->private_value = nid;
-                err = snd_hda_ctl_add(codec, kctl);
+                err = snd_hda_ctl_add(codec, nid, kctl);
                 if (err < 0)
                         return err;
         }
@@ -2165,14 +2544,19 @@ static struct snd_kcontrol_new spdif_share_sw = {
         .put = spdif_share_sw_put,
 };
 
+/**
+ * snd_hda_create_spdif_share_sw - create Default PCM switch
+ * @codec: the HDA codec
+ * @mout: multi-out instance
+ */
 int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
                                   struct hda_multi_out *mout)
 {
         if (!mout->dig_out_nid)
                 return 0;
         /* ATTENTION: here mout is passed as private_data, instead of codec */
-        return snd_hda_ctl_add(codec,
-                           snd_ctl_new1(&spdif_share_sw, mout));
+        return snd_hda_ctl_add(codec, mout->dig_out_nid,
+                              snd_ctl_new1(&spdif_share_sw, mout));
 }
 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_share_sw);
 
@@ -2230,7 +2614,7 @@ static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
 static struct snd_kcontrol_new dig_in_ctls[] = {
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-                .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH),
+                .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, SWITCH),
                 .info = snd_hda_spdif_in_switch_info,
                 .get = snd_hda_spdif_in_switch_get,
                 .put = snd_hda_spdif_in_switch_put,
@@ -2238,7 +2622,7 @@ static struct snd_kcontrol_new dig_in_ctls[] = {
         {
                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-                .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT),
+                .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
                 .info = snd_hda_spdif_mask_info,
                 .get = snd_hda_spdif_in_status_get,
         },
@@ -2276,7 +2660,7 @@ int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
                 if (!kctl)
                         return -ENOMEM;
                 kctl->private_value = nid;
-                err = snd_hda_ctl_add(codec, kctl);
+                err = snd_hda_ctl_add(codec, nid, kctl);
                 if (err < 0)
                         return err;
         }
@@ -2332,7 +2716,12 @@ int snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
 }
 EXPORT_SYMBOL_HDA(snd_hda_codec_write_cache);
 
-/* resume the all commands from the cache */
+/**
+ * snd_hda_codec_resume_cache - Resume the all commands from the cache
+ * @codec: HD-audio codec
+ *
+ * Execute all verbs recorded in the command caches to resume.
+ */
 void snd_hda_codec_resume_cache(struct hda_codec *codec)
 {
         struct hda_cache_head *buffer = codec->cmd_cache.buf.list;
@@ -2382,7 +2771,8 @@ static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
         snd_hda_codec_read(codec, fg, 0, AC_VERB_SET_POWER_STATE,
                             power_state);
         /* partial workaround for "azx_get_response timeout" */
-        if (power_state == AC_PWRST_D0)
+        if (power_state == AC_PWRST_D0 &&
+            (codec->vendor_id & 0xffff0000) == 0x14f10000)
                 msleep(10);
 
         nid = codec->start_nid;
@@ -2416,7 +2806,6 @@ static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg,
         if (power_state == AC_PWRST_D0) {
                 unsigned long end_time;
                 int state;
-                msleep(10);
                 /* wait until the codec reachs to D0 */
                 end_time = jiffies + msecs_to_jiffies(500);
                 do {
@@ -2452,9 +2841,11 @@ static void hda_call_codec_suspend(struct hda_codec *codec)
                             codec->afg ? codec->afg : codec->mfg,
                             AC_PWRST_D3);
 #ifdef CONFIG_SND_HDA_POWER_SAVE
+        snd_hda_update_power_acct(codec);
         cancel_delayed_work(&codec->power_work);
         codec->power_on = 0;
         codec->power_transition = 0;
+        codec->power_jiffies = jiffies;
 #endif
 }
 
@@ -2495,8 +2886,8 @@ int /*__devinit*/ snd_hda_build_controls(struct hda_bus *bus)
         list_for_each_entry(codec, &bus->codec_list, list) {
                 int err = snd_hda_codec_build_controls(codec);
                 if (err < 0) {
-                        printk(KERN_ERR "hda_codec: cannot build controls"
-                               "for #%d (error %d)\n", codec->addr, err); 
+                        printk(KERN_ERR "hda_codec: cannot build controls "
+                               "for #%d (error %d)\n", codec->addr, err);
                         err = snd_hda_codec_reset(codec);
                         if (err < 0) {
                                 printk(KERN_ERR
@@ -2592,8 +2983,12 @@ unsigned int snd_hda_calc_stream_format(unsigned int rate,
         val |= channels - 1;
 
         switch (snd_pcm_format_width(format)) {
-        case 8:  val |= 0x00; break;
-        case 16: val |= 0x10; break;
+        case 8:
+                val |= 0x00;
+                break;
+        case 16:
+                val |= 0x10;
+                break;
         case 20:
         case 24:
         case 32:
@@ -2756,8 +3151,12 @@ static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
 }
 
 /**
- * snd_hda_is_supported_format - check whether the given node supports
- * the format val
+ * snd_hda_is_supported_format - Check the validity of the format
+ * @codec: HD-audio codec
+ * @nid: NID to check
+ * @format: the HD-audio format value to check
+ *
+ * Check whether the given node supports the format value.
  *
  * Returns 1 if supported, 0 if not.
  */
@@ -2877,51 +3276,39 @@ static int set_pcm_default_values(struct hda_codec *codec,
         return 0;
 }
 
+/* global */
+const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
+        "Audio", "SPDIF", "HDMI", "Modem"
+};
+
 /*
  * get the empty PCM device number to assign
+ *
+ * note the max device number is limited by HDA_MAX_PCMS, currently 10
  */
 static int get_empty_pcm_device(struct hda_bus *bus, int type)
 {
-        static const char *dev_name[HDA_PCM_NTYPES] = {
-                "Audio", "SPDIF", "HDMI", "Modem"
+        /* audio device indices; not linear to keep compatibility */
+        static int audio_idx[HDA_PCM_NTYPES][5] = {
+                [HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
+                [HDA_PCM_TYPE_SPDIF] = { 1, -1 },
+                [HDA_PCM_TYPE_HDMI]  = { 3, 7, 8, 9, -1 },
+                [HDA_PCM_TYPE_MODEM] = { 6, -1 },
         };
-        /* starting device index for each PCM type */
-        static int dev_idx[HDA_PCM_NTYPES] = {
-                [HDA_PCM_TYPE_AUDIO] = 0,
-                [HDA_PCM_TYPE_SPDIF] = 1,
-                [HDA_PCM_TYPE_HDMI] = 3,
-                [HDA_PCM_TYPE_MODEM] = 6
-        };
-        /* normal audio device indices; not linear to keep compatibility */
-        static int audio_idx[4] = { 0, 2, 4, 5 };
-        int i, dev;
-
-        switch (type) {
-        case HDA_PCM_TYPE_AUDIO:
-                for (i = 0; i < ARRAY_SIZE(audio_idx); i++) {
-                        dev = audio_idx[i];
-                        if (!test_bit(dev, bus->pcm_dev_bits))
-                                goto ok;
-                }
-                snd_printk(KERN_WARNING "Too many audio devices\n");
-                return -EAGAIN;
-        case HDA_PCM_TYPE_SPDIF:
-        case HDA_PCM_TYPE_HDMI:
-        case HDA_PCM_TYPE_MODEM:
-                dev = dev_idx[type];
-                if (test_bit(dev, bus->pcm_dev_bits)) {
-                        snd_printk(KERN_WARNING "%s already defined\n",
-                                   dev_name[type]);
-                        return -EAGAIN;
-                }
-                break;
-        default:
+        int i;
+
+        if (type >= HDA_PCM_NTYPES) {
                 snd_printk(KERN_WARNING "Invalid PCM type %d\n", type);
                 return -EINVAL;
         }
- ok:
-        set_bit(dev, bus->pcm_dev_bits);
-        return dev;
+
+        for (i = 0; audio_idx[type][i] >= 0 ; i++)
+                if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
+                        return audio_idx[type][i];
+
+        snd_printk(KERN_WARNING "Too many %s devices\n",
+                snd_hda_pcm_type_name[type]);
+        return -EAGAIN;
 }
 
 /*
@@ -2958,7 +3345,7 @@ int snd_hda_codec_build_pcms(struct hda_codec *codec)
                 err = codec->patch_ops.build_pcms(codec);
                 if (err < 0) {
                         printk(KERN_ERR "hda_codec: cannot build PCMs"
-                               "for #%d (error %d)\n", codec->addr, err); 
+                               "for #%d (error %d)\n", codec->addr, err);
                         err = snd_hda_codec_reset(codec);
                         if (err < 0) {
                                 printk(KERN_ERR
@@ -3088,8 +3475,8 @@ EXPORT_SYMBOL_HDA(snd_hda_check_board_config);
 
 /**
  * snd_hda_check_board_codec_sid_config - compare the current codec
-                                          subsystem ID with the
-                                          config table
+                                        subsystem ID with the
+                                        config table
 
            This is important for Gateway notebooks with SB450 HDA Audio
            where the vendor ID of the PCI device is:
@@ -3159,14 +3546,16 @@ EXPORT_SYMBOL_HDA(snd_hda_check_board_codec_sid_config);
  */
 int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
 {
-        int err;
+        int err;
 
         for (; knew->name; knew++) {
                 struct snd_kcontrol *kctl;
+                if (knew->iface == -1)  /* skip this codec private value */
+                        continue;
                 kctl = snd_ctl_new1(knew, codec);
                 if (!kctl)
                         return -ENOMEM;
-                err = snd_hda_ctl_add(codec, kctl);
+                err = snd_hda_ctl_add(codec, 0, kctl);
                 if (err < 0) {
                         if (!codec->addr)
                                 return err;
@@ -3174,7 +3563,7 @@ int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew)
                         if (!kctl)
                                 return -ENOMEM;
                         kctl->id.device = codec->addr;
-                        err = snd_hda_ctl_add(codec, kctl);
+                        err = snd_hda_ctl_add(codec, 0, kctl);
                         if (err < 0)
                                 return err;
                 }
@@ -3207,8 +3596,27 @@ static void hda_keep_power_on(struct hda_codec *codec)
 {
         codec->power_count++;
         codec->power_on = 1;
+        codec->power_jiffies = jiffies;
+}
+
+/* update the power on/off account with the current jiffies */
+void snd_hda_update_power_acct(struct hda_codec *codec)
+{
+        unsigned long delta = jiffies - codec->power_jiffies;
+        if (codec->power_on)
+                codec->power_on_acct += delta;
+        else
+                codec->power_off_acct += delta;
+        codec->power_jiffies += delta;
 }
 
+/**
+ * snd_hda_power_up - Power-up the codec
+ * @codec: HD-audio codec
+ *
+ * Increment the power-up counter and power up the hardware really when
+ * not turned on yet.
+ */
 void snd_hda_power_up(struct hda_codec *codec)
 {
         struct hda_bus *bus = codec->bus;
@@ -3217,7 +3625,9 @@ void snd_hda_power_up(struct hda_codec *codec)
         if (codec->power_on || codec->power_transition)
                 return;
 
+        snd_hda_update_power_acct(codec);
         codec->power_on = 1;
+        codec->power_jiffies = jiffies;
         if (bus->ops.pm_notify)
                 bus->ops.pm_notify(bus);
         hda_call_codec_resume(codec);
@@ -3229,9 +3639,13 @@ EXPORT_SYMBOL_HDA(snd_hda_power_up);
 #define power_save(codec)       \
         ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
 
-#define power_save(codec)       \
-        ((codec)->bus->power_save ? *(codec)->bus->power_save : 0)
-
+/**
+ * snd_hda_power_down - Power-down the codec
+ * @codec: HD-audio codec
+ *
+ * Decrement the power-up counter and schedules the power-off work if
+ * the counter rearches to zero.
+ */
 void snd_hda_power_down(struct hda_codec *codec)
 {
         --codec->power_count;
@@ -3245,6 +3659,19 @@ void snd_hda_power_down(struct hda_codec *codec)
 }
 EXPORT_SYMBOL_HDA(snd_hda_power_down);
 
+/**
+ * snd_hda_check_amp_list_power - Check the amp list and update the power
+ * @codec: HD-audio codec
+ * @check: the object containing an AMP list and the status
+ * @nid: NID to check / update
+ *
+ * Check whether the given NID is in the amp list.  If it's in the list,
+ * check the current AMP status, and update the the power-status according
+ * to the mute status.
+ *
+ * This function is supposed to be set or called from the check_power_status
+ * patch ops.
+ */
 int snd_hda_check_amp_list_power(struct hda_codec *codec,
                                  struct hda_loopback_check *check,
                                  hda_nid_t nid)
@@ -3286,6 +3713,10 @@ EXPORT_SYMBOL_HDA(snd_hda_check_amp_list_power);
 /*
  * Channel mode helper
  */
+
+/**
+ * snd_hda_ch_mode_info - Info callback helper for the channel mode enum
+ */
 int snd_hda_ch_mode_info(struct hda_codec *codec,
                          struct snd_ctl_elem_info *uinfo,
                          const struct hda_channel_mode *chmode,
@@ -3302,6 +3733,9 @@ int snd_hda_ch_mode_info(struct hda_codec *codec,
 }
 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_info);
 
+/**
+ * snd_hda_ch_mode_get - Get callback helper for the channel mode enum
+ */
 int snd_hda_ch_mode_get(struct hda_codec *codec,
                         struct snd_ctl_elem_value *ucontrol,
                         const struct hda_channel_mode *chmode,
@@ -3320,6 +3754,9 @@ int snd_hda_ch_mode_get(struct hda_codec *codec,
 }
 EXPORT_SYMBOL_HDA(snd_hda_ch_mode_get);
 
+/**
+ * snd_hda_ch_mode_put - Put callback helper for the channel mode enum
+ */
 int snd_hda_ch_mode_put(struct hda_codec *codec,
                         struct snd_ctl_elem_value *ucontrol,
                         const struct hda_channel_mode *chmode,
@@ -3344,6 +3781,10 @@ EXPORT_SYMBOL_HDA(snd_hda_ch_mode_put);
 /*
  * input MUX helper
  */
+
+/**
+ * snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
+ */
 int snd_hda_input_mux_info(const struct hda_input_mux *imux,
                            struct snd_ctl_elem_info *uinfo)
 {
@@ -3362,6 +3803,9 @@ int snd_hda_input_mux_info(const struct hda_input_mux *imux,
 }
 EXPORT_SYMBOL_HDA(snd_hda_input_mux_info);
 
+/**
+ * snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
+ */
 int snd_hda_input_mux_put(struct hda_codec *codec,
                           const struct hda_input_mux *imux,
                           struct snd_ctl_elem_value *ucontrol,
@@ -3395,7 +3839,7 @@ static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
 {
         /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
         if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
-                set_dig_out_convert(codec, nid, 
+                set_dig_out_convert(codec, nid,
                                     codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff,
                                     -1);
         snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
@@ -3421,8 +3865,29 @@ static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
         }
 }
 
-/*
- * open the digital out in the exclusive mode
+/**
+ * snd_hda_bus_reboot_notify - call the reboot notifier of each codec
+ * @bus: HD-audio bus
+ */
+void snd_hda_bus_reboot_notify(struct hda_bus *bus)
+{
+        struct hda_codec *codec;
+
+        if (!bus)
+                return;
+        list_for_each_entry(codec, &bus->codec_list, list) {
+#ifdef CONFIG_SND_HDA_POWER_SAVE
+                if (!codec->power_on)
+                        continue;
+#endif
+                if (codec->patch_ops.reboot_notify)
+                        codec->patch_ops.reboot_notify(codec);
+        }
+}
+EXPORT_SYMBOL_HDA(snd_hda_bus_reboot_notify);
+
+/**
+ * snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
  */
 int snd_hda_multi_out_dig_open(struct hda_codec *codec,
                                struct hda_multi_out *mout)
@@ -3437,6 +3902,9 @@ int snd_hda_multi_out_dig_open(struct hda_codec *codec,
 }
 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_open);
 
+/**
+ * snd_hda_multi_out_dig_prepare - prepare the digital out stream
+ */
 int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
                                   struct hda_multi_out *mout,
                                   unsigned int stream_tag,
@@ -3450,6 +3918,9 @@ int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
 }
 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_prepare);
 
+/**
+ * snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
+ */
 int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
                                   struct hda_multi_out *mout)
 {
@@ -3460,8 +3931,8 @@ int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
 }
 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_cleanup);
 
-/*
- * release the digital out
+/**
+ * snd_hda_multi_out_dig_close - release the digital out stream
  */
 int snd_hda_multi_out_dig_close(struct hda_codec *codec,
                                 struct hda_multi_out *mout)
@@ -3473,8 +3944,12 @@ int snd_hda_multi_out_dig_close(struct hda_codec *codec,
 }
 EXPORT_SYMBOL_HDA(snd_hda_multi_out_dig_close);
 
-/*
- * set up more restrictions for analog out
+/**
+ * snd_hda_multi_out_analog_open - open analog outputs
+ *
+ * Open analog outputs and set up the hw-constraints.
+ * If the digital outputs can be opened as slave, open the digital
+ * outputs, too.
  */
 int snd_hda_multi_out_analog_open(struct hda_codec *codec,
                                   struct hda_multi_out *mout,
@@ -3519,9 +3994,11 @@ int snd_hda_multi_out_analog_open(struct hda_codec *codec,
 }
 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_open);
 
-/*
- * set up the i/o for analog out
- * when the digital out is available, copy the front out to digital out, too.
+/**
+ * snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
+ *
+ * Set up the i/o for analog out.
+ * When the digital out is available, copy the front out to digital out, too.
  */
 int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
                                      struct hda_multi_out *mout,
@@ -3578,8 +4055,8 @@ int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
 }
 EXPORT_SYMBOL_HDA(snd_hda_multi_out_analog_prepare);
 
-/*
- * clean up the setting for analog out
+/**
+ * snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
  */
 int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
                                      struct hda_multi_out *mout)
@@ -3621,13 +4098,13 @@ static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list)
 /*
  * Sort an associated group of pins according to their sequence numbers.
  */
-static void sort_pins_by_sequence(hda_nid_t * pins, short * sequences,
+static void sort_pins_by_sequence(hda_nid_t *pins, short *sequences,
                                   int num_pins)
 {
         int i, j;
         short seq;
         hda_nid_t nid;
-        
+
         for (i = 0; i < num_pins; i++) {
                 for (j = i + 1; j < num_pins; j++) {
                         if (sequences[i] > sequences[j]) {
@@ -3655,7 +4132,7 @@ static void sort_pins_by_sequence(hda_nid_t * pins, short * sequences,
  * is detected, one of speaker of HP pins is assigned as the primary
  * output, i.e. to line_out_pins[0].  So, line_outs is always positive
  * if any analog output exists.
- * 
+ *
  * The analog input pins are assigned to input_pins array.
  * The digital input/output pins are assigned to dig_in_pin and dig_out_pin,
  * respectively.
@@ -3718,9 +4195,9 @@ int snd_hda_parse_pin_def_config(struct hda_codec *codec,
                 case AC_JACK_SPEAKER:
                         seq = get_defcfg_sequence(def_conf);
                         assoc = get_defcfg_association(def_conf);
-                        if (! assoc)
+                        if (!assoc)
                                 continue;
-                        if (! assoc_speaker)
+                        if (!assoc_speaker)
                                 assoc_speaker = assoc;
                         else if (assoc_speaker != assoc)
                                 continue;
@@ -3818,7 +4295,7 @@ int snd_hda_parse_pin_def_config(struct hda_codec *codec,
                               cfg->speaker_outs);
         sort_pins_by_sequence(cfg->hp_pins, sequences_hp,
                               cfg->hp_outs);
-        
+
         /* if we have only one mic, make it AUTO_PIN_MIC */
         if (!cfg->input_pins[AUTO_PIN_MIC] &&
             cfg->input_pins[AUTO_PIN_FRONT_MIC]) {
@@ -3965,8 +4442,14 @@ EXPORT_SYMBOL_HDA(snd_hda_resume);
  * generic arrays
  */
 
-/* get a new element from the given array
- * if it exceeds the pre-allocated array size, re-allocate the array
+/**
+ * snd_array_new - get a new element from the given array
+ * @array: the array object
+ *
+ * Get a new element from the given array.  If it exceeds the
+ * pre-allocated array size, re-allocate the array.
+ *
+ * Returns NULL if allocation failed.
  */
 void *snd_array_new(struct snd_array *array)
 {
@@ -3990,7 +4473,10 @@ void *snd_array_new(struct snd_array *array)
 }
 EXPORT_SYMBOL_HDA(snd_array_new);
 
-/* free the given array elements */
+/**
+ * snd_array_free - free the given array elements
+ * @array: the array object
+ */
 void snd_array_free(struct snd_array *array)
 {
         kfree(array->list);
@@ -4000,7 +4486,12 @@ void snd_array_free(struct snd_array *array)
 }
 EXPORT_SYMBOL_HDA(snd_array_free);
 
-/*
+/**
+ * snd_print_pcm_rates - Print the supported PCM rates to the string buffer
+ * @pcm: PCM caps bits
+ * @buf: the string buffer to write
+ * @buflen: the max buffer length
+ *
  * used by hda_proc.c and hda_eld.c
  */
 void snd_print_pcm_rates(int pcm, char *buf, int buflen)
@@ -4019,6 +4510,14 @@ void snd_print_pcm_rates(int pcm, char *buf, int buflen)
 }
 EXPORT_SYMBOL_HDA(snd_print_pcm_rates);
 
+/**
+ * snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
+ * @pcm: PCM caps bits
+ * @buf: the string buffer to write
+ * @buflen: the max buffer length
+ *
+ * used by hda_proc.c and hda_eld.c
+ */
 void snd_print_pcm_bits(int pcm, char *buf, int buflen)
 {
         static unsigned int bits[] = { 8, 16, 20, 24, 32 };
diff --git a/sound/pci/hda/hda_codec.h b/sound/pci/hda/hda_codec.h
index 99552fb5f756..b75da47571e6 100644
--- a/sound/pci/hda/hda_codec.h
+++ b/sound/pci/hda/hda_codec.h
@@ -255,9 +255,13 @@ enum {
  *       in HD-audio specification
  */
 #define AC_PINCAP_HDMI                  (1<<7)  /* HDMI pin */
+#define AC_PINCAP_DP                    (1<<24) /* DisplayPort pin, can
+                                                 * coexist with AC_PINCAP_HDMI
+                                                 */
 #define AC_PINCAP_VREF                  (0x37<<8)
 #define AC_PINCAP_VREF_SHIFT            8
 #define AC_PINCAP_EAPD                  (1<<16) /* EAPD capable */
+#define AC_PINCAP_HBR                   (1<<27) /* High Bit Rate */
 /* Vref status (used in pin cap) */
 #define AC_PINCAP_VREF_HIZ              (1<<0)  /* Hi-Z */
 #define AC_PINCAP_VREF_50               (1<<1)  /* 50% */
@@ -286,6 +290,10 @@ enum {
 #define AC_PWRST_D1SUP                  (1<<1)
 #define AC_PWRST_D2SUP                  (1<<2)
 #define AC_PWRST_D3SUP                  (1<<3)
+#define AC_PWRST_D3COLDSUP              (1<<4)
+#define AC_PWRST_S3D3COLDSUP            (1<<29)
+#define AC_PWRST_CLKSTOP                (1<<30)
+#define AC_PWRST_EPSS                   (1U<<31)
 
 /* Power state values */
 #define AC_PWRST_SETTING                (0xf<<0)
@@ -519,6 +527,9 @@ enum {
 /* max. codec address */
 #define HDA_MAX_CODEC_ADDRESS   0x0f
 
+/* max number of PCM devics per card */
+#define HDA_MAX_PCMS            10
+
 /*
  * generic arrays
  */
@@ -631,6 +642,7 @@ struct hda_bus {
         unsigned int rirb_error:1;      /* error in codec communication */
         unsigned int response_reset:1;  /* controller was reset */
         unsigned int in_reset:1;        /* during reset operation */
+        unsigned int power_keep_link_on:1; /* don't power off HDA link */
 };
 
 /*
@@ -674,6 +686,7 @@ struct hda_codec_ops {
 #ifdef CONFIG_SND_HDA_POWER_SAVE
         int (*check_power_status)(struct hda_codec *codec, hda_nid_t nid);
 #endif
+        void (*reboot_notify)(struct hda_codec *codec);
 };
 
 /* record for amp information cache */
@@ -771,6 +784,7 @@ struct hda_codec {
 
         /* beep device */
         struct hda_beep *beep;
+        unsigned int beep_mode;
 
         /* widget capabilities cache */
         unsigned int num_nodes;
@@ -778,6 +792,7 @@ struct hda_codec {
         u32 *wcaps;
 
         struct snd_array mixers;        /* list of assigned mixer elements */
+        struct snd_array nids;          /* list of mapped mixer elements */
 
         struct hda_cache_rec amp_cache; /* cache for amp access */
         struct hda_cache_rec cmd_cache; /* cache for other commands */
@@ -806,11 +821,15 @@ struct hda_codec {
         unsigned int pin_amp_workaround:1; /* pin out-amp takes index
                                             * (e.g. Conexant codecs)
                                             */
+        unsigned int no_trigger_sense:1; /* don't trigger at pin-sensing */
 #ifdef CONFIG_SND_HDA_POWER_SAVE
         unsigned int power_on :1;       /* current (global) power-state */
         unsigned int power_transition :1; /* power-state in transition */
         int power_count;        /* current (global) power refcount */
         struct delayed_work power_work; /* delayed task for powerdown */
+        unsigned long power_on_acct;
+        unsigned long power_off_acct;
+        unsigned long power_jiffies;
 #endif
 
         /* codec-specific additional proc output */
@@ -883,6 +902,7 @@ int snd_hda_codec_set_pincfg(struct hda_codec *codec, hda_nid_t nid,
                              unsigned int cfg);
 int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
                        hda_nid_t nid, unsigned int cfg); /* for hwdep */
+void snd_hda_shutup_pins(struct hda_codec *codec);
 
 /*
  * Mixer
@@ -910,6 +930,7 @@ int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
  * Misc
  */
 void snd_hda_get_codec_name(struct hda_codec *codec, char *name, int namelen);
+void snd_hda_bus_reboot_notify(struct hda_bus *bus);
 
 /*
  * power management
@@ -933,6 +954,7 @@ const char *snd_hda_get_jack_location(u32 cfg);
 void snd_hda_power_up(struct hda_codec *codec);
 void snd_hda_power_down(struct hda_codec *codec);
 #define snd_hda_codec_needs_resume(codec) codec->power_count
+void snd_hda_update_power_acct(struct hda_codec *codec);
 #else
 static inline void snd_hda_power_up(struct hda_codec *codec) {}
 static inline void snd_hda_power_down(struct hda_codec *codec) {}
diff --git a/sound/pci/hda/hda_eld.c b/sound/pci/hda/hda_eld.c
index 9446a5abea13..d8da18a9e98b 100644
--- a/sound/pci/hda/hda_eld.c
+++ b/sound/pci/hda/hda_eld.c
@@ -22,6 +22,7 @@
  */
 
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <asm/unaligned.h>
 #include "hda_codec.h"
@@ -309,17 +310,12 @@ out_fail:
         return -EINVAL;
 }
 
-static int hdmi_present_sense(struct hda_codec *codec, hda_nid_t nid)
-{
-        return snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PIN_SENSE, 0);
-}
-
 static int hdmi_eld_valid(struct hda_codec *codec, hda_nid_t nid)
 {
         int eldv;
         int present;
 
-        present = hdmi_present_sense(codec, nid);
+        present = snd_hda_pin_sense(codec, nid);
         eldv    = (present & AC_PINSENSE_ELDV);
         present = (present & AC_PINSENSE_PRESENCE);
 
@@ -336,6 +332,7 @@ int snd_hdmi_get_eld_size(struct hda_codec *codec, hda_nid_t nid)
         return snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_HDMI_DIP_SIZE,
                                                  AC_DIPSIZE_ELD_BUF);
 }
+EXPORT_SYMBOL_HDA(snd_hdmi_get_eld_size);
 
 int snd_hdmi_get_eld(struct hdmi_eld *eld,
                      struct hda_codec *codec, hda_nid_t nid)
@@ -371,6 +368,7 @@ int snd_hdmi_get_eld(struct hdmi_eld *eld,
         kfree(buf);
         return ret;
 }
+EXPORT_SYMBOL_HDA(snd_hdmi_get_eld);
 
 static void hdmi_show_short_audio_desc(struct cea_sad *a)
 {
@@ -409,6 +407,7 @@ void snd_print_channel_allocation(int spk_alloc, char *buf, int buflen)
         }
         buf[j] = '\0';  /* necessary when j == 0 */
 }
+EXPORT_SYMBOL_HDA(snd_print_channel_allocation);
 
 void snd_hdmi_show_eld(struct hdmi_eld *e)
 {
@@ -427,6 +426,7 @@ void snd_hdmi_show_eld(struct hdmi_eld *e)
         for (i = 0; i < e->sad_count; i++)
                 hdmi_show_short_audio_desc(e->sad + i);
 }
+EXPORT_SYMBOL_HDA(snd_hdmi_show_eld);
 
 #ifdef CONFIG_PROC_FS
 
@@ -477,6 +477,8 @@ static void hdmi_print_eld_info(struct snd_info_entry *entry,
                 [4 ... 7] = "reserved"
         };
 
+        snd_iprintf(buffer, "monitor_present\t\t%d\n", e->monitor_present);
+        snd_iprintf(buffer, "eld_valid\t\t%d\n", e->eld_valid);
         snd_iprintf(buffer, "monitor_name\t\t%s\n", e->monitor_name);
         snd_iprintf(buffer, "connection_type\t\t%s\n",
                                 eld_connection_type_names[e->conn_type]);
@@ -518,7 +520,11 @@ static void hdmi_write_eld_info(struct snd_info_entry *entry,
                  *      monitor_name manufacture_id product_id
                  *      eld_version edid_version
                  */
-                if (!strcmp(name, "connection_type"))
+                if (!strcmp(name, "monitor_present"))
+                        e->monitor_present = val;
+                else if (!strcmp(name, "eld_valid"))
+                        e->eld_valid = val;
+                else if (!strcmp(name, "connection_type"))
                         e->conn_type = val;
                 else if (!strcmp(name, "port_id"))
                         e->port_id = val;
@@ -560,13 +566,14 @@ static void hdmi_write_eld_info(struct snd_info_entry *entry,
 }
 
 
-int snd_hda_eld_proc_new(struct hda_codec *codec, struct hdmi_eld *eld)
+int snd_hda_eld_proc_new(struct hda_codec *codec, struct hdmi_eld *eld,
+                         int index)
 {
         char name[32];
         struct snd_info_entry *entry;
         int err;
 
-        snprintf(name, sizeof(name), "eld#%d", codec->addr);
+        snprintf(name, sizeof(name), "eld#%d.%d", codec->addr, index);
         err = snd_card_proc_new(codec->bus->card, name, &entry);
         if (err < 0)
                 return err;
@@ -578,6 +585,7 @@ int snd_hda_eld_proc_new(struct hda_codec *codec, struct hdmi_eld *eld)
 
         return 0;
 }
+EXPORT_SYMBOL_HDA(snd_hda_eld_proc_new);
 
 void snd_hda_eld_proc_free(struct hda_codec *codec, struct hdmi_eld *eld)
 {
@@ -586,5 +594,6 @@ void snd_hda_eld_proc_free(struct hda_codec *codec, struct hdmi_eld *eld)
                 eld->proc_entry = NULL;
         }
 }
+EXPORT_SYMBOL_HDA(snd_hda_eld_proc_free);
 
 #endif /* CONFIG_PROC_FS */
diff --git a/sound/pci/hda/hda_generic.c b/sound/pci/hda/hda_generic.c
index b36f6c5a92df..5ea21285ee1f 100644
--- a/sound/pci/hda/hda_generic.c
+++ b/sound/pci/hda/hda_generic.c
@@ -727,7 +727,8 @@ static int create_mixer(struct hda_codec *codec, struct hda_gnode *node,
                 if (is_loopback)
                         add_input_loopback(codec, node->nid, HDA_INPUT, index);
                 snd_printdd("[%s] NID=0x%x, DIR=IN, IDX=0x%x\n", name, node->nid, index);
-                err = snd_hda_ctl_add(codec, snd_ctl_new1(&knew, codec));
+                err = snd_hda_ctl_add(codec, node->nid,
+                                        snd_ctl_new1(&knew, codec));
                 if (err < 0)
                         return err;
                 created = 1;
@@ -737,7 +738,8 @@ static int create_mixer(struct hda_codec *codec, struct hda_gnode *node,
                 if (is_loopback)
                         add_input_loopback(codec, node->nid, HDA_OUTPUT, 0);
                 snd_printdd("[%s] NID=0x%x, DIR=OUT\n", name, node->nid);
-                err = snd_hda_ctl_add(codec, snd_ctl_new1(&knew, codec));
+                err = snd_hda_ctl_add(codec, node->nid,
+                                        snd_ctl_new1(&knew, codec));
                 if (err < 0)
                         return err;
                 created = 1;
@@ -751,7 +753,8 @@ static int create_mixer(struct hda_codec *codec, struct hda_gnode *node,
             (node->amp_in_caps & AC_AMPCAP_NUM_STEPS)) {
                 knew = (struct snd_kcontrol_new)HDA_CODEC_VOLUME(name, node->nid, index, HDA_INPUT);
                 snd_printdd("[%s] NID=0x%x, DIR=IN, IDX=0x%x\n", name, node->nid, index);
-                err = snd_hda_ctl_add(codec, snd_ctl_new1(&knew, codec));
+                err = snd_hda_ctl_add(codec, node->nid,
+                                        snd_ctl_new1(&knew, codec));
                 if (err < 0)
                         return err;
                 created = 1;
@@ -759,7 +762,8 @@ static int create_mixer(struct hda_codec *codec, struct hda_gnode *node,
                    (node->amp_out_caps & AC_AMPCAP_NUM_STEPS)) {
                 knew = (struct snd_kcontrol_new)HDA_CODEC_VOLUME(name, node->nid, 0, HDA_OUTPUT);
                 snd_printdd("[%s] NID=0x%x, DIR=OUT\n", name, node->nid);
-                err = snd_hda_ctl_add(codec, snd_ctl_new1(&knew, codec));
+                err = snd_hda_ctl_add(codec, node->nid,
+                                        snd_ctl_new1(&knew, codec));
                 if (err < 0)
                         return err;
                 created = 1;
@@ -857,7 +861,8 @@ static int build_input_controls(struct hda_codec *codec)
         }
 
         /* create input MUX if multiple sources are available */
-        err = snd_hda_ctl_add(codec, snd_ctl_new1(&cap_sel, codec));
+        err = snd_hda_ctl_add(codec, spec->adc_node->nid,
+                              snd_ctl_new1(&cap_sel, codec));
         if (err < 0)
                 return err;
 
@@ -875,7 +880,8 @@ static int build_input_controls(struct hda_codec *codec)
                         HDA_CODEC_VOLUME(name, adc_node->nid,
                                          spec->input_mux.items[i].index,
                                          HDA_INPUT);
-                err = snd_hda_ctl_add(codec, snd_ctl_new1(&knew, codec));
+                err = snd_hda_ctl_add(codec, adc_node->nid,
+                                        snd_ctl_new1(&knew, codec));
                 if (err < 0)
                         return err;
         }
diff --git a/sound/pci/hda/hda_hwdep.c b/sound/pci/hda/hda_hwdep.c
index cc24e6721d74..a1fc83753cc6 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/string.h>
 #include <linux/firmware.h>
 #include <sound/core.h>
 #include "hda_codec.h"
@@ -154,6 +155,44 @@ int /*__devinit*/ snd_hda_create_hwdep(struct hda_codec *codec)
         return 0;
 }
 
+#ifdef CONFIG_SND_HDA_POWER_SAVE
+static ssize_t power_on_acct_show(struct device *dev,
+                                  struct device_attribute *attr,
+                                  char *buf)
+{
+        struct snd_hwdep *hwdep = dev_get_drvdata(dev);
+        struct hda_codec *codec = hwdep->private_data;
+        snd_hda_update_power_acct(codec);
+        return sprintf(buf, "%u\n", jiffies_to_msecs(codec->power_on_acct));
+}
+
+static ssize_t power_off_acct_show(struct device *dev,
+                                   struct device_attribute *attr,
+                                   char *buf)
+{
+        struct snd_hwdep *hwdep = dev_get_drvdata(dev);
+        struct hda_codec *codec = hwdep->private_data;
+        snd_hda_update_power_acct(codec);
+        return sprintf(buf, "%u\n", jiffies_to_msecs(codec->power_off_acct));
+}
+
+static struct device_attribute power_attrs[] = {
+        __ATTR_RO(power_on_acct),
+        __ATTR_RO(power_off_acct),
+};
+
+int snd_hda_hwdep_add_power_sysfs(struct hda_codec *codec)
+{
+        struct snd_hwdep *hwdep = codec->hwdep;
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(power_attrs); i++)
+                snd_add_device_sysfs_file(SNDRV_DEVICE_TYPE_HWDEP, hwdep->card,
+                                          hwdep->device, &power_attrs[i]);
+        return 0;
+}
+#endif /* CONFIG_SND_HDA_POWER_SAVE */
+
 #ifdef CONFIG_SND_HDA_RECONFIG
 
 /*
@@ -254,8 +293,11 @@ static ssize_t type##_store(struct device *dev,			\
 {                                                               \
         struct snd_hwdep *hwdep = dev_get_drvdata(dev);         \
         struct hda_codec *codec = hwdep->private_data;          \
-        char *after;                                            \
-        codec->type = simple_strtoul(buf, &after, 0);           \
+        unsigned long val;                                      \
+        int err = strict_strtoul(buf, 0, &val);                 \
+        if (err < 0)                                            \
+                return err;                                     \
+        codec->type = val;                                      \
         return count;                                           \
 }
 
@@ -390,8 +432,7 @@ static int parse_hints(struct hda_codec *codec, const char *buf)
         char *key, *val;
         struct hda_hint *hint;
 
-        while (isspace(*buf))
-                buf++;
+        buf = skip_spaces(buf);
         if (!*buf || *buf == '#' || *buf == '\n')
                 return 0;
         if (*buf == '=')
@@ -406,8 +447,7 @@ static int parse_hints(struct hda_codec *codec, const char *buf)
                 return -EINVAL;
         }
         *val++ = 0;
-        while (isspace(*val))
-                val++;
+        val = skip_spaces(val);
         remove_trail_spaces(key);
         remove_trail_spaces(val);
         hint = get_hint(codec, key);
@@ -585,6 +625,10 @@ enum {
         LINE_MODE_PINCFG,
         LINE_MODE_VERB,
         LINE_MODE_HINT,
+        LINE_MODE_VENDOR_ID,
+        LINE_MODE_SUBSYSTEM_ID,
+        LINE_MODE_REVISION_ID,
+        LINE_MODE_CHIP_NAME,
         NUM_LINE_MODES,
 };
 
@@ -614,53 +658,71 @@ static void parse_codec_mode(char *buf, struct hda_bus *bus,
 }
 
 /* parse the contents after the other command tags, [pincfg], [verb],
- * [hint] and [model]
+ * [vendor_id], [subsystem_id], [revision_id], [chip_name], [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);
 }
 
+static void parse_chip_name_mode(char *buf, struct hda_bus *bus,
+                                 struct hda_codec **codecp)
+{
+        kfree((*codecp)->chip_name);
+        (*codecp)->chip_name = kstrdup(buf, GFP_KERNEL);
+}
+
+#define DEFINE_PARSE_ID_MODE(name) \
+static void parse_##name##_mode(char *buf, struct hda_bus *bus, \
+                                 struct hda_codec **codecp) \
+{ \
+        unsigned long val; \
+        if (!strict_strtoul(buf, 0, &val)) \
+                (*codecp)->name = val; \
+}
+
+DEFINE_PARSE_ID_MODE(vendor_id);
+DEFINE_PARSE_ID_MODE(subsystem_id);
+DEFINE_PARSE_ID_MODE(revision_id);
+
+
 struct hda_patch_item {
         const char *tag;
         void (*parser)(char *buf, struct hda_bus *bus, struct hda_codec **retc);
+        int need_codec;
 };
 
 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 },
+        [LINE_MODE_CODEC] = { "[codec]", parse_codec_mode, 0 },
+        [LINE_MODE_MODEL] = { "[model]", parse_model_mode, 1 },
+        [LINE_MODE_VERB] = { "[verb]", parse_verb_mode, 1 },
+        [LINE_MODE_PINCFG] = { "[pincfg]", parse_pincfg_mode, 1 },
+        [LINE_MODE_HINT] = { "[hint]", parse_hint_mode, 1 },
+        [LINE_MODE_VENDOR_ID] = { "[vendor_id]", parse_vendor_id_mode, 1 },
+        [LINE_MODE_SUBSYSTEM_ID] = { "[subsystem_id]", parse_subsystem_id_mode, 1 },
+        [LINE_MODE_REVISION_ID] = { "[revision_id]", parse_revision_id_mode, 1 },
+        [LINE_MODE_CHIP_NAME] = { "[chip_name]", parse_chip_name_mode, 1 },
 };
 
 /* check the line starting with '[' -- change the parser mode accodingly */
@@ -743,7 +805,8 @@ int snd_hda_load_patch(struct hda_bus *bus, const char *patch)
                         continue;
                 if (*buf == '[')
                         line_mode = parse_line_mode(buf, bus);
-                else if (patch_items[line_mode].parser)
+                else if (patch_items[line_mode].parser &&
+                         (codec || !patch_items[line_mode].need_codec))
                         patch_items[line_mode].parser(buf, bus, &codec);
         }
         release_firmware(fw);
diff --git a/sound/pci/hda/hda_intel.c b/sound/pci/hda/hda_intel.c
index 6517f589d01d..cec68152dcb1 100644
--- a/sound/pci/hda/hda_intel.c
+++ b/sound/pci/hda/hda_intel.c
@@ -60,10 +60,14 @@ static int bdl_pos_adj[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] = -1};
 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;
+static int enable_msi = -1;
 #ifdef CONFIG_SND_HDA_PATCH_LOADER
 static char *patch[SNDRV_CARDS];
 #endif
+#ifdef CONFIG_SND_HDA_INPUT_BEEP
+static int beep_mode[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] =
+                                        CONFIG_SND_HDA_INPUT_BEEP_MODE};
+#endif
 
 module_param_array(index, int, NULL, 0444);
 MODULE_PARM_DESC(index, "Index value for Intel HD audio interface.");
@@ -91,6 +95,11 @@ MODULE_PARM_DESC(enable_msi, "Enable Message Signaled Interrupt (MSI)");
 module_param_array(patch, charp, NULL, 0444);
 MODULE_PARM_DESC(patch, "Patch file for Intel HD audio interface.");
 #endif
+#ifdef CONFIG_SND_HDA_INPUT_BEEP
+module_param_array(beep_mode, int, NULL, 0444);
+MODULE_PARM_DESC(beep_mode, "Select HDA Beep registration mode "
+                            "(0=off, 1=on, 2=mute switch on/off) (default=1).");
+#endif
 
 #ifdef CONFIG_SND_HDA_POWER_SAVE
 static int power_save = CONFIG_SND_HDA_POWER_SAVE_DEFAULT;
@@ -116,6 +125,7 @@ MODULE_SUPPORTED_DEVICE("{{Intel, ICH6},"
                          "{Intel, ICH9},"
                          "{Intel, ICH10},"
                          "{Intel, PCH},"
+                         "{Intel, CPT},"
                          "{Intel, SCH},"
                          "{ATI, SB450},"
                          "{ATI, SB600},"
@@ -250,8 +260,6 @@ enum { SDI0, SDI1, SDI2, SDI3, SDO0, SDO1, SDO2, SDO3 };
 #define AZX_MAX_FRAG            32
 /* max buffer size - no h/w limit, you can increase as you like */
 #define AZX_MAX_BUF_SIZE        (1024*1024*1024)
-/* max number of PCM devics per card */
-#define AZX_MAX_PCMS            8
 
 /* RIRB int mask: overrun[2], response[0] */
 #define RIRB_INT_RESPONSE       0x01
@@ -259,7 +267,8 @@ enum { SDI0, SDI1, SDI2, SDI3, SDO0, SDO1, SDO2, SDO3 };
 #define RIRB_INT_MASK           0x05
 
 /* STATESTS int mask: S3,SD2,SD1,SD0 */
-#define AZX_MAX_CODECS          4
+#define AZX_MAX_CODECS          8
+#define AZX_DEFAULT_CODECS      4
 #define STATESTS_INT_MASK       ((1 << AZX_MAX_CODECS) - 1)
 
 /* SD_CTL bits */
@@ -347,6 +356,7 @@ struct azx_dev {
                                          */
         unsigned char stream_tag;       /* assigned stream */
         unsigned char index;            /* stream index */
+        int device;                     /* last device number assigned to */
 
         unsigned int opened :1;
         unsigned int running :1;
@@ -398,12 +408,13 @@ struct azx {
         struct azx_dev *azx_dev;
 
         /* PCM */
-        struct snd_pcm *pcm[AZX_MAX_PCMS];
+        struct snd_pcm *pcm[HDA_MAX_PCMS];
 
         /* HD codec */
         unsigned short codec_mask;
         int  codec_probe_mask; /* copied from probe_mask option */
         struct hda_bus *bus;
+        unsigned int beep_mode;
 
         /* CORB/RIRB */
         struct azx_rb corb;
@@ -415,6 +426,7 @@ struct azx {
 
         /* flags */
         int position_fix;
+        int poll_count;
         unsigned int running :1;
         unsigned int initialized :1;
         unsigned int single_cmd :1;
@@ -437,6 +449,7 @@ struct azx {
 /* driver types */
 enum {
         AZX_DRIVER_ICH,
+        AZX_DRIVER_PCH,
         AZX_DRIVER_SCH,
         AZX_DRIVER_ATI,
         AZX_DRIVER_ATIHDMI,
@@ -451,6 +464,7 @@ enum {
 
 static char *driver_short_names[] __devinitdata = {
         [AZX_DRIVER_ICH] = "HDA Intel",
+        [AZX_DRIVER_PCH] = "HDA Intel PCH",
         [AZX_DRIVER_SCH] = "HDA Intel MID",
         [AZX_DRIVER_ATI] = "HDA ATI SB",
         [AZX_DRIVER_ATIHDMI] = "HDA ATI HDMI",
@@ -495,7 +509,7 @@ static char *driver_short_names[] __devinitdata = {
 #define get_azx_dev(substream) (substream->runtime->private_data)
 
 static int azx_acquire_irq(struct azx *chip, int do_disconnect);
-
+static int azx_send_cmd(struct hda_bus *bus, unsigned int val);
 /*
  * Interface for HD codec
  */
@@ -653,11 +667,12 @@ static unsigned int azx_rirb_get_response(struct hda_bus *bus,
 {
         struct azx *chip = bus->private_data;
         unsigned long timeout;
+        int do_poll = 0;
 
  again:
         timeout = jiffies + msecs_to_jiffies(1000);
         for (;;) {
-                if (chip->polling_mode) {
+                if (chip->polling_mode || do_poll) {
                         spin_lock_irq(&chip->reg_lock);
                         azx_update_rirb(chip);
                         spin_unlock_irq(&chip->reg_lock);
@@ -665,6 +680,9 @@ static unsigned int azx_rirb_get_response(struct hda_bus *bus,
                 if (!chip->rirb.cmds[addr]) {
                         smp_rmb();
                         bus->rirb_error = 0;
+
+                        if (!do_poll)
+                                chip->poll_count = 0;
                         return chip->rirb.res[addr]; /* the last value */
                 }
                 if (time_after(jiffies, timeout))
@@ -677,6 +695,24 @@ static unsigned int azx_rirb_get_response(struct hda_bus *bus,
                 }
         }
 
+        if (!chip->polling_mode && chip->poll_count < 2) {
+                snd_printdd(SFX "azx_get_response timeout, "
+                           "polling the codec once: last cmd=0x%08x\n",
+                           chip->last_cmd[addr]);
+                do_poll = 1;
+                chip->poll_count++;
+                goto again;
+        }
+
+
+        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[addr]);
+                chip->polling_mode = 1;
+                goto again;
+        }
+
         if (chip->msi) {
                 snd_printk(KERN_WARNING SFX "No response from codec, "
                            "disabling MSI: last cmd=0x%08x\n",
@@ -692,14 +728,6 @@ static unsigned int azx_rirb_get_response(struct hda_bus *bus,
                 goto again;
         }
 
-        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[addr]);
-                chip->polling_mode = 1;
-                goto again;
-        }
-
         if (chip->probing) {
                 /* If this critical timeout happens during the codec probing
                  * phase, this is likely an access to a non-existing codec
@@ -942,8 +970,8 @@ static void azx_stream_start(struct azx *chip, struct azx_dev *azx_dev)
         azx_dev->insufficient = 1;
 
         /* enable SIE */
-        azx_writeb(chip, INTCTL,
-                   azx_readb(chip, INTCTL) | (1 << azx_dev->index));
+        azx_writel(chip, INTCTL,
+                   azx_readl(chip, INTCTL) | (1 << azx_dev->index));
         /* set DMA start and interrupt mask */
         azx_sd_writeb(azx_dev, SD_CTL, azx_sd_readb(azx_dev, SD_CTL) |
                       SD_CTL_DMA_START | SD_INT_MASK);
@@ -962,8 +990,8 @@ static void azx_stream_stop(struct azx *chip, struct azx_dev *azx_dev)
 {
         azx_stream_clear(chip, azx_dev);
         /* disable SIE */
-        azx_writeb(chip, INTCTL,
-                   azx_readb(chip, INTCTL) & ~(1 << azx_dev->index));
+        azx_writel(chip, INTCTL,
+                   azx_readl(chip, INTCTL) & ~(1 << azx_dev->index));
 }
 
 
@@ -1039,6 +1067,7 @@ static void azx_init_pci(struct azx *chip)
                                 0x01, NVIDIA_HDA_ENABLE_COHBIT);
                 break;
         case AZX_DRIVER_SCH:
+        case AZX_DRIVER_PCH:
                 pci_read_config_word(chip->pci, INTEL_SCH_HDA_DEVC, &snoop);
                 if (snoop & INTEL_SCH_HDA_DEVC_NOSNOOP) {
                         pci_write_config_word(chip->pci, INTEL_SCH_HDA_DEVC,
@@ -1324,7 +1353,7 @@ static void azx_bus_reset(struct hda_bus *bus)
         if (chip->initialized) {
                 int i;
 
-                for (i = 0; i < AZX_MAX_PCMS; i++)
+                for (i = 0; i < HDA_MAX_PCMS; i++)
                         snd_pcm_suspend_all(chip->pcm[i]);
                 snd_hda_suspend(chip->bus);
                 snd_hda_resume(chip->bus);
@@ -1339,6 +1368,7 @@ static void azx_bus_reset(struct hda_bus *bus)
 
 /* number of codec slots for each chipset: 0 = default slots (i.e. 4) */
 static unsigned int azx_max_codecs[AZX_NUM_DRIVERS] __devinitdata = {
+        [AZX_DRIVER_NVIDIA] = 8,
         [AZX_DRIVER_TERA] = 1,
 };
 
@@ -1371,7 +1401,7 @@ static int __devinit azx_codec_create(struct azx *chip, const char *model)
         codecs = 0;
         max_slots = azx_max_codecs[chip->driver_type];
         if (!max_slots)
-                max_slots = AZX_MAX_CODECS;
+                max_slots = AZX_DEFAULT_CODECS;
 
         /* First try to probe all given codec slots */
         for (c = 0; c < max_slots; c++) {
@@ -1386,7 +1416,7 @@ static int __devinit azx_codec_create(struct azx *chip, const char *model)
                                 chip->codec_mask &= ~(1 << c);
                                 /* More badly, accessing to a non-existing
                                  * codec often screws up the controller chip,
-                                 * and distrubs the further communications.
+                                 * and disturbs the further communications.
                                  * Thus if an error occurs during probing,
                                  * better to reset the controller chip to
                                  * get back to the sanity state.
@@ -1404,6 +1434,7 @@ static int __devinit azx_codec_create(struct azx *chip, const char *model)
                         err = snd_hda_codec_new(chip->bus, c, &codec);
                         if (err < 0)
                                 continue;
+                        codec->beep_mode = chip->beep_mode;
                         codecs++;
                 }
         }
@@ -1430,10 +1461,13 @@ static int __devinit azx_codec_configure(struct azx *chip)
  */
 
 /* assign a stream for the PCM */
-static inline struct azx_dev *azx_assign_device(struct azx *chip, int stream)
+static inline struct azx_dev *
+azx_assign_device(struct azx *chip, struct snd_pcm_substream *substream)
 {
         int dev, i, nums;
-        if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
+        struct azx_dev *res = NULL;
+
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
                 dev = chip->playback_index_offset;
                 nums = chip->playback_streams;
         } else {
@@ -1442,10 +1476,15 @@ static inline struct azx_dev *azx_assign_device(struct azx *chip, int stream)
         }
         for (i = 0; i < nums; i++, dev++)
                 if (!chip->azx_dev[dev].opened) {
-                        chip->azx_dev[dev].opened = 1;
-                        return &chip->azx_dev[dev];
+                        res = &chip->azx_dev[dev];
+                        if (res->device == substream->pcm->device)
+                                break;
                 }
-        return NULL;
+        if (res) {
+                res->opened = 1;
+                res->device = substream->pcm->device;
+        }
+        return res;
 }
 
 /* release the assigned stream */
@@ -1494,7 +1533,7 @@ static int azx_pcm_open(struct snd_pcm_substream *substream)
         int err;
 
         mutex_lock(&chip->open_mutex);
-        azx_dev = azx_assign_device(chip, substream->stream);
+        azx_dev = azx_assign_device(chip, substream);
         if (azx_dev == NULL) {
                 mutex_unlock(&chip->open_mutex);
                 return -EBUSY;
@@ -1858,6 +1897,9 @@ static int azx_position_ok(struct azx *chip, struct azx_dev *azx_dev)
 
         if (!bdl_pos_adj[chip->dev_index])
                 return 1; /* no delayed ack */
+        if (WARN_ONCE(!azx_dev->period_bytes,
+                      "hda-intel: zero azx_dev->period_bytes"))
+                return 0; /* this shouldn't happen! */
         if (pos % azx_dev->period_bytes > azx_dev->period_bytes / 2)
                 return 0; /* NG - it's below the period boundary */
         return 1; /* OK, it's fine */
@@ -1945,7 +1987,7 @@ azx_attach_pcm_stream(struct hda_bus *bus, struct hda_codec *codec,
         int pcm_dev = cpcm->device;
         int s, err;
 
-        if (pcm_dev >= AZX_MAX_PCMS) {
+        if (pcm_dev >= HDA_MAX_PCMS) {
                 snd_printk(KERN_ERR SFX "Invalid PCM device number %d\n",
                            pcm_dev);
                 return -EINVAL;
@@ -2023,7 +2065,7 @@ static int azx_acquire_irq(struct azx *chip, int do_disconnect)
 {
         if (request_irq(chip->pci->irq, azx_interrupt,
                         chip->msi ? 0 : IRQF_SHARED,
-                        "HDA Intel", chip)) {
+                        "hda_intel", chip)) {
                 printk(KERN_ERR "hda-intel: unable to grab IRQ %d, "
                        "disabling device\n", chip->pci->irq);
                 if (do_disconnect)
@@ -2071,7 +2113,8 @@ static void azx_power_notify(struct hda_bus *bus)
         }
         if (power_on)
                 azx_init_chip(chip);
-        else if (chip->running && power_save_controller)
+        else if (chip->running && power_save_controller &&
+                 !bus->power_keep_link_on)
                 azx_stop_chip(chip);
 }
 #endif /* CONFIG_SND_HDA_POWER_SAVE */
@@ -2100,7 +2143,7 @@ static int azx_suspend(struct pci_dev *pci, pm_message_t state)
 
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
         azx_clear_irq_pending(chip);
-        for (i = 0; i < AZX_MAX_PCMS; i++)
+        for (i = 0; i < HDA_MAX_PCMS; i++)
                 snd_pcm_suspend_all(chip->pcm[i]);
         if (chip->initialized)
                 snd_hda_suspend(chip->bus);
@@ -2154,6 +2197,7 @@ static int azx_resume(struct pci_dev *pci)
 static int azx_halt(struct notifier_block *nb, unsigned long event, void *buf)
 {
         struct azx *chip = container_of(nb, struct azx, reboot_notifier);
+        snd_hda_bus_reboot_notify(chip->bus);
         azx_stop_chip(chip);
         return NOTIFY_OK;
 }
@@ -2221,7 +2265,16 @@ static int azx_dev_free(struct snd_device *device)
 static struct snd_pci_quirk position_fix_list[] __devinitdata = {
         SND_PCI_QUIRK(0x1028, 0x01cc, "Dell D820", POS_FIX_LPIB),
         SND_PCI_QUIRK(0x1028, 0x01de, "Dell Precision 390", POS_FIX_LPIB),
+        SND_PCI_QUIRK(0x1028, 0x01f6, "Dell Latitude 131L", POS_FIX_LPIB),
+        SND_PCI_QUIRK(0x103c, 0x306d, "HP dv3", POS_FIX_LPIB),
+        SND_PCI_QUIRK(0x1106, 0x3288, "ASUS M2V-MX SE", POS_FIX_LPIB),
         SND_PCI_QUIRK(0x1043, 0x813d, "ASUS P5AD2", POS_FIX_LPIB),
+        SND_PCI_QUIRK(0x1458, 0xa022, "ga-ma770-ud3", POS_FIX_LPIB),
+        SND_PCI_QUIRK(0x1462, 0x1002, "MSI Wind U115", POS_FIX_LPIB),
+        SND_PCI_QUIRK(0x1565, 0x820f, "Biostar Microtech", POS_FIX_LPIB),
+        SND_PCI_QUIRK(0x1565, 0x8218, "Biostar Microtech", POS_FIX_LPIB),
+        SND_PCI_QUIRK(0x8086, 0x2503, "DG965OT AAD63733-203", POS_FIX_LPIB),
+        SND_PCI_QUIRK(0x8086, 0xd601, "eMachines T5212", POS_FIX_LPIB),
         {}
 };
 
@@ -2304,11 +2357,14 @@ static void __devinit check_probe_mask(struct azx *chip, int dev)
 }
 
 /*
- * white-list for enable_msi
+ * white/black-list for enable_msi
  */
-static struct snd_pci_quirk msi_white_list[] __devinitdata = {
-        SND_PCI_QUIRK(0x103c, 0x30f7, "HP Pavilion dv4t-1300", 1),
-        SND_PCI_QUIRK(0x103c, 0x3607, "HP Compa CQ40", 1),
+static struct snd_pci_quirk msi_black_list[] __devinitdata = {
+        SND_PCI_QUIRK(0x1043, 0x81f2, "ASUS", 0), /* Athlon64 X2 + nvidia */
+        SND_PCI_QUIRK(0x1043, 0x81f6, "ASUS", 0), /* nvidia */
+        SND_PCI_QUIRK(0x1043, 0x822d, "ASUS", 0), /* Athlon64 X2 + nvidia MCP55 */
+        SND_PCI_QUIRK(0x1849, 0x0888, "ASRock", 0), /* Athlon64 X2 + nvidia */
+        SND_PCI_QUIRK(0xa0a0, 0x0575, "Aopen MZ915-M", 0), /* ICH6 */
         {}
 };
 
@@ -2316,15 +2372,24 @@ static void __devinit check_msi(struct azx *chip)
 {
         const struct snd_pci_quirk *q;
 
-        chip->msi = enable_msi;
-        if (chip->msi)
+        if (enable_msi >= 0) {
+                chip->msi = !!enable_msi;
                 return;
-        q = snd_pci_quirk_lookup(chip->pci, msi_white_list);
+        }
+        chip->msi = 1;  /* enable MSI as default */
+        q = snd_pci_quirk_lookup(chip->pci, msi_black_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;
+                return;
+        }
+
+        /* NVidia chipsets seem to cause troubles with MSI */
+        if (chip->driver_type == AZX_DRIVER_NVIDIA) {
+                printk(KERN_INFO "hda_intel: Disable MSI for Nvidia chipset\n");
+                chip->msi = 0;
         }
 }
 
@@ -2374,6 +2439,7 @@ static int __devinit azx_create(struct snd_card *card, struct pci_dev *pci,
         if (bdl_pos_adj[dev] < 0) {
                 switch (chip->driver_type) {
                 case AZX_DRIVER_ICH:
+                case AZX_DRIVER_PCH:
                         bdl_pos_adj[dev] = 1;
                         break;
                 default:
@@ -2436,6 +2502,11 @@ static int __devinit azx_create(struct snd_card *card, struct pci_dev *pci,
                 }
         }
 
+        /* disable 64bit DMA address for Teradici */
+        /* it does not work with device 6549:1200 subsys e4a2:040b */
+        if (chip->driver_type == AZX_DRIVER_TERA)
+                gcap &= ~ICH6_GCAP_64OK;
+
         /* allow 64bit DMA address if supported by H/W */
         if ((gcap & ICH6_GCAP_64OK) && !pci_set_dma_mask(pci, DMA_BIT_MASK(64)))
                 pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(64));
@@ -2578,6 +2649,10 @@ static int __devinit azx_probe(struct pci_dev *pci,
                 goto out_free;
         card->private_data = chip;
 
+#ifdef CONFIG_SND_HDA_INPUT_BEEP
+        chip->beep_mode = beep_mode[dev];
+#endif
+
         /* create codec instances */
         err = azx_codec_create(chip, model[dev]);
         if (err < 0)
@@ -2630,7 +2705,7 @@ static void __devexit azx_remove(struct pci_dev *pci)
 }
 
 /* PCI IDs */
-static struct pci_device_id azx_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(azx_ids) = {
         /* ICH 6..10 */
         { PCI_DEVICE(0x8086, 0x2668), .driver_data = AZX_DRIVER_ICH },
         { PCI_DEVICE(0x8086, 0x27d8), .driver_data = AZX_DRIVER_ICH },
@@ -2643,6 +2718,9 @@ static struct pci_device_id azx_ids[] = {
         { PCI_DEVICE(0x8086, 0x3a6e), .driver_data = AZX_DRIVER_ICH },
         /* PCH */
         { PCI_DEVICE(0x8086, 0x3b56), .driver_data = AZX_DRIVER_ICH },
+        { PCI_DEVICE(0x8086, 0x3b57), .driver_data = AZX_DRIVER_ICH },
+        /* CPT */
+        { PCI_DEVICE(0x8086, 0x1c20), .driver_data = AZX_DRIVER_PCH },
         /* SCH */
         { PCI_DEVICE(0x8086, 0x811b), .driver_data = AZX_DRIVER_SCH },
         /* ATI SB 450/600 */
@@ -2670,29 +2748,10 @@ static struct pci_device_id azx_ids[] = {
         /* ULI M5461 */
         { PCI_DEVICE(0x10b9, 0x5461), .driver_data = AZX_DRIVER_ULI },
         /* NVIDIA MCP */
-        { PCI_DEVICE(0x10de, 0x026c), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x0371), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x03e4), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x03f0), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x044a), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x044b), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x055c), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x055d), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x0590), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x0774), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x0775), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x0776), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x0777), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x07fc), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x07fd), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x0ac0), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x0ac1), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x0ac2), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x0ac3), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x0d94), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x0d95), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x0d96), .driver_data = AZX_DRIVER_NVIDIA },
-        { PCI_DEVICE(0x10de, 0x0d97), .driver_data = AZX_DRIVER_NVIDIA },
+        { PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID),
+          .class = PCI_CLASS_MULTIMEDIA_HD_AUDIO << 8,
+          .class_mask = 0xffffff,
+          .driver_data = AZX_DRIVER_NVIDIA },
         /* Teradici */
         { PCI_DEVICE(0x6549, 0x1200), .driver_data = AZX_DRIVER_TERA },
         /* Creative X-Fi (CA0110-IBG) */
diff --git a/sound/pci/hda/hda_local.h b/sound/pci/hda/hda_local.h
index 5f1dcc59002b..7cee364976ff 100644
--- a/sound/pci/hda/hda_local.h
+++ b/sound/pci/hda/hda_local.h
@@ -23,6 +23,16 @@
 #ifndef __SOUND_HDA_LOCAL_H
 #define __SOUND_HDA_LOCAL_H
 
+/* We abuse kcontrol_new.subdev field to pass the NID corresponding to
+ * the given new control.  If id.subdev has a bit flag HDA_SUBDEV_NID_FLAG,
+ * snd_hda_ctl_add() takes the lower-bit subdev value as a valid NID.
+ * 
+ * Note that the subdevice field is cleared again before the real registration
+ * in snd_hda_ctl_add(), so that this value won't appear in the outside.
+ */
+#define HDA_SUBDEV_NID_FLAG     (1U << 31)
+#define HDA_SUBDEV_AMP_FLAG     (1U << 30)
+
 /*
  * for mixer controls
  */
@@ -33,6 +43,7 @@
 /* mono volume with index (index=0,1,...) (channel=1,2) */
 #define HDA_CODEC_VOLUME_MONO_IDX(xname, xcidx, nid, channel, xindex, direction) \
         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xcidx,  \
+          .subdevice = HDA_SUBDEV_AMP_FLAG, \
           .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
                     SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
                     SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK, \
@@ -53,6 +64,7 @@
 /* mono mute switch with index (index=0,1,...) (channel=1,2) */
 #define HDA_CODEC_MUTE_MONO_IDX(xname, xcidx, nid, channel, xindex, direction) \
         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xcidx, \
+          .subdevice = HDA_SUBDEV_AMP_FLAG, \
           .info = snd_hda_mixer_amp_switch_info, \
           .get = snd_hda_mixer_amp_switch_get, \
           .put = snd_hda_mixer_amp_switch_put, \
@@ -66,6 +78,28 @@
 /* stereo mute switch */
 #define HDA_CODEC_MUTE(xname, nid, xindex, direction) \
         HDA_CODEC_MUTE_MONO(xname, nid, 3, xindex, direction)
+#ifdef CONFIG_SND_HDA_INPUT_BEEP
+/* special beep mono mute switch with index (index=0,1,...) (channel=1,2) */
+#define HDA_CODEC_MUTE_BEEP_MONO_IDX(xname, xcidx, nid, channel, xindex, direction) \
+        { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xcidx, \
+          .subdevice = HDA_SUBDEV_AMP_FLAG, \
+          .info = snd_hda_mixer_amp_switch_info, \
+          .get = snd_hda_mixer_amp_switch_get, \
+          .put = snd_hda_mixer_amp_switch_put_beep, \
+          .private_value = HDA_COMPOSE_AMP_VAL(nid, channel, xindex, direction) }
+#else
+/* no digital beep - just the standard one */
+#define HDA_CODEC_MUTE_BEEP_MONO_IDX(xname, xcidx, nid, ch, xidx, dir) \
+        HDA_CODEC_MUTE_MONO_IDX(xname, xcidx, nid, ch, xidx, dir)
+#endif /* CONFIG_SND_HDA_INPUT_BEEP */
+/* special beep mono mute switch */
+#define HDA_CODEC_MUTE_BEEP_MONO(xname, nid, channel, xindex, direction) \
+        HDA_CODEC_MUTE_BEEP_MONO_IDX(xname, 0, nid, channel, xindex, direction)
+/* special beep stereo mute switch */
+#define HDA_CODEC_MUTE_BEEP(xname, nid, xindex, direction) \
+        HDA_CODEC_MUTE_BEEP_MONO(xname, nid, 3, xindex, direction)
+
+extern const char *snd_hda_pcm_type_name[];
 
 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
                                   struct snd_ctl_elem_info *uinfo);
@@ -81,6 +115,10 @@ int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
                                  struct snd_ctl_elem_value *ucontrol);
 int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
                                  struct snd_ctl_elem_value *ucontrol);
+#ifdef CONFIG_SND_HDA_INPUT_BEEP
+int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol *kcontrol,
+                                      struct snd_ctl_elem_value *ucontrol);
+#endif
 /* lowlevel accessor with caching; use carefully */
 int snd_hda_codec_amp_read(struct hda_codec *codec, hda_nid_t nid, int ch,
                            int direction, int index);
@@ -424,8 +462,23 @@ 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);
 u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid);
+u32 snd_hda_pin_sense(struct hda_codec *codec, hda_nid_t nid);
+int snd_hda_jack_detect(struct hda_codec *codec, hda_nid_t nid);
 
-int snd_hda_ctl_add(struct hda_codec *codec, struct snd_kcontrol *kctl);
+/* flags for hda_nid_item */
+#define HDA_NID_ITEM_AMP        (1<<0)
+
+struct hda_nid_item {
+        struct snd_kcontrol *kctl;
+        unsigned int index;
+        hda_nid_t nid;
+        unsigned short flags;
+};
+
+int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
+                    struct snd_kcontrol *kctl);
+int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl,
+                    unsigned int index, hda_nid_t nid);
 void snd_hda_ctls_clear(struct hda_codec *codec);
 
 /*
@@ -437,6 +490,15 @@ int snd_hda_create_hwdep(struct hda_codec *codec);
 static inline int snd_hda_create_hwdep(struct hda_codec *codec) { return 0; }
 #endif
 
+#if defined(CONFIG_SND_HDA_POWER_SAVE) && defined(CONFIG_SND_HDA_HWDEP)
+int snd_hda_hwdep_add_power_sysfs(struct hda_codec *codec);
+#else
+static inline int snd_hda_hwdep_add_power_sysfs(struct hda_codec *codec)
+{
+        return 0;
+}
+#endif
+
 #ifdef CONFIG_SND_HDA_RECONFIG
 int snd_hda_hwdep_add_sysfs(struct hda_codec *codec);
 #else
@@ -490,7 +552,8 @@ int snd_hda_check_amp_list_power(struct hda_codec *codec,
  * AMP control callbacks
  */
 /* retrieve parameters from private_value */
-#define get_amp_nid(kc)         ((kc)->private_value & 0xffff)
+#define get_amp_nid_(pv)        ((pv) & 0xffff)
+#define get_amp_nid(kc)         get_amp_nid_((kc)->private_value)
 #define get_amp_channels(kc)    (((kc)->private_value >> 16) & 0x3)
 #define get_amp_direction(kc)   (((kc)->private_value >> 18) & 0x1)
 #define get_amp_index(kc)       (((kc)->private_value >> 19) & 0xf)
@@ -516,9 +579,11 @@ struct cea_sad {
  * ELD: EDID Like Data
  */
 struct hdmi_eld {
+        bool    monitor_present;
+        bool    eld_valid;
         int     eld_size;
         int     baseline_len;
-        int     eld_ver;        /* (eld_ver == 0) indicates invalid ELD */
+        int     eld_ver;
         int     cea_edid_ver;
         char    monitor_name[ELD_MAX_MNL + 1];
         int     manufacture_id;
@@ -541,11 +606,13 @@ int snd_hdmi_get_eld(struct hdmi_eld *, struct hda_codec *, hda_nid_t);
 void snd_hdmi_show_eld(struct hdmi_eld *eld);
 
 #ifdef CONFIG_PROC_FS
-int snd_hda_eld_proc_new(struct hda_codec *codec, struct hdmi_eld *eld);
+int snd_hda_eld_proc_new(struct hda_codec *codec, struct hdmi_eld *eld,
+                         int index);
 void snd_hda_eld_proc_free(struct hda_codec *codec, struct hdmi_eld *eld);
 #else
 static inline int snd_hda_eld_proc_new(struct hda_codec *codec,
-                                       struct hdmi_eld *eld)
+                                       struct hdmi_eld *eld,
+                                       int index)
 {
         return 0;
 }
diff --git a/sound/pci/hda/hda_proc.c b/sound/pci/hda/hda_proc.c
index 95f24e4729f8..f97d35de66c4 100644
--- a/sound/pci/hda/hda_proc.c
+++ b/sound/pci/hda/hda_proc.c
@@ -26,6 +26,21 @@
 #include "hda_codec.h"
 #include "hda_local.h"
 
+static char *bits_names(unsigned int bits, char *names[], int size)
+{
+        int i, n;
+        static char buf[128];
+
+        for (i = 0, n = 0; i < size; i++) {
+                if (bits & (1U<<i) && names[i])
+                        n += snprintf(buf + n, sizeof(buf) - n, " %s",
+                                      names[i]);
+        }
+        buf[n] = '\0';
+
+        return buf;
+}
+
 static const char *get_wid_type_name(unsigned int wid_value)
 {
         static char *names[16] = {
@@ -46,6 +61,52 @@ static const char *get_wid_type_name(unsigned int wid_value)
                 return "UNKNOWN Widget";
 }
 
+static void print_nid_array(struct snd_info_buffer *buffer,
+                            struct hda_codec *codec, hda_nid_t nid,
+                            struct snd_array *array)
+{
+        int i;
+        struct hda_nid_item *items = array->list, *item;
+        struct snd_kcontrol *kctl;
+        for (i = 0; i < array->used; i++) {
+                item = &items[i];
+                if (item->nid == nid) {
+                        kctl = item->kctl;
+                        snd_iprintf(buffer,
+                          "  Control: name=\"%s\", index=%i, device=%i\n",
+                          kctl->id.name, kctl->id.index + item->index,
+                          kctl->id.device);
+                        if (item->flags & HDA_NID_ITEM_AMP)
+                                snd_iprintf(buffer,
+                                  "    ControlAmp: chs=%lu, dir=%s, "
+                                  "idx=%lu, ofs=%lu\n",
+                                  get_amp_channels(kctl),
+                                  get_amp_direction(kctl) ? "Out" : "In",
+                                  get_amp_index(kctl),
+                                  get_amp_offset(kctl));
+                }
+        }
+}
+
+static void print_nid_pcms(struct snd_info_buffer *buffer,
+                           struct hda_codec *codec, hda_nid_t nid)
+{
+        int pcm, type;
+        struct hda_pcm *cpcm;
+        for (pcm = 0; pcm < codec->num_pcms; pcm++) {
+                cpcm = &codec->pcm_info[pcm];
+                for (type = 0; type < 2; type++) {
+                        if (cpcm->stream[type].nid != nid || cpcm->pcm == NULL)
+                                continue;
+                        snd_iprintf(buffer, "  Device: name=\"%s\", "
+                                    "type=\"%s\", device=%i\n",
+                                    cpcm->name,
+                                    snd_hda_pcm_type_name[cpcm->pcm_type],
+                                    cpcm->pcm->device);
+                }
+        }
+}
+
 static void print_amp_caps(struct snd_info_buffer *buffer,
                            struct hda_codec *codec, hda_nid_t nid, int dir)
 {
@@ -190,9 +251,14 @@ static void print_pin_caps(struct snd_info_buffer *buffer,
                 /* Realtek uses this bit as a different meaning */
                 if ((codec->vendor_id >> 16) == 0x10ec)
                         snd_iprintf(buffer, " R/L");
-                else
+                else {
+                        if (caps & AC_PINCAP_HBR)
+                                snd_iprintf(buffer, " HBR");
                         snd_iprintf(buffer, " HDMI");
+                }
         }
+        if (caps & AC_PINCAP_DP)
+                snd_iprintf(buffer, " DP");
         if (caps & AC_PINCAP_TRIG_REQ)
                 snd_iprintf(buffer, " Trigger");
         if (caps & AC_PINCAP_IMP_SENSE)
@@ -363,8 +429,24 @@ static const char *get_pwr_state(u32 state)
 static void print_power_state(struct snd_info_buffer *buffer,
                               struct hda_codec *codec, hda_nid_t nid)
 {
+        static char *names[] = {
+                [ilog2(AC_PWRST_D0SUP)]         = "D0",
+                [ilog2(AC_PWRST_D1SUP)]         = "D1",
+                [ilog2(AC_PWRST_D2SUP)]         = "D2",
+                [ilog2(AC_PWRST_D3SUP)]         = "D3",
+                [ilog2(AC_PWRST_D3COLDSUP)]     = "D3cold",
+                [ilog2(AC_PWRST_S3D3COLDSUP)]   = "S3D3cold",
+                [ilog2(AC_PWRST_CLKSTOP)]       = "CLKSTOP",
+                [ilog2(AC_PWRST_EPSS)]          = "EPSS",
+        };
+
+        int sup = snd_hda_param_read(codec, nid, AC_PAR_POWER_STATE);
         int pwr = snd_hda_codec_read(codec, nid, 0,
                                      AC_VERB_GET_POWER_STATE, 0);
+        if (sup)
+                snd_iprintf(buffer, "  Power states: %s\n",
+                            bits_names(sup, names, ARRAY_SIZE(names)));
+
         snd_iprintf(buffer, "  Power: setting=%s, actual=%s\n",
                     get_pwr_state(pwr & AC_PWRST_SETTING),
                     get_pwr_state((pwr & AC_PWRST_ACTUAL) >>
@@ -457,6 +539,8 @@ static void print_gpio(struct snd_info_buffer *buffer,
                             (data & (1<<i)) ? 1 : 0,
                             (unsol & (1<<i)) ? 1 : 0);
         /* FIXME: add GPO and GPI pin information */
+        print_nid_array(buffer, codec, nid, &codec->mixers);
+        print_nid_array(buffer, codec, nid, &codec->nids);
 }
 
 static void print_codec_info(struct snd_info_entry *entry,
@@ -536,6 +620,10 @@ static void print_codec_info(struct snd_info_entry *entry,
                         snd_iprintf(buffer, " CP");
                 snd_iprintf(buffer, "\n");
 
+                print_nid_array(buffer, codec, nid, &codec->mixers);
+                print_nid_array(buffer, codec, nid, &codec->nids);
+                print_nid_pcms(buffer, codec, nid);
+
                 /* volume knob is a special widget that always have connection
                  * list
                  */
diff --git a/sound/pci/hda/patch_analog.c b/sound/pci/hda/patch_analog.c
index 2d603f6aba63..e9fdfc4b1c57 100644
--- a/sound/pci/hda/patch_analog.c
+++ b/sound/pci/hda/patch_analog.c
@@ -72,7 +72,8 @@ struct ad198x_spec {
         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 
         unsigned int jack_present :1;
-        unsigned int inv_jack_detect:1;
+        unsigned int inv_jack_detect:1; /* inverted jack-detection */
+        unsigned int inv_eapd:1;        /* inverted EAPD implementation */
 
 #ifdef CONFIG_SND_HDA_POWER_SAVE
         struct hda_loopback_check loopback;
@@ -156,19 +157,24 @@ static const char *ad_slave_sws[] = {
 
 static void ad198x_free_kctls(struct hda_codec *codec);
 
+#ifdef CONFIG_SND_HDA_INPUT_BEEP
 /* additional beep mixers; the actual parameters are overwritten at build */
 static struct snd_kcontrol_new ad_beep_mixer[] = {
         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_OUTPUT),
-        HDA_CODEC_MUTE("Beep Playback Switch", 0, 0, HDA_OUTPUT),
+        HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_OUTPUT),
         { } /* end */
 };
 
 #define set_beep_amp(spec, nid, idx, dir) \
         ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 1, idx, dir)) /* mono */
+#else
+#define set_beep_amp(spec, nid, idx, dir) /* NOP */
+#endif
 
 static int ad198x_build_controls(struct hda_codec *codec)
 {
         struct ad198x_spec *spec = codec->spec;
+        struct snd_kcontrol *kctl;
         unsigned int i;
         int err;
 
@@ -194,6 +200,7 @@ static int ad198x_build_controls(struct hda_codec *codec)
         }
 
         /* create beep controls if needed */
+#ifdef CONFIG_SND_HDA_INPUT_BEEP
         if (spec->beep_amp) {
                 struct snd_kcontrol_new *knew;
                 for (knew = ad_beep_mixer; knew->name; knew++) {
@@ -202,11 +209,12 @@ static int ad198x_build_controls(struct hda_codec *codec)
                         if (!kctl)
                                 return -ENOMEM;
                         kctl->private_value = spec->beep_amp;
-                        err = snd_hda_ctl_add(codec, kctl);
+                        err = snd_hda_ctl_add(codec, 0, kctl);
                         if (err < 0)
                                 return err;
                 }
         }
+#endif
 
         /* if we have no master control, let's create it */
         if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
@@ -230,6 +238,27 @@ static int ad198x_build_controls(struct hda_codec *codec)
         }
 
         ad198x_free_kctls(codec); /* no longer needed */
+
+        /* assign Capture Source enums to NID */
+        kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");
+        if (!kctl)
+                kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
+        for (i = 0; kctl && i < kctl->count; i++) {
+                err = snd_hda_add_nid(codec, kctl, i, spec->capsrc_nids[i]);
+                if (err < 0)
+                        return err;
+        }
+
+        /* assign IEC958 enums to NID */
+        kctl = snd_hda_find_mixer_ctl(codec,
+                        SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source");
+        if (kctl) {
+                err = snd_hda_add_nid(codec, kctl, 0,
+                                      spec->multiout.dig_out_nid);
+                if (err < 0)
+                        return err;
+        }
+
         return 0;
 }
 
@@ -412,6 +441,11 @@ static int ad198x_build_pcms(struct hda_codec *codec)
         return 0;
 }
 
+static inline void ad198x_shutup(struct hda_codec *codec)
+{
+        snd_hda_shutup_pins(codec);
+}
+
 static void ad198x_free_kctls(struct hda_codec *codec)
 {
         struct ad198x_spec *spec = codec->spec;
@@ -425,6 +459,46 @@ static void ad198x_free_kctls(struct hda_codec *codec)
         snd_array_free(&spec->kctls);
 }
 
+static void ad198x_power_eapd_write(struct hda_codec *codec, hda_nid_t front,
+                                hda_nid_t hp)
+{
+        struct ad198x_spec *spec = codec->spec;
+        snd_hda_codec_write(codec, front, 0, AC_VERB_SET_EAPD_BTLENABLE,
+                            !spec->inv_eapd ? 0x00 : 0x02);
+        snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_EAPD_BTLENABLE,
+                            !spec->inv_eapd ? 0x00 : 0x02);
+}
+
+static void ad198x_power_eapd(struct hda_codec *codec)
+{
+        /* We currently only handle front, HP */
+        switch (codec->vendor_id) {
+        case 0x11d41882:
+        case 0x11d4882a:
+        case 0x11d41884:
+        case 0x11d41984:
+        case 0x11d41883:
+        case 0x11d4184a:
+        case 0x11d4194a:
+        case 0x11d4194b:
+                ad198x_power_eapd_write(codec, 0x12, 0x11);
+                break;
+        case 0x11d41981:
+        case 0x11d41983:
+                ad198x_power_eapd_write(codec, 0x05, 0x06);
+                break;
+        case 0x11d41986:
+                ad198x_power_eapd_write(codec, 0x1b, 0x1a);
+                break;
+        case 0x11d41988:
+        case 0x11d4198b:
+        case 0x11d4989a:
+        case 0x11d4989b:
+                ad198x_power_eapd_write(codec, 0x29, 0x22);
+                break;
+        }
+}
+
 static void ad198x_free(struct hda_codec *codec)
 {
         struct ad198x_spec *spec = codec->spec;
@@ -432,11 +506,21 @@ static void ad198x_free(struct hda_codec *codec)
         if (!spec)
                 return;
 
+        ad198x_shutup(codec);
         ad198x_free_kctls(codec);
         kfree(spec);
         snd_hda_detach_beep_device(codec);
 }
 
+#ifdef SND_HDA_NEEDS_RESUME
+static int ad198x_suspend(struct hda_codec *codec, pm_message_t state)
+{
+        ad198x_shutup(codec);
+        ad198x_power_eapd(codec);
+        return 0;
+}
+#endif
+
 static struct hda_codec_ops ad198x_patch_ops = {
         .build_controls = ad198x_build_controls,
         .build_pcms = ad198x_build_pcms,
@@ -445,12 +529,16 @@ static struct hda_codec_ops ad198x_patch_ops = {
 #ifdef CONFIG_SND_HDA_POWER_SAVE
         .check_power_status = ad198x_check_power_status,
 #endif
+#ifdef SND_HDA_NEEDS_RESUME
+        .suspend = ad198x_suspend,
+#endif
+        .reboot_notify = ad198x_shutup,
 };
 
 
 /*
  * EAPD control
- * the private value = nid | (invert << 8)
+ * the private value = nid
  */
 #define ad198x_eapd_info        snd_ctl_boolean_mono_info
 
@@ -459,8 +547,7 @@ static int ad198x_eapd_get(struct snd_kcontrol *kcontrol,
 {
         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
         struct ad198x_spec *spec = codec->spec;
-        int invert = (kcontrol->private_value >> 8) & 1;
-        if (invert)
+        if (spec->inv_eapd)
                 ucontrol->value.integer.value[0] = ! spec->cur_eapd;
         else
                 ucontrol->value.integer.value[0] = spec->cur_eapd;
@@ -472,11 +559,10 @@ static int ad198x_eapd_put(struct snd_kcontrol *kcontrol,
 {
         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
         struct ad198x_spec *spec = codec->spec;
-        int invert = (kcontrol->private_value >> 8) & 1;
         hda_nid_t nid = kcontrol->private_value & 0xff;
         unsigned int eapd;
         eapd = !!ucontrol->value.integer.value[0];
-        if (invert)
+        if (spec->inv_eapd)
                 eapd = !eapd;
         if (eapd == spec->cur_eapd)
                 return 0;
@@ -694,10 +780,11 @@ static struct snd_kcontrol_new ad1986a_laptop_eapd_mixers[] = {
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
                 .name = "External Amplifier",
+                .subdevice = HDA_SUBDEV_NID_FLAG | 0x1b,
                 .info = ad198x_eapd_info,
                 .get = ad198x_eapd_get,
                 .put = ad198x_eapd_put,
-                .private_value = 0x1b | (1 << 8), /* port-D, inversed */
+                .private_value = 0x1b, /* port-D */
         },
         { } /* end */
 };
@@ -712,10 +799,10 @@ static struct snd_kcontrol_new ad1986a_laptop_intmic_mixers[] = {
 static void ad1986a_automic(struct hda_codec *codec)
 {
         unsigned int present;
-        present = snd_hda_codec_read(codec, 0x1f, 0, AC_VERB_GET_PIN_SENSE, 0);
+        present = snd_hda_jack_detect(codec, 0x1f);
         /* 0 = 0x1f, 2 = 0x1d, 4 = mixed */
         snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_CONNECT_SEL,
-                            (present & AC_PINSENSE_PRESENCE) ? 0 : 2);
+                            present ? 0 : 2);
 }
 
 #define AD1986A_MIC_EVENT               0x36
@@ -754,10 +841,8 @@ static void ad1986a_update_hp(struct hda_codec *codec)
 static void ad1986a_hp_automute(struct hda_codec *codec)
 {
         struct ad198x_spec *spec = codec->spec;
-        unsigned int present;
 
-        present = snd_hda_codec_read(codec, 0x1a, 0, AC_VERB_GET_PIN_SENSE, 0);
-        spec->jack_present = !!(present & 0x80000000);
+        spec->jack_present = snd_hda_jack_detect(codec, 0x1a);
         if (spec->inv_jack_detect)
                 spec->jack_present = !spec->jack_present;
         ad1986a_update_hp(codec);
@@ -803,6 +888,7 @@ static struct snd_kcontrol_new ad1986a_automute_master_mixers[] = {
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
                 .name = "Master Playback Switch",
+                .subdevice = HDA_SUBDEV_AMP_FLAG,
                 .info = snd_hda_mixer_amp_switch_info,
                 .get = snd_hda_mixer_amp_switch_get,
                 .put = ad1986a_hp_master_sw_put,
@@ -1003,7 +1089,7 @@ static struct snd_pci_quirk ad1986a_cfg_tbl[] = {
         SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS M2N", AD1986A_3STACK),
         SND_PCI_QUIRK(0x1043, 0x8234, "ASUS M2N", AD1986A_3STACK),
         SND_PCI_QUIRK(0x10de, 0xcb84, "ASUS A8N-VM", AD1986A_3STACK),
-        SND_PCI_QUIRK(0x1179, 0xff40, "Toshiba", AD1986A_LAPTOP_EAPD),
+        SND_PCI_QUIRK(0x1179, 0xff40, "Toshiba Satellite L40-10Q", AD1986A_3STACK),
         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),
@@ -1068,6 +1154,7 @@ static int patch_ad1986a(struct hda_codec *codec)
         spec->loopback.amplist = ad1986a_loopbacks;
 #endif
         spec->vmaster_nid = 0x1b;
+        spec->inv_eapd = 1; /* AD1986A has the inverted EAPD implementation */
 
         codec->patch_ops = ad198x_patch_ops;
 
@@ -1180,6 +1267,8 @@ static int patch_ad1986a(struct hda_codec *codec)
          */
         spec->multiout.no_share_stream = 1;
 
+        codec->no_trigger_sense = 1;
+
         return 0;
 }
 
@@ -1365,6 +1454,8 @@ static int patch_ad1983(struct hda_codec *codec)
 
         codec->patch_ops = ad198x_patch_ops;
 
+        codec->no_trigger_sense = 1;
+
         return 0;
 }
 
@@ -1547,8 +1638,7 @@ static void ad1981_hp_automute(struct hda_codec *codec)
 {
         unsigned int present;
 
-        present = snd_hda_codec_read(codec, 0x06, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
+        present = snd_hda_jack_detect(codec, 0x06);
         snd_hda_codec_amp_stereo(codec, 0x05, HDA_OUTPUT, 0,
                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
 }
@@ -1568,8 +1658,7 @@ static void ad1981_hp_automic(struct hda_codec *codec)
         };
         unsigned int present;
 
-        present = snd_hda_codec_read(codec, 0x08, 0,
-                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
+        present = snd_hda_jack_detect(codec, 0x08);
         if (present)
                 snd_hda_sequence_write(codec, mic_jack_on);
         else
@@ -1604,6 +1693,7 @@ static struct snd_kcontrol_new ad1981_hp_mixers[] = {
         HDA_BIND_VOL("Master Playback Volume", &ad1981_hp_bind_master_vol),
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .subdevice = HDA_SUBDEV_NID_FLAG | 0x05,
                 .name = "Master Playback Switch",
                 .info = ad198x_eapd_info,
                 .get = ad198x_eapd_get,
@@ -1785,10 +1875,26 @@ static int patch_ad1981(struct hda_codec *codec)
 
                 codec->patch_ops.init = ad1981_hp_init;
                 codec->patch_ops.unsol_event = ad1981_hp_unsol_event;
+                /* set the upper-limit for mixer amp to 0dB for avoiding the
+                 * possible damage by overloading
+                 */
+                snd_hda_override_amp_caps(codec, 0x11, HDA_INPUT,
+                                          (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
+                                          (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
+                                          (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
+                                          (1 << AC_AMPCAP_MUTE_SHIFT));
                 break;
         case AD1981_THINKPAD:
                 spec->mixers[0] = ad1981_thinkpad_mixers;
                 spec->input_mux = &ad1981_thinkpad_capture_source;
+                /* set the upper-limit for mixer amp to 0dB for avoiding the
+                 * possible damage by overloading
+                 */
+                snd_hda_override_amp_caps(codec, 0x11, HDA_INPUT,
+                                          (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
+                                          (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
+                                          (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
+                                          (1 << AC_AMPCAP_MUTE_SHIFT));
                 break;
         case AD1981_TOSHIBA:
                 spec->mixers[0] = ad1981_hp_mixers;
@@ -1801,6 +1907,9 @@ static int patch_ad1981(struct hda_codec *codec)
                 codec->patch_ops.unsol_event = ad1981_hp_unsol_event;
                 break;
         }
+
+        codec->no_trigger_sense = 1;
+
         return 0;
 }
 
@@ -2117,10 +2226,11 @@ static struct snd_kcontrol_new ad1988_laptop_mixers[] = {
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
                 .name = "External Amplifier",
+                .subdevice = HDA_SUBDEV_NID_FLAG | 0x12,
                 .info = ad198x_eapd_info,
                 .get = ad198x_eapd_get,
                 .put = ad198x_eapd_put,
-                .private_value = 0x12 | (1 << 8), /* port-D, inversed */
+                .private_value = 0x12, /* port-D */
         },
 
         { } /* end */
@@ -2238,6 +2348,7 @@ static struct snd_kcontrol_new ad1988_spdif_out_mixers[] = {
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
                 .name = "IEC958 Playback Source",
+                .subdevice = HDA_SUBDEV_NID_FLAG | 0x1b,
                 .info = ad1988_spdif_playback_source_info,
                 .get = ad1988_spdif_playback_source_get,
                 .put = ad1988_spdif_playback_source_put,
@@ -2353,6 +2464,12 @@ static struct hda_verb ad1988_spdif_init_verbs[] = {
         { }
 };
 
+static struct hda_verb ad1988_spdif_in_init_verbs[] = {
+        /* unmute SPDIF input pin */
+        {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        { }
+};
+
 /* AD1989 has no ADC -> SPDIF route */
 static struct hda_verb ad1989_spdif_init_verbs[] = {
         /* SPDIF-1 out pin */
@@ -2524,7 +2641,7 @@ static void ad1988_laptop_unsol_event(struct hda_codec *codec, unsigned int res)
 {
         if ((res >> 26) != AD1988_HP_EVENT)
                 return;
-        if (snd_hda_codec_read(codec, 0x11, 0, AC_VERB_GET_PIN_SENSE, 0) & (1 << 31))
+        if (snd_hda_jack_detect(codec, 0x11))
                 snd_hda_sequence_write(codec, ad1988_laptop_hp_on);
         else
                 snd_hda_sequence_write(codec, ad1988_laptop_hp_off);
@@ -2569,6 +2686,8 @@ static int add_control(struct ad198x_spec *spec, int type, const char *name,
         knew->name = kstrdup(name, GFP_KERNEL);
         if (! knew->name)
                 return -ENOMEM;
+        if (get_amp_nid_(val))
+                knew->subdevice = HDA_SUBDEV_AMP_FLAG;
         knew->private_value = val;
         return 0;
 }
@@ -3059,6 +3178,7 @@ static int patch_ad1988(struct hda_codec *codec)
                 spec->input_mux = &ad1988_laptop_capture_source;
                 spec->num_mixers = 1;
                 spec->mixers[0] = ad1988_laptop_mixers;
+                spec->inv_eapd = 1; /* inverted EAPD */
                 spec->num_init_verbs = 1;
                 spec->init_verbs[0] = ad1988_laptop_init_verbs;
                 if (board_config == AD1988_LAPTOP_DIG)
@@ -3085,8 +3205,11 @@ static int patch_ad1988(struct hda_codec *codec)
                                 ad1988_spdif_init_verbs;
                 }
         }
-        if (spec->dig_in_nid && codec->vendor_id < 0x11d4989a)
+        if (spec->dig_in_nid && codec->vendor_id < 0x11d4989a) {
                 spec->mixers[spec->num_mixers++] = ad1988_spdif_in_mixers;
+                spec->init_verbs[spec->num_init_verbs++] =
+                        ad1988_spdif_in_init_verbs;
+        }
 
         codec->patch_ops = ad198x_patch_ops;
         switch (board_config) {
@@ -3103,6 +3226,8 @@ static int patch_ad1988(struct hda_codec *codec)
 #endif
         spec->vmaster_nid = 0x04;
 
+        codec->no_trigger_sense = 1;
+
         return 0;
 }
 
@@ -3315,6 +3440,8 @@ static int patch_ad1884(struct hda_codec *codec)
 
         codec->patch_ops = ad198x_patch_ops;
 
+        codec->no_trigger_sense = 1;
+
         return 0;
 }
 
@@ -3721,6 +3848,7 @@ static struct snd_kcontrol_new ad1884a_laptop_mixers[] = {
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
                 .name = "Master Playback Switch",
+                .subdevice = HDA_SUBDEV_AMP_FLAG,
                 .info = snd_hda_mixer_amp_switch_info,
                 .get = snd_hda_mixer_amp_switch_get,
                 .put = ad1884a_mobile_master_sw_put,
@@ -3749,6 +3877,7 @@ static struct snd_kcontrol_new ad1884a_mobile_mixers[] = {
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
                 .name = "Master Playback Switch",
+                .subdevice = HDA_SUBDEV_AMP_FLAG,
                 .info = snd_hda_mixer_amp_switch_info,
                 .get = snd_hda_mixer_amp_switch_get,
                 .put = ad1884a_mobile_master_sw_put,
@@ -3768,8 +3897,7 @@ static void ad1884a_hp_automute(struct hda_codec *codec)
 {
         unsigned int present;
 
-        present = snd_hda_codec_read(codec, 0x11, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
+        present = snd_hda_jack_detect(codec, 0x11);
         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,
@@ -3781,8 +3909,7 @@ static void ad1884a_hp_automic(struct hda_codec *codec)
 {
         unsigned int present;
 
-        present = snd_hda_codec_read(codec, 0x14, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
+        present = snd_hda_jack_detect(codec, 0x14);
         snd_hda_codec_write(codec, 0x0c, 0, AC_VERB_SET_CONNECT_SEL,
                             present ? 0 : 1);
 }
@@ -3817,13 +3944,9 @@ 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;
-        }
+        present = snd_hda_jack_detect(codec, 0x11);
+        if (!present)
+                present = snd_hda_jack_detect(codec, 0x12);
         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,
@@ -3835,11 +3958,9 @@ 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)
+        if (snd_hda_jack_detect(codec, 0x14))
                 idx = 0;
-        else if (snd_hda_codec_read(codec, 0x1c, 0, AC_VERB_GET_PIN_SENSE, 0) &
-                 AC_PINSENSE_PRESENCE)
+        else if (snd_hda_jack_detect(codec, 0x1c))
                 idx = 4;
         else
                 idx = 1;
@@ -4008,8 +4129,7 @@ static void ad1984a_thinkpad_automute(struct hda_codec *codec)
 {
         unsigned int present;
 
-        present = snd_hda_codec_read(codec, 0x11, 0, AC_VERB_GET_PIN_SENSE, 0)
-                & AC_PINSENSE_PRESENCE;
+        present = snd_hda_jack_detect(codec, 0x11);
         snd_hda_codec_amp_stereo(codec, 0x12, HDA_OUTPUT, 0,
                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
 }
@@ -4099,6 +4219,7 @@ static struct snd_kcontrol_new ad1984a_touchsmart_mixers[] = {
 /*      HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),*/
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .subdevice = HDA_SUBDEV_AMP_FLAG,
                 .name = "Master Playback Switch",
                 .info = snd_hda_mixer_amp_switch_info,
                 .get = snd_hda_mixer_amp_switch_get,
@@ -4117,14 +4238,12 @@ static struct snd_kcontrol_new ad1984a_touchsmart_mixers[] = {
 /* switch to external mic if plugged */
 static void ad1984a_touchsmart_automic(struct hda_codec *codec)
 {
-        if (snd_hda_codec_read(codec, 0x1c, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000) {
+        if (snd_hda_jack_detect(codec, 0x1c))
                 snd_hda_codec_write(codec, 0x0c, 0,
                                      AC_VERB_SET_CONNECT_SEL, 0x4);
-        } else {
+        else
                 snd_hda_codec_write(codec, 0x0c, 0,
                                      AC_VERB_SET_CONNECT_SEL, 0x5);
-        }
 }
 
 
@@ -4283,6 +4402,8 @@ static int patch_ad1884a(struct hda_codec *codec)
                 break;
         }
 
+        codec->no_trigger_sense = 1;
+
         return 0;
 }
 
@@ -4619,6 +4740,9 @@ static int patch_ad1882(struct hda_codec *codec)
                 spec->mixers[2] = ad1882_6stack_mixers;
                 break;
         }
+
+        codec->no_trigger_sense = 1;
+
         return 0;
 }
 
diff --git a/sound/pci/hda/patch_ca0110.c b/sound/pci/hda/patch_ca0110.c
index d08353d3bb7f..af478019088e 100644
--- a/sound/pci/hda/patch_ca0110.c
+++ b/sound/pci/hda/patch_ca0110.c
@@ -144,7 +144,7 @@ static int _add_switch(struct hda_codec *codec, hda_nid_t nid, const char *pfx,
         struct snd_kcontrol_new knew =
                 HDA_CODEC_MUTE_MONO(namestr, nid, chan, 0, type);
         sprintf(namestr, "%s %s Switch", pfx, dirstr[dir]);
-        return snd_hda_ctl_add(codec, snd_ctl_new1(&knew, codec));
+        return snd_hda_ctl_add(codec, nid, snd_ctl_new1(&knew, codec));
 }
 
 static int _add_volume(struct hda_codec *codec, hda_nid_t nid, const char *pfx,
@@ -155,7 +155,7 @@ static int _add_volume(struct hda_codec *codec, hda_nid_t nid, const char *pfx,
         struct snd_kcontrol_new knew =
                 HDA_CODEC_VOLUME_MONO(namestr, nid, chan, 0, type);
         sprintf(namestr, "%s %s Volume", pfx, dirstr[dir]);
-        return snd_hda_ctl_add(codec, snd_ctl_new1(&knew, codec));
+        return snd_hda_ctl_add(codec, nid, snd_ctl_new1(&knew, codec));
 }
 
 #define add_out_switch(codec, nid, pfx) _add_switch(codec, nid, pfx, 3, 0)
diff --git a/sound/pci/hda/patch_cirrus.c b/sound/pci/hda/patch_cirrus.c
index 8ba306856d38..350ee8ac4153 100644
--- a/sound/pci/hda/patch_cirrus.c
+++ b/sound/pci/hda/patch_cirrus.c
@@ -66,6 +66,7 @@ struct cs_spec {
 /* available models */
 enum {
         CS420X_MBP55,
+        CS420X_IMAC27,
         CS420X_AUTO,
         CS420X_MODELS
 };
@@ -500,7 +501,8 @@ static int add_mute(struct hda_codec *codec, const char *name, int index,
         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);
+        (*kctlp)->id.subdevice = HDA_SUBDEV_AMP_FLAG;
+        return snd_hda_ctl_add(codec, 0, *kctlp);
 }
 
 static int add_volume(struct hda_codec *codec, const char *name,
@@ -513,7 +515,8 @@ static int add_volume(struct hda_codec *codec, const char *name,
         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);
+        (*kctlp)->id.subdevice = HDA_SUBDEV_AMP_FLAG;
+        return snd_hda_ctl_add(codec, 0, *kctlp);
 }
 
 static void fix_volume_caps(struct hda_codec *codec, hda_nid_t dac)
@@ -536,14 +539,14 @@ static int add_vmaster(struct hda_codec *codec, hda_nid_t dac)
 
         spec->vmaster_sw =
                 snd_ctl_make_virtual_master("Master Playback Switch", NULL);
-        err = snd_hda_ctl_add(codec, spec->vmaster_sw);
+        err = snd_hda_ctl_add(codec, dac, 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);
+        err = snd_hda_ctl_add(codec, dac, spec->vmaster_vol);
         if (err < 0)
                 return err;
         return 0;
@@ -750,19 +753,27 @@ static int build_input(struct hda_codec *codec)
         spec->capture_bind[1] = make_bind_capture(codec, &snd_hda_bind_vol);
         for (i = 0; i < 2; i++) {
                 struct snd_kcontrol *kctl;
+                int n;
                 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);
+                err = snd_hda_ctl_add(codec, 0, kctl);
                 if (err < 0)
                         return err;
+                for (n = 0; n < AUTO_PIN_LAST; n++) {
+                        if (!spec->adc_nid[n])
+                                continue;
+                        err = snd_hda_add_nid(codec, kctl, 0, spec->adc_nid[n]);
+                        if (err < 0)
+                                return err;
+                }
         }
         
         if (spec->num_inputs > 1 && !spec->mic_detect) {
-                err = snd_hda_ctl_add(codec,
+                err = snd_hda_ctl_add(codec, 0,
                                       snd_ctl_new1(&cs_capture_source, codec));
                 if (err < 0)
                         return err;
@@ -807,7 +818,7 @@ 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;
+        unsigned int caps, hp_present;
         hda_nid_t nid;
         int i;
 
@@ -817,12 +828,7 @@ static void cs_automute(struct hda_codec *codec)
                 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;
+                hp_present = snd_hda_jack_detect(codec, nid);
                 if (hp_present)
                         break;
         }
@@ -832,7 +838,8 @@ static void cs_automute(struct hda_codec *codec)
                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
                                     hp_present ? 0 : PIN_OUT);
         }
-        if (spec->board_config == CS420X_MBP55) {
+        if (spec->board_config == CS420X_MBP55 ||
+            spec->board_config == CS420X_IMAC27) {
                 unsigned int gpio = hp_present ? 0x02 : 0x08;
                 snd_hda_codec_write(codec, 0x01, 0,
                                     AC_VERB_SET_GPIO_DATA, gpio);
@@ -844,15 +851,11 @@ 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;
+        unsigned int 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)
+        present = snd_hda_jack_detect(codec, nid);
+        if (present)
                 change_cur_input(codec, spec->automic_idx, 0);
         else {
                 unsigned int imic = (spec->automic_idx == AUTO_PIN_MIC) ?
@@ -947,7 +950,7 @@ static void init_input(struct hda_codec *codec)
                 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 
+                                 * No effect if SPDIF_OUT2 is selected in 
                                  * IDX_SPDIF_CTL.
                                   */
         cs_vendor_coef_set(codec, IDX_ADC_CFG, coef);
@@ -1078,12 +1081,14 @@ static int cs_parse_auto_config(struct hda_codec *codec)
 
 static const char *cs420x_models[CS420X_MODELS] = {
         [CS420X_MBP55] = "mbp55",
+        [CS420X_IMAC27] = "imac27",
         [CS420X_AUTO] = "auto",
 };
 
 
 static struct snd_pci_quirk cs420x_cfg_tbl[] = {
         SND_PCI_QUIRK(0x10de, 0xcb79, "MacBookPro 5,5", CS420X_MBP55),
+        SND_PCI_QUIRK(0x8086, 0x7270, "IMac 27 Inch", CS420X_IMAC27),
         {} /* terminator */
 };
 
@@ -1106,8 +1111,23 @@ static struct cs_pincfg mbp55_pincfgs[] = {
         {} /* terminator */
 };
 
+static struct cs_pincfg imac27_pincfgs[] = {
+        { 0x09, 0x012b4050 },
+        { 0x0a, 0x90100140 },
+        { 0x0b, 0x90100142 },
+        { 0x0c, 0x018b3020 },
+        { 0x0d, 0x90a00110 },
+        { 0x0e, 0x400000f0 },
+        { 0x0f, 0x01cbe030 },
+        { 0x10, 0x014be060 },
+        { 0x12, 0x01ab9070 },
+        { 0x15, 0x400000f0 },
+        {} /* terminator */
+};
+
 static struct cs_pincfg *cs_pincfgs[CS420X_MODELS] = {
         [CS420X_MBP55] = mbp55_pincfgs,
+        [CS420X_IMAC27] = imac27_pincfgs,
 };
 
 static void fix_pincfg(struct hda_codec *codec, int model)
@@ -1137,6 +1157,7 @@ static int patch_cs420x(struct hda_codec *codec)
                 fix_pincfg(codec, spec->board_config);
 
         switch (spec->board_config) {
+        case CS420X_IMAC27:
         case CS420X_MBP55:
                 /* GPIO1 = headphones */
                 /* GPIO3 = speakers */
diff --git a/sound/pci/hda/patch_cmedia.c b/sound/pci/hda/patch_cmedia.c
index 780e1a72114a..ff60908f4554 100644
--- a/sound/pci/hda/patch_cmedia.c
+++ b/sound/pci/hda/patch_cmedia.c
@@ -66,7 +66,7 @@ struct cmi_spec {
 
         struct hda_pcm pcm_rec[2];      /* PCM information */
 
-        /* pin deafault configuration */
+        /* pin default configuration */
         hda_nid_t pin_nid[NUM_PINS];
         unsigned int def_conf[NUM_PINS];
         unsigned int pin_def_confs;
@@ -197,8 +197,8 @@ static struct snd_kcontrol_new cmi9880_basic_mixer[] = {
         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0, HDA_INPUT),
         HDA_CODEC_MUTE("Capture Switch", 0x08, 0, HDA_INPUT),
         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0, HDA_INPUT),
-        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x23, 0, HDA_OUTPUT),
-        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x23, 0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Beep Playback Volume", 0x23, 0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Beep Playback Switch", 0x23, 0, HDA_OUTPUT),
         { } /* end */
 };
 
@@ -315,7 +315,8 @@ static struct hda_verb cmi9880_allout_init[] = {
 static int cmi9880_build_controls(struct hda_codec *codec)
 {
         struct cmi_spec *spec = codec->spec;
-        int err;
+        struct snd_kcontrol *kctl;
+        int i, err;
 
         err = snd_hda_add_new_ctls(codec, cmi9880_basic_mixer);
         if (err < 0)
@@ -340,6 +341,14 @@ static int cmi9880_build_controls(struct hda_codec *codec)
                 if (err < 0)
                         return err;
         }
+
+        /* assign Capture Source enums to NID */
+        kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");
+        for (i = 0; kctl && i < kctl->count; i++) {
+                err = snd_hda_add_nid(codec, kctl, i, spec->adc_nids[i]);
+                if (err < 0)
+                        return err;
+        }
         return 0;
 }
 
diff --git a/sound/pci/hda/patch_conexant.c b/sound/pci/hda/patch_conexant.c
index 905859d4f4df..feabb44c7ca4 100644
--- a/sound/pci/hda/patch_conexant.c
+++ b/sound/pci/hda/patch_conexant.c
@@ -29,6 +29,7 @@
 
 #include "hda_codec.h"
 #include "hda_local.h"
+#include "hda_beep.h"
 
 #define CXT_PIN_DIR_IN              0x00
 #define CXT_PIN_DIR_OUT             0x01
@@ -41,10 +42,12 @@
 
 /* Conexant 5051 specific */
 
-#define CXT5051_SPDIF_OUT       0x1C
+#define CXT5051_SPDIF_OUT       0x12
 #define CXT5051_PORTB_EVENT     0x38
 #define CXT5051_PORTC_EVENT     0x39
 
+#define AUTO_MIC_PORTB          (1 << 1)
+#define AUTO_MIC_PORTC          (1 << 2)
 
 struct conexant_jack {
 
@@ -73,7 +76,7 @@ struct conexant_spec {
                                          */
         unsigned int cur_eapd;
         unsigned int hp_present;
-        unsigned int no_auto_mic;
+        unsigned int auto_mic;
         unsigned int need_dac_fix;
 
         /* capture */
@@ -110,7 +113,23 @@ struct conexant_spec {
 
         unsigned int dell_automute;
         unsigned int port_d_mode;
-        unsigned char ext_mic_bias;
+        unsigned int dell_vostro:1;
+        unsigned int ideapad:1;
+
+        unsigned int ext_mic_present;
+        unsigned int recording;
+        void (*capture_prepare)(struct hda_codec *codec);
+        void (*capture_cleanup)(struct hda_codec *codec);
+
+        /* OLPC XO-1.5 supports DC input mode (e.g. for use with analog sensors)
+         * through the microphone jack.
+         * When the user enables this through a mixer switch, both internal and
+         * external microphones are disabled. Gain is fixed at 0dB. In this mode,
+         * we also allow the bias to be configured through a separate mixer
+         * control. */
+        unsigned int dc_enable;
+        unsigned int dc_input_bias; /* offset into cxt5066_olpc_dc_bias */
+        unsigned int mic_boost; /* offset into cxt5066_analog_mic_boost */
 };
 
 static int conexant_playback_pcm_open(struct hda_pcm_stream *hinfo,
@@ -183,6 +202,8 @@ static int conexant_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
                                       struct snd_pcm_substream *substream)
 {
         struct conexant_spec *spec = codec->spec;
+        if (spec->capture_prepare)
+                spec->capture_prepare(codec);
         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
                                    stream_tag, 0, format);
         return 0;
@@ -194,6 +215,8 @@ static int conexant_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
 {
         struct conexant_spec *spec = codec->spec;
         snd_hda_codec_cleanup_stream(codec, spec->adc_nids[substream->number]);
+        if (spec->capture_cleanup)
+                spec->capture_cleanup(codec);
         return 0;
 }
 
@@ -397,9 +420,7 @@ static void conexant_report_jack(struct hda_codec *codec, hda_nid_t nid)
                 for (i = 0; i < spec->jacks.used; i++) {
                         if (jacks->nid == nid) {
                                 unsigned int present;
-                                present = snd_hda_codec_read(codec, nid, 0,
-                                                AC_VERB_GET_PIN_SENSE, 0) &
-                                        AC_PINSENSE_PRESENCE;
+                                present = snd_hda_jack_detect(codec, nid);
 
                                 present = (present) ? jacks->type : 0 ;
 
@@ -478,6 +499,7 @@ static void conexant_free(struct hda_codec *codec)
                 snd_array_free(&spec->jacks);
         }
 #endif
+        snd_hda_detach_beep_device(codec);
         kfree(codec->spec);
 }
 
@@ -750,8 +772,7 @@ static void cxt5045_hp_automic(struct hda_codec *codec)
         };
         unsigned int present;
 
-        present = snd_hda_codec_read(codec, 0x12, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
+        present = snd_hda_jack_detect(codec, 0x12);
         if (present)
                 snd_hda_sequence_write(codec, mic_jack_on);
         else
@@ -765,8 +786,7 @@ static void cxt5045_hp_automute(struct hda_codec *codec)
         struct conexant_spec *spec = codec->spec;
         unsigned int bits;
 
-        spec->hp_present = snd_hda_codec_read(codec, 0x11, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
+        spec->hp_present = snd_hda_jack_detect(codec, 0x11);
 
         bits = (spec->hp_present || !spec->cur_eapd) ? HDA_AMP_MUTE : 0; 
         snd_hda_codec_amp_stereo(codec, 0x10, HDA_OUTPUT, 0,
@@ -1175,9 +1195,12 @@ static int patch_cxt5045(struct hda_codec *codec)
 
         switch (codec->subsystem_id >> 16) {
         case 0x103c:
-                /* HP laptop has a really bad sound over 0dB on NID 0x17.
-                 * Fix max PCM level to 0 dB
-                 * (originall it has 0x2b steps with 0dB offset 0x14)
+        case 0x1631:
+        case 0x1734:
+        case 0x17aa:
+                /* HP, Packard Bell, Fujitsu-Siemens & Lenovo laptops have
+                 * really bad sound over 0dB on NID 0x17. Fix max PCM level to
+                 * 0 dB (originally it has 0x2b steps with 0dB offset 0x14)
                  */
                 snd_hda_override_amp_caps(codec, 0x17, HDA_INPUT,
                                           (0x14 << AC_AMPCAP_OFFSET_SHIFT) |
@@ -1243,8 +1266,7 @@ static void cxt5047_hp_automute(struct hda_codec *codec)
         struct conexant_spec *spec = codec->spec;
         unsigned int bits;
 
-        spec->hp_present = snd_hda_codec_read(codec, 0x13, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
+        spec->hp_present = snd_hda_jack_detect(codec, 0x13);
 
         bits = (spec->hp_present || !spec->cur_eapd) ? HDA_AMP_MUTE : 0;
         /* See the note in cxt5047_hp_master_sw_put */
@@ -1267,8 +1289,7 @@ static void cxt5047_hp_automic(struct hda_codec *codec)
         };
         unsigned int present;
 
-        present = snd_hda_codec_read(codec, 0x15, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
+        present = snd_hda_jack_detect(codec, 0x15);
         if (present)
                 snd_hda_sequence_write(codec, mic_jack_on);
         else
@@ -1415,16 +1436,7 @@ static struct snd_kcontrol_new cxt5047_test_mixer[] = {
                 .get = conexant_mux_enum_get,
                 .put = conexant_mux_enum_put,
         },
-        HDA_CODEC_VOLUME("Input-1 Volume", 0x1a, 0x0, HDA_INPUT),
-        HDA_CODEC_MUTE("Input-1 Switch", 0x1a, 0x0, HDA_INPUT),
-        HDA_CODEC_VOLUME("Input-2 Volume", 0x1a, 0x1, HDA_INPUT),
-        HDA_CODEC_MUTE("Input-2 Switch", 0x1a, 0x1, HDA_INPUT),
-        HDA_CODEC_VOLUME("Input-3 Volume", 0x1a, 0x2, HDA_INPUT),
-        HDA_CODEC_MUTE("Input-3 Switch", 0x1a, 0x2, HDA_INPUT),
-        HDA_CODEC_VOLUME("Input-4 Volume", 0x1a, 0x3, HDA_INPUT),
-        HDA_CODEC_MUTE("Input-4 Switch", 0x1a, 0x3, HDA_INPUT),
-        HDA_CODEC_VOLUME("Input-5 Volume", 0x1a, 0x4, HDA_INPUT),
-        HDA_CODEC_MUTE("Input-5 Switch", 0x1a, 0x4, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Boost Volume", 0x1a, 0x0, HDA_OUTPUT),
 
         { } /* end */
 };
@@ -1581,6 +1593,21 @@ static int patch_cxt5047(struct hda_codec *codec)
 #endif  
         }
         spec->vmaster_nid = 0x13;
+
+        switch (codec->subsystem_id >> 16) {
+        case 0x103c:
+                /* HP laptops have really bad sound over 0 dB on NID 0x10.
+                 * Fix max PCM level to 0 dB (originally it has 0x1e steps
+                 * with 0 dB offset 0x17)
+                 */
+                snd_hda_override_amp_caps(codec, 0x10, HDA_INPUT,
+                                          (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
+                                          (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
+                                          (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
+                                          (1 << AC_AMPCAP_MUTE_SHIFT));
+                break;
+        }
+
         return 0;
 }
 
@@ -1596,6 +1623,11 @@ static void cxt5051_update_speaker(struct hda_codec *codec)
 {
         struct conexant_spec *spec = codec->spec;
         unsigned int pinctl;
+        /* headphone pin */
+        pinctl = (spec->hp_present && spec->cur_eapd) ? PIN_HP : 0;
+        snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
+                            pinctl);
+        /* speaker pin */
         pinctl = (!spec->hp_present && spec->cur_eapd) ? PIN_OUT : 0;
         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
                             pinctl);
@@ -1619,11 +1651,9 @@ static void cxt5051_portb_automic(struct hda_codec *codec)
         struct conexant_spec *spec = codec->spec;
         unsigned int present;
 
-        if (spec->no_auto_mic)
+        if (!(spec->auto_mic & AUTO_MIC_PORTB))
                 return;
-        present = snd_hda_codec_read(codec, 0x17, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) &
-                AC_PINSENSE_PRESENCE;
+        present = snd_hda_jack_detect(codec, 0x17);
         snd_hda_codec_write(codec, 0x14, 0,
                             AC_VERB_SET_CONNECT_SEL,
                             present ? 0x01 : 0x00);
@@ -1636,11 +1666,9 @@ static void cxt5051_portc_automic(struct hda_codec *codec)
         unsigned int present;
         hda_nid_t new_adc;
 
-        if (spec->no_auto_mic)
+        if (!(spec->auto_mic & AUTO_MIC_PORTC))
                 return;
-        present = snd_hda_codec_read(codec, 0x18, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) &
-                AC_PINSENSE_PRESENCE;
+        present = snd_hda_jack_detect(codec, 0x18);
         if (present)
                 spec->cur_adc_idx = 1;
         else
@@ -1661,9 +1689,7 @@ static void cxt5051_hp_automute(struct hda_codec *codec)
 {
         struct conexant_spec *spec = codec->spec;
 
-        spec->hp_present = snd_hda_codec_read(codec, 0x16, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) &
-                AC_PINSENSE_PRESENCE;
+        spec->hp_present = snd_hda_jack_detect(codec, 0x16);
         cxt5051_update_speaker(codec);
 }
 
@@ -1686,13 +1712,7 @@ static void cxt5051_hp_unsol_event(struct hda_codec *codec,
         conexant_report_jack(codec, nid);
 }
 
-static struct snd_kcontrol_new cxt5051_mixers[] = {
-        HDA_CODEC_VOLUME("Internal Mic Volume", 0x14, 0x00, HDA_INPUT),
-        HDA_CODEC_MUTE("Internal Mic Switch", 0x14, 0x00, HDA_INPUT),
-        HDA_CODEC_VOLUME("External Mic Volume", 0x14, 0x01, HDA_INPUT),
-        HDA_CODEC_MUTE("External Mic Switch", 0x14, 0x01, HDA_INPUT),
-        HDA_CODEC_VOLUME("Docking Mic Volume", 0x15, 0x00, HDA_INPUT),
-        HDA_CODEC_MUTE("Docking Mic Switch", 0x15, 0x00, HDA_INPUT),
+static struct snd_kcontrol_new cxt5051_playback_mixers[] = {
         HDA_CODEC_VOLUME("Master Playback Volume", 0x10, 0x00, HDA_OUTPUT),
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
@@ -1702,7 +1722,16 @@ static struct snd_kcontrol_new cxt5051_mixers[] = {
                 .put = cxt5051_hp_master_sw_put,
                 .private_value = 0x1a,
         },
+        {}
+};
 
+static struct snd_kcontrol_new cxt5051_capture_mixers[] = {
+        HDA_CODEC_VOLUME("Internal Mic Volume", 0x14, 0x00, HDA_INPUT),
+        HDA_CODEC_MUTE("Internal Mic Switch", 0x14, 0x00, HDA_INPUT),
+        HDA_CODEC_VOLUME("External Mic Volume", 0x14, 0x01, HDA_INPUT),
+        HDA_CODEC_MUTE("External Mic Switch", 0x14, 0x01, HDA_INPUT),
+        HDA_CODEC_VOLUME("Docking Mic Volume", 0x15, 0x00, HDA_INPUT),
+        HDA_CODEC_MUTE("Docking Mic Switch", 0x15, 0x00, HDA_INPUT),
         {}
 };
 
@@ -1711,32 +1740,26 @@ static struct snd_kcontrol_new cxt5051_hp_mixers[] = {
         HDA_CODEC_MUTE("Internal Mic Switch", 0x14, 0x00, HDA_INPUT),
         HDA_CODEC_VOLUME("External Mic Volume", 0x15, 0x00, HDA_INPUT),
         HDA_CODEC_MUTE("External Mic Switch", 0x15, 0x00, HDA_INPUT),
-        HDA_CODEC_VOLUME("Master Playback Volume", 0x10, 0x00, HDA_OUTPUT),
-        {
-                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-                .name = "Master Playback Switch",
-                .info = cxt_eapd_info,
-                .get = cxt_eapd_get,
-                .put = cxt5051_hp_master_sw_put,
-                .private_value = 0x1a,
-        },
-
         {}
 };
 
 static struct snd_kcontrol_new cxt5051_hp_dv6736_mixers[] = {
-        HDA_CODEC_VOLUME("Mic Volume", 0x14, 0x00, HDA_INPUT),
-        HDA_CODEC_MUTE("Mic Switch", 0x14, 0x00, HDA_INPUT),
-        HDA_CODEC_VOLUME("Master Playback Volume", 0x10, 0x00, HDA_OUTPUT),
-        {
-                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-                .name = "Master Playback Switch",
-                .info = cxt_eapd_info,
-                .get = cxt_eapd_get,
-                .put = cxt5051_hp_master_sw_put,
-                .private_value = 0x1a,
-        },
+        HDA_CODEC_VOLUME("Capture Volume", 0x14, 0x00, HDA_INPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x14, 0x00, HDA_INPUT),
+        {}
+};
 
+static struct snd_kcontrol_new cxt5051_f700_mixers[] = {
+        HDA_CODEC_VOLUME("Capture Volume", 0x14, 0x01, HDA_INPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x14, 0x01, HDA_INPUT),
+        {}
+};
+
+static struct snd_kcontrol_new cxt5051_toshiba_mixers[] = {
+        HDA_CODEC_VOLUME("Internal Mic Volume", 0x14, 0x00, HDA_INPUT),
+        HDA_CODEC_MUTE("Internal Mic Switch", 0x14, 0x00, HDA_INPUT),
+        HDA_CODEC_VOLUME("External Mic Volume", 0x14, 0x01, HDA_INPUT),
+        HDA_CODEC_MUTE("External Mic Switch", 0x14, 0x01, HDA_INPUT),
         {}
 };
 
@@ -1765,8 +1788,6 @@ static struct hda_verb cxt5051_init_verbs[] = {
         /* EAPD */
         {0x1a, AC_VERB_SET_EAPD_BTLENABLE, 0x2}, /* default on */ 
         {0x16, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|CONEXANT_HP_EVENT},
-        {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|CXT5051_PORTB_EVENT},
-        {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|CXT5051_PORTC_EVENT},
         { } /* end */
 };
 
@@ -1792,7 +1813,6 @@ static struct hda_verb cxt5051_hp_dv6736_init_verbs[] = {
         /* EAPD */
         {0x1a, AC_VERB_SET_EAPD_BTLENABLE, 0x2}, /* default on */
         {0x16, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|CONEXANT_HP_EVENT},
-        {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|CXT5051_PORTB_EVENT},
         { } /* end */
 };
 
@@ -1824,17 +1844,60 @@ static struct hda_verb cxt5051_lenovo_x200_init_verbs[] = {
         /* EAPD */
         {0x1a, AC_VERB_SET_EAPD_BTLENABLE, 0x2}, /* default on */
         {0x16, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|CONEXANT_HP_EVENT},
-        {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|CXT5051_PORTB_EVENT},
-        {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|CXT5051_PORTC_EVENT},
         {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|CONEXANT_HP_EVENT},
         { } /* end */
 };
 
+static struct hda_verb cxt5051_f700_init_verbs[] = {
+        /* Line in, Mic */
+        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x03},
+        {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0},
+        {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0},
+        /* SPK  */
+        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
+        /* HP, Amp  */
+        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
+        /* DAC1 */
+        {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        /* Record selector: Int mic */
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1) | 0x44},
+        {0x14, AC_VERB_SET_CONNECT_SEL, 0x1},
+        /* SPDIF route: PCM */
+        {0x1c, AC_VERB_SET_CONNECT_SEL, 0x0},
+        /* EAPD */
+        {0x1a, AC_VERB_SET_EAPD_BTLENABLE, 0x2}, /* default on */
+        {0x16, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|CONEXANT_HP_EVENT},
+        { } /* end */
+};
+
+static void cxt5051_init_mic_port(struct hda_codec *codec, hda_nid_t nid,
+                                 unsigned int event)
+{
+        snd_hda_codec_write(codec, nid, 0,
+                            AC_VERB_SET_UNSOLICITED_ENABLE,
+                            AC_USRSP_EN | event);
+#ifdef CONFIG_SND_HDA_INPUT_JACK
+        conexant_add_jack(codec, nid, SND_JACK_MICROPHONE);
+        conexant_report_jack(codec, nid);
+#endif
+}
+
 /* initialize jack-sensing, too */
 static int cxt5051_init(struct hda_codec *codec)
 {
+        struct conexant_spec *spec = codec->spec;
+
         conexant_init(codec);
         conexant_init_jacks(codec);
+
+        if (spec->auto_mic & AUTO_MIC_PORTB)
+                cxt5051_init_mic_port(codec, 0x17, CXT5051_PORTB_EVENT);
+        if (spec->auto_mic & AUTO_MIC_PORTC)
+                cxt5051_init_mic_port(codec, 0x18, CXT5051_PORTC_EVENT);
+
         if (codec->patch_ops.unsol_event) {
                 cxt5051_hp_automute(codec);
                 cxt5051_portb_automic(codec);
@@ -1849,6 +1912,8 @@ enum {
         CXT5051_HP,     /* no docking */
         CXT5051_HP_DV6736,      /* HP without mic switch */
         CXT5051_LENOVO_X200,    /* Lenovo X200 laptop */
+        CXT5051_F700,       /* HP Compaq Presario F700 */
+        CXT5051_TOSHIBA,        /* Toshiba M300 & co */
         CXT5051_MODELS
 };
 
@@ -1857,11 +1922,15 @@ static const char *cxt5051_models[CXT5051_MODELS] = {
         [CXT5051_HP]            = "hp",
         [CXT5051_HP_DV6736]     = "hp-dv6736",
         [CXT5051_LENOVO_X200]   = "lenovo-x200",
+        [CXT5051_F700]          = "hp-700",
+        [CXT5051_TOSHIBA]       = "toshiba",
 };
 
 static struct snd_pci_quirk cxt5051_cfg_tbl[] = {
         SND_PCI_QUIRK(0x103c, 0x30cf, "HP DV6736", CXT5051_HP_DV6736),
         SND_PCI_QUIRK(0x103c, 0x360b, "Compaq Presario CQ60", CXT5051_HP),
+        SND_PCI_QUIRK(0x103c, 0x30ea, "Compaq Presario F700", CXT5051_F700),
+        SND_PCI_QUIRK(0x1179, 0xff50, "Toshiba M30x", CXT5051_TOSHIBA),
         SND_PCI_QUIRK(0x14f1, 0x0101, "Conexant Reference board",
                       CXT5051_LAPTOP),
         SND_PCI_QUIRK(0x14f1, 0x5051, "HP Spartan 1.1", CXT5051_HP),
@@ -1889,8 +1958,9 @@ static int patch_cxt5051(struct hda_codec *codec)
         spec->multiout.dig_out_nid = CXT5051_SPDIF_OUT;
         spec->num_adc_nids = 1; /* not 2; via auto-mic switch */
         spec->adc_nids = cxt5051_adc_nids;
-        spec->num_mixers = 1;
-        spec->mixers[0] = cxt5051_mixers;
+        spec->num_mixers = 2;
+        spec->mixers[0] = cxt5051_capture_mixers;
+        spec->mixers[1] = cxt5051_playback_mixers;
         spec->num_init_verbs = 1;
         spec->init_verbs[0] = cxt5051_init_verbs;
         spec->spdif_route = 0;
@@ -1904,6 +1974,7 @@ static int patch_cxt5051(struct hda_codec *codec)
         board_config = snd_hda_check_board_config(codec, CXT5051_MODELS,
                                                   cxt5051_models,
                                                   cxt5051_cfg_tbl);
+        spec->auto_mic = AUTO_MIC_PORTB | AUTO_MIC_PORTC;
         switch (board_config) {
         case CXT5051_HP:
                 spec->mixers[0] = cxt5051_hp_mixers;
@@ -1911,11 +1982,20 @@ static int patch_cxt5051(struct hda_codec *codec)
         case CXT5051_HP_DV6736:
                 spec->init_verbs[0] = cxt5051_hp_dv6736_init_verbs;
                 spec->mixers[0] = cxt5051_hp_dv6736_mixers;
-                spec->no_auto_mic = 1;
+                spec->auto_mic = 0;
                 break;
         case CXT5051_LENOVO_X200:
                 spec->init_verbs[0] = cxt5051_lenovo_x200_init_verbs;
                 break;
+        case CXT5051_F700:
+                spec->init_verbs[0] = cxt5051_f700_init_verbs;
+                spec->mixers[0] = cxt5051_f700_mixers;
+                spec->auto_mic = 0;
+                break;
+        case CXT5051_TOSHIBA:
+                spec->mixers[0] = cxt5051_toshiba_mixers;
+                spec->auto_mic = AUTO_MIC_PORTB;
+                break;
         }
 
         return 0;
@@ -1983,36 +2063,147 @@ static int cxt5066_hp_master_sw_put(struct snd_kcontrol *kcontrol,
         return 1;
 }
 
+static const struct hda_input_mux cxt5066_olpc_dc_bias = {
+        .num_items = 3,
+        .items = {
+                { "Off", PIN_IN },
+                { "50%", PIN_VREF50 },
+                { "80%", PIN_VREF80 },
+        },
+};
+
+static int cxt5066_set_olpc_dc_bias(struct hda_codec *codec)
+{
+        struct conexant_spec *spec = codec->spec;
+        /* Even though port F is the DC input, the bias is controlled on port B.
+         * we also leave that port as an active input (but unselected) in DC mode
+         * just in case that is necessary to make the bias setting take effect. */
+        return snd_hda_codec_write_cache(codec, 0x1a, 0,
+                AC_VERB_SET_PIN_WIDGET_CONTROL,
+                cxt5066_olpc_dc_bias.items[spec->dc_input_bias].index);
+}
+
+/* OLPC defers mic widget control until when capture is started because the
+ * microphone LED comes on as soon as these settings are put in place. if we
+ * did this before recording, it would give the false indication that recording
+ * is happening when it is not. */
+static void cxt5066_olpc_select_mic(struct hda_codec *codec)
+{
+        struct conexant_spec *spec = codec->spec;
+        if (!spec->recording)
+                return;
+
+        if (spec->dc_enable) {
+                /* in DC mode we ignore presence detection and just use the jack
+                 * through our special DC port */
+                const struct hda_verb enable_dc_mode[] = {
+                        /* disble internal mic, port C */
+                        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
+
+                        /* enable DC capture, port F */
+                        {0x1e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+                        {},
+                };
+
+                snd_hda_sequence_write(codec, enable_dc_mode);
+                /* port B input disabled (and bias set) through the following call */
+                cxt5066_set_olpc_dc_bias(codec);
+                return;
+        }
+
+        /* disable DC (port F) */
+        snd_hda_codec_write(codec, 0x1e, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
+
+        /* external mic, port B */
+        snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
+                spec->ext_mic_present ? CXT5066_OLPC_EXT_MIC_BIAS : 0);
+
+        /* internal mic, port C */
+        snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
+                spec->ext_mic_present ? 0 : PIN_VREF80);
+}
+
 /* toggle input of built-in and mic jack appropriately */
-static void cxt5066_automic(struct hda_codec *codec)
+static void cxt5066_olpc_automic(struct hda_codec *codec)
 {
         struct conexant_spec *spec = codec->spec;
+        unsigned int present;
+
+        if (spec->dc_enable) /* don't do presence detection in DC mode */
+                return;
+
+        present = snd_hda_codec_read(codec, 0x1a, 0,
+                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
+        if (present)
+                snd_printdd("CXT5066: external microphone detected\n");
+        else
+                snd_printdd("CXT5066: external microphone absent\n");
+
+        snd_hda_codec_write(codec, 0x17, 0, AC_VERB_SET_CONNECT_SEL,
+                present ? 0 : 1);
+        spec->ext_mic_present = !!present;
+
+        cxt5066_olpc_select_mic(codec);
+}
+
+/* toggle input of built-in digital mic and mic jack appropriately */
+static void cxt5066_vostro_automic(struct hda_codec *codec)
+{
+        unsigned int present;
+
         struct hda_verb ext_mic_present[] = {
                 /* enable external mic, port B */
-                {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, spec->ext_mic_bias},
+                {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 
                 /* switch to external mic input */
                 {0x17, AC_VERB_SET_CONNECT_SEL, 0},
+                {0x14, AC_VERB_SET_CONNECT_SEL, 0},
 
-                /* disable internal mic, port C */
-                {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
+                /* disable internal digital mic */
+                {0x23, 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},
+                {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 
                 /* switch to internal mic input */
-                {0x17, AC_VERB_SET_CONNECT_SEL, 1},
+                {0x14, AC_VERB_SET_CONNECT_SEL, 2},
 
                 /* disable external mic, port B */
                 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
                 {}
         };
+
+        present = snd_hda_jack_detect(codec, 0x1a);
+        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);
+        }
+}
+
+/* toggle input of built-in digital mic and mic jack appropriately */
+static void cxt5066_ideapad_automic(struct hda_codec *codec)
+{
         unsigned int present;
 
-        present = snd_hda_codec_read(codec, 0x1a, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
+        struct hda_verb ext_mic_present[] = {
+                {0x14, AC_VERB_SET_CONNECT_SEL, 0},
+                {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+                {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
+                {}
+        };
+        static struct hda_verb ext_mic_absent[] = {
+                {0x14, AC_VERB_SET_CONNECT_SEL, 2},
+                {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+                {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
+                {}
+        };
+
+        present = snd_hda_jack_detect(codec, 0x1b);
         if (present) {
                 snd_printdd("CXT5066: external microphone detected\n");
                 snd_hda_sequence_write(codec, ext_mic_present);
@@ -2029,12 +2220,10 @@ static void cxt5066_hp_automute(struct hda_codec *codec)
         unsigned int portA, portD;
 
         /* Port A */
-        portA = snd_hda_codec_read(codec, 0x19, 0, AC_VERB_GET_PIN_SENSE, 0)
-                & AC_PINSENSE_PRESENCE;
+        portA = snd_hda_jack_detect(codec, 0x19);
 
         /* Port D */
-        portD = (snd_hda_codec_read(codec, 0x1c, 0, AC_VERB_GET_PIN_SENSE, 0)
-                & AC_PINSENSE_PRESENCE) << 1;
+        portD = snd_hda_jack_detect(codec, 0x1c);
 
         spec->hp_present = !!(portA | portD);
         snd_printdd("CXT5066: hp automute portA=%x portD=%x present=%d\n",
@@ -2043,15 +2232,46 @@ static void cxt5066_hp_automute(struct hda_codec *codec)
 }
 
 /* unsolicited event for jack sensing */
-static void cxt5066_unsol_event(struct hda_codec *codec, unsigned int res)
+static void cxt5066_olpc_unsol_event(struct hda_codec *codec, unsigned int res)
 {
+        struct conexant_spec *spec = codec->spec;
         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);
+                /* ignore mic events in DC mode; we're always using the jack */
+                if (!spec->dc_enable)
+                        cxt5066_olpc_automic(codec);
+                break;
+        }
+}
+
+/* unsolicited event for jack sensing */
+static void cxt5066_vostro_event(struct hda_codec *codec, unsigned int res)
+{
+        snd_printdd("CXT5066_vostro: 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_vostro_automic(codec);
+                break;
+        }
+}
+
+/* unsolicited event for jack sensing */
+static void cxt5066_ideapad_event(struct hda_codec *codec, unsigned int res)
+{
+        snd_printdd("CXT5066_ideapad: 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_ideapad_automic(codec);
                 break;
         }
 }
@@ -2067,6 +2287,23 @@ static const struct hda_input_mux cxt5066_analog_mic_boost = {
         },
 };
 
+static void cxt5066_set_mic_boost(struct hda_codec *codec)
+{
+        struct conexant_spec *spec = codec->spec;
+        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 |
+                        cxt5066_analog_mic_boost.items[spec->mic_boost].index);
+        if (spec->ideapad) {
+                /* adjust the internal mic as well...it is not through 0x17 */
+                snd_hda_codec_write_cache(codec, 0x23, 0,
+                        AC_VERB_SET_AMP_GAIN_MUTE,
+                        AC_AMP_SET_RIGHT | AC_AMP_SET_LEFT | AC_AMP_SET_INPUT |
+                                cxt5066_analog_mic_boost.
+                                        items[spec->mic_boost].index);
+        }
+}
+
 static int cxt5066_mic_boost_mux_enum_info(struct snd_kcontrol *kcontrol,
                                            struct snd_ctl_elem_info *uinfo)
 {
@@ -2077,12 +2314,8 @@ 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;
+        struct conexant_spec *spec = codec->spec;
+        ucontrol->value.enumerated.item[0] = spec->mic_boost;
         return 0;
 }
 
@@ -2090,23 +2323,132 @@ 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);
+        struct conexant_spec *spec = codec->spec;
         const struct hda_input_mux *imux = &cxt5066_analog_mic_boost;
         unsigned int idx;
+        idx = ucontrol->value.enumerated.item[0];
+        if (idx >= imux->num_items)
+                idx = imux->num_items - 1;
 
-        if (!imux->num_items)
+        spec->mic_boost = idx;
+        if (!spec->dc_enable)
+                cxt5066_set_mic_boost(codec);
+        return 1;
+}
+
+static void cxt5066_enable_dc(struct hda_codec *codec)
+{
+        const struct hda_verb enable_dc_mode[] = {
+                /* disable gain */
+                {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+
+                /* switch to DC input */
+                {0x17, AC_VERB_SET_CONNECT_SEL, 3},
+                {}
+        };
+
+        /* configure as input source */
+        snd_hda_sequence_write(codec, enable_dc_mode);
+        cxt5066_olpc_select_mic(codec); /* also sets configured bias */
+}
+
+static void cxt5066_disable_dc(struct hda_codec *codec)
+{
+        /* reconfigure input source */
+        cxt5066_set_mic_boost(codec);
+        /* automic also selects the right mic if we're recording */
+        cxt5066_olpc_automic(codec);
+}
+
+static int cxt5066_olpc_dc_get(struct snd_kcontrol *kcontrol,
+                             struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct conexant_spec *spec = codec->spec;
+        ucontrol->value.integer.value[0] = spec->dc_enable;
+        return 0;
+}
+
+static int cxt5066_olpc_dc_put(struct snd_kcontrol *kcontrol,
+                             struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct conexant_spec *spec = codec->spec;
+        int dc_enable = !!ucontrol->value.integer.value[0];
+
+        if (dc_enable == spec->dc_enable)
                 return 0;
+
+        spec->dc_enable = dc_enable;
+        if (dc_enable)
+                cxt5066_enable_dc(codec);
+        else
+                cxt5066_disable_dc(codec);
+
+        return 1;
+}
+
+static int cxt5066_olpc_dc_bias_enum_info(struct snd_kcontrol *kcontrol,
+                                           struct snd_ctl_elem_info *uinfo)
+{
+        return snd_hda_input_mux_info(&cxt5066_olpc_dc_bias, uinfo);
+}
+
+static int cxt5066_olpc_dc_bias_enum_get(struct snd_kcontrol *kcontrol,
+                                          struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct conexant_spec *spec = codec->spec;
+        ucontrol->value.enumerated.item[0] = spec->dc_input_bias;
+        return 0;
+}
+
+static int cxt5066_olpc_dc_bias_enum_put(struct snd_kcontrol *kcontrol,
+                                          struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct conexant_spec *spec = codec->spec;
+        const struct hda_input_mux *imux = &cxt5066_analog_mic_boost;
+        unsigned int idx;
+
         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);
-
+        spec->dc_input_bias = idx;
+        if (spec->dc_enable)
+                cxt5066_set_olpc_dc_bias(codec);
         return 1;
 }
 
+static void cxt5066_olpc_capture_prepare(struct hda_codec *codec)
+{
+        struct conexant_spec *spec = codec->spec;
+        /* mark as recording and configure the microphone widget so that the
+         * recording LED comes on. */
+        spec->recording = 1;
+        cxt5066_olpc_select_mic(codec);
+}
+
+static void cxt5066_olpc_capture_cleanup(struct hda_codec *codec)
+{
+        struct conexant_spec *spec = codec->spec;
+        const struct hda_verb disable_mics[] = {
+                /* disable external mic, port B */
+                {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
+
+                /* disble internal mic, port C */
+                {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
+
+                /* disable DC capture, port F */
+                {0x1e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
+                {},
+        };
+
+        snd_hda_sequence_write(codec, disable_mics);
+        spec->recording = 0;
+}
+
 static struct hda_input_mux cxt5066_capture_source = {
         .num_items = 4,
         .items = {
@@ -2147,6 +2489,7 @@ static struct snd_kcontrol_new cxt5066_mixer_master_olpc[] = {
                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
                                   SNDRV_CTL_ELEM_ACCESS_TLV_READ |
                                   SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK,
+                .subdevice = HDA_SUBDEV_AMP_FLAG,
                 .info = snd_hda_mixer_amp_volume_info,
                 .get = snd_hda_mixer_amp_volume_get,
                 .put = snd_hda_mixer_amp_volume_put,
@@ -2158,6 +2501,24 @@ static struct snd_kcontrol_new cxt5066_mixer_master_olpc[] = {
         {}
 };
 
+static struct snd_kcontrol_new cxt5066_mixer_olpc_dc[] = {
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "DC Mode Enable Switch",
+                .info = snd_ctl_boolean_mono_info,
+                .get = cxt5066_olpc_dc_get,
+                .put = cxt5066_olpc_dc_put,
+        },
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "DC Input Bias Enum",
+                .info = cxt5066_olpc_dc_bias_enum_info,
+                .get = cxt5066_olpc_dc_bias_enum_get,
+                .put = cxt5066_olpc_dc_bias_enum_put,
+        },
+        {}
+};
+
 static struct snd_kcontrol_new cxt5066_mixers[] = {
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
@@ -2181,6 +2542,19 @@ static struct snd_kcontrol_new cxt5066_mixers[] = {
         {}
 };
 
+static struct snd_kcontrol_new cxt5066_vostro_mixers[] = {
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Int 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,
+                .private_value = 0x23 | 0x100,
+        },
+        HDA_CODEC_VOLUME_MONO("Beep Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
+        {}
+};
+
 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 */
@@ -2242,10 +2616,10 @@ static struct hda_verb cxt5066_init_verbs_olpc[] = {
         {0x19, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC1 */
 
         /* Port B: external microphone */
-        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, CXT5066_OLPC_EXT_MIC_BIAS},
+        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
 
         /* Port C: internal microphone */
-        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
 
         /* Port D: unused */
         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
@@ -2254,7 +2628,7 @@ static struct hda_verb cxt5066_init_verbs_olpc[] = {
         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
         {0x1d, AC_VERB_SET_EAPD_BTLENABLE, 0x2}, /* default on */
 
-        /* Port F: unused */
+        /* Port F: external DC input through microphone port */
         {0x1e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
 
         /* Port G: internal speakers */
@@ -2297,6 +2671,117 @@ static struct hda_verb cxt5066_init_verbs_olpc[] = {
         { } /* end */
 };
 
+static struct hda_verb cxt5066_init_verbs_vostro[] = {
+        /* Port A: headphones */
+        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
+        {0x19, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC1 */
+
+        /* Port B: external microphone */
+        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
+
+        /* Port C: unused */
+        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
+
+        /* 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_MUTE(0)},
+        {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)},
+
+        /* Digital microphone port */
+        {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+
+        /* 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_ideapad[] = {
+        {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)},
+        {0x14, AC_VERB_SET_CONNECT_SEL, 2},     /* default to internal mic */
+
+        /* Audio input selector */
+        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x2},
+        {0x17, AC_VERB_SET_CONNECT_SEL, 1},     /* route ext mic */
+
+        /* 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},
+
+        /* internal microphone */
+        {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* enable int mic */
+
+        /* EAPD */
+        {0x1d, AC_VERB_SET_EAPD_BTLENABLE, 0x2}, /* default on */
+
+        {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_HP_EVENT},
+        {0x1b, 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 */
@@ -2305,11 +2790,32 @@ static struct hda_verb cxt5066_init_verbs_portd_lo[] = {
 /* initialize jack-sensing, too */
 static int cxt5066_init(struct hda_codec *codec)
 {
+        struct conexant_spec *spec = codec->spec;
+
         snd_printdd("CXT5066: init\n");
         conexant_init(codec);
         if (codec->patch_ops.unsol_event) {
                 cxt5066_hp_automute(codec);
-                cxt5066_automic(codec);
+                if (spec->dell_vostro)
+                        cxt5066_vostro_automic(codec);
+                else if (spec->ideapad)
+                        cxt5066_ideapad_automic(codec);
+        }
+        cxt5066_set_mic_boost(codec);
+        return 0;
+}
+
+static int cxt5066_olpc_init(struct hda_codec *codec)
+{
+        struct conexant_spec *spec = codec->spec;
+        snd_printdd("CXT5066: init\n");
+        conexant_init(codec);
+        cxt5066_hp_automute(codec);
+        if (!spec->dc_enable) {
+                cxt5066_set_mic_boost(codec);
+                cxt5066_olpc_automic(codec);
+        } else {
+                cxt5066_enable_dc(codec);
         }
         return 0;
 }
@@ -2318,6 +2824,8 @@ enum {
         CXT5066_LAPTOP,                 /* Laptops w/ EAPD support */
         CXT5066_DELL_LAPTOP,    /* Dell Laptop */
         CXT5066_OLPC_XO_1_5,    /* OLPC XO 1.5 */
+        CXT5066_DELL_VOSTO,     /* Dell Vostro 1015i */
+        CXT5066_IDEAPAD,        /* Lenovo IdeaPad U150 */
         CXT5066_MODELS
 };
 
@@ -2325,6 +2833,8 @@ static const char *cxt5066_models[CXT5066_MODELS] = {
         [CXT5066_LAPTOP]                = "laptop",
         [CXT5066_DELL_LAPTOP]   = "dell-laptop",
         [CXT5066_OLPC_XO_1_5]   = "olpc-xo-1_5",
+        [CXT5066_DELL_VOSTO]    = "dell-vostro",
+        [CXT5066_IDEAPAD]       = "ideapad",
 };
 
 static struct snd_pci_quirk cxt5066_cfg_tbl[] = {
@@ -2333,6 +2843,12 @@ static struct snd_pci_quirk cxt5066_cfg_tbl[] = {
         SND_PCI_QUIRK(0x1028, 0x02f5, "Dell",
                       CXT5066_DELL_LAPTOP),
         SND_PCI_QUIRK(0x152d, 0x0833, "OLPC XO-1.5", CXT5066_OLPC_XO_1_5),
+        SND_PCI_QUIRK(0x1028, 0x0402, "Dell Vostro", CXT5066_DELL_VOSTO),
+        SND_PCI_QUIRK(0x1028, 0x0408, "Dell Inspiron One 19T", CXT5066_IDEAPAD),
+        SND_PCI_QUIRK(0x1179, 0xff50, "Toshiba Satellite P500-PSPGSC-01800T", CXT5066_OLPC_XO_1_5),
+        SND_PCI_QUIRK(0x1179, 0xffe0, "Toshiba Satellite Pro T130-15F", CXT5066_OLPC_XO_1_5),
+        SND_PCI_QUIRK(0x17aa, 0x21b2, "Thinkpad X100e", CXT5066_IDEAPAD),
+        SND_PCI_QUIRK(0x17aa, 0x3a0d, "ideapad", CXT5066_IDEAPAD),
         {}
 };
 
@@ -2347,7 +2863,7 @@ static int patch_cxt5066(struct hda_codec *codec)
         codec->spec = spec;
 
         codec->patch_ops = conexant_patch_ops;
-        codec->patch_ops.init = cxt5066_init;
+        codec->patch_ops.init = conexant_init;
 
         spec->dell_automute = 0;
         spec->multiout.max_channels = 2;
@@ -2360,7 +2876,6 @@ static int patch_cxt5066(struct hda_codec *codec)
         spec->input_mux = &cxt5066_capture_source;
 
         spec->port_d_mode = PIN_HP;
-        spec->ext_mic_bias = PIN_VREF80;
 
         spec->num_init_verbs = 1;
         spec->init_verbs[0] = cxt5066_init_verbs;
@@ -2387,12 +2902,53 @@ static int patch_cxt5066(struct hda_codec *codec)
                 spec->dell_automute = 1;
                 break;
         case CXT5066_OLPC_XO_1_5:
-                codec->patch_ops.unsol_event = cxt5066_unsol_event;
+                codec->patch_ops.init = cxt5066_olpc_init;
+                codec->patch_ops.unsol_event = cxt5066_olpc_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_mixer_olpc_dc;
+                spec->mixers[spec->num_mixers++] = cxt5066_mixers;
+                spec->port_d_mode = 0;
+                spec->mic_boost = 3; /* default 30dB gain */
+
+                /* no S/PDIF out */
+                spec->multiout.dig_out_nid = 0;
+
+                /* input source automatically selected */
+                spec->input_mux = NULL;
+
+                /* our capture hooks which allow us to turn on the microphone LED
+                 * at the right time */
+                spec->capture_prepare = cxt5066_olpc_capture_prepare;
+                spec->capture_cleanup = cxt5066_olpc_capture_cleanup;
+                break;
+        case CXT5066_DELL_VOSTO:
+                codec->patch_ops.init = cxt5066_init;
+                codec->patch_ops.unsol_event = cxt5066_vostro_event;
+                spec->init_verbs[0] = cxt5066_init_verbs_vostro;
+                spec->mixers[spec->num_mixers++] = cxt5066_mixer_master_olpc;
                 spec->mixers[spec->num_mixers++] = cxt5066_mixers;
+                spec->mixers[spec->num_mixers++] = cxt5066_vostro_mixers;
                 spec->port_d_mode = 0;
-                spec->ext_mic_bias = CXT5066_OLPC_EXT_MIC_BIAS;
+                spec->dell_vostro = 1;
+                spec->mic_boost = 3; /* default 30dB gain */
+                snd_hda_attach_beep_device(codec, 0x13);
+
+                /* no S/PDIF out */
+                spec->multiout.dig_out_nid = 0;
+
+                /* input source automatically selected */
+                spec->input_mux = NULL;
+                break;
+        case CXT5066_IDEAPAD:
+                codec->patch_ops.init = cxt5066_init;
+                codec->patch_ops.unsol_event = cxt5066_ideapad_event;
+                spec->mixers[spec->num_mixers++] = cxt5066_mixer_master;
+                spec->mixers[spec->num_mixers++] = cxt5066_mixers;
+                spec->init_verbs[0] = cxt5066_init_verbs_ideapad;
+                spec->port_d_mode = 0;
+                spec->ideapad = 1;
+                spec->mic_boost = 2;    /* default 20dB gain */
 
                 /* no S/PDIF out */
                 spec->multiout.dig_out_nid = 0;
@@ -2417,6 +2973,8 @@ static struct hda_codec_preset snd_hda_preset_conexant[] = {
           .patch = patch_cxt5051 },
         { .id = 0x14f15066, .name = "CX20582 (Pebble)",
           .patch = patch_cxt5066 },
+        { .id = 0x14f15067, .name = "CX20583 (Pebble HSF)",
+          .patch = patch_cxt5066 },
         {} /* terminator */
 };
 
@@ -2424,6 +2982,7 @@ 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_ALIAS("snd-hda-codec-id:14f15067");
 
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("Conexant HD-audio codec");
diff --git a/sound/pci/hda/patch_hdmi.c b/sound/pci/hda/patch_hdmi.c
new file mode 100644
index 000000000000..2c2bafbf0258
--- /dev/null
+++ b/sound/pci/hda/patch_hdmi.c
@@ -0,0 +1,849 @@
+/*
+ *
+ *  patch_hdmi.c - routines for HDMI/DisplayPort codecs
+ *
+ *  Copyright(c) 2008-2010 Intel Corporation. All rights reserved.
+ *
+ *  Authors:
+ *                      Wu Fengguang <wfg@linux.intel.com>
+ *
+ *  Maintained by:
+ *                      Wu Fengguang <wfg@linux.intel.com>
+ *
+ *  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 the Free
+ *  Software Foundation; either version 2 of the License, or (at your option)
+ *  any later version.
+ *
+ *  This program 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.
+ */
+
+
+struct hdmi_spec {
+        int num_cvts;
+        int num_pins;
+        hda_nid_t cvt[MAX_HDMI_CVTS+1];  /* audio sources */
+        hda_nid_t pin[MAX_HDMI_PINS+1];  /* audio sinks */
+
+        /*
+         * source connection for each pin
+         */
+        hda_nid_t pin_cvt[MAX_HDMI_PINS+1];
+
+        /*
+         * HDMI sink attached to each pin
+         */
+        struct hdmi_eld sink_eld[MAX_HDMI_PINS];
+
+        /*
+         * export one pcm per pipe
+         */
+        struct hda_pcm  pcm_rec[MAX_HDMI_CVTS];
+
+        /*
+         * nvhdmi specific
+         */
+        struct hda_multi_out multiout;
+        unsigned int codec_type;
+};
+
+
+struct hdmi_audio_infoframe {
+        u8 type; /* 0x84 */
+        u8 ver;  /* 0x01 */
+        u8 len;  /* 0x0a */
+
+        u8 checksum;    /* PB0 */
+        u8 CC02_CT47;   /* CC in bits 0:2, CT in 4:7 */
+        u8 SS01_SF24;
+        u8 CXT04;
+        u8 CA;
+        u8 LFEPBL01_LSV36_DM_INH7;
+        u8 reserved[5]; /* PB6 - PB10 */
+};
+
+/*
+ * CEA speaker placement:
+ *
+ *        FLH       FCH        FRH
+ *  FLW    FL  FLC   FC   FRC   FR   FRW
+ *
+ *                                  LFE
+ *                     TC
+ *
+ *          RL  RLC   RC   RRC   RR
+ *
+ * The Left/Right Surround channel _notions_ LS/RS in SMPTE 320M corresponds to
+ * CEA RL/RR; The SMPTE channel _assignment_ C/LFE is swapped to CEA LFE/FC.
+ */
+enum cea_speaker_placement {
+        FL  = (1 <<  0),        /* Front Left           */
+        FC  = (1 <<  1),        /* Front Center         */
+        FR  = (1 <<  2),        /* Front Right          */
+        FLC = (1 <<  3),        /* Front Left Center    */
+        FRC = (1 <<  4),        /* Front Right Center   */
+        RL  = (1 <<  5),        /* Rear Left            */
+        RC  = (1 <<  6),        /* Rear Center          */
+        RR  = (1 <<  7),        /* Rear Right           */
+        RLC = (1 <<  8),        /* Rear Left Center     */
+        RRC = (1 <<  9),        /* Rear Right Center    */
+        LFE = (1 << 10),        /* Low Frequency Effect */
+        FLW = (1 << 11),        /* Front Left Wide      */
+        FRW = (1 << 12),        /* Front Right Wide     */
+        FLH = (1 << 13),        /* Front Left High      */
+        FCH = (1 << 14),        /* Front Center High    */
+        FRH = (1 << 15),        /* Front Right High     */
+        TC  = (1 << 16),        /* Top Center           */
+};
+
+/*
+ * ELD SA bits in the CEA Speaker Allocation data block
+ */
+static int eld_speaker_allocation_bits[] = {
+        [0] = FL | FR,
+        [1] = LFE,
+        [2] = FC,
+        [3] = RL | RR,
+        [4] = RC,
+        [5] = FLC | FRC,
+        [6] = RLC | RRC,
+        /* the following are not defined in ELD yet */
+        [7] = FLW | FRW,
+        [8] = FLH | FRH,
+        [9] = TC,
+        [10] = FCH,
+};
+
+struct cea_channel_speaker_allocation {
+        int ca_index;
+        int speakers[8];
+
+        /* derived values, just for convenience */
+        int channels;
+        int spk_mask;
+};
+
+/*
+ * ALSA sequence is:
+ *
+ *       surround40   surround41   surround50   surround51   surround71
+ * ch0   front left   =            =            =            =
+ * ch1   front right  =            =            =            =
+ * ch2   rear left    =            =            =            =
+ * ch3   rear right   =            =            =            =
+ * ch4                LFE          center       center       center
+ * ch5                                          LFE          LFE
+ * ch6                                                       side left
+ * ch7                                                       side right
+ *
+ * surround71 = {FL, FR, RLC, RRC, FC, LFE, RL, RR}
+ */
+static int hdmi_channel_mapping[0x32][8] = {
+        /* stereo */
+        [0x00] = { 0x00, 0x11, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7 },
+        /* 2.1 */
+        [0x01] = { 0x00, 0x11, 0x22, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7 },
+        /* Dolby Surround */
+        [0x02] = { 0x00, 0x11, 0x23, 0xf2, 0xf4, 0xf5, 0xf6, 0xf7 },
+        /* surround40 */
+        [0x08] = { 0x00, 0x11, 0x24, 0x35, 0xf3, 0xf2, 0xf6, 0xf7 },
+        /* 4ch */
+        [0x03] = { 0x00, 0x11, 0x23, 0x32, 0x44, 0xf5, 0xf6, 0xf7 },
+        /* surround41 */
+        [0x09] = { 0x00, 0x11, 0x24, 0x34, 0x43, 0xf2, 0xf6, 0xf7 },
+        /* surround50 */
+        [0x0a] = { 0x00, 0x11, 0x24, 0x35, 0x43, 0xf2, 0xf6, 0xf7 },
+        /* surround51 */
+        [0x0b] = { 0x00, 0x11, 0x24, 0x35, 0x43, 0x52, 0xf6, 0xf7 },
+        /* 7.1 */
+        [0x13] = { 0x00, 0x11, 0x26, 0x37, 0x43, 0x52, 0x64, 0x75 },
+};
+
+/*
+ * This is an ordered list!
+ *
+ * The preceding ones have better chances to be selected by
+ * hdmi_setup_channel_allocation().
+ */
+static struct cea_channel_speaker_allocation channel_allocations[] = {
+/*                        channel:   7     6    5    4    3     2    1    0  */
+{ .ca_index = 0x00,  .speakers = {   0,    0,   0,   0,   0,    0,  FR,  FL } },
+                                 /* 2.1 */
+{ .ca_index = 0x01,  .speakers = {   0,    0,   0,   0,   0,  LFE,  FR,  FL } },
+                                 /* Dolby Surround */
+{ .ca_index = 0x02,  .speakers = {   0,    0,   0,   0,  FC,    0,  FR,  FL } },
+                                 /* surround40 */
+{ .ca_index = 0x08,  .speakers = {   0,    0,  RR,  RL,   0,    0,  FR,  FL } },
+                                 /* surround41 */
+{ .ca_index = 0x09,  .speakers = {   0,    0,  RR,  RL,   0,  LFE,  FR,  FL } },
+                                 /* surround50 */
+{ .ca_index = 0x0a,  .speakers = {   0,    0,  RR,  RL,  FC,    0,  FR,  FL } },
+                                 /* surround51 */
+{ .ca_index = 0x0b,  .speakers = {   0,    0,  RR,  RL,  FC,  LFE,  FR,  FL } },
+                                 /* 6.1 */
+{ .ca_index = 0x0f,  .speakers = {   0,   RC,  RR,  RL,  FC,  LFE,  FR,  FL } },
+                                 /* surround71 */
+{ .ca_index = 0x13,  .speakers = { RRC,  RLC,  RR,  RL,  FC,  LFE,  FR,  FL } },
+
+{ .ca_index = 0x03,  .speakers = {   0,    0,   0,   0,  FC,  LFE,  FR,  FL } },
+{ .ca_index = 0x04,  .speakers = {   0,    0,   0,  RC,   0,    0,  FR,  FL } },
+{ .ca_index = 0x05,  .speakers = {   0,    0,   0,  RC,   0,  LFE,  FR,  FL } },
+{ .ca_index = 0x06,  .speakers = {   0,    0,   0,  RC,  FC,    0,  FR,  FL } },
+{ .ca_index = 0x07,  .speakers = {   0,    0,   0,  RC,  FC,  LFE,  FR,  FL } },
+{ .ca_index = 0x0c,  .speakers = {   0,   RC,  RR,  RL,   0,    0,  FR,  FL } },
+{ .ca_index = 0x0d,  .speakers = {   0,   RC,  RR,  RL,   0,  LFE,  FR,  FL } },
+{ .ca_index = 0x0e,  .speakers = {   0,   RC,  RR,  RL,  FC,    0,  FR,  FL } },
+{ .ca_index = 0x10,  .speakers = { RRC,  RLC,  RR,  RL,   0,    0,  FR,  FL } },
+{ .ca_index = 0x11,  .speakers = { RRC,  RLC,  RR,  RL,   0,  LFE,  FR,  FL } },
+{ .ca_index = 0x12,  .speakers = { RRC,  RLC,  RR,  RL,  FC,    0,  FR,  FL } },
+{ .ca_index = 0x14,  .speakers = { FRC,  FLC,   0,   0,   0,    0,  FR,  FL } },
+{ .ca_index = 0x15,  .speakers = { FRC,  FLC,   0,   0,   0,  LFE,  FR,  FL } },
+{ .ca_index = 0x16,  .speakers = { FRC,  FLC,   0,   0,  FC,    0,  FR,  FL } },
+{ .ca_index = 0x17,  .speakers = { FRC,  FLC,   0,   0,  FC,  LFE,  FR,  FL } },
+{ .ca_index = 0x18,  .speakers = { FRC,  FLC,   0,  RC,   0,    0,  FR,  FL } },
+{ .ca_index = 0x19,  .speakers = { FRC,  FLC,   0,  RC,   0,  LFE,  FR,  FL } },
+{ .ca_index = 0x1a,  .speakers = { FRC,  FLC,   0,  RC,  FC,    0,  FR,  FL } },
+{ .ca_index = 0x1b,  .speakers = { FRC,  FLC,   0,  RC,  FC,  LFE,  FR,  FL } },
+{ .ca_index = 0x1c,  .speakers = { FRC,  FLC,  RR,  RL,   0,    0,  FR,  FL } },
+{ .ca_index = 0x1d,  .speakers = { FRC,  FLC,  RR,  RL,   0,  LFE,  FR,  FL } },
+{ .ca_index = 0x1e,  .speakers = { FRC,  FLC,  RR,  RL,  FC,    0,  FR,  FL } },
+{ .ca_index = 0x1f,  .speakers = { FRC,  FLC,  RR,  RL,  FC,  LFE,  FR,  FL } },
+{ .ca_index = 0x20,  .speakers = {   0,  FCH,  RR,  RL,  FC,    0,  FR,  FL } },
+{ .ca_index = 0x21,  .speakers = {   0,  FCH,  RR,  RL,  FC,  LFE,  FR,  FL } },
+{ .ca_index = 0x22,  .speakers = {  TC,    0,  RR,  RL,  FC,    0,  FR,  FL } },
+{ .ca_index = 0x23,  .speakers = {  TC,    0,  RR,  RL,  FC,  LFE,  FR,  FL } },
+{ .ca_index = 0x24,  .speakers = { FRH,  FLH,  RR,  RL,   0,    0,  FR,  FL } },
+{ .ca_index = 0x25,  .speakers = { FRH,  FLH,  RR,  RL,   0,  LFE,  FR,  FL } },
+{ .ca_index = 0x26,  .speakers = { FRW,  FLW,  RR,  RL,   0,    0,  FR,  FL } },
+{ .ca_index = 0x27,  .speakers = { FRW,  FLW,  RR,  RL,   0,  LFE,  FR,  FL } },
+{ .ca_index = 0x28,  .speakers = {  TC,   RC,  RR,  RL,  FC,    0,  FR,  FL } },
+{ .ca_index = 0x29,  .speakers = {  TC,   RC,  RR,  RL,  FC,  LFE,  FR,  FL } },
+{ .ca_index = 0x2a,  .speakers = { FCH,   RC,  RR,  RL,  FC,    0,  FR,  FL } },
+{ .ca_index = 0x2b,  .speakers = { FCH,   RC,  RR,  RL,  FC,  LFE,  FR,  FL } },
+{ .ca_index = 0x2c,  .speakers = {  TC,  FCH,  RR,  RL,  FC,    0,  FR,  FL } },
+{ .ca_index = 0x2d,  .speakers = {  TC,  FCH,  RR,  RL,  FC,  LFE,  FR,  FL } },
+{ .ca_index = 0x2e,  .speakers = { FRH,  FLH,  RR,  RL,  FC,    0,  FR,  FL } },
+{ .ca_index = 0x2f,  .speakers = { FRH,  FLH,  RR,  RL,  FC,  LFE,  FR,  FL } },
+{ .ca_index = 0x30,  .speakers = { FRW,  FLW,  RR,  RL,  FC,    0,  FR,  FL } },
+{ .ca_index = 0x31,  .speakers = { FRW,  FLW,  RR,  RL,  FC,  LFE,  FR,  FL } },
+};
+
+
+/*
+ * HDMI routines
+ */
+
+static int hda_node_index(hda_nid_t *nids, hda_nid_t nid)
+{
+        int i;
+
+        for (i = 0; nids[i]; i++)
+                if (nids[i] == nid)
+                        return i;
+
+        snd_printk(KERN_WARNING "HDMI: nid %d not registered\n", nid);
+        return -EINVAL;
+}
+
+static void hdmi_get_show_eld(struct hda_codec *codec, hda_nid_t pin_nid,
+                              struct hdmi_eld *eld)
+{
+        if (!snd_hdmi_get_eld(eld, codec, pin_nid))
+                snd_hdmi_show_eld(eld);
+}
+
+#ifdef BE_PARANOID
+static void hdmi_get_dip_index(struct hda_codec *codec, hda_nid_t pin_nid,
+                                int *packet_index, int *byte_index)
+{
+        int val;
+
+        val = snd_hda_codec_read(codec, pin_nid, 0,
+                                 AC_VERB_GET_HDMI_DIP_INDEX, 0);
+
+        *packet_index = val >> 5;
+        *byte_index = val & 0x1f;
+}
+#endif
+
+static void hdmi_set_dip_index(struct hda_codec *codec, hda_nid_t pin_nid,
+                                int packet_index, int byte_index)
+{
+        int val;
+
+        val = (packet_index << 5) | (byte_index & 0x1f);
+
+        snd_hda_codec_write(codec, pin_nid, 0, AC_VERB_SET_HDMI_DIP_INDEX, val);
+}
+
+static void hdmi_write_dip_byte(struct hda_codec *codec, hda_nid_t pin_nid,
+                                unsigned char val)
+{
+        snd_hda_codec_write(codec, pin_nid, 0, AC_VERB_SET_HDMI_DIP_DATA, val);
+}
+
+static void hdmi_enable_output(struct hda_codec *codec, hda_nid_t pin_nid)
+{
+        /* Unmute */
+        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_codec_write(codec, pin_nid, 0,
+                            AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
+}
+
+static int hdmi_get_channel_count(struct hda_codec *codec, hda_nid_t nid)
+{
+        return 1 + snd_hda_codec_read(codec, nid, 0,
+                                        AC_VERB_GET_CVT_CHAN_COUNT, 0);
+}
+
+static void hdmi_set_channel_count(struct hda_codec *codec,
+                                   hda_nid_t nid, int chs)
+{
+        if (chs != hdmi_get_channel_count(codec, nid))
+                snd_hda_codec_write(codec, nid, 0,
+                                    AC_VERB_SET_CVT_CHAN_COUNT, chs - 1);
+}
+
+
+/*
+ * Channel mapping routines
+ */
+
+/*
+ * Compute derived values in channel_allocations[].
+ */
+static void init_channel_allocations(void)
+{
+        int i, j;
+        struct cea_channel_speaker_allocation *p;
+
+        for (i = 0; i < ARRAY_SIZE(channel_allocations); i++) {
+                p = channel_allocations + i;
+                p->channels = 0;
+                p->spk_mask = 0;
+                for (j = 0; j < ARRAY_SIZE(p->speakers); j++)
+                        if (p->speakers[j]) {
+                                p->channels++;
+                                p->spk_mask |= p->speakers[j];
+                        }
+        }
+}
+
+/*
+ * The transformation takes two steps:
+ *
+ *      eld->spk_alloc => (eld_speaker_allocation_bits[]) => spk_mask
+ *            spk_mask => (channel_allocations[])         => ai->CA
+ *
+ * TODO: it could select the wrong CA from multiple candidates.
+*/
+static int hdmi_setup_channel_allocation(struct hda_codec *codec, hda_nid_t nid,
+                                         struct hdmi_audio_infoframe *ai)
+{
+        struct hdmi_spec *spec = codec->spec;
+        struct hdmi_eld *eld;
+        int i;
+        int spk_mask = 0;
+        int channels = 1 + (ai->CC02_CT47 & 0x7);
+        char buf[SND_PRINT_CHANNEL_ALLOCATION_ADVISED_BUFSIZE];
+
+        /*
+         * CA defaults to 0 for basic stereo audio
+         */
+        if (channels <= 2)
+                return 0;
+
+        i = hda_node_index(spec->pin_cvt, nid);
+        if (i < 0)
+                return 0;
+        eld = &spec->sink_eld[i];
+
+        /*
+         * HDMI sink's ELD info cannot always be retrieved for now, e.g.
+         * in console or for audio devices. Assume the highest speakers
+         * configuration, to _not_ prohibit multi-channel audio playback.
+         */
+        if (!eld->spk_alloc)
+                eld->spk_alloc = 0xffff;
+
+        /*
+         * expand ELD's speaker allocation mask
+         *
+         * ELD tells the speaker mask in a compact(paired) form,
+         * expand ELD's notions to match the ones used by Audio InfoFrame.
+         */
+        for (i = 0; i < ARRAY_SIZE(eld_speaker_allocation_bits); i++) {
+                if (eld->spk_alloc & (1 << i))
+                        spk_mask |= eld_speaker_allocation_bits[i];
+        }
+
+        /* search for the first working match in the CA table */
+        for (i = 0; i < ARRAY_SIZE(channel_allocations); i++) {
+                if (channels == channel_allocations[i].channels &&
+                    (spk_mask & channel_allocations[i].spk_mask) ==
+                                channel_allocations[i].spk_mask) {
+                        ai->CA = channel_allocations[i].ca_index;
+                        break;
+                }
+        }
+
+        snd_print_channel_allocation(eld->spk_alloc, buf, sizeof(buf));
+        snd_printdd("HDMI: select CA 0x%x for %d-channel allocation: %s\n",
+                    ai->CA, channels, buf);
+
+        return ai->CA;
+}
+
+static void hdmi_debug_channel_mapping(struct hda_codec *codec,
+                                       hda_nid_t pin_nid)
+{
+#ifdef CONFIG_SND_DEBUG_VERBOSE
+        int i;
+        int slot;
+
+        for (i = 0; i < 8; i++) {
+                slot = snd_hda_codec_read(codec, pin_nid, 0,
+                                                AC_VERB_GET_HDMI_CHAN_SLOT, i);
+                printk(KERN_DEBUG "HDMI: ASP channel %d => slot %d\n",
+                                                slot >> 4, slot & 0xf);
+        }
+#endif
+}
+
+
+static void hdmi_setup_channel_mapping(struct hda_codec *codec,
+                                       hda_nid_t pin_nid,
+                                       struct hdmi_audio_infoframe *ai)
+{
+        int i;
+        int ca = ai->CA;
+        int err;
+
+        if (hdmi_channel_mapping[ca][1] == 0) {
+                for (i = 0; i < channel_allocations[ca].channels; i++)
+                        hdmi_channel_mapping[ca][i] = i | (i << 4);
+                for (; i < 8; i++)
+                        hdmi_channel_mapping[ca][i] = 0xf | (i << 4);
+        }
+
+        for (i = 0; i < 8; i++) {
+                err = snd_hda_codec_write(codec, pin_nid, 0,
+                                          AC_VERB_SET_HDMI_CHAN_SLOT,
+                                          hdmi_channel_mapping[ca][i]);
+                if (err) {
+                        snd_printdd(KERN_NOTICE
+                                    "HDMI: channel mapping failed\n");
+                        break;
+                }
+        }
+
+        hdmi_debug_channel_mapping(codec, pin_nid);
+}
+
+
+/*
+ * Audio InfoFrame routines
+ */
+
+/*
+ * Enable Audio InfoFrame Transmission
+ */
+static void hdmi_start_infoframe_trans(struct hda_codec *codec,
+                                       hda_nid_t pin_nid)
+{
+        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);
+}
+
+/*
+ * Disable Audio InfoFrame Transmission
+ */
+static void hdmi_stop_infoframe_trans(struct hda_codec *codec,
+                                      hda_nid_t pin_nid)
+{
+        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 void hdmi_debug_dip_size(struct hda_codec *codec, hda_nid_t pin_nid)
+{
+#ifdef CONFIG_SND_DEBUG_VERBOSE
+        int i;
+        int size;
+
+        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,
+                                                AC_VERB_GET_HDMI_DIP_SIZE, i);
+                printk(KERN_DEBUG "HDMI: DIP GP[%d] buf size is %d\n", i, size);
+        }
+#endif
+}
+
+static void hdmi_clear_dip_buffers(struct hda_codec *codec, hda_nid_t pin_nid)
+{
+#ifdef BE_PARANOID
+        int i, j;
+        int size;
+        int pi, bi;
+        for (i = 0; i < 8; i++) {
+                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);
+                for (j = 1; j < 1000; j++) {
+                        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);
+                        if (bi == 0) /* byte index wrapped around */
+                                break;
+                }
+                snd_printd(KERN_INFO
+                        "HDMI: DIP GP[%d] buf reported size=%d, written=%d\n",
+                        i, size, j);
+        }
+#endif
+}
+
+static void hdmi_checksum_audio_infoframe(struct hdmi_audio_infoframe *ai)
+{
+        u8 *bytes = (u8 *)ai;
+        u8 sum = 0;
+        int i;
+
+        ai->checksum = 0;
+
+        for (i = 0; i < sizeof(*ai); i++)
+                sum += bytes[i];
+
+        ai->checksum = -sum;
+}
+
+static void hdmi_fill_audio_infoframe(struct hda_codec *codec,
+                                      hda_nid_t pin_nid,
+                                      struct hdmi_audio_infoframe *ai)
+{
+        u8 *bytes = (u8 *)ai;
+        int i;
+
+        hdmi_debug_dip_size(codec, pin_nid);
+        hdmi_clear_dip_buffers(codec, pin_nid); /* be paranoid */
+
+        hdmi_checksum_audio_infoframe(ai);
+
+        hdmi_set_dip_index(codec, pin_nid, 0x0, 0x0);
+        for (i = 0; i < sizeof(*ai); i++)
+                hdmi_write_dip_byte(codec, pin_nid, bytes[i]);
+}
+
+static bool hdmi_infoframe_uptodate(struct hda_codec *codec, hda_nid_t pin_nid,
+                                    struct hdmi_audio_infoframe *ai)
+{
+        u8 *bytes = (u8 *)ai;
+        u8 val;
+        int i;
+
+        if (snd_hda_codec_read(codec, pin_nid, 0, AC_VERB_GET_HDMI_DIP_XMIT, 0)
+                                                            != AC_DIPXMIT_BEST)
+                return false;
+
+        hdmi_set_dip_index(codec, pin_nid, 0x0, 0x0);
+        for (i = 0; i < sizeof(*ai); i++) {
+                val = snd_hda_codec_read(codec, pin_nid, 0,
+                                         AC_VERB_GET_HDMI_DIP_DATA, 0);
+                if (val != bytes[i])
+                        return false;
+        }
+
+        return true;
+}
+
+static void hdmi_setup_audio_infoframe(struct hda_codec *codec, hda_nid_t nid,
+                                        struct snd_pcm_substream *substream)
+{
+        struct hdmi_spec *spec = codec->spec;
+        hda_nid_t pin_nid;
+        int i;
+        struct hdmi_audio_infoframe ai = {
+                .type           = 0x84,
+                .ver            = 0x01,
+                .len            = 0x0a,
+                .CC02_CT47      = substream->runtime->channels - 1,
+        };
+
+        hdmi_setup_channel_allocation(codec, nid, &ai);
+
+        for (i = 0; i < spec->num_pins; i++) {
+                if (spec->pin_cvt[i] != nid)
+                        continue;
+                if (!spec->sink_eld[i].monitor_present)
+                        continue;
+
+                pin_nid = spec->pin[i];
+                if (!hdmi_infoframe_uptodate(codec, pin_nid, &ai)) {
+                        snd_printdd("hdmi_setup_audio_infoframe: "
+                                    "cvt=%d pin=%d channels=%d\n",
+                                    nid, pin_nid,
+                                    substream->runtime->channels);
+                        hdmi_setup_channel_mapping(codec, pin_nid, &ai);
+                        hdmi_stop_infoframe_trans(codec, pin_nid);
+                        hdmi_fill_audio_infoframe(codec, pin_nid, &ai);
+                        hdmi_start_infoframe_trans(codec, pin_nid);
+                }
+        }
+}
+
+
+/*
+ * Unsolicited events
+ */
+
+static void hdmi_intrinsic_event(struct hda_codec *codec, unsigned int res)
+{
+        struct hdmi_spec *spec = codec->spec;
+        int tag = res >> AC_UNSOL_RES_TAG_SHIFT;
+        int pind = !!(res & AC_UNSOL_RES_PD);
+        int eldv = !!(res & AC_UNSOL_RES_ELDV);
+        int index;
+
+        printk(KERN_INFO
+                "HDMI hot plug event: Pin=%d Presence_Detect=%d ELD_Valid=%d\n",
+                tag, pind, eldv);
+
+        index = hda_node_index(spec->pin, tag);
+        if (index < 0)
+                return;
+
+        spec->sink_eld[index].monitor_present = pind;
+        spec->sink_eld[index].eld_valid = eldv;
+
+        if (pind && eldv) {
+                hdmi_get_show_eld(codec, spec->pin[index],
+                                  &spec->sink_eld[index]);
+                /* TODO: do real things about ELD */
+        }
+}
+
+static void hdmi_non_intrinsic_event(struct hda_codec *codec, unsigned int res)
+{
+        int tag = res >> AC_UNSOL_RES_TAG_SHIFT;
+        int subtag = (res & AC_UNSOL_RES_SUBTAG) >> AC_UNSOL_RES_SUBTAG_SHIFT;
+        int cp_state = !!(res & AC_UNSOL_RES_CP_STATE);
+        int cp_ready = !!(res & AC_UNSOL_RES_CP_READY);
+
+        printk(KERN_INFO
+                "HDMI CP event: PIN=%d SUBTAG=0x%x CP_STATE=%d CP_READY=%d\n",
+                tag,
+                subtag,
+                cp_state,
+                cp_ready);
+
+        /* TODO */
+        if (cp_state)
+                ;
+        if (cp_ready)
+                ;
+}
+
+
+static void hdmi_unsol_event(struct hda_codec *codec, unsigned int res)
+{
+        struct hdmi_spec *spec = codec->spec;
+        int tag = res >> AC_UNSOL_RES_TAG_SHIFT;
+        int subtag = (res & AC_UNSOL_RES_SUBTAG) >> AC_UNSOL_RES_SUBTAG_SHIFT;
+
+        if (hda_node_index(spec->pin, tag) < 0) {
+                snd_printd(KERN_INFO "Unexpected HDMI event tag 0x%x\n", tag);
+                return;
+        }
+
+        if (subtag == 0)
+                hdmi_intrinsic_event(codec, res);
+        else
+                hdmi_non_intrinsic_event(codec, res);
+}
+
+/*
+ * Callbacks
+ */
+
+static void hdmi_setup_stream(struct hda_codec *codec, hda_nid_t nid,
+                              u32 stream_tag, int format)
+{
+        int tag;
+        int fmt;
+
+        tag = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0) >> 4;
+        fmt = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_STREAM_FORMAT, 0);
+
+        snd_printdd("hdmi_setup_stream: "
+                    "NID=0x%x, %sstream=0x%x, %sformat=0x%x\n",
+                    nid,
+                    tag == stream_tag ? "" : "new-",
+                    stream_tag,
+                    fmt == format ? "" : "new-",
+                    format);
+
+        if (tag != stream_tag)
+                snd_hda_codec_write(codec, nid, 0,
+                                    AC_VERB_SET_CHANNEL_STREAMID,
+                                    stream_tag << 4);
+        if (fmt != format)
+                snd_hda_codec_write(codec, nid, 0,
+                                    AC_VERB_SET_STREAM_FORMAT, format);
+}
+
+/*
+ * HDA/HDMI auto parsing
+ */
+
+static int hdmi_read_pin_conn(struct hda_codec *codec, hda_nid_t pin_nid)
+{
+        struct hdmi_spec *spec = codec->spec;
+        hda_nid_t conn_list[HDA_MAX_CONNECTIONS];
+        int conn_len, curr;
+        int index;
+
+        if (!(get_wcaps(codec, pin_nid) & AC_WCAP_CONN_LIST)) {
+                snd_printk(KERN_WARNING
+                           "HDMI: pin %d wcaps %#x "
+                           "does not support connection list\n",
+                           pin_nid, get_wcaps(codec, pin_nid));
+                return -EINVAL;
+        }
+
+        conn_len = snd_hda_get_connections(codec, pin_nid, conn_list,
+                                           HDA_MAX_CONNECTIONS);
+        if (conn_len > 1)
+                curr = snd_hda_codec_read(codec, pin_nid, 0,
+                                          AC_VERB_GET_CONNECT_SEL, 0);
+        else
+                curr = 0;
+
+        index = hda_node_index(spec->pin, pin_nid);
+        if (index < 0)
+                return -EINVAL;
+
+        spec->pin_cvt[index] = conn_list[curr];
+
+        return 0;
+}
+
+static void hdmi_present_sense(struct hda_codec *codec, hda_nid_t pin_nid,
+                               struct hdmi_eld *eld)
+{
+        int present = snd_hda_pin_sense(codec, pin_nid);
+
+        eld->monitor_present    = !!(present & AC_PINSENSE_PRESENCE);
+        eld->eld_valid          = !!(present & AC_PINSENSE_ELDV);
+
+        if (present & AC_PINSENSE_ELDV)
+                hdmi_get_show_eld(codec, pin_nid, eld);
+}
+
+static int hdmi_add_pin(struct hda_codec *codec, hda_nid_t pin_nid)
+{
+        struct hdmi_spec *spec = codec->spec;
+
+        if (spec->num_pins >= MAX_HDMI_PINS) {
+                snd_printk(KERN_WARNING
+                           "HDMI: no space for pin %d\n", pin_nid);
+                return -EINVAL;
+        }
+
+        hdmi_present_sense(codec, pin_nid, &spec->sink_eld[spec->num_pins]);
+
+        spec->pin[spec->num_pins] = pin_nid;
+        spec->num_pins++;
+
+        /*
+         * It is assumed that converter nodes come first in the node list and
+         * hence have been registered and usable now.
+         */
+        return hdmi_read_pin_conn(codec, pin_nid);
+}
+
+static int hdmi_add_cvt(struct hda_codec *codec, hda_nid_t nid)
+{
+        struct hdmi_spec *spec = codec->spec;
+
+        if (spec->num_cvts >= MAX_HDMI_CVTS) {
+                snd_printk(KERN_WARNING
+                           "HDMI: no space for converter %d\n", nid);
+                return -EINVAL;
+        }
+
+        spec->cvt[spec->num_cvts] = nid;
+        spec->num_cvts++;
+
+        return 0;
+}
+
+static int hdmi_parse_codec(struct hda_codec *codec)
+{
+        hda_nid_t nid;
+        int i, nodes;
+
+        nodes = snd_hda_get_sub_nodes(codec, codec->afg, &nid);
+        if (!nid || nodes < 0) {
+                snd_printk(KERN_WARNING "HDMI: failed to get afg sub nodes\n");
+                return -EINVAL;
+        }
+
+        for (i = 0; i < nodes; i++, nid++) {
+                unsigned int caps;
+                unsigned int type;
+
+                caps = snd_hda_param_read(codec, nid, AC_PAR_AUDIO_WIDGET_CAP);
+                type = get_wcaps_type(caps);
+
+                if (!(caps & AC_WCAP_DIGITAL))
+                        continue;
+
+                switch (type) {
+                case AC_WID_AUD_OUT:
+                        if (hdmi_add_cvt(codec, nid) < 0)
+                                return -EINVAL;
+                        break;
+                case AC_WID_PIN:
+                        caps = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
+                        if (!(caps & (AC_PINCAP_HDMI | AC_PINCAP_DP)))
+                                continue;
+                        if (hdmi_add_pin(codec, nid) < 0)
+                                return -EINVAL;
+                        break;
+                }
+        }
+
+        /*
+         * G45/IbexPeak don't support EPSS: the unsolicited pin hot plug event
+         * can be lost and presence sense verb will become inaccurate if the
+         * HDA link is powered off at hot plug or hw initialization time.
+         */
+#ifdef CONFIG_SND_HDA_POWER_SAVE
+        if (!(snd_hda_param_read(codec, codec->afg, AC_PAR_POWER_STATE) &
+              AC_PWRST_EPSS))
+                codec->bus->power_keep_link_on = 1;
+#endif
+
+        return 0;
+}
+
diff --git a/sound/pci/hda/patch_intelhdmi.c b/sound/pci/hda/patch_intelhdmi.c
index 01a18ed475ac..88d035104cc5 100644
--- a/sound/pci/hda/patch_intelhdmi.c
+++ b/sound/pci/hda/patch_intelhdmi.c
@@ -33,605 +33,121 @@
 #include "hda_codec.h"
 #include "hda_local.h"
 
-static hda_nid_t cvt_nid;       /* audio converter */
-static hda_nid_t pin_nid;       /* HDMI output pin */
-
-#define INTEL_HDMI_EVENT_TAG            0x08
-
-struct intel_hdmi_spec {
-        struct hda_multi_out multiout;
-        struct hda_pcm pcm_rec;
-        struct hdmi_eld sink_eld;
-};
-
-struct hdmi_audio_infoframe {
-        u8 type; /* 0x84 */
-        u8 ver;  /* 0x01 */
-        u8 len;  /* 0x0a */
-
-        u8 checksum;    /* PB0 */
-        u8 CC02_CT47;   /* CC in bits 0:2, CT in 4:7 */
-        u8 SS01_SF24;
-        u8 CXT04;
-        u8 CA;
-        u8 LFEPBL01_LSV36_DM_INH7;
-        u8 reserved[5]; /* PB6 - PB10 */
-};
-
 /*
- * CEA speaker placement:
+ * The HDMI/DisplayPort configuration can be highly dynamic. A graphics device
+ * could support two independent pipes, each of them can be connected to one or
+ * more ports (DVI, HDMI or DisplayPort).
  *
- *        FLH       FCH        FRH
- *  FLW    FL  FLC   FC   FRC   FR   FRW
- *
- *                                  LFE
- *                     TC
- *
- *          RL  RLC   RC   RRC   RR
- *
- * The Left/Right Surround channel _notions_ LS/RS in SMPTE 320M corresponds to
- * CEA RL/RR; The SMPTE channel _assignment_ C/LFE is swapped to CEA LFE/FC.
- */
-enum cea_speaker_placement {
-        FL  = (1 <<  0),        /* Front Left           */
-        FC  = (1 <<  1),        /* Front Center         */
-        FR  = (1 <<  2),        /* Front Right          */
-        FLC = (1 <<  3),        /* Front Left Center    */
-        FRC = (1 <<  4),        /* Front Right Center   */
-        RL  = (1 <<  5),        /* Rear Left            */
-        RC  = (1 <<  6),        /* Rear Center          */
-        RR  = (1 <<  7),        /* Rear Right           */
-        RLC = (1 <<  8),        /* Rear Left Center     */
-        RRC = (1 <<  9),        /* Rear Right Center    */
-        LFE = (1 << 10),        /* Low Frequency Effect */
-        FLW = (1 << 11),        /* Front Left Wide      */
-        FRW = (1 << 12),        /* Front Right Wide     */
-        FLH = (1 << 13),        /* Front Left High      */
-        FCH = (1 << 14),        /* Front Center High    */
-        FRH = (1 << 15),        /* Front Right High     */
-        TC  = (1 << 16),        /* Top Center           */
-};
-
-/*
- * ELD SA bits in the CEA Speaker Allocation data block
+ * The HDA correspondence of pipes/ports are converter/pin nodes.
  */
-static int eld_speaker_allocation_bits[] = {
-        [0] = FL | FR,
-        [1] = LFE,
-        [2] = FC,
-        [3] = RL | RR,
-        [4] = RC,
-        [5] = FLC | FRC,
-        [6] = RLC | RRC,
-        /* the following are not defined in ELD yet */
-        [7] = FLW | FRW,
-        [8] = FLH | FRH,
-        [9] = TC,
-        [10] = FCH,
-};
+#define MAX_HDMI_CVTS   2
+#define MAX_HDMI_PINS   3
 
-struct cea_channel_speaker_allocation {
-        int ca_index;
-        int speakers[8];
+#include "patch_hdmi.c"
 
-        /* derived values, just for convenience */
-        int channels;
-        int spk_mask;
+static char *intel_hdmi_pcm_names[MAX_HDMI_CVTS] = {
+        "INTEL HDMI 0",
+        "INTEL HDMI 1",
 };
 
 /*
- * This is an ordered list!
- *
- * The preceding ones have better chances to be selected by
- * hdmi_setup_channel_allocation().
- */
-static struct cea_channel_speaker_allocation channel_allocations[] = {
-/*                        channel:   8     7    6    5    4     3    2    1  */
-{ .ca_index = 0x00,  .speakers = {   0,    0,   0,   0,   0,    0,  FR,  FL } },
-                                 /* 2.1 */
-{ .ca_index = 0x01,  .speakers = {   0,    0,   0,   0,   0,  LFE,  FR,  FL } },
-                                 /* Dolby Surround */
-{ .ca_index = 0x02,  .speakers = {   0,    0,   0,   0,  FC,    0,  FR,  FL } },
-{ .ca_index = 0x03,  .speakers = {   0,    0,   0,   0,  FC,  LFE,  FR,  FL } },
-{ .ca_index = 0x04,  .speakers = {   0,    0,   0,  RC,   0,    0,  FR,  FL } },
-{ .ca_index = 0x05,  .speakers = {   0,    0,   0,  RC,   0,  LFE,  FR,  FL } },
-{ .ca_index = 0x06,  .speakers = {   0,    0,   0,  RC,  FC,    0,  FR,  FL } },
-{ .ca_index = 0x07,  .speakers = {   0,    0,   0,  RC,  FC,  LFE,  FR,  FL } },
-{ .ca_index = 0x08,  .speakers = {   0,    0,  RR,  RL,   0,    0,  FR,  FL } },
-{ .ca_index = 0x09,  .speakers = {   0,    0,  RR,  RL,   0,  LFE,  FR,  FL } },
-{ .ca_index = 0x0a,  .speakers = {   0,    0,  RR,  RL,  FC,    0,  FR,  FL } },
-                                 /* 5.1 */
-{ .ca_index = 0x0b,  .speakers = {   0,    0,  RR,  RL,  FC,  LFE,  FR,  FL } },
-{ .ca_index = 0x0c,  .speakers = {   0,   RC,  RR,  RL,   0,    0,  FR,  FL } },
-{ .ca_index = 0x0d,  .speakers = {   0,   RC,  RR,  RL,   0,  LFE,  FR,  FL } },
-{ .ca_index = 0x0e,  .speakers = {   0,   RC,  RR,  RL,  FC,    0,  FR,  FL } },
-                                 /* 6.1 */
-{ .ca_index = 0x0f,  .speakers = {   0,   RC,  RR,  RL,  FC,  LFE,  FR,  FL } },
-{ .ca_index = 0x10,  .speakers = { RRC,  RLC,  RR,  RL,   0,    0,  FR,  FL } },
-{ .ca_index = 0x11,  .speakers = { RRC,  RLC,  RR,  RL,   0,  LFE,  FR,  FL } },
-{ .ca_index = 0x12,  .speakers = { RRC,  RLC,  RR,  RL,  FC,    0,  FR,  FL } },
-                                 /* 7.1 */
-{ .ca_index = 0x13,  .speakers = { RRC,  RLC,  RR,  RL,  FC,  LFE,  FR,  FL } },
-{ .ca_index = 0x14,  .speakers = { FRC,  FLC,   0,   0,   0,    0,  FR,  FL } },
-{ .ca_index = 0x15,  .speakers = { FRC,  FLC,   0,   0,   0,  LFE,  FR,  FL } },
-{ .ca_index = 0x16,  .speakers = { FRC,  FLC,   0,   0,  FC,    0,  FR,  FL } },
-{ .ca_index = 0x17,  .speakers = { FRC,  FLC,   0,   0,  FC,  LFE,  FR,  FL } },
-{ .ca_index = 0x18,  .speakers = { FRC,  FLC,   0,  RC,   0,    0,  FR,  FL } },
-{ .ca_index = 0x19,  .speakers = { FRC,  FLC,   0,  RC,   0,  LFE,  FR,  FL } },
-{ .ca_index = 0x1a,  .speakers = { FRC,  FLC,   0,  RC,  FC,    0,  FR,  FL } },
-{ .ca_index = 0x1b,  .speakers = { FRC,  FLC,   0,  RC,  FC,  LFE,  FR,  FL } },
-{ .ca_index = 0x1c,  .speakers = { FRC,  FLC,  RR,  RL,   0,    0,  FR,  FL } },
-{ .ca_index = 0x1d,  .speakers = { FRC,  FLC,  RR,  RL,   0,  LFE,  FR,  FL } },
-{ .ca_index = 0x1e,  .speakers = { FRC,  FLC,  RR,  RL,  FC,    0,  FR,  FL } },
-{ .ca_index = 0x1f,  .speakers = { FRC,  FLC,  RR,  RL,  FC,  LFE,  FR,  FL } },
-{ .ca_index = 0x20,  .speakers = {   0,  FCH,  RR,  RL,  FC,    0,  FR,  FL } },
-{ .ca_index = 0x21,  .speakers = {   0,  FCH,  RR,  RL,  FC,  LFE,  FR,  FL } },
-{ .ca_index = 0x22,  .speakers = {  TC,    0,  RR,  RL,  FC,    0,  FR,  FL } },
-{ .ca_index = 0x23,  .speakers = {  TC,    0,  RR,  RL,  FC,  LFE,  FR,  FL } },
-{ .ca_index = 0x24,  .speakers = { FRH,  FLH,  RR,  RL,   0,    0,  FR,  FL } },
-{ .ca_index = 0x25,  .speakers = { FRH,  FLH,  RR,  RL,   0,  LFE,  FR,  FL } },
-{ .ca_index = 0x26,  .speakers = { FRW,  FLW,  RR,  RL,   0,    0,  FR,  FL } },
-{ .ca_index = 0x27,  .speakers = { FRW,  FLW,  RR,  RL,   0,  LFE,  FR,  FL } },
-{ .ca_index = 0x28,  .speakers = {  TC,   RC,  RR,  RL,  FC,    0,  FR,  FL } },
-{ .ca_index = 0x29,  .speakers = {  TC,   RC,  RR,  RL,  FC,  LFE,  FR,  FL } },
-{ .ca_index = 0x2a,  .speakers = { FCH,   RC,  RR,  RL,  FC,    0,  FR,  FL } },
-{ .ca_index = 0x2b,  .speakers = { FCH,   RC,  RR,  RL,  FC,  LFE,  FR,  FL } },
-{ .ca_index = 0x2c,  .speakers = {  TC,  FCH,  RR,  RL,  FC,    0,  FR,  FL } },
-{ .ca_index = 0x2d,  .speakers = {  TC,  FCH,  RR,  RL,  FC,  LFE,  FR,  FL } },
-{ .ca_index = 0x2e,  .speakers = { FRH,  FLH,  RR,  RL,  FC,    0,  FR,  FL } },
-{ .ca_index = 0x2f,  .speakers = { FRH,  FLH,  RR,  RL,  FC,  LFE,  FR,  FL } },
-{ .ca_index = 0x30,  .speakers = { FRW,  FLW,  RR,  RL,  FC,    0,  FR,  FL } },
-{ .ca_index = 0x31,  .speakers = { FRW,  FLW,  RR,  RL,  FC,  LFE,  FR,  FL } },
-};
-
-/*
- * HDMI routines
- */
-
-#ifdef BE_PARANOID
-static void hdmi_get_dip_index(struct hda_codec *codec, hda_nid_t nid,
-                                int *packet_index, int *byte_index)
-{
-        int val;
-
-        val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_HDMI_DIP_INDEX, 0);
-
-        *packet_index = val >> 5;
-        *byte_index = val & 0x1f;
-}
-#endif
-
-static void hdmi_set_dip_index(struct hda_codec *codec, hda_nid_t nid,
-                                int packet_index, int byte_index)
-{
-        int val;
-
-        val = (packet_index << 5) | (byte_index & 0x1f);
-
-        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_HDMI_DIP_INDEX, val);
-}
-
-static void hdmi_write_dip_byte(struct hda_codec *codec, hda_nid_t nid,
-                                unsigned char val)
-{
-        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_HDMI_DIP_DATA, val);
-}
-
-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,
-                                AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
-        /* Enable pin out */
-        snd_hda_codec_write(codec, pin_nid, 0,
-                            AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
-}
-
-/*
- * Enable Audio InfoFrame Transmission
- */
-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,
-                                                AC_DIPXMIT_BEST);
-}
-
-/*
- * Disable Audio InfoFrame Transmission
- */
-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,
-                                                AC_DIPXMIT_DISABLE);
-}
-
-static int hdmi_get_channel_count(struct hda_codec *codec)
-{
-        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,
-                                        AC_VERB_SET_CVT_CHAN_COUNT, chs - 1);
-
-        if (chs != hdmi_get_channel_count(codec))
-                snd_printd(KERN_INFO "HDMI channel count: expect %d, get %d\n",
-                                        chs, hdmi_get_channel_count(codec));
-}
-
-static void hdmi_debug_channel_mapping(struct hda_codec *codec)
-{
-#ifdef CONFIG_SND_DEBUG_VERBOSE
-        int i;
-        int slot;
-
-        for (i = 0; i < 8; i++) {
-                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);
-        }
-#endif
-}
-
-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))
-                snd_hdmi_show_eld(eld);
-}
-
-
-/*
- * Audio InfoFrame routines
- */
-
-static void hdmi_debug_dip_size(struct hda_codec *codec)
-{
-#ifdef CONFIG_SND_DEBUG_VERBOSE
-        int i;
-        int size;
-
-        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,
-                                                AC_VERB_GET_HDMI_DIP_SIZE, i);
-                printk(KERN_DEBUG "HDMI: DIP GP[%d] buf size is %d\n", i, size);
-        }
-#endif
-}
-
-static void hdmi_clear_dip_buffers(struct hda_codec *codec)
-{
-#ifdef BE_PARANOID
-        int i, j;
-        int size;
-        int pi, bi;
-        for (i = 0; i < 8; i++) {
-                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);
-                for (j = 1; j < 1000; j++) {
-                        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);
-                        if (bi == 0) /* byte index wrapped around */
-                                break;
-                }
-                snd_printd(KERN_INFO
-                        "HDMI: DIP GP[%d] buf reported size=%d, written=%d\n",
-                        i, size, j);
-        }
-#endif
-}
-
-static void hdmi_fill_audio_infoframe(struct hda_codec *codec,
-                                        struct hdmi_audio_infoframe *ai)
-{
-        u8 *params = (u8 *)ai;
-        u8 sum = 0;
-        int i;
-
-        hdmi_debug_dip_size(codec);
-        hdmi_clear_dip_buffers(codec); /* be paranoid */
-
-        for (i = 0; i < sizeof(ai); i++)
-                sum += params[i];
-        ai->checksum = - sum;
-
-        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]);
-}
-
-/*
- * Compute derived values in channel_allocations[].
- */
-static void init_channel_allocations(void)
-{
-        int i, j;
-        struct cea_channel_speaker_allocation *p;
-
-        for (i = 0; i < ARRAY_SIZE(channel_allocations); i++) {
-                p = channel_allocations + i;
-                p->channels = 0;
-                p->spk_mask = 0;
-                for (j = 0; j < ARRAY_SIZE(p->speakers); j++)
-                        if (p->speakers[j]) {
-                                p->channels++;
-                                p->spk_mask |= p->speakers[j];
-                        }
-        }
-}
-
-/*
- * The transformation takes two steps:
- *
- *      eld->spk_alloc => (eld_speaker_allocation_bits[]) => spk_mask
- *            spk_mask => (channel_allocations[])         => ai->CA
- *
- * TODO: it could select the wrong CA from multiple candidates.
-*/
-static int hdmi_setup_channel_allocation(struct hda_codec *codec,
-                                         struct hdmi_audio_infoframe *ai)
-{
-        struct intel_hdmi_spec *spec = codec->spec;
-        struct hdmi_eld *eld = &spec->sink_eld;
-        int i;
-        int spk_mask = 0;
-        int channels = 1 + (ai->CC02_CT47 & 0x7);
-        char buf[SND_PRINT_CHANNEL_ALLOCATION_ADVISED_BUFSIZE];
-
-        /*
-         * CA defaults to 0 for basic stereo audio
-         */
-        if (channels <= 2)
-                return 0;
-
-        /*
-         * HDMI sink's ELD info cannot always be retrieved for now, e.g.
-         * in console or for audio devices. Assume the highest speakers
-         * configuration, to _not_ prohibit multi-channel audio playback.
-         */
-        if (!eld->spk_alloc)
-                eld->spk_alloc = 0xffff;
-
-        /*
-         * expand ELD's speaker allocation mask
-         *
-         * ELD tells the speaker mask in a compact(paired) form,
-         * expand ELD's notions to match the ones used by Audio InfoFrame.
-         */
-        for (i = 0; i < ARRAY_SIZE(eld_speaker_allocation_bits); i++) {
-                if (eld->spk_alloc & (1 << i))
-                        spk_mask |= eld_speaker_allocation_bits[i];
-        }
-
-        /* search for the first working match in the CA table */
-        for (i = 0; i < ARRAY_SIZE(channel_allocations); i++) {
-                if (channels == channel_allocations[i].channels &&
-                    (spk_mask & channel_allocations[i].spk_mask) ==
-                                channel_allocations[i].spk_mask) {
-                        ai->CA = channel_allocations[i].ca_index;
-                        break;
-                }
-        }
-
-        snd_print_channel_allocation(eld->spk_alloc, buf, sizeof(buf));
-        snd_printdd(KERN_INFO
-                        "HDMI: select CA 0x%x for %d-channel allocation: %s\n",
-                        ai->CA, channels, buf);
-
-        return ai->CA;
-}
-
-static void hdmi_setup_channel_mapping(struct hda_codec *codec,
-                                        struct hdmi_audio_infoframe *ai)
-{
-        int i;
-
-        if (!ai->CA)
-                return;
-
-        /*
-         * TODO: adjust channel mapping if necessary
-         * ALSA sequence is front/surr/clfe/side?
-         */
-
-        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);
-}
-
-
-static void hdmi_setup_audio_infoframe(struct hda_codec *codec,
-                                        struct snd_pcm_substream *substream)
-{
-        struct hdmi_audio_infoframe ai = {
-                .type           = 0x84,
-                .ver            = 0x01,
-                .len            = 0x0a,
-                .CC02_CT47      = substream->runtime->channels - 1,
-        };
-
-        hdmi_setup_channel_allocation(codec, &ai);
-        hdmi_setup_channel_mapping(codec, &ai);
-
-        hdmi_fill_audio_infoframe(codec, &ai);
-        hdmi_start_infoframe_trans(codec);
-}
-
-
-/*
- * Unsolicited events
- */
-
-static void hdmi_intrinsic_event(struct hda_codec *codec, unsigned int res)
-{
-        int pind = !!(res & AC_UNSOL_RES_PD);
-        int eldv = !!(res & AC_UNSOL_RES_ELDV);
-
-        printk(KERN_INFO
-                "HDMI hot plug event: Presence_Detect=%d ELD_Valid=%d\n",
-                pind, eldv);
-
-        if (pind && eldv) {
-                hdmi_parse_eld(codec);
-                /* TODO: do real things about ELD */
-        }
-}
-
-static void hdmi_non_intrinsic_event(struct hda_codec *codec, unsigned int res)
-{
-        int subtag = (res & AC_UNSOL_RES_SUBTAG) >> AC_UNSOL_RES_SUBTAG_SHIFT;
-        int cp_state = !!(res & AC_UNSOL_RES_CP_STATE);
-        int cp_ready = !!(res & AC_UNSOL_RES_CP_READY);
-
-        printk(KERN_INFO
-                "HDMI content protection event: SUBTAG=0x%x CP_STATE=%d CP_READY=%d\n",
-                subtag,
-                cp_state,
-                cp_ready);
-
-        /* TODO */
-        if (cp_state)
-                ;
-        if (cp_ready)
-                ;
-}
-
-
-static void intel_hdmi_unsol_event(struct hda_codec *codec, unsigned int res)
-{
-        int tag = res >> AC_UNSOL_RES_TAG_SHIFT;
-        int subtag = (res & AC_UNSOL_RES_SUBTAG) >> AC_UNSOL_RES_SUBTAG_SHIFT;
-
-        if (tag != INTEL_HDMI_EVENT_TAG) {
-                snd_printd(KERN_INFO "Unexpected HDMI event tag 0x%x\n", tag);
-                return;
-        }
-
-        if (subtag == 0)
-                hdmi_intrinsic_event(codec, res);
-        else
-                hdmi_non_intrinsic_event(codec, res);
-}
-
-/*
- * Callbacks
+ * HDMI callbacks
  */
 
-static int intel_hdmi_playback_pcm_open(struct hda_pcm_stream *hinfo,
-                                        struct hda_codec *codec,
-                                        struct snd_pcm_substream *substream)
-{
-        struct intel_hdmi_spec *spec = codec->spec;
-
-        return snd_hda_multi_out_dig_open(codec, &spec->multiout);
-}
-
-static int intel_hdmi_playback_pcm_close(struct hda_pcm_stream *hinfo,
-                                         struct hda_codec *codec,
-                                         struct snd_pcm_substream *substream)
-{
-        struct intel_hdmi_spec *spec = codec->spec;
-
-        hdmi_stop_infoframe_trans(codec);
-
-        return snd_hda_multi_out_dig_close(codec, &spec->multiout);
-}
-
 static int intel_hdmi_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 intel_hdmi_spec *spec = codec->spec;
+        hdmi_set_channel_count(codec, hinfo->nid,
+                               substream->runtime->channels);
 
-        snd_hda_multi_out_dig_prepare(codec, &spec->multiout, stream_tag,
-                                             format, substream);
+        hdmi_setup_audio_infoframe(codec, hinfo->nid, substream);
 
-        hdmi_set_channel_count(codec, substream->runtime->channels);
-
-        hdmi_setup_audio_infoframe(codec, substream);
+        hdmi_setup_stream(codec, hinfo->nid, stream_tag, format);
+        return 0;
+}
 
+static int intel_hdmi_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
+                                           struct hda_codec *codec,
+                                           struct snd_pcm_substream *substream)
+{
         return 0;
 }
 
 static struct hda_pcm_stream intel_hdmi_pcm_playback = {
         .substreams = 1,
         .channels_min = 2,
-        .channels_max = 8,
         .ops = {
-                .open    = intel_hdmi_playback_pcm_open,
-                .close   = intel_hdmi_playback_pcm_close,
-                .prepare = intel_hdmi_playback_pcm_prepare
+                .prepare = intel_hdmi_playback_pcm_prepare,
+                .cleanup = intel_hdmi_playback_pcm_cleanup,
         },
 };
 
 static int intel_hdmi_build_pcms(struct hda_codec *codec)
 {
-        struct intel_hdmi_spec *spec = codec->spec;
-        struct hda_pcm *info = &spec->pcm_rec;
+        struct hdmi_spec *spec = codec->spec;
+        struct hda_pcm *info = spec->pcm_rec;
+        int i;
 
-        codec->num_pcms = 1;
+        codec->num_pcms = spec->num_cvts;
         codec->pcm_info = info;
 
-        /* NID to query formats and rates and setup streams */
-        intel_hdmi_pcm_playback.nid = cvt_nid;
+        for (i = 0; i < codec->num_pcms; i++, info++) {
+                unsigned int chans;
+
+                chans = get_wcaps(codec, spec->cvt[i]);
+                chans = get_wcaps_channels(chans);
 
-        info->name = "INTEL HDMI";
-        info->pcm_type = HDA_PCM_TYPE_HDMI;
-        info->stream[SNDRV_PCM_STREAM_PLAYBACK] = intel_hdmi_pcm_playback;
+                info->name = intel_hdmi_pcm_names[i];
+                info->pcm_type = HDA_PCM_TYPE_HDMI;
+                info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
+                                                        intel_hdmi_pcm_playback;
+                info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->cvt[i];
+                info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = chans;
+        }
 
         return 0;
 }
 
 static int intel_hdmi_build_controls(struct hda_codec *codec)
 {
-        struct intel_hdmi_spec *spec = codec->spec;
+        struct hdmi_spec *spec = codec->spec;
         int err;
+        int i;
 
-        err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
-        if (err < 0)
-                return err;
+        for (i = 0; i < codec->num_pcms; i++) {
+                err = snd_hda_create_spdif_out_ctls(codec, spec->cvt[i]);
+                if (err < 0)
+                        return err;
+        }
 
         return 0;
 }
 
 static int intel_hdmi_init(struct hda_codec *codec)
 {
-        hdmi_enable_output(codec);
+        struct hdmi_spec *spec = codec->spec;
+        int i;
 
-        snd_hda_codec_write(codec, pin_nid, 0,
-                            AC_VERB_SET_UNSOLICITED_ENABLE,
-                            AC_USRSP_EN | INTEL_HDMI_EVENT_TAG);
+        for (i = 0; spec->pin[i]; i++) {
+                hdmi_enable_output(codec, spec->pin[i]);
+                snd_hda_codec_write(codec, spec->pin[i], 0,
+                                    AC_VERB_SET_UNSOLICITED_ENABLE,
+                                    AC_USRSP_EN | spec->pin[i]);
+        }
         return 0;
 }
 
 static void intel_hdmi_free(struct hda_codec *codec)
 {
-        struct intel_hdmi_spec *spec = codec->spec;
+        struct hdmi_spec *spec = codec->spec;
+        int i;
+
+        for (i = 0; i < spec->num_pins; i++)
+                snd_hda_eld_proc_free(codec, &spec->sink_eld[i]);
 
-        snd_hda_eld_proc_free(codec, &spec->sink_eld);
         kfree(spec);
 }
 
@@ -640,52 +156,41 @@ static struct hda_codec_ops intel_hdmi_patch_ops = {
         .free                   = intel_hdmi_free,
         .build_pcms             = intel_hdmi_build_pcms,
         .build_controls         = intel_hdmi_build_controls,
-        .unsol_event            = intel_hdmi_unsol_event,
+        .unsol_event            = hdmi_unsol_event,
 };
 
-static int do_patch_intel_hdmi(struct hda_codec *codec)
+static int patch_intel_hdmi(struct hda_codec *codec)
 {
-        struct intel_hdmi_spec *spec;
+        struct hdmi_spec *spec;
+        int i;
 
         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
         if (spec == NULL)
                 return -ENOMEM;
 
-        spec->multiout.num_dacs = 0;      /* no analog */
-        spec->multiout.max_channels = 8;
-        spec->multiout.dig_out_nid = cvt_nid;
-
         codec->spec = spec;
+        if (hdmi_parse_codec(codec) < 0) {
+                codec->spec = NULL;
+                kfree(spec);
+                return -EINVAL;
+        }
         codec->patch_ops = intel_hdmi_patch_ops;
 
-        snd_hda_eld_proc_new(codec, &spec->sink_eld);
+        for (i = 0; i < spec->num_pins; i++)
+                snd_hda_eld_proc_new(codec, &spec->sink_eld[i], i);
 
         init_channel_allocations();
 
         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 = 0x80860054, .name = "Q57 DEVIBX", .patch = patch_intel_hdmi },
         { .id = 0x10951392, .name = "SiI1392 HDMI",     .patch = patch_intel_hdmi },
         {} /* terminator */
 };
diff --git a/sound/pci/hda/patch_nvhdmi.c b/sound/pci/hda/patch_nvhdmi.c
index 6afdab09bab7..3c10c0b149f4 100644
--- a/sound/pci/hda/patch_nvhdmi.c
+++ b/sound/pci/hda/patch_nvhdmi.c
@@ -29,13 +29,23 @@
 #include "hda_codec.h"
 #include "hda_local.h"
 
+#define MAX_HDMI_CVTS   1
+#define MAX_HDMI_PINS   1
+
+#include "patch_hdmi.c"
+
+static char *nvhdmi_pcm_names[MAX_HDMI_CVTS] = {
+        "NVIDIA HDMI",
+};
+
 /* define below to restrict the supported rates and formats */
 /* #define LIMITED_RATE_FMT_SUPPORT */
 
-struct nvhdmi_spec {
-        struct hda_multi_out multiout;
-
-        struct hda_pcm pcm_rec;
+enum HDACodec {
+        HDA_CODEC_NVIDIA_MCP7X,
+        HDA_CODEC_NVIDIA_MCP89,
+        HDA_CODEC_NVIDIA_GT21X,
+        HDA_CODEC_INVALID
 };
 
 #define Nv_VERB_SET_Channel_Allocation          0xF79
@@ -43,15 +53,18 @@ struct nvhdmi_spec {
 #define Nv_VERB_SET_Audio_Protection_On         0xF98
 #define Nv_VERB_SET_Audio_Protection_Off        0xF99
 
-#define Nv_Master_Convert_nid   0x04
-#define Nv_Master_Pin_nid       0x05
+#define nvhdmi_master_con_nid_7x        0x04
+#define nvhdmi_master_pin_nid_7x        0x05
 
-static hda_nid_t nvhdmi_convert_nids[4] = {
+#define nvhdmi_master_con_nid_89        0x04
+#define nvhdmi_master_pin_nid_89        0x05
+
+static hda_nid_t nvhdmi_con_nids_7x[4] = {
         /*front, rear, clfe, rear_surr */
         0x6, 0x8, 0xa, 0xc,
 };
 
-static struct hda_verb nvhdmi_basic_init[] = {
+static struct hda_verb nvhdmi_basic_init_7x[] = {
         /* set audio protect on */
         { 0x1, Nv_VERB_SET_Audio_Protection_On, 0x1},
         /* enable digital output on pin widget */
@@ -84,22 +97,60 @@ static struct hda_verb nvhdmi_basic_init[] = {
  */
 static int nvhdmi_build_controls(struct hda_codec *codec)
 {
-        struct nvhdmi_spec *spec = codec->spec;
+        struct hdmi_spec *spec = codec->spec;
         int err;
+        int i;
 
-        err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
-        if (err < 0)
-                return err;
+        if ((spec->codec_type == HDA_CODEC_NVIDIA_MCP89)
+        || (spec->codec_type == HDA_CODEC_NVIDIA_GT21X)) {
+                for (i = 0; i < codec->num_pcms; i++) {
+                        err = snd_hda_create_spdif_out_ctls(codec,
+                                                            spec->cvt[i]);
+                        if (err < 0)
+                                return err;
+                }
+        } else {
+                err = snd_hda_create_spdif_out_ctls(codec,
+                                                    spec->multiout.dig_out_nid);
+                if (err < 0)
+                        return err;
+        }
 
         return 0;
 }
 
 static int nvhdmi_init(struct hda_codec *codec)
 {
-        snd_hda_sequence_write(codec, nvhdmi_basic_init);
+        struct hdmi_spec *spec = codec->spec;
+        int i;
+        if ((spec->codec_type == HDA_CODEC_NVIDIA_MCP89)
+        || (spec->codec_type == HDA_CODEC_NVIDIA_GT21X)) {
+                for (i = 0; spec->pin[i]; i++) {
+                        hdmi_enable_output(codec, spec->pin[i]);
+                        snd_hda_codec_write(codec, spec->pin[i], 0,
+                                            AC_VERB_SET_UNSOLICITED_ENABLE,
+                                            AC_USRSP_EN | spec->pin[i]);
+                }
+        } else {
+                snd_hda_sequence_write(codec, nvhdmi_basic_init_7x);
+        }
         return 0;
 }
 
+static void nvhdmi_free(struct hda_codec *codec)
+{
+        struct hdmi_spec *spec = codec->spec;
+        int i;
+
+        if ((spec->codec_type == HDA_CODEC_NVIDIA_MCP89)
+        || (spec->codec_type == HDA_CODEC_NVIDIA_GT21X)) {
+                for (i = 0; i < spec->num_pins; i++)
+                        snd_hda_eld_proc_free(codec, &spec->sink_eld[i]);
+        }
+
+        kfree(spec);
+}
+
 /*
  * Digital out
  */
@@ -107,25 +158,25 @@ static int nvhdmi_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
                                         struct hda_codec *codec,
                                         struct snd_pcm_substream *substream)
 {
-        struct nvhdmi_spec *spec = codec->spec;
+        struct hdmi_spec *spec = codec->spec;
         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
 }
 
-static int nvhdmi_dig_playback_pcm_close_8ch(struct hda_pcm_stream *hinfo,
+static int nvhdmi_dig_playback_pcm_close_8ch_7x(struct hda_pcm_stream *hinfo,
                                         struct hda_codec *codec,
                                         struct snd_pcm_substream *substream)
 {
-        struct nvhdmi_spec *spec = codec->spec;
+        struct hdmi_spec *spec = codec->spec;
         int i;
 
-        snd_hda_codec_write(codec, Nv_Master_Convert_nid,
+        snd_hda_codec_write(codec, nvhdmi_master_con_nid_7x,
                         0, AC_VERB_SET_CHANNEL_STREAMID, 0);
         for (i = 0; i < 4; i++) {
                 /* set the stream id */
-                snd_hda_codec_write(codec, nvhdmi_convert_nids[i], 0,
+                snd_hda_codec_write(codec, nvhdmi_con_nids_7x[i], 0,
                                 AC_VERB_SET_CHANNEL_STREAMID, 0);
                 /* set the stream format */
-                snd_hda_codec_write(codec, nvhdmi_convert_nids[i], 0,
+                snd_hda_codec_write(codec, nvhdmi_con_nids_7x[i], 0,
                                 AC_VERB_SET_STREAM_FORMAT, 0);
         }
 
@@ -136,10 +187,25 @@ static int nvhdmi_dig_playback_pcm_close_2ch(struct hda_pcm_stream *hinfo,
                                         struct hda_codec *codec,
                                         struct snd_pcm_substream *substream)
 {
-        struct nvhdmi_spec *spec = codec->spec;
+        struct hdmi_spec *spec = codec->spec;
         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
 }
 
+static int nvhdmi_dig_playback_pcm_prepare_8ch_89(struct hda_pcm_stream *hinfo,
+                                        struct hda_codec *codec,
+                                        unsigned int stream_tag,
+                                        unsigned int format,
+                                        struct snd_pcm_substream *substream)
+{
+        hdmi_set_channel_count(codec, hinfo->nid,
+                               substream->runtime->channels);
+
+        hdmi_setup_audio_infoframe(codec, hinfo->nid, substream);
+
+        hdmi_setup_stream(codec, hinfo->nid, stream_tag, format);
+        return 0;
+}
+
 static int nvhdmi_dig_playback_pcm_prepare_8ch(struct hda_pcm_stream *hinfo,
                                         struct hda_codec *codec,
                                         unsigned int stream_tag,
@@ -181,29 +247,29 @@ static int nvhdmi_dig_playback_pcm_prepare_8ch(struct hda_pcm_stream *hinfo,
         /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
         if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
                 snd_hda_codec_write(codec,
-                                Nv_Master_Convert_nid,
+                                nvhdmi_master_con_nid_7x,
                                 0,
                                 AC_VERB_SET_DIGI_CONVERT_1,
                                 codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff);
 
         /* set the stream id */
-        snd_hda_codec_write(codec, Nv_Master_Convert_nid, 0,
+        snd_hda_codec_write(codec, nvhdmi_master_con_nid_7x, 0,
                         AC_VERB_SET_CHANNEL_STREAMID, (stream_tag << 4) | 0x0);
 
         /* set the stream format */
-        snd_hda_codec_write(codec, Nv_Master_Convert_nid, 0,
+        snd_hda_codec_write(codec, nvhdmi_master_con_nid_7x, 0,
                         AC_VERB_SET_STREAM_FORMAT, format);
 
         /* turn on again (if needed) */
         /* enable and set the channel status audio/data flag */
         if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE)) {
                 snd_hda_codec_write(codec,
-                                Nv_Master_Convert_nid,
+                                nvhdmi_master_con_nid_7x,
                                 0,
                                 AC_VERB_SET_DIGI_CONVERT_1,
                                 codec->spdif_ctls & 0xff);
                 snd_hda_codec_write(codec,
-                                Nv_Master_Convert_nid,
+                                nvhdmi_master_con_nid_7x,
                                 0,
                                 AC_VERB_SET_DIGI_CONVERT_2, dataDCC2);
         }
@@ -220,19 +286,19 @@ static int nvhdmi_dig_playback_pcm_prepare_8ch(struct hda_pcm_stream *hinfo,
                 if (codec->spdif_status_reset &&
                 (codec->spdif_ctls & AC_DIG1_ENABLE))
                         snd_hda_codec_write(codec,
-                                nvhdmi_convert_nids[i],
+                                nvhdmi_con_nids_7x[i],
                                 0,
                                 AC_VERB_SET_DIGI_CONVERT_1,
                                 codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff);
                 /* set the stream id */
                 snd_hda_codec_write(codec,
-                                nvhdmi_convert_nids[i],
+                                nvhdmi_con_nids_7x[i],
                                 0,
                                 AC_VERB_SET_CHANNEL_STREAMID,
                                 (stream_tag << 4) | channel_id);
                 /* set the stream format */
                 snd_hda_codec_write(codec,
-                                nvhdmi_convert_nids[i],
+                                nvhdmi_con_nids_7x[i],
                                 0,
                                 AC_VERB_SET_STREAM_FORMAT,
                                 format);
@@ -241,12 +307,12 @@ static int nvhdmi_dig_playback_pcm_prepare_8ch(struct hda_pcm_stream *hinfo,
                 if (codec->spdif_status_reset &&
                 (codec->spdif_ctls & AC_DIG1_ENABLE)) {
                         snd_hda_codec_write(codec,
-                                        nvhdmi_convert_nids[i],
+                                        nvhdmi_con_nids_7x[i],
                                         0,
                                         AC_VERB_SET_DIGI_CONVERT_1,
                                         codec->spdif_ctls & 0xff);
                         snd_hda_codec_write(codec,
-                                        nvhdmi_convert_nids[i],
+                                        nvhdmi_con_nids_7x[i],
                                         0,
                                         AC_VERB_SET_DIGI_CONVERT_2, dataDCC2);
                 }
@@ -261,28 +327,47 @@ static int nvhdmi_dig_playback_pcm_prepare_8ch(struct hda_pcm_stream *hinfo,
         return 0;
 }
 
+static int nvhdmi_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
+                                           struct hda_codec *codec,
+                                           struct snd_pcm_substream *substream)
+{
+        return 0;
+}
+
 static int nvhdmi_dig_playback_pcm_prepare_2ch(struct hda_pcm_stream *hinfo,
                                         struct hda_codec *codec,
                                         unsigned int stream_tag,
                                         unsigned int format,
                                         struct snd_pcm_substream *substream)
 {
-        struct nvhdmi_spec *spec = codec->spec;
+        struct hdmi_spec *spec = codec->spec;
         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, stream_tag,
                                         format, substream);
 }
 
-static struct hda_pcm_stream nvhdmi_pcm_digital_playback_8ch = {
+static struct hda_pcm_stream nvhdmi_pcm_digital_playback_8ch_89 = {
+        .substreams = 1,
+        .channels_min = 2,
+        .rates = SUPPORTED_RATES,
+        .maxbps = SUPPORTED_MAXBPS,
+        .formats = SUPPORTED_FORMATS,
+        .ops = {
+                .prepare = nvhdmi_dig_playback_pcm_prepare_8ch_89,
+                .cleanup = nvhdmi_playback_pcm_cleanup,
+        },
+};
+
+static struct hda_pcm_stream nvhdmi_pcm_digital_playback_8ch_7x = {
         .substreams = 1,
         .channels_min = 2,
         .channels_max = 8,
-        .nid = Nv_Master_Convert_nid,
+        .nid = nvhdmi_master_con_nid_7x,
         .rates = SUPPORTED_RATES,
         .maxbps = SUPPORTED_MAXBPS,
         .formats = SUPPORTED_FORMATS,
         .ops = {
                 .open = nvhdmi_dig_playback_pcm_open,
-                .close = nvhdmi_dig_playback_pcm_close_8ch,
+                .close = nvhdmi_dig_playback_pcm_close_8ch_7x,
                 .prepare = nvhdmi_dig_playback_pcm_prepare_8ch
         },
 };
@@ -291,7 +376,7 @@ static struct hda_pcm_stream nvhdmi_pcm_digital_playback_2ch = {
         .substreams = 1,
         .channels_min = 2,
         .channels_max = 2,
-        .nid = Nv_Master_Convert_nid,
+        .nid = nvhdmi_master_con_nid_7x,
         .rates = SUPPORTED_RATES,
         .maxbps = SUPPORTED_MAXBPS,
         .formats = SUPPORTED_FORMATS,
@@ -302,10 +387,36 @@ static struct hda_pcm_stream nvhdmi_pcm_digital_playback_2ch = {
         },
 };
 
-static int nvhdmi_build_pcms_8ch(struct hda_codec *codec)
+static int nvhdmi_build_pcms_8ch_89(struct hda_codec *codec)
+{
+        struct hdmi_spec *spec = codec->spec;
+        struct hda_pcm *info = spec->pcm_rec;
+        int i;
+
+        codec->num_pcms = spec->num_cvts;
+        codec->pcm_info = info;
+
+        for (i = 0; i < codec->num_pcms; i++, info++) {
+                unsigned int chans;
+
+                chans = get_wcaps(codec, spec->cvt[i]);
+                chans = get_wcaps_channels(chans);
+
+                info->name = nvhdmi_pcm_names[i];
+                info->pcm_type = HDA_PCM_TYPE_HDMI;
+                info->stream[SNDRV_PCM_STREAM_PLAYBACK]
+                                        = nvhdmi_pcm_digital_playback_8ch_89;
+                info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->cvt[i];
+                info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = chans;
+        }
+
+        return 0;
+}
+
+static int nvhdmi_build_pcms_8ch_7x(struct hda_codec *codec)
 {
-        struct nvhdmi_spec *spec = codec->spec;
-        struct hda_pcm *info = &spec->pcm_rec;
+        struct hdmi_spec *spec = codec->spec;
+        struct hda_pcm *info = spec->pcm_rec;
 
         codec->num_pcms = 1;
         codec->pcm_info = info;
@@ -313,15 +424,15 @@ static int nvhdmi_build_pcms_8ch(struct hda_codec *codec)
         info->name = "NVIDIA HDMI";
         info->pcm_type = HDA_PCM_TYPE_HDMI;
         info->stream[SNDRV_PCM_STREAM_PLAYBACK]
-                                        = nvhdmi_pcm_digital_playback_8ch;
+                                        = nvhdmi_pcm_digital_playback_8ch_7x;
 
         return 0;
 }
 
 static int nvhdmi_build_pcms_2ch(struct hda_codec *codec)
 {
-        struct nvhdmi_spec *spec = codec->spec;
-        struct hda_pcm *info = &spec->pcm_rec;
+        struct hdmi_spec *spec = codec->spec;
+        struct hda_pcm *info = spec->pcm_rec;
 
         codec->num_pcms = 1;
         codec->pcm_info = info;
@@ -334,14 +445,17 @@ static int nvhdmi_build_pcms_2ch(struct hda_codec *codec)
         return 0;
 }
 
-static void nvhdmi_free(struct hda_codec *codec)
-{
-        kfree(codec->spec);
-}
+static struct hda_codec_ops nvhdmi_patch_ops_8ch_89 = {
+        .build_controls = nvhdmi_build_controls,
+        .build_pcms = nvhdmi_build_pcms_8ch_89,
+        .init = nvhdmi_init,
+        .free = nvhdmi_free,
+        .unsol_event = hdmi_unsol_event,
+};
 
-static struct hda_codec_ops nvhdmi_patch_ops_8ch = {
+static struct hda_codec_ops nvhdmi_patch_ops_8ch_7x = {
         .build_controls = nvhdmi_build_controls,
-        .build_pcms = nvhdmi_build_pcms_8ch,
+        .build_pcms = nvhdmi_build_pcms_8ch_7x,
         .init = nvhdmi_init,
         .free = nvhdmi_free,
 };
@@ -353,9 +467,36 @@ static struct hda_codec_ops nvhdmi_patch_ops_2ch = {
         .free = nvhdmi_free,
 };
 
-static int patch_nvhdmi_8ch(struct hda_codec *codec)
+static int patch_nvhdmi_8ch_89(struct hda_codec *codec)
+{
+        struct hdmi_spec *spec;
+        int i;
+
+        spec = kzalloc(sizeof(*spec), GFP_KERNEL);
+        if (spec == NULL)
+                return -ENOMEM;
+
+        codec->spec = spec;
+        spec->codec_type = HDA_CODEC_NVIDIA_MCP89;
+
+        if (hdmi_parse_codec(codec) < 0) {
+                codec->spec = NULL;
+                kfree(spec);
+                return -EINVAL;
+        }
+        codec->patch_ops = nvhdmi_patch_ops_8ch_89;
+
+        for (i = 0; i < spec->num_pins; i++)
+                snd_hda_eld_proc_new(codec, &spec->sink_eld[i], i);
+
+        init_channel_allocations();
+
+        return 0;
+}
+
+static int patch_nvhdmi_8ch_7x(struct hda_codec *codec)
 {
-        struct nvhdmi_spec *spec;
+        struct hdmi_spec *spec;
 
         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
         if (spec == NULL)
@@ -365,16 +506,17 @@ static int patch_nvhdmi_8ch(struct hda_codec *codec)
 
         spec->multiout.num_dacs = 0;  /* no analog */
         spec->multiout.max_channels = 8;
-        spec->multiout.dig_out_nid = Nv_Master_Convert_nid;
+        spec->multiout.dig_out_nid = nvhdmi_master_con_nid_7x;
+        spec->codec_type = HDA_CODEC_NVIDIA_MCP7X;
 
-        codec->patch_ops = nvhdmi_patch_ops_8ch;
+        codec->patch_ops = nvhdmi_patch_ops_8ch_7x;
 
         return 0;
 }
 
 static int patch_nvhdmi_2ch(struct hda_codec *codec)
 {
-        struct nvhdmi_spec *spec;
+        struct hdmi_spec *spec;
 
         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
         if (spec == NULL)
@@ -384,7 +526,8 @@ static int patch_nvhdmi_2ch(struct hda_codec *codec)
 
         spec->multiout.num_dacs = 0;  /* no analog */
         spec->multiout.max_channels = 2;
-        spec->multiout.dig_out_nid = Nv_Master_Convert_nid;
+        spec->multiout.dig_out_nid = nvhdmi_master_con_nid_7x;
+        spec->codec_type = HDA_CODEC_NVIDIA_MCP7X;
 
         codec->patch_ops = nvhdmi_patch_ops_2ch;
 
@@ -395,11 +538,24 @@ static int patch_nvhdmi_2ch(struct hda_codec *codec)
  * patch entries
  */
 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 = 0x10de0005, .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 = 0x10de0002, .name = "MCP77/78 HDMI",
+          .patch = patch_nvhdmi_8ch_7x },
+        { .id = 0x10de0003, .name = "MCP77/78 HDMI",
+          .patch = patch_nvhdmi_8ch_7x },
+        { .id = 0x10de0005, .name = "MCP77/78 HDMI",
+          .patch = patch_nvhdmi_8ch_7x },
+        { .id = 0x10de0006, .name = "MCP77/78 HDMI",
+          .patch = patch_nvhdmi_8ch_7x },
+        { .id = 0x10de0007, .name = "MCP79/7A HDMI",
+          .patch = patch_nvhdmi_8ch_7x },
+        { .id = 0x10de000a, .name = "GT220 HDMI",
+          .patch = patch_nvhdmi_8ch_89 },
+        { .id = 0x10de000b, .name = "GT21x HDMI",
+          .patch = patch_nvhdmi_8ch_89 },
+        { .id = 0x10de000c, .name = "MCP89 HDMI",
+          .patch = patch_nvhdmi_8ch_89 },
+        { .id = 0x10de000d, .name = "GT240 HDMI",
+          .patch = patch_nvhdmi_8ch_89 },
         { .id = 0x10de0067, .name = "MCP67 HDMI", .patch = patch_nvhdmi_2ch },
         { .id = 0x10de8001, .name = "MCP73 HDMI", .patch = patch_nvhdmi_2ch },
         {} /* terminator */
@@ -410,11 +566,15 @@ MODULE_ALIAS("snd-hda-codec-id:10de0003");
 MODULE_ALIAS("snd-hda-codec-id:10de0005");
 MODULE_ALIAS("snd-hda-codec-id:10de0006");
 MODULE_ALIAS("snd-hda-codec-id:10de0007");
+MODULE_ALIAS("snd-hda-codec-id:10de000a");
+MODULE_ALIAS("snd-hda-codec-id:10de000b");
+MODULE_ALIAS("snd-hda-codec-id:10de000c");
+MODULE_ALIAS("snd-hda-codec-id:10de000d");
 MODULE_ALIAS("snd-hda-codec-id:10de0067");
 MODULE_ALIAS("snd-hda-codec-id:10de8001");
 
 MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("Nvidia HDMI HD-audio codec");
+MODULE_DESCRIPTION("NVIDIA HDMI HD-audio codec");
 
 static struct hda_codec_preset_list nvhdmi_list = {
         .preset = snd_hda_preset_nvhdmi,
diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c
index 70583719282b..886d8e46bb37 100644
--- a/sound/pci/hda/patch_realtek.c
+++ b/sound/pci/hda/patch_realtek.c
@@ -131,8 +131,10 @@ enum {
 enum {
         ALC269_BASIC,
         ALC269_QUANTA_FL1,
-        ALC269_ASUS_EEEPC_P703,
-        ALC269_ASUS_EEEPC_P901,
+        ALC269_AMIC,
+        ALC269_DMIC,
+        ALC269VB_AMIC,
+        ALC269VB_DMIC,
         ALC269_FUJITSU,
         ALC269_LIFEBOOK,
         ALC269_AUTO,
@@ -188,6 +190,8 @@ enum {
         ALC663_ASUS_MODE4,
         ALC663_ASUS_MODE5,
         ALC663_ASUS_MODE6,
+        ALC663_ASUS_MODE7,
+        ALC663_ASUS_MODE8,
         ALC272_DELL,
         ALC272_DELL_ZM1,
         ALC272_SAMSUNG_NC10,
@@ -205,9 +209,12 @@ enum {
         ALC882_ASUS_A7J,
         ALC882_ASUS_A7M,
         ALC885_MACPRO,
+        ALC885_MBA21,
         ALC885_MBP3,
         ALC885_MB5,
+        ALC885_MACMINI3,
         ALC885_IMAC24,
+        ALC885_IMAC91,
         ALC883_3ST_2ch_DIG,
         ALC883_3ST_6ch_DIG,
         ALC883_3ST_6ch,
@@ -223,6 +230,7 @@ enum {
         ALC888_ACER_ASPIRE_7730G,
         ALC883_MEDION,
         ALC883_MEDION_MD2,
+        ALC883_MEDION_WIM2160,
         ALC883_LAPTOP_EAPD,
         ALC883_LENOVO_101E_2ch,
         ALC883_LENOVO_NB0763,
@@ -334,6 +342,9 @@ struct alc_spec {
         /* hooks */
         void (*init_hook)(struct hda_codec *codec);
         void (*unsol_event)(struct hda_codec *codec, unsigned int res);
+#ifdef CONFIG_SND_HDA_POWER_SAVE
+        void (*power_hook)(struct hda_codec *codec);
+#endif
 
         /* for pin sensing */
         unsigned int sense_updated: 1;
@@ -385,6 +396,7 @@ struct alc_config_preset {
         void (*init_hook)(struct hda_codec *);
 #ifdef CONFIG_SND_HDA_POWER_SAVE
         struct hda_amp_list *loopbacks;
+        void (*power_hook)(struct hda_codec *codec);
 #endif
 };
 
@@ -400,6 +412,8 @@ static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
         unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
         if (mux_idx >= spec->num_mux_defs)
                 mux_idx = 0;
+        if (!spec->input_mux[mux_idx].num_items && mux_idx > 0)
+                mux_idx = 0;
         return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
 }
 
@@ -428,6 +442,8 @@ 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];
+        if (!imux->num_items && mux_idx > 0)
+                imux = &spec->input_mux[0];
 
         type = get_wcaps_type(get_wcaps(codec, nid));
         if (type == AC_WID_AUD_MIX) {
@@ -626,6 +642,7 @@ static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
 
 #define ALC_PIN_MODE(xname, nid, dir) \
         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
+          .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
           .info = alc_pin_mode_info, \
           .get = alc_pin_mode_get, \
           .put = alc_pin_mode_put, \
@@ -677,6 +694,7 @@ static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
 }
 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
+          .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
           .info = alc_gpio_data_info, \
           .get = alc_gpio_data_get, \
           .put = alc_gpio_data_put, \
@@ -731,6 +749,7 @@ static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
 }
 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
+          .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
           .info = alc_spdif_ctrl_info, \
           .get = alc_spdif_ctrl_get, \
           .put = alc_spdif_ctrl_put, \
@@ -784,6 +803,7 @@ static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
 
 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
+          .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
           .info = alc_eapd_ctrl_info, \
           .get = alc_eapd_ctrl_get, \
           .put = alc_eapd_ctrl_put, \
@@ -830,27 +850,6 @@ static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
         spec->init_verbs[spec->num_init_verbs++] = verb;
 }
 
-#ifdef CONFIG_PROC_FS
-/*
- * hook for proc
- */
-static void print_realtek_coef(struct snd_info_buffer *buffer,
-                               struct hda_codec *codec, hda_nid_t nid)
-{
-        int coeff;
-
-        if (nid != 0x20)
-                return;
-        coeff = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);
-        snd_iprintf(buffer, "  Processing Coefficient: 0x%02x\n", coeff);
-        coeff = snd_hda_codec_read(codec, nid, 0,
-                                   AC_VERB_GET_COEF_INDEX, 0);
-        snd_iprintf(buffer, "  Coefficient Index: 0x%02x\n", coeff);
-}
-#else
-#define print_realtek_coef      NULL
-#endif
-
 /*
  * set up from the preset table
  */
@@ -897,6 +896,7 @@ static void setup_preset(struct hda_codec *codec,
         spec->unsol_event = preset->unsol_event;
         spec->init_hook = preset->init_hook;
 #ifdef CONFIG_SND_HDA_POWER_SAVE
+        spec->power_hook = preset->power_hook;
         spec->loopback.amplist = preset->loopbacks;
 #endif
 
@@ -961,18 +961,12 @@ 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, pincap;
         unsigned int nid = spec->autocfg.hp_pins[0];
         int i;
 
         if (!nid)
                 return;
-        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;
+        spec->jack_present = snd_hda_jack_detect(codec, nid);
         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
                 nid = spec->autocfg.speaker_pins[i];
                 if (!nid)
@@ -1012,9 +1006,7 @@ static void alc_mic_automute(struct hda_codec *codec)
 
         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;
+        present = snd_hda_jack_detect(codec, spec->ext_mic.pin);
         if (present) {
                 alive = &spec->ext_mic;
                 dead = &spec->int_mic;
@@ -1093,6 +1085,16 @@ static void alc889_coef_init(struct hda_codec *codec)
         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
 }
 
+/* turn on/off EAPD control (only if available) */
+static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
+{
+        if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
+                return;
+        if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
+                snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
+                                    on ? 2 : 0);
+}
+
 static void alc_auto_init_amp(struct hda_codec *codec, int type)
 {
         unsigned int tmp;
@@ -1110,25 +1112,22 @@ static void alc_auto_init_amp(struct hda_codec *codec, int type)
         case ALC_INIT_DEFAULT:
                 switch (codec->vendor_id) {
                 case 0x10ec0260:
-                        snd_hda_codec_write(codec, 0x0f, 0,
-                                            AC_VERB_SET_EAPD_BTLENABLE, 2);
-                        snd_hda_codec_write(codec, 0x10, 0,
-                                            AC_VERB_SET_EAPD_BTLENABLE, 2);
+                        set_eapd(codec, 0x0f, 1);
+                        set_eapd(codec, 0x10, 1);
                         break;
                 case 0x10ec0262:
                 case 0x10ec0267:
                 case 0x10ec0268:
                 case 0x10ec0269:
+                case 0x10ec0270:
                 case 0x10ec0272:
                 case 0x10ec0660:
                 case 0x10ec0662:
                 case 0x10ec0663:
                 case 0x10ec0862:
                 case 0x10ec0889:
-                        snd_hda_codec_write(codec, 0x14, 0,
-                                            AC_VERB_SET_EAPD_BTLENABLE, 2);
-                        snd_hda_codec_write(codec, 0x15, 0,
-                                            AC_VERB_SET_EAPD_BTLENABLE, 2);
+                        set_eapd(codec, 0x14, 1);
+                        set_eapd(codec, 0x15, 1);
                         break;
                 }
                 switch (codec->vendor_id) {
@@ -1155,6 +1154,7 @@ static void alc_auto_init_amp(struct hda_codec *codec, int type)
                 case 0x10ec0888:
                         alc888_coef_init(codec);
                         break;
+#if 0 /* XXX: This may cause the silent output on speaker on some machines */
                 case 0x10ec0267:
                 case 0x10ec0268:
                         snd_hda_codec_write(codec, 0x20, 0,
@@ -1167,6 +1167,7 @@ static void alc_auto_init_amp(struct hda_codec *codec, int type)
                                             AC_VERB_SET_PROC_COEF,
                                             tmp | 0x3000);
                         break;
+#endif /* XXX */
                 }
                 break;
         }
@@ -1230,6 +1231,8 @@ static void alc_init_auto_mic(struct hda_codec *codec)
                         return; /* invalid entry */
                 }
         }
+        if (!ext || !fixed)
+                return;
         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",
@@ -1256,7 +1259,7 @@ static void alc_init_auto_mic(struct hda_codec *codec)
  */
 static int alc_subsystem_id(struct hda_codec *codec,
                             hda_nid_t porta, hda_nid_t porte,
-                            hda_nid_t portd)
+                            hda_nid_t portd, hda_nid_t porti)
 {
         unsigned int ass, tmp, i;
         unsigned nid;
@@ -1282,7 +1285,7 @@ static int alc_subsystem_id(struct hda_codec *codec,
         snd_printd("realtek: No valid SSID, "
                    "checking pincfg 0x%08x for NID 0x%x\n",
                    ass, nid);
-        if (!(ass & 1) && !(ass & 0x100000))
+        if (!(ass & 1))
                 return 0;
         if ((ass >> 30) != 1)   /* no physical connection */
                 return 0;
@@ -1342,6 +1345,8 @@ do_sku:
                         nid = porte;
                 else if (tmp == 2)
                         nid = portd;
+                else if (tmp == 3)
+                        nid = porti;
                 else
                         return 1;
                 for (i = 0; i < spec->autocfg.line_outs; i++)
@@ -1356,9 +1361,10 @@ do_sku:
 }
 
 static void alc_ssid_check(struct hda_codec *codec,
-                           hda_nid_t porta, hda_nid_t porte, hda_nid_t portd)
+                           hda_nid_t porta, hda_nid_t porte,
+                           hda_nid_t portd, hda_nid_t porti)
 {
-        if (!alc_subsystem_id(codec, porta, porte, portd)) {
+        if (!alc_subsystem_id(codec, porta, porte, portd, porti)) {
                 struct alc_spec *spec = codec->spec;
                 snd_printd("realtek: "
                            "Enable default setup for auto mode as fallback\n");
@@ -1384,22 +1390,42 @@ struct alc_fixup {
 
 static void alc_pick_fixup(struct hda_codec *codec,
                            const struct snd_pci_quirk *quirk,
-                           const struct alc_fixup *fix)
+                           const struct alc_fixup *fix,
+                           int pre_init)
 {
         const struct alc_pincfg *cfg;
 
         quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
         if (!quirk)
                 return;
-
         fix += quirk->value;
         cfg = fix->pins;
-        if (cfg) {
+        if (pre_init && cfg) {
+#ifdef CONFIG_SND_DEBUG_VERBOSE
+                snd_printdd(KERN_INFO "hda_codec: %s: Apply pincfg for %s\n",
+                            codec->chip_name, quirk->name);
+#endif
                 for (; cfg->nid; cfg++)
                         snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val);
         }
-        if (fix->verbs)
+        if (!pre_init && fix->verbs) {
+#ifdef CONFIG_SND_DEBUG_VERBOSE
+                snd_printdd(KERN_INFO "hda_codec: %s: Apply fix-verbs for %s\n",
+                            codec->chip_name, quirk->name);
+#endif
                 add_verb(codec->spec, fix->verbs);
+        }
+}
+
+static int alc_read_coef_idx(struct hda_codec *codec,
+                        unsigned int coef_idx)
+{
+        unsigned int val;
+        snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
+                                coef_idx);
+        val = snd_hda_codec_read(codec, 0x20, 0,
+                                AC_VERB_GET_PROC_COEF, 0);
+        return val;
 }
 
 /*
@@ -1513,7 +1539,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, pincap;
+        unsigned int mute;
         hda_nid_t nid;
         int i;
 
@@ -1522,13 +1548,7 @@ 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) {
+                if (snd_hda_jack_detect(codec, nid)) {
                         spec->jack_present = 1;
                         break;
                 }
@@ -1611,6 +1631,11 @@ static struct hda_verb alc888_acer_aspire_4930g_verbs[] = {
  */
 
 static struct hda_verb alc888_acer_aspire_6530g_verbs[] = {
+/* Route to built-in subwoofer as well as speakers */
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0c, 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)},
 /* 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) */
@@ -1622,10 +1647,12 @@ static struct hda_verb alc888_acer_aspire_6530g_verbs[] = {
 /* Enable speaker output */
         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
 /* Enable headphone output */
         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
         { }
 };
 
@@ -1665,9 +1692,6 @@ static struct hda_verb alc889_acer_aspire_8930g_verbs[] = {
 /*  some bit here disables the other DACs. Init=0x4900 */
         {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
-/* Enable amplifiers */
-        {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
-        {0x15, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
 /* DMIC fix
  * This laptop has a stereo digital microphone. The mics are only 1cm apart
  * which makes the stereo useless. However, either the mic or the ALC889
@@ -1780,12 +1804,33 @@ static struct snd_kcontrol_new alc888_base_mixer[] = {
         { } /* end */
 };
 
+static struct snd_kcontrol_new alc889_acer_aspire_8930g_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("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),
+        { } /* end */
+};
+
+
 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;
+        spec->autocfg.speaker_pins[1] = 0x16;
+        spec->autocfg.speaker_pins[2] = 0x17;
 }
 
 static void alc888_acer_aspire_6530g_setup(struct hda_codec *codec)
@@ -2401,6 +2446,8 @@ static const char *alc_slave_sws[] = {
         "Speaker Playback Switch",
         "Mono Playback Switch",
         "IEC958 Playback Switch",
+        "Line-Out Playback Switch",
+        "PCM Playback Switch",
         NULL,
 };
 
@@ -2408,20 +2455,34 @@ static const char *alc_slave_sws[] = {
  * build control elements
  */
 
+#define NID_MAPPING             (-1)
+
+#define SUBDEV_SPEAKER_         (0 << 6)
+#define SUBDEV_HP_              (1 << 6)
+#define SUBDEV_LINE_            (2 << 6)
+#define SUBDEV_SPEAKER(x)       (SUBDEV_SPEAKER_ | ((x) & 0x3f))
+#define SUBDEV_HP(x)            (SUBDEV_HP_ | ((x) & 0x3f))
+#define SUBDEV_LINE(x)          (SUBDEV_LINE_ | ((x) & 0x3f))
+
 static void alc_free_kctls(struct hda_codec *codec);
 
+#ifdef CONFIG_SND_HDA_INPUT_BEEP
 /* additional beep mixers; the actual parameters are overwritten at build */
 static struct snd_kcontrol_new alc_beep_mixer[] = {
         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
-        HDA_CODEC_MUTE("Beep Playback Switch", 0, 0, HDA_INPUT),
+        HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
         { } /* end */
 };
+#endif
 
 static int alc_build_controls(struct hda_codec *codec)
 {
         struct alc_spec *spec = codec->spec;
-        int err;
-        int i;
+        struct snd_kcontrol *kctl;
+        struct snd_kcontrol_new *knew;
+        int i, j, err;
+        unsigned int u;
+        hda_nid_t nid;
 
         for (i = 0; i < spec->num_mixers; i++) {
                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
@@ -2452,6 +2513,7 @@ static int alc_build_controls(struct hda_codec *codec)
                         return err;
         }
 
+#ifdef CONFIG_SND_HDA_INPUT_BEEP
         /* create beep controls if needed */
         if (spec->beep_amp) {
                 struct snd_kcontrol_new *knew;
@@ -2461,11 +2523,12 @@ static int alc_build_controls(struct hda_codec *codec)
                         if (!kctl)
                                 return -ENOMEM;
                         kctl->private_value = spec->beep_amp;
-                        err = snd_hda_ctl_add(codec, kctl);
+                        err = snd_hda_ctl_add(codec, 0, kctl);
                         if (err < 0)
                                 return err;
                 }
         }
+#endif
 
         /* if we have no master control, let's create it */
         if (!spec->no_analog &&
@@ -2486,7 +2549,77 @@ static int alc_build_controls(struct hda_codec *codec)
                         return err;
         }
 
+        /* assign Capture Source enums to NID */
+        kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");
+        if (!kctl)
+                kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
+        for (i = 0; kctl && i < kctl->count; i++) {
+                hda_nid_t *nids = spec->capsrc_nids;
+                if (!nids)
+                        nids = spec->adc_nids;
+                err = snd_hda_add_nid(codec, kctl, i, nids[i]);
+                if (err < 0)
+                        return err;
+        }
+        if (spec->cap_mixer) {
+                const char *kname = kctl ? kctl->id.name : NULL;
+                for (knew = spec->cap_mixer; knew->name; knew++) {
+                        if (kname && strcmp(knew->name, kname) == 0)
+                                continue;
+                        kctl = snd_hda_find_mixer_ctl(codec, knew->name);
+                        for (i = 0; kctl && i < kctl->count; i++) {
+                                err = snd_hda_add_nid(codec, kctl, i,
+                                                      spec->adc_nids[i]);
+                                if (err < 0)
+                                        return err;
+                        }
+                }
+        }
+
+        /* other nid->control mapping */
+        for (i = 0; i < spec->num_mixers; i++) {
+                for (knew = spec->mixers[i]; knew->name; knew++) {
+                        if (knew->iface != NID_MAPPING)
+                                continue;
+                        kctl = snd_hda_find_mixer_ctl(codec, knew->name);
+                        if (kctl == NULL)
+                                continue;
+                        u = knew->subdevice;
+                        for (j = 0; j < 4; j++, u >>= 8) {
+                                nid = u & 0x3f;
+                                if (nid == 0)
+                                        continue;
+                                switch (u & 0xc0) {
+                                case SUBDEV_SPEAKER_:
+                                        nid = spec->autocfg.speaker_pins[nid];
+                                        break;
+                                case SUBDEV_LINE_:
+                                        nid = spec->autocfg.line_out_pins[nid];
+                                        break;
+                                case SUBDEV_HP_:
+                                        nid = spec->autocfg.hp_pins[nid];
+                                        break;
+                                default:
+                                        continue;
+                                }
+                                err = snd_hda_add_nid(codec, kctl, 0, nid);
+                                if (err < 0)
+                                        return err;
+                        }
+                        u = knew->private_value;
+                        for (j = 0; j < 4; j++, u >>= 8) {
+                                nid = u & 0xff;
+                                if (nid == 0)
+                                        continue;
+                                err = snd_hda_add_nid(codec, kctl, 0, nid);
+                                if (err < 0)
+                                        return err;
+                        }
+                }
+        }
+
         alc_free_kctls(codec); /* no longer needed */
+
         return 0;
 }
 
@@ -2779,8 +2912,7 @@ static void alc880_uniwill_mic_automute(struct hda_codec *codec)
         unsigned int present;
         unsigned char bits;
 
-        present = snd_hda_codec_read(codec, 0x18, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
+        present = snd_hda_jack_detect(codec, 0x18);
         bits = present ? HDA_AMP_MUTE : 0;
         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
 }
@@ -3480,7 +3612,7 @@ static int alc_build_pcms(struct hda_codec *codec)
         snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
                  "%s Analog", codec->chip_name);
         info->name = spec->stream_name_analog;
-        
+
         if (spec->stream_analog_playback) {
                 if (snd_BUG_ON(!spec->multiout.dac_nids))
                         return -EINVAL;
@@ -3570,6 +3702,11 @@ static int alc_build_pcms(struct hda_codec *codec)
         return 0;
 }
 
+static inline void alc_shutup(struct hda_codec *codec)
+{
+        snd_hda_shutup_pins(codec);
+}
+
 static void alc_free_kctls(struct hda_codec *codec)
 {
         struct alc_spec *spec = codec->spec;
@@ -3590,11 +3727,48 @@ static void alc_free(struct hda_codec *codec)
         if (!spec)
                 return;
 
+        alc_shutup(codec);
         alc_free_kctls(codec);
         kfree(spec);
         snd_hda_detach_beep_device(codec);
 }
 
+#ifdef CONFIG_SND_HDA_POWER_SAVE
+static void alc_power_eapd(struct hda_codec *codec)
+{
+        /* We currently only handle front, HP */
+        switch (codec->vendor_id) {
+        case 0x10ec0260:
+                set_eapd(codec, 0x0f, 0);
+                set_eapd(codec, 0x10, 0);
+                break;
+        case 0x10ec0262:
+        case 0x10ec0267:
+        case 0x10ec0268:
+        case 0x10ec0269:
+        case 0x10ec0270:
+        case 0x10ec0272:
+        case 0x10ec0660:
+        case 0x10ec0662:
+        case 0x10ec0663:
+        case 0x10ec0862:
+        case 0x10ec0889:
+                set_eapd(codec, 0x14, 0);
+                set_eapd(codec, 0x15, 0);
+                break;
+        }
+}
+
+static int alc_suspend(struct hda_codec *codec, pm_message_t state)
+{
+        struct alc_spec *spec = codec->spec;
+        alc_shutup(codec);
+        if (spec && spec->power_hook)
+                spec->power_hook(codec);
+        return 0;
+}
+#endif
+
 #ifdef SND_HDA_NEEDS_RESUME
 static int alc_resume(struct hda_codec *codec)
 {
@@ -3617,8 +3791,10 @@ static struct hda_codec_ops alc_patch_ops = {
         .resume = alc_resume,
 #endif
 #ifdef CONFIG_SND_HDA_POWER_SAVE
+        .suspend = alc_suspend,
         .check_power_status = alc_check_power_status,
 #endif
+        .reboot_notify = alc_shutup,
 };
 
 
@@ -3775,6 +3951,7 @@ static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
 #define PIN_CTL_TEST(xname,nid) {                       \
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
                         .name = xname,                 \
+                        .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
                         .info = alc_test_pin_ctl_info, \
                         .get = alc_test_pin_ctl_get,   \
                         .put = alc_test_pin_ctl_put,   \
@@ -3784,6 +3961,7 @@ static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
 #define PIN_SRC_TEST(xname,nid) {                       \
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
                         .name = xname,                 \
+                        .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
                         .info = alc_test_pin_src_info, \
                         .get = alc_test_pin_src_get,   \
                         .put = alc_test_pin_src_put,   \
@@ -3965,7 +4143,7 @@ static struct snd_pci_quirk alc880_cfg_tbl[] = {
         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
         SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
-        SND_PCI_QUIRK(0x1734, 0x10ac, "FSC", ALC880_UNIWILL),
+        SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_F1734),
         SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
         SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
@@ -4322,10 +4500,26 @@ static int add_control(struct alc_spec *spec, int type, const char *name,
         knew->name = kstrdup(name, GFP_KERNEL);
         if (!knew->name)
                 return -ENOMEM;
+        if (get_amp_nid_(val))
+                knew->subdevice = HDA_SUBDEV_AMP_FLAG;
         knew->private_value = val;
         return 0;
 }
 
+static int add_control_with_pfx(struct alc_spec *spec, int type,
+                                const char *pfx, const char *dir,
+                                const char *sfx, unsigned long val)
+{
+        char name[32];
+        snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
+        return add_control(spec, type, name, val);
+}
+
+#define add_pb_vol_ctrl(spec, type, pfx, val) \
+        add_control_with_pfx(spec, type, pfx, "Playback", "Volume", val)
+#define add_pb_sw_ctrl(spec, type, pfx, val) \
+        add_control_with_pfx(spec, type, pfx, "Playback", "Switch", val)
+
 #define alc880_is_fixed_pin(nid)        ((nid) >= 0x14 && (nid) <= 0x17)
 #define alc880_fixed_pin_idx(nid)       ((nid) - 0x14)
 #define alc880_is_multi_pin(nid)        ((nid) >= 0x18)
@@ -4379,7 +4573,6 @@ static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
                                              const struct auto_pin_cfg *cfg)
 {
-        char name[32];
         static const char *chname[4] = {
                 "Front", "Surround", NULL /*CLFE*/, "Side"
         };
@@ -4392,26 +4585,26 @@ static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
                 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
                 if (i == 2) {
                         /* Center/LFE */
-                        err = add_control(spec, ALC_CTL_WIDGET_VOL,
-                                          "Center Playback Volume",
+                        err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
+                                              "Center",
                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
                                                               HDA_OUTPUT));
                         if (err < 0)
                                 return err;
-                        err = add_control(spec, ALC_CTL_WIDGET_VOL,
-                                          "LFE Playback Volume",
+                        err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
+                                              "LFE",
                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
                                                               HDA_OUTPUT));
                         if (err < 0)
                                 return err;
-                        err = add_control(spec, ALC_CTL_BIND_MUTE,
-                                          "Center Playback Switch",
+                        err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
+                                             "Center",
                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2,
                                                               HDA_INPUT));
                         if (err < 0)
                                 return err;
-                        err = add_control(spec, ALC_CTL_BIND_MUTE,
-                                          "LFE Playback Switch",
+                        err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
+                                             "LFE",
                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2,
                                                               HDA_INPUT));
                         if (err < 0)
@@ -4423,14 +4616,12 @@ static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
                                 pfx = "Speaker";
                         else
                                 pfx = chname[i];
-                        sprintf(name, "%s Playback Volume", pfx);
-                        err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
+                        err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
                                                               HDA_OUTPUT));
                         if (err < 0)
                                 return err;
-                        sprintf(name, "%s Playback Switch", pfx);
-                        err = add_control(spec, ALC_CTL_BIND_MUTE, name,
+                        err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2,
                                                               HDA_INPUT));
                         if (err < 0)
@@ -4446,7 +4637,6 @@ static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
 {
         hda_nid_t nid;
         int err;
-        char name[32];
 
         if (!pin)
                 return 0;
@@ -4460,21 +4650,18 @@ static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
                         spec->multiout.extra_out_nid[0] = nid;
                 /* control HP volume/switch on the output mixer amp */
                 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
-                sprintf(name, "%s Playback Volume", pfx);
-                err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
+                err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
                 if (err < 0)
                         return err;
-                sprintf(name, "%s Playback Switch", pfx);
-                err = add_control(spec, ALC_CTL_BIND_MUTE, name,
+                err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
                 if (err < 0)
                         return err;
         } else if (alc880_is_multi_pin(pin)) {
                 /* set manual connection */
                 /* we have only a switch on HP-out PIN */
-                sprintf(name, "%s Playback Switch", pfx);
-                err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
+                err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
                 if (err < 0)
                         return err;
@@ -4487,16 +4674,13 @@ static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
                             const char *ctlname,
                             int idx, hda_nid_t mix_nid)
 {
-        char name[32];
         int err;
 
-        sprintf(name, "%s Playback Volume", ctlname);
-        err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
+        err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
         if (err < 0)
                 return err;
-        sprintf(name, "%s Playback Switch", ctlname);
-        err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
+        err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
         if (err < 0)
                 return err;
@@ -4634,6 +4818,25 @@ static void alc880_auto_init_analog_input(struct hda_codec *codec)
         }
 }
 
+static void alc880_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++) {
+                unsigned int mux_idx;
+                const struct hda_input_mux *imux;
+                mux_idx = c >= spec->num_mux_defs ? 0 : c;
+                imux = &spec->input_mux[mux_idx];
+                if (!imux->num_items && mux_idx > 0)
+                        imux = &spec->input_mux[0];
+                if (imux)
+                        snd_hda_codec_write(codec, spec->adc_nids[c], 0,
+                                            AC_VERB_SET_CONNECT_SEL,
+                                            imux->items[0].index);
+        }
+}
+
 /* parse the BIOS configuration and set up the alc_spec */
 /* return 1 if successful, 0 if the proper config is not found,
  * or a negative error code
@@ -4700,7 +4903,7 @@ static int alc880_parse_auto_config(struct hda_codec *codec)
         spec->num_mux_defs = 1;
         spec->input_mux = &spec->private_imux[0];
 
-        alc_ssid_check(codec, 0x15, 0x1b, 0x14);
+        alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
 
         return 1;
 }
@@ -4712,6 +4915,7 @@ static void alc880_auto_init(struct hda_codec *codec)
         alc880_auto_init_multi_out(codec);
         alc880_auto_init_extra_out(codec);
         alc880_auto_init_analog_input(codec);
+        alc880_auto_init_input_src(codec);
         if (spec->unsol_event)
                 alc_inithook(codec);
 }
@@ -4749,6 +4953,49 @@ static void fixup_automic_adc(struct hda_codec *codec)
         spec->auto_mic = 0; /* disable auto-mic to be sure */
 }
 
+/* choose the ADC/MUX containing the input pin and initialize the setup */
+static void fixup_single_adc(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+        hda_nid_t pin = 0;
+        int i;
+
+        /* search for the input pin; there must be only one */
+        for (i = 0; i < AUTO_PIN_LAST; i++) {
+                if (spec->autocfg.input_pins[i]) {
+                        pin = spec->autocfg.input_pins[i];
+                        break;
+                }
+        }
+        if (!pin)
+                return;
+
+        /* set the default connection to that pin */
+        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 idx;
+
+                idx = get_connection_index(codec, cap, pin);
+                if (idx < 0)
+                        continue;
+                /* use only this ADC */
+                if (spec->capsrc_nids)
+                        spec->capsrc_nids += i;
+                spec->adc_nids += i;
+                spec->num_adc_nids = 1;
+                /* select or unmute this route */
+                if (get_wcaps_type(get_wcaps(codec, cap)) == AC_WID_AUD_MIX) {
+                        snd_hda_codec_amp_stereo(codec, cap, HDA_INPUT, idx,
+                                                 HDA_AMP_MUTE, 0);
+                } else {
+                        snd_hda_codec_write_cache(codec, cap, 0,
+                                          AC_VERB_SET_CONNECT_SEL, idx);
+                }
+                return;
+        }
+}
+
 static void set_capture_mixer(struct hda_codec *codec)
 {
         struct alc_spec *spec = codec->spec;
@@ -4761,20 +5008,89 @@ static void set_capture_mixer(struct hda_codec *codec)
                   alc_capture_mixer3 },
         };
         if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) {
-                int mux;
-                if (spec->auto_mic) {
-                        mux = 0;
+                int mux = 0;
+                if (spec->auto_mic)
                         fixup_automic_adc(codec);
-                } else if (spec->input_mux && spec->input_mux->num_items > 1)
-                        mux = 1;
-                else
-                        mux = 0;
+                else if (spec->input_mux) {
+                        if (spec->input_mux->num_items > 1)
+                                mux = 1;
+                        else if (spec->input_mux->num_items == 1)
+                                fixup_single_adc(codec);
+                }
                 spec->cap_mixer = caps[mux][spec->num_adc_nids - 1];
         }
 }
 
+/* fill adc_nids (and capsrc_nids) containing all active input pins */
+static void fillup_priv_adc_nids(struct hda_codec *codec, hda_nid_t *nids,
+                                 int num_nids)
+{
+        struct alc_spec *spec = codec->spec;
+        int n;
+        hda_nid_t fallback_adc = 0, fallback_cap = 0;
+
+        for (n = 0; n < num_nids; n++) {
+                hda_nid_t adc, cap;
+                hda_nid_t conn[HDA_MAX_NUM_INPUTS];
+                int nconns, i, j;
+
+                adc = nids[n];
+                if (get_wcaps_type(get_wcaps(codec, adc)) != AC_WID_AUD_IN)
+                        continue;
+                cap = adc;
+                nconns = snd_hda_get_connections(codec, cap, conn,
+                                                 ARRAY_SIZE(conn));
+                if (nconns == 1) {
+                        cap = conn[0];
+                        nconns = snd_hda_get_connections(codec, cap, conn,
+                                                         ARRAY_SIZE(conn));
+                }
+                if (nconns <= 0)
+                        continue;
+                if (!fallback_adc) {
+                        fallback_adc = adc;
+                        fallback_cap = cap;
+                }
+                for (i = 0; i < AUTO_PIN_LAST; i++) {
+                        hda_nid_t nid = spec->autocfg.input_pins[i];
+                        if (!nid)
+                                continue;
+                        for (j = 0; j < nconns; j++) {
+                                if (conn[j] == nid)
+                                        break;
+                        }
+                        if (j >= nconns)
+                                break;
+                }
+                if (i >= AUTO_PIN_LAST) {
+                        int num_adcs = spec->num_adc_nids;
+                        spec->private_adc_nids[num_adcs] = adc;
+                        spec->private_capsrc_nids[num_adcs] = cap;
+                        spec->num_adc_nids++;
+                        spec->adc_nids = spec->private_adc_nids;
+                        if (adc != cap)
+                                spec->capsrc_nids = spec->private_capsrc_nids;
+                }
+        }
+        if (!spec->num_adc_nids) {
+                printk(KERN_WARNING "hda_codec: %s: no valid ADC found;"
+                       " using fallback 0x%x\n",
+                       codec->chip_name, fallback_adc);
+                spec->private_adc_nids[0] = fallback_adc;
+                spec->adc_nids = spec->private_adc_nids;
+                if (fallback_adc != fallback_cap) {
+                        spec->private_capsrc_nids[0] = fallback_cap;
+                        spec->capsrc_nids = spec->private_adc_nids;
+                }
+        }
+}
+
+#ifdef CONFIG_SND_HDA_INPUT_BEEP
 #define set_beep_amp(spec, nid, idx, dir) \
         ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
+#else
+#define set_beep_amp(spec, nid, idx, dir) /* NOP */
+#endif
 
 /*
  * OK, here we have finally the patch for ALC880
@@ -4856,7 +5172,6 @@ static int patch_alc880(struct hda_codec *codec)
         if (!spec->loopback.amplist)
                 spec->loopback.amplist = alc880_loopbacks;
 #endif
-        codec->proc_widget_hook = print_realtek_coef;
 
         return 0;
 }
@@ -5064,6 +5379,7 @@ static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
                 .name = "Master Playback Switch",
+                .subdevice = HDA_SUBDEV_NID_FLAG | 0x11,
                 .info = snd_ctl_boolean_mono_info,
                 .get = alc260_hp_master_sw_get,
                 .put = alc260_hp_master_sw_put,
@@ -5087,11 +5403,8 @@ static struct hda_verb alc260_hp_unsol_verbs[] = {
 static void alc260_hp_automute(struct hda_codec *codec)
 {
         struct alc_spec *spec = codec->spec;
-        unsigned int present;
 
-        present = snd_hda_codec_read(codec, 0x10, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0);
-        spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
+        spec->jack_present = snd_hda_jack_detect(codec, 0x10);
         alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
 }
 
@@ -5105,6 +5418,7 @@ static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
                 .name = "Master Playback Switch",
+                .subdevice = HDA_SUBDEV_NID_FLAG | 0x11,
                 .info = snd_ctl_boolean_mono_info,
                 .get = alc260_hp_master_sw_get,
                 .put = alc260_hp_master_sw_put,
@@ -5156,11 +5470,8 @@ static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
 static void alc260_hp_3013_automute(struct hda_codec *codec)
 {
         struct alc_spec *spec = codec->spec;
-        unsigned int present;
 
-        present = snd_hda_codec_read(codec, 0x15, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0);
-        spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
+        spec->jack_present = snd_hda_jack_detect(codec, 0x15);
         alc260_hp_master_update(codec, 0x15, 0x10, 0x11);
 }
 
@@ -5173,12 +5484,8 @@ static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
 
 static void alc260_hp_3012_automute(struct hda_codec *codec)
 {
-        unsigned int present, bits;
+        unsigned int bits = snd_hda_jack_detect(codec, 0x10) ? 0 : PIN_OUT;
 
-        present = snd_hda_codec_read(codec, 0x10, 0,
-                        AC_VERB_GET_PIN_SENSE, 0) & AC_PINSENSE_PRESENCE;
-
-        bits = present ? 0 : PIN_OUT;
         snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
                             bits);
         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
@@ -5748,8 +6055,7 @@ static void alc260_replacer_672v_automute(struct hda_codec *codec)
         unsigned int present;
 
         /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
-        present = snd_hda_codec_read(codec, 0x0f, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
+        present = snd_hda_jack_detect(codec, 0x0f);
         if (present) {
                 snd_hda_codec_write_cache(codec, 0x01, 0,
                                           AC_VERB_SET_GPIO_DATA, 1);
@@ -5989,7 +6295,6 @@ static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
 {
         hda_nid_t nid_vol;
         unsigned long vol_val, sw_val;
-        char name[32];
         int err;
 
         if (nid >= 0x0f && nid < 0x11) {
@@ -6009,14 +6314,12 @@ static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
 
         if (!(*vol_bits & (1 << nid_vol))) {
                 /* first control for the volume widget */
-                snprintf(name, sizeof(name), "%s Playback Volume", pfx);
-                err = add_control(spec, ALC_CTL_WIDGET_VOL, name, vol_val);
+                err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, vol_val);
                 if (err < 0)
                         return err;
                 *vol_bits |= (1 << nid_vol);
         }
-        snprintf(name, sizeof(name), "%s Playback Switch", pfx);
-        err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, sw_val);
+        err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, sw_val);
         if (err < 0)
                 return err;
         return 1;
@@ -6124,6 +6427,8 @@ static void alc260_auto_init_analog_input(struct hda_codec *codec)
         }
 }
 
+#define alc260_auto_init_input_src      alc880_auto_init_input_src
+
 /*
  * generic initialization of ADC, input mixers and output mixers
  */
@@ -6199,7 +6504,7 @@ static int alc260_parse_auto_config(struct hda_codec *codec)
         spec->num_mux_defs = 1;
         spec->input_mux = &spec->private_imux[0];
 
-        alc_ssid_check(codec, 0x10, 0x15, 0x0f);
+        alc_ssid_check(codec, 0x10, 0x15, 0x0f, 0);
 
         return 1;
 }
@@ -6210,6 +6515,7 @@ static void alc260_auto_init(struct hda_codec *codec)
         struct alc_spec *spec = codec->spec;
         alc260_auto_init_multi_out(codec);
         alc260_auto_init_analog_input(codec);
+        alc260_auto_init_input_src(codec);
         if (spec->unsol_event)
                 alc_inithook(codec);
 }
@@ -6246,6 +6552,7 @@ static const char *alc260_models[ALC260_MODEL_LAST] = {
 
 static struct snd_pci_quirk alc260_cfg_tbl[] = {
         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
+        SND_PCI_QUIRK(0x1025, 0x007f, "Acer", ALC260_WILL),
         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
         SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FAVORIT100),
         SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
@@ -6275,7 +6582,7 @@ static struct alc_config_preset alc260_presets[] = {
                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
                 .dac_nids = alc260_dac_nids,
                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
-                .adc_nids = alc260_adc_nids,
+                .adc_nids = alc260_dual_adc_nids,
                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
                 .channel_mode = alc260_modes,
                 .input_mux = &alc260_capture_source,
@@ -6477,7 +6784,6 @@ static int patch_alc260(struct hda_codec *codec)
         if (!spec->loopback.amplist)
                 spec->loopback.amplist = alc260_loopbacks;
 #endif
-        codec->proc_widget_hook = print_realtek_coef;
 
         return 0;
 }
@@ -6559,6 +6865,14 @@ static struct hda_input_mux mb5_capture_source = {
         },
 };
 
+static struct hda_input_mux macmini3_capture_source = {
+        .num_items = 2,
+        .items = {
+                { "Line", 0x2 },
+                { "CD", 0x4 },
+        },
+};
+
 static struct hda_input_mux alc883_3stack_6ch_intel = {
         .num_items = 4,
         .items = {
@@ -6619,7 +6933,7 @@ static struct hda_input_mux alc889A_mb31_capture_source = {
                 /* Front Mic (0x01) unused */
                 { "Line", 0x2 },
                 /* Line 2 (0x03) unused */
-                /* CD (0x04) unsused? */
+                /* CD (0x04) unused? */
         },
 };
 
@@ -6747,6 +7061,13 @@ static struct hda_channel_mode alc882_sixstack_modes[2] = {
         { 8, alc882_sixstack_ch8_init },
 };
 
+
+/* Macbook Air 2,1 */
+
+static struct hda_channel_mode alc885_mba21_ch_modes[1] = {
+      { 2, NULL },
+};
+
 /*
  * macbook pro ALC885 can switch LineIn to LineOut without losing Mic
  */
@@ -6807,6 +7128,7 @@ static struct hda_channel_mode alc885_mb5_6ch_modes[2] = {
         { 6, alc885_mb5_ch6_init },
 };
 
+#define alc885_macmini3_6ch_modes       alc885_mb5_6ch_modes
 
 /*
  * 2ch mode
@@ -7018,6 +7340,15 @@ static struct snd_kcontrol_new alc882_base_mixer[] = {
         { } /* end */
 };
 
+/* Macbook Air 2,1 same control for HP and internal Speaker */
+
+static struct snd_kcontrol_new alc885_mba21_mixer[] = {
+      HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
+      HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 0x02, HDA_OUTPUT),
+     { }
+};
+
+
 static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
         HDA_BIND_MUTE   ("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT),
@@ -7040,8 +7371,8 @@ static struct snd_kcontrol_new alc885_mb5_mixer[] = {
         HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
         HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
-        HDA_CODEC_VOLUME("HP Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
-        HDA_BIND_MUTE   ("HP Playback Switch", 0x0f, 0x02, HDA_INPUT),
+        HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
+        HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT),
         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
@@ -7051,6 +7382,35 @@ static struct snd_kcontrol_new alc885_mb5_mixer[] = {
         { } /* end */
 };
 
+static struct snd_kcontrol_new alc885_macmini3_mixer[] = {
+        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
+        HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
+        HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
+        HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
+        HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
+        HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
+        HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
+        HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT),
+        HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x07, HDA_INPUT),
+        HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x07, HDA_INPUT),
+        HDA_CODEC_VOLUME("Line Boost", 0x15, 0x00, HDA_INPUT),
+        { } /* end */
+};
+
+static struct snd_kcontrol_new alc885_imac91_mixer[] = {
+        HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
+        HDA_BIND_MUTE   ("Line-Out Playback Switch", 0x0c, 0x02, HDA_INPUT),
+        HDA_CODEC_MUTE  ("Speaker Playback Switch", 0x14, 0x00, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Speaker 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),
+        HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
+        { } /* end */
+};
+
+
 static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
@@ -7128,29 +7488,18 @@ static struct snd_kcontrol_new alc882_chmode_mixer[] = {
 
 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)},
         {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},
@@ -7187,14 +7536,8 @@ static struct hda_verb alc882_base_init_verbs[] = {
         /* 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(3)},
-        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
-        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
         /* Input mixer3 */
         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
-        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
-        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
         /* ADC2: mute amp left and right */
         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
@@ -7238,26 +7581,17 @@ static struct hda_verb alc_hp15_unsol_verbs[] = {
 
 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)},
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(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)},
+        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(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)},
+        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(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)},
+        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
 
         /* Front HP Pin: output 0 (0x0c) */
         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
@@ -7291,17 +7625,11 @@ static struct hda_verb alc885_init_verbs[] = {
 
         /* 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)},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
         /* 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)},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
         /* ADC2: mute amp left and right */
         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
         /* ADC3: mute amp left and right */
@@ -7336,8 +7664,8 @@ static struct snd_kcontrol_new alc882_macpro_mixer[] = {
         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
         /* FIXME: this looks suspicious...
-        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x02, HDA_INPUT),
-        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x02, HDA_INPUT),
+        HDA_CODEC_VOLUME("Beep Playback Volume", 0x0b, 0x02, HDA_INPUT),
+        HDA_CODEC_MUTE("Beep Playback Switch", 0x0b, 0x02, HDA_INPUT),
         */
         { } /* end */
 };
@@ -7428,6 +7756,7 @@ static struct hda_verb alc885_mb5_init_verbs[] = {
         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
         {0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
+        {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
         /* 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},
@@ -7442,6 +7771,76 @@ static struct hda_verb alc885_mb5_init_verbs[] = {
         { }
 };
 
+/* Macmini 3,1 */
+static struct hda_verb alc885_macmini3_init_verbs[] = {
+        /* DACs */
+        {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        /* Front mixer */
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        /* Surround mixer */
+        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        /* LFE mixer */
+        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        /* HP mixer */
+        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        /* Front Pin (0x0c) */
+        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
+        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
+        /* LFE Pin (0x0e) */
+        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
+        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
+        /* HP Pin (0x0f) */
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
+        {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
+        /* Line In pin */
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
+        { }
+};
+
+
+static struct hda_verb alc885_mba21_init_verbs[] = {
+        /*Internal and HP Speaker Mixer*/
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        /*Internal Speaker Pin (0x0c)*/
+        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
+        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
+        /* HP Pin: output 0 (0x0e) */
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, (ALC880_HP_EVENT | AC_USRSP_EN)},
+        /* Line in (is hp when jack connected)*/
+        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_VREF_50},
+        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+
+        { }
+ };
+
+
 /* Macbook Pro rev3 */
 static struct hda_verb alc885_mbp3_init_verbs[] = {
         /* Front mixer: unmute input/output amp left and right (volume = 0) */
@@ -7506,6 +7905,66 @@ static struct hda_verb alc885_mbp3_init_verbs[] = {
         { }
 };
 
+/* iMac 9,1 */
+static struct hda_verb alc885_imac91_init_verbs[] = {
+        /* Line-Out 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)},
+        /* HP Pin: output 0 (0x0c) */
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
+        /* Internal Speakers: output 0 (0x0d) */
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
+        /* 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: use output 1 when in LineOut mode */
+        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
+
+        /* FIXME: use matrix-type input source selection */
+        /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
+        /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
+        /* Input mixer2 */
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
+        /* Input mixer3 */
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
+        /* ADC1: mute amp left and right */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
+        /* ADC2: mute amp left and right */
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
+        /* ADC3: mute amp left and right */
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
+
+        { }
+};
+
 /* iMac 24 mixer. */
 static struct snd_kcontrol_new alc885_imac24_mixer[] = {
         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
@@ -7544,6 +8003,20 @@ static void alc885_imac24_setup(struct hda_codec *codec)
         spec->autocfg.speaker_pins[1] = 0x1a;
 }
 
+#define alc885_mb5_setup        alc885_imac24_setup
+#define alc885_macmini3_setup   alc885_imac24_setup
+
+/* Macbook Air 2,1 */
+static void alc885_mba21_setup(struct hda_codec *codec)
+{
+       struct alc_spec *spec = codec->spec;
+
+       spec->autocfg.hp_pins[0] = 0x14;
+       spec->autocfg.speaker_pins[0] = 0x18;
+}
+
+
+
 static void alc885_mbp3_setup(struct hda_codec *codec)
 {
         struct alc_spec *spec = codec->spec;
@@ -7552,6 +8025,14 @@ static void alc885_mbp3_setup(struct hda_codec *codec)
         spec->autocfg.speaker_pins[0] = 0x14;
 }
 
+static void alc885_imac91_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] = 0x1a;
+}
 
 static struct hda_verb alc882_targa_verbs[] = {
         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
@@ -7685,18 +8166,6 @@ static struct hda_verb alc883_auto_init_verbs[] = {
         {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)
          */
@@ -7721,16 +8190,9 @@ static struct hda_verb alc883_auto_init_verbs[] = {
         /* 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, (0x7000 | (0x00 << 8))},
-        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
-        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
-        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
+        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
         /* Input mixer3 */
-        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
-        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
-        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
-        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
-
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
         { }
 };
 
@@ -8026,6 +8488,42 @@ static struct snd_kcontrol_new alc883_medion_md2_mixer[] = {
         { } /* end */
 };
 
+static struct snd_kcontrol_new alc883_medion_wim2160_mixer[] = {
+        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
+        HDA_CODEC_MUTE("Speaker Playback Switch", 0x15, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Line Playback Volume", 0x08, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Line Playback Switch", 0x08, 0x0, HDA_INPUT),
+        { } /* end */
+};
+
+static struct hda_verb alc883_medion_wim2160_verbs[] = {
+        /* Unmute front mixer */
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+
+        /* Set speaker pin to front mixer */
+        {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
+
+        /* Init headphone pin */
+        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
+
+        { } /* end */
+};
+
+/* toggle speaker-output according to the hp-jack state */
+static void alc883_medion_wim2160_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        spec->autocfg.hp_pins[0] = 0x1a;
+        spec->autocfg.speaker_pins[0] = 0x15;
+}
+
 static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
@@ -8040,9 +8538,7 @@ static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
 
 static struct snd_kcontrol_new alc888_acer_aspire_6530_mixer[] = {
         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
-        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
-        HDA_BIND_MUTE("LFE Playback Switch", 0x0f, 2, HDA_INPUT),
         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
@@ -8184,12 +8680,8 @@ static void alc883_mitac_setup(struct hda_codec *codec)
 /*
 static void alc883_mitac_mic_automute(struct hda_codec *codec)
 {
-        unsigned int present;
-        unsigned char bits;
+        unsigned char bits = snd_hda_jack_detect(codec, 0x18) ? HDA_AMP_MUTE : 0;
 
-        present = snd_hda_codec_read(codec, 0x18, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-        bits = present ? HDA_AMP_MUTE : 0;
         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
 }
 */
@@ -8411,10 +8903,8 @@ static struct hda_channel_mode alc888_3st_hp_modes[3] = {
 /* toggle front-jack and RCA according to the hp-jack state */
 static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
 {
-        unsigned int present;
+        unsigned int present = snd_hda_jack_detect(codec, 0x1b);
 
-        present = snd_hda_codec_read(codec, 0x1b, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
@@ -8424,10 +8914,8 @@ static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
 /* toggle RCA according to the front-jack state */
 static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
 {
-        unsigned int present;
+        unsigned int present = snd_hda_jack_detect(codec, 0x14);
 
-        present = snd_hda_codec_read(codec, 0x14, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
 }
@@ -8468,8 +8956,7 @@ static void alc883_clevo_m720_mic_automute(struct hda_codec *codec)
 {
         unsigned int present;
 
-        present = snd_hda_codec_read(codec, 0x18, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
+        present = snd_hda_jack_detect(codec, 0x18);
         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
 }
@@ -8520,24 +9007,16 @@ static void alc883_haier_w66_setup(struct hda_codec *codec)
 
 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
 {
-        unsigned int present;
-        unsigned char bits;
+        int bits = snd_hda_jack_detect(codec, 0x14) ? HDA_AMP_MUTE : 0;
 
-        present = snd_hda_codec_read(codec, 0x14, 0, AC_VERB_GET_PIN_SENSE, 0)
-                & AC_PINSENSE_PRESENCE;
-        bits = present ? HDA_AMP_MUTE : 0;
         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
                                  HDA_AMP_MUTE, bits);
 }
 
 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
 {
-        unsigned int present;
-        unsigned char bits;
+        int bits = snd_hda_jack_detect(codec, 0x1b) ? HDA_AMP_MUTE : 0;
 
-        present = snd_hda_codec_read(codec, 0x1b, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-        bits = present ? HDA_AMP_MUTE : 0;
         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
                                  HDA_AMP_MUTE, bits);
         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
@@ -8688,8 +9167,7 @@ static void alc889A_mb31_automute(struct hda_codec *codec)
         /* Mute only in 2ch or 4ch mode */
         if (snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_CONNECT_SEL, 0)
             == 0x00) {
-                present = snd_hda_codec_read(codec, 0x15, 0,
-                        AC_VERB_GET_PIN_SENSE, 0) & AC_PINSENSE_PRESENCE;
+                present = snd_hda_jack_detect(codec, 0x15);
                 snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
@@ -8735,8 +9213,11 @@ static const char *alc882_models[ALC882_MODEL_LAST] = {
         [ALC882_ASUS_A7M]       = "asus-a7m",
         [ALC885_MACPRO]         = "macpro",
         [ALC885_MB5]            = "mb5",
+        [ALC885_MACMINI3]       = "macmini3",
+        [ALC885_MBA21]          = "mba21",
         [ALC885_MBP3]           = "mbp3",
         [ALC885_IMAC24]         = "imac24",
+        [ALC885_IMAC91]         = "imac91",
         [ALC883_3ST_2ch_DIG]    = "3stack-2ch-dig",
         [ALC883_3ST_6ch_DIG]    = "3stack-6ch-dig",
         [ALC883_3ST_6ch]        = "3stack-6ch",
@@ -8752,6 +9233,7 @@ static const char *alc882_models[ALC882_MODEL_LAST] = {
         [ALC888_ACER_ASPIRE_7730G]      = "acer-aspire-7730g",
         [ALC883_MEDION]         = "medion",
         [ALC883_MEDION_MD2]     = "medion-md2",
+        [ALC883_MEDION_WIM2160] = "medion-wim2160",
         [ALC883_LAPTOP_EAPD]    = "laptop-eapd",
         [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
         [ALC883_LENOVO_NB0763]  = "lenovo-nb0763",
@@ -8839,7 +9321,7 @@ static struct snd_pci_quirk alc882_cfg_tbl[] = {
         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, 0x2fb3, "MSI", ALC882_AUTO),
         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),
@@ -8853,6 +9335,7 @@ static struct snd_pci_quirk alc882_cfg_tbl[] = {
         SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
         SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
         SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
+        SND_PCI_QUIRK(0x1462, 0x4570, "MSI Wind Top AE2220", ALC883_TARGA_DIG),
         SND_PCI_QUIRK(0x1462, 0x6510, "MSI GX620", ALC883_TARGA_8ch_DIG),
         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
         SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
@@ -8862,10 +9345,12 @@ static struct snd_pci_quirk alc882_cfg_tbl[] = {
         SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
         SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
         SND_PCI_QUIRK(0x1462, 0x7350, "MSI", ALC883_6ST_DIG),
+        SND_PCI_QUIRK(0x1462, 0x7437, "MSI NetOn AP1900", ALC883_TARGA_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, 0x0571, "Clevo laptop M570U", ALC883_3ST_6ch_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),
@@ -8893,7 +9378,7 @@ static struct snd_pci_quirk alc882_cfg_tbl[] = {
         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(0x8086, 0xd601, "D102GGC", ALC882_6ST_DIG),
 
         {}
 };
@@ -8910,12 +9395,14 @@ static struct snd_pci_quirk alc882_ssid_cfg_tbl[] = {
         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, 0x4900, "iMac 9,1 Aluminum", ALC885_IMAC91),
         SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC885_MB5),
         /* FIXME: HP jack sense seems not working for MBP 5,1 or 5,2,
          * so apparently no perfect solution yet
          */
         SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC885_MB5),
         SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC885_MB5),
+        SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC885_MACMINI3),
         {} /* terminator */
 };
 
@@ -8967,6 +9454,18 @@ static struct alc_config_preset alc882_presets[] = {
                 .input_mux = &alc882_capture_source,
                 .dig_out_nid = ALC882_DIGOUT_NID,
         },
+           [ALC885_MBA21] = {
+                        .mixers = { alc885_mba21_mixer },
+                        .init_verbs = { alc885_mba21_init_verbs, alc880_gpio1_init_verbs },
+                        .num_dacs = 2,
+                        .dac_nids = alc882_dac_nids,
+                        .channel_mode = alc885_mba21_ch_modes,
+                        .num_channel_mode = ARRAY_SIZE(alc885_mba21_ch_modes),
+                        .input_mux = &alc882_capture_source,
+                        .unsol_event = alc_automute_amp_unsol_event,
+                        .setup = alc885_mba21_setup,
+                        .init_hook = alc_automute_amp,
+       },
         [ALC885_MBP3] = {
                 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
                 .init_verbs = { alc885_mbp3_init_verbs,
@@ -8994,6 +9493,24 @@ static struct alc_config_preset alc882_presets[] = {
                 .input_mux = &mb5_capture_source,
                 .dig_out_nid = ALC882_DIGOUT_NID,
                 .dig_in_nid = ALC882_DIGIN_NID,
+                .unsol_event = alc_automute_amp_unsol_event,
+                .setup = alc885_mb5_setup,
+                .init_hook = alc_automute_amp,
+        },
+        [ALC885_MACMINI3] = {
+                .mixers = { alc885_macmini3_mixer, alc882_chmode_mixer },
+                .init_verbs = { alc885_macmini3_init_verbs,
+                                alc880_gpio1_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc882_dac_nids),
+                .dac_nids = alc882_dac_nids,
+                .channel_mode = alc885_macmini3_6ch_modes,
+                .num_channel_mode = ARRAY_SIZE(alc885_macmini3_6ch_modes),
+                .input_mux = &macmini3_capture_source,
+                .dig_out_nid = ALC882_DIGOUT_NID,
+                .dig_in_nid = ALC882_DIGIN_NID,
+                .unsol_event = alc_automute_amp_unsol_event,
+                .setup = alc885_macmini3_setup,
+                .init_hook = alc_automute_amp,
         },
         [ALC885_MACPRO] = {
                 .mixers = { alc882_macpro_mixer },
@@ -9021,6 +9538,21 @@ static struct alc_config_preset alc882_presets[] = {
                 .setup = alc885_imac24_setup,
                 .init_hook = alc885_imac24_init_hook,
         },
+        [ALC885_IMAC91] = {
+                .mixers = { alc885_imac91_mixer, alc882_chmode_mixer },
+                .init_verbs = { alc885_imac91_init_verbs,
+                                alc880_gpio1_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc882_dac_nids),
+                .dac_nids = alc882_dac_nids,
+                .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_imac91_setup,
+                .init_hook = alc_automute_amp,
+        },
         [ALC882_TARGA] = {
                 .mixers = { alc882_targa_mixer, alc882_chmode_mixer },
                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
@@ -9187,6 +9719,7 @@ static struct alc_config_preset alc882_presets[] = {
                 .dac_nids = alc883_dac_nids,
                 .adc_nids = alc883_adc_nids_alt,
                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
+                .capsrc_nids = alc883_capsrc_nids,
                 .dig_out_nid = ALC883_DIGOUT_NID,
                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
                 .channel_mode = alc883_3ST_2ch_modes,
@@ -9256,6 +9789,7 @@ static struct alc_config_preset alc882_presets[] = {
                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
                 .channel_mode = alc883_3ST_6ch_modes,
                 .need_dac_fix = 1,
+                .const_channel_count = 6,
                 .num_mux_defs =
                         ARRAY_SIZE(alc888_2_capture_sources),
                 .input_mux = alc888_2_capture_sources,
@@ -9283,10 +9817,11 @@ static struct alc_config_preset alc882_presets[] = {
                 .init_hook = alc_automute_amp,
         },
         [ALC888_ACER_ASPIRE_8930G] = {
-                .mixers = { alc888_base_mixer,
+                .mixers = { alc889_acer_aspire_8930g_mixer,
                                 alc883_chmode_mixer },
                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
-                                alc889_acer_aspire_8930g_verbs },
+                                alc889_acer_aspire_8930g_verbs,
+                                alc889_eapd_verbs},
                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
                 .dac_nids = alc883_dac_nids,
                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
@@ -9303,6 +9838,9 @@ static struct alc_config_preset alc882_presets[] = {
                 .unsol_event = alc_automute_amp_unsol_event,
                 .setup = alc889_acer_aspire_8930g_setup,
                 .init_hook = alc_automute_amp,
+#ifdef CONFIG_SND_HDA_POWER_SAVE
+                .power_hook = alc_power_eapd,
+#endif
         },
         [ALC888_ACER_ASPIRE_7730G] = {
                 .mixers = { alc883_3ST_6ch_mixer,
@@ -9333,6 +9871,7 @@ static struct alc_config_preset alc882_presets[] = {
                 .dac_nids = alc883_dac_nids,
                 .adc_nids = alc883_adc_nids_alt,
                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
+                .capsrc_nids = alc883_capsrc_nids,
                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
                 .channel_mode = alc883_sixstack_modes,
                 .input_mux = &alc883_capture_source,
@@ -9350,6 +9889,21 @@ static struct alc_config_preset alc882_presets[] = {
                 .setup = alc883_medion_md2_setup,
                 .init_hook = alc_automute_amp,
         },
+        [ALC883_MEDION_WIM2160] = {
+                .mixers = { alc883_medion_wim2160_mixer },
+                .init_verbs = { alc883_init_verbs, alc883_medion_wim2160_verbs },
+                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
+                .dac_nids = alc883_dac_nids,
+                .dig_out_nid = ALC883_DIGOUT_NID,
+                .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
+                .adc_nids = alc883_adc_nids,
+                .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
+                .channel_mode = alc883_3ST_2ch_modes,
+                .input_mux = &alc883_capture_source,
+                .unsol_event = alc_automute_amp_unsol_event,
+                .setup = alc883_medion_wim2160_setup,
+                .init_hook = alc_automute_amp,
+        },
         [ALC883_LAPTOP_EAPD] = {
                 .mixers = { alc883_base_mixer },
                 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
@@ -9394,6 +9948,7 @@ static struct alc_config_preset alc882_presets[] = {
                 .dac_nids = alc883_dac_nids,
                 .adc_nids = alc883_adc_nids_alt,
                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
+                .capsrc_nids = alc883_capsrc_nids,
                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
                 .channel_mode = alc883_3ST_2ch_modes,
                 .input_mux = &alc883_lenovo_101e_capture_source,
@@ -9573,6 +10128,7 @@ static struct alc_config_preset alc882_presets[] = {
                         alc880_gpio1_init_verbs },
                 .adc_nids = alc883_adc_nids,
                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
+                .capsrc_nids = alc883_capsrc_nids,
                 .dac_nids = alc883_dac_nids,
                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
                 .channel_mode = alc889A_mb31_6ch_modes,
@@ -9640,6 +10196,8 @@ static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
         int idx;
 
         alc_set_pin_output(codec, nid, pin_type);
+        if (dac_idx >= spec->multiout.num_dacs)
+                return;
         if (spec->multiout.dac_nids[dac_idx] == 0x25)
                 idx = 4;
         else
@@ -9711,6 +10269,8 @@ static void alc882_auto_init_input_src(struct hda_codec *codec)
                         continue;
                 mux_idx = c >= spec->num_mux_defs ? 0 : c;
                 imux = &spec->input_mux[mux_idx];
+                if (!imux->num_items && mux_idx > 0)
+                        imux = &spec->input_mux[0];
                 for (idx = 0; idx < conns; idx++) {
                         /* if the current connection is the selected one,
                          * unmute it as default - otherwise mute it
@@ -9833,7 +10393,7 @@ static int alc882_parse_auto_config(struct hda_codec *codec)
         spec->num_mux_defs = 1;
         spec->input_mux = &spec->private_imux[0];
 
-        alc_ssid_check(codec, 0x15, 0x1b, 0x14);
+        alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
 
         err = alc_auto_add_mic_boost(codec);
         if (err < 0)
@@ -9889,7 +10449,8 @@ static int patch_alc882(struct hda_codec *codec)
                 board_config = ALC882_AUTO;
         }
 
-        alc_pick_fixup(codec, alc882_fixup_tbl, alc882_fixups);
+        if (board_config == ALC882_AUTO)
+                alc_pick_fixup(codec, alc882_fixup_tbl, alc882_fixups, 1);
 
         if (board_config == ALC882_AUTO) {
                 /* automatic parse from the BIOS config */
@@ -9927,10 +10488,12 @@ static int patch_alc882(struct hda_codec *codec)
                 spec->init_amp = ALC_INIT_DEFAULT; /* always initialize */
 
         if (!spec->adc_nids && spec->input_mux) {
-                int i;
+                int i, j;
                 spec->num_adc_nids = 0;
                 for (i = 0; i < ARRAY_SIZE(alc882_adc_nids); i++) {
+                        const struct hda_input_mux *imux = spec->input_mux;
                         hda_nid_t cap;
+                        hda_nid_t items[16];
                         hda_nid_t nid = alc882_adc_nids[i];
                         unsigned int wcap = get_wcaps(codec, nid);
                         /* get type */
@@ -9941,6 +10504,15 @@ static int patch_alc882(struct hda_codec *codec)
                         err = snd_hda_get_connections(codec, nid, &cap, 1);
                         if (err < 0)
                                 continue;
+                        err = snd_hda_get_connections(codec, cap, items,
+                                                      ARRAY_SIZE(items));
+                        if (err < 0)
+                                continue;
+                        for (j = 0; j < imux->num_items; j++)
+                                if (imux->items[j].index >= err)
+                                        break;
+                        if (j < imux->num_items)
+                                continue;
                         spec->private_capsrc_nids[spec->num_adc_nids] = cap;
                         spec->num_adc_nids++;
                 }
@@ -9951,6 +10523,9 @@ static int patch_alc882(struct hda_codec *codec)
         set_capture_mixer(codec);
         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
 
+        if (board_config == ALC882_AUTO)
+                alc_pick_fixup(codec, alc882_fixup_tbl, alc882_fixups, 0);
+
         spec->vmaster_nid = 0x0c;
 
         codec->patch_ops = alc_patch_ops;
@@ -9960,7 +10535,6 @@ static int patch_alc882(struct hda_codec *codec)
         if (!spec->loopback.amplist)
                 spec->loopback.amplist = alc882_loopbacks;
 #endif
-        codec->proc_widget_hook = print_realtek_coef;
 
         return 0;
 }
@@ -10032,10 +10606,8 @@ static void alc262_hp_master_update(struct hda_codec *codec)
 static void alc262_hp_bpc_automute(struct hda_codec *codec)
 {
         struct alc_spec *spec = codec->spec;
-        unsigned int presence;
-        presence = snd_hda_codec_read(codec, 0x1b, 0,
-                                      AC_VERB_GET_PIN_SENSE, 0);
-        spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
+
+        spec->jack_present = snd_hda_jack_detect(codec, 0x1b);
         alc262_hp_master_update(codec);
 }
 
@@ -10049,10 +10621,8 @@ static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
 {
         struct alc_spec *spec = codec->spec;
-        unsigned int presence;
-        presence = snd_hda_codec_read(codec, 0x15, 0,
-                                      AC_VERB_GET_PIN_SENSE, 0);
-        spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
+
+        spec->jack_present = snd_hda_jack_detect(codec, 0x15);
         alc262_hp_master_update(codec);
 }
 
@@ -10087,8 +10657,14 @@ static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
                 .info = snd_ctl_boolean_mono_info,              \
                 .get = alc262_hp_master_sw_get,                 \
                 .put = alc262_hp_master_sw_put,                 \
+        }, \
+        {                                                       \
+                .iface = NID_MAPPING,                           \
+                .name = "Master Playback Switch",               \
+                .private_value = 0x15 | (0x16 << 8) | (0x1b << 16),     \
         }
 
+
 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
         ALC262_HP_MASTER_SWITCH,
         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
@@ -10146,7 +10722,7 @@ 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 */
+        spec->autocfg.speaker_pins[0] = 0x14;
 }
 
 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
@@ -10246,6 +10822,12 @@ static int alc262_hippo_master_sw_put(struct snd_kcontrol *kcontrol,
                 .info = snd_ctl_boolean_mono_info,              \
                 .get = alc262_hippo_master_sw_get,              \
                 .put = alc262_hippo_master_sw_put,              \
+        },                                                      \
+        {                                                       \
+                .iface = NID_MAPPING,                           \
+                .name = "Master Playback Switch",               \
+                .subdevice = SUBDEV_HP(0) | (SUBDEV_LINE(0) << 8) | \
+                             (SUBDEV_SPEAKER(0) << 16), \
         }
 
 static struct snd_kcontrol_new alc262_hippo_mixer[] = {
@@ -10286,13 +10868,8 @@ static void alc262_hippo_automute(struct hda_codec *codec)
 {
         struct alc_spec *spec = codec->spec;
         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
-        unsigned int present;
 
-        /* need to execute and sync at first */
-        snd_hda_codec_read(codec, hp_nid, 0, AC_VERB_SET_PIN_SENSE, 0);
-        present = snd_hda_codec_read(codec, hp_nid, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0);
-        spec->jack_present = (present & 0x80000000) != 0;
+        spec->jack_present = snd_hda_jack_detect(codec, hp_nid);
         alc262_hippo_master_update(codec);
 }
 
@@ -10581,6 +11158,13 @@ static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
         {}
 };
 
+static struct hda_verb alc262_lenovo_3000_init_verbs[] = {
+        /* Front Mic pin: input vref at 50% */
+        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
+        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {}
+};
+
 static struct hda_input_mux alc262_fujitsu_capture_source = {
         .num_items = 3,
         .items = {
@@ -10618,21 +11202,8 @@ static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
         unsigned int mute;
 
         if (force || !spec->sense_updated) {
-                unsigned int present;
-                /* need to execute and sync at first */
-                snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
-                /* check laptop HP jack */
-                present = snd_hda_codec_read(codec, 0x14, 0,
-                                             AC_VERB_GET_PIN_SENSE, 0);
-                /* need to execute and sync at first */
-                snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
-                /* check docking HP jack */
-                present |= snd_hda_codec_read(codec, 0x1b, 0,
-                                              AC_VERB_GET_PIN_SENSE, 0);
-                if (present & AC_PINSENSE_PRESENCE)
-                        spec->jack_present = 1;
-                else
-                        spec->jack_present = 0;
+                spec->jack_present = snd_hda_jack_detect(codec, 0x14) ||
+                                     snd_hda_jack_detect(codec, 0x1b);
                 spec->sense_updated = 1;
         }
         /* unmute internal speaker only if both HPs are unplugged and
@@ -10677,12 +11248,7 @@ static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
         unsigned int mute;
 
         if (force || !spec->sense_updated) {
-                unsigned int present_int_hp;
-                /* need to execute and sync at first */
-                snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
-                present_int_hp = snd_hda_codec_read(codec, 0x1b, 0,
-                                        AC_VERB_GET_PIN_SENSE, 0);
-                spec->jack_present = (present_int_hp & 0x80000000) != 0;
+                spec->jack_present = snd_hda_jack_detect(codec, 0x1b);
                 spec->sense_updated = 1;
         }
         if (spec->jack_present) {
@@ -10742,11 +11308,17 @@ static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
                 .name = "Master Playback Switch",
+                .subdevice = HDA_SUBDEV_AMP_FLAG,
                 .info = snd_hda_mixer_amp_switch_info,
                 .get = snd_hda_mixer_amp_switch_get,
                 .put = alc262_fujitsu_master_sw_put,
                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
         },
+        {
+                .iface = NID_MAPPING,
+                .name = "Master Playback Switch",
+                .private_value = 0x1b,
+        },
         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
@@ -10777,6 +11349,7 @@ static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
                 .name = "Master Playback Switch",
+                .subdevice = HDA_SUBDEV_AMP_FLAG,
                 .info = snd_hda_mixer_amp_switch_info,
                 .get = snd_hda_mixer_amp_switch_get,
                 .put = alc262_lenovo_3000_master_sw_put,
@@ -10874,12 +11447,7 @@ static void alc262_ultra_automute(struct hda_codec *codec)
         mute = 0;
         /* auto-mute only when HP is used as HP */
         if (!spec->cur_mux[0]) {
-                unsigned int present;
-                /* need to execute and sync at first */
-                snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
-                present = snd_hda_codec_read(codec, 0x15, 0,
-                                             AC_VERB_GET_PIN_SENSE, 0);
-                spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
+                spec->jack_present = snd_hda_jack_detect(codec, 0x15);
                 if (spec->jack_present)
                         mute = HDA_AMP_MUTE;
         }
@@ -10936,6 +11504,11 @@ static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
                 .get = alc_mux_enum_get,
                 .put = alc262_ultra_mux_enum_put,
         },
+        {
+                .iface = NID_MAPPING,
+                .name = "Capture Source",
+                .private_value = 0x15,
+        },
         { } /* end */
 };
 
@@ -10956,7 +11529,6 @@ static int alc262_check_volbit(hda_nid_t nid)
 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;
 
@@ -10966,28 +11538,25 @@ static int alc262_add_out_vol_ctl(struct alc_spec *spec, hda_nid_t nid,
         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);
+        return add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, 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);
+        return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, val);
 }
 
 /* add playback controls from the parsed DAC table */
@@ -11043,7 +11612,7 @@ static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
 }
 
 #define alc262_auto_create_input_ctls \
-        alc880_auto_create_input_ctls
+        alc882_auto_create_input_ctls
 
 /*
  * generic initialization of ADC, input mixers and output mixers
@@ -11386,7 +11955,7 @@ static int alc262_parse_auto_config(struct hda_codec *codec)
         if (err < 0)
                 return err;
 
-        alc_ssid_check(codec, 0x15, 0x14, 0x1b);
+        alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
 
         return 1;
 }
@@ -11463,8 +12032,10 @@ static struct snd_pci_quirk alc262_cfg_tbl[] = {
         SND_PCI_QUIRK(0x104d, 0x9025, "Sony VAIO Z21MN", ALC262_TOSHIBA_S06),
         SND_PCI_QUIRK(0x104d, 0x9035, "Sony VAIO VGN-FW170J", ALC262_AUTO),
         SND_PCI_QUIRK(0x104d, 0x9047, "Sony VAIO Type G", ALC262_AUTO),
+#if 0 /* disable the quirk since model=auto works better in recent versions */
         SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO",
                            ALC262_SONY_ASSAMD),
+#endif
         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
                       ALC262_TOSHIBA_RX1),
         SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
@@ -11580,9 +12151,9 @@ static struct alc_config_preset alc262_presets[] = {
                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
                 .channel_mode = alc262_modes,
                 .input_mux = &alc262_capture_source,
-                .unsol_event = alc_automute_amp_unsol_event,
+                .unsol_event = alc_sku_unsol_event,
                 .setup = alc262_hp_t5735_setup,
-                .init_hook = alc_automute_amp,
+                .init_hook = alc_inithook,
         },
         [ALC262_HP_RP5700] = {
                 .mixers = { alc262_hp_rp5700_mixer },
@@ -11648,7 +12219,8 @@ static struct alc_config_preset alc262_presets[] = {
         [ALC262_LENOVO_3000] = {
                 .mixers = { alc262_lenovo_3000_mixer },
                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
-                                alc262_lenovo_3000_unsol_verbs },
+                                alc262_lenovo_3000_unsol_verbs,
+                                alc262_lenovo_3000_init_verbs },
                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
                 .dac_nids = alc262_dac_nids,
                 .hp_nid = 0x03,
@@ -11826,7 +12398,6 @@ static int patch_alc262(struct hda_codec *codec)
         if (!spec->loopback.amplist)
                 spec->loopback.amplist = alc262_loopbacks;
 #endif
-        codec->proc_widget_hook = print_realtek_coef;
 
         return 0;
 }
@@ -11923,10 +12494,7 @@ static void alc268_acer_automute(struct hda_codec *codec, int force)
         unsigned int mute;
 
         if (force || !spec->sense_updated) {
-                unsigned int present;
-                present = snd_hda_codec_read(codec, 0x14, 0,
-                                         AC_VERB_GET_PIN_SENSE, 0);
-                spec->jack_present = (present & 0x80000000) != 0;
+                spec->jack_present = snd_hda_jack_detect(codec, 0x14);
                 spec->sense_updated = 1;
         }
         if (spec->jack_present)
@@ -11958,6 +12526,7 @@ static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
                 .name = "Master Playback Switch",
+                .subdevice = HDA_SUBDEV_AMP_FLAG,
                 .info = snd_hda_mixer_amp_switch_info,
                 .get = snd_hda_mixer_amp_switch_get,
                 .put = alc268_acer_master_sw_put,
@@ -11973,6 +12542,7 @@ static struct snd_kcontrol_new alc268_acer_mixer[] = {
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
                 .name = "Master Playback Switch",
+                .subdevice = HDA_SUBDEV_AMP_FLAG,
                 .info = snd_hda_mixer_amp_switch_info,
                 .get = snd_hda_mixer_amp_switch_get,
                 .put = alc268_acer_master_sw_put,
@@ -11990,6 +12560,7 @@ static struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
                 .name = "Master Playback Switch",
+                .subdevice = HDA_SUBDEV_AMP_FLAG,
                 .info = snd_hda_mixer_amp_switch_info,
                 .get = snd_hda_mixer_amp_switch_get,
                 .put = alc268_acer_master_sw_put,
@@ -12045,13 +12616,12 @@ static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
         unsigned int present;
         unsigned char bits;
 
-        present = snd_hda_codec_read(codec, 0x15, 0,
-                                AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-        bits = present ? AMP_IN_MUTE(0) : 0;
+        present = snd_hda_jack_detect(codec, 0x15);
+        bits = present ? HDA_AMP_MUTE : 0;
         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0,
-                                AMP_IN_MUTE(0), bits);
+                                 HDA_AMP_MUTE, bits);
         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1,
-                                AMP_IN_MUTE(0), bits);
+                                 HDA_AMP_MUTE, bits);
 }
 
 static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
@@ -12327,17 +12897,16 @@ static struct snd_kcontrol_new alc268_test_mixer[] = {
 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);
         switch (nid) {
         case 0x14:
         case 0x16:
                 dac = 0x02;
                 break;
         case 0x15:
+        case 0x21: /* ALC269vb has this pin, too */
                 dac = 0x03;
                 break;
         default:
@@ -12345,7 +12914,7 @@ static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
         }
         if (spec->multiout.dac_nids[0] != dac &&
             spec->multiout.dac_nids[1] != dac) {
-                err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
+                err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
                                   HDA_COMPOSE_AMP_VAL(dac, 3, idx,
                                                       HDA_OUTPUT));
                 if (err < 0)
@@ -12353,12 +12922,11 @@ static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
         }
 
-        sprintf(name, "%s Playback Switch", ctlname);
         if (nid != 0x16)
-                err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
+                err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
         else /* mono */
-                err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
+                err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
                           HDA_COMPOSE_AMP_VAL(nid, 2, idx, HDA_OUTPUT));
         if (err < 0)
                 return err;
@@ -12388,8 +12956,7 @@ static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
 
         nid = cfg->speaker_pins[0];
         if (nid == 0x1d) {
-                err = add_control(spec, ALC_CTL_WIDGET_VOL,
-                                  "Speaker Playback Volume",
+                err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, "Speaker",
                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
                 if (err < 0)
                         return err;
@@ -12407,8 +12974,7 @@ static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
 
         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",
+                err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, "Mono",
                                   HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT));
                 if (err < 0)
                         return err;
@@ -12561,7 +13127,7 @@ static int alc268_parse_auto_config(struct hda_codec *codec)
         if (err < 0)
                 return err;
 
-        alc_ssid_check(codec, 0x15, 0x1b, 0x14);
+        alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
 
         return 1;
 }
@@ -12794,7 +13360,7 @@ static int patch_alc268(struct hda_codec *codec)
         int board_config;
         int i, has_beep, err;
 
-        spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
+        spec = kzalloc(sizeof(*spec), GFP_KERNEL);
         if (spec == NULL)
                 return -ENOMEM;
 
@@ -12806,7 +13372,7 @@ static int patch_alc268(struct hda_codec *codec)
 
         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);
+                        ALC268_MODEL_LAST, alc268_models, alc268_ssid_cfg_tbl);
 
         if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
@@ -12898,8 +13464,6 @@ static int patch_alc268(struct hda_codec *codec)
         if (board_config == ALC268_AUTO)
                 spec->init_hook = alc268_auto_init;
 
-        codec->proc_widget_hook = print_realtek_coef;
-
         return 0;
 }
 
@@ -12919,9 +13483,18 @@ static hda_nid_t alc269_capsrc_nids[1] = {
         0x23,
 };
 
-/* NOTE: ADC2 (0x07) is connected from a recording *MIXER* (0x24),
- *       not a mux!
- */
+static hda_nid_t alc269vb_adc_nids[1] = {
+        /* ADC1 */
+        0x09,
+};
+
+static hda_nid_t alc269vb_capsrc_nids[1] = {
+        0x22,
+};
+
+static hda_nid_t alc269_adc_candidates[] = {
+        0x08, 0x09, 0x07,
+};
 
 #define alc269_modes            alc260_modes
 #define alc269_capture_source   alc880_lg_lw_capture_source
@@ -12948,6 +13521,7 @@ static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
                 .name = "Master Playback Switch",
+                .subdevice = HDA_SUBDEV_AMP_FLAG,
                 .info = snd_hda_mixer_amp_switch_info,
                 .get = snd_hda_mixer_amp_switch_get,
                 .put = alc268_acer_master_sw_put,
@@ -12968,6 +13542,7 @@ static struct snd_kcontrol_new alc269_lifebook_mixer[] = {
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
                 .name = "Master Playback Switch",
+                .subdevice = HDA_SUBDEV_AMP_FLAG,
                 .info = snd_hda_mixer_amp_switch_info,
                 .get = snd_hda_mixer_amp_switch_get,
                 .put = alc268_acer_master_sw_put,
@@ -12985,7 +13560,7 @@ static struct snd_kcontrol_new alc269_lifebook_mixer[] = {
         { }
 };
 
-static struct snd_kcontrol_new alc269_eeepc_mixer[] = {
+static struct snd_kcontrol_new alc269_laptop_mixer[] = {
         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),
@@ -12993,16 +13568,47 @@ static struct snd_kcontrol_new alc269_eeepc_mixer[] = {
         { } /* end */
 };
 
+static struct snd_kcontrol_new alc269vb_laptop_mixer[] = {
+        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", 0x21, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
+        { } /* end */
+};
+
 /* capture mixer elements */
-static struct snd_kcontrol_new alc269_epc_capture_mixer[] = {
+static struct snd_kcontrol_new alc269_laptop_analog_capture_mixer[] = {
         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
+        HDA_CODEC_VOLUME("IntMic Boost", 0x19, 0, HDA_INPUT),
+        { } /* end */
+};
+
+static struct snd_kcontrol_new alc269_laptop_digital_capture_mixer[] = {
+        HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
+        { } /* end */
+};
+
+static struct snd_kcontrol_new alc269vb_laptop_analog_capture_mixer[] = {
+        HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
+        HDA_CODEC_VOLUME("IntMic Boost", 0x19, 0, HDA_INPUT),
+        { } /* end */
+};
+
+static struct snd_kcontrol_new alc269vb_laptop_digital_capture_mixer[] = {
+        HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
         { } /* end */
 };
 
 /* FSC amilo */
-#define alc269_fujitsu_mixer    alc269_eeepc_mixer
+#define alc269_fujitsu_mixer    alc269_laptop_mixer
 
 static struct hda_verb alc269_quanta_fl1_verbs[] = {
         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
@@ -13034,13 +13640,12 @@ static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
         unsigned int present;
         unsigned char bits;
 
-        present = snd_hda_codec_read(codec, 0x15, 0,
-                        AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-        bits = present ? AMP_IN_MUTE(0) : 0;
+        present = snd_hda_jack_detect(codec, 0x15);
+        bits = present ? HDA_AMP_MUTE : 0;
         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
-                        AMP_IN_MUTE(0), bits);
+                                 HDA_AMP_MUTE, bits);
         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
-                        AMP_IN_MUTE(0), bits);
+                                 HDA_AMP_MUTE, bits);
 
         snd_hda_codec_write(codec, 0x20, 0,
                         AC_VERB_SET_COEF_INDEX, 0x0c);
@@ -13060,18 +13665,16 @@ static void alc269_lifebook_speaker_automute(struct hda_codec *codec)
         unsigned char bits;
 
         /* Check laptop headphone socket */
-        present = snd_hda_codec_read(codec, 0x15, 0,
-                        AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
+        present = snd_hda_jack_detect(codec, 0x15);
 
         /* Check port replicator headphone socket */
-        present |= snd_hda_codec_read(codec, 0x1a, 0,
-                        AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
+        present |= snd_hda_jack_detect(codec, 0x1a);
 
-        bits = present ? AMP_IN_MUTE(0) : 0;
+        bits = present ? HDA_AMP_MUTE : 0;
         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
-                        AMP_IN_MUTE(0), bits);
+                                 HDA_AMP_MUTE, bits);
         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
-                        AMP_IN_MUTE(0), bits);
+                                 HDA_AMP_MUTE, bits);
 
         snd_hda_codec_write(codec, 0x20, 0,
                         AC_VERB_SET_COEF_INDEX, 0x0c);
@@ -13089,11 +13692,8 @@ static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
         unsigned int present_laptop;
         unsigned int present_dock;
 
-        present_laptop = snd_hda_codec_read(codec, 0x18, 0,
-                                AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-
-        present_dock = snd_hda_codec_read(codec, 0x1b, 0,
-                                AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
+        present_laptop  = snd_hda_jack_detect(codec, 0x18);
+        present_dock    = snd_hda_jack_detect(codec, 0x1b);
 
         /* Laptop mic port overrides dock mic port, design decision */
         if (present_dock)
@@ -13132,6 +13732,8 @@ static void alc269_lifebook_unsol_event(struct hda_codec *codec,
 static void alc269_quanta_fl1_setup(struct hda_codec *codec)
 {
         struct alc_spec *spec = codec->spec;
+        spec->autocfg.hp_pins[0] = 0x15;
+        spec->autocfg.speaker_pins[0] = 0x14;
         spec->ext_mic.pin = 0x18;
         spec->ext_mic.mux_idx = 0;
         spec->int_mic.pin = 0x19;
@@ -13151,7 +13753,7 @@ static void alc269_lifebook_init_hook(struct hda_codec *codec)
         alc269_lifebook_mic_autoswitch(codec);
 }
 
-static struct hda_verb alc269_eeepc_dmic_init_verbs[] = {
+static struct hda_verb alc269_laptop_dmic_init_verbs[] = {
         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
         {0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
@@ -13162,7 +13764,7 @@ static struct hda_verb alc269_eeepc_dmic_init_verbs[] = {
         {}
 };
 
-static struct hda_verb alc269_eeepc_amic_init_verbs[] = {
+static struct hda_verb alc269_laptop_amic_init_verbs[] = {
         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
         {0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
@@ -13172,23 +13774,46 @@ static struct hda_verb alc269_eeepc_amic_init_verbs[] = {
         {}
 };
 
+static struct hda_verb alc269vb_laptop_dmic_init_verbs[] = {
+        {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},
+        {0x22, AC_VERB_SET_CONNECT_SEL, 0x06},
+        {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
+        {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
+        {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
+        {}
+};
+
+static struct hda_verb alc269vb_laptop_amic_init_verbs[] = {
+        {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},
+        {0x22, AC_VERB_SET_CONNECT_SEL, 0x01},
+        {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
+        {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
+        {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
+        {}
+};
+
 /* toggle speaker-output according to the hp-jack state */
 static void alc269_speaker_automute(struct hda_codec *codec)
 {
+        struct alc_spec *spec = codec->spec;
+        unsigned int nid = spec->autocfg.hp_pins[0];
         unsigned int present;
         unsigned char bits;
 
-        present = snd_hda_codec_read(codec, 0x15, 0,
-                                AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-        bits = present ? AMP_IN_MUTE(0) : 0;
+        present = snd_hda_jack_detect(codec, nid);
+        bits = present ? HDA_AMP_MUTE : 0;
         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
-                                AMP_IN_MUTE(0), bits);
+                                 HDA_AMP_MUTE, bits);
         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
-                                AMP_IN_MUTE(0), bits);
+                                 HDA_AMP_MUTE, bits);
 }
 
 /* unsolicited event for HP jack sensing */
-static void alc269_eeepc_unsol_event(struct hda_codec *codec,
+static void alc269_laptop_unsol_event(struct hda_codec *codec,
                                      unsigned int res)
 {
         switch (res >> 26) {
@@ -13201,9 +13826,23 @@ static void alc269_eeepc_unsol_event(struct hda_codec *codec,
         }
 }
 
-static void alc269_eeepc_dmic_setup(struct hda_codec *codec)
+static void alc269_laptop_amic_setup(struct hda_codec *codec)
 {
         struct alc_spec *spec = codec->spec;
+        spec->autocfg.hp_pins[0] = 0x15;
+        spec->autocfg.speaker_pins[0] = 0x14;
+        spec->ext_mic.pin = 0x18;
+        spec->ext_mic.mux_idx = 0;
+        spec->int_mic.pin = 0x19;
+        spec->int_mic.mux_idx = 1;
+        spec->auto_mic = 1;
+}
+
+static void alc269_laptop_dmic_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+        spec->autocfg.hp_pins[0] = 0x15;
+        spec->autocfg.speaker_pins[0] = 0x14;
         spec->ext_mic.pin = 0x18;
         spec->ext_mic.mux_idx = 0;
         spec->int_mic.pin = 0x12;
@@ -13211,9 +13850,11 @@ static void alc269_eeepc_dmic_setup(struct hda_codec *codec)
         spec->auto_mic = 1;
 }
 
-static void alc269_eeepc_amic_setup(struct hda_codec *codec)
+static void alc269vb_laptop_amic_setup(struct hda_codec *codec)
 {
         struct alc_spec *spec = codec->spec;
+        spec->autocfg.hp_pins[0] = 0x21;
+        spec->autocfg.speaker_pins[0] = 0x14;
         spec->ext_mic.pin = 0x18;
         spec->ext_mic.mux_idx = 0;
         spec->int_mic.pin = 0x19;
@@ -13221,7 +13862,19 @@ static void alc269_eeepc_amic_setup(struct hda_codec *codec)
         spec->auto_mic = 1;
 }
 
-static void alc269_eeepc_inithook(struct hda_codec *codec)
+static void alc269vb_laptop_dmic_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+        spec->autocfg.hp_pins[0] = 0x21;
+        spec->autocfg.speaker_pins[0] = 0x14;
+        spec->ext_mic.pin = 0x18;
+        spec->ext_mic.mux_idx = 0;
+        spec->int_mic.pin = 0x12;
+        spec->int_mic.mux_idx = 6;
+        spec->auto_mic = 1;
+}
+
+static void alc269_laptop_inithook(struct hda_codec *codec)
 {
         alc269_speaker_automute(codec);
         alc_mic_automute(codec);
@@ -13234,22 +13887,10 @@ static struct hda_verb alc269_init_verbs[] = {
         /*
          * Unmute ADC0 and set the default input to mic-in
          */
-        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-
-        /* Mute input amps (PCBeep, 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)},
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 
         /*
-         * Set up output mixers (0x0c - 0x0e)
+         * Set up output mixers (0x02 - 0x03)
          */
         /* set vol=0 to output mixers */
         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
@@ -13274,26 +13915,57 @@ static struct hda_verb alc269_init_verbs[] = {
 
         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
-        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 
-        {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
-        {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
+        /* FIXME: use Mux-type input source selection */
+        /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
+        /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
+        {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
 
-        /* FIXME: use matrix-type input source selection */
+        /* set EAPD */
+        {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
+        { }
+};
+
+static struct hda_verb alc269vb_init_verbs[] = {
+        /*
+         * Unmute ADC0 and set the default input to mic-in
+         */
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+
+        /*
+         * Set up output mixers (0x02 - 0x03)
+         */
+        /* set vol=0 to output mixers */
+        {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x03, 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)},
+        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+
+        /* FIXME: use Mux-type input source selection */
         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
-        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
-        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
-        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
+        {0x22, AC_VERB_SET_CONNECT_SEL, 0x00},
 
         /* set EAPD */
         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
-        {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
         { }
 };
 
@@ -13362,11 +14034,21 @@ static int alc269_parse_auto_config(struct hda_codec *codec)
         if (spec->kctls.list)
                 add_mixer(spec, spec->kctls.list);
 
-        add_verb(spec, alc269_init_verbs);
+        if ((alc_read_coef_idx(codec, 0) & 0x00f0) == 0x0010) {
+                add_verb(spec, alc269vb_init_verbs);
+                alc_ssid_check(codec, 0, 0x1b, 0x14, 0x21);
+        } else {
+                add_verb(spec, alc269_init_verbs);
+                alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
+        }
+
         spec->num_mux_defs = 1;
         spec->input_mux = &spec->private_imux[0];
+        fillup_priv_adc_nids(codec, alc269_adc_candidates,
+                             sizeof(alc269_adc_candidates));
+
         /* set default input source */
-        snd_hda_codec_write_cache(codec, alc269_capsrc_nids[0],
+        snd_hda_codec_write_cache(codec, spec->capsrc_nids[0],
                                   0, AC_VERB_SET_CONNECT_SEL,
                                   spec->input_mux->items[0].index);
 
@@ -13377,8 +14059,6 @@ static int alc269_parse_auto_config(struct hda_codec *codec)
         if (!spec->cap_mixer && !spec->no_analog)
                 set_capture_mixer(codec);
 
-        alc_ssid_check(codec, 0x15, 0x1b, 0x14);
-
         return 1;
 }
 
@@ -13398,14 +14078,35 @@ static void alc269_auto_init(struct hda_codec *codec)
                 alc_inithook(codec);
 }
 
+enum {
+        ALC269_FIXUP_SONY_VAIO,
+};
+
+const static struct hda_verb alc269_sony_vaio_fixup_verbs[] = {
+        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREFGRD},
+        {}
+};
+
+static const struct alc_fixup alc269_fixups[] = {
+        [ALC269_FIXUP_SONY_VAIO] = {
+                .verbs = alc269_sony_vaio_fixup_verbs
+        },
+};
+
+static struct snd_pci_quirk alc269_fixup_tbl[] = {
+        SND_PCI_QUIRK(0x104d, 0x9071, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
+        {}
+};
+
+
 /*
  * configuration and preset
  */
 static const char *alc269_models[ALC269_MODEL_LAST] = {
         [ALC269_BASIC]                  = "basic",
         [ALC269_QUANTA_FL1]             = "quanta",
-        [ALC269_ASUS_EEEPC_P703]        = "eeepc-p703",
-        [ALC269_ASUS_EEEPC_P901]        = "eeepc-p901",
+        [ALC269_AMIC]                   = "laptop-amic",
+        [ALC269_DMIC]                   = "laptop-dmic",
         [ALC269_FUJITSU]                = "fujitsu",
         [ALC269_LIFEBOOK]               = "lifebook",
         [ALC269_AUTO]                   = "auto",
@@ -13414,20 +14115,57 @@ static const char *alc269_models[ALC269_MODEL_LAST] = {
 static struct snd_pci_quirk alc269_cfg_tbl[] = {
         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
-                      ALC269_ASUS_EEEPC_P703),
-        SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_ASUS_EEEPC_P703),
-        SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_ASUS_EEEPC_P703),
-        SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_ASUS_EEEPC_P703),
-        SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_ASUS_EEEPC_P703),
-        SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_ASUS_EEEPC_P703),
-        SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_ASUS_EEEPC_P703),
+                      ALC269_AMIC),
+        SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269VB_AMIC),
+        SND_PCI_QUIRK(0x1043, 0x1113, "ASUS N63Jn", ALC269VB_AMIC),
+        SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269VB_AMIC),
+        SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_AMIC),
+        SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269VB_AMIC),
+        SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269VB_AMIC),
+        SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269VB_AMIC),
+        SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269VB_AMIC),
+        SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_AMIC),
+        SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82Jv", ALC269_AMIC),
+        SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_AMIC),
+        SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_AMIC),
+        SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_AMIC),
+        SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_AMIC),
+        SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_AMIC),
+        SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_AMIC),
+        SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_AMIC),
+        SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_AMIC),
+        SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_AMIC),
+        SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_AMIC),
+        SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_AMIC),
+        SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_AMIC),
+        SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_AMIC),
+        SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_AMIC),
+        SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_AMIC),
+        SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_AMIC),
+        SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_AMIC),
+        SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_AMIC),
+        SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_AMIC),
+        SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_AMIC),
+        SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_AMIC),
+        SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_DMIC),
+        SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_AMIC),
+        SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_AMIC),
+        SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_AMIC),
+        SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_AMIC),
         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
-                      ALC269_ASUS_EEEPC_P901),
+                      ALC269_DMIC),
         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
-                      ALC269_ASUS_EEEPC_P901),
-        SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_ASUS_EEEPC_P901),
-        SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
+                      ALC269_DMIC),
+        SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005HA", ALC269_DMIC),
+        SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005HA", ALC269_DMIC),
+        SND_PCI_QUIRK(0x104d, 0x9071, "Sony VAIO", ALC269_AUTO),
         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
+        SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_DMIC),
+        SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
+        SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_AMIC),
+        SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_AMIC),
+        SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_DMIC),
+        SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_DMIC),
         {}
 };
 
@@ -13455,47 +14193,75 @@ static struct alc_config_preset alc269_presets[] = {
                 .setup = alc269_quanta_fl1_setup,
                 .init_hook = alc269_quanta_fl1_init_hook,
         },
-        [ALC269_ASUS_EEEPC_P703] = {
-                .mixers = { alc269_eeepc_mixer },
-                .cap_mixer = alc269_epc_capture_mixer,
+        [ALC269_AMIC] = {
+                .mixers = { alc269_laptop_mixer },
+                .cap_mixer = alc269_laptop_analog_capture_mixer,
                 .init_verbs = { alc269_init_verbs,
-                                alc269_eeepc_amic_init_verbs },
+                                alc269_laptop_amic_init_verbs },
                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
                 .dac_nids = alc269_dac_nids,
                 .hp_nid = 0x03,
                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
                 .channel_mode = alc269_modes,
-                .unsol_event = alc269_eeepc_unsol_event,
-                .setup = alc269_eeepc_amic_setup,
-                .init_hook = alc269_eeepc_inithook,
+                .unsol_event = alc269_laptop_unsol_event,
+                .setup = alc269_laptop_amic_setup,
+                .init_hook = alc269_laptop_inithook,
         },
-        [ALC269_ASUS_EEEPC_P901] = {
-                .mixers = { alc269_eeepc_mixer },
-                .cap_mixer = alc269_epc_capture_mixer,
+        [ALC269_DMIC] = {
+                .mixers = { alc269_laptop_mixer },
+                .cap_mixer = alc269_laptop_digital_capture_mixer,
                 .init_verbs = { alc269_init_verbs,
-                                alc269_eeepc_dmic_init_verbs },
+                                alc269_laptop_dmic_init_verbs },
                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
                 .dac_nids = alc269_dac_nids,
                 .hp_nid = 0x03,
                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
                 .channel_mode = alc269_modes,
-                .unsol_event = alc269_eeepc_unsol_event,
-                .setup = alc269_eeepc_dmic_setup,
-                .init_hook = alc269_eeepc_inithook,
+                .unsol_event = alc269_laptop_unsol_event,
+                .setup = alc269_laptop_dmic_setup,
+                .init_hook = alc269_laptop_inithook,
+        },
+        [ALC269VB_AMIC] = {
+                .mixers = { alc269vb_laptop_mixer },
+                .cap_mixer = alc269vb_laptop_analog_capture_mixer,
+                .init_verbs = { alc269vb_init_verbs,
+                                alc269vb_laptop_amic_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc269_dac_nids),
+                .dac_nids = alc269_dac_nids,
+                .hp_nid = 0x03,
+                .num_channel_mode = ARRAY_SIZE(alc269_modes),
+                .channel_mode = alc269_modes,
+                .unsol_event = alc269_laptop_unsol_event,
+                .setup = alc269vb_laptop_amic_setup,
+                .init_hook = alc269_laptop_inithook,
+        },
+        [ALC269VB_DMIC] = {
+                .mixers = { alc269vb_laptop_mixer },
+                .cap_mixer = alc269vb_laptop_digital_capture_mixer,
+                .init_verbs = { alc269vb_init_verbs,
+                                alc269vb_laptop_dmic_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc269_dac_nids),
+                .dac_nids = alc269_dac_nids,
+                .hp_nid = 0x03,
+                .num_channel_mode = ARRAY_SIZE(alc269_modes),
+                .channel_mode = alc269_modes,
+                .unsol_event = alc269_laptop_unsol_event,
+                .setup = alc269vb_laptop_dmic_setup,
+                .init_hook = alc269_laptop_inithook,
         },
         [ALC269_FUJITSU] = {
                 .mixers = { alc269_fujitsu_mixer },
-                .cap_mixer = alc269_epc_capture_mixer,
+                .cap_mixer = alc269_laptop_digital_capture_mixer,
                 .init_verbs = { alc269_init_verbs,
-                                alc269_eeepc_dmic_init_verbs },
+                                alc269_laptop_dmic_init_verbs },
                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
                 .dac_nids = alc269_dac_nids,
                 .hp_nid = 0x03,
                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
                 .channel_mode = alc269_modes,
-                .unsol_event = alc269_eeepc_unsol_event,
-                .setup = alc269_eeepc_dmic_setup,
-                .init_hook = alc269_eeepc_inithook,
+                .unsol_event = alc269_laptop_unsol_event,
+                .setup = alc269_laptop_dmic_setup,
+                .init_hook = alc269_laptop_inithook,
         },
         [ALC269_LIFEBOOK] = {
                 .mixers = { alc269_lifebook_mixer },
@@ -13516,6 +14282,7 @@ static int patch_alc269(struct hda_codec *codec)
         struct alc_spec *spec;
         int board_config;
         int err;
+        int is_alc269vb = 0;
 
         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
         if (spec == NULL)
@@ -13525,6 +14292,16 @@ static int patch_alc269(struct hda_codec *codec)
 
         alc_fix_pll_init(codec, 0x20, 0x04, 15);
 
+        if ((alc_read_coef_idx(codec, 0) & 0x00f0) == 0x0010){
+                kfree(codec->chip_name);
+                codec->chip_name = kstrdup("ALC259", GFP_KERNEL);
+                if (!codec->chip_name) {
+                        alc_free(codec);
+                        return -ENOMEM;
+                }
+                is_alc269vb = 1;
+        }
+
         board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
                                                   alc269_models,
                                                   alc269_cfg_tbl);
@@ -13535,6 +14312,9 @@ static int patch_alc269(struct hda_codec *codec)
                 board_config = ALC269_AUTO;
         }
 
+        if (board_config == ALC269_AUTO)
+                alc_pick_fixup(codec, alc269_fixup_tbl, alc269_fixups, 1);
+
         if (board_config == ALC269_AUTO) {
                 /* automatic parse from the BIOS config */
                 err = alc269_parse_auto_config(codec);
@@ -13558,7 +14338,7 @@ static int patch_alc269(struct hda_codec *codec)
         if (board_config != ALC269_AUTO)
                 setup_preset(codec, &alc269_presets[board_config]);
 
-        if (codec->subsystem_id == 0x17aa3bf8) {
+        if (board_config == ALC269_QUANTA_FL1) {
                 /* Due to a hardware problem on Lenovo Ideadpad, we need to
                  * fix the sample rate of analog I/O to 44.1kHz
                  */
@@ -13571,13 +14351,25 @@ static int patch_alc269(struct hda_codec *codec)
         spec->stream_digital_playback = &alc269_pcm_digital_playback;
         spec->stream_digital_capture = &alc269_pcm_digital_capture;
 
-        spec->adc_nids = alc269_adc_nids;
-        spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
-        spec->capsrc_nids = alc269_capsrc_nids;
+        if (!spec->adc_nids) { /* wasn't filled automatically? use default */
+                if (!is_alc269vb) {
+                        spec->adc_nids = alc269_adc_nids;
+                        spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
+                        spec->capsrc_nids = alc269_capsrc_nids;
+                } else {
+                        spec->adc_nids = alc269vb_adc_nids;
+                        spec->num_adc_nids = ARRAY_SIZE(alc269vb_adc_nids);
+                        spec->capsrc_nids = alc269vb_capsrc_nids;
+                }
+        }
+
         if (!spec->cap_mixer)
                 set_capture_mixer(codec);
         set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
 
+        if (board_config == ALC269_AUTO)
+                alc_pick_fixup(codec, alc269_fixup_tbl, alc269_fixups, 0);
+
         spec->vmaster_nid = 0x02;
 
         codec->patch_ops = alc_patch_ops;
@@ -13587,7 +14379,6 @@ static int patch_alc269(struct hda_codec *codec)
         if (!spec->loopback.amplist)
                 spec->loopback.amplist = alc269_loopbacks;
 #endif
-        codec->proc_widget_hook = print_realtek_coef;
 
         return 0;
 }
@@ -14157,10 +14948,8 @@ static struct hda_verb alc861_toshiba_init_verbs[] = {
 /* toggle speaker-output according to the hp-jack state */
 static void alc861_toshiba_automute(struct hda_codec *codec)
 {
-        unsigned int present;
+        unsigned int present = snd_hda_jack_detect(codec, 0x0f);
 
-        present = snd_hda_codec_read(codec, 0x0f, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
         snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
@@ -14260,9 +15049,7 @@ static int alc861_auto_fill_dac_nids(struct hda_codec *codec,
 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,
+        return add_pb_sw_ctrl(codec->spec, ALC_CTL_WIDGET_MUTE, pfx,
                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
 }
 
@@ -14454,7 +15241,7 @@ static int alc861_parse_auto_config(struct hda_codec *codec)
         spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
         set_capture_mixer(codec);
 
-        alc_ssid_check(codec, 0x0e, 0x0f, 0x0b);
+        alc_ssid_check(codec, 0x0e, 0x0f, 0x0b, 0);
 
         return 1;
 }
@@ -14627,6 +15414,27 @@ static struct alc_config_preset alc861_presets[] = {
         },
 };
 
+/* Pin config fixes */
+enum {
+        PINFIX_FSC_AMILO_PI1505,
+};
+
+static struct alc_pincfg alc861_fsc_amilo_pi1505_pinfix[] = {
+        { 0x0b, 0x0221101f }, /* HP */
+        { 0x0f, 0x90170310 }, /* speaker */
+        { }
+};
+
+static const struct alc_fixup alc861_fixups[] = {
+        [PINFIX_FSC_AMILO_PI1505] = {
+                .pins = alc861_fsc_amilo_pi1505_pinfix
+        },
+};
+
+static struct snd_pci_quirk alc861_fixup_tbl[] = {
+        SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", PINFIX_FSC_AMILO_PI1505),
+        {}
+};
 
 static int patch_alc861(struct hda_codec *codec)
 {
@@ -14650,6 +15458,9 @@ static int patch_alc861(struct hda_codec *codec)
                 board_config = ALC861_AUTO;
         }
 
+        if (board_config == ALC861_AUTO)
+                alc_pick_fixup(codec, alc861_fixup_tbl, alc861_fixups, 1);
+
         if (board_config == ALC861_AUTO) {
                 /* automatic parse from the BIOS config */
                 err = alc861_parse_auto_config(codec);
@@ -14679,18 +15490,26 @@ static int patch_alc861(struct hda_codec *codec)
         spec->stream_digital_playback = &alc861_pcm_digital_playback;
         spec->stream_digital_capture = &alc861_pcm_digital_capture;
 
+        if (!spec->cap_mixer)
+                set_capture_mixer(codec);
         set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
 
         spec->vmaster_nid = 0x03;
 
-        codec->patch_ops = alc_patch_ops;
         if (board_config == ALC861_AUTO)
+                alc_pick_fixup(codec, alc861_fixup_tbl, alc861_fixups, 0);
+
+        codec->patch_ops = alc_patch_ops;
+        if (board_config == ALC861_AUTO) {
                 spec->init_hook = alc861_auto_init;
 #ifdef CONFIG_SND_HDA_POWER_SAVE
+                spec->power_hook = alc_power_eapd;
+#endif
+        }
+#ifdef CONFIG_SND_HDA_POWER_SAVE
         if (!spec->loopback.amplist)
                 spec->loopback.amplist = alc861_loopbacks;
 #endif
-        codec->proc_widget_hook = print_realtek_coef;
 
         return 0;
 }
@@ -15067,9 +15886,9 @@ static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
         unsigned int present;
         unsigned char bits;
 
-        present = snd_hda_codec_read(codec, 0x18, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
+        present = snd_hda_jack_detect(codec, 0x18);
         bits = present ? HDA_AMP_MUTE : 0;
+
         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
                                  HDA_AMP_MUTE, bits);
 }
@@ -15386,7 +16205,6 @@ static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
                                              const struct auto_pin_cfg *cfg)
 {
-        char name[32];
         static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
         hda_nid_t nid_v, nid_s;
         int i, err;
@@ -15403,26 +16221,26 @@ static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
 
                 if (i == 2) {
                         /* Center/LFE */
-                        err = add_control(spec, ALC_CTL_WIDGET_VOL,
-                                          "Center Playback Volume",
+                        err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
+                                              "Center",
                                           HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
                                                               HDA_OUTPUT));
                         if (err < 0)
                                 return err;
-                        err = add_control(spec, ALC_CTL_WIDGET_VOL,
-                                          "LFE Playback Volume",
+                        err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
+                                              "LFE",
                                           HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
                                                               HDA_OUTPUT));
                         if (err < 0)
                                 return err;
-                        err = add_control(spec, ALC_CTL_BIND_MUTE,
-                                          "Center Playback Switch",
+                        err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
+                                             "Center",
                                           HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
                                                               HDA_INPUT));
                         if (err < 0)
                                 return err;
-                        err = add_control(spec, ALC_CTL_BIND_MUTE,
-                                          "LFE Playback Switch",
+                        err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
+                                             "LFE",
                                           HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
                                                               HDA_INPUT));
                         if (err < 0)
@@ -15437,8 +16255,7 @@ static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
                                         pfx = "PCM";
                         } else
                                 pfx = chname[i];
-                        sprintf(name, "%s Playback Volume", pfx);
-                        err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
+                        err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
                                           HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
                                                               HDA_OUTPUT));
                         if (err < 0)
@@ -15446,8 +16263,7 @@ static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
                         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,
+                        err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
                                           HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
                                                               HDA_INPUT));
                         if (err < 0)
@@ -15465,7 +16281,6 @@ static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
 {
         hda_nid_t nid_v, nid_s;
         int err;
-        char name[32];
 
         if (!pin)
                 return 0;
@@ -15483,21 +16298,18 @@ static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
                 nid_s = alc861vd_idx_to_mixer_switch(
                                 alc880_fixed_pin_idx(pin));
 
-                sprintf(name, "%s Playback Volume", pfx);
-                err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
+                err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
                                   HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
                 if (err < 0)
                         return err;
-                sprintf(name, "%s Playback Switch", pfx);
-                err = add_control(spec, ALC_CTL_BIND_MUTE, name,
+                err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
                                   HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
                 if (err < 0)
                         return err;
         } else if (alc880_is_multi_pin(pin)) {
                 /* set manual connection */
                 /* we have only a switch on HP-out PIN */
-                sprintf(name, "%s Playback Switch", pfx);
-                err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
+                err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
                 if (err < 0)
                         return err;
@@ -15560,7 +16372,7 @@ static int alc861vd_parse_auto_config(struct hda_codec *codec)
         if (err < 0)
                 return err;
 
-        alc_ssid_check(codec, 0x15, 0x1b, 0x14);
+        alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
 
         return 1;
 }
@@ -15621,7 +16433,8 @@ static int patch_alc861vd(struct hda_codec *codec)
                 board_config = ALC861VD_AUTO;
         }
 
-        alc_pick_fixup(codec, alc861vd_fixup_tbl, alc861vd_fixups);
+        if (board_config == ALC861VD_AUTO)
+                alc_pick_fixup(codec, alc861vd_fixup_tbl, alc861vd_fixups, 1);
 
         if (board_config == ALC861VD_AUTO) {
                 /* automatic parse from the BIOS config */
@@ -15669,6 +16482,9 @@ static int patch_alc861vd(struct hda_codec *codec)
 
         spec->vmaster_nid = 0x02;
 
+        if (board_config == ALC861VD_AUTO)
+                alc_pick_fixup(codec, alc861vd_fixup_tbl, alc861vd_fixups, 0);
+
         codec->patch_ops = alc_patch_ops;
 
         if (board_config == ALC861VD_AUTO)
@@ -15677,7 +16493,6 @@ static int patch_alc861vd(struct hda_codec *codec)
         if (!spec->loopback.amplist)
                 spec->loopback.amplist = alc861vd_loopbacks;
 #endif
-        codec->proc_widget_hook = print_realtek_coef;
 
         return 0;
 }
@@ -16083,6 +16898,52 @@ static struct snd_kcontrol_new alc663_g50v_mixer[] = {
         { } /* end */
 };
 
+static struct hda_bind_ctls alc663_asus_mode7_8_all_bind_switch = {
+        .ops = &snd_hda_bind_sw,
+        .values = {
+                HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
+                HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
+                HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
+                HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
+                HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
+                0
+        },
+};
+
+static struct hda_bind_ctls alc663_asus_mode7_8_sp_bind_switch = {
+        .ops = &snd_hda_bind_sw,
+        .values = {
+                HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
+                HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
+                0
+        },
+};
+
+static struct snd_kcontrol_new alc663_mode7_mixer[] = {
+        HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
+        HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
+        HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
+        HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("IntMic Playback Volume", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("IntMic Playback Switch", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
+        { } /* end */
+};
+
+static struct snd_kcontrol_new alc663_mode8_mixer[] = {
+        HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
+        HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
+        HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
+        HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x15, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
+        { } /* end */
+};
+
+
 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
@@ -16098,13 +16959,6 @@ static struct hda_verb alc662_init_verbs[] = {
         /* ADC: 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) */
-
-        {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)},
 
         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
@@ -16154,6 +17008,28 @@ static struct hda_verb alc662_init_verbs[] = {
         { }
 };
 
+static struct hda_verb alc663_init_verbs[] = {
+        {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        { }
+};
+
+static struct hda_verb alc272_init_verbs[] = {
+        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        { }
+};
+
 static struct hda_verb alc662_sue_init_verbs[] = {
         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
@@ -16173,61 +17049,6 @@ static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
         {}
 };
 
-/*
- * generic initialization of ADC, input mixers and output mixers
- */
-static struct hda_verb alc662_auto_init_verbs[] = {
-        /*
-         * Unmute ADC and set the default input to mic-in
-         */
-        {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
-        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-
-        /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
-         * mixer widget
-         * Note: PASD motherboards uses the Line In 2 as the input for front
-         * panel mic (mic 2)
-         */
-        /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
-        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_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 */
-        {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-        {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-        {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-
-        /* set up input amps for analog loopback */
-        /* Amp Indices: DAC = 0, mixer = 1 */
-        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-
-
-        /* FIXME: use matrix-type input source selection */
-        /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
-        /* Input mixer */
-        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-        { }
-};
-
-/* additional verbs for ALC663 */
-static struct hda_verb alc663_auto_init_verbs[] = {
-        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
-        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-        { }
-};
-
 static struct hda_verb alc663_m51va_init_verbs[] = {
         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
@@ -16370,6 +17191,45 @@ static struct hda_verb alc272_dell_init_verbs[] = {
         {}
 };
 
+static struct hda_verb alc663_mode7_init_verbs[] = {
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
+        {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
+        {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
+        {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
+        {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
+        {}
+};
+
+static struct hda_verb alc663_mode8_init_verbs[] = {
+        {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {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, 0x01},
+        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
+        {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
+        {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
+        {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
+        {}
+};
+
 static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
@@ -16387,9 +17247,9 @@ static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
         unsigned int present;
         unsigned char bits;
 
-        present = snd_hda_codec_read(codec, 0x14, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
+        present = snd_hda_jack_detect(codec, 0x14);
         bits = present ? HDA_AMP_MUTE : 0;
+
         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
                                  HDA_AMP_MUTE, bits);
 }
@@ -16399,9 +17259,9 @@ static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
         unsigned int present;
         unsigned char bits;
 
-        present = snd_hda_codec_read(codec, 0x1b, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
+        present = snd_hda_jack_detect(codec, 0x1b);
         bits = present ? HDA_AMP_MUTE : 0;
+
         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
                                  HDA_AMP_MUTE, bits);
         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
@@ -16460,14 +17320,12 @@ static void alc663_m51va_speaker_automute(struct hda_codec *codec)
         unsigned int present;
         unsigned char bits;
 
-        present = snd_hda_codec_read(codec, 0x21, 0,
-                        AC_VERB_GET_PIN_SENSE, 0)
-                        & AC_PINSENSE_PRESENCE;
+        present = snd_hda_jack_detect(codec, 0x21);
         bits = present ? HDA_AMP_MUTE : 0;
         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
-                                AMP_IN_MUTE(0), bits);
+                                 HDA_AMP_MUTE, bits);
         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
-                                AMP_IN_MUTE(0), bits);
+                                 HDA_AMP_MUTE, bits);
 }
 
 static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
@@ -16475,18 +17333,16 @@ static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
         unsigned int present;
         unsigned char bits;
 
-        present = snd_hda_codec_read(codec, 0x21, 0,
-                        AC_VERB_GET_PIN_SENSE, 0)
-                        & AC_PINSENSE_PRESENCE;
+        present = snd_hda_jack_detect(codec, 0x21);
         bits = present ? HDA_AMP_MUTE : 0;
         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
-                                AMP_IN_MUTE(0), bits);
+                                 HDA_AMP_MUTE, bits);
         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
-                                AMP_IN_MUTE(0), bits);
+                                 HDA_AMP_MUTE, bits);
         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
-                                AMP_IN_MUTE(0), bits);
+                                 HDA_AMP_MUTE, bits);
         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
-                                AMP_IN_MUTE(0), bits);
+                                 HDA_AMP_MUTE, bits);
 }
 
 static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
@@ -16494,18 +17350,16 @@ static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
         unsigned int present;
         unsigned char bits;
 
-        present = snd_hda_codec_read(codec, 0x15, 0,
-                        AC_VERB_GET_PIN_SENSE, 0)
-                        & AC_PINSENSE_PRESENCE;
+        present = snd_hda_jack_detect(codec, 0x15);
         bits = present ? HDA_AMP_MUTE : 0;
         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
-                                AMP_IN_MUTE(0), bits);
+                                 HDA_AMP_MUTE, bits);
         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
-                                AMP_IN_MUTE(0), bits);
+                                 HDA_AMP_MUTE, bits);
         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
-                                AMP_IN_MUTE(0), bits);
+                                 HDA_AMP_MUTE, bits);
         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
-                                AMP_IN_MUTE(0), bits);
+                                 HDA_AMP_MUTE, bits);
 }
 
 static void alc662_f5z_speaker_automute(struct hda_codec *codec)
@@ -16513,9 +17367,7 @@ static void alc662_f5z_speaker_automute(struct hda_codec *codec)
         unsigned int present;
         unsigned char bits;
 
-        present = snd_hda_codec_read(codec, 0x1b, 0,
-                        AC_VERB_GET_PIN_SENSE, 0)
-                        & AC_PINSENSE_PRESENCE;
+        present = snd_hda_jack_detect(codec, 0x1b);
         bits = present ? 0 : PIN_OUT;
         snd_hda_codec_write(codec, 0x14, 0,
                          AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
@@ -16525,12 +17377,8 @@ static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec)
 {
         unsigned int present1, present2;
 
-        present1 = snd_hda_codec_read(codec, 0x21, 0,
-                        AC_VERB_GET_PIN_SENSE, 0)
-                        & AC_PINSENSE_PRESENCE;
-        present2 = snd_hda_codec_read(codec, 0x15, 0,
-                        AC_VERB_GET_PIN_SENSE, 0)
-                        & AC_PINSENSE_PRESENCE;
+        present1 = snd_hda_jack_detect(codec, 0x21);
+        present2 = snd_hda_jack_detect(codec, 0x15);
 
         if (present1 || present2) {
                 snd_hda_codec_write_cache(codec, 0x14, 0,
@@ -16545,23 +17393,67 @@ static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
 {
         unsigned int present1, present2;
 
-        present1 = snd_hda_codec_read(codec, 0x1b, 0,
-                                AC_VERB_GET_PIN_SENSE, 0)
-                                & AC_PINSENSE_PRESENCE;
-        present2 = snd_hda_codec_read(codec, 0x15, 0,
-                                AC_VERB_GET_PIN_SENSE, 0)
-                                & AC_PINSENSE_PRESENCE;
+        present1 = snd_hda_jack_detect(codec, 0x1b);
+        present2 = snd_hda_jack_detect(codec, 0x15);
 
         if (present1 || present2) {
                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
-                                AMP_IN_MUTE(0), AMP_IN_MUTE(0));
+                                         HDA_AMP_MUTE, HDA_AMP_MUTE);
                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
-                                AMP_IN_MUTE(0), AMP_IN_MUTE(0));
+                                         HDA_AMP_MUTE, HDA_AMP_MUTE);
         } else {
                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
-                                AMP_IN_MUTE(0), 0);
+                                         HDA_AMP_MUTE, 0);
                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
-                                AMP_IN_MUTE(0), 0);
+                                         HDA_AMP_MUTE, 0);
+        }
+}
+
+static void alc663_two_hp_m7_speaker_automute(struct hda_codec *codec)
+{
+        unsigned int present1, present2;
+
+        present1 = snd_hda_codec_read(codec, 0x1b, 0,
+                        AC_VERB_GET_PIN_SENSE, 0)
+                        & AC_PINSENSE_PRESENCE;
+        present2 = snd_hda_codec_read(codec, 0x21, 0,
+                        AC_VERB_GET_PIN_SENSE, 0)
+                        & AC_PINSENSE_PRESENCE;
+
+        if (present1 || present2) {
+                snd_hda_codec_write_cache(codec, 0x14, 0,
+                        AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
+                snd_hda_codec_write_cache(codec, 0x17, 0,
+                        AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
+        } else {
+                snd_hda_codec_write_cache(codec, 0x14, 0,
+                        AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
+                snd_hda_codec_write_cache(codec, 0x17, 0,
+                        AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
+        }
+}
+
+static void alc663_two_hp_m8_speaker_automute(struct hda_codec *codec)
+{
+        unsigned int present1, present2;
+
+        present1 = snd_hda_codec_read(codec, 0x21, 0,
+                        AC_VERB_GET_PIN_SENSE, 0)
+                        & AC_PINSENSE_PRESENCE;
+        present2 = snd_hda_codec_read(codec, 0x15, 0,
+                        AC_VERB_GET_PIN_SENSE, 0)
+                        & AC_PINSENSE_PRESENCE;
+
+        if (present1 || present2) {
+                snd_hda_codec_write_cache(codec, 0x14, 0,
+                        AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
+                snd_hda_codec_write_cache(codec, 0x17, 0,
+                        AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
+        } else {
+                snd_hda_codec_write_cache(codec, 0x14, 0,
+                        AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
+                snd_hda_codec_write_cache(codec, 0x17, 0,
+                        AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
         }
 }
 
@@ -16584,7 +17476,7 @@ static void alc663_m51va_setup(struct hda_codec *codec)
         spec->ext_mic.pin = 0x18;
         spec->ext_mic.mux_idx = 0;
         spec->int_mic.pin = 0x12;
-        spec->int_mic.mux_idx = 1;
+        spec->int_mic.mux_idx = 9;
         spec->auto_mic = 1;
 }
 
@@ -16596,7 +17488,17 @@ static void alc663_m51va_inithook(struct hda_codec *codec)
 
 /* ***************** Mode1 ******************************/
 #define alc663_mode1_unsol_event        alc663_m51va_unsol_event
-#define alc663_mode1_setup              alc663_m51va_setup
+
+static void alc663_mode1_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;
+}
+
 #define alc663_mode1_inithook           alc663_m51va_inithook
 
 /* ***************** Mode2 ******************************/
@@ -16613,7 +17515,7 @@ static void alc662_mode2_unsol_event(struct hda_codec *codec,
         }
 }
 
-#define alc662_mode2_setup      alc663_m51va_setup
+#define alc662_mode2_setup      alc663_mode1_setup
 
 static void alc662_mode2_inithook(struct hda_codec *codec)
 {
@@ -16634,7 +17536,7 @@ static void alc663_mode3_unsol_event(struct hda_codec *codec,
         }
 }
 
-#define alc663_mode3_setup      alc663_m51va_setup
+#define alc663_mode3_setup      alc663_mode1_setup
 
 static void alc663_mode3_inithook(struct hda_codec *codec)
 {
@@ -16655,7 +17557,7 @@ static void alc663_mode4_unsol_event(struct hda_codec *codec,
         }
 }
 
-#define alc663_mode4_setup      alc663_m51va_setup
+#define alc663_mode4_setup      alc663_mode1_setup
 
 static void alc663_mode4_inithook(struct hda_codec *codec)
 {
@@ -16676,7 +17578,7 @@ static void alc663_mode5_unsol_event(struct hda_codec *codec,
         }
 }
 
-#define alc663_mode5_setup      alc663_m51va_setup
+#define alc663_mode5_setup      alc663_mode1_setup
 
 static void alc663_mode5_inithook(struct hda_codec *codec)
 {
@@ -16697,7 +17599,7 @@ static void alc663_mode6_unsol_event(struct hda_codec *codec,
         }
 }
 
-#define alc663_mode6_setup      alc663_m51va_setup
+#define alc663_mode6_setup      alc663_mode1_setup
 
 static void alc663_mode6_inithook(struct hda_codec *codec)
 {
@@ -16705,14 +17607,56 @@ static void alc663_mode6_inithook(struct hda_codec *codec)
         alc_mic_automute(codec);
 }
 
+/* ***************** Mode7 ******************************/
+static void alc663_mode7_unsol_event(struct hda_codec *codec,
+                                           unsigned int res)
+{
+        switch (res >> 26) {
+        case ALC880_HP_EVENT:
+                alc663_two_hp_m7_speaker_automute(codec);
+                break;
+        case ALC880_MIC_EVENT:
+                alc_mic_automute(codec);
+                break;
+        }
+}
+
+#define alc663_mode7_setup      alc663_mode1_setup
+
+static void alc663_mode7_inithook(struct hda_codec *codec)
+{
+        alc663_two_hp_m7_speaker_automute(codec);
+        alc_mic_automute(codec);
+}
+
+/* ***************** Mode8 ******************************/
+static void alc663_mode8_unsol_event(struct hda_codec *codec,
+                                           unsigned int res)
+{
+        switch (res >> 26) {
+        case ALC880_HP_EVENT:
+                alc663_two_hp_m8_speaker_automute(codec);
+                break;
+        case ALC880_MIC_EVENT:
+                alc_mic_automute(codec);
+                break;
+        }
+}
+
+#define alc663_mode8_setup      alc663_m51va_setup
+
+static void alc663_mode8_inithook(struct hda_codec *codec)
+{
+        alc663_two_hp_m8_speaker_automute(codec);
+        alc_mic_automute(codec);
+}
+
 static void alc663_g71v_hp_automute(struct hda_codec *codec)
 {
         unsigned int present;
         unsigned char bits;
 
-        present = snd_hda_codec_read(codec, 0x21, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0)
-                & AC_PINSENSE_PRESENCE;
+        present = snd_hda_jack_detect(codec, 0x21);
         bits = present ? HDA_AMP_MUTE : 0;
         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
                                  HDA_AMP_MUTE, bits);
@@ -16725,9 +17669,7 @@ static void alc663_g71v_front_automute(struct hda_codec *codec)
         unsigned int present;
         unsigned char bits;
 
-        present = snd_hda_codec_read(codec, 0x15, 0,
-                                     AC_VERB_GET_PIN_SENSE, 0)
-                & AC_PINSENSE_PRESENCE;
+        present = snd_hda_jack_detect(codec, 0x15);
         bits = present ? HDA_AMP_MUTE : 0;
         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
                                  HDA_AMP_MUTE, bits);
@@ -16843,6 +17785,8 @@ static const char *alc662_models[ALC662_MODEL_LAST] = {
         [ALC663_ASUS_MODE4] = "asus-mode4",
         [ALC663_ASUS_MODE5] = "asus-mode5",
         [ALC663_ASUS_MODE6] = "asus-mode6",
+        [ALC663_ASUS_MODE7] = "asus-mode7",
+        [ALC663_ASUS_MODE8] = "asus-mode8",
         [ALC272_DELL]           = "dell",
         [ALC272_DELL_ZM1]       = "dell-zm1",
         [ALC272_SAMSUNG_NC10]   = "samsung-nc10",
@@ -16855,16 +17799,27 @@ static struct snd_pci_quirk alc662_cfg_tbl[] = {
         SND_PCI_QUIRK(0x1028, 0x02f4, "DELL ZM1", ALC272_DELL_ZM1),
         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
+        SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC663_ASUS_MODE1),
         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
+        SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC663_ASUS_MODE1),
+        SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC663_ASUS_MODE1),
         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
+        SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC663_ASUS_MODE7),
+        SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC663_ASUS_MODE7),
+        SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC663_ASUS_MODE8),
+        SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC663_ASUS_MODE3),
+        SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC663_ASUS_MODE1),
         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
+        SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_ASUS_MODE2),
+        SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC663_ASUS_MODE1),
         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
+        SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC663_ASUS_MODE1),
         SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC663_ASUS_MODE3),
         SND_PCI_QUIRK(0x1043, 0x17c3, "ASUS UX20", ALC663_ASUS_M51VA),
         SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_ASUS_MODE2),
@@ -16880,6 +17835,7 @@ static struct snd_pci_quirk alc662_cfg_tbl[] = {
         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
         SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC663_ASUS_MODE1),
+        SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC663_ASUS_MODE1),
         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC663_ASUS_MODE1),
         SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC663_ASUS_MODE1),
         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
@@ -16903,10 +17859,11 @@ static struct snd_pci_quirk alc662_cfg_tbl[] = {
         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
         SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
                       ALC662_3ST_6ch_DIG),
-        SND_PCI_QUIRK(0x1179, 0xff6e, "Toshiba NB200", ALC663_ASUS_MODE4),
+        SND_PCI_QUIRK(0x1179, 0xff6e, "Toshiba NB20x", ALC662_AUTO),
         SND_PCI_QUIRK(0x144d, 0xca00, "Samsung NC10", ALC272_SAMSUNG_NC10),
         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
                       ALC662_3ST_6ch_DIG),
+        SND_PCI_QUIRK(0x152d, 0x2304, "Quanta WH1", ALC663_ASUS_H13),
         SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
         SND_PCI_QUIRK(0x1631, 0xc10c, "PB RS65", ALC663_ASUS_M51VA),
         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
@@ -17147,6 +18104,36 @@ static struct alc_config_preset alc662_presets[] = {
                 .setup = alc663_mode6_setup,
                 .init_hook = alc663_mode6_inithook,
         },
+        [ALC663_ASUS_MODE7] = {
+                .mixers = { alc663_mode7_mixer },
+                .cap_mixer = alc662_auto_capture_mixer,
+                .init_verbs = { alc662_init_verbs,
+                                alc663_mode7_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc662_dac_nids),
+                .hp_nid = 0x03,
+                .dac_nids = alc662_dac_nids,
+                .dig_out_nid = ALC662_DIGOUT_NID,
+                .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
+                .channel_mode = alc662_3ST_2ch_modes,
+                .unsol_event = alc663_mode7_unsol_event,
+                .setup = alc663_mode7_setup,
+                .init_hook = alc663_mode7_inithook,
+        },
+        [ALC663_ASUS_MODE8] = {
+                .mixers = { alc663_mode8_mixer },
+                .cap_mixer = alc662_auto_capture_mixer,
+                .init_verbs = { alc662_init_verbs,
+                                alc663_mode8_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc662_dac_nids),
+                .hp_nid = 0x03,
+                .dac_nids = alc662_dac_nids,
+                .dig_out_nid = ALC662_DIGOUT_NID,
+                .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
+                .channel_mode = alc662_3ST_2ch_modes,
+                .unsol_event = alc663_mode8_unsol_event,
+                .setup = alc663_mode8_setup,
+                .init_hook = alc663_mode8_inithook,
+        },
         [ALC272_DELL] = {
                 .mixers = { alc663_m51va_mixer },
                 .cap_mixer = alc272_auto_capture_mixer,
@@ -17264,21 +18251,17 @@ static int alc662_auto_fill_dac_nids(struct hda_codec *codec,
         return 0;
 }
 
-static int alc662_add_vol_ctl(struct alc_spec *spec, const char *pfx,
+static inline int alc662_add_vol_ctl(struct alc_spec *spec, const char *pfx,
                               hda_nid_t nid, unsigned int chs)
 {
-        char name[32];
-        sprintf(name, "%s Playback Volume", pfx);
-        return add_control(spec, ALC_CTL_WIDGET_VOL, name,
+        return add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
 }
 
-static int alc662_add_sw_ctl(struct alc_spec *spec, const char *pfx,
+static inline int alc662_add_sw_ctl(struct alc_spec *spec, const char *pfx,
                              hda_nid_t nid, unsigned int chs)
 {
-        char name[32];
-        sprintf(name, "%s Playback Switch", pfx);
-        return add_control(spec, ALC_CTL_WIDGET_MUTE, name,
+        return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT));
 }
 
@@ -17356,13 +18339,11 @@ static int alc662_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
                 return 0;
         nid = alc662_look_for_dac(codec, pin);
         if (!nid) {
-                char name[32];
                 /* the corresponding DAC is already occupied */
                 if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP))
                         return 0; /* no way */
                 /* create a switch only */
-                sprintf(name, "%s Playback Switch", pfx);
-                return add_control(spec, ALC_CTL_WIDGET_MUTE, name,
+                return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
                                    HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
         }
 
@@ -17500,15 +18481,23 @@ static int alc662_parse_auto_config(struct hda_codec *codec)
         spec->num_mux_defs = 1;
         spec->input_mux = &spec->private_imux[0];
 
-        add_verb(spec, alc662_auto_init_verbs);
-        if (codec->vendor_id == 0x10ec0663)
-                add_verb(spec, alc663_auto_init_verbs);
+        add_verb(spec, alc662_init_verbs);
+        if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
+            codec->vendor_id == 0x10ec0665)
+                add_verb(spec, alc663_init_verbs);
+
+        if (codec->vendor_id == 0x10ec0272)
+                add_verb(spec, alc272_init_verbs);
 
         err = alc_auto_add_mic_boost(codec);
         if (err < 0)
                 return err;
 
-        alc_ssid_check(codec, 0x15, 0x1b, 0x14);
+        if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
+            codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
+            alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0x21);
+        else
+            alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
 
         return 1;
 }
@@ -17538,6 +18527,15 @@ static int patch_alc662(struct hda_codec *codec)
 
         alc_fix_pll_init(codec, 0x20, 0x04, 15);
 
+        if (alc_read_coef_idx(codec, 0)==0x8020){
+                kfree(codec->chip_name);
+                codec->chip_name = kstrdup("ALC661", GFP_KERNEL);
+                if (!codec->chip_name) {
+                        alc_free(codec);
+                        return -ENOMEM;
+                }
+        }
+
         board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
                                                   alc662_models,
                                                   alc662_cfg_tbl);
@@ -17585,11 +18583,20 @@ static int patch_alc662(struct hda_codec *codec)
 
         if (!spec->cap_mixer)
                 set_capture_mixer(codec);
-        if (codec->vendor_id == 0x10ec0662)
+
+        switch (codec->vendor_id) {
+        case 0x10ec0662:
                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
-        else
+                break;
+        case 0x10ec0272:
+        case 0x10ec0663:
+        case 0x10ec0665:
                 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
-
+                break;
+        case 0x10ec0273:
+                set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
+                break;
+        }
         spec->vmaster_nid = 0x02;
 
         codec->patch_ops = alc_patch_ops;
@@ -17599,11 +18606,24 @@ static int patch_alc662(struct hda_codec *codec)
         if (!spec->loopback.amplist)
                 spec->loopback.amplist = alc662_loopbacks;
 #endif
-        codec->proc_widget_hook = print_realtek_coef;
 
         return 0;
 }
 
+static int patch_alc888(struct hda_codec *codec)
+{
+        if ((alc_read_coef_idx(codec, 0) & 0x00f0)==0x0030){
+                kfree(codec->chip_name);
+                codec->chip_name = kstrdup("ALC888-VD", GFP_KERNEL);
+                if (!codec->chip_name) {
+                        alc_free(codec);
+                        return -ENOMEM;
+                }
+                return patch_alc662(codec);
+        }
+        return patch_alc882(codec);
+}
+
 /*
  * patch entries
  */
@@ -17613,7 +18633,9 @@ static struct hda_codec_preset snd_hda_preset_realtek[] = {
         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
+        { .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
         { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
+        { .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
           .patch = patch_alc861 },
         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
@@ -17624,6 +18646,8 @@ static struct hda_codec_preset snd_hda_preset_realtek[] = {
         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
           .patch = patch_alc662 },
         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
+        { .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
+        { .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
@@ -17635,8 +18659,9 @@ static struct hda_codec_preset snd_hda_preset_realtek[] = {
         { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc882 },
         { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
           .patch = patch_alc882 },
-        { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc882 },
+        { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc888 },
         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
+        { .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
         {} /* terminator */
 };
 
diff --git a/sound/pci/hda/patch_si3054.c b/sound/pci/hda/patch_si3054.c
index 43b436c5d01b..f419ee8d75f0 100644
--- a/sound/pci/hda/patch_si3054.c
+++ b/sound/pci/hda/patch_si3054.c
@@ -122,6 +122,7 @@ static int si3054_switch_put(struct snd_kcontrol *kcontrol,
 #define SI3054_KCONTROL(kname,reg,mask) { \
         .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
         .name = kname, \
+        .subdevice = HDA_SUBDEV_NID_FLAG | reg, \
         .info = si3054_switch_info, \
         .get  = si3054_switch_get, \
         .put  = si3054_switch_put, \
diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c
index 86de305fc9f2..a0e06d82da1f 100644
--- a/sound/pci/hda/patch_sigmatel.c
+++ b/sound/pci/hda/patch_sigmatel.c
@@ -93,6 +93,7 @@ enum {
         STAC_92HD83XXX_REF,
         STAC_92HD83XXX_PWR_REF,
         STAC_DELL_S14,
+        STAC_92HD83XXX_HP,
         STAC_92HD83XXX_MODELS
 };
 
@@ -103,6 +104,7 @@ enum {
         STAC_DELL_M4_2,
         STAC_DELL_M4_3,
         STAC_HP_M4,
+        STAC_HP_DV4,
         STAC_HP_DV5,
         STAC_HP_HDX,
         STAC_HP_DV4_1222NR,
@@ -208,6 +210,7 @@ struct sigmatel_spec {
         unsigned int gpio_data;
         unsigned int gpio_mute;
         unsigned int gpio_led;
+        unsigned int gpio_led_polarity;
 
         /* stream */
         unsigned int stream_delay;
@@ -566,6 +569,11 @@ static hda_nid_t stac92hd83xxx_pin_nids[10] = {
         0x0f, 0x10, 0x11, 0x1f, 0x20,
 };
 
+static hda_nid_t stac92hd88xxx_pin_nids[10] = {
+        0x0a, 0x0b, 0x0c, 0x0d,
+        0x0f, 0x11, 0x1f, 0x20,
+};
+
 #define STAC92HD71BXX_NUM_PINS 13
 static hda_nid_t stac92hd71bxx_pin_nids_4port[STAC92HD71BXX_NUM_PINS] = {
         0x0a, 0x0b, 0x0c, 0x0d, 0x00,
@@ -1085,7 +1093,7 @@ static int stac92xx_build_controls(struct hda_codec *codec)
         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,
+                err = snd_hda_ctl_add(codec, 0,
                                   snd_ctl_new1(&stac_dmux_mixer, codec));
                 if (err < 0)
                         return err;
@@ -1101,7 +1109,7 @@ static int stac92xx_build_controls(struct hda_codec *codec)
                         spec->spdif_mute = 1;
                 }
                 stac_smux_mixer.count = spec->num_smuxes;
-                err = snd_hda_ctl_add(codec,
+                err = snd_hda_ctl_add(codec, 0,
                                   snd_ctl_new1(&stac_smux_mixer, codec));
                 if (err < 0)
                         return err;
@@ -1537,6 +1545,11 @@ static unsigned int alienware_m17x_pin_configs[13] = {
         0x904601b0,
 };
 
+static unsigned int intel_dg45id_pin_configs[13] = {
+        0x02214230, 0x02A19240, 0x01013214, 0x01014210,
+        0x01A19250, 0x01011212, 0x01016211
+};
+
 static unsigned int *stac92hd73xx_brd_tbl[STAC_92HD73XX_MODELS] = {
         [STAC_92HD73XX_REF]     = ref92hd73xx_pin_configs,
         [STAC_DELL_M6_AMIC]     = dell_m6_pin_configs,
@@ -1544,6 +1557,7 @@ static unsigned int *stac92hd73xx_brd_tbl[STAC_92HD73XX_MODELS] = {
         [STAC_DELL_M6_BOTH]     = dell_m6_pin_configs,
         [STAC_DELL_EQ]  = dell_m6_pin_configs,
         [STAC_ALIENWARE_M17X]   = alienware_m17x_pin_configs,
+        [STAC_92HD73XX_INTEL]   = intel_dg45id_pin_configs,
 };
 
 static const char *stac92hd73xx_models[STAC_92HD73XX_MODELS] = {
@@ -1592,6 +1606,10 @@ static struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = {
                                 "Dell Studio 1555", STAC_DELL_M6_DMIC),
         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02bd,
                                 "Dell Studio 1557", STAC_DELL_M6_DMIC),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02fe,
+                                "Dell Studio XPS 1645", STAC_DELL_M6_BOTH),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0413,
+                                "Dell Studio 1558", STAC_DELL_M6_BOTH),
         {} /* terminator */
 };
 
@@ -1624,6 +1642,7 @@ static const char *stac92hd83xxx_models[STAC_92HD83XXX_MODELS] = {
         [STAC_92HD83XXX_REF] = "ref",
         [STAC_92HD83XXX_PWR_REF] = "mic-ref",
         [STAC_DELL_S14] = "dell-s14",
+        [STAC_92HD83XXX_HP] = "hp",
 };
 
 static struct snd_pci_quirk stac92hd83xxx_cfg_tbl[] = {
@@ -1634,6 +1653,8 @@ static struct snd_pci_quirk stac92hd83xxx_cfg_tbl[] = {
                       "DFI LanParty", STAC_92HD83XXX_REF),
         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ba,
                       "unknown Dell", STAC_DELL_S14),
+        SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xff00, 0x3600,
+                      "HP", STAC_92HD83XXX_HP),
         {} /* terminator */
 };
 
@@ -1671,6 +1692,7 @@ static unsigned int *stac92hd71bxx_brd_tbl[STAC_92HD71BXX_MODELS] = {
         [STAC_DELL_M4_2]        = dell_m4_2_pin_configs,
         [STAC_DELL_M4_3]        = dell_m4_3_pin_configs,
         [STAC_HP_M4]            = NULL,
+        [STAC_HP_DV4]           = NULL,
         [STAC_HP_DV5]           = NULL,
         [STAC_HP_HDX]           = NULL,
         [STAC_HP_DV4_1222NR]    = NULL,
@@ -1683,6 +1705,7 @@ static const char *stac92hd71bxx_models[STAC_92HD71BXX_MODELS] = {
         [STAC_DELL_M4_2] = "dell-m4-2",
         [STAC_DELL_M4_3] = "dell-m4-3",
         [STAC_HP_M4] = "hp-m4",
+        [STAC_HP_DV4] = "hp-dv4",
         [STAC_HP_DV5] = "hp-dv5",
         [STAC_HP_HDX] = "hp-hdx",
         [STAC_HP_DV4_1222NR] = "hp-dv4-1222nr",
@@ -1701,7 +1724,7 @@ static struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = {
         SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3080,
                       "HP", STAC_HP_DV5),
         SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x30f0,
-                      "HP dv4-7", STAC_HP_DV5),
+                      "HP dv4-7", STAC_HP_DV4),
         SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3600,
                       "HP dv4-7", STAC_HP_DV5),
         SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3610,
@@ -1712,6 +1735,8 @@ static struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = {
                       "HP HDX", STAC_HP_HDX),  /* HDX16 */
         SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3620,
                       "HP dv6", STAC_HP_DV5),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3061,
+                      "HP dv6", STAC_HP_DV5), /* HP dv6-1110ax */
         SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x7010,
                       "HP", STAC_HP_DV5),
         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0233,
@@ -2091,6 +2116,7 @@ static unsigned int ref9205_pin_configs[12] = {
     10280204
     1028021F
     10280228 (Dell Vostro 1500)
+    10280229 (Dell Vostro 1700)
 */
 static unsigned int dell_9205_m42_pin_configs[12] = {
         0x0321101F, 0x03A11020, 0x400003FA, 0x90170310,
@@ -2176,6 +2202,8 @@ static struct snd_pci_quirk stac9205_cfg_tbl[] = {
                       "Dell Inspiron", STAC_9205_DELL_M44),
         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0228,
                       "Dell Vostro 1500", STAC_9205_DELL_M42),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0229,
+                      "Dell Vostro 1700", 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),
@@ -2648,6 +2676,7 @@ static int stac92xx_clfe_switch_put(struct snd_kcontrol *kcontrol,
 enum {
         STAC_CTL_WIDGET_VOL,
         STAC_CTL_WIDGET_MUTE,
+        STAC_CTL_WIDGET_MUTE_BEEP,
         STAC_CTL_WIDGET_MONO_MUX,
         STAC_CTL_WIDGET_HP_SWITCH,
         STAC_CTL_WIDGET_IO_SWITCH,
@@ -2658,6 +2687,7 @@ enum {
 static struct snd_kcontrol_new stac92xx_control_templates[] = {
         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
         HDA_CODEC_MUTE(NULL, 0, 0, 0),
+        HDA_CODEC_MUTE_BEEP(NULL, 0, 0, 0),
         STAC_MONO_MUX,
         STAC_CODEC_HP_SWITCH(NULL),
         STAC_CODEC_IO_SWITCH(NULL, 0),
@@ -2669,7 +2699,8 @@ static struct snd_kcontrol_new stac92xx_control_templates[] = {
 static struct snd_kcontrol_new *
 stac_control_new(struct sigmatel_spec *spec,
                  struct snd_kcontrol_new *ktemp,
-                 const char *name)
+                 const char *name,
+                 unsigned int subdev)
 {
         struct snd_kcontrol_new *knew;
 
@@ -2685,6 +2716,7 @@ stac_control_new(struct sigmatel_spec *spec,
                 spec->kctls.alloced--;
                 return NULL;
         }
+        knew->subdevice = subdev;
         return knew;
 }
 
@@ -2693,7 +2725,8 @@ static int stac92xx_add_control_temp(struct sigmatel_spec *spec,
                                      int idx, const char *name,
                                      unsigned long val)
 {
-        struct snd_kcontrol_new *knew = stac_control_new(spec, ktemp, name);
+        struct snd_kcontrol_new *knew = stac_control_new(spec, ktemp, name,
+                                                         HDA_SUBDEV_AMP_FLAG);
         if (!knew)
                 return -ENOMEM;
         knew->index = idx;
@@ -2764,7 +2797,7 @@ static int stac92xx_add_input_source(struct sigmatel_spec *spec)
         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,
-                                stac_input_src_temp.name);
+                                stac_input_src_temp.name, 0);
         if (!knew)
                 return -ENOMEM;
         knew->count = spec->num_adcs;
@@ -2852,6 +2885,13 @@ static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid)
 
         conn_len = snd_hda_get_connections(codec, nid, conn,
                                            HDA_MAX_CONNECTIONS);
+        /* 92HD88: trace back up the link of nids to find the DAC */
+        while (conn_len == 1 && (get_wcaps_type(get_wcaps(codec, conn[0]))
+                                        != AC_WID_AUD_OUT)) {
+                nid = conn[0];
+                conn_len = snd_hda_get_connections(codec, nid, conn,
+                        HDA_MAX_CONNECTIONS);
+        }
         for (j = 0; j < conn_len; j++) {
                 wcaps = get_wcaps(codec, conn[j]);
                 wtype = get_wcaps_type(wcaps);
@@ -3221,12 +3261,15 @@ static int stac92xx_auto_create_beep_ctls(struct hda_codec *codec,
 {
         struct sigmatel_spec *spec = codec->spec;
         u32 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
-        int err;
+        int err, type = STAC_CTL_WIDGET_MUTE_BEEP;
+
+        if (spec->anabeep_nid == nid)
+                type = STAC_CTL_WIDGET_MUTE;
 
         /* check for mute support for the the amp */
         if ((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT) {
-                err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
-                        "PC Beep Playback Switch",
+                err = stac92xx_add_control(spec, type,
+                        "Beep Playback Switch",
                         HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
                         if (err < 0)
                                 return err;
@@ -3235,7 +3278,7 @@ static int stac92xx_auto_create_beep_ctls(struct hda_codec *codec,
         /* check to see if there is volume support for the amp */
         if ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) {
                 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL,
-                        "PC Beep Playback Volume",
+                        "Beep Playback Volume",
                         HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
                         if (err < 0)
                                 return err;
@@ -3258,12 +3301,7 @@ static int stac92xx_dig_beep_switch_put(struct snd_kcontrol *kcontrol,
                                         struct snd_ctl_elem_value *ucontrol)
 {
         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-        int enabled = !!ucontrol->value.integer.value[0];
-        if (codec->beep->enabled != enabled) {
-                codec->beep->enabled = enabled;
-                return 1;
-        }
-        return 0;
+        return snd_hda_enable_beep_device(codec, ucontrol->value.integer.value[0]);
 }
 
 static struct snd_kcontrol_new stac92xx_dig_beep_ctrl = {
@@ -3276,7 +3314,7 @@ static struct snd_kcontrol_new stac92xx_dig_beep_ctrl = {
 static int stac92xx_beep_switch_ctl(struct hda_codec *codec)
 {
         return stac92xx_add_control_temp(codec->spec, &stac92xx_dig_beep_ctrl,
-                                         0, "PC Beep Playback Switch", 0);
+                                         0, "Beep Playback Switch", 0);
 }
 #endif
 
@@ -3631,6 +3669,26 @@ static void stac92xx_auto_init_hp_out(struct hda_codec *codec)
         }
 }
 
+static int is_dual_headphones(struct hda_codec *codec)
+{
+        struct sigmatel_spec *spec = codec->spec;
+        int i, valid_hps;
+
+        if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT ||
+            spec->autocfg.hp_outs <= 1)
+                return 0;
+        valid_hps = 0;
+        for (i = 0; i < spec->autocfg.hp_outs; i++) {
+                hda_nid_t nid = spec->autocfg.hp_pins[i];
+                unsigned int cfg = snd_hda_codec_get_pincfg(codec, nid);
+                if (get_defcfg_location(cfg) & AC_JACK_LOC_SEPARATE)
+                        continue;
+                valid_hps++;
+        }
+        return (valid_hps > 1);
+}
+
+
 static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out, hda_nid_t dig_in)
 {
         struct sigmatel_spec *spec = codec->spec;
@@ -3647,8 +3705,7 @@ static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out
         /* If we have no real line-out pin and multiple hp-outs, HPs should
          * be set up as multi-channel outputs.
          */
-        if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
-            spec->autocfg.hp_outs > 1) {
+        if (is_dual_headphones(codec)) {
                 /* Copy hp_outs to line_outs, backup line_outs in
                  * speaker_outs so that the following routines can handle
                  * HP pins as primary outputs.
@@ -3743,15 +3800,16 @@ static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out
                 err = snd_hda_attach_beep_device(codec, nid);
                 if (err < 0)
                         return err;
-                /* IDT/STAC codecs have linear beep tone parameter */
-                codec->beep->linear_tone = 1;
-                /* if no beep switch is available, make its own one */
-                caps = query_amp_caps(codec, nid, HDA_OUTPUT);
-                if (codec->beep &&
-                    !((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT)) {
-                        err = stac92xx_beep_switch_ctl(codec);
-                        if (err < 0)
-                                return err;
+                if (codec->beep) {
+                        /* IDT/STAC codecs have linear beep tone parameter */
+                        codec->beep->linear_tone = 1;
+                        /* if no beep switch is available, make its own one */
+                        caps = query_amp_caps(codec, nid, HDA_OUTPUT);
+                        if (!(caps & AC_AMPCAP_MUTE)) {
+                                err = stac92xx_beep_switch_ctl(codec);
+                                if (err < 0)
+                                        return err;
+                        }
                 }
         }
 #endif
@@ -4120,34 +4178,52 @@ static void stac92xx_power_down(struct hda_codec *codec)
 static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
                                   int enable);
 
+static inline int get_int_hint(struct hda_codec *codec, const char *key,
+                               int *valp)
+{
+        const char *p;
+        p = snd_hda_get_hint(codec, key);
+        if (p) {
+                unsigned long val;
+                if (!strict_strtoul(p, 0, &val)) {
+                        *valp = val;
+                        return 1;
+                }
+        }
+        return 0;
+}
+
 /* override some hints from the hwdep entry */
 static void stac_store_hints(struct hda_codec *codec)
 {
         struct sigmatel_spec *spec = codec->spec;
-        const char *p;
         int val;
 
         val = snd_hda_get_bool_hint(codec, "hp_detect");
         if (val >= 0)
                 spec->hp_detect = val;
-        p = snd_hda_get_hint(codec, "gpio_mask");
-        if (p) {
-                spec->gpio_mask = simple_strtoul(p, NULL, 0);
+        if (get_int_hint(codec, "gpio_mask", &spec->gpio_mask)) {
                 spec->eapd_mask = spec->gpio_dir = spec->gpio_data =
                         spec->gpio_mask;
         }
-        p = snd_hda_get_hint(codec, "gpio_dir");
-        if (p)
-                spec->gpio_dir = simple_strtoul(p, NULL, 0) & spec->gpio_mask;
-        p = snd_hda_get_hint(codec, "gpio_data");
-        if (p)
-                spec->gpio_data = simple_strtoul(p, NULL, 0) & spec->gpio_mask;
-        p = snd_hda_get_hint(codec, "eapd_mask");
-        if (p)
-                spec->eapd_mask = simple_strtoul(p, NULL, 0) & spec->gpio_mask;
+        if (get_int_hint(codec, "gpio_dir", &spec->gpio_dir))
+                spec->gpio_mask &= spec->gpio_mask;
+        if (get_int_hint(codec, "gpio_data", &spec->gpio_data))
+                spec->gpio_dir &= spec->gpio_mask;
+        if (get_int_hint(codec, "eapd_mask", &spec->eapd_mask))
+                spec->eapd_mask &= spec->gpio_mask;
+        if (get_int_hint(codec, "gpio_mute", &spec->gpio_mute))
+                spec->gpio_mute &= spec->gpio_mask;
         val = snd_hda_get_bool_hint(codec, "eapd_switch");
         if (val >= 0)
                 spec->eapd_switch = val;
+        get_int_hint(codec, "gpio_led_polarity", &spec->gpio_led_polarity);
+        if (get_int_hint(codec, "gpio_led", &spec->gpio_led)) {
+                spec->gpio_mask |= spec->gpio_led;
+                spec->gpio_dir |= spec->gpio_led;
+                if (spec->gpio_led_polarity)
+                        spec->gpio_data |= spec->gpio_led;
+        }
 }
 
 static int stac92xx_init(struct hda_codec *codec)
@@ -4294,6 +4370,12 @@ static int stac92xx_init(struct hda_codec *codec)
                 if (enable_pin_detect(codec, nid, STAC_PWR_EVENT))
                         stac_issue_unsol_event(codec, nid);
         }
+
+#ifdef CONFIG_SND_HDA_POWER_SAVE
+        /* sync mute LED */
+        if (spec->gpio_led && codec->patch_ops.check_power_status)
+                codec->patch_ops.check_power_status(codec, 0x01);
+#endif  
         if (spec->dac_list)
                 stac92xx_power_down(codec);
         return 0;
@@ -4329,6 +4411,18 @@ static void stac92xx_free_kctls(struct hda_codec *codec)
         snd_array_free(&spec->kctls);
 }
 
+static void stac92xx_shutup(struct hda_codec *codec)
+{
+        struct sigmatel_spec *spec = codec->spec;
+
+        snd_hda_shutup_pins(codec);
+
+        if (spec->eapd_mask)
+                stac_gpio_set(codec, spec->gpio_mask,
+                                spec->gpio_dir, spec->gpio_data &
+                                ~spec->eapd_mask);
+}
+
 static void stac92xx_free(struct hda_codec *codec)
 {
         struct sigmatel_spec *spec = codec->spec;
@@ -4336,6 +4430,7 @@ static void stac92xx_free(struct hda_codec *codec)
         if (! spec)
                 return;
 
+        stac92xx_shutup(codec);
         stac92xx_free_jacks(codec);
         snd_array_free(&spec->events);
 
@@ -4386,14 +4481,11 @@ static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid,
                                           pin_ctl & ~flag);
 }
 
-static int get_pin_presence(struct hda_codec *codec, hda_nid_t nid)
+static inline int get_pin_presence(struct hda_codec *codec, hda_nid_t nid)
 {
         if (!nid)
                 return 0;
-        if (snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PIN_SENSE, 0x00)
-            & (1 << 31))
-                return 1;
-        return 0;
+        return snd_hda_jack_detect(codec, nid);
 }
 
 static void stac92xx_line_out_detect(struct hda_codec *codec,
@@ -4670,13 +4762,86 @@ static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
         }
 }
 
-static int hp_bseries_system(u32 subsystem_id)
+static int hp_blike_system(u32 subsystem_id);
+
+static void set_hp_led_gpio(struct hda_codec *codec)
+{
+        struct sigmatel_spec *spec = codec->spec;
+        unsigned int gpio;
+
+        if (spec->gpio_led)
+                return;
+
+        gpio = snd_hda_param_read(codec, codec->afg, AC_PAR_GPIO_CAP);
+        gpio &= AC_GPIO_IO_COUNT;
+        if (gpio > 3)
+                spec->gpio_led = 0x08; /* GPIO 3 */
+        else
+                spec->gpio_led = 0x01; /* GPIO 0 */
+}
+
+/*
+ * This method searches for the mute LED GPIO configuration
+ * provided as OEM string in SMBIOS. The format of that string
+ * is HP_Mute_LED_P_G or HP_Mute_LED_P
+ * where P can be 0 or 1 and defines mute LED GPIO control state (low/high)
+ * that corresponds to the NOT muted state of the master volume
+ * and G is the index of the GPIO to use as the mute LED control (0..9)
+ * If _G portion is missing it is assigned based on the codec ID
+ *
+ * So, HP B-series like systems may have HP_Mute_LED_0 (current models)
+ * or  HP_Mute_LED_0_3 (future models) OEM SMBIOS strings
+ *
+ *
+ * The dv-series laptops don't seem to have the HP_Mute_LED* strings in
+ * SMBIOS - at least the ones I have seen do not have them - which include
+ * my own system (HP Pavilion dv6-1110ax) and my cousin's
+ * HP Pavilion dv9500t CTO.
+ * Need more information on whether it is true across the entire series.
+ * -- kunal
+ */
+static int find_mute_led_gpio(struct hda_codec *codec, int default_polarity)
+{
+        struct sigmatel_spec *spec = codec->spec;
+        const struct dmi_device *dev = NULL;
+
+        if ((codec->subsystem_id >> 16) == PCI_VENDOR_ID_HP) {
+                while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING,
+                                                                NULL, dev))) {
+                        if (sscanf(dev->name, "HP_Mute_LED_%d_%d",
+                                  &spec->gpio_led_polarity,
+                                  &spec->gpio_led) == 2) {
+                                spec->gpio_led = 1 << spec->gpio_led;
+                                return 1;
+                        }
+                        if (sscanf(dev->name, "HP_Mute_LED_%d",
+                                  &spec->gpio_led_polarity) == 1) {
+                                set_hp_led_gpio(codec);
+                                return 1;
+                        }
+                }
+
+                /*
+                 * Fallback case - if we don't find the DMI strings,
+                 * we statically set the GPIO - if not a B-series system.
+                 */
+                if (!hp_blike_system(codec->subsystem_id)) {
+                        set_hp_led_gpio(codec);
+                        spec->gpio_led_polarity = default_polarity;
+                        return 1;
+                }
+        }
+        return 0;
+}
+
+static int hp_blike_system(u32 subsystem_id)
 {
         switch (subsystem_id) {
-        case 0x103c307e:
-        case 0x103c307f:
-        case 0x103c3080:
-        case 0x103c3081:
+        case 0x103c1520:
+        case 0x103c1521:
+        case 0x103c1523:
+        case 0x103c1524:
+        case 0x103c1525:
         case 0x103c1722:
         case 0x103c1723:
         case 0x103c1724:
@@ -4685,6 +4850,14 @@ static int hp_bseries_system(u32 subsystem_id)
         case 0x103c1727:
         case 0x103c1728:
         case 0x103c1729:
+        case 0x103c172a:
+        case 0x103c172b:
+        case 0x103c307e:
+        case 0x103c307f:
+        case 0x103c3080:
+        case 0x103c3081:
+        case 0x103c7007:
+        case 0x103c7008:
                 return 1;
         }
         return 0;
@@ -4752,6 +4925,11 @@ static int stac92xx_resume(struct hda_codec *codec)
                         stac_issue_unsol_event(codec,
                                                spec->autocfg.line_out_pins[0]);
         }
+#ifdef CONFIG_SND_HDA_POWER_SAVE
+        /* sync mute LED */
+        if (spec->gpio_led && codec->patch_ops.check_power_status)
+                codec->patch_ops.check_power_status(codec, 0x01);
+#endif  
         return 0;
 }
 
@@ -4771,48 +4949,34 @@ static int stac92xx_hp_check_power_status(struct hda_codec *codec,
                                               hda_nid_t nid)
 {
         struct sigmatel_spec *spec = codec->spec;
+        int i, muted = 1;
 
-        if (nid == 0x10) {
-                if (snd_hda_codec_amp_read(codec, nid, 0, HDA_OUTPUT, 0) &
-                    HDA_AMP_MUTE)
-                        spec->gpio_data &= ~spec->gpio_led; /* orange */
-                else
-                        spec->gpio_data |= spec->gpio_led; /* white */
-
-                if (hp_bseries_system(codec->subsystem_id)) {
-                        /* LED state is inverted on these systems */
-                        spec->gpio_data ^= spec->gpio_led;
+        for (i = 0; i < spec->multiout.num_dacs; i++) {
+                nid = spec->multiout.dac_nids[i];
+                if (!(snd_hda_codec_amp_read(codec, nid, 0, HDA_OUTPUT, 0) &
+                      HDA_AMP_MUTE)) {
+                        muted = 0; /* something heard */
+                        break;
                 }
+        }
+        if (muted)
+                spec->gpio_data &= ~spec->gpio_led; /* orange */
+        else
+                spec->gpio_data |= spec->gpio_led; /* white */
 
-                stac_gpio_set(codec, spec->gpio_mask,
-                              spec->gpio_dir,
-                              spec->gpio_data);
+        if (!spec->gpio_led_polarity) {
+                /* LED state is inverted on these systems */
+                spec->gpio_data ^= spec->gpio_led;
         }
 
+        stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, spec->gpio_data);
         return 0;
 }
 #endif
 
 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 &
-                                ~spec->eapd_mask);
+        stac92xx_shutup(codec);
         return 0;
 }
 #endif
@@ -4827,6 +4991,7 @@ static struct hda_codec_ops stac92xx_patch_ops = {
         .suspend = stac92xx_suspend,
         .resume = stac92xx_resume,
 #endif
+        .reboot_notify = stac92xx_shutup,
 };
 
 static int patch_stac9200(struct hda_codec *codec)
@@ -4838,6 +5003,7 @@ static int patch_stac9200(struct hda_codec *codec)
         if (spec == NULL)
                 return -ENOMEM;
 
+        codec->no_trigger_sense = 1;
         codec->spec = spec;
         spec->num_pins = ARRAY_SIZE(stac9200_pin_nids);
         spec->pin_nids = stac9200_pin_nids;
@@ -4900,6 +5066,7 @@ static int patch_stac925x(struct hda_codec *codec)
         if (spec == NULL)
                 return -ENOMEM;
 
+        codec->no_trigger_sense = 1;
         codec->spec = spec;
         spec->num_pins = ARRAY_SIZE(stac925x_pin_nids);
         spec->pin_nids = stac925x_pin_nids;
@@ -4984,6 +5151,7 @@ static int patch_stac92hd73xx(struct hda_codec *codec)
         if (spec == NULL)
                 return -ENOMEM;
 
+        codec->no_trigger_sense = 1;
         codec->spec = spec;
         codec->slave_dig_outs = stac92hd73xx_slave_dig_outs;
         spec->num_pins = ARRAY_SIZE(stac92hd73xx_pin_nids);
@@ -5125,12 +5293,12 @@ static int patch_stac92hd83xxx(struct hda_codec *codec)
         hda_nid_t conn[STAC92HD83_DAC_COUNT + 1];
         int err;
         int num_dacs;
-        hda_nid_t nid;
 
         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
         if (spec == NULL)
                 return -ENOMEM;
 
+        codec->no_trigger_sense = 1;
         codec->spec = spec;
         codec->slave_dig_outs = stac92hd83xxx_slave_dig_outs;
         spec->digbeep_nid = 0x21;
@@ -5163,7 +5331,18 @@ again:
                                 stac92hd83xxx_brd_tbl[spec->board_config]);
 
         switch (codec->vendor_id) {
+        case 0x111d7666:
+        case 0x111d7667:
+        case 0x111d7668:
+        case 0x111d7669:
+                spec->num_pins = ARRAY_SIZE(stac92hd88xxx_pin_nids);
+                spec->pin_nids = stac92hd88xxx_pin_nids;
+                spec->mono_nid = 0;
+                spec->digbeep_nid = 0;
+                spec->num_pwrs = 0;
+                break;
         case 0x111d7604:
+        case 0x111d76d4:
         case 0x111d7605:
         case 0x111d76d5:
                 if (spec->board_config == STAC_92HD83XXX_PWR_REF)
@@ -5172,6 +5351,24 @@ again:
                 break;
         }
 
+        codec->patch_ops = stac92xx_patch_ops;
+
+        if (find_mute_led_gpio(codec, 0))
+                snd_printd("mute LED gpio %d polarity %d\n",
+                                spec->gpio_led,
+                                spec->gpio_led_polarity);
+
+#ifdef CONFIG_SND_HDA_POWER_SAVE
+        if (spec->gpio_led) {
+                spec->gpio_mask |= spec->gpio_led;
+                spec->gpio_dir |= spec->gpio_led;
+                spec->gpio_data |= spec->gpio_led;
+                /* register check_power_status callback. */
+                codec->patch_ops.check_power_status =
+                        stac92xx_hp_check_power_status;
+        }
+#endif  
+
         err = stac92xx_parse_auto_config(codec, 0x1d, 0);
         if (!err) {
                 if (spec->board_config < 0) {
@@ -5188,26 +5385,21 @@ again:
                 return err;
         }
 
-        switch (spec->board_config) {
-        case STAC_DELL_S14:
-                nid = 0xf;
-                break;
-        default:
-                nid = 0xe;
-                break;
-        }
-
-        num_dacs = snd_hda_get_connections(codec, nid,
+        /* docking output support */
+        num_dacs = snd_hda_get_connections(codec, 0xF,
                                 conn, STAC92HD83_DAC_COUNT + 1) - 1;
-        if (num_dacs < 0)
-                num_dacs = STAC92HD83_DAC_COUNT;
-
-        /* set port X to select the last DAC
-         */
-        snd_hda_codec_write_cache(codec, nid, 0,
+        /* skip non-DAC connections */
+        while (num_dacs >= 0 &&
+                        (get_wcaps_type(get_wcaps(codec, conn[num_dacs]))
+                                        != AC_WID_AUD_OUT))
+                num_dacs--;
+        /* set port E and F to select the last DAC */
+        if (num_dacs >= 0) {
+                snd_hda_codec_write_cache(codec, 0xE, 0,
                         AC_VERB_SET_CONNECT_SEL, num_dacs);
-
-        codec->patch_ops = stac92xx_patch_ops;
+                snd_hda_codec_write_cache(codec, 0xF, 0,
+                        AC_VERB_SET_CONNECT_SEL, num_dacs);
+        }
 
         codec->proc_widget_hook = stac92hd_proc_hook;
 
@@ -5269,6 +5461,54 @@ static int stac92hd71bxx_connected_smuxes(struct hda_codec *codec,
                 return 0;
 }
 
+/* HP dv7 bass switch - GPIO5 */
+#define stac_hp_bass_gpio_info  snd_ctl_boolean_mono_info
+static int stac_hp_bass_gpio_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.integer.value[0] = !!(spec->gpio_data & 0x20);
+        return 0;
+}
+
+static int stac_hp_bass_gpio_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;
+        unsigned int gpio_data;
+
+        gpio_data = (spec->gpio_data & ~0x20) |
+                (ucontrol->value.integer.value[0] ? 0x20 : 0);
+        if (gpio_data == spec->gpio_data)
+                return 0;
+        spec->gpio_data = gpio_data;
+        stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, spec->gpio_data);
+        return 1;
+}
+
+static struct snd_kcontrol_new stac_hp_bass_sw_ctrl = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .info = stac_hp_bass_gpio_info,
+        .get = stac_hp_bass_gpio_get,
+        .put = stac_hp_bass_gpio_put,
+};
+
+static int stac_add_hp_bass_switch(struct hda_codec *codec)
+{
+        struct sigmatel_spec *spec = codec->spec;
+
+        if (!stac_control_new(spec, &stac_hp_bass_sw_ctrl,
+                              "Bass Speaker Playback Switch", 0))
+                return -ENOMEM;
+
+        spec->gpio_mask |= 0x20;
+        spec->gpio_dir |= 0x20;
+        spec->gpio_data |= 0x20;
+        return 0;
+}
+
 static int patch_stac92hd71bxx(struct hda_codec *codec)
 {
         struct sigmatel_spec *spec;
@@ -5280,6 +5520,7 @@ static int patch_stac92hd71bxx(struct hda_codec *codec)
         if (spec == NULL)
                 return -ENOMEM;
 
+        codec->no_trigger_sense = 1;
         codec->spec = spec;
         codec->patch_ops = stac92xx_patch_ops;
         spec->num_pins = STAC92HD71BXX_NUM_PINS;
@@ -5412,6 +5653,8 @@ again:
         spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
         spec->num_smuxes = stac92hd71bxx_connected_smuxes(codec, 0x1e);
 
+        snd_printdd("Found board config: %d\n", spec->board_config);
+
         switch (spec->board_config) {
         case STAC_HP_M4:
                 /* enable internal microphone */
@@ -5437,6 +5680,8 @@ again:
                  */
                 spec->num_smuxes = 1;
                 spec->num_dmuxes = 1;
+                /* fallthrough */
+        case STAC_HP_DV4:
                 spec->gpio_led = 0x01;
                 /* fallthrough */
         case STAC_HP_DV5:
@@ -5452,12 +5697,11 @@ again:
                 spec->num_dmics = 1;
                 spec->num_dmuxes = 1;
                 spec->num_smuxes = 1;
-                /* orange/white mute led on GPIO3, orange=0, white=1 */
                 spec->gpio_led = 0x08;
                 break;
         }
 
-        if (hp_bseries_system(codec->subsystem_id)) {
+        if (hp_blike_system(codec->subsystem_id)) {
                 pin_cfg = snd_hda_codec_get_pincfg(codec, 0x0f);
                 if (get_defcfg_device(pin_cfg) == AC_JACK_LINE_OUT ||
                         get_defcfg_device(pin_cfg) == AC_JACK_SPEAKER  ||
@@ -5475,26 +5719,10 @@ again:
                 }
         }
 
-        if ((codec->subsystem_id >> 16) == PCI_VENDOR_ID_HP) {
-                const struct dmi_device *dev = NULL;
-                while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING,
-                                              NULL, dev))) {
-                        if (strcmp(dev->name, "HP_Mute_LED_1")) {
-                                switch (codec->vendor_id) {
-                                case 0x111d7608:
-                                        spec->gpio_led = 0x01;
-                                        break;
-                                case 0x111d7600:
-                                case 0x111d7601:
-                                case 0x111d7602:
-                                case 0x111d7603:
-                                        spec->gpio_led = 0x08;
-                                        break;
-                                }
-                                break;
-                        }
-                }
-        }
+        if (find_mute_led_gpio(codec, 1))
+                snd_printd("mute LED gpio %d polarity %d\n",
+                                spec->gpio_led,
+                                spec->gpio_led_polarity);
 
 #ifdef CONFIG_SND_HDA_POWER_SAVE
         if (spec->gpio_led) {
@@ -5525,6 +5753,16 @@ again:
                 return err;
         }
 
+        /* enable bass on HP dv7 */
+        if (spec->board_config == STAC_HP_DV4 ||
+            spec->board_config == STAC_HP_DV5) {
+                unsigned int cap;
+                cap = snd_hda_param_read(codec, 0x1, AC_PAR_GPIO_CAP);
+                cap &= AC_GPIO_IO_COUNT;
+                if (cap >= 6)
+                        stac_add_hp_bass_switch(codec);
+        }
+
         codec->proc_widget_hook = stac92hd7x_proc_hook;
 
         return 0;
@@ -5539,6 +5777,7 @@ static int patch_stac922x(struct hda_codec *codec)
         if (spec == NULL)
                 return -ENOMEM;
 
+        codec->no_trigger_sense = 1;
         codec->spec = spec;
         spec->num_pins = ARRAY_SIZE(stac922x_pin_nids);
         spec->pin_nids = stac922x_pin_nids;
@@ -5642,6 +5881,7 @@ static int patch_stac927x(struct hda_codec *codec)
         if (spec == NULL)
                 return -ENOMEM;
 
+        codec->no_trigger_sense = 1;
         codec->spec = spec;
         codec->slave_dig_outs = stac927x_slave_dig_outs;
         spec->num_pins = ARRAY_SIZE(stac927x_pin_nids);
@@ -5776,6 +6016,7 @@ static int patch_stac9205(struct hda_codec *codec)
         if (spec == NULL)
                 return -ENOMEM;
 
+        codec->no_trigger_sense = 1;
         codec->spec = spec;
         spec->num_pins = ARRAY_SIZE(stac9205_pin_nids);
         spec->pin_nids = stac9205_pin_nids;
@@ -5931,6 +6172,7 @@ static int patch_stac9872(struct hda_codec *codec)
         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
         if (spec == NULL)
                 return -ENOMEM;
+        codec->no_trigger_sense = 1;
         codec->spec = spec;
         spec->num_pins = ARRAY_SIZE(stac9872_pin_nids);
         spec->pin_nids = stac9872_pin_nids;
@@ -6019,8 +6261,13 @@ static struct hda_codec_preset snd_hda_preset_sigmatel[] = {
         { .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 },
         { .id = 0x111d7603, .name = "92HD75B3X5", .patch = patch_stac92hd71bxx},
         { .id = 0x111d7604, .name = "92HD83C1X5", .patch = patch_stac92hd83xxx},
+        { .id = 0x111d76d4, .name = "92HD83C1C5", .patch = patch_stac92hd83xxx},
         { .id = 0x111d7605, .name = "92HD81B1X5", .patch = patch_stac92hd83xxx},
         { .id = 0x111d76d5, .name = "92HD81B1C5", .patch = patch_stac92hd83xxx},
+        { .id = 0x111d7666, .name = "92HD88B3", .patch = patch_stac92hd83xxx},
+        { .id = 0x111d7667, .name = "92HD88B1", .patch = patch_stac92hd83xxx},
+        { .id = 0x111d7668, .name = "92HD88B2", .patch = patch_stac92hd83xxx},
+        { .id = 0x111d7669, .name = "92HD88B4", .patch = patch_stac92hd83xxx},
         { .id = 0x111d7608, .name = "92HD75B2X5", .patch = patch_stac92hd71bxx},
         { .id = 0x111d7674, .name = "92HD73D1X5", .patch = patch_stac92hd73xx },
         { .id = 0x111d7675, .name = "92HD73C1X5", .patch = patch_stac92hd73xx },
diff --git a/sound/pci/hda/patch_via.c b/sound/pci/hda/patch_via.c
index ee89db90c9b6..73453814e098 100644
--- a/sound/pci/hda/patch_via.c
+++ b/sound/pci/hda/patch_via.c
@@ -1,10 +1,10 @@
 /*
  * Universal Interface for Intel High Definition Audio Codec
  *
- * HD audio interface patch for VIA VT1702/VT1708/VT1709 codec
+ * HD audio interface patch for VIA VT17xx/VT18xx/VT20xx codec
  *
- * Copyright (c) 2006-2008 Lydia Wang <lydiawang@viatech.com>
- *                         Takashi Iwai <tiwai@suse.de>
+ *  (C) 2006-2009 VIA Technology, Inc.
+ *  (C) 2006-2008 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
@@ -22,21 +22,27 @@
  */
 
 /* * * * * * * * * * * * * * Release History * * * * * * * * * * * * * * * * */
-/*                                                                           */
+/*                                                                           */
 /* 2006-03-03  Lydia Wang  Create the basic patch to support VT1708 codec    */
-/* 2006-03-14  Lydia Wang  Modify hard code for some pin widget nid          */
-/* 2006-08-02  Lydia Wang  Add support to VT1709 codec                       */
+/* 2006-03-14  Lydia Wang  Modify hard code for some pin widget nid          */
+/* 2006-08-02  Lydia Wang  Add support to VT1709 codec                       */
 /* 2006-09-08  Lydia Wang  Fix internal loopback recording source select bug */
-/* 2007-09-12  Lydia Wang  Add EAPD enable during driver initialization      */
-/* 2007-09-17  Lydia Wang  Add VT1708B codec support                        */
+/* 2007-09-12  Lydia Wang  Add EAPD enable during driver initialization      */
+/* 2007-09-17  Lydia Wang  Add VT1708B codec support                        */
 /* 2007-11-14  Lydia Wang  Add VT1708A codec HP and CD pin connect config    */
 /* 2008-02-03  Lydia Wang  Fix Rear channels and Back channels inverse issue */
-/* 2008-03-06  Lydia Wang  Add VT1702 codec and VT1708S codec support        */
-/* 2008-04-09  Lydia Wang  Add mute front speaker when HP plugin             */
-/* 2008-04-09  Lydia Wang  Add Independent HP feature                        */
+/* 2008-03-06  Lydia Wang  Add VT1702 codec and VT1708S codec support        */
+/* 2008-04-09  Lydia Wang  Add mute front speaker when HP plugin             */
+/* 2008-04-09  Lydia Wang  Add Independent HP feature                        */
 /* 2008-05-28  Lydia Wang  Add second S/PDIF Out support for VT1702          */
-/* 2008-09-15  Logan Li    Add VT1708S Mic Boost workaround/backdoor         */
-/*                                                                           */
+/* 2008-09-15  Logan Li    Add VT1708S Mic Boost workaround/backdoor         */
+/* 2009-02-16  Logan Li    Add support for VT1718S                           */
+/* 2009-03-13  Logan Li    Add support for VT1716S                           */
+/* 2009-04-14  Lydai Wang  Add support for VT1828S and VT2020                */
+/* 2009-07-08  Lydia Wang  Add support for VT2002P                           */
+/* 2009-07-21  Lydia Wang  Add support for VT1812                            */
+/* 2009-09-19  Lydia Wang  Add support for VT1818S                           */
+/*                                                                           */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 
@@ -48,6 +54,8 @@
 #include "hda_codec.h"
 #include "hda_local.h"
 
+#define NID_MAPPING             (-1)
+
 /* amp values */
 #define AMP_VAL_IDX_SHIFT       19
 #define AMP_VAL_IDX_MASK        (0x0f<<19)
@@ -76,14 +84,6 @@
 #define VT1702_HP_NID           0x17
 #define VT1702_DIGOUT_NID       0x11
 
-#define IS_VT1708_VENDORID(x)           ((x) >= 0x11061708 && (x) <= 0x1106170b)
-#define IS_VT1709_10CH_VENDORID(x)      ((x) >= 0x1106e710 && (x) <= 0x1106e713)
-#define IS_VT1709_6CH_VENDORID(x)       ((x) >= 0x1106e714 && (x) <= 0x1106e717)
-#define IS_VT1708B_8CH_VENDORID(x)      ((x) >= 0x1106e720 && (x) <= 0x1106e723)
-#define IS_VT1708B_4CH_VENDORID(x)      ((x) >= 0x1106e724 && (x) <= 0x1106e727)
-#define IS_VT1708S_VENDORID(x)          ((x) >= 0x11060397 && (x) <= 0x11067397)
-#define IS_VT1702_VENDORID(x)           ((x) >= 0x11060398 && (x) <= 0x11067398)
-
 enum VIA_HDA_CODEC {
         UNKNOWN = -1,
         VT1708,
@@ -92,12 +92,89 @@ enum VIA_HDA_CODEC {
         VT1708B_8CH,
         VT1708B_4CH,
         VT1708S,
+        VT1708BCE,
         VT1702,
+        VT1718S,
+        VT1716S,
+        VT2002P,
+        VT1812,
         CODEC_TYPES,
 };
 
-static enum VIA_HDA_CODEC get_codec_type(u32 vendor_id)
+struct via_spec {
+        /* codec parameterization */
+        struct snd_kcontrol_new *mixers[6];
+        unsigned int num_mixers;
+
+        struct hda_verb *init_verbs[5];
+        unsigned int num_iverbs;
+
+        char *stream_name_analog;
+        struct hda_pcm_stream *stream_analog_playback;
+        struct hda_pcm_stream *stream_analog_capture;
+
+        char *stream_name_digital;
+        struct hda_pcm_stream *stream_digital_playback;
+        struct hda_pcm_stream *stream_digital_capture;
+
+        /* playback */
+        struct hda_multi_out multiout;
+        hda_nid_t slave_dig_outs[2];
+
+        /* capture */
+        unsigned int num_adc_nids;
+        hda_nid_t *adc_nids;
+        hda_nid_t mux_nids[3];
+        hda_nid_t dig_in_nid;
+        hda_nid_t dig_in_pin;
+
+        /* capture source */
+        const struct hda_input_mux *input_mux;
+        unsigned int cur_mux[3];
+
+        /* PCM information */
+        struct hda_pcm pcm_rec[3];
+
+        /* dynamic controls, init_verbs and input_mux */
+        struct auto_pin_cfg autocfg;
+        struct snd_array kctls;
+        struct hda_input_mux private_imux[2];
+        hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
+
+        /* HP mode source */
+        const struct hda_input_mux *hp_mux;
+        unsigned int hp_independent_mode;
+        unsigned int hp_independent_mode_index;
+        unsigned int smart51_enabled;
+        unsigned int dmic_enabled;
+        enum VIA_HDA_CODEC codec_type;
+
+        /* work to check hp jack state */
+        struct hda_codec *codec;
+        struct delayed_work vt1708_hp_work;
+        int vt1708_jack_detectect;
+        int vt1708_hp_present;
+#ifdef CONFIG_SND_HDA_POWER_SAVE
+        struct hda_loopback_check loopback;
+#endif
+};
+
+static struct via_spec * via_new_spec(struct hda_codec *codec)
 {
+        struct via_spec *spec;
+
+        spec = kzalloc(sizeof(*spec), GFP_KERNEL);
+        if (spec == NULL)
+                return NULL;
+
+        codec->spec = spec;
+        spec->codec = codec;
+        return spec;
+}
+
+static enum VIA_HDA_CODEC get_codec_type(struct hda_codec *codec)
+{
+        u32 vendor_id = codec->vendor_id;
         u16 ven_id = vendor_id >> 16;
         u16 dev_id = vendor_id & 0xffff;
         enum VIA_HDA_CODEC codec_type;
@@ -111,9 +188,11 @@ static enum VIA_HDA_CODEC get_codec_type(u32 vendor_id)
                 codec_type = VT1709_10CH;
         else if (dev_id >= 0xe714 && dev_id <= 0xe717)
                 codec_type = VT1709_6CH;
-        else if (dev_id >= 0xe720 && dev_id <= 0xe723)
+        else if (dev_id >= 0xe720 && dev_id <= 0xe723) {
                 codec_type = VT1708B_8CH;
-        else if (dev_id >= 0xe724 && dev_id <= 0xe727)
+                if (snd_hda_param_read(codec, 0x16, AC_PAR_CONNLIST_LEN) == 0x7)
+                        codec_type = VT1708BCE;
+        } else if (dev_id >= 0xe724 && dev_id <= 0xe727)
                 codec_type = VT1708B_4CH;
         else if ((dev_id & 0xfff) == 0x397
                  && (dev_id >> 12) < 8)
@@ -121,6 +200,19 @@ static enum VIA_HDA_CODEC get_codec_type(u32 vendor_id)
         else if ((dev_id & 0xfff) == 0x398
                  && (dev_id >> 12) < 8)
                 codec_type = VT1702;
+        else if ((dev_id & 0xfff) == 0x428
+                 && (dev_id >> 12) < 8)
+                codec_type = VT1718S;
+        else if (dev_id == 0x0433 || dev_id == 0xa721)
+                codec_type = VT1716S;
+        else if (dev_id == 0x0441 || dev_id == 0x4441)
+                codec_type = VT1718S;
+        else if (dev_id == 0x0438 || dev_id == 0x4438)
+                codec_type = VT2002P;
+        else if (dev_id == 0x0448)
+                codec_type = VT1812;
+        else if (dev_id == 0x0440)
+                codec_type = VT1708S;
         else
                 codec_type = UNKNOWN;
         return codec_type;
@@ -128,10 +220,16 @@ static enum VIA_HDA_CODEC get_codec_type(u32 vendor_id)
 
 #define VIA_HP_EVENT            0x01
 #define VIA_GPIO_EVENT          0x02
+#define VIA_JACK_EVENT          0x04
+#define VIA_MONO_EVENT          0x08
+#define VIA_SPEAKER_EVENT       0x10
+#define VIA_BIND_HP_EVENT       0x20
 
 enum {
         VIA_CTL_WIDGET_VOL,
         VIA_CTL_WIDGET_MUTE,
+        VIA_CTL_WIDGET_ANALOG_MUTE,
+        VIA_CTL_WIDGET_BIND_PIN_MUTE,
 };
 
 enum {
@@ -141,99 +239,162 @@ enum {
         AUTO_SEQ_SIDE
 };
 
-/* Some VT1708S based boards gets the micboost setting wrong, so we have
- * to apply some brute-force and re-write the TLV's by software. */
-static int mic_boost_tlv(struct snd_kcontrol *kcontrol, int op_flag,
-                         unsigned int size, unsigned int __user *_tlv)
+static void analog_low_current_mode(struct hda_codec *codec, int stream_idle);
+static void set_jack_power_state(struct hda_codec *codec);
+static int is_aa_path_mute(struct hda_codec *codec);
+
+static void vt1708_start_hp_work(struct via_spec *spec)
 {
-        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-        hda_nid_t nid = get_amp_nid(kcontrol);
+        if (spec->codec_type != VT1708 || spec->autocfg.hp_pins[0] == 0)
+                return;
+        snd_hda_codec_write(spec->codec, 0x1, 0, 0xf81,
+                            !spec->vt1708_jack_detectect);
+        if (!delayed_work_pending(&spec->vt1708_hp_work))
+                schedule_delayed_work(&spec->vt1708_hp_work,
+                                      msecs_to_jiffies(100));
+}
 
-        if (get_codec_type(codec->vendor_id) == VT1708S
-            && (nid == 0x1a || nid == 0x1e)) {
-                if (size < 4 * sizeof(unsigned int))
-                        return -ENOMEM;
-                if (put_user(1, _tlv))  /* SNDRV_CTL_TLVT_DB_SCALE */
-                        return -EFAULT;
-                if (put_user(2 * sizeof(unsigned int), _tlv + 1))
-                        return -EFAULT;
-                if (put_user(0, _tlv + 2)) /* offset = 0 */
-                        return -EFAULT;
-                if (put_user(1000, _tlv + 3)) /* step size = 10 dB */
-                        return -EFAULT;
-        }
-        return 0;
+static void vt1708_stop_hp_work(struct via_spec *spec)
+{
+        if (spec->codec_type != VT1708 || spec->autocfg.hp_pins[0] == 0)
+                return;
+        if (snd_hda_get_bool_hint(spec->codec, "analog_loopback_hp_detect") == 1
+            && !is_aa_path_mute(spec->codec))
+                return;
+        snd_hda_codec_write(spec->codec, 0x1, 0, 0xf81,
+                            !spec->vt1708_jack_detectect);
+        cancel_delayed_work(&spec->vt1708_hp_work);
+        flush_scheduled_work();
 }
 
-static int mic_boost_volume_info(struct snd_kcontrol *kcontrol,
-                                 struct snd_ctl_elem_info *uinfo)
+
+static int analog_input_switch_put(struct snd_kcontrol *kcontrol,
+                                   struct snd_ctl_elem_value *ucontrol)
 {
+        int change = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-        hda_nid_t nid = get_amp_nid(kcontrol);
 
-        if (get_codec_type(codec->vendor_id) == VT1708S
-            && (nid == 0x1a || nid == 0x1e)) {
-                uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
-                uinfo->count = 2;
-                uinfo->value.integer.min = 0;
-                uinfo->value.integer.max = 3;
+        set_jack_power_state(codec);
+        analog_low_current_mode(snd_kcontrol_chip(kcontrol), -1);
+        if (snd_hda_get_bool_hint(codec, "analog_loopback_hp_detect") == 1) {
+                if (is_aa_path_mute(codec))
+                        vt1708_start_hp_work(codec->spec);
+                else
+                        vt1708_stop_hp_work(codec->spec);
         }
-        return 0;
+        return change;
 }
 
-static struct snd_kcontrol_new vt1708_control_templates[] = {
-        HDA_CODEC_VOLUME(NULL, 0, 0, 0),
-        HDA_CODEC_MUTE(NULL, 0, 0, 0),
-};
+/* modify .put = snd_hda_mixer_amp_switch_put */
+#define ANALOG_INPUT_MUTE                                               \
+        {               .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
+                        .name = NULL,                                   \
+                        .index = 0,                                     \
+                        .info = snd_hda_mixer_amp_switch_info,          \
+                        .get = snd_hda_mixer_amp_switch_get,            \
+                        .put = analog_input_switch_put,                 \
+                        .private_value = HDA_COMPOSE_AMP_VAL(0, 3, 0, 0) }
 
+static void via_hp_bind_automute(struct hda_codec *codec);
 
-struct via_spec {
-        /* codec parameterization */
-        struct snd_kcontrol_new *mixers[3];
-        unsigned int num_mixers;
-
-        struct hda_verb *init_verbs[5];
-        unsigned int num_iverbs;
-
-        char *stream_name_analog;
-        struct hda_pcm_stream *stream_analog_playback;
-        struct hda_pcm_stream *stream_analog_capture;
-
-        char *stream_name_digital;
-        struct hda_pcm_stream *stream_digital_playback;
-        struct hda_pcm_stream *stream_digital_capture;
-
-        /* playback */
-        struct hda_multi_out multiout;
-        hda_nid_t slave_dig_outs[2];
-
-        /* capture */
-        unsigned int num_adc_nids;
-        hda_nid_t *adc_nids;
-        hda_nid_t mux_nids[3];
-        hda_nid_t dig_in_nid;
-        hda_nid_t dig_in_pin;
+static int bind_pin_switch_put(struct snd_kcontrol *kcontrol,
+                               struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct via_spec *spec = codec->spec;
+        int i;
+        int change = 0;
 
-        /* capture source */
-        const struct hda_input_mux *input_mux;
-        unsigned int cur_mux[3];
+        long *valp = ucontrol->value.integer.value;
+        int lmute, rmute;
+        if (strstr(kcontrol->id.name, "Switch") == NULL) {
+                snd_printd("Invalid control!\n");
+                return change;
+        }
+        change = snd_hda_mixer_amp_switch_put(kcontrol,
+                                              ucontrol);
+        /* Get mute value */
+        lmute = *valp ? 0 : HDA_AMP_MUTE;
+        valp++;
+        rmute = *valp ? 0 : HDA_AMP_MUTE;
+
+        /* Set hp pins */
+        if (!spec->hp_independent_mode) {
+                for (i = 0; i < spec->autocfg.hp_outs; i++) {
+                        snd_hda_codec_amp_update(
+                                codec, spec->autocfg.hp_pins[i],
+                                0, HDA_OUTPUT, 0, HDA_AMP_MUTE,
+                                lmute);
+                        snd_hda_codec_amp_update(
+                                codec, spec->autocfg.hp_pins[i],
+                                1, HDA_OUTPUT, 0, HDA_AMP_MUTE,
+                                rmute);
+                }
+        }
 
-        /* PCM information */
-        struct hda_pcm pcm_rec[3];
+        if (!lmute && !rmute) {
+                /* Line Outs */
+                for (i = 0; i < spec->autocfg.line_outs; i++)
+                        snd_hda_codec_amp_stereo(
+                                codec, spec->autocfg.line_out_pins[i],
+                                HDA_OUTPUT, 0, HDA_AMP_MUTE, 0);
+                /* Speakers */
+                for (i = 0; i < spec->autocfg.speaker_outs; i++)
+                        snd_hda_codec_amp_stereo(
+                                codec, spec->autocfg.speaker_pins[i],
+                                HDA_OUTPUT, 0, HDA_AMP_MUTE, 0);
+                /* unmute */
+                via_hp_bind_automute(codec);
 
-        /* dynamic controls, init_verbs and input_mux */
-        struct auto_pin_cfg autocfg;
-        struct snd_array kctls;
-        struct hda_input_mux private_imux[2];
-        hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
+        } else {
+                if (lmute) {
+                        /* Mute all left channels */
+                        for (i = 1; i < spec->autocfg.line_outs; i++)
+                                snd_hda_codec_amp_update(
+                                        codec,
+                                        spec->autocfg.line_out_pins[i],
+                                        0, HDA_OUTPUT, 0, HDA_AMP_MUTE,
+                                        lmute);
+                        for (i = 0; i < spec->autocfg.speaker_outs; i++)
+                                snd_hda_codec_amp_update(
+                                        codec,
+                                        spec->autocfg.speaker_pins[i],
+                                        0, HDA_OUTPUT, 0, HDA_AMP_MUTE,
+                                        lmute);
+                }
+                if (rmute) {
+                        /* mute all right channels */
+                        for (i = 1; i < spec->autocfg.line_outs; i++)
+                                snd_hda_codec_amp_update(
+                                        codec,
+                                        spec->autocfg.line_out_pins[i],
+                                        1, HDA_OUTPUT, 0, HDA_AMP_MUTE,
+                                        rmute);
+                        for (i = 0; i < spec->autocfg.speaker_outs; i++)
+                                snd_hda_codec_amp_update(
+                                        codec,
+                                        spec->autocfg.speaker_pins[i],
+                                        1, HDA_OUTPUT, 0, HDA_AMP_MUTE,
+                                        rmute);
+                }
+        }
+        return change;
+}
 
-        /* HP mode source */
-        const struct hda_input_mux *hp_mux;
-        unsigned int hp_independent_mode;
+#define BIND_PIN_MUTE                                                   \
+        {               .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
+                        .name = NULL,                                   \
+                        .index = 0,                                     \
+                        .info = snd_hda_mixer_amp_switch_info,          \
+                        .get = snd_hda_mixer_amp_switch_get,            \
+                        .put = bind_pin_switch_put,                     \
+                        .private_value = HDA_COMPOSE_AMP_VAL(0, 3, 0, 0) }
 
-#ifdef CONFIG_SND_HDA_POWER_SAVE
-        struct hda_loopback_check loopback;
-#endif
+static struct snd_kcontrol_new via_control_templates[] = {
+        HDA_CODEC_VOLUME(NULL, 0, 0, 0),
+        HDA_CODEC_MUTE(NULL, 0, 0, 0),
+        ANALOG_INPUT_MUTE,
+        BIND_PIN_MUTE,
 };
 
 static hda_nid_t vt1708_adc_nids[2] = {
@@ -261,6 +422,27 @@ static hda_nid_t vt1702_adc_nids[3] = {
         0x12, 0x20, 0x1F
 };
 
+static hda_nid_t vt1718S_adc_nids[2] = {
+        /* ADC1-2 */
+        0x10, 0x11
+};
+
+static hda_nid_t vt1716S_adc_nids[2] = {
+        /* ADC1-2 */
+        0x13, 0x14
+};
+
+static hda_nid_t vt2002P_adc_nids[2] = {
+        /* ADC1-2 */
+        0x10, 0x11
+};
+
+static hda_nid_t vt1812_adc_nids[2] = {
+        /* ADC1-2 */
+        0x10, 0x11
+};
+
+
 /* add dynamic controls */
 static int via_add_control(struct via_spec *spec, int type, const char *name,
                            unsigned long val)
@@ -271,14 +453,32 @@ static int via_add_control(struct via_spec *spec, int type, const char *name,
         knew = snd_array_new(&spec->kctls);
         if (!knew)
                 return -ENOMEM;
-        *knew = vt1708_control_templates[type];
+        *knew = via_control_templates[type];
         knew->name = kstrdup(name, GFP_KERNEL);
         if (!knew->name)
                 return -ENOMEM;
+        if (get_amp_nid_(val))
+                knew->subdevice = HDA_SUBDEV_AMP_FLAG;
         knew->private_value = val;
         return 0;
 }
 
+static struct snd_kcontrol_new *via_clone_control(struct via_spec *spec,
+                                                struct snd_kcontrol_new *tmpl)
+{
+        struct snd_kcontrol_new *knew;
+
+        snd_array_init(&spec->kctls, sizeof(*knew), 32);
+        knew = snd_array_new(&spec->kctls);
+        if (!knew)
+                return NULL;
+        *knew = *tmpl;
+        knew->name = kstrdup(tmpl->name, GFP_KERNEL);
+        if (!knew->name)
+                return NULL;
+        return knew;
+}
+
 static void via_free_kctls(struct hda_codec *codec)
 {
         struct via_spec *spec = codec->spec;
@@ -293,8 +493,8 @@ static void via_free_kctls(struct hda_codec *codec)
 }
 
 /* create input playback/capture controls for the given pin */
-static int via_new_analog_input(struct via_spec *spec, hda_nid_t pin,
-                                const char *ctlname, int idx, int mix_nid)
+static int via_new_analog_input(struct via_spec *spec, const char *ctlname,
+                                int idx, int mix_nid)
 {
         char name[32];
         int err;
@@ -305,7 +505,7 @@ static int via_new_analog_input(struct via_spec *spec, hda_nid_t pin,
         if (err < 0)
                 return err;
         sprintf(name, "%s Playback Switch", ctlname);
-        err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
+        err = via_add_control(spec, VIA_CTL_WIDGET_ANALOG_MUTE, name,
                               HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
         if (err < 0)
                 return err;
@@ -322,7 +522,7 @@ static void via_auto_set_output_and_unmute(struct hda_codec *codec,
         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, 
+                snd_hda_codec_write(codec, nid, 0,
                                     AC_VERB_SET_EAPD_BTLENABLE, 0x02);
 }
 
@@ -343,10 +543,13 @@ static void via_auto_init_hp_out(struct hda_codec *codec)
 {
         struct via_spec *spec = codec->spec;
         hda_nid_t pin;
+        int i;
 
-        pin = spec->autocfg.hp_pins[0];
-        if (pin) /* connect to front */
-                via_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
+        for (i = 0; i < spec->autocfg.hp_outs; i++) {
+                pin = spec->autocfg.hp_pins[i];
+                if (pin) /* connect to front */
+                        via_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
+        }
 }
 
 static void via_auto_init_analog_input(struct hda_codec *codec)
@@ -364,6 +567,502 @@ static void via_auto_init_analog_input(struct hda_codec *codec)
 
         }
 }
+
+static int is_smart51_pins(struct via_spec *spec, hda_nid_t pin);
+
+static void set_pin_power_state(struct hda_codec *codec, hda_nid_t nid,
+                                unsigned int *affected_parm)
+{
+        unsigned parm;
+        unsigned def_conf = snd_hda_codec_get_pincfg(codec, nid);
+        unsigned no_presence = (def_conf & AC_DEFCFG_MISC)
+                >> AC_DEFCFG_MISC_SHIFT
+                & AC_DEFCFG_MISC_NO_PRESENCE; /* do not support pin sense */
+        unsigned present = snd_hda_jack_detect(codec, nid);
+        struct via_spec *spec = codec->spec;
+        if ((spec->smart51_enabled && is_smart51_pins(spec, nid))
+            || ((no_presence || present)
+                && get_defcfg_connect(def_conf) != AC_JACK_PORT_NONE)) {
+                *affected_parm = AC_PWRST_D0; /* if it's connected */
+                parm = AC_PWRST_D0;
+        } else
+                parm = AC_PWRST_D3;
+
+        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE, parm);
+}
+
+static void set_jack_power_state(struct hda_codec *codec)
+{
+        struct via_spec *spec = codec->spec;
+        int imux_is_smixer;
+        unsigned int parm;
+
+        if (spec->codec_type == VT1702) {
+                imux_is_smixer = snd_hda_codec_read(
+                        codec, 0x13, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 3;
+                /* inputs */
+                /* PW 1/2/5 (14h/15h/18h) */
+                parm = AC_PWRST_D3;
+                set_pin_power_state(codec, 0x14, &parm);
+                set_pin_power_state(codec, 0x15, &parm);
+                set_pin_power_state(codec, 0x18, &parm);
+                if (imux_is_smixer)
+                        parm = AC_PWRST_D0; /* SW0 = stereo mixer (idx 3) */
+                /* SW0 (13h), AIW 0/1/2 (12h/1fh/20h) */
+                snd_hda_codec_write(codec, 0x13, 0, AC_VERB_SET_POWER_STATE,
+                                    parm);
+                snd_hda_codec_write(codec, 0x12, 0, AC_VERB_SET_POWER_STATE,
+                                    parm);
+                snd_hda_codec_write(codec, 0x1f, 0, AC_VERB_SET_POWER_STATE,
+                                    parm);
+                snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_POWER_STATE,
+                                    parm);
+
+                /* outputs */
+                /* PW 3/4 (16h/17h) */
+                parm = AC_PWRST_D3;
+                set_pin_power_state(codec, 0x16, &parm);
+                set_pin_power_state(codec, 0x17, &parm);
+                /* MW0 (1ah), AOW 0/1 (10h/1dh) */
+                snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_POWER_STATE,
+                                    imux_is_smixer ? AC_PWRST_D0 : parm);
+                snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE,
+                                    parm);
+                snd_hda_codec_write(codec, 0x1d, 0, AC_VERB_SET_POWER_STATE,
+                                    parm);
+        } else if (spec->codec_type == VT1708B_8CH
+                   || spec->codec_type == VT1708B_4CH
+                   || spec->codec_type == VT1708S) {
+                /* SW0 (17h) = stereo mixer */
+                int is_8ch = spec->codec_type != VT1708B_4CH;
+                imux_is_smixer = snd_hda_codec_read(
+                        codec, 0x17, 0, AC_VERB_GET_CONNECT_SEL, 0x00)
+                        == ((spec->codec_type == VT1708S)  ? 5 : 0);
+                /* inputs */
+                /* PW 1/2/5 (1ah/1bh/1eh) */
+                parm = AC_PWRST_D3;
+                set_pin_power_state(codec, 0x1a, &parm);
+                set_pin_power_state(codec, 0x1b, &parm);
+                set_pin_power_state(codec, 0x1e, &parm);
+                if (imux_is_smixer)
+                        parm = AC_PWRST_D0;
+                /* SW0 (17h), AIW 0/1 (13h/14h) */
+                snd_hda_codec_write(codec, 0x17, 0, AC_VERB_SET_POWER_STATE,
+                                    parm);
+                snd_hda_codec_write(codec, 0x13, 0, AC_VERB_SET_POWER_STATE,
+                                    parm);
+                snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_POWER_STATE,
+                                    parm);
+
+                /* outputs */
+                /* PW0 (19h), SW1 (18h), AOW1 (11h) */
+                parm = AC_PWRST_D3;
+                set_pin_power_state(codec, 0x19, &parm);
+                snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_POWER_STATE,
+                                    parm);
+                snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE,
+                                    parm);
+
+                /* PW6 (22h), SW2 (26h), AOW2 (24h) */
+                if (is_8ch) {
+                        parm = AC_PWRST_D3;
+                        set_pin_power_state(codec, 0x22, &parm);
+                        snd_hda_codec_write(codec, 0x26, 0,
+                                            AC_VERB_SET_POWER_STATE, parm);
+                        snd_hda_codec_write(codec, 0x24, 0,
+                                            AC_VERB_SET_POWER_STATE, parm);
+                }
+
+                /* PW 3/4/7 (1ch/1dh/23h) */
+                parm = AC_PWRST_D3;
+                /* force to D0 for internal Speaker */
+                set_pin_power_state(codec, 0x1c, &parm);
+                set_pin_power_state(codec, 0x1d, &parm);
+                if (is_8ch)
+                        set_pin_power_state(codec, 0x23, &parm);
+                /* MW0 (16h), Sw3 (27h), AOW 0/3 (10h/25h) */
+                snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_POWER_STATE,
+                                    imux_is_smixer ? AC_PWRST_D0 : parm);
+                snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE,
+                                    parm);
+                if (is_8ch) {
+                        snd_hda_codec_write(codec, 0x25, 0,
+                                            AC_VERB_SET_POWER_STATE, parm);
+                        snd_hda_codec_write(codec, 0x27, 0,
+                                            AC_VERB_SET_POWER_STATE, parm);
+                }
+        }  else if (spec->codec_type == VT1718S) {
+                /* MUX6 (1eh) = stereo mixer */
+                imux_is_smixer = snd_hda_codec_read(
+                        codec, 0x1e, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 5;
+                /* inputs */
+                /* PW 5/6/7 (29h/2ah/2bh) */
+                parm = AC_PWRST_D3;
+                set_pin_power_state(codec, 0x29, &parm);
+                set_pin_power_state(codec, 0x2a, &parm);
+                set_pin_power_state(codec, 0x2b, &parm);
+                if (imux_is_smixer)
+                        parm = AC_PWRST_D0;
+                /* MUX6/7 (1eh/1fh), AIW 0/1 (10h/11h) */
+                snd_hda_codec_write(codec, 0x1e, 0, AC_VERB_SET_POWER_STATE,
+                                    parm);
+                snd_hda_codec_write(codec, 0x1f, 0, AC_VERB_SET_POWER_STATE,
+                                    parm);
+                snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE,
+                                    parm);
+                snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE,
+                                    parm);
+
+                /* outputs */
+                /* PW3 (27h), MW2 (1ah), AOW3 (bh) */
+                parm = AC_PWRST_D3;
+                set_pin_power_state(codec, 0x27, &parm);
+                snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_POWER_STATE,
+                                    parm);
+                snd_hda_codec_write(codec, 0xb, 0, AC_VERB_SET_POWER_STATE,
+                                    parm);
+
+                /* PW2 (26h), AOW2 (ah) */
+                parm = AC_PWRST_D3;
+                set_pin_power_state(codec, 0x26, &parm);
+                snd_hda_codec_write(codec, 0xa, 0, AC_VERB_SET_POWER_STATE,
+                                    parm);
+
+                /* PW0/1 (24h/25h) */
+                parm = AC_PWRST_D3;
+                set_pin_power_state(codec, 0x24, &parm);
+                set_pin_power_state(codec, 0x25, &parm);
+                if (!spec->hp_independent_mode) /* check for redirected HP */
+                        set_pin_power_state(codec, 0x28, &parm);
+                snd_hda_codec_write(codec, 0x8, 0, AC_VERB_SET_POWER_STATE,
+                                    parm);
+                snd_hda_codec_write(codec, 0x9, 0, AC_VERB_SET_POWER_STATE,
+                                    parm);
+                /* MW9 (21h), Mw2 (1ah), AOW0 (8h) */
+                snd_hda_codec_write(codec, 0x21, 0, AC_VERB_SET_POWER_STATE,
+                                    imux_is_smixer ? AC_PWRST_D0 : parm);
+                if (spec->hp_independent_mode) {
+                        /* PW4 (28h), MW3 (1bh), MUX1(34h), AOW4 (ch) */
+                        parm = AC_PWRST_D3;
+                        set_pin_power_state(codec, 0x28, &parm);
+                        snd_hda_codec_write(codec, 0x1b, 0,
+                                            AC_VERB_SET_POWER_STATE, parm);
+                        snd_hda_codec_write(codec, 0x34, 0,
+                                            AC_VERB_SET_POWER_STATE, parm);
+                        snd_hda_codec_write(codec, 0xc, 0,
+                                            AC_VERB_SET_POWER_STATE, parm);
+                }
+        } else if (spec->codec_type == VT1716S) {
+                unsigned int mono_out, present;
+                /* SW0 (17h) = stereo mixer */
+                imux_is_smixer = snd_hda_codec_read(
+                        codec, 0x17, 0, AC_VERB_GET_CONNECT_SEL, 0x00) ==  5;
+                /* inputs */
+                /* PW 1/2/5 (1ah/1bh/1eh) */
+                parm = AC_PWRST_D3;
+                set_pin_power_state(codec, 0x1a, &parm);
+                set_pin_power_state(codec, 0x1b, &parm);
+                set_pin_power_state(codec, 0x1e, &parm);
+                if (imux_is_smixer)
+                        parm = AC_PWRST_D0;
+                /* SW0 (17h), AIW0(13h) */
+                snd_hda_codec_write(codec, 0x17, 0, AC_VERB_SET_POWER_STATE,
+                                    parm);
+                snd_hda_codec_write(codec, 0x13, 0, AC_VERB_SET_POWER_STATE,
+                                    parm);
+
+                parm = AC_PWRST_D3;
+                set_pin_power_state(codec, 0x1e, &parm);
+                /* PW11 (22h) */
+                if (spec->dmic_enabled)
+                        set_pin_power_state(codec, 0x22, &parm);
+                else
+                        snd_hda_codec_write(
+                                codec, 0x22, 0,
+                                AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
+
+                /* SW2(26h), AIW1(14h) */
+                snd_hda_codec_write(codec, 0x26, 0, AC_VERB_SET_POWER_STATE,
+                                    parm);
+                snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_POWER_STATE,
+                                    parm);
+
+                /* outputs */
+                /* PW0 (19h), SW1 (18h), AOW1 (11h) */
+                parm = AC_PWRST_D3;
+                set_pin_power_state(codec, 0x19, &parm);
+                /* Smart 5.1 PW2(1bh) */
+                if (spec->smart51_enabled)
+                        set_pin_power_state(codec, 0x1b, &parm);
+                snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_POWER_STATE,
+                                    parm);
+                snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE,
+                                    parm);
+
+                /* PW7 (23h), SW3 (27h), AOW3 (25h) */
+                parm = AC_PWRST_D3;
+                set_pin_power_state(codec, 0x23, &parm);
+                /* Smart 5.1 PW1(1ah) */
+                if (spec->smart51_enabled)
+                        set_pin_power_state(codec, 0x1a, &parm);
+                snd_hda_codec_write(codec, 0x27, 0, AC_VERB_SET_POWER_STATE,
+                                    parm);
+
+                /* Smart 5.1 PW5(1eh) */
+                if (spec->smart51_enabled)
+                        set_pin_power_state(codec, 0x1e, &parm);
+                snd_hda_codec_write(codec, 0x25, 0, AC_VERB_SET_POWER_STATE,
+                                    parm);
+
+                /* Mono out */
+                /* SW4(28h)->MW1(29h)-> PW12 (2ah)*/
+                present = snd_hda_jack_detect(codec, 0x1c);
+                if (present)
+                        mono_out = 0;
+                else {
+                        present = snd_hda_jack_detect(codec, 0x1d);
+                        if (!spec->hp_independent_mode && present)
+                                mono_out = 0;
+                        else
+                                mono_out = 1;
+                }
+                parm = mono_out ? AC_PWRST_D0 : AC_PWRST_D3;
+                snd_hda_codec_write(codec, 0x28, 0, AC_VERB_SET_POWER_STATE,
+                                    parm);
+                snd_hda_codec_write(codec, 0x29, 0, AC_VERB_SET_POWER_STATE,
+                                    parm);
+                snd_hda_codec_write(codec, 0x2a, 0, AC_VERB_SET_POWER_STATE,
+                                    parm);
+
+                /* PW 3/4 (1ch/1dh) */
+                parm = AC_PWRST_D3;
+                set_pin_power_state(codec, 0x1c, &parm);
+                set_pin_power_state(codec, 0x1d, &parm);
+                /* HP Independent Mode, power on AOW3 */
+                if (spec->hp_independent_mode)
+                        snd_hda_codec_write(codec, 0x25, 0,
+                                            AC_VERB_SET_POWER_STATE, parm);
+
+                /* force to D0 for internal Speaker */
+                /* MW0 (16h), AOW0 (10h) */
+                snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_POWER_STATE,
+                                    imux_is_smixer ? AC_PWRST_D0 : parm);
+                snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE,
+                                    mono_out ? AC_PWRST_D0 : parm);
+        } else if (spec->codec_type == VT2002P) {
+                unsigned int present;
+                /* MUX9 (1eh) = stereo mixer */
+                imux_is_smixer = snd_hda_codec_read(
+                        codec, 0x1e, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 3;
+                /* inputs */
+                /* PW 5/6/7 (29h/2ah/2bh) */
+                parm = AC_PWRST_D3;
+                set_pin_power_state(codec, 0x29, &parm);
+                set_pin_power_state(codec, 0x2a, &parm);
+                set_pin_power_state(codec, 0x2b, &parm);
+                if (imux_is_smixer)
+                        parm = AC_PWRST_D0;
+                /* MUX9/10 (1eh/1fh), AIW 0/1 (10h/11h) */
+                snd_hda_codec_write(codec, 0x1e, 0,
+                                    AC_VERB_SET_POWER_STATE, parm);
+                snd_hda_codec_write(codec, 0x1f, 0,
+                                    AC_VERB_SET_POWER_STATE, parm);
+                snd_hda_codec_write(codec, 0x10, 0,
+                                    AC_VERB_SET_POWER_STATE, parm);
+                snd_hda_codec_write(codec, 0x11, 0,
+                                    AC_VERB_SET_POWER_STATE, parm);
+
+                /* outputs */
+                /* AOW0 (8h)*/
+                snd_hda_codec_write(codec, 0x8, 0,
+                                    AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
+
+                /* PW4 (26h), MW4 (1ch), MUX4(37h) */
+                parm = AC_PWRST_D3;
+                set_pin_power_state(codec, 0x26, &parm);
+                snd_hda_codec_write(codec, 0x1c, 0,
+                                    AC_VERB_SET_POWER_STATE, parm);
+                snd_hda_codec_write(codec, 0x37,
+                                    0, AC_VERB_SET_POWER_STATE, parm);
+
+                /* PW1 (25h), MW1 (19h), MUX1(35h), AOW1 (9h) */
+                parm = AC_PWRST_D3;
+                set_pin_power_state(codec, 0x25, &parm);
+                snd_hda_codec_write(codec, 0x19, 0,
+                                    AC_VERB_SET_POWER_STATE, parm);
+                snd_hda_codec_write(codec, 0x35, 0,
+                                    AC_VERB_SET_POWER_STATE, parm);
+                if (spec->hp_independent_mode)  {
+                        snd_hda_codec_write(codec, 0x9, 0,
+                                            AC_VERB_SET_POWER_STATE, parm);
+                }
+
+                /* Class-D */
+                /* PW0 (24h), MW0(18h), MUX0(34h) */
+                present = snd_hda_jack_detect(codec, 0x25);
+                parm = AC_PWRST_D3;
+                set_pin_power_state(codec, 0x24, &parm);
+                if (present) {
+                        snd_hda_codec_write(
+                                codec, 0x18, 0,
+                                AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
+                        snd_hda_codec_write(
+                                codec, 0x34, 0,
+                                AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
+                } else {
+                        snd_hda_codec_write(
+                                codec, 0x18, 0,
+                                AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
+                        snd_hda_codec_write(
+                                codec, 0x34, 0,
+                                AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
+                }
+
+                /* Mono Out */
+                /* PW15 (31h), MW8(17h), MUX8(3bh) */
+                present = snd_hda_jack_detect(codec, 0x26);
+                parm = AC_PWRST_D3;
+                set_pin_power_state(codec, 0x31, &parm);
+                if (present) {
+                        snd_hda_codec_write(
+                                codec, 0x17, 0,
+                                AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
+                        snd_hda_codec_write(
+                                codec, 0x3b, 0,
+                                AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
+                } else {
+                        snd_hda_codec_write(
+                                codec, 0x17, 0,
+                                AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
+                        snd_hda_codec_write(
+                                codec, 0x3b, 0,
+                                AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
+                }
+
+                /* MW9 (21h) */
+                if (imux_is_smixer || !is_aa_path_mute(codec))
+                        snd_hda_codec_write(
+                                codec, 0x21, 0,
+                                AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
+                else
+                        snd_hda_codec_write(
+                                codec, 0x21, 0,
+                                AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
+        } else if (spec->codec_type == VT1812) {
+                unsigned int present;
+                /* MUX10 (1eh) = stereo mixer */
+                imux_is_smixer = snd_hda_codec_read(
+                        codec, 0x1e, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 5;
+                /* inputs */
+                /* PW 5/6/7 (29h/2ah/2bh) */
+                parm = AC_PWRST_D3;
+                set_pin_power_state(codec, 0x29, &parm);
+                set_pin_power_state(codec, 0x2a, &parm);
+                set_pin_power_state(codec, 0x2b, &parm);
+                if (imux_is_smixer)
+                        parm = AC_PWRST_D0;
+                /* MUX10/11 (1eh/1fh), AIW 0/1 (10h/11h) */
+                snd_hda_codec_write(codec, 0x1e, 0,
+                                    AC_VERB_SET_POWER_STATE, parm);
+                snd_hda_codec_write(codec, 0x1f, 0,
+                                    AC_VERB_SET_POWER_STATE, parm);
+                snd_hda_codec_write(codec, 0x10, 0,
+                                    AC_VERB_SET_POWER_STATE, parm);
+                snd_hda_codec_write(codec, 0x11, 0,
+                                    AC_VERB_SET_POWER_STATE, parm);
+
+                /* outputs */
+                /* AOW0 (8h)*/
+                snd_hda_codec_write(codec, 0x8, 0,
+                                    AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
+
+                /* PW4 (28h), MW4 (18h), MUX4(38h) */
+                parm = AC_PWRST_D3;
+                set_pin_power_state(codec, 0x28, &parm);
+                snd_hda_codec_write(codec, 0x18, 0,
+                                    AC_VERB_SET_POWER_STATE, parm);
+                snd_hda_codec_write(codec, 0x38, 0,
+                                    AC_VERB_SET_POWER_STATE, parm);
+
+                /* PW1 (25h), MW1 (15h), MUX1(35h), AOW1 (9h) */
+                parm = AC_PWRST_D3;
+                set_pin_power_state(codec, 0x25, &parm);
+                snd_hda_codec_write(codec, 0x15, 0,
+                                    AC_VERB_SET_POWER_STATE, parm);
+                snd_hda_codec_write(codec, 0x35, 0,
+                                    AC_VERB_SET_POWER_STATE, parm);
+                if (spec->hp_independent_mode)  {
+                        snd_hda_codec_write(codec, 0x9, 0,
+                                            AC_VERB_SET_POWER_STATE, parm);
+                }
+
+                /* Internal Speaker */
+                /* PW0 (24h), MW0(14h), MUX0(34h) */
+                present = snd_hda_jack_detect(codec, 0x25);
+                parm = AC_PWRST_D3;
+                set_pin_power_state(codec, 0x24, &parm);
+                if (present) {
+                        snd_hda_codec_write(codec, 0x14, 0,
+                                            AC_VERB_SET_POWER_STATE,
+                                            AC_PWRST_D3);
+                        snd_hda_codec_write(codec, 0x34, 0,
+                                            AC_VERB_SET_POWER_STATE,
+                                            AC_PWRST_D3);
+                } else {
+                        snd_hda_codec_write(codec, 0x14, 0,
+                                            AC_VERB_SET_POWER_STATE,
+                                            AC_PWRST_D0);
+                        snd_hda_codec_write(codec, 0x34, 0,
+                                            AC_VERB_SET_POWER_STATE,
+                                            AC_PWRST_D0);
+                }
+                /* Mono Out */
+                /* PW13 (31h), MW13(1ch), MUX13(3ch), MW14(3eh) */
+                present = snd_hda_jack_detect(codec, 0x28);
+                parm = AC_PWRST_D3;
+                set_pin_power_state(codec, 0x31, &parm);
+                if (present) {
+                        snd_hda_codec_write(codec, 0x1c, 0,
+                                            AC_VERB_SET_POWER_STATE,
+                                            AC_PWRST_D3);
+                        snd_hda_codec_write(codec, 0x3c, 0,
+                                            AC_VERB_SET_POWER_STATE,
+                                            AC_PWRST_D3);
+                        snd_hda_codec_write(codec, 0x3e, 0,
+                                            AC_VERB_SET_POWER_STATE,
+                                            AC_PWRST_D3);
+                } else {
+                        snd_hda_codec_write(codec, 0x1c, 0,
+                                            AC_VERB_SET_POWER_STATE,
+                                            AC_PWRST_D0);
+                        snd_hda_codec_write(codec, 0x3c, 0,
+                                            AC_VERB_SET_POWER_STATE,
+                                            AC_PWRST_D0);
+                        snd_hda_codec_write(codec, 0x3e, 0,
+                                            AC_VERB_SET_POWER_STATE,
+                                            AC_PWRST_D0);
+                }
+
+                /* PW15 (33h), MW15 (1dh), MUX15(3dh) */
+                parm = AC_PWRST_D3;
+                set_pin_power_state(codec, 0x33, &parm);
+                snd_hda_codec_write(codec, 0x1d, 0,
+                                    AC_VERB_SET_POWER_STATE, parm);
+                snd_hda_codec_write(codec, 0x3d, 0,
+                                    AC_VERB_SET_POWER_STATE, parm);
+
+                /* MW9 (21h) */
+                if (imux_is_smixer || !is_aa_path_mute(codec))
+                        snd_hda_codec_write(
+                                codec, 0x21, 0,
+                                AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
+                else
+                        snd_hda_codec_write(
+                                codec, 0x21, 0,
+                                AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
+        }
+}
+
 /*
  * input MUX handling
  */
@@ -395,6 +1094,14 @@ static int via_mux_enum_put(struct snd_kcontrol *kcontrol,
 
         if (!spec->mux_nids[adc_idx])
                 return -EINVAL;
+        /* switch to D0 beofre change index */
+        if (snd_hda_codec_read(codec, spec->mux_nids[adc_idx], 0,
+                               AC_VERB_GET_POWER_STATE, 0x00) != AC_PWRST_D0)
+                snd_hda_codec_write(codec, spec->mux_nids[adc_idx], 0,
+                                    AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
+        /* update jack power state */
+        set_jack_power_state(codec);
+
         return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
                                      spec->mux_nids[adc_idx],
                                      &spec->cur_mux[adc_idx]);
@@ -412,80 +1119,340 @@ static int via_independent_hp_get(struct snd_kcontrol *kcontrol,
                                   struct snd_ctl_elem_value *ucontrol)
 {
         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-        struct via_spec *spec = codec->spec;
-        hda_nid_t nid = spec->autocfg.hp_pins[0];
-        unsigned int pinsel = snd_hda_codec_read(codec, nid, 0,
-                                                 AC_VERB_GET_CONNECT_SEL,
-                                                 0x00);
+        hda_nid_t nid = kcontrol->private_value;
+        unsigned int pinsel;
 
+        /* use !! to translate conn sel 2 for VT1718S */
+        pinsel = !!snd_hda_codec_read(codec, nid, 0,
+                                      AC_VERB_GET_CONNECT_SEL,
+                                      0x00);
         ucontrol->value.enumerated.item[0] = pinsel;
 
         return 0;
 }
 
+static void activate_ctl(struct hda_codec *codec, const char *name, int active)
+{
+        struct snd_kcontrol *ctl = snd_hda_find_mixer_ctl(codec, name);
+        if (ctl) {
+                ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
+                ctl->vd[0].access |= active
+                        ? 0 : SNDRV_CTL_ELEM_ACCESS_INACTIVE;
+                snd_ctl_notify(codec->bus->card,
+                               SNDRV_CTL_EVENT_MASK_VALUE, &ctl->id);
+        }
+}
+
+static hda_nid_t side_mute_channel(struct via_spec *spec)
+{
+        switch (spec->codec_type) {
+        case VT1708:            return 0x1b;
+        case VT1709_10CH:       return 0x29;
+        case VT1708B_8CH:       /* fall thru */
+        case VT1708S:           return 0x27;
+        default:                return 0;
+        }
+}
+
+static int update_side_mute_status(struct hda_codec *codec)
+{
+        /* mute side channel */
+        struct via_spec *spec = codec->spec;
+        unsigned int parm = spec->hp_independent_mode
+                ? AMP_OUT_MUTE : AMP_OUT_UNMUTE;
+        hda_nid_t sw3 = side_mute_channel(spec);
+
+        if (sw3)
+                snd_hda_codec_write(codec, sw3, 0, AC_VERB_SET_AMP_GAIN_MUTE,
+                                    parm);
+        return 0;
+}
+
 static int via_independent_hp_put(struct snd_kcontrol *kcontrol,
                                   struct snd_ctl_elem_value *ucontrol)
 {
         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
         struct via_spec *spec = codec->spec;
-        hda_nid_t nid = spec->autocfg.hp_pins[0];
+        hda_nid_t nid = kcontrol->private_value;
         unsigned int pinsel = ucontrol->value.enumerated.item[0];
-        unsigned int con_nid = snd_hda_codec_read(codec, nid, 0,
-                                         AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
-
-        if (con_nid == spec->multiout.hp_nid) {
-                if (pinsel == 0) {
-                        if (!spec->hp_independent_mode) {
-                                if (spec->multiout.num_dacs > 1)
-                                        spec->multiout.num_dacs -= 1;
-                                spec->hp_independent_mode = 1;
-                        }
-                } else if (pinsel == 1) {
-                       if (spec->hp_independent_mode) {
-                                if (spec->multiout.num_dacs > 1)
-                                        spec->multiout.num_dacs += 1;
-                                spec->hp_independent_mode = 0;
-                       }
-                }
-        } else {
-                if (pinsel == 0) {
-                        if (spec->hp_independent_mode) {
-                                if (spec->multiout.num_dacs > 1)
-                                        spec->multiout.num_dacs += 1;
-                                spec->hp_independent_mode = 0;
-                        }
-                } else if (pinsel == 1) {
-                       if (!spec->hp_independent_mode) {
-                                if (spec->multiout.num_dacs > 1)
-                                        spec->multiout.num_dacs -= 1;
-                                spec->hp_independent_mode = 1;
-                       }
-                }
+        /* Get Independent Mode index of headphone pin widget */
+        spec->hp_independent_mode = spec->hp_independent_mode_index == pinsel
+                ? 1 : 0;
+        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, pinsel);
+
+        if (spec->multiout.hp_nid && spec->multiout.hp_nid
+            != spec->multiout.dac_nids[HDA_FRONT])
+                snd_hda_codec_setup_stream(codec, spec->multiout.hp_nid,
+                                           0, 0, 0);
+
+        update_side_mute_status(codec);
+        /* update HP volume/swtich active state */
+        if (spec->codec_type == VT1708S
+            || spec->codec_type == VT1702
+            || spec->codec_type == VT1718S
+            || spec->codec_type == VT1716S
+            || spec->codec_type == VT2002P
+            || spec->codec_type == VT1812) {
+                activate_ctl(codec, "Headphone Playback Volume",
+                             spec->hp_independent_mode);
+                activate_ctl(codec, "Headphone Playback Switch",
+                             spec->hp_independent_mode);
         }
-        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
-                            pinsel);
-
-        if (spec->multiout.hp_nid &&
-            spec->multiout.hp_nid != spec->multiout.dac_nids[HDA_FRONT])
-                        snd_hda_codec_setup_stream(codec,
-                                                   spec->multiout.hp_nid,
-                                                   0, 0, 0);
-
         return 0;
 }
 
-static struct snd_kcontrol_new via_hp_mixer[] = {
+static struct snd_kcontrol_new via_hp_mixer[2] = {
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
                 .name = "Independent HP",
-                .count = 1,
                 .info = via_independent_hp_info,
                 .get = via_independent_hp_get,
                 .put = via_independent_hp_put,
         },
-        { } /* end */
+        {
+                .iface = NID_MAPPING,
+                .name = "Independent HP",
+        },
+};
+
+static int via_hp_build(struct hda_codec *codec)
+{
+        struct via_spec *spec = codec->spec;
+        struct snd_kcontrol_new *knew;
+        hda_nid_t nid;
+        int nums;
+        hda_nid_t conn[HDA_MAX_CONNECTIONS];
+
+        switch (spec->codec_type) {
+        case VT1718S:
+                nid = 0x34;
+                break;
+        case VT2002P:
+                nid = 0x35;
+                break;
+        case VT1812:
+                nid = 0x3d;
+                break;
+        default:
+                nid = spec->autocfg.hp_pins[0];
+                break;
+        }
+
+        nums = snd_hda_get_connections(codec, nid, conn, HDA_MAX_CONNECTIONS);
+        if (nums <= 1)
+                return 0;
+
+        knew = via_clone_control(spec, &via_hp_mixer[0]);
+        if (knew == NULL)
+                return -ENOMEM;
+
+        knew->subdevice = HDA_SUBDEV_NID_FLAG | nid;
+        knew->private_value = nid;
+
+        knew = via_clone_control(spec, &via_hp_mixer[1]);
+        if (knew == NULL)
+                return -ENOMEM;
+        knew->subdevice = side_mute_channel(spec);
+
+        return 0;
+}
+
+static void notify_aa_path_ctls(struct hda_codec *codec)
+{
+        int i;
+        struct snd_ctl_elem_id id;
+        const char *labels[] = {"Mic", "Front Mic", "Line"};
+
+        memset(&id, 0, sizeof(id));
+        id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
+        for (i = 0; i < ARRAY_SIZE(labels); i++) {
+                sprintf(id.name, "%s Playback Volume", labels[i]);
+                snd_ctl_notify(codec->bus->card, SNDRV_CTL_EVENT_MASK_VALUE,
+                               &id);
+        }
+}
+
+static void mute_aa_path(struct hda_codec *codec, int mute)
+{
+        struct via_spec *spec = codec->spec;
+        hda_nid_t  nid_mixer;
+        int start_idx;
+        int end_idx;
+        int i;
+        /* get nid of MW0 and start & end index */
+        switch (spec->codec_type) {
+        case VT1708:
+                nid_mixer = 0x17;
+                start_idx = 2;
+                end_idx = 4;
+                break;
+        case VT1709_10CH:
+        case VT1709_6CH:
+                nid_mixer = 0x18;
+                start_idx = 2;
+                end_idx = 4;
+                break;
+        case VT1708B_8CH:
+        case VT1708B_4CH:
+        case VT1708S:
+        case VT1716S:
+                nid_mixer = 0x16;
+                start_idx = 2;
+                end_idx = 4;
+                break;
+        default:
+                return;
+        }
+        /* check AA path's mute status */
+        for (i = start_idx; i <= end_idx; i++) {
+                int val = mute ? HDA_AMP_MUTE : HDA_AMP_UNMUTE;
+                snd_hda_codec_amp_stereo(codec, nid_mixer, HDA_INPUT, i,
+                                         HDA_AMP_MUTE, val);
+        }
+}
+static int is_smart51_pins(struct via_spec *spec, hda_nid_t pin)
+{
+        int res = 0;
+        int index;
+        for (index = AUTO_PIN_MIC; index < AUTO_PIN_FRONT_LINE; index++) {
+                if (pin == spec->autocfg.input_pins[index]) {
+                        res = 1;
+                        break;
+                }
+        }
+        return res;
+}
+
+static int via_smart51_info(struct snd_kcontrol *kcontrol,
+                            struct snd_ctl_elem_info *uinfo)
+{
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
+        uinfo->count = 1;
+        uinfo->value.integer.min = 0;
+        uinfo->value.integer.max = 1;
+        return 0;
+}
+
+static int via_smart51_get(struct snd_kcontrol *kcontrol,
+                           struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct via_spec *spec = codec->spec;
+        int index[] = { AUTO_PIN_MIC, AUTO_PIN_FRONT_MIC, AUTO_PIN_LINE };
+        int on = 1;
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(index); i++) {
+                hda_nid_t nid = spec->autocfg.input_pins[index[i]];
+                if (nid) {
+                        int ctl =
+                            snd_hda_codec_read(codec, nid, 0,
+                                               AC_VERB_GET_PIN_WIDGET_CONTROL,
+                                               0);
+                        if (i == AUTO_PIN_FRONT_MIC
+                            && spec->hp_independent_mode
+                            && spec->codec_type != VT1718S)
+                                continue; /* ignore FMic for independent HP */
+                        if (ctl & AC_PINCTL_IN_EN
+                            && !(ctl & AC_PINCTL_OUT_EN))
+                                on = 0;
+                }
+        }
+        *ucontrol->value.integer.value = on;
+        return 0;
+}
+
+static int via_smart51_put(struct snd_kcontrol *kcontrol,
+                           struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct via_spec *spec = codec->spec;
+        int out_in = *ucontrol->value.integer.value
+                ? AC_PINCTL_OUT_EN : AC_PINCTL_IN_EN;
+        int index[] = { AUTO_PIN_MIC, AUTO_PIN_FRONT_MIC, AUTO_PIN_LINE };
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(index); i++) {
+                hda_nid_t nid = spec->autocfg.input_pins[index[i]];
+                if (i == AUTO_PIN_FRONT_MIC
+                    && spec->hp_independent_mode
+                    && spec->codec_type != VT1718S)
+                        continue; /* don't retask FMic for independent HP */
+                if (nid) {
+                        unsigned int parm = snd_hda_codec_read(
+                                codec, nid, 0,
+                                AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
+                        parm &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
+                        parm |= out_in;
+                        snd_hda_codec_write(codec, nid, 0,
+                                            AC_VERB_SET_PIN_WIDGET_CONTROL,
+                                            parm);
+                        if (out_in == AC_PINCTL_OUT_EN) {
+                                mute_aa_path(codec, 1);
+                                notify_aa_path_ctls(codec);
+                        }
+                        if (spec->codec_type == VT1718S)
+                                snd_hda_codec_amp_stereo(
+                                        codec, nid, HDA_OUTPUT, 0, HDA_AMP_MUTE,
+                                        HDA_AMP_UNMUTE);
+                }
+                if (i == AUTO_PIN_FRONT_MIC) {
+                        if (spec->codec_type == VT1708S
+                            || spec->codec_type == VT1716S) {
+                                /* input = index 1 (AOW3) */
+                                snd_hda_codec_write(
+                                        codec, nid, 0,
+                                        AC_VERB_SET_CONNECT_SEL, 1);
+                                snd_hda_codec_amp_stereo(
+                                        codec, nid, HDA_OUTPUT,
+                                        0, HDA_AMP_MUTE, HDA_AMP_UNMUTE);
+                        }
+                }
+        }
+        spec->smart51_enabled = *ucontrol->value.integer.value;
+        set_jack_power_state(codec);
+        return 1;
+}
+
+static struct snd_kcontrol_new via_smart51_mixer[2] = {
+        {
+         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+         .name = "Smart 5.1",
+         .count = 1,
+         .info = via_smart51_info,
+         .get = via_smart51_get,
+         .put = via_smart51_put,
+         },
+        {
+         .iface = NID_MAPPING,
+         .name = "Smart 5.1",
+        }
 };
 
+static int via_smart51_build(struct via_spec *spec)
+{
+        struct snd_kcontrol_new *knew;
+        int index[] = { AUTO_PIN_MIC, AUTO_PIN_FRONT_MIC, AUTO_PIN_LINE };
+        hda_nid_t nid;
+        int i;
+
+        knew = via_clone_control(spec, &via_smart51_mixer[0]);
+        if (knew == NULL)
+                return -ENOMEM;
+
+        for (i = 0; i < ARRAY_SIZE(index); i++) {
+                nid = spec->autocfg.input_pins[index[i]];
+                if (nid) {
+                        knew = via_clone_control(spec, &via_smart51_mixer[1]);
+                        if (knew == NULL)
+                                return -ENOMEM;
+                        knew->subdevice = nid;
+                }
+        }
+
+        return 0;
+}
+
 /* capture mixer elements */
 static struct snd_kcontrol_new vt1708_capture_mixer[] = {
         HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_INPUT),
@@ -506,6 +1473,112 @@ static struct snd_kcontrol_new vt1708_capture_mixer[] = {
         },
         { } /* end */
 };
+
+/* check AA path's mute statue */
+static int is_aa_path_mute(struct hda_codec *codec)
+{
+        int mute = 1;
+        hda_nid_t  nid_mixer;
+        int start_idx;
+        int end_idx;
+        int i;
+        struct via_spec *spec = codec->spec;
+        /* get nid of MW0 and start & end index */
+        switch (spec->codec_type) {
+        case VT1708B_8CH:
+        case VT1708B_4CH:
+        case VT1708S:
+        case VT1716S:
+                nid_mixer = 0x16;
+                start_idx = 2;
+                end_idx = 4;
+                break;
+        case VT1702:
+                nid_mixer = 0x1a;
+                start_idx = 1;
+                end_idx = 3;
+                break;
+        case VT1718S:
+                nid_mixer = 0x21;
+                start_idx = 1;
+                end_idx = 3;
+                break;
+        case VT2002P:
+        case VT1812:
+                nid_mixer = 0x21;
+                start_idx = 0;
+                end_idx = 2;
+                break;
+        default:
+                return 0;
+        }
+        /* check AA path's mute status */
+        for (i = start_idx; i <= end_idx; i++) {
+                unsigned int con_list = snd_hda_codec_read(
+                        codec, nid_mixer, 0, AC_VERB_GET_CONNECT_LIST, i/4*4);
+                int shift = 8 * (i % 4);
+                hda_nid_t nid_pin = (con_list & (0xff << shift)) >> shift;
+                unsigned int defconf = snd_hda_codec_get_pincfg(codec, nid_pin);
+                if (get_defcfg_connect(defconf) == AC_JACK_PORT_COMPLEX) {
+                        /* check mute status while the pin is connected */
+                        int mute_l = snd_hda_codec_amp_read(codec, nid_mixer, 0,
+                                                            HDA_INPUT, i) >> 7;
+                        int mute_r = snd_hda_codec_amp_read(codec, nid_mixer, 1,
+                                                            HDA_INPUT, i) >> 7;
+                        if (!mute_l || !mute_r) {
+                                mute = 0;
+                                break;
+                        }
+                }
+        }
+        return mute;
+}
+
+/* enter/exit analog low-current mode */
+static void analog_low_current_mode(struct hda_codec *codec, int stream_idle)
+{
+        struct via_spec *spec = codec->spec;
+        static int saved_stream_idle = 1; /* saved stream idle status */
+        int enable = is_aa_path_mute(codec);
+        unsigned int verb = 0;
+        unsigned int parm = 0;
+
+        if (stream_idle == -1)  /* stream status did not change */
+                enable = enable && saved_stream_idle;
+        else {
+                enable = enable && stream_idle;
+                saved_stream_idle = stream_idle;
+        }
+
+        /* decide low current mode's verb & parameter */
+        switch (spec->codec_type) {
+        case VT1708B_8CH:
+        case VT1708B_4CH:
+                verb = 0xf70;
+                parm = enable ? 0x02 : 0x00; /* 0x02: 2/3x, 0x00: 1x */
+                break;
+        case VT1708S:
+        case VT1718S:
+        case VT1716S:
+                verb = 0xf73;
+                parm = enable ? 0x51 : 0xe1; /* 0x51: 4/28x, 0xe1: 1x */
+                break;
+        case VT1702:
+                verb = 0xf73;
+                parm = enable ? 0x01 : 0x1d; /* 0x01: 4/40x, 0x1d: 1x */
+                break;
+        case VT2002P:
+        case VT1812:
+                verb = 0xf93;
+                parm = enable ? 0x00 : 0xe0; /* 0x00: 4/40x, 0xe0: 1x */
+                break;
+        default:
+                return;         /* other codecs are not supported */
+        }
+        /* send verb */
+        snd_hda_codec_write(codec, codec->afg, 0, verb, parm);
+}
+
 /*
  * generic initialization of ADC, input mixers and output mixers
  */
@@ -534,9 +1607,9 @@ static struct hda_verb vt1708_volume_init_verbs[] = {
         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
-        
-        /* Setup default input to PW4 */
-        {0x20, AC_VERB_SET_CONNECT_SEL, 0x1},
+
+        /* Setup default input MW0 to PW4 */
+        {0x20, AC_VERB_SET_CONNECT_SEL, 0},
         /* PW9 Output enable */
         {0x25, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
         { }
@@ -547,30 +1620,13 @@ static int via_playback_pcm_open(struct hda_pcm_stream *hinfo,
                                  struct snd_pcm_substream *substream)
 {
         struct via_spec *spec = codec->spec;
+        int idle = substream->pstr->substream_opened == 1
+                && substream->ref_count == 0;
+        analog_low_current_mode(codec, idle);
         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
                                              hinfo);
 }
 
-static int via_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 via_spec *spec = codec->spec;
-        return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
-                                                stream_tag, format, substream);
-}
-
-static int via_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
-                                    struct hda_codec *codec,
-                                    struct snd_pcm_substream *substream)
-{
-        struct via_spec *spec = codec->spec;
-        return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
-}
-
-
 static void playback_multi_pcm_prep_0(struct hda_codec *codec,
                                       unsigned int stream_tag,
                                       unsigned int format,
@@ -615,8 +1671,8 @@ static void playback_multi_pcm_prep_0(struct hda_codec *codec,
         snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
                                    0, format);
 
-        if (mout->hp_nid && mout->hp_nid != nids[HDA_FRONT] &&
-            !spec->hp_independent_mode)
+        if (mout->hp_nid && mout->hp_nid != nids[HDA_FRONT]
+            && !spec->hp_independent_mode)
                 /* headphone out will just decode front left/right (stereo) */
                 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
                                            0, format);
@@ -658,7 +1714,7 @@ static int via_playback_multi_pcm_prepare(struct hda_pcm_stream *hinfo,
                         snd_hda_codec_setup_stream(codec, mout->hp_nid,
                                                    stream_tag, 0, format);
         }
-
+        vt1708_start_hp_work(spec);
         return 0;
 }
 
@@ -698,7 +1754,7 @@ static int via_playback_multi_pcm_cleanup(struct hda_pcm_stream *hinfo,
                         snd_hda_codec_setup_stream(codec, mout->hp_nid,
                                                    0, 0, 0);
         }
-
+        vt1708_stop_hp_work(spec);
         return 0;
 }
 
@@ -779,7 +1835,7 @@ static struct hda_pcm_stream vt1708_pcm_analog_playback = {
 };
 
 static struct hda_pcm_stream vt1708_pcm_analog_s16_playback = {
-        .substreams = 1,
+        .substreams = 2,
         .channels_min = 2,
         .channels_max = 8,
         .nid = 0x10, /* NID to query formats and rates */
@@ -790,8 +1846,8 @@ static struct hda_pcm_stream vt1708_pcm_analog_s16_playback = {
         .formats = SNDRV_PCM_FMTBIT_S16_LE,
         .ops = {
                 .open = via_playback_pcm_open,
-                .prepare = via_playback_pcm_prepare,
-                .cleanup = via_playback_pcm_cleanup
+                .prepare = via_playback_multi_pcm_prepare,
+                .cleanup = via_playback_multi_pcm_cleanup
         },
 };
 
@@ -828,8 +1884,9 @@ static struct hda_pcm_stream vt1708_pcm_digital_capture = {
 static int via_build_controls(struct hda_codec *codec)
 {
         struct via_spec *spec = codec->spec;
-        int err;
-        int i;
+        struct snd_kcontrol *kctl;
+        struct snd_kcontrol_new *knew;
+        int err, i;
 
         for (i = 0; i < spec->num_mixers; i++) {
                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
@@ -853,6 +1910,32 @@ static int via_build_controls(struct hda_codec *codec)
                 if (err < 0)
                         return err;
         }
+
+        /* assign Capture Source enums to NID */
+        kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
+        for (i = 0; kctl && i < kctl->count; i++) {
+                err = snd_hda_add_nid(codec, kctl, i, spec->mux_nids[i]);
+                if (err < 0)
+                        return err;
+        }
+
+        /* other nid->control mapping */
+        for (i = 0; i < spec->num_mixers; i++) {
+                for (knew = spec->mixers[i]; knew->name; knew++) {
+                        if (knew->iface != NID_MAPPING)
+                                continue;
+                        kctl = snd_hda_find_mixer_ctl(codec, knew->name);
+                        if (kctl == NULL)
+                                continue;
+                        err = snd_hda_add_nid(codec, kctl, 0,
+                                              knew->subdevice);
+                }
+        }
+
+        /* init power states */
+        set_jack_power_state(codec);
+        analog_low_current_mode(codec, 1);
+
         via_free_kctls(codec); /* no longer needed */
         return 0;
 }
@@ -866,8 +1949,10 @@ static int via_build_pcms(struct hda_codec *codec)
         codec->pcm_info = info;
 
         info->name = spec->stream_name_analog;
-        info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
-        info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
+        info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
+                *(spec->stream_analog_playback);
+        info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
+                spec->multiout.dac_nids[0];
         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
 
@@ -904,20 +1989,58 @@ static void via_free(struct hda_codec *codec)
                 return;
 
         via_free_kctls(codec);
+        vt1708_stop_hp_work(spec);
         kfree(codec->spec);
 }
 
 /* mute internal speaker if HP is plugged */
 static void via_hp_automute(struct hda_codec *codec)
 {
-        unsigned int present;
+        unsigned int present = 0;
         struct via_spec *spec = codec->spec;
 
-        present = snd_hda_codec_read(codec, spec->autocfg.hp_pins[0], 0,
-                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
-        snd_hda_codec_amp_stereo(codec, spec->autocfg.line_out_pins[0],
-                                 HDA_OUTPUT, 0, HDA_AMP_MUTE,
-                                 present ? HDA_AMP_MUTE : 0);
+        present = snd_hda_jack_detect(codec, spec->autocfg.hp_pins[0]);
+
+        if (!spec->hp_independent_mode) {
+                struct snd_ctl_elem_id id;
+                /* auto mute */
+                snd_hda_codec_amp_stereo(
+                        codec, spec->autocfg.line_out_pins[0], HDA_OUTPUT, 0,
+                        HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
+                /* notify change */
+                memset(&id, 0, sizeof(id));
+                id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
+                strcpy(id.name, "Front Playback Switch");
+                snd_ctl_notify(codec->bus->card, SNDRV_CTL_EVENT_MASK_VALUE,
+                               &id);
+        }
+}
+
+/* mute mono out if HP or Line out is plugged */
+static void via_mono_automute(struct hda_codec *codec)
+{
+        unsigned int hp_present, lineout_present;
+        struct via_spec *spec = codec->spec;
+
+        if (spec->codec_type != VT1716S)
+                return;
+
+        lineout_present = snd_hda_jack_detect(codec,
+                                              spec->autocfg.line_out_pins[0]);
+
+        /* Mute Mono Out if Line Out is plugged */
+        if (lineout_present) {
+                snd_hda_codec_amp_stereo(
+                        codec, 0x2A, HDA_OUTPUT, 0, HDA_AMP_MUTE, HDA_AMP_MUTE);
+                return;
+        }
+
+        hp_present = snd_hda_jack_detect(codec, spec->autocfg.hp_pins[0]);
+
+        if (!spec->hp_independent_mode)
+                snd_hda_codec_amp_stereo(
+                        codec, 0x2A, HDA_OUTPUT, 0, HDA_AMP_MUTE,
+                        hp_present ? HDA_AMP_MUTE : 0);
 }
 
 static void via_gpio_control(struct hda_codec *codec)
@@ -968,15 +2091,83 @@ static void via_gpio_control(struct hda_codec *codec)
         }
 }
 
+/* mute Internal-Speaker if HP is plugged */
+static void via_speaker_automute(struct hda_codec *codec)
+{
+        unsigned int hp_present;
+        struct via_spec *spec = codec->spec;
+
+        if (spec->codec_type != VT2002P && spec->codec_type != VT1812)
+                return;
+
+        hp_present = snd_hda_jack_detect(codec, spec->autocfg.hp_pins[0]);
+
+        if (!spec->hp_independent_mode) {
+                struct snd_ctl_elem_id id;
+                snd_hda_codec_amp_stereo(
+                        codec, spec->autocfg.speaker_pins[0], HDA_OUTPUT, 0,
+                        HDA_AMP_MUTE, hp_present ? HDA_AMP_MUTE : 0);
+                /* notify change */
+                memset(&id, 0, sizeof(id));
+                id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
+                strcpy(id.name, "Speaker Playback Switch");
+                snd_ctl_notify(codec->bus->card, SNDRV_CTL_EVENT_MASK_VALUE,
+                               &id);
+        }
+}
+
+/* mute line-out and internal speaker if HP is plugged */
+static void via_hp_bind_automute(struct hda_codec *codec)
+{
+        /* use long instead of int below just to avoid an internal compiler
+         * error with gcc 4.0.x
+         */
+        unsigned long hp_present, present = 0;
+        struct via_spec *spec = codec->spec;
+        int i;
+
+        if (!spec->autocfg.hp_pins[0] || !spec->autocfg.line_out_pins[0])
+                return;
+
+        hp_present = snd_hda_jack_detect(codec, spec->autocfg.hp_pins[0]);
+
+        present = snd_hda_jack_detect(codec, spec->autocfg.line_out_pins[0]);
+
+        if (!spec->hp_independent_mode) {
+                /* Mute Line-Outs */
+                for (i = 0; i < spec->autocfg.line_outs; i++)
+                        snd_hda_codec_amp_stereo(
+                                codec, spec->autocfg.line_out_pins[i],
+                                HDA_OUTPUT, 0,
+                                HDA_AMP_MUTE, hp_present ? HDA_AMP_MUTE : 0);
+                if (hp_present)
+                        present = hp_present;
+        }
+        /* Speakers */
+        for (i = 0; i < spec->autocfg.speaker_outs; i++)
+                snd_hda_codec_amp_stereo(
+                        codec, spec->autocfg.speaker_pins[i], HDA_OUTPUT, 0,
+                        HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
+}
+
+
 /* unsolicited event for jack sensing */
 static void via_unsol_event(struct hda_codec *codec,
                                   unsigned int res)
 {
         res >>= 26;
-        if (res == VIA_HP_EVENT)
+        if (res & VIA_HP_EVENT)
                 via_hp_automute(codec);
-        else if (res == VIA_GPIO_EVENT)
+        if (res & VIA_GPIO_EVENT)
                 via_gpio_control(codec);
+        if (res & VIA_JACK_EVENT)
+                set_jack_power_state(codec);
+        if (res & VIA_MONO_EVENT)
+                via_mono_automute(codec);
+        if (res & VIA_SPEAKER_EVENT)
+                via_speaker_automute(codec);
+        if (res & VIA_BIND_HP_EVENT)
+                via_hp_bind_automute(codec);
 }
 
 static int via_init(struct hda_codec *codec)
@@ -986,6 +2177,10 @@ static int via_init(struct hda_codec *codec)
         for (i = 0; i < spec->num_iverbs; i++)
                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
 
+        spec->codec_type = get_codec_type(codec);
+        if (spec->codec_type == VT1708BCE)
+                spec->codec_type = VT1708S; /* VT1708BCE & VT1708S are almost
+                                               same */
         /* Lydia Add for EAPD enable */
         if (!spec->dig_in_nid) { /* No Digital In connection */
                 if (spec->dig_in_pin) {
@@ -1003,9 +2198,18 @@ static int via_init(struct hda_codec *codec)
         if (spec->slave_dig_outs[0])
                 codec->slave_dig_outs = spec->slave_dig_outs;
 
-        return 0;
+        return 0;
 }
 
+#ifdef SND_HDA_NEEDS_RESUME
+static int via_suspend(struct hda_codec *codec, pm_message_t state)
+{
+        struct via_spec *spec = codec->spec;
+        vt1708_stop_hp_work(spec);
+        return 0;
+}
+#endif
+
 #ifdef CONFIG_SND_HDA_POWER_SAVE
 static int via_check_power_status(struct hda_codec *codec, hda_nid_t nid)
 {
@@ -1021,6 +2225,9 @@ static struct hda_codec_ops via_patch_ops = {
         .build_pcms = via_build_pcms,
         .init = via_init,
         .free = via_free,
+#ifdef SND_HDA_NEEDS_RESUME
+        .suspend = via_suspend,
+#endif
 #ifdef CONFIG_SND_HDA_POWER_SAVE
         .check_power_status = via_check_power_status,
 #endif
@@ -1036,8 +2243,8 @@ static int vt1708_auto_fill_dac_nids(struct via_spec *spec,
         spec->multiout.num_dacs = cfg->line_outs;
 
         spec->multiout.dac_nids = spec->private_dac_nids;
-        
-        for(i = 0; i < 4; i++) {
+
+        for (i = 0; i < 4; i++) {
                 nid = cfg->line_out_pins[i];
                 if (nid) {
                         /* config dac list */
@@ -1067,7 +2274,7 @@ static int vt1708_auto_create_multi_out_ctls(struct via_spec *spec,
 {
         char name[32];
         static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" };
-        hda_nid_t nid, nid_vol = 0;
+        hda_nid_t nid, nid_vol, nid_vols[] = {0x17, 0x19, 0x1a, 0x1b};
         int i, err;
 
         for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
@@ -1075,9 +2282,8 @@ static int vt1708_auto_create_multi_out_ctls(struct via_spec *spec,
 
                 if (!nid)
                         continue;
-                
-                if (i != AUTO_SEQ_FRONT)
-                        nid_vol = 0x18 + i;
+
+                nid_vol = nid_vols[i];
 
                 if (i == AUTO_SEQ_CENLFE) {
                         /* Center/LFE */
@@ -1105,21 +2311,21 @@ static int vt1708_auto_create_multi_out_ctls(struct via_spec *spec,
                                                                   HDA_OUTPUT));
                         if (err < 0)
                                 return err;
-                } else if (i == AUTO_SEQ_FRONT){
+                } else if (i == AUTO_SEQ_FRONT) {
                         /* add control to mixer index 0 */
                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
                                               "Master Front Playback Volume",
-                                              HDA_COMPOSE_AMP_VAL(0x17, 3, 0,
+                                              HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
                                                                   HDA_INPUT));
                         if (err < 0)
                                 return err;
                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
                                               "Master Front Playback Switch",
-                                              HDA_COMPOSE_AMP_VAL(0x17, 3, 0,
+                                              HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
                                                                   HDA_INPUT));
                         if (err < 0)
                                 return err;
-                        
+
                         /* add control to PW3 */
                         sprintf(name, "%s Playback Volume", chname[i]);
                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
@@ -1178,6 +2384,7 @@ static int vt1708_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
                 return 0;
 
         spec->multiout.hp_nid = VT1708_HP_NID; /* AOW3 */
+        spec->hp_independent_mode_index = 1;
 
         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
                               "Headphone Playback Volume",
@@ -1218,7 +2425,7 @@ static int vt1708_auto_create_analog_input_ctls(struct via_spec *spec,
                 case 0x1d: /* Mic */
                         idx = 2;
                         break;
-                                
+
                 case 0x1e: /* Line In */
                         idx = 3;
                         break;
@@ -1231,8 +2438,7 @@ static int vt1708_auto_create_analog_input_ctls(struct via_spec *spec,
                         idx = 1;
                         break;
                 }
-                err = via_new_analog_input(spec, cfg->input_pins[i], labels[i],
-                                           idx, 0x17);
+                err = via_new_analog_input(spec, labels[i], idx, 0x17);
                 if (err < 0)
                         return err;
                 imux->items[imux->num_items].label = labels[i];
@@ -1260,16 +2466,60 @@ static void vt1708_set_pinconfig_connect(struct hda_codec *codec, hda_nid_t nid)
         def_conf = snd_hda_codec_get_pincfg(codec, nid);
         seqassoc = (unsigned char) get_defcfg_association(def_conf);
         seqassoc = (seqassoc << 4) | get_defcfg_sequence(def_conf);
-        if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE) {
-                if (seqassoc == 0xff) {
-                        def_conf = def_conf & (~(AC_JACK_PORT_BOTH << 30));
-                        snd_hda_codec_set_pincfg(codec, nid, def_conf);
-                }
+        if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE
+            && (seqassoc == 0xf0 || seqassoc == 0xff)) {
+                def_conf = def_conf & (~(AC_JACK_PORT_BOTH << 30));
+                snd_hda_codec_set_pincfg(codec, nid, def_conf);
         }
 
         return;
 }
 
+static int vt1708_jack_detectect_get(struct snd_kcontrol *kcontrol,
+                                     struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct via_spec *spec = codec->spec;
+
+        if (spec->codec_type != VT1708)
+                return 0;
+        spec->vt1708_jack_detectect =
+                !((snd_hda_codec_read(codec, 0x1, 0, 0xf84, 0) >> 8) & 0x1);
+        ucontrol->value.integer.value[0] = spec->vt1708_jack_detectect;
+        return 0;
+}
+
+static int vt1708_jack_detectect_put(struct snd_kcontrol *kcontrol,
+                                     struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct via_spec *spec = codec->spec;
+        int change;
+
+        if (spec->codec_type != VT1708)
+                return 0;
+        spec->vt1708_jack_detectect = ucontrol->value.integer.value[0];
+        change = (0x1 & (snd_hda_codec_read(codec, 0x1, 0, 0xf84, 0) >> 8))
+                == !spec->vt1708_jack_detectect;
+        if (spec->vt1708_jack_detectect) {
+                mute_aa_path(codec, 1);
+                notify_aa_path_ctls(codec);
+        }
+        return change;
+}
+
+static struct snd_kcontrol_new vt1708_jack_detectect[] = {
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Jack Detect",
+                .count = 1,
+                .info = snd_ctl_boolean_mono_info,
+                .get = vt1708_jack_detectect_get,
+                .put = vt1708_jack_detectect_put,
+        },
+        {} /* end */
+};
+
 static int vt1708_parse_auto_config(struct hda_codec *codec)
 {
         struct via_spec *spec = codec->spec;
@@ -1297,6 +2547,10 @@ static int vt1708_parse_auto_config(struct hda_codec *codec)
         err = vt1708_auto_create_analog_input_ctls(spec, &spec->autocfg);
         if (err < 0)
                 return err;
+        /* add jack detect on/off control */
+        err = snd_hda_add_new_ctls(codec, vt1708_jack_detectect);
+        if (err < 0)
+                return err;
 
         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
 
@@ -1314,21 +2568,46 @@ static int vt1708_parse_auto_config(struct hda_codec *codec)
         spec->input_mux = &spec->private_imux[0];
 
         if (spec->hp_mux)
-                spec->mixers[spec->num_mixers++] = via_hp_mixer;
+                via_hp_build(codec);
 
+        via_smart51_build(spec);
         return 1;
 }
 
 /* init callback for auto-configuration model -- overriding the default init */
 static int via_auto_init(struct hda_codec *codec)
 {
+        struct via_spec *spec = codec->spec;
+
         via_init(codec);
         via_auto_init_multi_out(codec);
         via_auto_init_hp_out(codec);
         via_auto_init_analog_input(codec);
+        if (spec->codec_type == VT2002P || spec->codec_type == VT1812) {
+                via_hp_bind_automute(codec);
+        } else {
+                via_hp_automute(codec);
+                via_speaker_automute(codec);
+        }
+
         return 0;
 }
 
+static void vt1708_update_hp_jack_state(struct work_struct *work)
+{
+        struct via_spec *spec = container_of(work, struct via_spec,
+                                             vt1708_hp_work.work);
+        if (spec->codec_type != VT1708)
+                return;
+        /* if jack state toggled */
+        if (spec->vt1708_hp_present
+            != snd_hda_jack_detect(spec->codec, spec->autocfg.hp_pins[0])) {
+                spec->vt1708_hp_present ^= 1;
+                via_hp_automute(spec->codec);
+        }
+        vt1708_start_hp_work(spec);
+}
+
 static int get_mux_nids(struct hda_codec *codec)
 {
         struct via_spec *spec = codec->spec;
@@ -1362,12 +2641,10 @@ static int patch_vt1708(struct hda_codec *codec)
         int err;
 
         /* create a codec specific record */
-        spec = kzalloc(sizeof(*spec), GFP_KERNEL);
+        spec = via_new_spec(codec);
         if (spec == NULL)
                 return -ENOMEM;
 
-        codec->spec = spec;
-
         /* automatic parse from the BIOS config */
         err = vt1708_parse_auto_config(codec);
         if (err < 0) {
@@ -1378,7 +2655,7 @@ static int patch_vt1708(struct hda_codec *codec)
                        "from BIOS.  Using genenic mode...\n");
         }
 
-        
+
         spec->stream_name_analog = "VT1708 Analog";
         spec->stream_analog_playback = &vt1708_pcm_analog_playback;
         /* disable 32bit format on VT1708 */
@@ -1390,7 +2667,7 @@ static int patch_vt1708(struct hda_codec *codec)
         spec->stream_digital_playback = &vt1708_pcm_digital_playback;
         spec->stream_digital_capture = &vt1708_pcm_digital_capture;
 
-        
+
         if (!spec->adc_nids && spec->input_mux) {
                 spec->adc_nids = vt1708_adc_nids;
                 spec->num_adc_nids = ARRAY_SIZE(vt1708_adc_nids);
@@ -1405,7 +2682,7 @@ static int patch_vt1708(struct hda_codec *codec)
 #ifdef CONFIG_SND_HDA_POWER_SAVE
         spec->loopback.amplist = vt1708_loopbacks;
 #endif
-
+        INIT_DELAYED_WORK(&spec->vt1708_hp_work, vt1708_update_hp_jack_state);
         return 0;
 }
 
@@ -1433,7 +2710,8 @@ static struct snd_kcontrol_new vt1709_capture_mixer[] = {
 };
 
 static struct hda_verb vt1709_uniwill_init_verbs[] = {
-        {0x20, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_HP_EVENT},
+        {0x20, AC_VERB_SET_UNSOLICITED_ENABLE,
+         AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT},
         { }
 };
 
@@ -1473,8 +2751,8 @@ static struct hda_verb vt1709_10ch_volume_init_verbs[] = {
         {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 
-        /* Set input of PW4 as AOW4 */
-        {0x20, AC_VERB_SET_CONNECT_SEL, 0x1},
+        /* Set input of PW4 as MW0 */
+        {0x20, AC_VERB_SET_CONNECT_SEL, 0},
         /* PW9 Output enable */
         {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
         { }
@@ -1487,8 +2765,8 @@ static struct hda_pcm_stream vt1709_10ch_pcm_analog_playback = {
         .nid = 0x10, /* NID to query formats and rates */
         .ops = {
                 .open = via_playback_pcm_open,
-                .prepare = via_playback_pcm_prepare,
-                .cleanup = via_playback_pcm_cleanup
+                .prepare = via_playback_multi_pcm_prepare,
+                .cleanup = via_playback_multi_pcm_cleanup,
         },
 };
 
@@ -1499,8 +2777,8 @@ static struct hda_pcm_stream vt1709_6ch_pcm_analog_playback = {
         .nid = 0x10, /* NID to query formats and rates */
         .ops = {
                 .open = via_playback_pcm_open,
-                .prepare = via_playback_pcm_prepare,
-                .cleanup = via_playback_pcm_cleanup
+                .prepare = via_playback_multi_pcm_prepare,
+                .cleanup = via_playback_multi_pcm_cleanup,
         },
 };
 
@@ -1575,11 +2853,11 @@ static int vt1709_auto_fill_dac_nids(struct via_spec *spec,
                 spec->multiout.dac_nids[cfg->line_outs] = 0x28; /* AOW4 */
 
         } else if (cfg->line_outs == 3) { /* 6 channels */
-                for(i = 0; i < cfg->line_outs; i++) {
+                for (i = 0; i < cfg->line_outs; i++) {
                         nid = cfg->line_out_pins[i];
                         if (nid) {
                                 /* config dac list */
-                                switch(i) {
+                                switch (i) {
                                 case AUTO_SEQ_FRONT:
                                         /* AOW0 */
                                         spec->multiout.dac_nids[i] = 0x10;
@@ -1608,56 +2886,58 @@ static int vt1709_auto_create_multi_out_ctls(struct via_spec *spec,
 {
         char name[32];
         static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" };
-        hda_nid_t nid = 0;
+        hda_nid_t nid, nid_vol, nid_vols[] = {0x18, 0x1a, 0x1b, 0x29};
         int i, err;
 
         for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
                 nid = cfg->line_out_pins[i];
 
-                if (!nid)       
+                if (!nid)
                         continue;
 
+                nid_vol = nid_vols[i];
+
                 if (i == AUTO_SEQ_CENLFE) {
                         /* Center/LFE */
                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
                                               "Center Playback Volume",
-                                              HDA_COMPOSE_AMP_VAL(0x1b, 1, 0,
+                                              HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
                                                                   HDA_OUTPUT));
                         if (err < 0)
                                 return err;
                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
                                               "LFE Playback Volume",
-                                              HDA_COMPOSE_AMP_VAL(0x1b, 2, 0,
+                                              HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
                                                                   HDA_OUTPUT));
                         if (err < 0)
                                 return err;
                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
                                               "Center Playback Switch",
-                                              HDA_COMPOSE_AMP_VAL(0x1b, 1, 0,
+                                              HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
                                                                   HDA_OUTPUT));
                         if (err < 0)
                                 return err;
                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
                                               "LFE Playback Switch",
-                                              HDA_COMPOSE_AMP_VAL(0x1b, 2, 0,
+                                              HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
                                                                   HDA_OUTPUT));
                         if (err < 0)
                                 return err;
-                } else if (i == AUTO_SEQ_FRONT){
-                        /* add control to mixer index 0 */
+                } else if (i == AUTO_SEQ_FRONT) {
+                        /* ADD control to mixer index 0 */
                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
                                               "Master Front Playback Volume",
-                                              HDA_COMPOSE_AMP_VAL(0x18, 3, 0,
+                                              HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
                                                                   HDA_INPUT));
                         if (err < 0)
                                 return err;
                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
                                               "Master Front Playback Switch",
-                                              HDA_COMPOSE_AMP_VAL(0x18, 3, 0,
+                                              HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
                                                                   HDA_INPUT));
                         if (err < 0)
                                 return err;
-                        
+
                         /* add control to PW3 */
                         sprintf(name, "%s Playback Volume", chname[i]);
                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
@@ -1674,26 +2954,26 @@ static int vt1709_auto_create_multi_out_ctls(struct via_spec *spec,
                 } else if (i == AUTO_SEQ_SURROUND) {
                         sprintf(name, "%s Playback Volume", chname[i]);
                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
-                                              HDA_COMPOSE_AMP_VAL(0x1a, 3, 0,
+                                              HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
                                                                   HDA_OUTPUT));
                         if (err < 0)
                                 return err;
                         sprintf(name, "%s Playback Switch", chname[i]);
                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
-                                              HDA_COMPOSE_AMP_VAL(0x1a, 3, 0,
+                                              HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
                                                                   HDA_OUTPUT));
                         if (err < 0)
                                 return err;
                 } else if (i == AUTO_SEQ_SIDE) {
                         sprintf(name, "%s Playback Volume", chname[i]);
                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
-                                              HDA_COMPOSE_AMP_VAL(0x29, 3, 0,
+                                              HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
                                                                   HDA_OUTPUT));
                         if (err < 0)
                                 return err;
                         sprintf(name, "%s Playback Switch", chname[i]);
                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
-                                              HDA_COMPOSE_AMP_VAL(0x29, 3, 0,
+                                              HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
                                                                   HDA_OUTPUT));
                         if (err < 0)
                                 return err;
@@ -1714,6 +2994,7 @@ static int vt1709_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
                 spec->multiout.hp_nid = VT1709_HP_DAC_NID;
         else if (spec->multiout.num_dacs == 3) /* 6 channels */
                 spec->multiout.hp_nid = 0;
+        spec->hp_independent_mode_index = 1;
 
         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
                               "Headphone Playback Volume",
@@ -1752,7 +3033,7 @@ static int vt1709_auto_create_analog_input_ctls(struct via_spec *spec,
                 case 0x1d: /* Mic */
                         idx = 2;
                         break;
-                                
+
                 case 0x1e: /* Line In */
                         idx = 3;
                         break;
@@ -1765,8 +3046,7 @@ static int vt1709_auto_create_analog_input_ctls(struct via_spec *spec,
                         idx = 1;
                         break;
                 }
-                err = via_new_analog_input(spec, cfg->input_pins[i], labels[i],
-                                           idx, 0x18);
+                err = via_new_analog_input(spec, labels[i], idx, 0x18);
                 if (err < 0)
                         return err;
                 imux->items[imux->num_items].label = labels[i];
@@ -1814,8 +3094,9 @@ static int vt1709_parse_auto_config(struct hda_codec *codec)
         spec->input_mux = &spec->private_imux[0];
 
         if (spec->hp_mux)
-                spec->mixers[spec->num_mixers++] = via_hp_mixer;
+                via_hp_build(codec);
 
+        via_smart51_build(spec);
         return 1;
 }
 
@@ -1835,12 +3116,10 @@ static int patch_vt1709_10ch(struct hda_codec *codec)
         int err;
 
         /* create a codec specific record */
-        spec = kzalloc(sizeof(*spec), GFP_KERNEL);
+        spec = via_new_spec(codec);
         if (spec == NULL)
                 return -ENOMEM;
 
-        codec->spec = spec;
-
         err = vt1709_parse_auto_config(codec);
         if (err < 0) {
                 via_free(codec);
@@ -1861,7 +3140,7 @@ static int patch_vt1709_10ch(struct hda_codec *codec)
         spec->stream_digital_playback = &vt1709_pcm_digital_playback;
         spec->stream_digital_capture = &vt1709_pcm_digital_capture;
 
-        
+
         if (!spec->adc_nids && spec->input_mux) {
                 spec->adc_nids = vt1709_adc_nids;
                 spec->num_adc_nids = ARRAY_SIZE(vt1709_adc_nids);
@@ -1929,12 +3208,10 @@ static int patch_vt1709_6ch(struct hda_codec *codec)
         int err;
 
         /* create a codec specific record */
-        spec = kzalloc(sizeof(*spec), GFP_KERNEL);
+        spec = via_new_spec(codec);
         if (spec == NULL)
                 return -ENOMEM;
 
-        codec->spec = spec;
-
         err = vt1709_parse_auto_config(codec);
         if (err < 0) {
                 via_free(codec);
@@ -1955,7 +3232,7 @@ static int patch_vt1709_6ch(struct hda_codec *codec)
         spec->stream_digital_playback = &vt1709_pcm_digital_playback;
         spec->stream_digital_capture = &vt1709_pcm_digital_capture;
 
-        
+
         if (!spec->adc_nids && spec->input_mux) {
                 spec->adc_nids = vt1709_adc_nids;
                 spec->num_adc_nids = ARRAY_SIZE(vt1709_adc_nids);
@@ -2024,7 +3301,7 @@ static struct hda_verb vt1708B_8ch_volume_init_verbs[] = {
         {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 
         /* Setup default input to PW4 */
-        {0x1d, AC_VERB_SET_CONNECT_SEL, 0x1},
+        {0x1d, AC_VERB_SET_CONNECT_SEL, 0},
         /* PW9 Output enable */
         {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
         /* PW10 Input enable */
@@ -2068,10 +3345,29 @@ static struct hda_verb vt1708B_4ch_volume_init_verbs[] = {
 };
 
 static struct hda_verb vt1708B_uniwill_init_verbs[] = {
-        {0x1D, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_HP_EVENT},
+        {0x1d, AC_VERB_SET_UNSOLICITED_ENABLE,
+         AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT},
+        {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
+        {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
+        {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
+        {0x1c, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
+        {0x1e, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
+        {0x22, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
+        {0x23, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
         { }
 };
 
+static int via_pcm_open_close(struct hda_pcm_stream *hinfo,
+                              struct hda_codec *codec,
+                              struct snd_pcm_substream *substream)
+{
+        int idle = substream->pstr->substream_opened == 1
+                && substream->ref_count == 0;
+
+        analog_low_current_mode(codec, idle);
+        return 0;
+}
+
 static struct hda_pcm_stream vt1708B_8ch_pcm_analog_playback = {
         .substreams = 2,
         .channels_min = 2,
@@ -2080,7 +3376,8 @@ static struct hda_pcm_stream vt1708B_8ch_pcm_analog_playback = {
         .ops = {
                 .open = via_playback_pcm_open,
                 .prepare = via_playback_multi_pcm_prepare,
-                .cleanup = via_playback_multi_pcm_cleanup
+                .cleanup = via_playback_multi_pcm_cleanup,
+                .close = via_pcm_open_close
         },
 };
 
@@ -2102,8 +3399,10 @@ static struct hda_pcm_stream vt1708B_pcm_analog_capture = {
         .channels_max = 2,
         .nid = 0x13, /* NID to query formats and rates */
         .ops = {
+                .open = via_pcm_open_close,
                 .prepare = via_capture_pcm_prepare,
-                .cleanup = via_capture_pcm_cleanup
+                .cleanup = via_capture_pcm_cleanup,
+                .close = via_pcm_open_close
         },
 };
 
@@ -2260,6 +3559,7 @@ static int vt1708B_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
                 return 0;
 
         spec->multiout.hp_nid = VT1708B_HP_NID; /* AOW3 */
+        spec->hp_independent_mode_index = 1;
 
         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
                               "Headphone Playback Volume",
@@ -2313,8 +3613,7 @@ static int vt1708B_auto_create_analog_input_ctls(struct via_spec *spec,
                         idx = 1;
                         break;
                 }
-                err = via_new_analog_input(spec, cfg->input_pins[i], labels[i],
-                                           idx, 0x16);
+                err = via_new_analog_input(spec, labels[i], idx, 0x16);
                 if (err < 0)
                         return err;
                 imux->items[imux->num_items].label = labels[i];
@@ -2362,8 +3661,9 @@ static int vt1708B_parse_auto_config(struct hda_codec *codec)
         spec->input_mux = &spec->private_imux[0];
 
         if (spec->hp_mux)
-                spec->mixers[spec->num_mixers++] = via_hp_mixer;
+                via_hp_build(codec);
 
+        via_smart51_build(spec);
         return 1;
 }
 
@@ -2376,19 +3676,19 @@ static struct hda_amp_list vt1708B_loopbacks[] = {
         { } /* end */
 };
 #endif
-
+static int patch_vt1708S(struct hda_codec *codec);
 static int patch_vt1708B_8ch(struct hda_codec *codec)
 {
         struct via_spec *spec;
         int err;
 
+        if (get_codec_type(codec) == VT1708BCE)
+                return patch_vt1708S(codec);
         /* create a codec specific record */
-        spec = kzalloc(sizeof(*spec), GFP_KERNEL);
+        spec = via_new_spec(codec);
         if (spec == NULL)
                 return -ENOMEM;
 
-        codec->spec = spec;
-
         /* automatic parse from the BIOS config */
         err = vt1708B_parse_auto_config(codec);
         if (err < 0) {
@@ -2435,12 +3735,10 @@ static int patch_vt1708B_4ch(struct hda_codec *codec)
         int err;
 
         /* create a codec specific record */
-        spec = kzalloc(sizeof(*spec), GFP_KERNEL);
+        spec = via_new_spec(codec);
         if (spec == NULL)
                 return -ENOMEM;
 
-        codec->spec = spec;
-
         /* automatic parse from the BIOS config */
         err = vt1708B_parse_auto_config(codec);
         if (err < 0) {
@@ -2483,29 +3781,15 @@ static int patch_vt1708B_4ch(struct hda_codec *codec)
 
 /* Patch for VT1708S */
 
-/* VT1708S software backdoor based override for buggy hardware micboost
- * setting */
-#define MIC_BOOST_VOLUME(xname, nid) {                          \
-        .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 = mic_boost_volume_info,                  \
-        .get = snd_hda_mixer_amp_volume_get,            \
-        .put = snd_hda_mixer_amp_volume_put,            \
-        .tlv = { .c = mic_boost_tlv },                  \
-        .private_value = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT) }
-
 /* capture mixer elements */
 static struct snd_kcontrol_new vt1708S_capture_mixer[] = {
         HDA_CODEC_VOLUME("Capture Volume", 0x13, 0x0, HDA_INPUT),
         HDA_CODEC_MUTE("Capture Switch", 0x13, 0x0, HDA_INPUT),
         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x14, 0x0, HDA_INPUT),
         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x14, 0x0, HDA_INPUT),
-        MIC_BOOST_VOLUME("Mic Boost Capture Volume", 0x1A),
-        MIC_BOOST_VOLUME("Front Mic Boost Capture Volume", 0x1E),
+        HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x1A, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Front Mic Boost Capture Volume", 0x1E, 0x0,
+                         HDA_INPUT),
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
                 /* The multiple "Capture Source" controls confuse alsamixer
@@ -2542,11 +3826,21 @@ static struct hda_verb vt1708S_volume_init_verbs[] = {
         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
         /* Enable Mic Boost Volume backdoor */
         {0x1, 0xf98, 0x1},
+        /* don't bybass mixer */
+        {0x1, 0xf88, 0xc0},
         { }
 };
 
 static struct hda_verb vt1708S_uniwill_init_verbs[] = {
-        {0x1D, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_HP_EVENT},
+        {0x1d, AC_VERB_SET_UNSOLICITED_ENABLE,
+         AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT},
+        {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
+        {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
+        {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
+        {0x1c, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
+        {0x1e, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
+        {0x22, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
+        {0x23, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
         { }
 };
 
@@ -2557,8 +3851,9 @@ static struct hda_pcm_stream vt1708S_pcm_analog_playback = {
         .nid = 0x10, /* NID to query formats and rates */
         .ops = {
                 .open = via_playback_pcm_open,
-                .prepare = via_playback_pcm_prepare,
-                .cleanup = via_playback_pcm_cleanup
+                .prepare = via_playback_multi_pcm_prepare,
+                .cleanup = via_playback_multi_pcm_cleanup,
+                .close = via_pcm_open_close
         },
 };
 
@@ -2568,8 +3863,10 @@ static struct hda_pcm_stream vt1708S_pcm_analog_capture = {
         .channels_max = 2,
         .nid = 0x13, /* NID to query formats and rates */
         .ops = {
+                .open = via_pcm_open_close,
                 .prepare = via_capture_pcm_prepare,
-                .cleanup = via_capture_pcm_cleanup
+                .cleanup = via_capture_pcm_cleanup,
+                .close = via_pcm_open_close
         },
 };
 
@@ -2726,6 +4023,7 @@ static int vt1708S_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
                 return 0;
 
         spec->multiout.hp_nid = VT1708S_HP_NID; /* AOW3 */
+        spec->hp_independent_mode_index = 1;
 
         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
                               "Headphone Playback Volume",
@@ -2780,8 +4078,7 @@ static int vt1708S_auto_create_analog_input_ctls(struct via_spec *spec,
                         idx = 1;
                         break;
                 }
-                err = via_new_analog_input(spec, cfg->input_pins[i], labels[i],
-                                           idx, 0x16);
+                err = via_new_analog_input(spec, labels[i], idx, 0x16);
                 if (err < 0)
                         return err;
                 imux->items[imux->num_items].label = labels[i];
@@ -2850,8 +4147,9 @@ static int vt1708S_parse_auto_config(struct hda_codec *codec)
         spec->input_mux = &spec->private_imux[0];
 
         if (spec->hp_mux)
-                spec->mixers[spec->num_mixers++] = via_hp_mixer;
+                via_hp_build(codec);
 
+        via_smart51_build(spec);
         return 1;
 }
 
@@ -2865,18 +4163,26 @@ static struct hda_amp_list vt1708S_loopbacks[] = {
 };
 #endif
 
+static void override_mic_boost(struct hda_codec *codec, hda_nid_t pin,
+                               int offset, int num_steps, int step_size)
+{
+        snd_hda_override_amp_caps(codec, pin, HDA_INPUT,
+                                  (offset << AC_AMPCAP_OFFSET_SHIFT) |
+                                  (num_steps << AC_AMPCAP_NUM_STEPS_SHIFT) |
+                                  (step_size << AC_AMPCAP_STEP_SIZE_SHIFT) |
+                                  (0 << AC_AMPCAP_MUTE_SHIFT));
+}
+
 static int patch_vt1708S(struct hda_codec *codec)
 {
         struct via_spec *spec;
         int err;
 
         /* create a codec specific record */
-        spec = kzalloc(sizeof(*spec), GFP_KERNEL);
+        spec = via_new_spec(codec);
         if (spec == NULL)
                 return -ENOMEM;
 
-        codec->spec = spec;
-
         /* automatic parse from the BIOS config */
         err = vt1708S_parse_auto_config(codec);
         if (err < 0) {
@@ -2890,17 +4196,25 @@ static int patch_vt1708S(struct hda_codec *codec)
         spec->init_verbs[spec->num_iverbs++] = vt1708S_volume_init_verbs;
         spec->init_verbs[spec->num_iverbs++] = vt1708S_uniwill_init_verbs;
 
-        spec->stream_name_analog = "VT1708S Analog";
+        if (codec->vendor_id == 0x11060440)
+                spec->stream_name_analog = "VT1818S Analog";
+        else
+                spec->stream_name_analog = "VT1708S Analog";
         spec->stream_analog_playback = &vt1708S_pcm_analog_playback;
         spec->stream_analog_capture = &vt1708S_pcm_analog_capture;
 
-        spec->stream_name_digital = "VT1708S Digital";
+        if (codec->vendor_id == 0x11060440)
+                spec->stream_name_digital = "VT1818S Digital";
+        else
+                spec->stream_name_digital = "VT1708S Digital";
         spec->stream_digital_playback = &vt1708S_pcm_digital_playback;
 
         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);
+                override_mic_boost(codec, 0x1a, 0, 3, 40);
+                override_mic_boost(codec, 0x1e, 0, 3, 40);
                 spec->mixers[spec->num_mixers] = vt1708S_capture_mixer;
                 spec->num_mixers++;
         }
@@ -2913,6 +4227,16 @@ static int patch_vt1708S(struct hda_codec *codec)
         spec->loopback.amplist = vt1708S_loopbacks;
 #endif
 
+        /* correct names for VT1708BCE */
+        if (get_codec_type(codec) == VT1708BCE) {
+                kfree(codec->chip_name);
+                codec->chip_name = kstrdup("VT1708BCE", GFP_KERNEL);
+                snprintf(codec->bus->card->mixername,
+                         sizeof(codec->bus->card->mixername),
+                         "%s %s", codec->vendor_name, codec->chip_name);
+                spec->stream_name_analog = "VT1708BCE Analog";
+                spec->stream_name_digital = "VT1708BCE Digital";
+        }
         return 0;
 }
 
@@ -2967,12 +4291,20 @@ static struct hda_verb vt1702_volume_init_verbs[] = {
         /* PW6 PW7 Output enable */
         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
         {0x1C, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
+        /* mixer enable */
+        {0x1, 0xF88, 0x3},
+        /* GPIO 0~2 */
+        {0x1, 0xF82, 0x3F},
         { }
 };
 
 static struct hda_verb vt1702_uniwill_init_verbs[] = {
-        {0x01, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_GPIO_EVENT},
-        {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_HP_EVENT},
+        {0x17, AC_VERB_SET_UNSOLICITED_ENABLE,
+         AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT},
+        {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
+        {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
+        {0x16, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
+        {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
         { }
 };
 
@@ -2984,7 +4316,8 @@ static struct hda_pcm_stream vt1702_pcm_analog_playback = {
         .ops = {
                 .open = via_playback_pcm_open,
                 .prepare = via_playback_multi_pcm_prepare,
-                .cleanup = via_playback_multi_pcm_cleanup
+                .cleanup = via_playback_multi_pcm_cleanup,
+                .close = via_pcm_open_close
         },
 };
 
@@ -2994,8 +4327,10 @@ static struct hda_pcm_stream vt1702_pcm_analog_capture = {
         .channels_max = 2,
         .nid = 0x12, /* NID to query formats and rates */
         .ops = {
+                .open = via_pcm_open_close,
                 .prepare = via_capture_pcm_prepare,
-                .cleanup = via_capture_pcm_cleanup
+                .cleanup = via_capture_pcm_cleanup,
+                .close = via_pcm_open_close
         },
 };
 
@@ -3065,12 +4400,13 @@ static int vt1702_auto_create_line_out_ctls(struct via_spec *spec,
 
 static int vt1702_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
 {
-        int err;
-
+        int err, i;
+        struct hda_input_mux *imux;
+        static const char *texts[] = { "ON", "OFF", NULL};
         if (!pin)
                 return 0;
-
         spec->multiout.hp_nid = 0x1D;
+        spec->hp_independent_mode_index = 0;
 
         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
                               "Headphone Playback Volume",
@@ -3084,8 +4420,18 @@ static int vt1702_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
         if (err < 0)
                 return err;
 
-        create_hp_imux(spec);
+        imux = &spec->private_imux[1];
+
+        /* for hp mode select */
+        i = 0;
+        while (texts[i] != NULL)        {
+                imux->items[imux->num_items].label =  texts[i];
+                imux->items[imux->num_items].index = i;
+                imux->num_items++;
+                i++;
+        }
 
+        spec->hp_mux = &spec->private_imux[1];
         return 0;
 }
 
@@ -3121,8 +4467,7 @@ static int vt1702_auto_create_analog_input_ctls(struct via_spec *spec,
                         idx = 3;
                         break;
                 }
-                err = via_new_analog_input(spec, cfg->input_pins[i],
-                                           labels[i], idx, 0x1A);
+                err = via_new_analog_input(spec, labels[i], idx, 0x1A);
                 if (err < 0)
                         return err;
                 imux->items[imux->num_items].label = labels[i];
@@ -3152,6 +4497,12 @@ static int vt1702_parse_auto_config(struct hda_codec *codec)
         err = vt1702_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
         if (err < 0)
                 return err;
+        /* limit AA path volume to 0 dB */
+        snd_hda_override_amp_caps(codec, 0x1A, HDA_INPUT,
+                                  (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
+                                  (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
+                                  (0x5 << AC_AMPCAP_STEP_SIZE_SHIFT) |
+                                  (1 << AC_AMPCAP_MUTE_SHIFT));
         err = vt1702_auto_create_analog_input_ctls(spec, &spec->autocfg);
         if (err < 0)
                 return err;
@@ -3166,7 +4517,7 @@ static int vt1702_parse_auto_config(struct hda_codec *codec)
         spec->input_mux = &spec->private_imux[0];
 
         if (spec->hp_mux)
-                spec->mixers[spec->num_mixers++] = via_hp_mixer;
+                via_hp_build(codec);
 
         return 1;
 }
@@ -3185,16 +4536,12 @@ static int patch_vt1702(struct hda_codec *codec)
 {
         struct via_spec *spec;
         int err;
-        unsigned int response;
-        unsigned char control;
 
         /* create a codec specific record */
-        spec = kzalloc(sizeof(*spec), GFP_KERNEL);
+        spec = via_new_spec(codec);
         if (spec == NULL)
                 return -ENOMEM;
 
-        codec->spec = spec;
-
         /* automatic parse from the BIOS config */
         err = vt1702_parse_auto_config(codec);
         if (err < 0) {
@@ -3231,17 +4578,1631 @@ static int patch_vt1702(struct hda_codec *codec)
         spec->loopback.amplist = vt1702_loopbacks;
 #endif
 
-        /* Open backdoor */
-        response = snd_hda_codec_read(codec, codec->afg, 0, 0xF8C, 0);
-        control = (unsigned char)(response & 0xff);
-        control |= 0x3;
-        snd_hda_codec_write(codec,  codec->afg, 0, 0xF88, control);
+        return 0;
+}
+
+/* Patch for VT1718S */
+
+/* capture mixer elements */
+static struct snd_kcontrol_new vt1718S_capture_mixer[] = {
+        HDA_CODEC_VOLUME("Capture Volume", 0x10, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x10, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x11, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x11, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x2b, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Front Mic Boost Capture Volume", 0x29, 0x0,
+                         HDA_INPUT),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                /* The multiple "Capture Source" controls confuse alsamixer
+                 * So call somewhat different..
+                 */
+                .name = "Input Source",
+                .count = 2,
+                .info = via_mux_enum_info,
+                .get = via_mux_enum_get,
+                .put = via_mux_enum_put,
+        },
+        { } /* end */
+};
+
+static struct hda_verb vt1718S_volume_init_verbs[] = {
+        /*
+         * Unmute ADC0-1 and set the default input to mic-in
+         */
+        {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x11, 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
+         */
+        /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
+        {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
+        {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
+        {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
+
+        /* Setup default input of Front HP to MW9 */
+        {0x28, AC_VERB_SET_CONNECT_SEL, 0x1},
+        /* PW9 PW10 Output enable */
+        {0x2d, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_OUT_EN},
+        {0x2e, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_OUT_EN},
+        /* PW11 Input enable */
+        {0x2f, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_IN_EN},
+        /* Enable Boost Volume backdoor */
+        {0x1, 0xf88, 0x8},
+        /* MW0/1/2/3/4: un-mute index 0 (AOWx), mute index 1 (MW9) */
+        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x1c, 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_MUTE(1)},
+        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        /* set MUX1 = 2 (AOW4), MUX2 = 1 (AOW3) */
+        {0x34, AC_VERB_SET_CONNECT_SEL, 0x2},
+        {0x35, AC_VERB_SET_CONNECT_SEL, 0x1},
+        /* Unmute MW4's index 0 */
+        {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        { }
+};
+
+
+static struct hda_verb vt1718S_uniwill_init_verbs[] = {
+        {0x28, AC_VERB_SET_UNSOLICITED_ENABLE,
+         AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT},
+        {0x24, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
+        {0x25, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
+        {0x26, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
+        {0x27, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
+        {0x29, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
+        {0x2a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
+        {0x2b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
+        { }
+};
+
+static struct hda_pcm_stream vt1718S_pcm_analog_playback = {
+        .substreams = 2,
+        .channels_min = 2,
+        .channels_max = 10,
+        .nid = 0x8, /* NID to query formats and rates */
+        .ops = {
+                .open = via_playback_pcm_open,
+                .prepare = via_playback_multi_pcm_prepare,
+                .cleanup = via_playback_multi_pcm_cleanup,
+                .close = via_pcm_open_close,
+        },
+};
+
+static struct hda_pcm_stream vt1718S_pcm_analog_capture = {
+        .substreams = 2,
+        .channels_min = 2,
+        .channels_max = 2,
+        .nid = 0x10, /* NID to query formats and rates */
+        .ops = {
+                .open = via_pcm_open_close,
+                .prepare = via_capture_pcm_prepare,
+                .cleanup = via_capture_pcm_cleanup,
+                .close = via_pcm_open_close,
+        },
+};
+
+static struct hda_pcm_stream vt1718S_pcm_digital_playback = {
+        .substreams = 2,
+        .channels_min = 2,
+        .channels_max = 2,
+        /* NID is set in via_build_pcms */
+        .ops = {
+                .open = via_dig_playback_pcm_open,
+                .close = via_dig_playback_pcm_close,
+                .prepare = via_dig_playback_pcm_prepare,
+                .cleanup = via_dig_playback_pcm_cleanup
+        },
+};
+
+static struct hda_pcm_stream vt1718S_pcm_digital_capture = {
+        .substreams = 1,
+        .channels_min = 2,
+        .channels_max = 2,
+};
+
+/* fill in the dac_nids table from the parsed pin configuration */
+static int vt1718S_auto_fill_dac_nids(struct via_spec *spec,
+                                     const struct auto_pin_cfg *cfg)
+{
+        int i;
+        hda_nid_t nid;
+
+        spec->multiout.num_dacs = cfg->line_outs;
+
+        spec->multiout.dac_nids = spec->private_dac_nids;
+
+        for (i = 0; i < 4; i++) {
+                nid = cfg->line_out_pins[i];
+                if (nid) {
+                        /* config dac list */
+                        switch (i) {
+                        case AUTO_SEQ_FRONT:
+                                spec->multiout.dac_nids[i] = 0x8;
+                                break;
+                        case AUTO_SEQ_CENLFE:
+                                spec->multiout.dac_nids[i] = 0xa;
+                                break;
+                        case AUTO_SEQ_SURROUND:
+                                spec->multiout.dac_nids[i] = 0x9;
+                                break;
+                        case AUTO_SEQ_SIDE:
+                                spec->multiout.dac_nids[i] = 0xb;
+                                break;
+                        }
+                }
+        }
+
+        return 0;
+}
+
+/* add playback controls from the parsed DAC table */
+static int vt1718S_auto_create_multi_out_ctls(struct via_spec *spec,
+                                             const struct auto_pin_cfg *cfg)
+{
+        char name[32];
+        static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" };
+        hda_nid_t nid_vols[] = {0x8, 0x9, 0xa, 0xb};
+        hda_nid_t nid_mutes[] = {0x24, 0x25, 0x26, 0x27};
+        hda_nid_t nid, nid_vol, nid_mute = 0;
+        int i, err;
+
+        for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
+                nid = cfg->line_out_pins[i];
+
+                if (!nid)
+                        continue;
+                nid_vol = nid_vols[i];
+                nid_mute = nid_mutes[i];
+
+                if (i == AUTO_SEQ_CENLFE) {
+                        /* Center/LFE */
+                        err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
+                                              "Center Playback Volume",
+                                              HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
+                                                                  HDA_OUTPUT));
+                        if (err < 0)
+                                return err;
+                        err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
+                                              "LFE Playback Volume",
+                                              HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
+                                                                  HDA_OUTPUT));
+                        if (err < 0)
+                                return err;
+                        err = via_add_control(
+                                spec, VIA_CTL_WIDGET_MUTE,
+                                "Center Playback Switch",
+                                HDA_COMPOSE_AMP_VAL(nid_mute, 1, 0,
+                                                    HDA_OUTPUT));
+                        if (err < 0)
+                                return err;
+                        err = via_add_control(
+                                spec, VIA_CTL_WIDGET_MUTE,
+                                "LFE Playback Switch",
+                                HDA_COMPOSE_AMP_VAL(nid_mute, 2, 0,
+                                                    HDA_OUTPUT));
+                        if (err < 0)
+                                return err;
+                } else if (i == AUTO_SEQ_FRONT) {
+                        /* Front */
+                        sprintf(name, "%s Playback Volume", chname[i]);
+                        err = via_add_control(
+                                spec, VIA_CTL_WIDGET_VOL, name,
+                                HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT));
+                        if (err < 0)
+                                return err;
+                        sprintf(name, "%s Playback Switch", chname[i]);
+                        err = via_add_control(
+                                spec, VIA_CTL_WIDGET_MUTE, name,
+                                HDA_COMPOSE_AMP_VAL(nid_mute, 3, 0,
+                                                    HDA_OUTPUT));
+                        if (err < 0)
+                                return err;
+                } else {
+                        sprintf(name, "%s Playback Volume", chname[i]);
+                        err = via_add_control(
+                                spec, VIA_CTL_WIDGET_VOL, name,
+                                HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT));
+                        if (err < 0)
+                                return err;
+                        sprintf(name, "%s Playback Switch", chname[i]);
+                        err = via_add_control(
+                                spec, VIA_CTL_WIDGET_MUTE, name,
+                                HDA_COMPOSE_AMP_VAL(nid_mute, 3, 0,
+                                                    HDA_OUTPUT));
+                        if (err < 0)
+                                return err;
+                }
+        }
+        return 0;
+}
+
+static int vt1718S_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
+{
+        int err;
+
+        if (!pin)
+                return 0;
+
+        spec->multiout.hp_nid = 0xc; /* AOW4 */
+        spec->hp_independent_mode_index = 1;
+
+        err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
+                              "Headphone Playback Volume",
+                              HDA_COMPOSE_AMP_VAL(0xc, 3, 0, HDA_OUTPUT));
+        if (err < 0)
+                return err;
+
+        err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
+                              "Headphone Playback Switch",
+                              HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
+        if (err < 0)
+                return err;
+
+        create_hp_imux(spec);
+        return 0;
+}
+
+/* create playback/capture controls for input pins */
+static int vt1718S_auto_create_analog_input_ctls(struct via_spec *spec,
+                                                const struct auto_pin_cfg *cfg)
+{
+        static char *labels[] = {
+                "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
+        };
+        struct hda_input_mux *imux = &spec->private_imux[0];
+        int i, err, idx = 0;
+
+        /* for internal loopback recording select */
+        imux->items[imux->num_items].label = "Stereo Mixer";
+        imux->items[imux->num_items].index = 5;
+        imux->num_items++;
+
+        for (i = 0; i < AUTO_PIN_LAST; i++) {
+                if (!cfg->input_pins[i])
+                        continue;
+
+                switch (cfg->input_pins[i]) {
+                case 0x2b: /* Mic */
+                        idx = 1;
+                        break;
+
+                case 0x2a: /* Line In */
+                        idx = 2;
+                        break;
+
+                case 0x29: /* Front Mic */
+                        idx = 3;
+                        break;
+
+                case 0x2c: /* CD */
+                        idx = 0;
+                        break;
+                }
+                err = via_new_analog_input(spec, labels[i], idx, 0x21);
+                if (err < 0)
+                        return err;
+                imux->items[imux->num_items].label = labels[i];
+                imux->items[imux->num_items].index = idx;
+                imux->num_items++;
+        }
+        return 0;
+}
+
+static int vt1718S_parse_auto_config(struct hda_codec *codec)
+{
+        struct via_spec *spec = codec->spec;
+        int err;
+
+        err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
+
+        if (err < 0)
+                return err;
+        err = vt1718S_auto_fill_dac_nids(spec, &spec->autocfg);
+        if (err < 0)
+                return err;
+        if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
+                return 0; /* can't find valid BIOS pin config */
+
+        err = vt1718S_auto_create_multi_out_ctls(spec, &spec->autocfg);
+        if (err < 0)
+                return err;
+        err = vt1718S_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
+        if (err < 0)
+                return err;
+        err = vt1718S_auto_create_analog_input_ctls(spec, &spec->autocfg);
+        if (err < 0)
+                return err;
+
+        spec->multiout.max_channels = spec->multiout.num_dacs * 2;
+
+        fill_dig_outs(codec);
+
+        if (spec->autocfg.dig_in_pin && codec->vendor_id == 0x11060428)
+                spec->dig_in_nid = 0x13;
+
+        if (spec->kctls.list)
+                spec->mixers[spec->num_mixers++] = spec->kctls.list;
+
+        spec->input_mux = &spec->private_imux[0];
+
+        if (spec->hp_mux)
+                via_hp_build(codec);
+
+        via_smart51_build(spec);
+
+        return 1;
+}
+
+#ifdef CONFIG_SND_HDA_POWER_SAVE
+static struct hda_amp_list vt1718S_loopbacks[] = {
+        { 0x21, HDA_INPUT, 1 },
+        { 0x21, HDA_INPUT, 2 },
+        { 0x21, HDA_INPUT, 3 },
+        { 0x21, HDA_INPUT, 4 },
+        { } /* end */
+};
+#endif
+
+static int patch_vt1718S(struct hda_codec *codec)
+{
+        struct via_spec *spec;
+        int err;
+
+        /* create a codec specific record */
+        spec = via_new_spec(codec);
+        if (spec == NULL)
+                return -ENOMEM;
+
+        /* automatic parse from the BIOS config */
+        err = vt1718S_parse_auto_config(codec);
+        if (err < 0) {
+                via_free(codec);
+                return err;
+        } else if (!err) {
+                printk(KERN_INFO "hda_codec: Cannot set up configuration "
+                       "from BIOS.  Using genenic mode...\n");
+        }
+
+        spec->init_verbs[spec->num_iverbs++] = vt1718S_volume_init_verbs;
+        spec->init_verbs[spec->num_iverbs++] = vt1718S_uniwill_init_verbs;
+
+        if (codec->vendor_id == 0x11060441)
+                spec->stream_name_analog = "VT2020 Analog";
+        else if (codec->vendor_id == 0x11064441)
+                spec->stream_name_analog = "VT1828S Analog";
+        else
+                spec->stream_name_analog = "VT1718S Analog";
+        spec->stream_analog_playback = &vt1718S_pcm_analog_playback;
+        spec->stream_analog_capture = &vt1718S_pcm_analog_capture;
+
+        if (codec->vendor_id == 0x11060441)
+                spec->stream_name_digital = "VT2020 Digital";
+        else if (codec->vendor_id == 0x11064441)
+                spec->stream_name_digital = "VT1828S Digital";
+        else
+                spec->stream_name_digital = "VT1718S Digital";
+        spec->stream_digital_playback = &vt1718S_pcm_digital_playback;
+        if (codec->vendor_id == 0x11060428 || codec->vendor_id == 0x11060441)
+                spec->stream_digital_capture = &vt1718S_pcm_digital_capture;
+
+        if (!spec->adc_nids && spec->input_mux) {
+                spec->adc_nids = vt1718S_adc_nids;
+                spec->num_adc_nids = ARRAY_SIZE(vt1718S_adc_nids);
+                get_mux_nids(codec);
+                override_mic_boost(codec, 0x2b, 0, 3, 40);
+                override_mic_boost(codec, 0x29, 0, 3, 40);
+                spec->mixers[spec->num_mixers] = vt1718S_capture_mixer;
+                spec->num_mixers++;
+        }
+
+        codec->patch_ops = via_patch_ops;
+
+        codec->patch_ops.init = via_auto_init;
+        codec->patch_ops.unsol_event = via_unsol_event;
+
+#ifdef CONFIG_SND_HDA_POWER_SAVE
+        spec->loopback.amplist = vt1718S_loopbacks;
+#endif
+
+        return 0;
+}
+
+/* Patch for VT1716S */
+
+static int vt1716s_dmic_info(struct snd_kcontrol *kcontrol,
+                            struct snd_ctl_elem_info *uinfo)
+{
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
+        uinfo->count = 1;
+        uinfo->value.integer.min = 0;
+        uinfo->value.integer.max = 1;
+        return 0;
+}
+
+static int vt1716s_dmic_get(struct snd_kcontrol *kcontrol,
+                           struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        int index = 0;
+
+        index = snd_hda_codec_read(codec, 0x26, 0,
+                                               AC_VERB_GET_CONNECT_SEL, 0);
+        if (index != -1)
+                *ucontrol->value.integer.value = index;
+
+        return 0;
+}
+
+static int vt1716s_dmic_put(struct snd_kcontrol *kcontrol,
+                           struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct via_spec *spec = codec->spec;
+        int index = *ucontrol->value.integer.value;
+
+        snd_hda_codec_write(codec, 0x26, 0,
+                                               AC_VERB_SET_CONNECT_SEL, index);
+        spec->dmic_enabled = index;
+        set_jack_power_state(codec);
+
+        return 1;
+}
+
+/* capture mixer elements */
+static struct snd_kcontrol_new vt1716S_capture_mixer[] = {
+        HDA_CODEC_VOLUME("Capture Volume", 0x13, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x13, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x14, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x14, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x1A, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Front Mic Boost Capture Volume", 0x1E, 0x0,
+                         HDA_INPUT),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Input Source",
+                .count = 1,
+                .info = via_mux_enum_info,
+                .get = via_mux_enum_get,
+                .put = via_mux_enum_put,
+        },
+        { } /* end */
+};
+
+static struct snd_kcontrol_new vt1716s_dmic_mixer[] = {
+        HDA_CODEC_VOLUME("Digital Mic Capture Volume", 0x22, 0x0, HDA_INPUT),
+        {
+         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+         .name = "Digital Mic Capture Switch",
+         .subdevice = HDA_SUBDEV_NID_FLAG | 0x26,
+         .count = 1,
+         .info = vt1716s_dmic_info,
+         .get = vt1716s_dmic_get,
+         .put = vt1716s_dmic_put,
+         },
+        {}                      /* end */
+};
+
+
+/* mono-out mixer elements */
+static struct snd_kcontrol_new vt1716S_mono_out_mixer[] = {
+        HDA_CODEC_MUTE("Mono Playback Switch", 0x2a, 0x0, HDA_OUTPUT),
+        { } /* end */
+};
+
+static struct hda_verb vt1716S_volume_init_verbs[] = {
+        /*
+         * Unmute ADC0-1 and set the default input to mic-in
+         */
+        {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x14, 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
+         */
+        /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
+        {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)},
+        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
+
+        /* MUX Indices: Stereo Mixer = 5 */
+        {0x17, AC_VERB_SET_CONNECT_SEL, 0x5},
+
+        /* Setup default input of PW4 to MW0 */
+        {0x1d, AC_VERB_SET_CONNECT_SEL, 0x0},
+
+        /* Setup default input of SW1 as MW0 */
+        {0x18, AC_VERB_SET_CONNECT_SEL, 0x1},
+
+        /* Setup default input of SW4 as AOW0 */
+        {0x28, AC_VERB_SET_CONNECT_SEL, 0x1},
+
+        /* PW9 PW10 Output enable */
+        {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
+        {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
+
+        /* Unmute SW1, PW12 */
+        {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        /* PW12 Output enable */
+        {0x2a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
+        /* Enable Boost Volume backdoor */
+        {0x1, 0xf8a, 0x80},
+        /* don't bybass mixer */
+        {0x1, 0xf88, 0xc0},
+        /* Enable mono output */
+        {0x1, 0xf90, 0x08},
+        { }
+};
+
+
+static struct hda_verb vt1716S_uniwill_init_verbs[] = {
+        {0x1d, AC_VERB_SET_UNSOLICITED_ENABLE,
+         AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT},
+        {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
+        {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
+        {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
+        {0x1c, AC_VERB_SET_UNSOLICITED_ENABLE,
+         AC_USRSP_EN | VIA_MONO_EVENT | VIA_JACK_EVENT},
+        {0x1e, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
+        {0x23, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
+        { }
+};
+
+static struct hda_pcm_stream vt1716S_pcm_analog_playback = {
+        .substreams = 2,
+        .channels_min = 2,
+        .channels_max = 6,
+        .nid = 0x10, /* NID to query formats and rates */
+        .ops = {
+                .open = via_playback_pcm_open,
+                .prepare = via_playback_multi_pcm_prepare,
+                .cleanup = via_playback_multi_pcm_cleanup,
+                .close = via_pcm_open_close,
+        },
+};
+
+static struct hda_pcm_stream vt1716S_pcm_analog_capture = {
+        .substreams = 2,
+        .channels_min = 2,
+        .channels_max = 2,
+        .nid = 0x13, /* NID to query formats and rates */
+        .ops = {
+                .open = via_pcm_open_close,
+                .prepare = via_capture_pcm_prepare,
+                .cleanup = via_capture_pcm_cleanup,
+                .close = via_pcm_open_close,
+        },
+};
+
+static struct hda_pcm_stream vt1716S_pcm_digital_playback = {
+        .substreams = 2,
+        .channels_min = 2,
+        .channels_max = 2,
+        /* NID is set in via_build_pcms */
+        .ops = {
+                .open = via_dig_playback_pcm_open,
+                .close = via_dig_playback_pcm_close,
+                .prepare = via_dig_playback_pcm_prepare,
+                .cleanup = via_dig_playback_pcm_cleanup
+        },
+};
+
+/* fill in the dac_nids table from the parsed pin configuration */
+static int vt1716S_auto_fill_dac_nids(struct via_spec *spec,
+                                      const struct auto_pin_cfg *cfg)
+{       int i;
+        hda_nid_t nid;
+
+        spec->multiout.num_dacs = cfg->line_outs;
+
+        spec->multiout.dac_nids = spec->private_dac_nids;
+
+        for (i = 0; i < 3; i++) {
+                nid = cfg->line_out_pins[i];
+                if (nid) {
+                        /* config dac list */
+                        switch (i) {
+                        case AUTO_SEQ_FRONT:
+                                spec->multiout.dac_nids[i] = 0x10;
+                                break;
+                        case AUTO_SEQ_CENLFE:
+                                spec->multiout.dac_nids[i] = 0x25;
+                                break;
+                        case AUTO_SEQ_SURROUND:
+                                spec->multiout.dac_nids[i] = 0x11;
+                                break;
+                        }
+                }
+        }
+
+        return 0;
+}
+
+/* add playback controls from the parsed DAC table */
+static int vt1716S_auto_create_multi_out_ctls(struct via_spec *spec,
+                                              const struct auto_pin_cfg *cfg)
+{
+        char name[32];
+        static const char *chname[3] = { "Front", "Surround", "C/LFE" };
+        hda_nid_t nid_vols[] = {0x10, 0x11, 0x25};
+        hda_nid_t nid_mutes[] = {0x1C, 0x18, 0x27};
+        hda_nid_t nid, nid_vol, nid_mute;
+        int i, err;
+
+        for (i = 0; i <= AUTO_SEQ_CENLFE; i++) {
+                nid = cfg->line_out_pins[i];
+
+                if (!nid)
+                        continue;
+
+                nid_vol = nid_vols[i];
+                nid_mute = nid_mutes[i];
+
+                if (i == AUTO_SEQ_CENLFE) {
+                        err = via_add_control(
+                                spec, VIA_CTL_WIDGET_VOL,
+                                "Center Playback Volume",
+                                HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0, HDA_OUTPUT));
+                        if (err < 0)
+                                return err;
+                        err = via_add_control(
+                                spec, VIA_CTL_WIDGET_VOL,
+                                "LFE Playback Volume",
+                                HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT));
+                        if (err < 0)
+                                return err;
+                        err = via_add_control(
+                                spec, VIA_CTL_WIDGET_MUTE,
+                                "Center Playback Switch",
+                                HDA_COMPOSE_AMP_VAL(nid_mute, 1, 0,
+                                                    HDA_OUTPUT));
+                        if (err < 0)
+                                return err;
+                        err = via_add_control(
+                                spec, VIA_CTL_WIDGET_MUTE,
+                                "LFE Playback Switch",
+                                HDA_COMPOSE_AMP_VAL(nid_mute, 2, 0,
+                                                    HDA_OUTPUT));
+                        if (err < 0)
+                                return err;
+                } else if (i == AUTO_SEQ_FRONT) {
+
+                        err = via_add_control(
+                                spec, VIA_CTL_WIDGET_VOL,
+                                "Master Front Playback Volume",
+                                HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_INPUT));
+                        if (err < 0)
+                                return err;
+                        err = via_add_control(
+                                spec, VIA_CTL_WIDGET_MUTE,
+                                "Master Front Playback Switch",
+                                HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_INPUT));
+                        if (err < 0)
+                                return err;
+
+                        sprintf(name, "%s Playback Volume", chname[i]);
+                        err = via_add_control(
+                                spec, VIA_CTL_WIDGET_VOL, name,
+                                HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT));
+                        if (err < 0)
+                                return err;
+                        sprintf(name, "%s Playback Switch", chname[i]);
+                        err = via_add_control(
+                                spec, VIA_CTL_WIDGET_MUTE, name,
+                                HDA_COMPOSE_AMP_VAL(nid_mute, 3, 0,
+                                                    HDA_OUTPUT));
+                        if (err < 0)
+                                return err;
+                } else {
+                        sprintf(name, "%s Playback Volume", chname[i]);
+                        err = via_add_control(
+                                spec, VIA_CTL_WIDGET_VOL, name,
+                                HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT));
+                        if (err < 0)
+                                return err;
+                        sprintf(name, "%s Playback Switch", chname[i]);
+                        err = via_add_control(
+                                spec, VIA_CTL_WIDGET_MUTE, name,
+                                HDA_COMPOSE_AMP_VAL(nid_mute, 3, 0,
+                                                    HDA_OUTPUT));
+                        if (err < 0)
+                                return err;
+                }
+        }
+        return 0;
+}
+
+static int vt1716S_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
+{
+        int err;
+
+        if (!pin)
+                return 0;
+
+        spec->multiout.hp_nid = 0x25; /* AOW3 */
+        spec->hp_independent_mode_index = 1;
+
+        err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
+                              "Headphone Playback Volume",
+                              HDA_COMPOSE_AMP_VAL(0x25, 3, 0, HDA_OUTPUT));
+        if (err < 0)
+                return err;
+
+        err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
+                              "Headphone Playback Switch",
+                              HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
+        if (err < 0)
+                return err;
+
+        create_hp_imux(spec);
+        return 0;
+}
+
+/* create playback/capture controls for input pins */
+static int vt1716S_auto_create_analog_input_ctls(struct via_spec *spec,
+                                                const struct auto_pin_cfg *cfg)
+{
+        static char *labels[] = {
+                "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
+        };
+        struct hda_input_mux *imux = &spec->private_imux[0];
+        int i, err, idx = 0;
+
+        /* for internal loopback recording select */
+        imux->items[imux->num_items].label = "Stereo Mixer";
+        imux->items[imux->num_items].index = 5;
+        imux->num_items++;
+
+        for (i = 0; i < AUTO_PIN_LAST; i++) {
+                if (!cfg->input_pins[i])
+                        continue;
+
+                switch (cfg->input_pins[i]) {
+                case 0x1a: /* Mic */
+                        idx = 2;
+                        break;
+
+                case 0x1b: /* Line In */
+                        idx = 3;
+                        break;
+
+                case 0x1e: /* Front Mic */
+                        idx = 4;
+                        break;
+
+                case 0x1f: /* CD */
+                        idx = 1;
+                        break;
+                }
+                err = via_new_analog_input(spec, labels[i], idx, 0x16);
+                if (err < 0)
+                        return err;
+                imux->items[imux->num_items].label = labels[i];
+                imux->items[imux->num_items].index = idx-1;
+                imux->num_items++;
+        }
+        return 0;
+}
+
+static int vt1716S_parse_auto_config(struct hda_codec *codec)
+{
+        struct via_spec *spec = codec->spec;
+        int err;
+
+        err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
+        if (err < 0)
+                return err;
+        err = vt1716S_auto_fill_dac_nids(spec, &spec->autocfg);
+        if (err < 0)
+                return err;
+        if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
+                return 0; /* can't find valid BIOS pin config */
+
+        err = vt1716S_auto_create_multi_out_ctls(spec, &spec->autocfg);
+        if (err < 0)
+                return err;
+        err = vt1716S_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
+        if (err < 0)
+                return err;
+        err = vt1716S_auto_create_analog_input_ctls(spec, &spec->autocfg);
+        if (err < 0)
+                return err;
+
+        spec->multiout.max_channels = spec->multiout.num_dacs * 2;
+
+        fill_dig_outs(codec);
+
+        if (spec->kctls.list)
+                spec->mixers[spec->num_mixers++] = spec->kctls.list;
+
+        spec->input_mux = &spec->private_imux[0];
+
+        if (spec->hp_mux)
+                via_hp_build(codec);
+
+        via_smart51_build(spec);
+
+        return 1;
+}
+
+#ifdef CONFIG_SND_HDA_POWER_SAVE
+static struct hda_amp_list vt1716S_loopbacks[] = {
+        { 0x16, HDA_INPUT, 1 },
+        { 0x16, HDA_INPUT, 2 },
+        { 0x16, HDA_INPUT, 3 },
+        { 0x16, HDA_INPUT, 4 },
+        { } /* end */
+};
+#endif
+
+static int patch_vt1716S(struct hda_codec *codec)
+{
+        struct via_spec *spec;
+        int err;
+
+        /* create a codec specific record */
+        spec = via_new_spec(codec);
+        if (spec == NULL)
+                return -ENOMEM;
+
+        /* automatic parse from the BIOS config */
+        err = vt1716S_parse_auto_config(codec);
+        if (err < 0) {
+                via_free(codec);
+                return err;
+        } else if (!err) {
+                printk(KERN_INFO "hda_codec: Cannot set up configuration "
+                       "from BIOS.  Using genenic mode...\n");
+        }
+
+        spec->init_verbs[spec->num_iverbs++]  = vt1716S_volume_init_verbs;
+        spec->init_verbs[spec->num_iverbs++] = vt1716S_uniwill_init_verbs;
+
+        spec->stream_name_analog = "VT1716S Analog";
+        spec->stream_analog_playback = &vt1716S_pcm_analog_playback;
+        spec->stream_analog_capture = &vt1716S_pcm_analog_capture;
+
+        spec->stream_name_digital = "VT1716S Digital";
+        spec->stream_digital_playback = &vt1716S_pcm_digital_playback;
+
+        if (!spec->adc_nids && spec->input_mux) {
+                spec->adc_nids = vt1716S_adc_nids;
+                spec->num_adc_nids = ARRAY_SIZE(vt1716S_adc_nids);
+                get_mux_nids(codec);
+                override_mic_boost(codec, 0x1a, 0, 3, 40);
+                override_mic_boost(codec, 0x1e, 0, 3, 40);
+                spec->mixers[spec->num_mixers] = vt1716S_capture_mixer;
+                spec->num_mixers++;
+        }
+
+        spec->mixers[spec->num_mixers] = vt1716s_dmic_mixer;
+        spec->num_mixers++;
+
+        spec->mixers[spec->num_mixers++] = vt1716S_mono_out_mixer;
+
+        codec->patch_ops = via_patch_ops;
+
+        codec->patch_ops.init = via_auto_init;
+        codec->patch_ops.unsol_event = via_unsol_event;
+
+#ifdef CONFIG_SND_HDA_POWER_SAVE
+        spec->loopback.amplist = vt1716S_loopbacks;
+#endif
+
+        return 0;
+}
+
+/* for vt2002P */
+
+/* capture mixer elements */
+static struct snd_kcontrol_new vt2002P_capture_mixer[] = {
+        HDA_CODEC_VOLUME("Capture Volume", 0x10, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x10, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x11, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x11, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x2b, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Front Mic Boost Capture Volume", 0x29, 0x0,
+                         HDA_INPUT),
+        {
+                .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 = via_mux_enum_info,
+                .get = via_mux_enum_get,
+                .put = via_mux_enum_put,
+        },
+        { } /* end */
+};
+
+static struct hda_verb vt2002P_volume_init_verbs[] = {
+        /*
+         * Unmute ADC0-1 and set the default input to mic-in
+         */
+        {0x8, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x9, 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
+         */
+        /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
+        {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
+        {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
+        {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
+
+        /* MUX Indices: Mic = 0 */
+        {0x1e, AC_VERB_SET_CONNECT_SEL, 0},
+        {0x1f, AC_VERB_SET_CONNECT_SEL, 0},
+
+        /* PW9 Output enable */
+        {0x2d, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_OUT_EN},
+
+        /* Enable Boost Volume backdoor */
+        {0x1, 0xfb9, 0x24},
+
+        /* MW0/1/4/8: un-mute index 0 (MUXx), un-mute index 1 (MW9) */
+        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x17, 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(1)},
+        {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+
+        /* set MUX0/1/4/8 = 0 (AOW0) */
+        {0x34, AC_VERB_SET_CONNECT_SEL, 0},
+        {0x35, AC_VERB_SET_CONNECT_SEL, 0},
+        {0x37, AC_VERB_SET_CONNECT_SEL, 0},
+        {0x3b, AC_VERB_SET_CONNECT_SEL, 0},
+
+        /* set PW0 index=0 (MW0) */
+        {0x24, AC_VERB_SET_CONNECT_SEL, 0},
+
+        /* Enable AOW0 to MW9 */
+        {0x1, 0xfb8, 0x88},
+        { }
+};
+
+
+static struct hda_verb vt2002P_uniwill_init_verbs[] = {
+        {0x25, AC_VERB_SET_UNSOLICITED_ENABLE,
+         AC_USRSP_EN | VIA_JACK_EVENT | VIA_BIND_HP_EVENT},
+        {0x26, AC_VERB_SET_UNSOLICITED_ENABLE,
+         AC_USRSP_EN | VIA_JACK_EVENT | VIA_BIND_HP_EVENT},
+        {0x29, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
+        {0x2a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
+        {0x2b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
+        { }
+};
+
+static struct hda_pcm_stream vt2002P_pcm_analog_playback = {
+        .substreams = 2,
+        .channels_min = 2,
+        .channels_max = 2,
+        .nid = 0x8, /* NID to query formats and rates */
+        .ops = {
+                .open = via_playback_pcm_open,
+                .prepare = via_playback_multi_pcm_prepare,
+                .cleanup = via_playback_multi_pcm_cleanup,
+                .close = via_pcm_open_close,
+        },
+};
+
+static struct hda_pcm_stream vt2002P_pcm_analog_capture = {
+        .substreams = 2,
+        .channels_min = 2,
+        .channels_max = 2,
+        .nid = 0x10, /* NID to query formats and rates */
+        .ops = {
+                .open = via_pcm_open_close,
+                .prepare = via_capture_pcm_prepare,
+                .cleanup = via_capture_pcm_cleanup,
+                .close = via_pcm_open_close,
+        },
+};
+
+static struct hda_pcm_stream vt2002P_pcm_digital_playback = {
+        .substreams = 1,
+        .channels_min = 2,
+        .channels_max = 2,
+        /* NID is set in via_build_pcms */
+        .ops = {
+                .open = via_dig_playback_pcm_open,
+                .close = via_dig_playback_pcm_close,
+                .prepare = via_dig_playback_pcm_prepare,
+                .cleanup = via_dig_playback_pcm_cleanup
+        },
+};
+
+/* fill in the dac_nids table from the parsed pin configuration */
+static int vt2002P_auto_fill_dac_nids(struct via_spec *spec,
+                                      const struct auto_pin_cfg *cfg)
+{
+        spec->multiout.num_dacs = 1;
+        spec->multiout.dac_nids = spec->private_dac_nids;
+        if (cfg->line_out_pins[0])
+                spec->multiout.dac_nids[0] = 0x8;
+        return 0;
+}
+
+/* add playback controls from the parsed DAC table */
+static int vt2002P_auto_create_multi_out_ctls(struct via_spec *spec,
+                                             const struct auto_pin_cfg *cfg)
+{
+        int err;
+
+        if (!cfg->line_out_pins[0])
+                return -1;
+
+
+        /* Line-Out: PortE */
+        err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
+                              "Master Front Playback Volume",
+                              HDA_COMPOSE_AMP_VAL(0x8, 3, 0, HDA_OUTPUT));
+        if (err < 0)
+                return err;
+        err = via_add_control(spec, VIA_CTL_WIDGET_BIND_PIN_MUTE,
+                              "Master Front Playback Switch",
+                              HDA_COMPOSE_AMP_VAL(0x26, 3, 0, HDA_OUTPUT));
+        if (err < 0)
+                return err;
+
+        return 0;
+}
+
+static int vt2002P_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
+{
+        int err;
+
+        if (!pin)
+                return 0;
+
+        spec->multiout.hp_nid = 0x9;
+        spec->hp_independent_mode_index = 1;
+
+        err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
+                              "Headphone Playback Volume",
+                              HDA_COMPOSE_AMP_VAL(
+                                      spec->multiout.hp_nid, 3, 0, HDA_OUTPUT));
+        if (err < 0)
+                return err;
+
+        err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
+                              "Headphone Playback Switch",
+                              HDA_COMPOSE_AMP_VAL(0x25, 3, 0, HDA_OUTPUT));
+        if (err < 0)
+                return err;
+
+        create_hp_imux(spec);
+        return 0;
+}
+
+/* create playback/capture controls for input pins */
+static int vt2002P_auto_create_analog_input_ctls(struct via_spec *spec,
+                                                const struct auto_pin_cfg *cfg)
+{
+        static char *labels[] = {
+                "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
+        };
+        struct hda_input_mux *imux = &spec->private_imux[0];
+        int i, err, idx = 0;
+
+        for (i = 0; i < AUTO_PIN_LAST; i++) {
+                if (!cfg->input_pins[i])
+                        continue;
+
+                switch (cfg->input_pins[i]) {
+                case 0x2b: /* Mic */
+                        idx = 0;
+                        break;
+
+                case 0x2a: /* Line In */
+                        idx = 1;
+                        break;
+
+                case 0x29: /* Front Mic */
+                        idx = 2;
+                        break;
+                }
+                err = via_new_analog_input(spec, labels[i], idx, 0x21);
+                if (err < 0)
+                        return err;
+                imux->items[imux->num_items].label = labels[i];
+                imux->items[imux->num_items].index = idx;
+                imux->num_items++;
+        }
+
+        /* build volume/mute control of loopback */
+        err = via_new_analog_input(spec, "Stereo Mixer", 3, 0x21);
+        if (err < 0)
+                return err;
+
+        /* for internal loopback recording select */
+        imux->items[imux->num_items].label = "Stereo Mixer";
+        imux->items[imux->num_items].index = 3;
+        imux->num_items++;
+
+        /* for digital mic select */
+        imux->items[imux->num_items].label = "Digital Mic";
+        imux->items[imux->num_items].index = 4;
+        imux->num_items++;
+
+        return 0;
+}
+
+static int vt2002P_parse_auto_config(struct hda_codec *codec)
+{
+        struct via_spec *spec = codec->spec;
+        int err;
+
+
+        err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
+        if (err < 0)
+                return err;
+
+        err = vt2002P_auto_fill_dac_nids(spec, &spec->autocfg);
+        if (err < 0)
+                return err;
+
+        if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
+                return 0; /* can't find valid BIOS pin config */
+
+        err = vt2002P_auto_create_multi_out_ctls(spec, &spec->autocfg);
+        if (err < 0)
+                return err;
+        err = vt2002P_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
+        if (err < 0)
+                return err;
+        err = vt2002P_auto_create_analog_input_ctls(spec, &spec->autocfg);
+        if (err < 0)
+                return err;
+
+        spec->multiout.max_channels = spec->multiout.num_dacs * 2;
+
+        fill_dig_outs(codec);
+
+        if (spec->kctls.list)
+                spec->mixers[spec->num_mixers++] = spec->kctls.list;
+
+        spec->input_mux = &spec->private_imux[0];
+
+        if (spec->hp_mux)
+                via_hp_build(codec);
+
+        return 1;
+}
+
+#ifdef CONFIG_SND_HDA_POWER_SAVE
+static struct hda_amp_list vt2002P_loopbacks[] = {
+        { 0x21, HDA_INPUT, 0 },
+        { 0x21, HDA_INPUT, 1 },
+        { 0x21, HDA_INPUT, 2 },
+        { } /* end */
+};
+#endif
+
+
+/* patch for vt2002P */
+static int patch_vt2002P(struct hda_codec *codec)
+{
+        struct via_spec *spec;
+        int err;
+
+        /* create a codec specific record */
+        spec = via_new_spec(codec);
+        if (spec == NULL)
+                return -ENOMEM;
+
+        /* automatic parse from the BIOS config */
+        err = vt2002P_parse_auto_config(codec);
+        if (err < 0) {
+                via_free(codec);
+                return err;
+        } else if (!err) {
+                printk(KERN_INFO "hda_codec: Cannot set up configuration "
+                       "from BIOS.  Using genenic mode...\n");
+        }
+
+        spec->init_verbs[spec->num_iverbs++]  = vt2002P_volume_init_verbs;
+        spec->init_verbs[spec->num_iverbs++] = vt2002P_uniwill_init_verbs;
+
+        spec->stream_name_analog = "VT2002P Analog";
+        spec->stream_analog_playback = &vt2002P_pcm_analog_playback;
+        spec->stream_analog_capture = &vt2002P_pcm_analog_capture;
+
+        spec->stream_name_digital = "VT2002P Digital";
+        spec->stream_digital_playback = &vt2002P_pcm_digital_playback;
+
+        if (!spec->adc_nids && spec->input_mux) {
+                spec->adc_nids = vt2002P_adc_nids;
+                spec->num_adc_nids = ARRAY_SIZE(vt2002P_adc_nids);
+                get_mux_nids(codec);
+                override_mic_boost(codec, 0x2b, 0, 3, 40);
+                override_mic_boost(codec, 0x29, 0, 3, 40);
+                spec->mixers[spec->num_mixers] = vt2002P_capture_mixer;
+                spec->num_mixers++;
+        }
+
+        codec->patch_ops = via_patch_ops;
+
+        codec->patch_ops.init = via_auto_init;
+        codec->patch_ops.unsol_event = via_unsol_event;
+
+#ifdef CONFIG_SND_HDA_POWER_SAVE
+        spec->loopback.amplist = vt2002P_loopbacks;
+#endif
+
+        return 0;
+}
+
+/* for vt1812 */
+
+/* capture mixer elements */
+static struct snd_kcontrol_new vt1812_capture_mixer[] = {
+        HDA_CODEC_VOLUME("Capture Volume", 0x10, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x10, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x11, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x11, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic Boost Capture Volume", 0x2b, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Front Mic Boost Capture Volume", 0x29, 0x0,
+                       HDA_INPUT),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                /* The multiple "Capture Source" controls confuse alsamixer
+                 * So call somewhat different..
+                 */
+                .name = "Input Source",
+                .count = 2,
+                .info = via_mux_enum_info,
+                .get = via_mux_enum_get,
+                .put = via_mux_enum_put,
+        },
+        { } /* end */
+};
+
+static struct hda_verb vt1812_volume_init_verbs[] = {
+        /*
+         * Unmute ADC0-1 and set the default input to mic-in
+         */
+        {0x8, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x9, 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
+         */
+        /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
+        {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
+        {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
+        {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
+        {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
+
+        /* MUX Indices: Mic = 0 */
+        {0x1e, AC_VERB_SET_CONNECT_SEL, 0},
+        {0x1f, AC_VERB_SET_CONNECT_SEL, 0},
+
+        /* PW9 Output enable */
+        {0x2d, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_OUT_EN},
+
+        /* Enable Boost Volume backdoor */
+        {0x1, 0xfb9, 0x24},
+
+        /* MW0/1/4/13/15: un-mute index 0 (MUXx), un-mute index 1 (MW9) */
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+
+        /* set MUX0/1/4/13/15 = 0 (AOW0) */
+        {0x34, AC_VERB_SET_CONNECT_SEL, 0},
+        {0x35, AC_VERB_SET_CONNECT_SEL, 0},
+        {0x38, AC_VERB_SET_CONNECT_SEL, 0},
+        {0x3c, AC_VERB_SET_CONNECT_SEL, 0},
+        {0x3d, AC_VERB_SET_CONNECT_SEL, 0},
+
+        /* Enable AOW0 to MW9 */
+        {0x1, 0xfb8, 0xa8},
+        { }
+};
+
+
+static struct hda_verb vt1812_uniwill_init_verbs[] = {
+        {0x33, AC_VERB_SET_UNSOLICITED_ENABLE,
+         AC_USRSP_EN | VIA_JACK_EVENT | VIA_BIND_HP_EVENT},
+        {0x25, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT },
+        {0x28, AC_VERB_SET_UNSOLICITED_ENABLE,
+         AC_USRSP_EN | VIA_JACK_EVENT | VIA_BIND_HP_EVENT},
+        {0x29, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
+        {0x2a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
+        {0x2b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
+        { }
+};
+
+static struct hda_pcm_stream vt1812_pcm_analog_playback = {
+        .substreams = 2,
+        .channels_min = 2,
+        .channels_max = 2,
+        .nid = 0x8, /* NID to query formats and rates */
+        .ops = {
+                .open = via_playback_pcm_open,
+                .prepare = via_playback_multi_pcm_prepare,
+                .cleanup = via_playback_multi_pcm_cleanup,
+                .close = via_pcm_open_close,
+        },
+};
+
+static struct hda_pcm_stream vt1812_pcm_analog_capture = {
+        .substreams = 2,
+        .channels_min = 2,
+        .channels_max = 2,
+        .nid = 0x10, /* NID to query formats and rates */
+        .ops = {
+                .open = via_pcm_open_close,
+                .prepare = via_capture_pcm_prepare,
+                .cleanup = via_capture_pcm_cleanup,
+                .close = via_pcm_open_close,
+        },
+};
+
+static struct hda_pcm_stream vt1812_pcm_digital_playback = {
+        .substreams = 1,
+        .channels_min = 2,
+        .channels_max = 2,
+        /* NID is set in via_build_pcms */
+        .ops = {
+                .open = via_dig_playback_pcm_open,
+                .close = via_dig_playback_pcm_close,
+                .prepare = via_dig_playback_pcm_prepare,
+                .cleanup = via_dig_playback_pcm_cleanup
+        },
+};
+/* fill in the dac_nids table from the parsed pin configuration */
+static int vt1812_auto_fill_dac_nids(struct via_spec *spec,
+                                     const struct auto_pin_cfg *cfg)
+{
+        spec->multiout.num_dacs = 1;
+        spec->multiout.dac_nids = spec->private_dac_nids;
+        if (cfg->line_out_pins[0])
+                spec->multiout.dac_nids[0] = 0x8;
+        return 0;
+}
+
+
+/* add playback controls from the parsed DAC table */
+static int vt1812_auto_create_multi_out_ctls(struct via_spec *spec,
+                                             const struct auto_pin_cfg *cfg)
+{
+        int err;
+
+        if (!cfg->line_out_pins[0])
+                return -1;
+
+        /* Line-Out: PortE */
+        err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
+                              "Front Playback Volume",
+                              HDA_COMPOSE_AMP_VAL(0x8, 3, 0, HDA_OUTPUT));
+        if (err < 0)
+                return err;
+        err = via_add_control(spec, VIA_CTL_WIDGET_BIND_PIN_MUTE,
+                              "Front Playback Switch",
+                              HDA_COMPOSE_AMP_VAL(0x28, 3, 0, HDA_OUTPUT));
+        if (err < 0)
+                return err;
+
+        return 0;
+}
+
+static int vt1812_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
+{
+        int err;
+
+        if (!pin)
+                return 0;
+
+        spec->multiout.hp_nid = 0x9;
+        spec->hp_independent_mode_index = 1;
+
+
+        err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
+                              "Headphone Playback Volume",
+                              HDA_COMPOSE_AMP_VAL(
+                                      spec->multiout.hp_nid, 3, 0, HDA_OUTPUT));
+        if (err < 0)
+                return err;
+
+        err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
+                              "Headphone Playback Switch",
+                              HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
+        if (err < 0)
+                return err;
+
+        create_hp_imux(spec);
+        return 0;
+}
+
+/* create playback/capture controls for input pins */
+static int vt1812_auto_create_analog_input_ctls(struct via_spec *spec,
+                                                const struct auto_pin_cfg *cfg)
+{
+        static char *labels[] = {
+                "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
+        };
+        struct hda_input_mux *imux = &spec->private_imux[0];
+        int i, err, idx = 0;
+
+        for (i = 0; i < AUTO_PIN_LAST; i++) {
+                if (!cfg->input_pins[i])
+                        continue;
+
+                switch (cfg->input_pins[i]) {
+                case 0x2b: /* Mic */
+                        idx = 0;
+                        break;
+
+                case 0x2a: /* Line In */
+                        idx = 1;
+                        break;
+
+                case 0x29: /* Front Mic */
+                        idx = 2;
+                        break;
+                }
+                err = via_new_analog_input(spec, labels[i], idx, 0x21);
+                if (err < 0)
+                        return err;
+                imux->items[imux->num_items].label = labels[i];
+                imux->items[imux->num_items].index = idx;
+                imux->num_items++;
+        }
+        /* build volume/mute control of loopback */
+        err = via_new_analog_input(spec, "Stereo Mixer", 5, 0x21);
+        if (err < 0)
+                return err;
+
+        /* for internal loopback recording select */
+        imux->items[imux->num_items].label = "Stereo Mixer";
+        imux->items[imux->num_items].index = 5;
+        imux->num_items++;
+
+        /* for digital mic select */
+        imux->items[imux->num_items].label = "Digital Mic";
+        imux->items[imux->num_items].index = 6;
+        imux->num_items++;
+
+        return 0;
+}
+
+static int vt1812_parse_auto_config(struct hda_codec *codec)
+{
+        struct via_spec *spec = codec->spec;
+        int err;
+
+
+        err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
+        if (err < 0)
+                return err;
+        fill_dig_outs(codec);
+        err = vt1812_auto_fill_dac_nids(spec, &spec->autocfg);
+        if (err < 0)
+                return err;
+
+        if (!spec->autocfg.line_outs && !spec->autocfg.hp_outs)
+                return 0; /* can't find valid BIOS pin config */
+
+        err = vt1812_auto_create_multi_out_ctls(spec, &spec->autocfg);
+        if (err < 0)
+                return err;
+        err = vt1812_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
+        if (err < 0)
+                return err;
+        err = vt1812_auto_create_analog_input_ctls(spec, &spec->autocfg);
+        if (err < 0)
+                return err;
+
+        spec->multiout.max_channels = spec->multiout.num_dacs * 2;
+
+        fill_dig_outs(codec);
+
+        if (spec->kctls.list)
+                spec->mixers[spec->num_mixers++] = spec->kctls.list;
+
+        spec->input_mux = &spec->private_imux[0];
+
+        if (spec->hp_mux)
+                via_hp_build(codec);
+
+        return 1;
+}
+
+#ifdef CONFIG_SND_HDA_POWER_SAVE
+static struct hda_amp_list vt1812_loopbacks[] = {
+        { 0x21, HDA_INPUT, 0 },
+        { 0x21, HDA_INPUT, 1 },
+        { 0x21, HDA_INPUT, 2 },
+        { } /* end */
+};
+#endif
+
+
+/* patch for vt1812 */
+static int patch_vt1812(struct hda_codec *codec)
+{
+        struct via_spec *spec;
+        int err;
+
+        /* create a codec specific record */
+        spec = via_new_spec(codec);
+        if (spec == NULL)
+                return -ENOMEM;
+
+        /* automatic parse from the BIOS config */
+        err = vt1812_parse_auto_config(codec);
+        if (err < 0) {
+                via_free(codec);
+                return err;
+        } else if (!err) {
+                printk(KERN_INFO "hda_codec: Cannot set up configuration "
+                       "from BIOS.  Using genenic mode...\n");
+        }
+
+
+        spec->init_verbs[spec->num_iverbs++]  = vt1812_volume_init_verbs;
+        spec->init_verbs[spec->num_iverbs++] = vt1812_uniwill_init_verbs;
+
+        spec->stream_name_analog = "VT1812 Analog";
+        spec->stream_analog_playback = &vt1812_pcm_analog_playback;
+        spec->stream_analog_capture = &vt1812_pcm_analog_capture;
 
-        /* Enable GPIO 0&1 for volume&mute control */
-        /* Enable GPIO 2 for DMIC-DATA */
-        response = snd_hda_codec_read(codec, codec->afg, 0, 0xF84, 0);
-        control = (unsigned char)((response >> 16) & 0x3f);
-        snd_hda_codec_write(codec,  codec->afg, 0, 0xF82, control);
+        spec->stream_name_digital = "VT1812 Digital";
+        spec->stream_digital_playback = &vt1812_pcm_digital_playback;
+
+
+        if (!spec->adc_nids && spec->input_mux) {
+                spec->adc_nids = vt1812_adc_nids;
+                spec->num_adc_nids = ARRAY_SIZE(vt1812_adc_nids);
+                get_mux_nids(codec);
+                override_mic_boost(codec, 0x2b, 0, 3, 40);
+                override_mic_boost(codec, 0x29, 0, 3, 40);
+                spec->mixers[spec->num_mixers] = vt1812_capture_mixer;
+                spec->num_mixers++;
+        }
+
+        codec->patch_ops = via_patch_ops;
+
+        codec->patch_ops.init = via_auto_init;
+        codec->patch_ops.unsol_event = via_unsol_event;
+
+#ifdef CONFIG_SND_HDA_POWER_SAVE
+        spec->loopback.amplist = vt1812_loopbacks;
+#endif
 
         return 0;
 }
@@ -3318,6 +6279,23 @@ static struct hda_codec_preset snd_hda_preset_via[] = {
           .patch = patch_vt1702},
         { .id = 0x11067398, .name = "VT1702",
           .patch = patch_vt1702},
+        { .id = 0x11060428, .name = "VT1718S",
+          .patch = patch_vt1718S},
+        { .id = 0x11064428, .name = "VT1718S",
+          .patch = patch_vt1718S},
+        { .id = 0x11060441, .name = "VT2020",
+          .patch = patch_vt1718S},
+        { .id = 0x11064441, .name = "VT1828S",
+          .patch = patch_vt1718S},
+        { .id = 0x11060433, .name = "VT1716S",
+          .patch = patch_vt1716S},
+        { .id = 0x1106a721, .name = "VT1716S",
+          .patch = patch_vt1716S},
+        { .id = 0x11060438, .name = "VT2002P", .patch = patch_vt2002P},
+        { .id = 0x11064438, .name = "VT2002P", .patch = patch_vt2002P},
+        { .id = 0x11060448, .name = "VT1812", .patch = patch_vt1812},
+        { .id = 0x11060440, .name = "VT1818S",
+          .patch = patch_vt1708S},
         {} /* terminator */
 };
 
diff --git a/sound/pci/ice1712/Makefile b/sound/pci/ice1712/Makefile
index 536eae2ccf94..f7ce33f00ea5 100644
--- a/sound/pci/ice1712/Makefile
+++ b/sound/pci/ice1712/Makefile
@@ -5,7 +5,7 @@
 
 snd-ice17xx-ak4xxx-objs := ak4xxx.o
 snd-ice1712-objs := ice1712.o delta.o hoontech.o ews.o
-snd-ice1724-objs := ice1724.o amp.o revo.o aureon.o vt1720_mobo.o pontis.o prodigy192.o prodigy_hifi.o juli.o phase.o wtm.o se.o maya44.o
+snd-ice1724-objs := ice1724.o amp.o revo.o aureon.o vt1720_mobo.o pontis.o prodigy192.o prodigy_hifi.o juli.o phase.o wtm.o se.o maya44.o quartet.o
 
 # Toplevel Module Dependency
 obj-$(CONFIG_SND_ICE1712) += snd-ice1712.o snd-ice17xx-ak4xxx.o
diff --git a/sound/pci/ice1712/ak4xxx.c b/sound/pci/ice1712/ak4xxx.c
index 03391da8c8c7..90d560c3df13 100644
--- a/sound/pci/ice1712/ak4xxx.c
+++ b/sound/pci/ice1712/ak4xxx.c
@@ -24,6 +24,7 @@
 #include <asm/io.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
+#include <linux/slab.h>
 #include <linux/init.h>
 #include <sound/core.h>
 #include <sound/initval.h>
diff --git a/sound/pci/ice1712/amp.c b/sound/pci/ice1712/amp.c
index 6da21a2bcade..e328cfb7620c 100644
--- a/sound/pci/ice1712/amp.c
+++ b/sound/pci/ice1712/amp.c
@@ -25,7 +25,6 @@
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
-#include <linux/slab.h>
 #include <sound/core.h>
 
 #include "ice1712.h"
diff --git a/sound/pci/ice1712/aureon.c b/sound/pci/ice1712/aureon.c
index 110d16e52733..9e66f6d306f8 100644
--- a/sound/pci/ice1712/aureon.c
+++ b/sound/pci/ice1712/aureon.c
@@ -689,42 +689,27 @@ static int aureon_ac97_mmute_put(struct snd_kcontrol *kcontrol, struct snd_ctl_e
         return change;
 }
 
-static const DECLARE_TLV_DB_SCALE(db_scale_wm_dac, -12700, 100, 1);
+static const DECLARE_TLV_DB_SCALE(db_scale_wm_dac, -10000, 100, 1);
 static const DECLARE_TLV_DB_SCALE(db_scale_wm_pcm, -6400, 50, 1);
 static const DECLARE_TLV_DB_SCALE(db_scale_wm_adc, -1200, 100, 0);
 static const DECLARE_TLV_DB_SCALE(db_scale_ac97_master, -4650, 150, 0);
 static const DECLARE_TLV_DB_SCALE(db_scale_ac97_gain, -3450, 150, 0);
 
-/*
- * Logarithmic volume values for WM8770
- * Computed as 20 * Log10(255 / x)
- */
-static const unsigned char wm_vol[256] = {
-        127, 48, 42, 39, 36, 34, 33, 31, 30, 29, 28, 27, 27, 26, 25, 25, 24, 24, 23,
-        23, 22, 22, 21, 21, 21, 20, 20, 20, 19, 19, 19, 18, 18, 18, 18, 17, 17, 17,
-        17, 16, 16, 16, 16, 15, 15, 15, 15, 15, 15, 14, 14, 14, 14, 14, 13, 13, 13,
-        13, 13, 13, 13, 12, 12, 12, 12, 12, 12, 12, 11, 11, 11, 11, 11, 11, 11, 11,
-        11, 10, 10, 10, 10, 10, 10, 10, 10, 10, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 8, 8,
-        8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 6, 6, 6,
-        6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
-        5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 3,
-        3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0
-};
-
-#define WM_VOL_MAX      (sizeof(wm_vol) - 1)
+#define WM_VOL_MAX      100
+#define WM_VOL_CNT      101     /* 0dB .. -100dB */
 #define WM_VOL_MUTE     0x8000
 
 static void wm_set_vol(struct snd_ice1712 *ice, unsigned int index, unsigned short vol, unsigned short master)
 {
         unsigned char nvol;
 
-        if ((master & WM_VOL_MUTE) || (vol & WM_VOL_MUTE))
+        if ((master & WM_VOL_MUTE) || (vol & WM_VOL_MUTE)) {
                 nvol = 0;
-        else
-                nvol = 127 - wm_vol[(((vol & ~WM_VOL_MUTE) * (master & ~WM_VOL_MUTE)) / 127) & WM_VOL_MAX];
+        } else {
+                nvol = ((vol % WM_VOL_CNT) * (master % WM_VOL_CNT)) /
+                                                                WM_VOL_MAX;
+                nvol += 0x1b;
+        }
 
         wm_put(ice, index, nvol);
         wm_put_nocache(ice, index, 0x180 | nvol);
@@ -795,7 +780,7 @@ static int wm_master_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_
         for (ch = 0; ch < 2; ch++) {
                 unsigned int vol = ucontrol->value.integer.value[ch];
                 if (vol > WM_VOL_MAX)
-                        continue;
+                        vol = WM_VOL_MAX;
                 vol |= spec->master[ch] & WM_VOL_MUTE;
                 if (vol != spec->master[ch]) {
                         int dac;
@@ -820,7 +805,7 @@ static int wm_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *
         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
         uinfo->count = voices;
         uinfo->value.integer.min = 0;           /* mute (-101dB) */
-        uinfo->value.integer.max = 0x7F;        /* 0dB */
+        uinfo->value.integer.max = WM_VOL_MAX;  /* 0dB */
         return 0;
 }
 
@@ -850,9 +835,9 @@ static int wm_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *
         snd_ice1712_save_gpio_status(ice);
         for (i = 0; i < voices; i++) {
                 unsigned int vol = ucontrol->value.integer.value[i];
-                if (vol > 0x7f)
-                        continue;
-                vol |= spec->vol[ofs+i];
+                if (vol > WM_VOL_MAX)
+                        vol = WM_VOL_MAX;
+                vol |= spec->vol[ofs+i] & WM_VOL_MUTE;
                 if (vol != spec->vol[ofs+i]) {
                         spec->vol[ofs+i] = vol;
                         idx  = WM_DAC_ATTEN + ofs + i;
diff --git a/sound/pci/ice1712/ice1712.c b/sound/pci/ice1712/ice1712.c
index d74033a2cfbe..4fc6d8bc637e 100644
--- a/sound/pci/ice1712/ice1712.c
+++ b/sound/pci/ice1712/ice1712.c
@@ -106,7 +106,7 @@ module_param_array(dxr_enable, int, NULL, 0444);
 MODULE_PARM_DESC(dxr_enable, "Enable DXR support for Terratec DMX6FIRE.");
 
 
-static const struct pci_device_id snd_ice1712_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_ice1712_ids) = {
         { PCI_VDEVICE(ICE, PCI_DEVICE_ID_ICE_1712), 0 },   /* ICE1712 */
         { 0, }
 };
@@ -298,6 +298,16 @@ static void snd_ice1712_set_gpio_dir(struct snd_ice1712 *ice, unsigned int data)
         inb(ICEREG(ice, DATA)); /* dummy read for pci-posting */
 }
 
+static unsigned int snd_ice1712_get_gpio_dir(struct snd_ice1712 *ice)
+{
+        return snd_ice1712_read(ice, ICE1712_IREG_GPIO_DIRECTION);
+}
+
+static unsigned int snd_ice1712_get_gpio_mask(struct snd_ice1712 *ice)
+{
+        return snd_ice1712_read(ice, ICE1712_IREG_GPIO_WRITE_MASK);
+}
+
 static void snd_ice1712_set_gpio_mask(struct snd_ice1712 *ice, unsigned int data)
 {
         snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, data);
@@ -1170,6 +1180,10 @@ static int snd_ice1712_playback_pro_open(struct snd_pcm_substream *substream)
         snd_pcm_set_sync(substream);
         snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24);
         snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, &hw_constraints_rates);
+        if (is_pro_rate_locked(ice)) {
+                runtime->hw.rate_min = PRO_RATE_DEFAULT;
+                runtime->hw.rate_max = PRO_RATE_DEFAULT;
+        }
 
         if (ice->spdif.ops.open)
                 ice->spdif.ops.open(ice, substream);
@@ -1187,6 +1201,11 @@ static int snd_ice1712_capture_pro_open(struct snd_pcm_substream *substream)
         snd_pcm_set_sync(substream);
         snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24);
         snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, &hw_constraints_rates);
+        if (is_pro_rate_locked(ice)) {
+                runtime->hw.rate_min = PRO_RATE_DEFAULT;
+                runtime->hw.rate_max = PRO_RATE_DEFAULT;
+        }
+
         return 0;
 }
 
@@ -2557,7 +2576,9 @@ static int __devinit snd_ice1712_create(struct snd_card *card,
         mutex_init(&ice->i2c_mutex);
         mutex_init(&ice->open_mutex);
         ice->gpio.set_mask = snd_ice1712_set_gpio_mask;
+        ice->gpio.get_mask = snd_ice1712_get_gpio_mask;
         ice->gpio.set_dir = snd_ice1712_set_gpio_dir;
+        ice->gpio.get_dir = snd_ice1712_get_gpio_dir;
         ice->gpio.set_data = snd_ice1712_set_gpio_data;
         ice->gpio.get_data = snd_ice1712_get_gpio_data;
 
diff --git a/sound/pci/ice1712/ice1712.h b/sound/pci/ice1712/ice1712.h
index d063149e7047..0da778a69ef8 100644
--- a/sound/pci/ice1712/ice1712.h
+++ b/sound/pci/ice1712/ice1712.h
@@ -359,7 +359,9 @@ struct snd_ice1712 {
                 unsigned int saved[2];          /* for ewx_i2c */
                 /* operators */
                 void (*set_mask)(struct snd_ice1712 *ice, unsigned int data);
+                unsigned int (*get_mask)(struct snd_ice1712 *ice);
                 void (*set_dir)(struct snd_ice1712 *ice, unsigned int data);
+                unsigned int (*get_dir)(struct snd_ice1712 *ice);
                 void (*set_data)(struct snd_ice1712 *ice, unsigned int data);
                 unsigned int (*get_data)(struct snd_ice1712 *ice);
                 /* misc operators - move to another place? */
@@ -377,8 +379,11 @@ struct snd_ice1712 {
         unsigned int (*get_rate)(struct snd_ice1712 *ice);
         void (*set_rate)(struct snd_ice1712 *ice, unsigned int rate);
         unsigned char (*set_mclk)(struct snd_ice1712 *ice, unsigned int rate);
-        void (*set_spdif_clock)(struct snd_ice1712 *ice);
-
+        int (*set_spdif_clock)(struct snd_ice1712 *ice, int type);
+        int (*get_spdif_master_type)(struct snd_ice1712 *ice);
+        char **ext_clock_names;
+        int ext_clock_count;
+        void (*pro_open)(struct snd_ice1712 *, struct snd_pcm_substream *);
 #ifdef CONFIG_PM
         int (*pm_suspend)(struct snd_ice1712 *);
         int (*pm_resume)(struct snd_ice1712 *);
@@ -399,6 +404,11 @@ static inline void snd_ice1712_gpio_set_dir(struct snd_ice1712 *ice, unsigned in
         ice->gpio.set_dir(ice, bits);
 }
 
+static inline unsigned int snd_ice1712_gpio_get_dir(struct snd_ice1712 *ice)
+{
+        return ice->gpio.get_dir(ice);
+}
+
 static inline void snd_ice1712_gpio_set_mask(struct snd_ice1712 *ice, unsigned int bits)
 {
         ice->gpio.set_mask(ice, bits);
diff --git a/sound/pci/ice1712/ice1724.c b/sound/pci/ice1712/ice1724.c
index 10fc92c05574..c1498fa5545f 100644
--- a/sound/pci/ice1712/ice1724.c
+++ b/sound/pci/ice1712/ice1724.c
@@ -53,6 +53,7 @@
 #include "phase.h"
 #include "wtm.h"
 #include "se.h"
+#include "quartet.h"
 
 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
 MODULE_DESCRIPTION("VIA ICEnsemble ICE1724/1720 (Envy24HT/PT)");
@@ -70,6 +71,7 @@ MODULE_SUPPORTED_DEVICE("{"
                PHASE_DEVICE_DESC
                WTM_DEVICE_DESC
                SE_DEVICE_DESC
+               QTET_DEVICE_DESC
                 "{VIA,VT1720},"
                 "{VIA,VT1724},"
                 "{ICEnsemble,Generic ICE1724},"
@@ -92,7 +94,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[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_vt1724_ids) = {
         { PCI_VDEVICE(ICE, PCI_DEVICE_ID_VT1724), 0 },
         { 0, }
 };
@@ -104,6 +106,8 @@ static int PRO_RATE_LOCKED;
 static int PRO_RATE_RESET = 1;
 static unsigned int PRO_RATE_DEFAULT = 44100;
 
+static char *ext_clock_names[1] = { "IEC958 In" };
+
 /*
  *  Basic I/O
  */
@@ -118,9 +122,12 @@ static inline int stdclock_is_spdif_master(struct snd_ice1712 *ice)
         return (inb(ICEMT1724(ice, RATE)) & VT1724_SPDIF_MASTER) ? 1 : 0;
 }
 
+/*
+ * locking rate makes sense only for internal clock mode
+ */
 static inline int is_pro_rate_locked(struct snd_ice1712 *ice)
 {
-        return ice->is_spdif_master(ice) || PRO_RATE_LOCKED;
+        return (!ice->is_spdif_master(ice)) && PRO_RATE_LOCKED;
 }
 
 /*
@@ -196,6 +203,12 @@ static void snd_vt1724_set_gpio_dir(struct snd_ice1712 *ice, unsigned int data)
         inw(ICEREG1724(ice, GPIO_DIRECTION)); /* dummy read for pci-posting */
 }
 
+/* get gpio direction 0 = read, 1 = write */
+static unsigned int snd_vt1724_get_gpio_dir(struct snd_ice1712 *ice)
+{
+        return inl(ICEREG1724(ice, GPIO_DIRECTION));
+}
+
 /* set the gpio mask (0 = writable) */
 static void snd_vt1724_set_gpio_mask(struct snd_ice1712 *ice, unsigned int data)
 {
@@ -205,6 +218,17 @@ static void snd_vt1724_set_gpio_mask(struct snd_ice1712 *ice, unsigned int data)
         inw(ICEREG1724(ice, GPIO_WRITE_MASK)); /* dummy read for pci-posting */
 }
 
+static unsigned int snd_vt1724_get_gpio_mask(struct snd_ice1712 *ice)
+{
+        unsigned int mask;
+        if (!ice->vt1720)
+                mask = (unsigned int)inb(ICEREG1724(ice, GPIO_WRITE_MASK_22));
+        else
+                mask = 0;
+        mask = (mask << 16) | inw(ICEREG1724(ice, GPIO_WRITE_MASK));
+        return mask;
+}
+
 static void snd_vt1724_set_gpio_data(struct snd_ice1712 *ice, unsigned int data)
 {
         outw(data, ICEREG1724(ice, GPIO_DATA));
@@ -651,16 +675,22 @@ static int snd_vt1724_set_pro_rate(struct snd_ice1712 *ice, unsigned int rate,
                 return ((rate == ice->cur_rate) && !force) ? 0 : -EBUSY;
         }
         if (!force && is_pro_rate_locked(ice)) {
+                /* comparing required and current rate - makes sense for
+                 * internal clock only */
                 spin_unlock_irqrestore(&ice->reg_lock, flags);
                 return (rate == ice->cur_rate) ? 0 : -EBUSY;
         }
 
-        old_rate = ice->get_rate(ice);
-        if (force || (old_rate != rate))
-                ice->set_rate(ice, rate);
-        else if (rate == ice->cur_rate) {
-                spin_unlock_irqrestore(&ice->reg_lock, flags);
-                return 0;
+        if (force || !ice->is_spdif_master(ice)) {
+                /* force means the rate was switched by ucontrol, otherwise
+                 * setting clock rate for internal clock mode */
+                old_rate = ice->get_rate(ice);
+                if (force || (old_rate != rate))
+                        ice->set_rate(ice, rate);
+                else if (rate == ice->cur_rate) {
+                        spin_unlock_irqrestore(&ice->reg_lock, flags);
+                        return 0;
+                }
         }
 
         ice->cur_rate = rate;
@@ -1016,6 +1046,8 @@ static int snd_vt1724_playback_pro_open(struct snd_pcm_substream *substream)
                                    VT1724_BUFFER_ALIGN);
         snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
                                    VT1724_BUFFER_ALIGN);
+        if (ice->pro_open)
+                ice->pro_open(ice, substream);
         return 0;
 }
 
@@ -1034,6 +1066,8 @@ static int snd_vt1724_capture_pro_open(struct snd_pcm_substream *substream)
                                    VT1724_BUFFER_ALIGN);
         snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
                                    VT1724_BUFFER_ALIGN);
+        if (ice->pro_open)
+                ice->pro_open(ice, substream);
         return 0;
 }
 
@@ -1787,15 +1821,21 @@ static int snd_vt1724_pro_internal_clock_info(struct snd_kcontrol *kcontrol,
                                               struct snd_ctl_elem_info *uinfo)
 {
         struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
-
+        int hw_rates_count = ice->hw_rates->count;
         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
         uinfo->count = 1;
-        uinfo->value.enumerated.items = ice->hw_rates->count + 1;
+
+        uinfo->value.enumerated.items = hw_rates_count + ice->ext_clock_count;
+        /* upper limit - keep at top */
         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
-        if (uinfo->value.enumerated.item == uinfo->value.enumerated.items - 1)
-                strcpy(uinfo->value.enumerated.name, "IEC958 Input");
+        if (uinfo->value.enumerated.item >= hw_rates_count)
+                /* ext_clock items */
+                strcpy(uinfo->value.enumerated.name,
+                                ice->ext_clock_names[
+                                uinfo->value.enumerated.item - hw_rates_count]);
         else
+                /* int clock items */
                 sprintf(uinfo->value.enumerated.name, "%d",
                         ice->hw_rates->list[uinfo->value.enumerated.item]);
         return 0;
@@ -1809,7 +1849,8 @@ static int snd_vt1724_pro_internal_clock_get(struct snd_kcontrol *kcontrol,
 
         spin_lock_irq(&ice->reg_lock);
         if (ice->is_spdif_master(ice)) {
-                ucontrol->value.enumerated.item[0] = ice->hw_rates->count;
+                ucontrol->value.enumerated.item[0] = ice->hw_rates->count +
+                        ice->get_spdif_master_type(ice);
         } else {
                 rate = ice->get_rate(ice);
                 ucontrol->value.enumerated.item[0] = 0;
@@ -1824,8 +1865,14 @@ static int snd_vt1724_pro_internal_clock_get(struct snd_kcontrol *kcontrol,
         return 0;
 }
 
+static int stdclock_get_spdif_master_type(struct snd_ice1712 *ice)
+{
+        /* standard external clock - only single type - SPDIF IN */
+        return 0;
+}
+
 /* setting clock to external - SPDIF */
-static void stdclock_set_spdif_clock(struct snd_ice1712 *ice)
+static int stdclock_set_spdif_clock(struct snd_ice1712 *ice, int type)
 {
         unsigned char oval;
         unsigned char i2s_oval;
@@ -1834,27 +1881,30 @@ static void stdclock_set_spdif_clock(struct snd_ice1712 *ice)
         /* setting 256fs */
         i2s_oval = inb(ICEMT1724(ice, I2S_FORMAT));
         outb(i2s_oval & ~VT1724_MT_I2S_MCLK_128X, ICEMT1724(ice, I2S_FORMAT));
+        return 0;
 }
 
+
 static int snd_vt1724_pro_internal_clock_put(struct snd_kcontrol *kcontrol,
                                              struct snd_ctl_elem_value *ucontrol)
 {
         struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
         unsigned int old_rate, new_rate;
         unsigned int item = ucontrol->value.enumerated.item[0];
-        unsigned int spdif = ice->hw_rates->count;
+        unsigned int first_ext_clock = ice->hw_rates->count;
 
-        if (item > spdif)
+        if (item >  first_ext_clock + ice->ext_clock_count - 1)
                 return -EINVAL;
 
+        /* if rate = 0 => external clock */
         spin_lock_irq(&ice->reg_lock);
         if (ice->is_spdif_master(ice))
                 old_rate = 0;
         else
                 old_rate = ice->get_rate(ice);
-        if (item == spdif) {
-                /* switching to external clock via SPDIF */
-                ice->set_spdif_clock(ice);
+        if (item >= first_ext_clock) {
+                /* switching to external clock */
+                ice->set_spdif_clock(ice, item - first_ext_clock);
                 new_rate = 0;
         } else {
                 /* internal on-card clock */
@@ -1866,7 +1916,7 @@ static int snd_vt1724_pro_internal_clock_put(struct snd_kcontrol *kcontrol,
         }
         spin_unlock_irq(&ice->reg_lock);
 
-        /* the first reset to the SPDIF master mode? */
+        /* the first switch to the ext. clock mode? */
         if (old_rate != new_rate && !new_rate) {
                 /* notify akm chips as well */
                 unsigned int i;
@@ -2136,6 +2186,7 @@ static struct snd_ice1712_card_info *card_tables[] __devinitdata = {
         snd_vt1724_phase_cards,
         snd_vt1724_wtm_cards,
         snd_vt1724_se_cards,
+        snd_vt1724_qtet_cards,
         NULL,
 };
 
@@ -2434,7 +2485,9 @@ static int __devinit snd_vt1724_create(struct snd_card *card,
         mutex_init(&ice->open_mutex);
         mutex_init(&ice->i2c_mutex);
         ice->gpio.set_mask = snd_vt1724_set_gpio_mask;
+        ice->gpio.get_mask = snd_vt1724_get_gpio_mask;
         ice->gpio.set_dir = snd_vt1724_set_gpio_dir;
+        ice->gpio.get_dir = snd_vt1724_get_gpio_dir;
         ice->gpio.set_data = snd_vt1724_set_gpio_data;
         ice->gpio.get_data = snd_vt1724_get_gpio_data;
         ice->card = card;
@@ -2522,6 +2575,9 @@ static int __devinit snd_vt1724_probe(struct pci_dev *pci,
                 return err;
         }
 
+        /* field init before calling chip_init */
+        ice->ext_clock_count = 0;
+
         for (tbl = card_tables; *tbl; tbl++) {
                 for (c = *tbl; c->subvendor; c++) {
                         if (c->subvendor == ice->eeprom.subvendor) {
@@ -2560,6 +2616,13 @@ __found:
                 ice->set_mclk = stdclock_set_mclk;
         if (!ice->set_spdif_clock)
                 ice->set_spdif_clock = stdclock_set_spdif_clock;
+        if (!ice->get_spdif_master_type)
+                ice->get_spdif_master_type = stdclock_get_spdif_master_type;
+        if (!ice->ext_clock_names)
+                ice->ext_clock_names = ext_clock_names;
+        if (!ice->ext_clock_count)
+                ice->ext_clock_count = ARRAY_SIZE(ext_clock_names);
+
         if (!ice->hw_rates)
                 set_std_hw_rates(ice);
 
@@ -2719,7 +2782,7 @@ static int snd_vt1724_resume(struct pci_dev *pci)
 
         if (ice->pm_saved_is_spdif_master) {
                 /* switching to external clock via SPDIF */
-                ice->set_spdif_clock(ice);
+                ice->set_spdif_clock(ice, 0);
         } else {
                 /* internal on-card clock */
                 snd_vt1724_set_pro_rate(ice, ice->pro_rate_default, 1);
diff --git a/sound/pci/ice1712/juli.c b/sound/pci/ice1712/juli.c
index fd948bfd9aef..98bc3b7681b5 100644
--- a/sound/pci/ice1712/juli.c
+++ b/sound/pci/ice1712/juli.c
@@ -380,7 +380,7 @@ static struct snd_kcontrol_new juli_mute_controls[] __devinitdata = {
          * inputs) are fed from Xilinx.
          *
          * I even checked traces on board and coded a support in driver for
-         * an alternative possiblity - the unused I2S ICE output channels
+         * an alternative possibility - the unused I2S ICE output channels
          * switched to HW-IN/SPDIF-IN and providing the monitoring signal to
          * the DAC - to no avail. The I2S outputs seem to be unconnected.
          *
@@ -412,25 +412,6 @@ static struct snd_kcontrol_new juli_mute_controls[] __devinitdata = {
         },
 };
 
-
-static void ak4358_proc_regs_read(struct snd_info_entry *entry,
-                struct snd_info_buffer *buffer)
-{
-        struct snd_ice1712 *ice = (struct snd_ice1712 *)entry->private_data;
-        int reg, val;
-        for (reg = 0; reg <= 0xf; reg++) {
-                val =  snd_akm4xxx_get(ice->akm, 0, reg);
-                snd_iprintf(buffer, "0x%02x = 0x%02x\n", reg, val);
-        }
-}
-
-static void ak4358_proc_init(struct snd_ice1712 *ice)
-{
-        struct snd_info_entry *entry;
-        if (!snd_card_proc_new(ice->card, "ak4358_codec", &entry))
-                snd_info_set_text_ops(entry, ice, ak4358_proc_regs_read);
-}
-
 static char *slave_vols[] __devinitdata = {
         PCM_VOLUME,
         MONITOR_AN_IN_VOLUME,
@@ -496,14 +477,37 @@ static int __devinit juli_add_controls(struct snd_ice1712 *ice)
         /* only capture SPDIF over AK4114 */
         err = snd_ak4114_build(spec->ak4114, NULL,
                         ice->pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream);
-
-        ak4358_proc_init(ice);
         if (err < 0)
                 return err;
         return 0;
 }
 
 /*
+ * suspend/resume
+ * */
+
+#ifdef CONFIG_PM
+static int juli_resume(struct snd_ice1712 *ice)
+{
+        struct snd_akm4xxx *ak = ice->akm;
+        struct juli_spec *spec = ice->spec;
+        /* akm4358 un-reset, un-mute */
+        snd_akm4xxx_reset(ak, 0);
+        /* reinit ak4114 */
+        snd_ak4114_reinit(spec->ak4114);
+        return 0;
+}
+
+static int juli_suspend(struct snd_ice1712 *ice)
+{
+        struct snd_akm4xxx *ak = ice->akm;
+        /* akm4358 reset and soft-mute */
+        snd_akm4xxx_reset(ak, 1);
+        return 0;
+}
+#endif
+
+/*
  * initialize the chip
  */
 
@@ -550,13 +554,14 @@ static inline unsigned char juli_set_mclk(struct snd_ice1712 *ice,
 }
 
 /* setting clock to external - SPDIF */
-static void juli_set_spdif_clock(struct snd_ice1712 *ice)
+static int juli_set_spdif_clock(struct snd_ice1712 *ice, int type)
 {
         unsigned int old;
         old = ice->gpio.get_data(ice);
         /* external clock (= 0), multiply 1x, 48kHz */
         ice->gpio.set_data(ice, (old & ~GPIO_RATE_MASK) | GPIO_MULTI_1X |
                         GPIO_FREQ_48KHZ);
+        return 0;
 }
 
 /* Called when ak4114 detects change in the input SPDIF stream */
@@ -646,6 +651,13 @@ static int __devinit juli_init(struct snd_ice1712 *ice)
         ice->set_spdif_clock = juli_set_spdif_clock;
 
         ice->spdif.ops.open = juli_spdif_in_open;
+
+#ifdef CONFIG_PM
+        ice->pm_resume = juli_resume;
+        ice->pm_suspend = juli_suspend;
+        ice->pm_suspend_enabled = 1;
+#endif
+
         return 0;
 }
 
diff --git a/sound/pci/ice1712/maya44.c b/sound/pci/ice1712/maya44.c
index 3e1c20ae2f1c..726fd4b92e19 100644
--- a/sound/pci/ice1712/maya44.c
+++ b/sound/pci/ice1712/maya44.c
@@ -347,7 +347,7 @@ static int maya_gpio_sw_put(struct snd_kcontrol *kcontrol,
 
 /* known working input slots (0-4) */
 #define MAYA_LINE_IN    1       /* in-2 */
-#define MAYA_MIC_IN     4       /* in-5 */
+#define MAYA_MIC_IN     3       /* in-4 */
 
 static void wm8776_select_input(struct snd_maya44 *chip, int idx, int line)
 {
@@ -393,8 +393,8 @@ static int maya_rec_src_put(struct snd_kcontrol *kcontrol,
         int changed;
 
         mutex_lock(&chip->mutex);
-        changed = maya_set_gpio_bits(chip->ice, GPIO_MIC_RELAY,
-                                     sel ? GPIO_MIC_RELAY : 0);
+        changed = maya_set_gpio_bits(chip->ice, 1 << GPIO_MIC_RELAY,
+                                     sel ? (1 << GPIO_MIC_RELAY) : 0);
         wm8776_select_input(chip, 0, sel ? MAYA_MIC_IN : MAYA_LINE_IN);
         mutex_unlock(&chip->mutex);
         return changed;
diff --git a/sound/pci/ice1712/quartet.c b/sound/pci/ice1712/quartet.c
new file mode 100644
index 000000000000..1948632787e6
--- /dev/null
+++ b/sound/pci/ice1712/quartet.c
@@ -0,0 +1,1130 @@
+/*
+ *   ALSA driver for ICEnsemble VT1724 (Envy24HT)
+ *
+ *   Lowlevel functions for Infrasonic Quartet
+ *
+ *      Copyright (c) 2009 Pavel Hofman <pavel.hofman@ivitera.com>
+ *
+ *
+ *   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
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program 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 <asm/io.h>
+#include <linux/delay.h>
+#include <linux/interrupt.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <sound/core.h>
+#include <sound/tlv.h>
+#include <sound/info.h>
+
+#include "ice1712.h"
+#include "envy24ht.h"
+#include <sound/ak4113.h>
+#include "quartet.h"
+
+struct qtet_spec {
+        struct ak4113 *ak4113;
+        unsigned int scr;       /* system control register */
+        unsigned int mcr;       /* monitoring control register */
+        unsigned int cpld;      /* cpld register */
+};
+
+struct qtet_kcontrol_private {
+        unsigned int bit;
+        void (*set_register)(struct snd_ice1712 *ice, unsigned int val);
+        unsigned int (*get_register)(struct snd_ice1712 *ice);
+        unsigned char *texts[2];
+};
+
+enum {
+        IN12_SEL = 0,
+        IN34_SEL,
+        AIN34_SEL,
+        COAX_OUT,
+        IN12_MON12,
+        IN12_MON34,
+        IN34_MON12,
+        IN34_MON34,
+        OUT12_MON34,
+        OUT34_MON12,
+};
+
+static char *ext_clock_names[3] = {"IEC958 In", "Word Clock 1xFS",
+        "Word Clock 256xFS"};
+
+/* chip address on I2C bus */
+#define AK4113_ADDR             0x26    /* S/PDIF receiver */
+
+/* chip address on SPI bus */
+#define AK4620_ADDR             0x02    /* ADC/DAC */
+
+
+/*
+ * GPIO pins
+ */
+
+/* GPIO0 - O - DATA0, def. 0 */
+#define GPIO_D0                 (1<<0)
+/* GPIO1 - I/O - DATA1, Jack Detect Input0 (0:present, 1:missing), def. 1 */
+#define GPIO_D1_JACKDTC0        (1<<1)
+/* GPIO2 - I/O - DATA2, Jack Detect Input1 (0:present, 1:missing), def. 1 */
+#define GPIO_D2_JACKDTC1        (1<<2)
+/* GPIO3 - I/O - DATA3, def. 1 */
+#define GPIO_D3                 (1<<3)
+/* GPIO4 - I/O - DATA4, SPI CDTO, def. 1 */
+#define GPIO_D4_SPI_CDTO        (1<<4)
+/* GPIO5 - I/O - DATA5, SPI CCLK, def. 1 */
+#define GPIO_D5_SPI_CCLK        (1<<5)
+/* GPIO6 - I/O - DATA6, Cable Detect Input (0:detected, 1:not detected */
+#define GPIO_D6_CD              (1<<6)
+/* GPIO7 - I/O - DATA7, Device Detect Input (0:detected, 1:not detected */
+#define GPIO_D7_DD              (1<<7)
+/* GPIO8 - O - CPLD Chip Select, def. 1 */
+#define GPIO_CPLD_CSN           (1<<8)
+/* GPIO9 - O - CPLD register read/write (0:write, 1:read), def. 0 */
+#define GPIO_CPLD_RW            (1<<9)
+/* GPIO10 - O - SPI Chip Select for CODEC#0, def. 1 */
+#define GPIO_SPI_CSN0           (1<<10)
+/* GPIO11 - O - SPI Chip Select for CODEC#1, def. 1 */
+#define GPIO_SPI_CSN1           (1<<11)
+/* GPIO12 - O - Ex. Register Output Enable (0:enable, 1:disable), def. 1,
+ * init 0 */
+#define GPIO_EX_GPIOE           (1<<12)
+/* GPIO13 - O - Ex. Register0 Chip Select for System Control Register,
+ * def. 1 */
+#define GPIO_SCR                (1<<13)
+/* GPIO14 - O - Ex. Register1 Chip Select for Monitor Control Register,
+ * def. 1 */
+#define GPIO_MCR                (1<<14)
+
+#define GPIO_SPI_ALL            (GPIO_D4_SPI_CDTO | GPIO_D5_SPI_CCLK |\
+                GPIO_SPI_CSN0 | GPIO_SPI_CSN1)
+
+#define GPIO_DATA_MASK          (GPIO_D0 | GPIO_D1_JACKDTC0 | \
+                GPIO_D2_JACKDTC1 | GPIO_D3 | \
+                GPIO_D4_SPI_CDTO | GPIO_D5_SPI_CCLK | \
+                GPIO_D6_CD | GPIO_D7_DD)
+
+/* System Control Register GPIO_SCR data bits */
+/* Mic/Line select relay (0:line, 1:mic) */
+#define SCR_RELAY               GPIO_D0
+/* Phantom power drive control (0:5V, 1:48V) */
+#define SCR_PHP_V               GPIO_D1_JACKDTC0
+/* H/W mute control (0:Normal, 1:Mute) */
+#define SCR_MUTE                GPIO_D2_JACKDTC1
+/* Phantom power control (0:Phantom on, 1:off) */
+#define SCR_PHP                 GPIO_D3
+/* Analog input 1/2 Source Select */
+#define SCR_AIN12_SEL0          GPIO_D4_SPI_CDTO
+#define SCR_AIN12_SEL1          GPIO_D5_SPI_CCLK
+/* Analog input 3/4 Source Select (0:line, 1:hi-z) */
+#define SCR_AIN34_SEL           GPIO_D6_CD
+/* Codec Power Down (0:power down, 1:normal) */
+#define SCR_CODEC_PDN           GPIO_D7_DD
+
+#define SCR_AIN12_LINE          (0)
+#define SCR_AIN12_MIC           (SCR_AIN12_SEL0)
+#define SCR_AIN12_LOWCUT        (SCR_AIN12_SEL1 | SCR_AIN12_SEL0)
+
+/* Monitor Control Register GPIO_MCR data bits */
+/* Input 1/2 to Monitor 1/2 (0:off, 1:on) */
+#define MCR_IN12_MON12          GPIO_D0
+/* Input 1/2 to Monitor 3/4 (0:off, 1:on) */
+#define MCR_IN12_MON34          GPIO_D1_JACKDTC0
+/* Input 3/4 to Monitor 1/2 (0:off, 1:on) */
+#define MCR_IN34_MON12          GPIO_D2_JACKDTC1
+/* Input 3/4 to Monitor 3/4 (0:off, 1:on) */
+#define MCR_IN34_MON34          GPIO_D3
+/* Output to Monitor 1/2 (0:off, 1:on) */
+#define MCR_OUT34_MON12         GPIO_D4_SPI_CDTO
+/* Output to Monitor 3/4 (0:off, 1:on) */
+#define MCR_OUT12_MON34         GPIO_D5_SPI_CCLK
+
+/* CPLD Register DATA bits */
+/* Clock Rate Select */
+#define CPLD_CKS0               GPIO_D0
+#define CPLD_CKS1               GPIO_D1_JACKDTC0
+#define CPLD_CKS2               GPIO_D2_JACKDTC1
+/* Sync Source Select (0:Internal, 1:External) */
+#define CPLD_SYNC_SEL           GPIO_D3
+/* Word Clock FS Select (0:FS, 1:256FS) */
+#define CPLD_WORD_SEL           GPIO_D4_SPI_CDTO
+/* Coaxial Output Source (IS-Link) (0:SPDIF, 1:I2S) */
+#define CPLD_COAX_OUT           GPIO_D5_SPI_CCLK
+/* Input 1/2 Source Select (0:Analog12, 1:An34) */
+#define CPLD_IN12_SEL           GPIO_D6_CD
+/* Input 3/4 Source Select (0:Analog34, 1:Digital In) */
+#define CPLD_IN34_SEL           GPIO_D7_DD
+
+/* internal clock (CPLD_SYNC_SEL = 0) options */
+#define CPLD_CKS_44100HZ        (0)
+#define CPLD_CKS_48000HZ        (CPLD_CKS0)
+#define CPLD_CKS_88200HZ        (CPLD_CKS1)
+#define CPLD_CKS_96000HZ        (CPLD_CKS1 | CPLD_CKS0)
+#define CPLD_CKS_176400HZ       (CPLD_CKS2)
+#define CPLD_CKS_192000HZ       (CPLD_CKS2 | CPLD_CKS0)
+
+#define CPLD_CKS_MASK           (CPLD_CKS0 | CPLD_CKS1 | CPLD_CKS2)
+
+/* external clock (CPLD_SYNC_SEL = 1) options */
+/* external clock - SPDIF */
+#define CPLD_EXT_SPDIF  (0 | CPLD_SYNC_SEL)
+/* external clock - WordClock 1xfs */
+#define CPLD_EXT_WORDCLOCK_1FS  (CPLD_CKS1 | CPLD_SYNC_SEL)
+/* external clock - WordClock 256xfs */
+#define CPLD_EXT_WORDCLOCK_256FS        (CPLD_CKS1 | CPLD_WORD_SEL |\
+                CPLD_SYNC_SEL)
+
+#define EXT_SPDIF_TYPE                  0
+#define EXT_WORDCLOCK_1FS_TYPE          1
+#define EXT_WORDCLOCK_256FS_TYPE        2
+
+#define AK4620_DFS0             (1<<0)
+#define AK4620_DFS1             (1<<1)
+#define AK4620_CKS0             (1<<2)
+#define AK4620_CKS1             (1<<3)
+/* Clock and Format Control register */
+#define AK4620_DFS_REG          0x02
+
+/* Deem and Volume Control register */
+#define AK4620_DEEMVOL_REG      0x03
+#define AK4620_SMUTE            (1<<7)
+
+/*
+ * Conversion from int value to its binary form. Used for debugging.
+ * The output buffer must be allocated prior to calling the function.
+ */
+static char *get_binary(char *buffer, int value)
+{
+        int i, j, pos;
+        pos = 0;
+        for (i = 0; i < 4; ++i) {
+                for (j = 0; j < 8; ++j) {
+                        if (value & (1 << (31-(i*8 + j))))
+                                buffer[pos] = '1';
+                        else
+                                buffer[pos] = '0';
+                        pos++;
+                }
+                if (i < 3) {
+                        buffer[pos] = ' ';
+                        pos++;
+                }
+        }
+        buffer[pos] = '\0';
+        return buffer;
+}
+
+/*
+ * Initial setup of the conversion array GPIO <-> rate
+ */
+static unsigned int qtet_rates[] = {
+        44100, 48000, 88200,
+        96000, 176400, 192000,
+};
+
+static unsigned int cks_vals[] = {
+        CPLD_CKS_44100HZ, CPLD_CKS_48000HZ, CPLD_CKS_88200HZ,
+        CPLD_CKS_96000HZ, CPLD_CKS_176400HZ, CPLD_CKS_192000HZ,
+};
+
+static struct snd_pcm_hw_constraint_list qtet_rates_info = {
+        .count = ARRAY_SIZE(qtet_rates),
+        .list = qtet_rates,
+        .mask = 0,
+};
+
+static void qtet_ak4113_write(void *private_data, unsigned char reg,
+                unsigned char val)
+{
+        snd_vt1724_write_i2c((struct snd_ice1712 *)private_data, AK4113_ADDR,
+                        reg, val);
+}
+
+static unsigned char qtet_ak4113_read(void *private_data, unsigned char reg)
+{
+        return snd_vt1724_read_i2c((struct snd_ice1712 *)private_data,
+                        AK4113_ADDR, reg);
+}
+
+
+/*
+ * AK4620 section
+ */
+
+/*
+ * Write data to addr register of ak4620
+ */
+static void qtet_akm_write(struct snd_akm4xxx *ak, int chip,
+                unsigned char addr, unsigned char data)
+{
+        unsigned int tmp, orig_dir;
+        int idx;
+        unsigned int addrdata;
+        struct snd_ice1712 *ice = ak->private_data[0];
+
+        if (snd_BUG_ON(chip < 0 || chip >= 4))
+                return;
+        /*printk(KERN_DEBUG "Writing to AK4620: chip=%d, addr=0x%x,
+          data=0x%x\n", chip, addr, data);*/
+        orig_dir = ice->gpio.get_dir(ice);
+        ice->gpio.set_dir(ice, orig_dir | GPIO_SPI_ALL);
+        /* set mask - only SPI bits */
+        ice->gpio.set_mask(ice, ~GPIO_SPI_ALL);
+
+        tmp = ice->gpio.get_data(ice);
+        /* high all */
+        tmp |= GPIO_SPI_ALL;
+        ice->gpio.set_data(ice, tmp);
+        udelay(100);
+        /* drop chip select */
+        if (chip)
+                /* CODEC 1 */
+                tmp &= ~GPIO_SPI_CSN1;
+        else
+                tmp &= ~GPIO_SPI_CSN0;
+        ice->gpio.set_data(ice, tmp);
+        udelay(100);
+
+        /* build I2C address + data byte */
+        addrdata = (AK4620_ADDR << 6) | 0x20 | (addr & 0x1f);
+        addrdata = (addrdata << 8) | data;
+        for (idx = 15; idx >= 0; idx--) {
+                /* drop clock */
+                tmp &= ~GPIO_D5_SPI_CCLK;
+                ice->gpio.set_data(ice, tmp);
+                udelay(100);
+                /* set data */
+                if (addrdata & (1 << idx))
+                        tmp |= GPIO_D4_SPI_CDTO;
+                else
+                        tmp &= ~GPIO_D4_SPI_CDTO;
+                ice->gpio.set_data(ice, tmp);
+                udelay(100);
+                /* raise clock */
+                tmp |= GPIO_D5_SPI_CCLK;
+                ice->gpio.set_data(ice, tmp);
+                udelay(100);
+        }
+        /* all back to 1 */
+        tmp |= GPIO_SPI_ALL;
+        ice->gpio.set_data(ice, tmp);
+        udelay(100);
+
+        /* return all gpios to non-writable */
+        ice->gpio.set_mask(ice, 0xffffff);
+        /* restore GPIOs direction */
+        ice->gpio.set_dir(ice, orig_dir);
+}
+
+static void qtet_akm_set_regs(struct snd_akm4xxx *ak, unsigned char addr,
+                unsigned char mask, unsigned char value)
+{
+        unsigned char tmp;
+        int chip;
+        for (chip = 0; chip < ak->num_chips; chip++) {
+                tmp = snd_akm4xxx_get(ak, chip, addr);
+                /* clear the bits */
+                tmp &= ~mask;
+                /* set the new bits */
+                tmp |= value;
+                snd_akm4xxx_write(ak, chip, addr, tmp);
+        }
+}
+
+/*
+ * change the rate of AK4620
+ */
+static void qtet_akm_set_rate_val(struct snd_akm4xxx *ak, unsigned int rate)
+{
+        unsigned char ak4620_dfs;
+
+        if (rate == 0)  /* no hint - S/PDIF input is master or the new spdif
+                           input rate undetected, simply return */
+                return;
+
+        /* adjust DFS on codecs - see datasheet */
+        if (rate > 108000)
+                ak4620_dfs = AK4620_DFS1 | AK4620_CKS1;
+        else if (rate > 54000)
+                ak4620_dfs = AK4620_DFS0 | AK4620_CKS0;
+        else
+                ak4620_dfs = 0;
+
+        /* set new value */
+        qtet_akm_set_regs(ak, AK4620_DFS_REG, AK4620_DFS0 | AK4620_DFS1 |
+                        AK4620_CKS0 | AK4620_CKS1, ak4620_dfs);
+}
+
+#define AK_CONTROL(xname, xch)  { .name = xname, .num_channels = xch }
+
+#define PCM_12_PLAYBACK_VOLUME  "PCM 1/2 Playback Volume"
+#define PCM_34_PLAYBACK_VOLUME  "PCM 3/4 Playback Volume"
+#define PCM_12_CAPTURE_VOLUME   "PCM 1/2 Capture Volume"
+#define PCM_34_CAPTURE_VOLUME   "PCM 3/4 Capture Volume"
+
+static const struct snd_akm4xxx_dac_channel qtet_dac[] = {
+        AK_CONTROL(PCM_12_PLAYBACK_VOLUME, 2),
+        AK_CONTROL(PCM_34_PLAYBACK_VOLUME, 2),
+};
+
+static const struct snd_akm4xxx_adc_channel qtet_adc[] = {
+        AK_CONTROL(PCM_12_CAPTURE_VOLUME, 2),
+        AK_CONTROL(PCM_34_CAPTURE_VOLUME, 2),
+};
+
+static struct snd_akm4xxx akm_qtet_dac __devinitdata = {
+        .type = SND_AK4620,
+        .num_dacs = 4,  /* DAC1 - Output 12
+        */
+        .num_adcs = 4,  /* ADC1 - Input 12
+        */
+        .ops = {
+                .write = qtet_akm_write,
+                .set_rate_val = qtet_akm_set_rate_val,
+        },
+        .dac_info = qtet_dac,
+        .adc_info = qtet_adc,
+};
+
+/* Communication routines with the CPLD */
+
+
+/* Writes data to external register reg, both reg and data are
+ * GPIO representations */
+static void reg_write(struct snd_ice1712 *ice, unsigned int reg,
+                unsigned int data)
+{
+        unsigned int tmp;
+
+        mutex_lock(&ice->gpio_mutex);
+        /* set direction of used GPIOs*/
+        /* all outputs */
+        tmp = 0x00ffff;
+        ice->gpio.set_dir(ice, tmp);
+        /* mask - writable bits */
+        ice->gpio.set_mask(ice, ~(tmp));
+        /* write the data */
+        tmp = ice->gpio.get_data(ice);
+        tmp &= ~GPIO_DATA_MASK;
+        tmp |= data;
+        ice->gpio.set_data(ice, tmp);
+        udelay(100);
+        /* drop output enable */
+        tmp &=  ~GPIO_EX_GPIOE;
+        ice->gpio.set_data(ice, tmp);
+        udelay(100);
+        /* drop the register gpio */
+        tmp &= ~reg;
+        ice->gpio.set_data(ice, tmp);
+        udelay(100);
+        /* raise the register GPIO */
+        tmp |= reg;
+        ice->gpio.set_data(ice, tmp);
+        udelay(100);
+
+        /* raise all data gpios */
+        tmp |= GPIO_DATA_MASK;
+        ice->gpio.set_data(ice, tmp);
+        /* mask - immutable bits */
+        ice->gpio.set_mask(ice, 0xffffff);
+        /* outputs only 8-15 */
+        ice->gpio.set_dir(ice, 0x00ff00);
+        mutex_unlock(&ice->gpio_mutex);
+}
+
+static unsigned int get_scr(struct snd_ice1712 *ice)
+{
+        struct qtet_spec *spec = ice->spec;
+        return spec->scr;
+}
+
+static unsigned int get_mcr(struct snd_ice1712 *ice)
+{
+        struct qtet_spec *spec = ice->spec;
+        return spec->mcr;
+}
+
+static unsigned int get_cpld(struct snd_ice1712 *ice)
+{
+        struct qtet_spec *spec = ice->spec;
+        return spec->cpld;
+}
+
+static void set_scr(struct snd_ice1712 *ice, unsigned int val)
+{
+        struct qtet_spec *spec = ice->spec;
+        reg_write(ice, GPIO_SCR, val);
+        spec->scr = val;
+}
+
+static void set_mcr(struct snd_ice1712 *ice, unsigned int val)
+{
+        struct qtet_spec *spec = ice->spec;
+        reg_write(ice, GPIO_MCR, val);
+        spec->mcr = val;
+}
+
+static void set_cpld(struct snd_ice1712 *ice, unsigned int val)
+{
+        struct qtet_spec *spec = ice->spec;
+        reg_write(ice, GPIO_CPLD_CSN, val);
+        spec->cpld = val;
+}
+#ifdef CONFIG_PROC_FS
+static void proc_regs_read(struct snd_info_entry *entry,
+                struct snd_info_buffer *buffer)
+{
+        struct snd_ice1712 *ice = entry->private_data;
+        char bin_buffer[36];
+
+        snd_iprintf(buffer, "SCR:       %s\n", get_binary(bin_buffer,
+                                get_scr(ice)));
+        snd_iprintf(buffer, "MCR:       %s\n", get_binary(bin_buffer,
+                                get_mcr(ice)));
+        snd_iprintf(buffer, "CPLD:      %s\n", get_binary(bin_buffer,
+                                get_cpld(ice)));
+}
+
+static void proc_init(struct snd_ice1712 *ice)
+{
+        struct snd_info_entry *entry;
+        if (!snd_card_proc_new(ice->card, "quartet", &entry))
+                snd_info_set_text_ops(entry, ice, proc_regs_read);
+}
+#else /* !CONFIG_PROC_FS */
+static void proc_init(struct snd_ice1712 *ice) {}
+#endif
+
+static int qtet_mute_get(struct snd_kcontrol *kcontrol,
+                struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
+        unsigned int val;
+        val = get_scr(ice) & SCR_MUTE;
+        ucontrol->value.integer.value[0] = (val) ? 0 : 1;
+        return 0;
+}
+
+static int qtet_mute_put(struct snd_kcontrol *kcontrol,
+                struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
+        unsigned int old, new, smute;
+        old = get_scr(ice) & SCR_MUTE;
+        if (ucontrol->value.integer.value[0]) {
+                /* unmute */
+                new = 0;
+                /* un-smuting DAC */
+                smute = 0;
+        } else {
+                /* mute */
+                new = SCR_MUTE;
+                /* smuting DAC */
+                smute = AK4620_SMUTE;
+        }
+        if (old != new) {
+                struct snd_akm4xxx *ak = ice->akm;
+                set_scr(ice, (get_scr(ice) & ~SCR_MUTE) | new);
+                /* set smute */
+                qtet_akm_set_regs(ak, AK4620_DEEMVOL_REG, AK4620_SMUTE, smute);
+                return 1;
+        }
+        /* no change */
+        return 0;
+}
+
+static int qtet_ain12_enum_info(struct snd_kcontrol *kcontrol,
+                struct snd_ctl_elem_info *uinfo)
+{
+        static char *texts[3] = {"Line In 1/2", "Mic", "Mic + Low-cut"};
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        uinfo->count = 1;
+        uinfo->value.enumerated.items = ARRAY_SIZE(texts);
+
+        if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
+                uinfo->value.enumerated.item =
+                        uinfo->value.enumerated.items - 1;
+        strcpy(uinfo->value.enumerated.name,
+                        texts[uinfo->value.enumerated.item]);
+
+        return 0;
+}
+
+static int qtet_ain12_sw_get(struct snd_kcontrol *kcontrol,
+                struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
+        unsigned int val, result;
+        val = get_scr(ice) & (SCR_AIN12_SEL1 | SCR_AIN12_SEL0);
+        switch (val) {
+        case SCR_AIN12_LINE:
+                result = 0;
+                break;
+        case SCR_AIN12_MIC:
+                result = 1;
+                break;
+        case SCR_AIN12_LOWCUT:
+                result = 2;
+                break;
+        default:
+                /* BUG - no other combinations allowed */
+                snd_BUG();
+                result = 0;
+        }
+        ucontrol->value.integer.value[0] = result;
+        return 0;
+}
+
+static int qtet_ain12_sw_put(struct snd_kcontrol *kcontrol,
+                struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
+        unsigned int old, new, tmp, masked_old;
+        old = new = get_scr(ice);
+        masked_old = old & (SCR_AIN12_SEL1 | SCR_AIN12_SEL0);
+        tmp = ucontrol->value.integer.value[0];
+        if (tmp == 2)
+                tmp = 3;        /* binary 10 is not supported */
+        tmp <<= 4;      /* shifting to SCR_AIN12_SEL0 */
+        if (tmp != masked_old) {
+                /* change requested */
+                switch (tmp) {
+                case SCR_AIN12_LINE:
+                        new = old & ~(SCR_AIN12_SEL1 | SCR_AIN12_SEL0);
+                        set_scr(ice, new);
+                        /* turn off relay */
+                        new &= ~SCR_RELAY;
+                        set_scr(ice, new);
+                        break;
+                case SCR_AIN12_MIC:
+                        /* turn on relay */
+                        new = old | SCR_RELAY;
+                        set_scr(ice, new);
+                        new = (new & ~SCR_AIN12_SEL1) | SCR_AIN12_SEL0;
+                        set_scr(ice, new);
+                        break;
+                case SCR_AIN12_LOWCUT:
+                        /* turn on relay */
+                        new = old | SCR_RELAY;
+                        set_scr(ice, new);
+                        new |= SCR_AIN12_SEL1 | SCR_AIN12_SEL0;
+                        set_scr(ice, new);
+                        break;
+                default:
+                        snd_BUG();
+                }
+                return 1;
+        }
+        /* no change */
+        return 0;
+}
+
+static int qtet_php_get(struct snd_kcontrol *kcontrol,
+                struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
+        unsigned int val;
+        /* if phantom voltage =48V, phantom on */
+        val = get_scr(ice) & SCR_PHP_V;
+        ucontrol->value.integer.value[0] = val ? 1 : 0;
+        return 0;
+}
+
+static int qtet_php_put(struct snd_kcontrol *kcontrol,
+                struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
+        unsigned int old, new;
+        old = new = get_scr(ice);
+        if (ucontrol->value.integer.value[0] /* phantom on requested */
+                        && (~old & SCR_PHP_V)) /* 0 = voltage 5V */ {
+                /* is off, turn on */
+                /* turn voltage on first, = 1 */
+                new = old | SCR_PHP_V;
+                set_scr(ice, new);
+                /* turn phantom on, = 0 */
+                new &= ~SCR_PHP;
+                set_scr(ice, new);
+        } else if (!ucontrol->value.integer.value[0] && (old & SCR_PHP_V)) {
+                /* phantom off requested and 1 = voltage 48V */
+                /* is on, turn off */
+                /* turn voltage off first, = 0 */
+                new = old & ~SCR_PHP_V;
+                set_scr(ice, new);
+                /* turn phantom off, = 1 */
+                new |= SCR_PHP;
+                set_scr(ice, new);
+        }
+        if (old != new)
+                return 1;
+        /* no change */
+        return 0;
+}
+
+#define PRIV_SW(xid, xbit, xreg)        [xid] = {.bit = xbit,\
+        .set_register = set_##xreg,\
+        .get_register = get_##xreg, }
+
+
+#define PRIV_ENUM2(xid, xbit, xreg, xtext1, xtext2)     [xid] = {.bit = xbit,\
+        .set_register = set_##xreg,\
+        .get_register = get_##xreg,\
+        .texts = {xtext1, xtext2} }
+
+static struct qtet_kcontrol_private qtet_privates[] = {
+        PRIV_ENUM2(IN12_SEL, CPLD_IN12_SEL, cpld, "An In 1/2", "An In 3/4"),
+        PRIV_ENUM2(IN34_SEL, CPLD_IN34_SEL, cpld, "An In 3/4", "IEC958 In"),
+        PRIV_ENUM2(AIN34_SEL, SCR_AIN34_SEL, scr, "Line In 3/4", "Hi-Z"),
+        PRIV_ENUM2(COAX_OUT, CPLD_COAX_OUT, cpld, "IEC958", "I2S"),
+        PRIV_SW(IN12_MON12, MCR_IN12_MON12, mcr),
+        PRIV_SW(IN12_MON34, MCR_IN12_MON34, mcr),
+        PRIV_SW(IN34_MON12, MCR_IN34_MON12, mcr),
+        PRIV_SW(IN34_MON34, MCR_IN34_MON34, mcr),
+        PRIV_SW(OUT12_MON34, MCR_OUT12_MON34, mcr),
+        PRIV_SW(OUT34_MON12, MCR_OUT34_MON12, mcr),
+};
+
+static int qtet_enum_info(struct snd_kcontrol *kcontrol,
+                struct snd_ctl_elem_info *uinfo)
+{
+        struct qtet_kcontrol_private private =
+                qtet_privates[kcontrol->private_value];
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        uinfo->count = 1;
+        uinfo->value.enumerated.items = ARRAY_SIZE(private.texts);
+
+        if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
+                uinfo->value.enumerated.item =
+                        uinfo->value.enumerated.items - 1;
+        strcpy(uinfo->value.enumerated.name,
+                        private.texts[uinfo->value.enumerated.item]);
+
+        return 0;
+}
+
+static int qtet_sw_get(struct snd_kcontrol *kcontrol,
+                struct snd_ctl_elem_value *ucontrol)
+{
+        struct qtet_kcontrol_private private =
+                qtet_privates[kcontrol->private_value];
+        struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
+        ucontrol->value.integer.value[0] =
+                (private.get_register(ice) & private.bit) ? 1 : 0;
+        return 0;
+}
+
+static int qtet_sw_put(struct snd_kcontrol *kcontrol,
+                struct snd_ctl_elem_value *ucontrol)
+{
+        struct qtet_kcontrol_private private =
+                qtet_privates[kcontrol->private_value];
+        struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);
+        unsigned int old, new;
+        old = private.get_register(ice);
+        if (ucontrol->value.integer.value[0])
+                new = old | private.bit;
+        else
+                new = old & ~private.bit;
+        if (old != new) {
+                private.set_register(ice, new);
+                return 1;
+        }
+        /* no change */
+        return 0;
+}
+
+#define qtet_sw_info    snd_ctl_boolean_mono_info
+
+#define QTET_CONTROL(xname, xtype, xpriv)       \
+        {.iface = SNDRV_CTL_ELEM_IFACE_MIXER,\
+        .name = xname,\
+        .info = qtet_##xtype##_info,\
+        .get = qtet_sw_get,\
+        .put = qtet_sw_put,\
+        .private_value = xpriv }
+
+static struct snd_kcontrol_new qtet_controls[] __devinitdata = {
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Master Playback Switch",
+                .info = qtet_sw_info,
+                .get = qtet_mute_get,
+                .put = qtet_mute_put,
+                .private_value = 0
+        },
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Phantom Power",
+                .info = qtet_sw_info,
+                .get = qtet_php_get,
+                .put = qtet_php_put,
+                .private_value = 0
+        },
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Analog In 1/2 Capture Switch",
+                .info = qtet_ain12_enum_info,
+                .get = qtet_ain12_sw_get,
+                .put = qtet_ain12_sw_put,
+                .private_value = 0
+        },
+        QTET_CONTROL("Analog In 3/4 Capture Switch", enum, AIN34_SEL),
+        QTET_CONTROL("PCM In 1/2 Capture Switch", enum, IN12_SEL),
+        QTET_CONTROL("PCM In 3/4 Capture Switch", enum, IN34_SEL),
+        QTET_CONTROL("Coax Output Source", enum, COAX_OUT),
+        QTET_CONTROL("Analog In 1/2 to Monitor 1/2", sw, IN12_MON12),
+        QTET_CONTROL("Analog In 1/2 to Monitor 3/4", sw, IN12_MON34),
+        QTET_CONTROL("Analog In 3/4 to Monitor 1/2", sw, IN34_MON12),
+        QTET_CONTROL("Analog In 3/4 to Monitor 3/4", sw, IN34_MON34),
+        QTET_CONTROL("Output 1/2 to Monitor 3/4", sw, OUT12_MON34),
+        QTET_CONTROL("Output 3/4 to Monitor 1/2", sw, OUT34_MON12),
+};
+
+static char *slave_vols[] __devinitdata = {
+        PCM_12_PLAYBACK_VOLUME,
+        PCM_34_PLAYBACK_VOLUME,
+        NULL
+};
+
+static __devinitdata
+DECLARE_TLV_DB_SCALE(qtet_master_db_scale, -6350, 50, 1);
+
+static struct snd_kcontrol __devinit *ctl_find(struct snd_card *card,
+                const char *name)
+{
+        struct snd_ctl_elem_id sid;
+        memset(&sid, 0, sizeof(sid));
+        /* FIXME: strcpy is bad. */
+        strcpy(sid.name, name);
+        sid.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
+        return snd_ctl_find_id(card, &sid);
+}
+
+static void __devinit add_slaves(struct snd_card *card,
+                struct snd_kcontrol *master, char **list)
+{
+        for (; *list; list++) {
+                struct snd_kcontrol *slave = ctl_find(card, *list);
+                if (slave)
+                        snd_ctl_add_slave(master, slave);
+        }
+}
+
+static int __devinit qtet_add_controls(struct snd_ice1712 *ice)
+{
+        struct qtet_spec *spec = ice->spec;
+        int err, i;
+        struct snd_kcontrol *vmaster;
+        err = snd_ice1712_akm4xxx_build_controls(ice);
+        if (err < 0)
+                return err;
+        for (i = 0; i < ARRAY_SIZE(qtet_controls); i++) {
+                err = snd_ctl_add(ice->card,
+                                snd_ctl_new1(&qtet_controls[i], ice));
+                if (err < 0)
+                        return err;
+        }
+
+        /* Create virtual master control */
+        vmaster = snd_ctl_make_virtual_master("Master Playback Volume",
+                        qtet_master_db_scale);
+        if (!vmaster)
+                return -ENOMEM;
+        add_slaves(ice->card, vmaster, slave_vols);
+        err = snd_ctl_add(ice->card, vmaster);
+        if (err < 0)
+                return err;
+        /* only capture SPDIF over AK4113 */
+        err = snd_ak4113_build(spec->ak4113,
+                        ice->pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream);
+        if (err < 0)
+                return err;
+        return 0;
+}
+
+static inline int qtet_is_spdif_master(struct snd_ice1712 *ice)
+{
+        /* CPLD_SYNC_SEL: 0 = internal, 1 = external (i.e. spdif master) */
+        return (get_cpld(ice) & CPLD_SYNC_SEL) ? 1 : 0;
+}
+
+static unsigned int qtet_get_rate(struct snd_ice1712 *ice)
+{
+        int i;
+        unsigned char result;
+
+        result =  get_cpld(ice) & CPLD_CKS_MASK;
+        for (i = 0; i < ARRAY_SIZE(cks_vals); i++)
+                if (cks_vals[i] == result)
+                        return qtet_rates[i];
+        return 0;
+}
+
+static int get_cks_val(int rate)
+{
+        int i;
+        for (i = 0; i < ARRAY_SIZE(qtet_rates); i++)
+                if (qtet_rates[i] == rate)
+                        return cks_vals[i];
+        return 0;
+}
+
+/* setting new rate */
+static void qtet_set_rate(struct snd_ice1712 *ice, unsigned int rate)
+{
+        unsigned int new;
+        unsigned char val;
+        /* switching ice1724 to external clock - supplied by ext. circuits */
+        val = inb(ICEMT1724(ice, RATE));
+        outb(val | VT1724_SPDIF_MASTER, ICEMT1724(ice, RATE));
+
+        new =  (get_cpld(ice) & ~CPLD_CKS_MASK) | get_cks_val(rate);
+        /* switch to internal clock, drop CPLD_SYNC_SEL */
+        new &= ~CPLD_SYNC_SEL;
+        /* printk(KERN_DEBUG "QT - set_rate: old %x, new %x\n",
+           get_cpld(ice), new); */
+        set_cpld(ice, new);
+}
+
+static inline unsigned char qtet_set_mclk(struct snd_ice1712 *ice,
+                unsigned int rate)
+{
+        /* no change in master clock */
+        return 0;
+}
+
+/* setting clock to external - SPDIF */
+static int qtet_set_spdif_clock(struct snd_ice1712 *ice, int type)
+{
+        unsigned int old, new;
+
+        old = new = get_cpld(ice);
+        new &= ~(CPLD_CKS_MASK | CPLD_WORD_SEL);
+        switch (type) {
+        case EXT_SPDIF_TYPE:
+                new |= CPLD_EXT_SPDIF;
+                break;
+        case EXT_WORDCLOCK_1FS_TYPE:
+                new |= CPLD_EXT_WORDCLOCK_1FS;
+                break;
+        case EXT_WORDCLOCK_256FS_TYPE:
+                new |= CPLD_EXT_WORDCLOCK_256FS;
+                break;
+        default:
+                snd_BUG();
+        }
+        if (old != new) {
+                set_cpld(ice, new);
+                /* changed */
+                return 1;
+        }
+        return 0;
+}
+
+static int qtet_get_spdif_master_type(struct snd_ice1712 *ice)
+{
+        unsigned int val;
+        int result;
+        val = get_cpld(ice);
+        /* checking only rate/clock-related bits */
+        val &= (CPLD_CKS_MASK | CPLD_WORD_SEL | CPLD_SYNC_SEL);
+        if (!(val & CPLD_SYNC_SEL)) {
+                /* switched to internal clock, is not any external type */
+                result = -1;
+        } else {
+                switch (val) {
+                case (CPLD_EXT_SPDIF):
+                        result = EXT_SPDIF_TYPE;
+                        break;
+                case (CPLD_EXT_WORDCLOCK_1FS):
+                        result = EXT_WORDCLOCK_1FS_TYPE;
+                        break;
+                case (CPLD_EXT_WORDCLOCK_256FS):
+                        result = EXT_WORDCLOCK_256FS_TYPE;
+                        break;
+                default:
+                        /* undefined combination of external clock setup */
+                        snd_BUG();
+                        result = 0;
+                }
+        }
+        return result;
+}
+
+/* Called when ak4113 detects change in the input SPDIF stream */
+static void qtet_ak4113_change(struct ak4113 *ak4113, unsigned char c0,
+                unsigned char c1)
+{
+        struct snd_ice1712 *ice = ak4113->change_callback_private;
+        int rate;
+        if ((qtet_get_spdif_master_type(ice) == EXT_SPDIF_TYPE) &&
+                        c1) {
+                /* only for SPDIF master mode, rate was changed */
+                rate = snd_ak4113_external_rate(ak4113);
+                /* printk(KERN_DEBUG "ak4113 - input rate changed to %d\n",
+                   rate); */
+                qtet_akm_set_rate_val(ice->akm, rate);
+        }
+}
+
+/*
+ * If clock slaved to SPDIF-IN, setting runtime rate
+ * to the detected external rate
+ */
+static void qtet_spdif_in_open(struct snd_ice1712 *ice,
+                struct snd_pcm_substream *substream)
+{
+        struct qtet_spec *spec = ice->spec;
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        int rate;
+
+        if (qtet_get_spdif_master_type(ice) != EXT_SPDIF_TYPE)
+                /* not external SPDIF, no rate limitation */
+                return;
+        /* only external SPDIF can detect incoming sample rate */
+        rate = snd_ak4113_external_rate(spec->ak4113);
+        if (rate >= runtime->hw.rate_min && rate <= runtime->hw.rate_max) {
+                runtime->hw.rate_min = rate;
+                runtime->hw.rate_max = rate;
+        }
+}
+
+/*
+ * initialize the chip
+ */
+static int __devinit qtet_init(struct snd_ice1712 *ice)
+{
+        static const unsigned char ak4113_init_vals[] = {
+                /* AK4113_REG_PWRDN */  AK4113_RST | AK4113_PWN |
+                        AK4113_OCKS0 | AK4113_OCKS1,
+                /* AK4113_REQ_FORMAT */ AK4113_DIF_I24I2S | AK4113_VTX |
+                        AK4113_DEM_OFF | AK4113_DEAU,
+                /* AK4113_REG_IO0 */    AK4113_OPS2 | AK4113_TXE |
+                        AK4113_XTL_24_576M,
+                /* AK4113_REG_IO1 */    AK4113_EFH_1024LRCLK | AK4113_IPS(0),
+                /* AK4113_REG_INT0_MASK */      0,
+                /* AK4113_REG_INT1_MASK */      0,
+                /* AK4113_REG_DATDTS */         0,
+        };
+        int err;
+        struct qtet_spec *spec;
+        struct snd_akm4xxx *ak;
+        unsigned char val;
+
+        /* switching ice1724 to external clock - supplied by ext. circuits */
+        val = inb(ICEMT1724(ice, RATE));
+        outb(val | VT1724_SPDIF_MASTER, ICEMT1724(ice, RATE));
+
+        spec = kzalloc(sizeof(*spec), GFP_KERNEL);
+        if (!spec)
+                return -ENOMEM;
+        /* qtet is clocked by Xilinx array */
+        ice->hw_rates = &qtet_rates_info;
+        ice->is_spdif_master = qtet_is_spdif_master;
+        ice->get_rate = qtet_get_rate;
+        ice->set_rate = qtet_set_rate;
+        ice->set_mclk = qtet_set_mclk;
+        ice->set_spdif_clock = qtet_set_spdif_clock;
+        ice->get_spdif_master_type = qtet_get_spdif_master_type;
+        ice->ext_clock_names = ext_clock_names;
+        ice->ext_clock_count = ARRAY_SIZE(ext_clock_names);
+        /* since Qtet can detect correct SPDIF-in rate, all streams can be
+         * limited to this specific rate */
+        ice->spdif.ops.open = ice->pro_open = qtet_spdif_in_open;
+        ice->spec = spec;
+
+        /* Mute Off */
+        /* SCR Initialize*/
+        /* keep codec power down first */
+        set_scr(ice, SCR_PHP);
+        udelay(1);
+        /* codec power up */
+        set_scr(ice, SCR_PHP | SCR_CODEC_PDN);
+
+        /* MCR Initialize */
+        set_mcr(ice, 0);
+
+        /* CPLD Initialize */
+        set_cpld(ice, 0);
+
+
+        ice->num_total_dacs = 2;
+        ice->num_total_adcs = 2;
+
+        ice->akm = kcalloc(2, sizeof(struct snd_akm4xxx), GFP_KERNEL);
+        ak = ice->akm;
+        if (!ak)
+                return -ENOMEM;
+        /* only one codec with two chips */
+        ice->akm_codecs = 1;
+        err = snd_ice1712_akm4xxx_init(ak, &akm_qtet_dac, NULL, ice);
+        if (err < 0)
+                return err;
+        err = snd_ak4113_create(ice->card,
+                        qtet_ak4113_read,
+                        qtet_ak4113_write,
+                        ak4113_init_vals,
+                        ice, &spec->ak4113);
+        if (err < 0)
+                return err;
+        /* callback for codecs rate setting */
+        spec->ak4113->change_callback = qtet_ak4113_change;
+        spec->ak4113->change_callback_private = ice;
+        /* AK41143 in Quartet can detect external rate correctly
+         * (i.e. check_flags = 0) */
+        spec->ak4113->check_flags = 0;
+
+        proc_init(ice);
+
+        qtet_set_rate(ice, 44100);
+        return 0;
+}
+
+static unsigned char qtet_eeprom[] __devinitdata = {
+        [ICE_EEP2_SYSCONF]     = 0x28,  /* clock 256(24MHz), mpu401, 1xADC,
+                                           1xDACs, SPDIF in */
+        [ICE_EEP2_ACLINK]      = 0x80,  /* I2S */
+        [ICE_EEP2_I2S]         = 0x78,  /* 96k, 24bit, 192k */
+        [ICE_EEP2_SPDIF]       = 0xc3,  /* out-en, out-int, in, out-ext */
+        [ICE_EEP2_GPIO_DIR]    = 0x00,  /* 0-7 inputs, switched to output
+                                           only during output operations */
+        [ICE_EEP2_GPIO_DIR1]   = 0xff,  /* 8-15 outputs */
+        [ICE_EEP2_GPIO_DIR2]   = 0x00,
+        [ICE_EEP2_GPIO_MASK]   = 0xff,  /* changed only for OUT operations */
+        [ICE_EEP2_GPIO_MASK1]  = 0x00,
+        [ICE_EEP2_GPIO_MASK2]  = 0xff,
+
+        [ICE_EEP2_GPIO_STATE]  = 0x00, /* inputs */
+        [ICE_EEP2_GPIO_STATE1] = 0x7d, /* all 1, but GPIO_CPLD_RW
+                                          and GPIO15 always zero */
+        [ICE_EEP2_GPIO_STATE2] = 0x00, /* inputs */
+};
+
+/* entry point */
+struct snd_ice1712_card_info snd_vt1724_qtet_cards[] __devinitdata = {
+        {
+                .subvendor = VT1724_SUBDEVICE_QTET,
+                .name = "Infrasonic Quartet",
+                .model = "quartet",
+                .chip_init = qtet_init,
+                .build_controls = qtet_add_controls,
+                .eeprom_size = sizeof(qtet_eeprom),
+                .eeprom_data = qtet_eeprom,
+        },
+        { } /* terminator */
+};
diff --git a/sound/pci/ice1712/quartet.h b/sound/pci/ice1712/quartet.h
new file mode 100644
index 000000000000..80809b72439a
--- /dev/null
+++ b/sound/pci/ice1712/quartet.h
@@ -0,0 +1,10 @@
+#ifndef __SOUND_QTET_H
+#define __SOUND_QTET_H
+
+#define QTET_DEVICE_DESC                "{Infrasonic,Quartet},"
+
+#define VT1724_SUBDEVICE_QTET           0x30305349      /* Infrasonic Quartet */
+
+extern struct snd_ice1712_card_info  snd_vt1724_qtet_cards[];
+
+#endif  /* __SOUND_QTET_H */
diff --git a/sound/pci/ice1712/vt1720_mobo.c b/sound/pci/ice1712/vt1720_mobo.c
index 7f9674b641c0..4c551e147c08 100644
--- a/sound/pci/ice1712/vt1720_mobo.c
+++ b/sound/pci/ice1712/vt1720_mobo.c
@@ -25,7 +25,6 @@
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
-#include <linux/slab.h>
 #include <sound/core.h>
 
 #include "ice1712.h"
diff --git a/sound/pci/ice1712/wtm.c b/sound/pci/ice1712/wtm.c
index 5af9e84456d1..e618f789026e 100644
--- a/sound/pci/ice1712/wtm.c
+++ b/sound/pci/ice1712/wtm.c
@@ -29,7 +29,6 @@
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
-#include <linux/slab.h>
 #include <sound/core.h>
 
 #include "ice1712.h"
diff --git a/sound/pci/intel8x0.c b/sound/pci/intel8x0.c
index aac20fb4aad2..6433e65c9507 100644
--- a/sound/pci/intel8x0.c
+++ b/sound/pci/intel8x0.c
@@ -420,7 +420,7 @@ struct intel8x0 {
         u32 int_sta_mask;               /* interrupt status mask */
 };
 
-static struct pci_device_id snd_intel8x0_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_intel8x0_ids) = {
         { PCI_VDEVICE(INTEL, 0x2415), DEVICE_INTEL },   /* 82801AA */
         { PCI_VDEVICE(INTEL, 0x2425), DEVICE_INTEL },   /* 82901AB */
         { PCI_VDEVICE(INTEL, 0x2445), DEVICE_INTEL },   /* 82801BA */
@@ -2063,6 +2063,12 @@ static struct ac97_quirk ac97_quirks[] __devinitdata = {
                 .type = AC97_TUNE_HP_ONLY
         },
         {
+                .subvendor = 0x161f,
+                .subdevice = 0x203a,
+                .name = "Gateway 4525GZ",               /* AD1981B */
+                .type = AC97_TUNE_INV_EAPD
+        },
+        {
                 .subvendor = 0x1734,
                 .subdevice = 0x0088,
                 .name = "Fujitsu-Siemens D1522",        /* AD1981 */
diff --git a/sound/pci/intel8x0m.c b/sound/pci/intel8x0m.c
index 9e7d12e7673f..13cec1e5ced9 100644
--- a/sound/pci/intel8x0m.c
+++ b/sound/pci/intel8x0m.c
@@ -219,7 +219,7 @@ struct intel8x0m {
         unsigned int pcm_pos_shift;
 };
 
-static struct pci_device_id snd_intel8x0m_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_intel8x0m_ids) = {
         { PCI_VDEVICE(INTEL, 0x2416), DEVICE_INTEL },   /* 82801AA */
         { PCI_VDEVICE(INTEL, 0x2426), DEVICE_INTEL },   /* 82901AB */
         { PCI_VDEVICE(INTEL, 0x2446), DEVICE_INTEL },   /* 82801BA */
diff --git a/sound/pci/korg1212/korg1212.c b/sound/pci/korg1212/korg1212.c
index 7cc38a11e997..6d795700be79 100644
--- a/sound/pci/korg1212/korg1212.c
+++ b/sound/pci/korg1212/korg1212.c
@@ -418,7 +418,7 @@ module_param_array(enable, bool, NULL, 0444);
 MODULE_PARM_DESC(enable, "Enable Korg 1212 soundcard.");
 MODULE_AUTHOR("Haroldo Gamal <gamal@alternex.com.br>");
 
-static struct pci_device_id snd_korg1212_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_korg1212_ids) = {
         {
                 .vendor    = 0x10b5,
                 .device    = 0x906d,
diff --git a/sound/pci/lx6464es/lx6464es.c b/sound/pci/lx6464es/lx6464es.c
index 11b8c6514b3d..ef9af3f4ace2 100644
--- a/sound/pci/lx6464es/lx6464es.c
+++ b/sound/pci/lx6464es/lx6464es.c
@@ -26,6 +26,7 @@
 #include <linux/init.h>
 #include <linux/pci.h>
 #include <linux/delay.h>
+#include <linux/slab.h>
 
 #include <sound/initval.h>
 #include <sound/control.h>
@@ -55,7 +56,7 @@ static const char card_name[] = "LX6464ES";
 
 #define PCI_DEVICE_ID_PLX_LX6464ES              PCI_DEVICE_ID_PLX_9056
 
-static struct pci_device_id snd_lx6464es_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_lx6464es_ids) = {
         { PCI_DEVICE(PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_LX6464ES),
           .subvendor = PCI_VENDOR_ID_DIGIGRAM,
           .subdevice = PCI_SUBDEVICE_ID_DIGIGRAM_LX6464ES_SERIAL_SUBSYSTEM
diff --git a/sound/pci/maestro3.c b/sound/pci/maestro3.c
index 75283fbb4b3f..b56e33676780 100644
--- a/sound/pci/maestro3.c
+++ b/sound/pci/maestro3.c
@@ -849,6 +849,7 @@ struct snd_m3 {
         struct snd_kcontrol *master_switch;
         struct snd_kcontrol *master_volume;
         struct tasklet_struct hwvol_tq;
+        unsigned int in_suspend;
 
 #ifdef CONFIG_PM
         u16 *suspend_mem;
@@ -861,7 +862,7 @@ struct snd_m3 {
 /*
  * pci ids
  */
-static struct pci_device_id snd_m3_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_m3_ids) = {
         {PCI_VENDOR_ID_ESS, PCI_DEVICE_ID_ESS_ALLEGRO_1, PCI_ANY_ID, PCI_ANY_ID,
          PCI_CLASS_MULTIMEDIA_AUDIO << 8, 0xffff00, 0},
         {PCI_VENDOR_ID_ESS, PCI_DEVICE_ID_ESS_ALLEGRO, PCI_ANY_ID, PCI_ANY_ID,
@@ -884,6 +885,7 @@ static struct pci_device_id snd_m3_ids[] = {
 MODULE_DEVICE_TABLE(pci, snd_m3_ids);
 
 static struct snd_pci_quirk m3_amp_quirk_list[] __devinitdata = {
+        SND_PCI_QUIRK(0x0E11, 0x0094, "Compaq Evo N600c", 0x0c),
         SND_PCI_QUIRK(0x10f7, 0x833e, "Panasonic CF-28", 0x0d),
         SND_PCI_QUIRK(0x10f7, 0x833d, "Panasonic CF-72", 0x0d),
         SND_PCI_QUIRK(0x1033, 0x80f1, "NEC LM800J/7", 0x03),
@@ -1613,6 +1615,11 @@ static void snd_m3_update_hw_volume(unsigned long private_data)
         outb(0x88, chip->iobase + SHADOW_MIX_REG_MASTER);
         outb(0x88, chip->iobase + HW_VOL_COUNTER_MASTER);
 
+        /* Ignore spurious HV interrupts during suspend / resume, this avoids
+           mistaking them for a mute button press. */
+        if (chip->in_suspend)
+                return;
+
         if (!chip->master_switch || !chip->master_volume)
                 return;
 
@@ -2424,6 +2431,7 @@ static int m3_suspend(struct pci_dev *pci, pm_message_t state)
         if (chip->suspend_mem == NULL)
                 return 0;
 
+        chip->in_suspend = 1;
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
         snd_pcm_suspend_all(chip->pcm);
         snd_ac97_suspend(chip->ac97);
@@ -2497,6 +2505,7 @@ static int m3_resume(struct pci_dev *pci)
         snd_m3_hv_init(chip);
 
         snd_power_change_state(card, SNDRV_CTL_POWER_D0);
+        chip->in_suspend = 0;
         return 0;
 }
 #endif /* CONFIG_PM */
diff --git a/sound/pci/mixart/mixart.c b/sound/pci/mixart/mixart.c
index a83d1968a845..3be8f97c8bc0 100644
--- a/sound/pci/mixart/mixart.c
+++ b/sound/pci/mixart/mixart.c
@@ -27,6 +27,7 @@
 #include <linux/dma-mapping.h>
 #include <linux/moduleparam.h>
 #include <linux/mutex.h>
+#include <linux/slab.h>
 
 #include <sound/core.h>
 #include <sound/initval.h>
@@ -60,7 +61,7 @@ MODULE_PARM_DESC(enable, "Enable Digigram " CARD_NAME " soundcard.");
 /*
  */
 
-static struct pci_device_id snd_mixart_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_mixart_ids) = {
         { PCI_VDEVICE(MOTOROLA, 0x0003), 0, }, /* MC8240 */
         { 0, }
 };
@@ -1161,13 +1162,15 @@ static long snd_mixart_BA0_read(struct snd_info_entry *entry, void *file_private
                                 unsigned long count, unsigned long pos)
 {
         struct mixart_mgr *mgr = entry->private_data;
+        unsigned long maxsize;
 
-        count = count & ~3; /* make sure the read size is a multiple of 4 bytes */
-        if(count <= 0)
+        if (pos >= MIXART_BA0_SIZE)
                 return 0;
-        if(pos + count > MIXART_BA0_SIZE)
-                count = (long)(MIXART_BA0_SIZE - pos);
-        if(copy_to_user_fromio(buf, MIXART_MEM( mgr, pos ), count))
+        maxsize = MIXART_BA0_SIZE - pos;
+        if (count > maxsize)
+                count = maxsize;
+        count = count & ~3; /* make sure the read size is a multiple of 4 bytes */
+        if (copy_to_user_fromio(buf, MIXART_MEM(mgr, pos), count))
                 return -EFAULT;
         return count;
 }
@@ -1180,13 +1183,15 @@ static long snd_mixart_BA1_read(struct snd_info_entry *entry, void *file_private
                                 unsigned long count, unsigned long pos)
 {
         struct mixart_mgr *mgr = entry->private_data;
+        unsigned long maxsize;
 
-        count = count & ~3; /* make sure the read size is a multiple of 4 bytes */
-        if(count <= 0)
+        if (pos > MIXART_BA1_SIZE)
                 return 0;
-        if(pos + count > MIXART_BA1_SIZE)
-                count = (long)(MIXART_BA1_SIZE - pos);
-        if(copy_to_user_fromio(buf, MIXART_REG( mgr, pos ), count))
+        maxsize = MIXART_BA1_SIZE - pos;
+        if (count > maxsize)
+                count = maxsize;
+        count = count & ~3; /* make sure the read size is a multiple of 4 bytes */
+        if (copy_to_user_fromio(buf, MIXART_REG(mgr, pos), count))
                 return -EFAULT;
         return count;
 }
diff --git a/sound/pci/mixart/mixart_hwdep.c b/sound/pci/mixart/mixart_hwdep.c
index 4cf4cd8c939c..bf2696aa5d49 100644
--- a/sound/pci/mixart/mixart_hwdep.c
+++ b/sound/pci/mixart/mixart_hwdep.c
@@ -24,6 +24,7 @@
 #include <linux/pci.h>
 #include <linux/firmware.h>
 #include <linux/vmalloc.h>
+#include <linux/slab.h>
 #include <asm/io.h>
 #include <sound/core.h>
 #include "mixart.h"
diff --git a/sound/pci/nm256/nm256.c b/sound/pci/nm256/nm256.c
index 97a0731331a1..5a60492ac7b3 100644
--- a/sound/pci/nm256/nm256.c
+++ b/sound/pci/nm256/nm256.c
@@ -262,7 +262,7 @@ struct nm256 {
 /*
  * PCI ids
  */
-static struct pci_device_id snd_nm256_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_nm256_ids) = {
         {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},
diff --git a/sound/pci/oxygen/Makefile b/sound/pci/oxygen/Makefile
index 4ba07d42fd1d..acd8f15f7bff 100644
--- a/sound/pci/oxygen/Makefile
+++ b/sound/pci/oxygen/Makefile
@@ -1,7 +1,8 @@
 snd-oxygen-lib-objs := oxygen_io.o oxygen_lib.o oxygen_mixer.o oxygen_pcm.o
 snd-hifier-objs := hifier.o
 snd-oxygen-objs := oxygen.o
-snd-virtuoso-objs := virtuoso.o
+snd-virtuoso-objs := virtuoso.o xonar_lib.o \
+        xonar_pcm179x.o xonar_cs43xx.o xonar_wm87x6.o xonar_hdmi.o
 
 obj-$(CONFIG_SND_OXYGEN_LIB) += snd-oxygen-lib.o
 obj-$(CONFIG_SND_HIFIER) += snd-hifier.o
diff --git a/sound/pci/oxygen/cs2000.h b/sound/pci/oxygen/cs2000.h
new file mode 100644
index 000000000000..c3501bdb5edc
--- /dev/null
+++ b/sound/pci/oxygen/cs2000.h
@@ -0,0 +1,83 @@
+#ifndef CS2000_H_INCLUDED
+#define CS2000_H_INCLUDED
+
+#define CS2000_DEV_ID           0x01
+#define CS2000_DEV_CTRL         0x02
+#define CS2000_DEV_CFG_1        0x03
+#define CS2000_DEV_CFG_2        0x04
+#define CS2000_GLOBAL_CFG       0x05
+#define CS2000_RATIO_0          0x06 /* 32 bits, big endian */
+#define CS2000_RATIO_1          0x0a
+#define CS2000_RATIO_2          0x0e
+#define CS2000_RATIO_3          0x12
+#define CS2000_FUN_CFG_1        0x16
+#define CS2000_FUN_CFG_2        0x17
+#define CS2000_FUN_CFG_3        0x1e
+
+/* DEV_ID */
+#define CS2000_DEVICE_MASK              0xf8
+#define CS2000_REVISION_MASK            0x07
+
+/* DEV_CTRL */
+#define CS2000_UNLOCK                   0x80
+#define CS2000_AUX_OUT_DIS              0x02
+#define CS2000_CLK_OUT_DIS              0x01
+
+/* DEV_CFG_1 */
+#define CS2000_R_MOD_SEL_MASK           0xe0
+#define CS2000_R_MOD_SEL_1              0x00
+#define CS2000_R_MOD_SEL_2              0x20
+#define CS2000_R_MOD_SEL_4              0x40
+#define CS2000_R_MOD_SEL_8              0x60
+#define CS2000_R_MOD_SEL_1_2            0x80
+#define CS2000_R_MOD_SEL_1_4            0xa0
+#define CS2000_R_MOD_SEL_1_8            0xc0
+#define CS2000_R_MOD_SEL_1_16           0xe0
+#define CS2000_R_SEL_MASK               0x18
+#define CS2000_R_SEL_SHIFT              3
+#define CS2000_AUX_OUT_SRC_MASK         0x06
+#define CS2000_AUX_OUT_SRC_REF_CLK      0x00
+#define CS2000_AUX_OUT_SRC_CLK_IN       0x02
+#define CS2000_AUX_OUT_SRC_CLK_OUT      0x04
+#define CS2000_AUX_OUT_SRC_PLL_LOCK     0x06
+#define CS2000_EN_DEV_CFG_1             0x01
+
+/* DEV_CFG_2 */
+#define CS2000_LOCK_CLK_MASK            0x06
+#define CS2000_LOCK_CLK_SHIFT           1
+#define CS2000_FRAC_N_SRC_MASK          0x01
+#define CS2000_FRAC_N_SRC_STATIC        0x00
+#define CS2000_FRAC_N_SRC_DYNAMIC       0x01
+
+/* GLOBAL_CFG */
+#define CS2000_FREEZE                   0x08
+#define CS2000_EN_DEV_CFG_2             0x01
+
+/* FUN_CFG_1 */
+#define CS2000_CLK_SKIP_EN              0x80
+#define CS2000_AUX_LOCK_CFG_MASK        0x40
+#define CS2000_AUX_LOCK_CFG_PP_HIGH     0x00
+#define CS2000_AUX_LOCK_CFG_OD_LOW      0x40
+#define CS2000_REF_CLK_DIV_MASK         0x18
+#define CS2000_REF_CLK_DIV_4            0x00
+#define CS2000_REF_CLK_DIV_2            0x08
+#define CS2000_REF_CLK_DIV_1            0x10
+
+/* FUN_CFG_2 */
+#define CS2000_CLK_OUT_UNL              0x10
+#define CS2000_L_F_RATIO_CFG_MASK       0x08
+#define CS2000_L_F_RATIO_CFG_20_12      0x00
+#define CS2000_L_F_RATIO_CFG_12_20      0x08
+
+/* FUN_CFG_3 */
+#define CS2000_CLK_IN_BW_MASK           0x70
+#define CS2000_CLK_IN_BW_1              0x00
+#define CS2000_CLK_IN_BW_2              0x10
+#define CS2000_CLK_IN_BW_4              0x20
+#define CS2000_CLK_IN_BW_8              0x30
+#define CS2000_CLK_IN_BW_16             0x40
+#define CS2000_CLK_IN_BW_32             0x50
+#define CS2000_CLK_IN_BW_64             0x60
+#define CS2000_CLK_IN_BW_128            0x70
+
+#endif
diff --git a/sound/pci/oxygen/hifier.c b/sound/pci/oxygen/hifier.c
index 84ef13183419..5a87d683691f 100644
--- a/sound/pci/oxygen/hifier.c
+++ b/sound/pci/oxygen/hifier.c
@@ -17,6 +17,12 @@
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  */
 
+/*
+ * CMI8788:
+ *
+ * SPI 0 -> AK4396
+ */
+
 #include <linux/delay.h>
 #include <linux/pci.h>
 #include <sound/control.h>
@@ -42,7 +48,7 @@ MODULE_PARM_DESC(id, "ID string");
 module_param_array(enable, bool, NULL, 0444);
 MODULE_PARM_DESC(enable, "enable card");
 
-static struct pci_device_id hifier_ids[] __devinitdata = {
+static DEFINE_PCI_DEVICE_TABLE(hifier_ids) = {
         { OXYGEN_PCI_SUBID(0x14c3, 0x1710) },
         { OXYGEN_PCI_SUBID(0x14c3, 0x1711) },
         { OXYGEN_PCI_SUBID_BROKEN_EEPROM },
@@ -51,23 +57,28 @@ static struct pci_device_id hifier_ids[] __devinitdata = {
 MODULE_DEVICE_TABLE(pci, hifier_ids);
 
 struct hifier_data {
-        u8 ak4396_ctl2;
+        u8 ak4396_regs[5];
 };
 
 static void ak4396_write(struct oxygen *chip, u8 reg, u8 value)
 {
+        struct hifier_data *data = chip->model_data;
+
         oxygen_write_spi(chip, OXYGEN_SPI_TRIGGER  |
                          OXYGEN_SPI_DATA_LENGTH_2 |
                          OXYGEN_SPI_CLOCK_160 |
                          (0 << OXYGEN_SPI_CODEC_SHIFT) |
                          OXYGEN_SPI_CEN_LATCH_CLOCK_HI,
                          AK4396_WRITE | (reg << 8) | value);
+        data->ak4396_regs[reg] = value;
 }
 
-static void update_ak4396_volume(struct oxygen *chip)
+static void ak4396_write_cached(struct oxygen *chip, u8 reg, u8 value)
 {
-        ak4396_write(chip, AK4396_LCH_ATT, chip->dac_volume[0]);
-        ak4396_write(chip, AK4396_RCH_ATT, chip->dac_volume[1]);
+        struct hifier_data *data = chip->model_data;
+
+        if (value != data->ak4396_regs[reg])
+                ak4396_write(chip, reg, value);
 }
 
 static void hifier_registers_init(struct oxygen *chip)
@@ -75,16 +86,19 @@ static void hifier_registers_init(struct oxygen *chip)
         struct hifier_data *data = chip->model_data;
 
         ak4396_write(chip, AK4396_CONTROL_1, AK4396_DIF_24_MSB | AK4396_RSTN);
-        ak4396_write(chip, AK4396_CONTROL_2, data->ak4396_ctl2);
+        ak4396_write(chip, AK4396_CONTROL_2,
+                     data->ak4396_regs[AK4396_CONTROL_2]);
         ak4396_write(chip, AK4396_CONTROL_3, AK4396_PCM);
-        update_ak4396_volume(chip);
+        ak4396_write(chip, AK4396_LCH_ATT, chip->dac_volume[0]);
+        ak4396_write(chip, AK4396_RCH_ATT, chip->dac_volume[1]);
 }
 
 static void hifier_init(struct oxygen *chip)
 {
         struct hifier_data *data = chip->model_data;
 
-        data->ak4396_ctl2 = AK4396_SMUTE | AK4396_DEM_OFF | AK4396_DFS_NORMAL;
+        data->ak4396_regs[AK4396_CONTROL_2] =
+                AK4396_SMUTE | AK4396_DEM_OFF | AK4396_DFS_NORMAL;
         hifier_registers_init(chip);
 
         snd_component_add(chip->card, "AK4396");
@@ -106,20 +120,29 @@ static void set_ak4396_params(struct oxygen *chip,
         struct hifier_data *data = chip->model_data;
         u8 value;
 
-        value = data->ak4396_ctl2 & ~AK4396_DFS_MASK;
+        value = data->ak4396_regs[AK4396_CONTROL_2] & ~AK4396_DFS_MASK;
         if (params_rate(params) <= 54000)
                 value |= AK4396_DFS_NORMAL;
         else if (params_rate(params) <= 108000)
                 value |= AK4396_DFS_DOUBLE;
         else
                 value |= AK4396_DFS_QUAD;
-        data->ak4396_ctl2 = value;
 
         msleep(1); /* wait for the new MCLK to become stable */
 
-        ak4396_write(chip, AK4396_CONTROL_1, AK4396_DIF_24_MSB);
-        ak4396_write(chip, AK4396_CONTROL_2, value);
-        ak4396_write(chip, AK4396_CONTROL_1, AK4396_DIF_24_MSB | AK4396_RSTN);
+        if (value != data->ak4396_regs[AK4396_CONTROL_2]) {
+                ak4396_write(chip, AK4396_CONTROL_1,
+                             AK4396_DIF_24_MSB);
+                ak4396_write(chip, AK4396_CONTROL_2, value);
+                ak4396_write(chip, AK4396_CONTROL_1,
+                             AK4396_DIF_24_MSB | AK4396_RSTN);
+        }
+}
+
+static void update_ak4396_volume(struct oxygen *chip)
+{
+        ak4396_write_cached(chip, AK4396_LCH_ATT, chip->dac_volume[0]);
+        ak4396_write_cached(chip, AK4396_RCH_ATT, chip->dac_volume[1]);
 }
 
 static void update_ak4396_mute(struct oxygen *chip)
@@ -127,11 +150,10 @@ static void update_ak4396_mute(struct oxygen *chip)
         struct hifier_data *data = chip->model_data;
         u8 value;
 
-        value = data->ak4396_ctl2 & ~AK4396_SMUTE;
+        value = data->ak4396_regs[AK4396_CONTROL_2] & ~AK4396_SMUTE;
         if (chip->dac_mute)
                 value |= AK4396_SMUTE;
-        data->ak4396_ctl2 = value;
-        ak4396_write(chip, AK4396_CONTROL_2, value);
+        ak4396_write_cached(chip, AK4396_CONTROL_2, value);
 }
 
 static void set_cs5340_params(struct oxygen *chip,
@@ -141,21 +163,14 @@ static void set_cs5340_params(struct oxygen *chip,
 
 static const DECLARE_TLV_DB_LINEAR(ak4396_db_scale, TLV_DB_GAIN_MUTE, 0);
 
-static int hifier_control_filter(struct snd_kcontrol_new *template)
-{
-        if (!strcmp(template->name, "Stereo Upmixing"))
-                return 1; /* stereo only - we don't need upmixing */
-        return 0;
-}
-
 static const struct oxygen_model model_hifier = {
         .shortname = "C-Media CMI8787",
         .longname = "C-Media Oxygen HD Audio",
         .chip = "CMI8788",
         .init = hifier_init,
-        .control_filter = hifier_control_filter,
         .cleanup = hifier_cleanup,
         .resume = hifier_resume,
+        .get_i2s_mclk = oxygen_default_i2s_mclk,
         .set_dac_params = set_ak4396_params,
         .set_adc_params = set_cs5340_params,
         .update_dac_volume = update_ak4396_volume,
diff --git a/sound/pci/oxygen/oxygen.c b/sound/pci/oxygen/oxygen.c
index 72db4c39007f..289cb4dacfc7 100644
--- a/sound/pci/oxygen/oxygen.c
+++ b/sound/pci/oxygen/oxygen.c
@@ -18,6 +18,8 @@
  */
 
 /*
+ * CMI8788:
+ *
  * SPI 0 -> 1st AK4396 (front)
  * SPI 1 -> 2nd AK4396 (surround)
  * SPI 2 -> 3rd AK4396 (center/LFE)
@@ -27,6 +29,10 @@
  * GPIO 0 -> DFS0 of AK5385
  * GPIO 1 -> DFS1 of AK5385
  * GPIO 8 -> enable headphone amplifier on HT-Omega models
+ *
+ * CM9780:
+ *
+ * GPO 0 -> route line-in (0) or AC97 output (1) to ADC input
  */
 
 #include <linux/delay.h>
@@ -66,7 +72,7 @@ enum {
         MODEL_CLARO_HALO,       /* HT-Omega Claro halo */
 };
 
-static struct pci_device_id oxygen_ids[] __devinitdata = {
+static DEFINE_PCI_DEVICE_TABLE(oxygen_ids) = {
         { OXYGEN_PCI_SUBID(0x10b0, 0x0216), .driver_data = MODEL_CMEDIA_REF },
         { OXYGEN_PCI_SUBID(0x10b0, 0x0218), .driver_data = MODEL_CMEDIA_REF },
         { OXYGEN_PCI_SUBID(0x10b0, 0x0219), .driver_data = MODEL_CMEDIA_REF },
@@ -91,8 +97,8 @@ MODULE_DEVICE_TABLE(pci, oxygen_ids);
 #define GPIO_CLARO_HP           0x0100
 
 struct generic_data {
-        u8 ak4396_ctl2;
-        u16 saved_wm8785_registers[2];
+        u8 ak4396_regs[4][5];
+        u16 wm8785_regs[3];
 };
 
 static void ak4396_write(struct oxygen *chip, unsigned int codec,
@@ -102,12 +108,24 @@ static void ak4396_write(struct oxygen *chip, unsigned int codec,
         static const u8 codec_spi_map[4] = {
                 0, 1, 2, 4
         };
+        struct generic_data *data = chip->model_data;
+
         oxygen_write_spi(chip, OXYGEN_SPI_TRIGGER |
                          OXYGEN_SPI_DATA_LENGTH_2 |
                          OXYGEN_SPI_CLOCK_160 |
                          (codec_spi_map[codec] << OXYGEN_SPI_CODEC_SHIFT) |
                          OXYGEN_SPI_CEN_LATCH_CLOCK_HI,
                          AK4396_WRITE | (reg << 8) | value);
+        data->ak4396_regs[codec][reg] = value;
+}
+
+static void ak4396_write_cached(struct oxygen *chip, unsigned int codec,
+                                u8 reg, u8 value)
+{
+        struct generic_data *data = chip->model_data;
+
+        if (value != data->ak4396_regs[codec][reg])
+                ak4396_write(chip, codec, reg, value);
 }
 
 static void wm8785_write(struct oxygen *chip, u8 reg, unsigned int value)
@@ -120,20 +138,8 @@ static void wm8785_write(struct oxygen *chip, u8 reg, unsigned int value)
                          (3 << OXYGEN_SPI_CODEC_SHIFT) |
                          OXYGEN_SPI_CEN_LATCH_CLOCK_LO,
                          (reg << 9) | value);
-        if (reg < ARRAY_SIZE(data->saved_wm8785_registers))
-                data->saved_wm8785_registers[reg] = value;
-}
-
-static void update_ak4396_volume(struct oxygen *chip)
-{
-        unsigned int i;
-
-        for (i = 0; i < 4; ++i) {
-                ak4396_write(chip, i,
-                             AK4396_LCH_ATT, chip->dac_volume[i * 2]);
-                ak4396_write(chip, i,
-                             AK4396_RCH_ATT, chip->dac_volume[i * 2 + 1]);
-        }
+        if (reg < ARRAY_SIZE(data->wm8785_regs))
+                data->wm8785_regs[reg] = value;
 }
 
 static void ak4396_registers_init(struct oxygen *chip)
@@ -142,21 +148,25 @@ static void ak4396_registers_init(struct oxygen *chip)
         unsigned int i;
 
         for (i = 0; i < 4; ++i) {
-                ak4396_write(chip, i,
-                             AK4396_CONTROL_1, AK4396_DIF_24_MSB | AK4396_RSTN);
-                ak4396_write(chip, i,
-                             AK4396_CONTROL_2, data->ak4396_ctl2);
-                ak4396_write(chip, i,
-                             AK4396_CONTROL_3, AK4396_PCM);
+                ak4396_write(chip, i, AK4396_CONTROL_1,
+                             AK4396_DIF_24_MSB | AK4396_RSTN);
+                ak4396_write(chip, i, AK4396_CONTROL_2,
+                             data->ak4396_regs[0][AK4396_CONTROL_2]);
+                ak4396_write(chip, i, AK4396_CONTROL_3,
+                             AK4396_PCM);
+                ak4396_write(chip, i, AK4396_LCH_ATT,
+                             chip->dac_volume[i * 2]);
+                ak4396_write(chip, i, AK4396_RCH_ATT,
+                             chip->dac_volume[i * 2 + 1]);
         }
-        update_ak4396_volume(chip);
 }
 
 static void ak4396_init(struct oxygen *chip)
 {
         struct generic_data *data = chip->model_data;
 
-        data->ak4396_ctl2 = AK4396_SMUTE | AK4396_DEM_OFF | AK4396_DFS_NORMAL;
+        data->ak4396_regs[0][AK4396_CONTROL_2] =
+                AK4396_SMUTE | AK4396_DEM_OFF | AK4396_DFS_NORMAL;
         ak4396_registers_init(chip);
         snd_component_add(chip->card, "AK4396");
 }
@@ -173,17 +183,17 @@ static void wm8785_registers_init(struct oxygen *chip)
         struct generic_data *data = chip->model_data;
 
         wm8785_write(chip, WM8785_R7, 0);
-        wm8785_write(chip, WM8785_R0, data->saved_wm8785_registers[0]);
-        wm8785_write(chip, WM8785_R1, data->saved_wm8785_registers[1]);
+        wm8785_write(chip, WM8785_R0, data->wm8785_regs[0]);
+        wm8785_write(chip, WM8785_R2, data->wm8785_regs[2]);
 }
 
 static void wm8785_init(struct oxygen *chip)
 {
         struct generic_data *data = chip->model_data;
 
-        data->saved_wm8785_registers[0] = WM8785_MCR_SLAVE |
-                WM8785_OSR_SINGLE | WM8785_FORMAT_LJUST;
-        data->saved_wm8785_registers[1] = WM8785_WL_24;
+        data->wm8785_regs[0] =
+                WM8785_MCR_SLAVE | WM8785_OSR_SINGLE | WM8785_FORMAT_LJUST;
+        data->wm8785_regs[2] = WM8785_HPFR | WM8785_HPFL;
         wm8785_registers_init(chip);
         snd_component_add(chip->card, "WM8785");
 }
@@ -264,24 +274,36 @@ static void set_ak4396_params(struct oxygen *chip,
         unsigned int i;
         u8 value;
 
-        value = data->ak4396_ctl2 & ~AK4396_DFS_MASK;
+        value = data->ak4396_regs[0][AK4396_CONTROL_2] & ~AK4396_DFS_MASK;
         if (params_rate(params) <= 54000)
                 value |= AK4396_DFS_NORMAL;
         else if (params_rate(params) <= 108000)
                 value |= AK4396_DFS_DOUBLE;
         else
                 value |= AK4396_DFS_QUAD;
-        data->ak4396_ctl2 = value;
 
         msleep(1); /* wait for the new MCLK to become stable */
 
+        if (value != data->ak4396_regs[0][AK4396_CONTROL_2]) {
+                for (i = 0; i < 4; ++i) {
+                        ak4396_write(chip, i, AK4396_CONTROL_1,
+                                     AK4396_DIF_24_MSB);
+                        ak4396_write(chip, i, AK4396_CONTROL_2, value);
+                        ak4396_write(chip, i, AK4396_CONTROL_1,
+                                     AK4396_DIF_24_MSB | AK4396_RSTN);
+                }
+        }
+}
+
+static void update_ak4396_volume(struct oxygen *chip)
+{
+        unsigned int i;
+
         for (i = 0; i < 4; ++i) {
-                ak4396_write(chip, i,
-                             AK4396_CONTROL_1, AK4396_DIF_24_MSB);
-                ak4396_write(chip, i,
-                             AK4396_CONTROL_2, value);
-                ak4396_write(chip, i,
-                             AK4396_CONTROL_1, AK4396_DIF_24_MSB | AK4396_RSTN);
+                ak4396_write_cached(chip, i, AK4396_LCH_ATT,
+                                    chip->dac_volume[i * 2]);
+                ak4396_write_cached(chip, i, AK4396_RCH_ATT,
+                                    chip->dac_volume[i * 2 + 1]);
         }
 }
 
@@ -291,21 +313,19 @@ static void update_ak4396_mute(struct oxygen *chip)
         unsigned int i;
         u8 value;
 
-        value = data->ak4396_ctl2 & ~AK4396_SMUTE;
+        value = data->ak4396_regs[0][AK4396_CONTROL_2] & ~AK4396_SMUTE;
         if (chip->dac_mute)
                 value |= AK4396_SMUTE;
-        data->ak4396_ctl2 = value;
         for (i = 0; i < 4; ++i)
-                ak4396_write(chip, i, AK4396_CONTROL_2, value);
+                ak4396_write_cached(chip, i, AK4396_CONTROL_2, value);
 }
 
 static void set_wm8785_params(struct oxygen *chip,
                               struct snd_pcm_hw_params *params)
 {
+        struct generic_data *data = chip->model_data;
         unsigned int value;
 
-        wm8785_write(chip, WM8785_R7, 0);
-
         value = WM8785_MCR_SLAVE | WM8785_FORMAT_LJUST;
         if (params_rate(params) <= 48000)
                 value |= WM8785_OSR_SINGLE;
@@ -313,13 +333,11 @@ static void set_wm8785_params(struct oxygen *chip,
                 value |= WM8785_OSR_DOUBLE;
         else
                 value |= WM8785_OSR_QUAD;
-        wm8785_write(chip, WM8785_R0, value);
-
-        if (snd_pcm_format_width(params_format(params)) <= 16)
-                value = WM8785_WL_16;
-        else
-                value = WM8785_WL_24;
-        wm8785_write(chip, WM8785_R1, value);
+        if (value != data->wm8785_regs[0]) {
+                wm8785_write(chip, WM8785_R7, 0);
+                wm8785_write(chip, WM8785_R0, value);
+                wm8785_write(chip, WM8785_R2, data->wm8785_regs[2]);
+        }
 }
 
 static void set_ak5385_params(struct oxygen *chip,
@@ -337,6 +355,134 @@ static void set_ak5385_params(struct oxygen *chip,
                               value, GPIO_AK5385_DFS_MASK);
 }
 
+static int rolloff_info(struct snd_kcontrol *ctl,
+                        struct snd_ctl_elem_info *info)
+{
+        static const char *const names[2] = {
+                "Sharp Roll-off", "Slow Roll-off"
+        };
+
+        info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        info->count = 1;
+        info->value.enumerated.items = 2;
+        if (info->value.enumerated.item >= 2)
+                info->value.enumerated.item = 1;
+        strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
+        return 0;
+}
+
+static int rolloff_get(struct snd_kcontrol *ctl,
+                       struct snd_ctl_elem_value *value)
+{
+        struct oxygen *chip = ctl->private_data;
+        struct generic_data *data = chip->model_data;
+
+        value->value.enumerated.item[0] =
+                (data->ak4396_regs[0][AK4396_CONTROL_2] & AK4396_SLOW) != 0;
+        return 0;
+}
+
+static int rolloff_put(struct snd_kcontrol *ctl,
+                       struct snd_ctl_elem_value *value)
+{
+        struct oxygen *chip = ctl->private_data;
+        struct generic_data *data = chip->model_data;
+        unsigned int i;
+        int changed;
+        u8 reg;
+
+        mutex_lock(&chip->mutex);
+        reg = data->ak4396_regs[0][AK4396_CONTROL_2];
+        if (value->value.enumerated.item[0])
+                reg |= AK4396_SLOW;
+        else
+                reg &= ~AK4396_SLOW;
+        changed = reg != data->ak4396_regs[0][AK4396_CONTROL_2];
+        if (changed) {
+                for (i = 0; i < 4; ++i)
+                        ak4396_write(chip, i, AK4396_CONTROL_2, reg);
+        }
+        mutex_unlock(&chip->mutex);
+        return changed;
+}
+
+static const struct snd_kcontrol_new rolloff_control = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name = "DAC Filter Playback Enum",
+        .info = rolloff_info,
+        .get = rolloff_get,
+        .put = rolloff_put,
+};
+
+static int hpf_info(struct snd_kcontrol *ctl, struct snd_ctl_elem_info *info)
+{
+        static const char *const names[2] = {
+                "None", "High-pass Filter"
+        };
+
+        info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        info->count = 1;
+        info->value.enumerated.items = 2;
+        if (info->value.enumerated.item >= 2)
+                info->value.enumerated.item = 1;
+        strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
+        return 0;
+}
+
+static int hpf_get(struct snd_kcontrol *ctl, struct snd_ctl_elem_value *value)
+{
+        struct oxygen *chip = ctl->private_data;
+        struct generic_data *data = chip->model_data;
+
+        value->value.enumerated.item[0] =
+                (data->wm8785_regs[WM8785_R2] & WM8785_HPFR) != 0;
+        return 0;
+}
+
+static int hpf_put(struct snd_kcontrol *ctl, struct snd_ctl_elem_value *value)
+{
+        struct oxygen *chip = ctl->private_data;
+        struct generic_data *data = chip->model_data;
+        unsigned int reg;
+        int changed;
+
+        mutex_lock(&chip->mutex);
+        reg = data->wm8785_regs[WM8785_R2] & ~(WM8785_HPFR | WM8785_HPFL);
+        if (value->value.enumerated.item[0])
+                reg |= WM8785_HPFR | WM8785_HPFL;
+        changed = reg != data->wm8785_regs[WM8785_R2];
+        if (changed)
+                wm8785_write(chip, WM8785_R2, reg);
+        mutex_unlock(&chip->mutex);
+        return changed;
+}
+
+static const struct snd_kcontrol_new hpf_control = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name = "ADC Filter Capture Enum",
+        .info = hpf_info,
+        .get = hpf_get,
+        .put = hpf_put,
+};
+
+static int generic_mixer_init(struct oxygen *chip)
+{
+        return snd_ctl_add(chip->card, snd_ctl_new1(&rolloff_control, chip));
+}
+
+static int generic_wm8785_mixer_init(struct oxygen *chip)
+{
+        int err;
+
+        err = generic_mixer_init(chip);
+        if (err < 0)
+                return err;
+        err = snd_ctl_add(chip->card, snd_ctl_new1(&hpf_control, chip));
+        if (err < 0)
+                return err;
+        return 0;
+}
+
 static const DECLARE_TLV_DB_LINEAR(ak4396_db_scale, TLV_DB_GAIN_MUTE, 0);
 
 static const struct oxygen_model model_generic = {
@@ -344,8 +490,10 @@ static const struct oxygen_model model_generic = {
         .longname = "C-Media Oxygen HD Audio",
         .chip = "CMI8788",
         .init = generic_init,
+        .mixer_init = generic_wm8785_mixer_init,
         .cleanup = generic_cleanup,
         .resume = generic_resume,
+        .get_i2s_mclk = oxygen_default_i2s_mclk,
         .set_dac_params = set_ak4396_params,
         .set_adc_params = set_wm8785_params,
         .update_dac_volume = update_ak4396_volume,
@@ -374,6 +522,7 @@ static int __devinit get_oxygen_model(struct oxygen *chip,
         switch (id->driver_data) {
         case MODEL_MERIDIAN:
                 chip->model.init = meridian_init;
+                chip->model.mixer_init = generic_mixer_init;
                 chip->model.resume = meridian_resume;
                 chip->model.set_adc_params = set_ak5385_params;
                 chip->model.device_config = PLAYBACK_0_TO_I2S |
@@ -389,6 +538,7 @@ static int __devinit get_oxygen_model(struct oxygen *chip,
                 break;
         case MODEL_CLARO_HALO:
                 chip->model.init = claro_halo_init;
+                chip->model.mixer_init = generic_mixer_init;
                 chip->model.cleanup = claro_cleanup;
                 chip->model.suspend = claro_suspend;
                 chip->model.resume = claro_resume;
diff --git a/sound/pci/oxygen/oxygen.h b/sound/pci/oxygen/oxygen.h
index bd615dbffadb..6147216af744 100644
--- a/sound/pci/oxygen/oxygen.h
+++ b/sound/pci/oxygen/oxygen.h
@@ -78,12 +78,15 @@ struct oxygen_model {
         void (*resume)(struct oxygen *chip);
         void (*pcm_hardware_filter)(unsigned int channel,
                                     struct snd_pcm_hardware *hardware);
+        unsigned int (*get_i2s_mclk)(struct oxygen *chip, unsigned int channel,
+                                     struct snd_pcm_hw_params *hw_params);
         void (*set_dac_params)(struct oxygen *chip,
                                struct snd_pcm_hw_params *params);
         void (*set_adc_params)(struct oxygen *chip,
                                struct snd_pcm_hw_params *params);
         void (*update_dac_volume)(struct oxygen *chip);
         void (*update_dac_mute)(struct oxygen *chip);
+        void (*update_center_lfe_mix)(struct oxygen *chip, bool mixed);
         void (*gpio_changed)(struct oxygen *chip);
         void (*uart_input)(struct oxygen *chip);
         void (*ac97_switch)(struct oxygen *chip,
@@ -162,6 +165,8 @@ void oxygen_update_spdif_source(struct oxygen *chip);
 /* oxygen_pcm.c */
 
 int oxygen_pcm_init(struct oxygen *chip);
+unsigned int oxygen_default_i2s_mclk(struct oxygen *chip, unsigned int channel,
+                                     struct snd_pcm_hw_params *hw_params);
 
 /* oxygen_io.c */
 
diff --git a/sound/pci/oxygen/oxygen_lib.c b/sound/pci/oxygen/oxygen_lib.c
index 9a8936e20744..fad03d64e3ad 100644
--- a/sound/pci/oxygen/oxygen_lib.c
+++ b/sound/pci/oxygen/oxygen_lib.c
@@ -21,6 +21,7 @@
 #include <linux/interrupt.h>
 #include <linux/mutex.h>
 #include <linux/pci.h>
+#include <linux/slab.h>
 #include <sound/ac97_codec.h>
 #include <sound/asoundef.h>
 #include <sound/core.h>
@@ -278,7 +279,11 @@ oxygen_search_pci_id(struct oxygen *chip, const struct pci_device_id ids[])
 static void oxygen_restore_eeprom(struct oxygen *chip,
                                   const struct pci_device_id *id)
 {
-        if (oxygen_read_eeprom(chip, 0) != OXYGEN_EEPROM_ID) {
+        u16 eeprom_id;
+
+        eeprom_id = oxygen_read_eeprom(chip, 0);
+        if (eeprom_id != OXYGEN_EEPROM_ID &&
+            (eeprom_id != 0xffff || id->subdevice != 0x8788)) {
                 /*
                  * This function gets called only when a known card model has
                  * been detected, i.e., we know there is a valid subsystem
@@ -303,6 +308,28 @@ static void oxygen_restore_eeprom(struct oxygen *chip,
         }
 }
 
+static void pci_bridge_magic(void)
+{
+        struct pci_dev *pci = NULL;
+        u32 tmp;
+
+        for (;;) {
+                /* If there is any Pericom PI7C9X110 PCI-E/PCI bridge ... */
+                pci = pci_get_device(0x12d8, 0xe110, pci);
+                if (!pci)
+                        break;
+                /*
+                 * ... configure its secondary internal arbiter to park to
+                 * the secondary port, instead of to the last master.
+                 */
+                if (!pci_read_config_dword(pci, 0x40, &tmp)) {
+                        tmp |= 1;
+                        pci_write_config_dword(pci, 0x40, tmp);
+                }
+                /* Why?  Try asking C-Media. */
+        }
+}
+
 static void oxygen_init(struct oxygen *chip)
 {
         unsigned int i;
@@ -581,6 +608,7 @@ int oxygen_pci_probe(struct pci_dev *pci, int index, char *id,
         snd_card_set_dev(card, &pci->dev);
         card->private_free = oxygen_card_free;
 
+        pci_bridge_magic();
         oxygen_init(chip);
         chip->model.init(chip);
 
diff --git a/sound/pci/oxygen/oxygen_mixer.c b/sound/pci/oxygen/oxygen_mixer.c
index 5401c547c4e3..f375b8a27862 100644
--- a/sound/pci/oxygen/oxygen_mixer.c
+++ b/sound/pci/oxygen/oxygen_mixer.c
@@ -99,11 +99,15 @@ static int dac_mute_put(struct snd_kcontrol *ctl,
 
 static int upmix_info(struct snd_kcontrol *ctl, struct snd_ctl_elem_info *info)
 {
-        static const char *const names[3] = {
-                "Front", "Front+Surround", "Front+Surround+Back"
+        static const char *const names[5] = {
+                "Front",
+                "Front+Surround",
+                "Front+Surround+Back",
+                "Front+Surround+Center/LFE",
+                "Front+Surround+Center/LFE+Back",
         };
         struct oxygen *chip = ctl->private_data;
-        unsigned int count = 2 + (chip->model.dac_channels == 8);
+        unsigned int count = chip->model.update_center_lfe_mix ? 5 : 3;
 
         info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
         info->count = 1;
@@ -127,7 +131,7 @@ static int upmix_get(struct snd_kcontrol *ctl, struct snd_ctl_elem_value *value)
 void oxygen_update_dac_routing(struct oxygen *chip)
 {
         /* DAC 0: front, DAC 1: surround, DAC 2: center/LFE, DAC 3: back */
-        static const unsigned int reg_values[3] = {
+        static const unsigned int reg_values[5] = {
                 /* stereo -> front */
                 (0 << OXYGEN_PLAY_DAC0_SOURCE_SHIFT) |
                 (1 << OXYGEN_PLAY_DAC1_SOURCE_SHIFT) |
@@ -143,6 +147,16 @@ void oxygen_update_dac_routing(struct oxygen *chip)
                 (0 << OXYGEN_PLAY_DAC1_SOURCE_SHIFT) |
                 (2 << OXYGEN_PLAY_DAC2_SOURCE_SHIFT) |
                 (0 << OXYGEN_PLAY_DAC3_SOURCE_SHIFT),
+                /* stereo -> front+surround+center/LFE */
+                (0 << OXYGEN_PLAY_DAC0_SOURCE_SHIFT) |
+                (0 << OXYGEN_PLAY_DAC1_SOURCE_SHIFT) |
+                (0 << OXYGEN_PLAY_DAC2_SOURCE_SHIFT) |
+                (3 << OXYGEN_PLAY_DAC3_SOURCE_SHIFT),
+                /* stereo -> front+surround+center/LFE+back */
+                (0 << OXYGEN_PLAY_DAC0_SOURCE_SHIFT) |
+                (0 << OXYGEN_PLAY_DAC1_SOURCE_SHIFT) |
+                (0 << OXYGEN_PLAY_DAC2_SOURCE_SHIFT) |
+                (0 << OXYGEN_PLAY_DAC3_SOURCE_SHIFT),
         };
         u8 channels;
         unsigned int reg_value;
@@ -167,22 +181,23 @@ void oxygen_update_dac_routing(struct oxygen *chip)
                               OXYGEN_PLAY_DAC1_SOURCE_MASK |
                               OXYGEN_PLAY_DAC2_SOURCE_MASK |
                               OXYGEN_PLAY_DAC3_SOURCE_MASK);
+        if (chip->model.update_center_lfe_mix)
+                chip->model.update_center_lfe_mix(chip, chip->dac_routing > 2);
 }
 
 static int upmix_put(struct snd_kcontrol *ctl, struct snd_ctl_elem_value *value)
 {
         struct oxygen *chip = ctl->private_data;
-        unsigned int count = 2 + (chip->model.dac_channels == 8);
+        unsigned int count = chip->model.update_center_lfe_mix ? 5 : 3;
         int changed;
 
+        if (value->value.enumerated.item[0] >= count)
+                return -EINVAL;
         mutex_lock(&chip->mutex);
         changed = value->value.enumerated.item[0] != chip->dac_routing;
         if (changed) {
-                chip->dac_routing = min(value->value.enumerated.item[0],
-                                        count - 1);
-                spin_lock_irq(&chip->reg_lock);
+                chip->dac_routing = value->value.enumerated.item[0];
                 oxygen_update_dac_routing(chip);
-                spin_unlock_irq(&chip->reg_lock);
         }
         mutex_unlock(&chip->mutex);
         return changed;
@@ -790,7 +805,7 @@ static const struct {
                 .controls = {
                         {
                                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-                                .name = "Analog Input Monitor Switch",
+                                .name = "Analog Input Monitor Playback Switch",
                                 .info = snd_ctl_boolean_mono_info,
                                 .get = monitor_get,
                                 .put = monitor_put,
@@ -798,7 +813,7 @@ static const struct {
                         },
                         {
                                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-                                .name = "Analog Input Monitor Volume",
+                                .name = "Analog Input Monitor Playback Volume",
                                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
                                           SNDRV_CTL_ELEM_ACCESS_TLV_READ,
                                 .info = monitor_volume_info,
@@ -815,7 +830,7 @@ static const struct {
                 .controls = {
                         {
                                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-                                .name = "Analog Input Monitor Switch",
+                                .name = "Analog Input Monitor Playback Switch",
                                 .info = snd_ctl_boolean_mono_info,
                                 .get = monitor_get,
                                 .put = monitor_put,
@@ -823,7 +838,7 @@ static const struct {
                         },
                         {
                                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-                                .name = "Analog Input Monitor Volume",
+                                .name = "Analog Input Monitor Playback Volume",
                                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
                                           SNDRV_CTL_ELEM_ACCESS_TLV_READ,
                                 .info = monitor_volume_info,
@@ -840,7 +855,7 @@ static const struct {
                 .controls = {
                         {
                                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-                                .name = "Analog Input Monitor Switch",
+                                .name = "Analog Input Monitor Playback Switch",
                                 .index = 1,
                                 .info = snd_ctl_boolean_mono_info,
                                 .get = monitor_get,
@@ -849,7 +864,7 @@ static const struct {
                         },
                         {
                                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-                                .name = "Analog Input Monitor Volume",
+                                .name = "Analog Input Monitor Playback Volume",
                                 .index = 1,
                                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
                                           SNDRV_CTL_ELEM_ACCESS_TLV_READ,
@@ -867,7 +882,7 @@ static const struct {
                 .controls = {
                         {
                                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-                                .name = "Digital Input Monitor Switch",
+                                .name = "Digital Input Monitor Playback Switch",
                                 .info = snd_ctl_boolean_mono_info,
                                 .get = monitor_get,
                                 .put = monitor_put,
@@ -875,7 +890,7 @@ static const struct {
                         },
                         {
                                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-                                .name = "Digital Input Monitor Volume",
+                                .name = "Digital Input Monitor Playback Volume",
                                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
                                           SNDRV_CTL_ELEM_ACCESS_TLV_READ,
                                 .info = monitor_volume_info,
@@ -954,6 +969,9 @@ static int add_controls(struct oxygen *chip,
                         if (err == 1)
                                 continue;
                 }
+                if (!strcmp(template.name, "Stereo Upmixing") &&
+                    chip->model.dac_channels == 2)
+                        continue;
                 if (!strcmp(template.name, "Master Playback Volume") &&
                     chip->model.dac_tlv) {
                         template.tlv.p = chip->model.dac_tlv;
diff --git a/sound/pci/oxygen/oxygen_pcm.c b/sound/pci/oxygen/oxygen_pcm.c
index ef2345d82b86..9dff6954c397 100644
--- a/sound/pci/oxygen/oxygen_pcm.c
+++ b/sound/pci/oxygen/oxygen_pcm.c
@@ -271,13 +271,16 @@ static unsigned int oxygen_rate(struct snd_pcm_hw_params *hw_params)
         }
 }
 
-static unsigned int oxygen_i2s_mclk(struct snd_pcm_hw_params *hw_params)
+unsigned int oxygen_default_i2s_mclk(struct oxygen *chip,
+                                     unsigned int channel,
+                                     struct snd_pcm_hw_params *hw_params)
 {
         if (params_rate(hw_params) <= 96000)
                 return OXYGEN_I2S_MCLK_256;
         else
                 return OXYGEN_I2S_MCLK_128;
 }
+EXPORT_SYMBOL(oxygen_default_i2s_mclk);
 
 static unsigned int oxygen_i2s_bits(struct snd_pcm_hw_params *hw_params)
 {
@@ -354,7 +357,7 @@ static int oxygen_rec_a_hw_params(struct snd_pcm_substream *substream,
                              OXYGEN_REC_FORMAT_A_MASK);
         oxygen_write16_masked(chip, OXYGEN_I2S_A_FORMAT,
                               oxygen_rate(hw_params) |
-                              oxygen_i2s_mclk(hw_params) |
+                              chip->model.get_i2s_mclk(chip, PCM_A, hw_params) |
                               chip->model.adc_i2s_format |
                               oxygen_i2s_bits(hw_params),
                               OXYGEN_I2S_RATE_MASK |
@@ -390,7 +393,8 @@ static int oxygen_rec_b_hw_params(struct snd_pcm_substream *substream,
         if (!is_ac97)
                 oxygen_write16_masked(chip, OXYGEN_I2S_B_FORMAT,
                                       oxygen_rate(hw_params) |
-                                      oxygen_i2s_mclk(hw_params) |
+                                      chip->model.get_i2s_mclk(chip, PCM_B,
+                                                               hw_params) |
                                       chip->model.adc_i2s_format |
                                       oxygen_i2s_bits(hw_params),
                                       OXYGEN_I2S_RATE_MASK |
@@ -435,6 +439,7 @@ static int oxygen_spdif_hw_params(struct snd_pcm_substream *substream,
         if (err < 0)
                 return err;
 
+        mutex_lock(&chip->mutex);
         spin_lock_irq(&chip->reg_lock);
         oxygen_clear_bits32(chip, OXYGEN_SPDIF_CONTROL,
                             OXYGEN_SPDIF_OUT_ENABLE);
@@ -446,6 +451,7 @@ static int oxygen_spdif_hw_params(struct snd_pcm_substream *substream,
                               OXYGEN_SPDIF_OUT_RATE_MASK);
         oxygen_update_spdif_source(chip);
         spin_unlock_irq(&chip->reg_lock);
+        mutex_unlock(&chip->mutex);
         return 0;
 }
 
@@ -459,6 +465,7 @@ static int oxygen_multich_hw_params(struct snd_pcm_substream *substream,
         if (err < 0)
                 return err;
 
+        mutex_lock(&chip->mutex);
         spin_lock_irq(&chip->reg_lock);
         oxygen_write8_masked(chip, OXYGEN_PLAY_CHANNELS,
                              oxygen_play_channels(hw_params),
@@ -469,18 +476,18 @@ 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) |
+                              chip->model.get_i2s_mclk(chip, PCM_MULTICH,
+                                                       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);
         spin_unlock_irq(&chip->reg_lock);
 
-        mutex_lock(&chip->mutex);
         chip->model.set_dac_params(chip, hw_params);
+        oxygen_update_dac_routing(chip);
         mutex_unlock(&chip->mutex);
         return 0;
 }
diff --git a/sound/pci/oxygen/virtuoso.c b/sound/pci/oxygen/virtuoso.c
index 6ebcb6bdd712..f03a2f2cffee 100644
--- a/sound/pci/oxygen/virtuoso.c
+++ b/sound/pci/oxygen/virtuoso.c
@@ -17,145 +17,12 @@
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  */
 
-/*
- * Xonar D2/D2X
- * ------------
- *
- * CMI8788:
- *
- * SPI 0 -> 1st PCM1796 (front)
- * SPI 1 -> 2nd PCM1796 (surround)
- * SPI 2 -> 3rd PCM1796 (center/LFE)
- * SPI 4 -> 4th PCM1796 (back)
- *
- * GPIO 2 -> M0 of CS5381
- * GPIO 3 -> M1 of CS5381
- * GPIO 5 <- external power present (D2X only)
- * GPIO 7 -> ALT
- * GPIO 8 -> enable output to speakers
- */
-
-/*
- * Xonar D1/DX
- * -----------
- *
- * CMI8788:
- *
- * I²C <-> CS4398 (front)
- *     <-> CS4362A (surround, center/LFE, back)
- *
- * GPI 0 <- external power present (DX only)
- *
- * GPIO 0 -> enable output to speakers
- * GPIO 1 -> enable front panel I/O
- * GPIO 2 -> M0 of CS5361
- * GPIO 3 -> M1 of CS5361
- * GPIO 8 -> route input jack to line-in (0) or mic-in (1)
- *
- * CS4398:
- *
- * AD0 <- 1
- * AD1 <- 1
- *
- * CS4362A:
- *
- * AD0 <- 0
- */
-
-/*
- * Xonar HDAV1.3 (Deluxe)
- * ----------------------
- *
- * CMI8788:
- *
- * I²C <-> PCM1796 (front)
- *
- * GPI 0 <- external power present
- *
- * GPIO 0 -> enable output to speakers
- * GPIO 2 -> M0 of CS5381
- * GPIO 3 -> M1 of CS5381
- * GPIO 8 -> route input jack to line-in (0) or mic-in (1)
- *
- * TXD -> HDMI controller
- * RXD <- HDMI controller
- *
- * PCM1796 front: AD1,0 <- 0,0
- *
- * no daughterboard
- * ----------------
- *
- * GPIO 4 <- 1
- *
- * H6 daughterboard
- * ----------------
- *
- * GPIO 4 <- 0
- * GPIO 5 <- 0
- *
- * I²C <-> PCM1796 (surround)
- *     <-> PCM1796 (center/LFE)
- *     <-> PCM1796 (back)
- *
- * PCM1796 surround:   AD1,0 <- 0,1
- * PCM1796 center/LFE: AD1,0 <- 1,0
- * PCM1796 back:       AD1,0 <- 1,1
- *
- * unknown daughterboard
- * ---------------------
- *
- * GPIO 4 <- 0
- * GPIO 5 <- 1
- *
- * I²C <-> CS4362A (surround, center/LFE, back)
- *
- * CS4362A: AD0 <- 0
- */
-
-/*
- * Xonar Essence ST (Deluxe)/STX
- * -----------------------------
- *
- * CMI8788:
- *
- * I²C <-> PCM1792A
- *
- * GPI 0 <- external power present
- *
- * GPIO 0 -> enable output to speakers
- * GPIO 1 -> route HP to front panel (0) or rear jack (1)
- * GPIO 2 -> M0 of CS5381
- * GPIO 3 -> M1 of CS5381
- * GPIO 7 -> route output to speaker jacks (0) or HP (1)
- * GPIO 8 -> route input jack to line-in (0) or mic-in (1)
- *
- * PCM1792A:
- *
- * AD0 <- 0
- *
- * H6 daughterboard
- * ----------------
- *
- * GPIO 4 <- 0
- * GPIO 5 <- 0
- */
-
 #include <linux/pci.h>
 #include <linux/delay.h>
-#include <linux/mutex.h>
-#include <sound/ac97_codec.h>
-#include <sound/asoundef.h>
-#include <sound/control.h>
 #include <sound/core.h>
 #include <sound/initval.h>
 #include <sound/pcm.h>
-#include <sound/pcm_params.h>
-#include <sound/tlv.h>
-#include "oxygen.h"
-#include "cm9780.h"
-#include "pcm1796.h"
-#include "cs4398.h"
-#include "cs4362a.h"
+#include "xonar.h"
 
 MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>");
 MODULE_DESCRIPTION("Asus AVx00 driver");
@@ -173,972 +40,31 @@ MODULE_PARM_DESC(id, "ID string");
 module_param_array(enable, bool, NULL, 0444);
 MODULE_PARM_DESC(enable, "enable card");
 
-enum {
-        MODEL_D2,
-        MODEL_D2X,
-        MODEL_D1,
-        MODEL_DX,
-        MODEL_HDAV,     /* without daughterboard */
-        MODEL_HDAV_H6,  /* with H6 daughterboard */
-        MODEL_ST,
-        MODEL_ST_H6,
-        MODEL_STX,
-};
-
-static struct pci_device_id xonar_ids[] __devinitdata = {
-        { OXYGEN_PCI_SUBID(0x1043, 0x8269), .driver_data = MODEL_D2 },
-        { OXYGEN_PCI_SUBID(0x1043, 0x8275), .driver_data = MODEL_DX },
-        { OXYGEN_PCI_SUBID(0x1043, 0x82b7), .driver_data = MODEL_D2X },
-        { OXYGEN_PCI_SUBID(0x1043, 0x8314), .driver_data = MODEL_HDAV },
-        { OXYGEN_PCI_SUBID(0x1043, 0x8327), .driver_data = MODEL_DX },
-        { OXYGEN_PCI_SUBID(0x1043, 0x834f), .driver_data = MODEL_D1 },
-        { OXYGEN_PCI_SUBID(0x1043, 0x835c), .driver_data = MODEL_STX },
-        { OXYGEN_PCI_SUBID(0x1043, 0x835d), .driver_data = MODEL_ST },
+static DEFINE_PCI_DEVICE_TABLE(xonar_ids) = {
+        { OXYGEN_PCI_SUBID(0x1043, 0x8269) },
+        { OXYGEN_PCI_SUBID(0x1043, 0x8275) },
+        { OXYGEN_PCI_SUBID(0x1043, 0x82b7) },
+        { OXYGEN_PCI_SUBID(0x1043, 0x8314) },
+        { OXYGEN_PCI_SUBID(0x1043, 0x8327) },
+        { OXYGEN_PCI_SUBID(0x1043, 0x834f) },
+        { OXYGEN_PCI_SUBID(0x1043, 0x835c) },
+        { OXYGEN_PCI_SUBID(0x1043, 0x835d) },
+        { OXYGEN_PCI_SUBID(0x1043, 0x838e) },
         { OXYGEN_PCI_SUBID_BROKEN_EEPROM },
         { }
 };
 MODULE_DEVICE_TABLE(pci, xonar_ids);
 
-
-#define GPIO_CS53x1_M_MASK      0x000c
-#define GPIO_CS53x1_M_SINGLE    0x0000
-#define GPIO_CS53x1_M_DOUBLE    0x0004
-#define GPIO_CS53x1_M_QUAD      0x0008
-
-#define GPIO_D2X_EXT_POWER      0x0020
-#define GPIO_D2_ALT             0x0080
-#define GPIO_D2_OUTPUT_ENABLE   0x0100
-
-#define GPI_DX_EXT_POWER        0x01
-#define GPIO_DX_OUTPUT_ENABLE   0x0001
-#define GPIO_DX_FRONT_PANEL     0x0002
-#define GPIO_DX_INPUT_ROUTE     0x0100
-
-#define GPIO_DB_MASK            0x0030
-#define GPIO_DB_H6              0x0000
-#define GPIO_DB_XX              0x0020
-
-#define GPIO_ST_HP_REAR         0x0002
-#define GPIO_ST_HP              0x0080
-
-#define I2C_DEVICE_PCM1796(i)   (0x98 + ((i) << 1))     /* 10011, ADx=i, /W=0 */
-#define I2C_DEVICE_CS4398       0x9e    /* 10011, AD1=1, AD0=1, /W=0 */
-#define I2C_DEVICE_CS4362A      0x30    /* 001100, AD0=0, /W=0 */
-
-struct xonar_data {
-        unsigned int anti_pop_delay;
-        unsigned int dacs;
-        u16 output_enable_bit;
-        u8 ext_power_reg;
-        u8 ext_power_int_reg;
-        u8 ext_power_bit;
-        u8 has_power;
-        u8 pcm1796_oversampling;
-        u8 cs4398_fm;
-        u8 cs4362a_fm;
-        u8 hdmi_params[5];
-};
-
-static void xonar_gpio_changed(struct oxygen *chip);
-
-static inline void pcm1796_write_spi(struct oxygen *chip, unsigned int codec,
-                                     u8 reg, u8 value)
-{
-        /* maps ALSA channel pair number to SPI output */
-        static const u8 codec_map[4] = {
-                0, 1, 2, 4
-        };
-        oxygen_write_spi(chip, OXYGEN_SPI_TRIGGER  |
-                         OXYGEN_SPI_DATA_LENGTH_2 |
-                         OXYGEN_SPI_CLOCK_160 |
-                         (codec_map[codec] << OXYGEN_SPI_CODEC_SHIFT) |
-                         OXYGEN_SPI_CEN_LATCH_CLOCK_HI,
-                         (reg << 8) | value);
-}
-
-static inline void pcm1796_write_i2c(struct oxygen *chip, unsigned int codec,
-                                     u8 reg, u8 value)
-{
-        oxygen_write_i2c(chip, I2C_DEVICE_PCM1796(codec), reg, value);
-}
-
-static void pcm1796_write(struct oxygen *chip, unsigned int codec,
-                          u8 reg, u8 value)
-{
-        if ((chip->model.function_flags & OXYGEN_FUNCTION_2WIRE_SPI_MASK) ==
-            OXYGEN_FUNCTION_SPI)
-                pcm1796_write_spi(chip, codec, reg, value);
-        else
-                pcm1796_write_i2c(chip, codec, reg, value);
-}
-
-static void cs4398_write(struct oxygen *chip, u8 reg, u8 value)
-{
-        oxygen_write_i2c(chip, I2C_DEVICE_CS4398, reg, value);
-}
-
-static void cs4362a_write(struct oxygen *chip, u8 reg, u8 value)
-{
-        oxygen_write_i2c(chip, I2C_DEVICE_CS4362A, reg, value);
-}
-
-static void hdmi_write_command(struct oxygen *chip, u8 command,
-                               unsigned int count, const u8 *params)
-{
-        unsigned int i;
-        u8 checksum;
-
-        oxygen_write_uart(chip, 0xfb);
-        oxygen_write_uart(chip, 0xef);
-        oxygen_write_uart(chip, command);
-        oxygen_write_uart(chip, count);
-        for (i = 0; i < count; ++i)
-                oxygen_write_uart(chip, params[i]);
-        checksum = 0xfb + 0xef + command + count;
-        for (i = 0; i < count; ++i)
-                checksum += params[i];
-        oxygen_write_uart(chip, checksum);
-}
-
-static void xonar_enable_output(struct oxygen *chip)
-{
-        struct xonar_data *data = chip->model_data;
-
-        msleep(data->anti_pop_delay);
-        oxygen_set_bits16(chip, OXYGEN_GPIO_DATA, data->output_enable_bit);
-}
-
-static void xonar_common_init(struct oxygen *chip)
-{
-        struct xonar_data *data = chip->model_data;
-
-        if (data->ext_power_reg) {
-                oxygen_set_bits8(chip, data->ext_power_int_reg,
-                                 data->ext_power_bit);
-                chip->interrupt_mask |= OXYGEN_INT_GPIO;
-                chip->model.gpio_changed = xonar_gpio_changed;
-                data->has_power = !!(oxygen_read8(chip, data->ext_power_reg)
-                                     & data->ext_power_bit);
-        }
-        oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL,
-                          GPIO_CS53x1_M_MASK | data->output_enable_bit);
-        oxygen_write16_masked(chip, OXYGEN_GPIO_DATA,
-                              GPIO_CS53x1_M_SINGLE, GPIO_CS53x1_M_MASK);
-        oxygen_ac97_set_bits(chip, 0, CM9780_JACK, CM9780_FMIC2MIC);
-        xonar_enable_output(chip);
-}
-
-static void update_pcm1796_volume(struct oxygen *chip)
-{
-        struct xonar_data *data = chip->model_data;
-        unsigned int i;
-
-        for (i = 0; i < data->dacs; ++i) {
-                pcm1796_write(chip, i, 16, chip->dac_volume[i * 2]);
-                pcm1796_write(chip, i, 17, chip->dac_volume[i * 2 + 1]);
-        }
-}
-
-static void update_pcm1796_mute(struct oxygen *chip)
-{
-        struct xonar_data *data = chip->model_data;
-        unsigned int i;
-        u8 value;
-
-        value = PCM1796_DMF_DISABLED | PCM1796_FMT_24_LJUST | PCM1796_ATLD;
-        if (chip->dac_mute)
-                value |= PCM1796_MUTE;
-        for (i = 0; i < data->dacs; ++i)
-                pcm1796_write(chip, i, 18, value);
-}
-
-static void pcm1796_init(struct oxygen *chip)
-{
-        struct xonar_data *data = chip->model_data;
-        unsigned int i;
-
-        for (i = 0; i < data->dacs; ++i) {
-                pcm1796_write(chip, i, 19, PCM1796_FLT_SHARP | PCM1796_ATS_1);
-                pcm1796_write(chip, i, 20, data->pcm1796_oversampling);
-                pcm1796_write(chip, i, 21, 0);
-        }
-        update_pcm1796_mute(chip); /* set ATLD before ATL/ATR */
-        update_pcm1796_volume(chip);
-}
-
-static void xonar_d2_init(struct oxygen *chip)
-{
-        struct xonar_data *data = chip->model_data;
-
-        data->anti_pop_delay = 300;
-        data->dacs = 4;
-        data->output_enable_bit = GPIO_D2_OUTPUT_ENABLE;
-        data->pcm1796_oversampling = PCM1796_OS_64;
-
-        pcm1796_init(chip);
-
-        oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_D2_ALT);
-        oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA, GPIO_D2_ALT);
-
-        xonar_common_init(chip);
-
-        snd_component_add(chip->card, "PCM1796");
-        snd_component_add(chip->card, "CS5381");
-}
-
-static void xonar_d2x_init(struct oxygen *chip)
-{
-        struct xonar_data *data = chip->model_data;
-
-        data->ext_power_reg = OXYGEN_GPIO_DATA;
-        data->ext_power_int_reg = OXYGEN_GPIO_INTERRUPT_MASK;
-        data->ext_power_bit = GPIO_D2X_EXT_POWER;
-        oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_D2X_EXT_POWER);
-
-        xonar_d2_init(chip);
-}
-
-static void update_cs4362a_volumes(struct oxygen *chip)
-{
-        u8 mute;
-
-        mute = chip->dac_mute ? CS4362A_MUTE : 0;
-        cs4362a_write(chip, 7, (127 - chip->dac_volume[2]) | mute);
-        cs4362a_write(chip, 8, (127 - chip->dac_volume[3]) | mute);
-        cs4362a_write(chip, 10, (127 - chip->dac_volume[4]) | mute);
-        cs4362a_write(chip, 11, (127 - chip->dac_volume[5]) | mute);
-        cs4362a_write(chip, 13, (127 - chip->dac_volume[6]) | mute);
-        cs4362a_write(chip, 14, (127 - chip->dac_volume[7]) | mute);
-}
-
-static void update_cs43xx_volume(struct oxygen *chip)
-{
-        cs4398_write(chip, 5, (127 - chip->dac_volume[0]) * 2);
-        cs4398_write(chip, 6, (127 - chip->dac_volume[1]) * 2);
-        update_cs4362a_volumes(chip);
-}
-
-static void update_cs43xx_mute(struct oxygen *chip)
-{
-        u8 reg;
-
-        reg = CS4398_MUTEP_LOW | CS4398_PAMUTE;
-        if (chip->dac_mute)
-                reg |= CS4398_MUTE_B | CS4398_MUTE_A;
-        cs4398_write(chip, 4, reg);
-        update_cs4362a_volumes(chip);
-}
-
-static void cs43xx_init(struct oxygen *chip)
-{
-        struct xonar_data *data = chip->model_data;
-
-        /* set CPEN (control port mode) and power down */
-        cs4398_write(chip, 8, CS4398_CPEN | CS4398_PDN);
-        cs4362a_write(chip, 0x01, CS4362A_PDN | CS4362A_CPEN);
-        /* configure */
-        cs4398_write(chip, 2, data->cs4398_fm);
-        cs4398_write(chip, 3, CS4398_ATAPI_B_R | CS4398_ATAPI_A_L);
-        cs4398_write(chip, 7, CS4398_RMP_DN | CS4398_RMP_UP |
-                     CS4398_ZERO_CROSS | CS4398_SOFT_RAMP);
-        cs4362a_write(chip, 0x02, CS4362A_DIF_LJUST);
-        cs4362a_write(chip, 0x03, CS4362A_MUTEC_6 | CS4362A_AMUTE |
-                      CS4362A_RMP_UP | CS4362A_ZERO_CROSS | CS4362A_SOFT_RAMP);
-        cs4362a_write(chip, 0x04, CS4362A_RMP_DN | CS4362A_DEM_NONE);
-        cs4362a_write(chip, 0x05, 0);
-        cs4362a_write(chip, 0x06, data->cs4362a_fm);
-        cs4362a_write(chip, 0x09, data->cs4362a_fm);
-        cs4362a_write(chip, 0x0c, data->cs4362a_fm);
-        update_cs43xx_volume(chip);
-        update_cs43xx_mute(chip);
-        /* clear power down */
-        cs4398_write(chip, 8, CS4398_CPEN);
-        cs4362a_write(chip, 0x01, CS4362A_CPEN);
-}
-
-static void xonar_d1_init(struct oxygen *chip)
-{
-        struct xonar_data *data = chip->model_data;
-
-        data->anti_pop_delay = 800;
-        data->output_enable_bit = GPIO_DX_OUTPUT_ENABLE;
-        data->cs4398_fm = CS4398_FM_SINGLE | CS4398_DEM_NONE | CS4398_DIF_LJUST;
-        data->cs4362a_fm = CS4362A_FM_SINGLE |
-                CS4362A_ATAPI_B_R | CS4362A_ATAPI_A_L;
-
-        oxygen_write16(chip, OXYGEN_2WIRE_BUS_STATUS,
-                       OXYGEN_2WIRE_LENGTH_8 |
-                       OXYGEN_2WIRE_INTERRUPT_MASK |
-                       OXYGEN_2WIRE_SPEED_FAST);
-
-        cs43xx_init(chip);
-
-        oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL,
-                          GPIO_DX_FRONT_PANEL | GPIO_DX_INPUT_ROUTE);
-        oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA,
-                            GPIO_DX_FRONT_PANEL | GPIO_DX_INPUT_ROUTE);
-
-        xonar_common_init(chip);
-
-        snd_component_add(chip->card, "CS4398");
-        snd_component_add(chip->card, "CS4362A");
-        snd_component_add(chip->card, "CS5361");
-}
-
-static void xonar_dx_init(struct oxygen *chip)
-{
-        struct xonar_data *data = chip->model_data;
-
-        data->ext_power_reg = OXYGEN_GPI_DATA;
-        data->ext_power_int_reg = OXYGEN_GPI_INTERRUPT_MASK;
-        data->ext_power_bit = GPI_DX_EXT_POWER;
-
-        xonar_d1_init(chip);
-}
-
-static void xonar_hdav_init(struct oxygen *chip)
-{
-        struct xonar_data *data = chip->model_data;
-        u8 param;
-
-        oxygen_write16(chip, OXYGEN_2WIRE_BUS_STATUS,
-                       OXYGEN_2WIRE_LENGTH_8 |
-                       OXYGEN_2WIRE_INTERRUPT_MASK |
-                       OXYGEN_2WIRE_SPEED_FAST);
-
-        data->anti_pop_delay = 100;
-        data->dacs = chip->model.private_data == MODEL_HDAV_H6 ? 4 : 1;
-        data->output_enable_bit = GPIO_DX_OUTPUT_ENABLE;
-        data->ext_power_reg = OXYGEN_GPI_DATA;
-        data->ext_power_int_reg = OXYGEN_GPI_INTERRUPT_MASK;
-        data->ext_power_bit = GPI_DX_EXT_POWER;
-        data->pcm1796_oversampling = PCM1796_OS_64;
-
-        pcm1796_init(chip);
-
-        oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_DX_INPUT_ROUTE);
-        oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA, GPIO_DX_INPUT_ROUTE);
-
-        oxygen_reset_uart(chip);
-        param = 0;
-        hdmi_write_command(chip, 0x61, 1, &param);
-        param = 1;
-        hdmi_write_command(chip, 0x74, 1, &param);
-        data->hdmi_params[1] = IEC958_AES3_CON_FS_48000;
-        data->hdmi_params[4] = 1;
-        hdmi_write_command(chip, 0x54, 5, data->hdmi_params);
-
-        xonar_common_init(chip);
-
-        snd_component_add(chip->card, "PCM1796");
-        snd_component_add(chip->card, "CS5381");
-}
-
-static void xonar_st_init(struct oxygen *chip)
-{
-        struct xonar_data *data = chip->model_data;
-
-        oxygen_write16(chip, OXYGEN_2WIRE_BUS_STATUS,
-                       OXYGEN_2WIRE_LENGTH_8 |
-                       OXYGEN_2WIRE_INTERRUPT_MASK |
-                       OXYGEN_2WIRE_SPEED_FAST);
-
-        if (chip->model.private_data == MODEL_ST_H6)
-                chip->model.dac_channels = 8;
-        data->anti_pop_delay = 100;
-        data->dacs = chip->model.private_data == MODEL_ST_H6 ? 4 : 1;
-        data->output_enable_bit = GPIO_DX_OUTPUT_ENABLE;
-        data->pcm1796_oversampling = PCM1796_OS_64;
-
-        pcm1796_init(chip);
-
-        oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL,
-                          GPIO_DX_INPUT_ROUTE | GPIO_ST_HP_REAR | GPIO_ST_HP);
-        oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA,
-                            GPIO_DX_INPUT_ROUTE | GPIO_ST_HP_REAR | GPIO_ST_HP);
-
-        xonar_common_init(chip);
-
-        snd_component_add(chip->card, "PCM1792A");
-        snd_component_add(chip->card, "CS5381");
-}
-
-static void xonar_stx_init(struct oxygen *chip)
-{
-        struct xonar_data *data = chip->model_data;
-
-        data->ext_power_reg = OXYGEN_GPI_DATA;
-        data->ext_power_int_reg = OXYGEN_GPI_INTERRUPT_MASK;
-        data->ext_power_bit = GPI_DX_EXT_POWER;
-
-        xonar_st_init(chip);
-}
-
-static void xonar_disable_output(struct oxygen *chip)
-{
-        struct xonar_data *data = chip->model_data;
-
-        oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA, data->output_enable_bit);
-}
-
-static void xonar_d2_cleanup(struct oxygen *chip)
-{
-        xonar_disable_output(chip);
-}
-
-static void xonar_d1_cleanup(struct oxygen *chip)
-{
-        xonar_disable_output(chip);
-        cs4362a_write(chip, 0x01, CS4362A_PDN | CS4362A_CPEN);
-        oxygen_clear_bits8(chip, OXYGEN_FUNCTION, OXYGEN_FUNCTION_RESET_CODEC);
-}
-
-static void xonar_hdav_cleanup(struct oxygen *chip)
-{
-        u8 param = 0;
-
-        hdmi_write_command(chip, 0x74, 1, &param);
-        xonar_disable_output(chip);
-}
-
-static void xonar_st_cleanup(struct oxygen *chip)
-{
-        xonar_disable_output(chip);
-}
-
-static void xonar_d2_suspend(struct oxygen *chip)
-{
-        xonar_d2_cleanup(chip);
-}
-
-static void xonar_d1_suspend(struct oxygen *chip)
-{
-        xonar_d1_cleanup(chip);
-}
-
-static void xonar_hdav_suspend(struct oxygen *chip)
-{
-        xonar_hdav_cleanup(chip);
-        msleep(2);
-}
-
-static void xonar_st_suspend(struct oxygen *chip)
-{
-        xonar_st_cleanup(chip);
-}
-
-static void xonar_d2_resume(struct oxygen *chip)
-{
-        pcm1796_init(chip);
-        xonar_enable_output(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);
-}
-
-static void xonar_hdav_resume(struct oxygen *chip)
-{
-        struct xonar_data *data = chip->model_data;
-        u8 param;
-
-        oxygen_reset_uart(chip);
-        param = 0;
-        hdmi_write_command(chip, 0x61, 1, &param);
-        param = 1;
-        hdmi_write_command(chip, 0x74, 1, &param);
-        hdmi_write_command(chip, 0x54, 5, data->hdmi_params);
-        pcm1796_init(chip);
-        xonar_enable_output(chip);
-}
-
-static void xonar_st_resume(struct oxygen *chip)
-{
-        pcm1796_init(chip);
-        xonar_enable_output(chip);
-}
-
-static void xonar_hdav_pcm_hardware_filter(unsigned int channel,
-                                           struct snd_pcm_hardware *hardware)
-{
-        if (channel == PCM_MULTICH) {
-                hardware->rates = SNDRV_PCM_RATE_44100 |
-                                  SNDRV_PCM_RATE_48000 |
-                                  SNDRV_PCM_RATE_96000 |
-                                  SNDRV_PCM_RATE_192000;
-                hardware->rate_min = 44100;
-        }
-}
-
-static void set_pcm1796_params(struct oxygen *chip,
-                               struct snd_pcm_hw_params *params)
-{
-        struct xonar_data *data = chip->model_data;
-        unsigned int i;
-
-        data->pcm1796_oversampling =
-                params_rate(params) >= 96000 ? PCM1796_OS_32 : PCM1796_OS_64;
-        for (i = 0; i < data->dacs; ++i)
-                pcm1796_write(chip, i, 20, data->pcm1796_oversampling);
-}
-
-static void set_cs53x1_params(struct oxygen *chip,
-                              struct snd_pcm_hw_params *params)
-{
-        unsigned int value;
-
-        if (params_rate(params) <= 54000)
-                value = GPIO_CS53x1_M_SINGLE;
-        else if (params_rate(params) <= 108000)
-                value = GPIO_CS53x1_M_DOUBLE;
-        else
-                value = GPIO_CS53x1_M_QUAD;
-        oxygen_write16_masked(chip, OXYGEN_GPIO_DATA,
-                              value, GPIO_CS53x1_M_MASK);
-}
-
-static void set_cs43xx_params(struct oxygen *chip,
-                              struct snd_pcm_hw_params *params)
-{
-        struct xonar_data *data = chip->model_data;
-
-        data->cs4398_fm = CS4398_DEM_NONE | CS4398_DIF_LJUST;
-        data->cs4362a_fm = CS4362A_ATAPI_B_R | CS4362A_ATAPI_A_L;
-        if (params_rate(params) <= 50000) {
-                data->cs4398_fm |= CS4398_FM_SINGLE;
-                data->cs4362a_fm |= CS4362A_FM_SINGLE;
-        } else if (params_rate(params) <= 100000) {
-                data->cs4398_fm |= CS4398_FM_DOUBLE;
-                data->cs4362a_fm |= CS4362A_FM_DOUBLE;
-        } else {
-                data->cs4398_fm |= CS4398_FM_QUAD;
-                data->cs4362a_fm |= CS4362A_FM_QUAD;
-        }
-        cs4398_write(chip, 2, data->cs4398_fm);
-        cs4362a_write(chip, 0x06, data->cs4362a_fm);
-        cs4362a_write(chip, 0x09, data->cs4362a_fm);
-        cs4362a_write(chip, 0x0c, data->cs4362a_fm);
-}
-
-static void set_hdmi_params(struct oxygen *chip,
-                            struct snd_pcm_hw_params *params)
-{
-        struct xonar_data *data = chip->model_data;
-
-        data->hdmi_params[0] = 0; /* 1 = non-audio */
-        switch (params_rate(params)) {
-        case 44100:
-                data->hdmi_params[1] = IEC958_AES3_CON_FS_44100;
-                break;
-        case 48000:
-                data->hdmi_params[1] = IEC958_AES3_CON_FS_48000;
-                break;
-        default: /* 96000 */
-                data->hdmi_params[1] = IEC958_AES3_CON_FS_96000;
-                break;
-        case 192000:
-                data->hdmi_params[1] = IEC958_AES3_CON_FS_192000;
-                break;
-        }
-        data->hdmi_params[2] = params_channels(params) / 2 - 1;
-        if (params_format(params) == SNDRV_PCM_FORMAT_S16_LE)
-                data->hdmi_params[3] = 0;
-        else
-                data->hdmi_params[3] = 0xc0;
-        data->hdmi_params[4] = 1; /* ? */
-        hdmi_write_command(chip, 0x54, 5, data->hdmi_params);
-}
-
-static void set_hdav_params(struct oxygen *chip,
-                            struct snd_pcm_hw_params *params)
-{
-        set_pcm1796_params(chip, params);
-        set_hdmi_params(chip, params);
-}
-
-static void xonar_gpio_changed(struct oxygen *chip)
-{
-        struct xonar_data *data = chip->model_data;
-        u8 has_power;
-
-        has_power = !!(oxygen_read8(chip, data->ext_power_reg)
-                       & data->ext_power_bit);
-        if (has_power != data->has_power) {
-                data->has_power = has_power;
-                if (has_power) {
-                        snd_printk(KERN_NOTICE "power restored\n");
-                } else {
-                        snd_printk(KERN_CRIT
-                                   "Hey! Don't unplug the power cable!\n");
-                        /* TODO: stop PCMs */
-                }
-        }
-}
-
-static void xonar_hdav_uart_input(struct oxygen *chip)
-{
-        if (chip->uart_input_count >= 2 &&
-            chip->uart_input[chip->uart_input_count - 2] == 'O' &&
-            chip->uart_input[chip->uart_input_count - 1] == 'K') {
-                printk(KERN_DEBUG "message from Xonar HDAV HDMI chip received:\n");
-                print_hex_dump_bytes("", DUMP_PREFIX_OFFSET,
-                                     chip->uart_input, chip->uart_input_count);
-                chip->uart_input_count = 0;
-        }
-}
-
-static int gpio_bit_switch_get(struct snd_kcontrol *ctl,
-                               struct snd_ctl_elem_value *value)
-{
-        struct oxygen *chip = ctl->private_data;
-        u16 bit = ctl->private_value;
-
-        value->value.integer.value[0] =
-                !!(oxygen_read16(chip, OXYGEN_GPIO_DATA) & bit);
-        return 0;
-}
-
-static int gpio_bit_switch_put(struct snd_kcontrol *ctl,
-                               struct snd_ctl_elem_value *value)
-{
-        struct oxygen *chip = ctl->private_data;
-        u16 bit = ctl->private_value;
-        u16 old_bits, new_bits;
-        int changed;
-
-        spin_lock_irq(&chip->reg_lock);
-        old_bits = oxygen_read16(chip, OXYGEN_GPIO_DATA);
-        if (value->value.integer.value[0])
-                new_bits = old_bits | bit;
-        else
-                new_bits = old_bits & ~bit;
-        changed = new_bits != old_bits;
-        if (changed)
-                oxygen_write16(chip, OXYGEN_GPIO_DATA, new_bits);
-        spin_unlock_irq(&chip->reg_lock);
-        return changed;
-}
-
-static const struct snd_kcontrol_new alt_switch = {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "Analog Loopback Switch",
-        .info = snd_ctl_boolean_mono_info,
-        .get = gpio_bit_switch_get,
-        .put = gpio_bit_switch_put,
-        .private_value = GPIO_D2_ALT,
-};
-
-static const struct snd_kcontrol_new front_panel_switch = {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "Front Panel Switch",
-        .info = snd_ctl_boolean_mono_info,
-        .get = gpio_bit_switch_get,
-        .put = gpio_bit_switch_put,
-        .private_value = GPIO_DX_FRONT_PANEL,
-};
-
-static int st_output_switch_info(struct snd_kcontrol *ctl,
-                                 struct snd_ctl_elem_info *info)
-{
-        static const char *const names[3] = {
-                "Speakers", "Headphones", "FP Headphones"
-        };
-
-        info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
-        info->count = 1;
-        info->value.enumerated.items = 3;
-        if (info->value.enumerated.item >= 3)
-                info->value.enumerated.item = 2;
-        strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
-        return 0;
-}
-
-static int st_output_switch_get(struct snd_kcontrol *ctl,
-                                struct snd_ctl_elem_value *value)
-{
-        struct oxygen *chip = ctl->private_data;
-        u16 gpio;
-
-        gpio = oxygen_read16(chip, OXYGEN_GPIO_DATA);
-        if (!(gpio & GPIO_ST_HP))
-                value->value.enumerated.item[0] = 0;
-        else if (gpio & GPIO_ST_HP_REAR)
-                value->value.enumerated.item[0] = 1;
-        else
-                value->value.enumerated.item[0] = 2;
-        return 0;
-}
-
-
-static int st_output_switch_put(struct snd_kcontrol *ctl,
-                                struct snd_ctl_elem_value *value)
-{
-        struct oxygen *chip = ctl->private_data;
-        u16 gpio_old, gpio;
-
-        mutex_lock(&chip->mutex);
-        gpio_old = oxygen_read16(chip, OXYGEN_GPIO_DATA);
-        gpio = gpio_old;
-        switch (value->value.enumerated.item[0]) {
-        case 0:
-                gpio &= ~(GPIO_ST_HP | GPIO_ST_HP_REAR);
-                break;
-        case 1:
-                gpio |= GPIO_ST_HP | GPIO_ST_HP_REAR;
-                break;
-        case 2:
-                gpio = (gpio | GPIO_ST_HP) & ~GPIO_ST_HP_REAR;
-                break;
-        }
-        oxygen_write16(chip, OXYGEN_GPIO_DATA, gpio);
-        mutex_unlock(&chip->mutex);
-        return gpio != gpio_old;
-}
-
-static const struct snd_kcontrol_new st_output_switch = {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "Analog Output",
-        .info = st_output_switch_info,
-        .get = st_output_switch_get,
-        .put = st_output_switch_put,
-};
-
-static void xonar_line_mic_ac97_switch(struct oxygen *chip,
-                                       unsigned int reg, unsigned int mute)
-{
-        if (reg == AC97_LINE) {
-                spin_lock_irq(&chip->reg_lock);
-                oxygen_write16_masked(chip, OXYGEN_GPIO_DATA,
-                                      mute ? GPIO_DX_INPUT_ROUTE : 0,
-                                      GPIO_DX_INPUT_ROUTE);
-                spin_unlock_irq(&chip->reg_lock);
-        }
-}
-
-static const DECLARE_TLV_DB_SCALE(pcm1796_db_scale, -6000, 50, 0);
-static const DECLARE_TLV_DB_SCALE(cs4362a_db_scale, -6000, 100, 0);
-
-static int xonar_d2_control_filter(struct snd_kcontrol_new *template)
-{
-        if (!strncmp(template->name, "CD Capture ", 11))
-                /* CD in is actually connected to the video in pin */
-                template->private_value ^= AC97_CD ^ AC97_VIDEO;
-        return 0;
-}
-
-static int xonar_d1_control_filter(struct snd_kcontrol_new *template)
-{
-        if (!strncmp(template->name, "CD Capture ", 11))
-                return 1; /* no CD input */
-        return 0;
-}
-
-static int xonar_st_control_filter(struct snd_kcontrol_new *template)
-{
-        if (!strncmp(template->name, "CD Capture ", 11))
-                return 1; /* no CD input */
-        if (!strcmp(template->name, "Stereo Upmixing"))
-                return 1; /* stereo only - we don't need upmixing */
-        return 0;
-}
-
-static int xonar_d2_mixer_init(struct oxygen *chip)
-{
-        return snd_ctl_add(chip->card, snd_ctl_new1(&alt_switch, chip));
-}
-
-static int xonar_d1_mixer_init(struct oxygen *chip)
-{
-        return snd_ctl_add(chip->card, snd_ctl_new1(&front_panel_switch, chip));
-}
-
-static int xonar_st_mixer_init(struct oxygen *chip)
-{
-        return snd_ctl_add(chip->card, snd_ctl_new1(&st_output_switch, chip));
-}
-
-static const struct oxygen_model model_xonar_d2 = {
-        .longname = "Asus Virtuoso 200",
-        .chip = "AV200",
-        .init = xonar_d2_init,
-        .control_filter = xonar_d2_control_filter,
-        .mixer_init = xonar_d2_mixer_init,
-        .cleanup = xonar_d2_cleanup,
-        .suspend = xonar_d2_suspend,
-        .resume = xonar_d2_resume,
-        .set_dac_params = set_pcm1796_params,
-        .set_adc_params = set_cs53x1_params,
-        .update_dac_volume = update_pcm1796_volume,
-        .update_dac_mute = update_pcm1796_mute,
-        .dac_tlv = pcm1796_db_scale,
-        .model_data_size = sizeof(struct xonar_data),
-        .device_config = PLAYBACK_0_TO_I2S |
-                         PLAYBACK_1_TO_SPDIF |
-                         CAPTURE_0_FROM_I2S_2 |
-                         CAPTURE_1_FROM_SPDIF |
-                         MIDI_OUTPUT |
-                         MIDI_INPUT,
-        .dac_channels = 8,
-        .dac_volume_min = 255 - 2*60,
-        .dac_volume_max = 255,
-        .misc_flags = OXYGEN_MISC_MIDI,
-        .function_flags = OXYGEN_FUNCTION_SPI |
-                          OXYGEN_FUNCTION_ENABLE_SPI_4_5,
-        .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
-        .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
-};
-
-static const struct oxygen_model model_xonar_d1 = {
-        .longname = "Asus Virtuoso 100",
-        .chip = "AV200",
-        .init = xonar_d1_init,
-        .control_filter = xonar_d1_control_filter,
-        .mixer_init = xonar_d1_mixer_init,
-        .cleanup = xonar_d1_cleanup,
-        .suspend = xonar_d1_suspend,
-        .resume = xonar_d1_resume,
-        .set_dac_params = set_cs43xx_params,
-        .set_adc_params = set_cs53x1_params,
-        .update_dac_volume = update_cs43xx_volume,
-        .update_dac_mute = update_cs43xx_mute,
-        .ac97_switch = xonar_line_mic_ac97_switch,
-        .dac_tlv = cs4362a_db_scale,
-        .model_data_size = sizeof(struct xonar_data),
-        .device_config = PLAYBACK_0_TO_I2S |
-                         PLAYBACK_1_TO_SPDIF |
-                         CAPTURE_0_FROM_I2S_2,
-        .dac_channels = 8,
-        .dac_volume_min = 127 - 60,
-        .dac_volume_max = 127,
-        .function_flags = OXYGEN_FUNCTION_2WIRE,
-        .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
-        .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
-};
-
-static const struct oxygen_model model_xonar_hdav = {
-        .longname = "Asus Virtuoso 200",
-        .chip = "AV200",
-        .init = xonar_hdav_init,
-        .cleanup = xonar_hdav_cleanup,
-        .suspend = xonar_hdav_suspend,
-        .resume = xonar_hdav_resume,
-        .pcm_hardware_filter = xonar_hdav_pcm_hardware_filter,
-        .set_dac_params = set_hdav_params,
-        .set_adc_params = set_cs53x1_params,
-        .update_dac_volume = update_pcm1796_volume,
-        .update_dac_mute = update_pcm1796_mute,
-        .uart_input = xonar_hdav_uart_input,
-        .ac97_switch = xonar_line_mic_ac97_switch,
-        .dac_tlv = pcm1796_db_scale,
-        .model_data_size = sizeof(struct xonar_data),
-        .device_config = PLAYBACK_0_TO_I2S |
-                         PLAYBACK_1_TO_SPDIF |
-                         CAPTURE_0_FROM_I2S_2 |
-                         CAPTURE_1_FROM_SPDIF,
-        .dac_channels = 8,
-        .dac_volume_min = 255 - 2*60,
-        .dac_volume_max = 255,
-        .misc_flags = OXYGEN_MISC_MIDI,
-        .function_flags = OXYGEN_FUNCTION_2WIRE,
-        .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
-        .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
-};
-
-static const struct oxygen_model model_xonar_st = {
-        .longname = "Asus Virtuoso 100",
-        .chip = "AV200",
-        .init = xonar_st_init,
-        .control_filter = xonar_st_control_filter,
-        .mixer_init = xonar_st_mixer_init,
-        .cleanup = xonar_st_cleanup,
-        .suspend = xonar_st_suspend,
-        .resume = xonar_st_resume,
-        .set_dac_params = set_pcm1796_params,
-        .set_adc_params = set_cs53x1_params,
-        .update_dac_volume = update_pcm1796_volume,
-        .update_dac_mute = update_pcm1796_mute,
-        .ac97_switch = xonar_line_mic_ac97_switch,
-        .dac_tlv = pcm1796_db_scale,
-        .model_data_size = sizeof(struct xonar_data),
-        .device_config = PLAYBACK_0_TO_I2S |
-                         PLAYBACK_1_TO_SPDIF |
-                         CAPTURE_0_FROM_I2S_2,
-        .dac_channels = 2,
-        .dac_volume_min = 255 - 2*60,
-        .dac_volume_max = 255,
-        .function_flags = OXYGEN_FUNCTION_2WIRE,
-        .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
-        .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
-};
-
 static int __devinit get_xonar_model(struct oxygen *chip,
                                      const struct pci_device_id *id)
 {
-        static const struct oxygen_model *const models[] = {
-                [MODEL_D1]      = &model_xonar_d1,
-                [MODEL_DX]      = &model_xonar_d1,
-                [MODEL_D2]      = &model_xonar_d2,
-                [MODEL_D2X]     = &model_xonar_d2,
-                [MODEL_HDAV]    = &model_xonar_hdav,
-                [MODEL_ST]      = &model_xonar_st,
-                [MODEL_STX]     = &model_xonar_st,
-        };
-        static const char *const names[] = {
-                [MODEL_D1]      = "Xonar D1",
-                [MODEL_DX]      = "Xonar DX",
-                [MODEL_D2]      = "Xonar D2",
-                [MODEL_D2X]     = "Xonar D2X",
-                [MODEL_HDAV]    = "Xonar HDAV1.3",
-                [MODEL_HDAV_H6] = "Xonar HDAV1.3+H6",
-                [MODEL_ST]      = "Xonar Essence ST",
-                [MODEL_ST_H6]   = "Xonar Essence ST+H6",
-                [MODEL_STX]     = "Xonar Essence STX",
-        };
-        unsigned int model = id->driver_data;
-
-        if (model >= ARRAY_SIZE(models) || !models[model])
-                return -EINVAL;
-        chip->model = *models[model];
-
-        switch (model) {
-        case MODEL_D2X:
-                chip->model.init = xonar_d2x_init;
-                break;
-        case MODEL_DX:
-                chip->model.init = xonar_dx_init;
-                break;
-        case MODEL_HDAV:
-                oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_DB_MASK);
-                switch (oxygen_read16(chip, OXYGEN_GPIO_DATA) & GPIO_DB_MASK) {
-                case GPIO_DB_H6:
-                        model = MODEL_HDAV_H6;
-                        break;
-                case GPIO_DB_XX:
-                        snd_printk(KERN_ERR "unknown daughterboard\n");
-                        return -ENODEV;
-                }
-                break;
-        case MODEL_ST:
-                oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_DB_MASK);
-                switch (oxygen_read16(chip, OXYGEN_GPIO_DATA) & GPIO_DB_MASK) {
-                case GPIO_DB_H6:
-                        model = MODEL_ST_H6;
-                        break;
-                }
-                break;
-        case MODEL_STX:
-                chip->model.init = xonar_stx_init;
-                oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_DB_MASK);
-                break;
-        }
-
-        chip->model.shortname = names[model];
-        chip->model.private_data = model;
-        return 0;
+        if (get_xonar_pcm179x_model(chip, id) >= 0)
+                return 0;
+        if (get_xonar_cs43xx_model(chip, id) >= 0)
+                return 0;
+        if (get_xonar_wm87x6_model(chip, id) >= 0)
+                return 0;
+        return -EINVAL;
 }
 
 static int __devinit xonar_probe(struct pci_dev *pci,
diff --git a/sound/pci/oxygen/wm8766.h b/sound/pci/oxygen/wm8766.h
new file mode 100644
index 000000000000..e0e849a7eaeb
--- /dev/null
+++ b/sound/pci/oxygen/wm8766.h
@@ -0,0 +1,73 @@
+#ifndef WM8766_H_INCLUDED
+#define WM8766_H_INCLUDED
+
+#define WM8766_LDA1             0x00
+#define WM8766_RDA1             0x01
+#define WM8766_DAC_CTRL         0x02
+#define WM8766_INT_CTRL         0x03
+#define WM8766_LDA2             0x04
+#define WM8766_RDA2             0x05
+#define WM8766_LDA3             0x06
+#define WM8766_RDA3             0x07
+#define WM8766_MASTDA           0x08
+#define WM8766_DAC_CTRL2        0x09
+#define WM8766_DAC_CTRL3        0x0a
+#define WM8766_MUTE1            0x0c
+#define WM8766_MUTE2            0x0f
+#define WM8766_RESET            0x1f
+
+/* LDAx/RDAx/MASTDA */
+#define WM8766_ATT_MASK         0x0ff
+#define WM8766_UPDATE           0x100
+/* DAC_CTRL */
+#define WM8766_MUTEALL          0x001
+#define WM8766_DEEMPALL         0x002
+#define WM8766_PWDN             0x004
+#define WM8766_ATC              0x008
+#define WM8766_IZD              0x010
+#define WM8766_PL_LEFT_MASK     0x060
+#define WM8766_PL_LEFT_MUTE     0x000
+#define WM8766_PL_LEFT_LEFT     0x020
+#define WM8766_PL_LEFT_RIGHT    0x040
+#define WM8766_PL_LEFT_LRMIX    0x060
+#define WM8766_PL_RIGHT_MASK    0x180
+#define WM8766_PL_RIGHT_MUTE    0x000
+#define WM8766_PL_RIGHT_LEFT    0x080
+#define WM8766_PL_RIGHT_RIGHT   0x100
+#define WM8766_PL_RIGHT_LRMIX   0x180
+/* INT_CTRL */
+#define WM8766_FMT_MASK         0x003
+#define WM8766_FMT_RJUST        0x000
+#define WM8766_FMT_LJUST        0x001
+#define WM8766_FMT_I2S          0x002
+#define WM8766_FMT_DSP          0x003
+#define WM8766_LRP              0x004
+#define WM8766_BCP              0x008
+#define WM8766_IWL_MASK         0x030
+#define WM8766_IWL_16           0x000
+#define WM8766_IWL_20           0x010
+#define WM8766_IWL_24           0x020
+#define WM8766_IWL_32           0x030
+#define WM8766_PHASE_MASK       0x1c0
+/* DAC_CTRL2 */
+#define WM8766_ZCD              0x001
+#define WM8766_DZFM_MASK        0x006
+#define WM8766_DMUTE_MASK       0x038
+#define WM8766_DEEMP_MASK       0x1c0
+/* DAC_CTRL3 */
+#define WM8766_DACPD_MASK       0x00e
+#define WM8766_PWRDNALL         0x010
+#define WM8766_MS               0x020
+#define WM8766_RATE_MASK        0x1c0
+#define WM8766_RATE_128         0x000
+#define WM8766_RATE_192         0x040
+#define WM8766_RATE_256         0x080
+#define WM8766_RATE_384         0x0c0
+#define WM8766_RATE_512         0x100
+#define WM8766_RATE_768         0x140
+/* MUTE1 */
+#define WM8766_MPD1             0x040
+/* MUTE2 */
+#define WM8766_MPD2             0x020
+
+#endif
diff --git a/sound/pci/oxygen/wm8776.h b/sound/pci/oxygen/wm8776.h
new file mode 100644
index 000000000000..1a96f5615727
--- /dev/null
+++ b/sound/pci/oxygen/wm8776.h
@@ -0,0 +1,177 @@
+#ifndef WM8776_H_INCLUDED
+#define WM8776_H_INCLUDED
+
+/*
+ * the following register names are from:
+ * wm8776.h  --  WM8776 ASoC driver
+ *
+ * Copyright 2009 Wolfson Microelectronics plc
+ *
+ * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#define WM8776_HPLVOL           0x00
+#define WM8776_HPRVOL           0x01
+#define WM8776_HPMASTER         0x02
+#define WM8776_DACLVOL          0x03
+#define WM8776_DACRVOL          0x04
+#define WM8776_DACMASTER        0x05
+#define WM8776_PHASESWAP        0x06
+#define WM8776_DACCTRL1         0x07
+#define WM8776_DACMUTE          0x08
+#define WM8776_DACCTRL2         0x09
+#define WM8776_DACIFCTRL        0x0a
+#define WM8776_ADCIFCTRL        0x0b
+#define WM8776_MSTRCTRL         0x0c
+#define WM8776_PWRDOWN          0x0d
+#define WM8776_ADCLVOL          0x0e
+#define WM8776_ADCRVOL          0x0f
+#define WM8776_ALCCTRL1         0x10
+#define WM8776_ALCCTRL2         0x11
+#define WM8776_ALCCTRL3         0x12
+#define WM8776_NOISEGATE        0x13
+#define WM8776_LIMITER          0x14
+#define WM8776_ADCMUX           0x15
+#define WM8776_OUTMUX           0x16
+#define WM8776_RESET            0x17
+
+
+/* HPLVOL/HPRVOL/HPMASTER */
+#define WM8776_HPATT_MASK       0x07f
+#define WM8776_HPZCEN           0x080
+#define WM8776_UPDATE           0x100
+
+/* DACLVOL/DACRVOL/DACMASTER */
+#define WM8776_DATT_MASK        0x0ff
+/*#define WM8776_UPDATE         0x100*/
+
+/* PHASESWAP */
+#define WM8776_PH_MASK          0x003
+
+/* DACCTRL1 */
+#define WM8776_DZCEN            0x001
+#define WM8776_ATC              0x002
+#define WM8776_IZD              0x004
+#define WM8776_TOD              0x008
+#define WM8776_PL_LEFT_MASK     0x030
+#define WM8776_PL_LEFT_MUTE     0x000
+#define WM8776_PL_LEFT_LEFT     0x010
+#define WM8776_PL_LEFT_RIGHT    0x020
+#define WM8776_PL_LEFT_LRMIX    0x030
+#define WM8776_PL_RIGHT_MASK    0x0c0
+#define WM8776_PL_RIGHT_MUTE    0x000
+#define WM8776_PL_RIGHT_LEFT    0x040
+#define WM8776_PL_RIGHT_RIGHT   0x080
+#define WM8776_PL_RIGHT_LRMIX   0x0c0
+
+/* DACMUTE */
+#define WM8776_DMUTE            0x001
+
+/* DACCTRL2 */
+#define WM8776_DEEMPH           0x001
+#define WM8776_DZFM_MASK        0x006
+#define WM8776_DZFM_NONE        0x000
+#define WM8776_DZFM_LR          0x002
+#define WM8776_DZFM_BOTH        0x004
+#define WM8776_DZFM_EITHER      0x006
+
+/* DACIFCTRL */
+#define WM8776_DACFMT_MASK      0x003
+#define WM8776_DACFMT_RJUST     0x000
+#define WM8776_DACFMT_LJUST     0x001
+#define WM8776_DACFMT_I2S       0x002
+#define WM8776_DACFMT_DSP       0x003
+#define WM8776_DACLRP           0x004
+#define WM8776_DACBCP           0x008
+#define WM8776_DACWL_MASK       0x030
+#define WM8776_DACWL_16         0x000
+#define WM8776_DACWL_20         0x010
+#define WM8776_DACWL_24         0x020
+#define WM8776_DACWL_32         0x030
+
+/* ADCIFCTRL */
+#define WM8776_ADCFMT_MASK      0x003
+#define WM8776_ADCFMT_RJUST     0x000
+#define WM8776_ADCFMT_LJUST     0x001
+#define WM8776_ADCFMT_I2S       0x002
+#define WM8776_ADCFMT_DSP       0x003
+#define WM8776_ADCLRP           0x004
+#define WM8776_ADCBCP           0x008
+#define WM8776_ADCWL_MASK       0x030
+#define WM8776_ADCWL_16         0x000
+#define WM8776_ADCWL_20         0x010
+#define WM8776_ADCWL_24         0x020
+#define WM8776_ADCWL_32         0x030
+#define WM8776_ADCMCLK          0x040
+#define WM8776_ADCHPD           0x100
+
+/* MSTRCTRL */
+#define WM8776_ADCRATE_MASK     0x007
+#define WM8776_ADCRATE_256      0x002
+#define WM8776_ADCRATE_384      0x003
+#define WM8776_ADCRATE_512      0x004
+#define WM8776_ADCRATE_768      0x005
+#define WM8776_ADCOSR           0x008
+#define WM8776_DACRATE_MASK     0x070
+#define WM8776_DACRATE_128      0x000
+#define WM8776_DACRATE_192      0x010
+#define WM8776_DACRATE_256      0x020
+#define WM8776_DACRATE_384      0x030
+#define WM8776_DACRATE_512      0x040
+#define WM8776_DACRATE_768      0x050
+#define WM8776_DACMS            0x080
+#define WM8776_ADCMS            0x100
+
+/* PWRDOWN */
+#define WM8776_PDWN             0x001
+#define WM8776_ADCPD            0x002
+#define WM8776_DACPD            0x004
+#define WM8776_HPPD             0x008
+#define WM8776_AINPD            0x040
+
+/* ADCLVOL/ADCRVOL */
+#define WM8776_AGMASK           0x0ff
+#define WM8776_ZCA              0x100
+
+/* ALCCTRL1 */
+#define WM8776_LCT_MASK         0x00f
+#define WM8776_MAXGAIN_MASK     0x070
+#define WM8776_LCSEL_MASK       0x180
+#define WM8776_LCSEL_LIMITER    0x000
+#define WM8776_LCSEL_ALC_RIGHT 0x080
+#define WM8776_LCSEL_ALC_LEFT   0x100
+#define WM8776_LCSEL_ALC_STEREO 0x180
+
+/* ALCCTRL2 */
+#define WM8776_HLD_MASK         0x00f
+#define WM8776_ALCZC            0x080
+#define WM8776_LCEN             0x100
+
+/* ALCCTRL3 */
+#define WM8776_ATK_MASK         0x00f
+#define WM8776_DCY_MASK         0x0f0
+
+/* NOISEGATE */
+#define WM8776_NGAT             0x001
+#define WM8776_NGTH_MASK        0x01c
+
+/* LIMITER */
+#define WM8776_MAXATTEN_MASK    0x00f
+#define WM8776_TRANWIN_MASK     0x070
+
+/* ADCMUX */
+#define WM8776_AMX_MASK         0x01f
+#define WM8776_MUTERA           0x040
+#define WM8776_MUTELA           0x080
+#define WM8776_LRBOTH           0x100
+
+/* OUTMUX */
+#define WM8776_MX_DAC           0x001
+#define WM8776_MX_AUX           0x002
+#define WM8776_MX_BYPASS        0x004
+
+#endif
diff --git a/sound/pci/oxygen/xonar.h b/sound/pci/oxygen/xonar.h
new file mode 100644
index 000000000000..b35343b0a9a5
--- /dev/null
+++ b/sound/pci/oxygen/xonar.h
@@ -0,0 +1,52 @@
+#ifndef XONAR_H_INCLUDED
+#define XONAR_H_INCLUDED
+
+#include "oxygen.h"
+
+struct xonar_generic {
+        unsigned int anti_pop_delay;
+        u16 output_enable_bit;
+        u8 ext_power_reg;
+        u8 ext_power_int_reg;
+        u8 ext_power_bit;
+        u8 has_power;
+};
+
+struct xonar_hdmi {
+        u8 params[5];
+};
+
+/* generic helper functions */
+
+void xonar_enable_output(struct oxygen *chip);
+void xonar_disable_output(struct oxygen *chip);
+void xonar_init_ext_power(struct oxygen *chip);
+void xonar_init_cs53x1(struct oxygen *chip);
+void xonar_set_cs53x1_params(struct oxygen *chip,
+                             struct snd_pcm_hw_params *params);
+int xonar_gpio_bit_switch_get(struct snd_kcontrol *ctl,
+                              struct snd_ctl_elem_value *value);
+int xonar_gpio_bit_switch_put(struct snd_kcontrol *ctl,
+                              struct snd_ctl_elem_value *value);
+
+/* model-specific card drivers */
+
+int get_xonar_pcm179x_model(struct oxygen *chip,
+                            const struct pci_device_id *id);
+int get_xonar_cs43xx_model(struct oxygen *chip,
+                           const struct pci_device_id *id);
+int get_xonar_wm87x6_model(struct oxygen *chip,
+                           const struct pci_device_id *id);
+
+/* HDMI helper functions */
+
+void xonar_hdmi_init(struct oxygen *chip, struct xonar_hdmi *data);
+void xonar_hdmi_cleanup(struct oxygen *chip);
+void xonar_hdmi_resume(struct oxygen *chip, struct xonar_hdmi *hdmi);
+void xonar_hdmi_pcm_hardware_filter(unsigned int channel,
+                                    struct snd_pcm_hardware *hardware);
+void xonar_set_hdmi_params(struct oxygen *chip, struct xonar_hdmi *hdmi,
+                           struct snd_pcm_hw_params *params);
+void xonar_hdmi_uart_input(struct oxygen *chip);
+
+#endif
diff --git a/sound/pci/oxygen/xonar_cs43xx.c b/sound/pci/oxygen/xonar_cs43xx.c
new file mode 100644
index 000000000000..7c4986b27f2b
--- /dev/null
+++ b/sound/pci/oxygen/xonar_cs43xx.c
@@ -0,0 +1,437 @@
+/*
+ * card driver for models with CS4398/CS4362A DACs (Xonar D1/DX)
+ *
+ * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
+ *
+ *
+ *  This driver is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License, version 2.
+ *
+ *  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 driver; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * Xonar D1/DX
+ * -----------
+ *
+ * CMI8788:
+ *
+ * I²C <-> CS4398 (front)
+ *     <-> CS4362A (surround, center/LFE, back)
+ *
+ * GPI 0 <- external power present (DX only)
+ *
+ * GPIO 0 -> enable output to speakers
+ * GPIO 1 -> enable front panel I/O
+ * GPIO 2 -> M0 of CS5361
+ * GPIO 3 -> M1 of CS5361
+ * GPIO 8 -> route input jack to line-in (0) or mic-in (1)
+ *
+ * CS4398:
+ *
+ * AD0 <- 1
+ * AD1 <- 1
+ *
+ * CS4362A:
+ *
+ * AD0 <- 0
+ *
+ * CM9780:
+ *
+ * GPO 0 -> route line-in (0) or AC97 output (1) to CS5361 input
+ */
+
+#include <linux/pci.h>
+#include <linux/delay.h>
+#include <sound/ac97_codec.h>
+#include <sound/control.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/tlv.h>
+#include "xonar.h"
+#include "cm9780.h"
+#include "cs4398.h"
+#include "cs4362a.h"
+
+#define GPI_EXT_POWER           0x01
+#define GPIO_D1_OUTPUT_ENABLE   0x0001
+#define GPIO_D1_FRONT_PANEL     0x0002
+#define GPIO_D1_INPUT_ROUTE     0x0100
+
+#define I2C_DEVICE_CS4398       0x9e    /* 10011, AD1=1, AD0=1, /W=0 */
+#define I2C_DEVICE_CS4362A      0x30    /* 001100, AD0=0, /W=0 */
+
+struct xonar_cs43xx {
+        struct xonar_generic generic;
+        u8 cs4398_regs[8];
+        u8 cs4362a_regs[15];
+};
+
+static void cs4398_write(struct oxygen *chip, u8 reg, u8 value)
+{
+        struct xonar_cs43xx *data = chip->model_data;
+
+        oxygen_write_i2c(chip, I2C_DEVICE_CS4398, reg, value);
+        if (reg < ARRAY_SIZE(data->cs4398_regs))
+                data->cs4398_regs[reg] = value;
+}
+
+static void cs4398_write_cached(struct oxygen *chip, u8 reg, u8 value)
+{
+        struct xonar_cs43xx *data = chip->model_data;
+
+        if (value != data->cs4398_regs[reg])
+                cs4398_write(chip, reg, value);
+}
+
+static void cs4362a_write(struct oxygen *chip, u8 reg, u8 value)
+{
+        struct xonar_cs43xx *data = chip->model_data;
+
+        oxygen_write_i2c(chip, I2C_DEVICE_CS4362A, reg, value);
+        if (reg < ARRAY_SIZE(data->cs4362a_regs))
+                data->cs4362a_regs[reg] = value;
+}
+
+static void cs4362a_write_cached(struct oxygen *chip, u8 reg, u8 value)
+{
+        struct xonar_cs43xx *data = chip->model_data;
+
+        if (value != data->cs4362a_regs[reg])
+                cs4362a_write(chip, reg, value);
+}
+
+static void cs43xx_registers_init(struct oxygen *chip)
+{
+        struct xonar_cs43xx *data = chip->model_data;
+        unsigned int i;
+
+        /* set CPEN (control port mode) and power down */
+        cs4398_write(chip, 8, CS4398_CPEN | CS4398_PDN);
+        cs4362a_write(chip, 0x01, CS4362A_PDN | CS4362A_CPEN);
+        /* configure */
+        cs4398_write(chip, 2, data->cs4398_regs[2]);
+        cs4398_write(chip, 3, CS4398_ATAPI_B_R | CS4398_ATAPI_A_L);
+        cs4398_write(chip, 4, data->cs4398_regs[4]);
+        cs4398_write(chip, 5, data->cs4398_regs[5]);
+        cs4398_write(chip, 6, data->cs4398_regs[6]);
+        cs4398_write(chip, 7, data->cs4398_regs[7]);
+        cs4362a_write(chip, 0x02, CS4362A_DIF_LJUST);
+        cs4362a_write(chip, 0x03, CS4362A_MUTEC_6 | CS4362A_AMUTE |
+                      CS4362A_RMP_UP | CS4362A_ZERO_CROSS | CS4362A_SOFT_RAMP);
+        cs4362a_write(chip, 0x04, data->cs4362a_regs[0x04]);
+        cs4362a_write(chip, 0x05, 0);
+        for (i = 6; i <= 14; ++i)
+                cs4362a_write(chip, i, data->cs4362a_regs[i]);
+        /* clear power down */
+        cs4398_write(chip, 8, CS4398_CPEN);
+        cs4362a_write(chip, 0x01, CS4362A_CPEN);
+}
+
+static void xonar_d1_init(struct oxygen *chip)
+{
+        struct xonar_cs43xx *data = chip->model_data;
+
+        data->generic.anti_pop_delay = 800;
+        data->generic.output_enable_bit = GPIO_D1_OUTPUT_ENABLE;
+        data->cs4398_regs[2] =
+                CS4398_FM_SINGLE | CS4398_DEM_NONE | CS4398_DIF_LJUST;
+        data->cs4398_regs[4] = CS4398_MUTEP_LOW |
+                CS4398_MUTE_B | CS4398_MUTE_A | CS4398_PAMUTE;
+        data->cs4398_regs[5] = 60 * 2;
+        data->cs4398_regs[6] = 60 * 2;
+        data->cs4398_regs[7] = CS4398_RMP_DN | CS4398_RMP_UP |
+                CS4398_ZERO_CROSS | CS4398_SOFT_RAMP;
+        data->cs4362a_regs[4] = CS4362A_RMP_DN | CS4362A_DEM_NONE;
+        data->cs4362a_regs[6] = CS4362A_FM_SINGLE |
+                CS4362A_ATAPI_B_R | CS4362A_ATAPI_A_L;
+        data->cs4362a_regs[7] = 60 | CS4362A_MUTE;
+        data->cs4362a_regs[8] = 60 | CS4362A_MUTE;
+        data->cs4362a_regs[9] = data->cs4362a_regs[6];
+        data->cs4362a_regs[10] = 60 | CS4362A_MUTE;
+        data->cs4362a_regs[11] = 60 | CS4362A_MUTE;
+        data->cs4362a_regs[12] = data->cs4362a_regs[6];
+        data->cs4362a_regs[13] = 60 | CS4362A_MUTE;
+        data->cs4362a_regs[14] = 60 | CS4362A_MUTE;
+
+        oxygen_write16(chip, OXYGEN_2WIRE_BUS_STATUS,
+                       OXYGEN_2WIRE_LENGTH_8 |
+                       OXYGEN_2WIRE_INTERRUPT_MASK |
+                       OXYGEN_2WIRE_SPEED_FAST);
+
+        cs43xx_registers_init(chip);
+
+        oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL,
+                          GPIO_D1_FRONT_PANEL | GPIO_D1_INPUT_ROUTE);
+        oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA,
+                            GPIO_D1_FRONT_PANEL | GPIO_D1_INPUT_ROUTE);
+
+        oxygen_ac97_set_bits(chip, 0, CM9780_JACK, CM9780_FMIC2MIC);
+
+        xonar_init_cs53x1(chip);
+        xonar_enable_output(chip);
+
+        snd_component_add(chip->card, "CS4398");
+        snd_component_add(chip->card, "CS4362A");
+        snd_component_add(chip->card, "CS5361");
+}
+
+static void xonar_dx_init(struct oxygen *chip)
+{
+        struct xonar_cs43xx *data = chip->model_data;
+
+        data->generic.ext_power_reg = OXYGEN_GPI_DATA;
+        data->generic.ext_power_int_reg = OXYGEN_GPI_INTERRUPT_MASK;
+        data->generic.ext_power_bit = GPI_EXT_POWER;
+        xonar_init_ext_power(chip);
+        xonar_d1_init(chip);
+}
+
+static void xonar_d1_cleanup(struct oxygen *chip)
+{
+        xonar_disable_output(chip);
+        cs4362a_write(chip, 0x01, CS4362A_PDN | CS4362A_CPEN);
+        oxygen_clear_bits8(chip, OXYGEN_FUNCTION, OXYGEN_FUNCTION_RESET_CODEC);
+}
+
+static void xonar_d1_suspend(struct oxygen *chip)
+{
+        xonar_d1_cleanup(chip);
+}
+
+static void xonar_d1_resume(struct oxygen *chip)
+{
+        oxygen_set_bits8(chip, OXYGEN_FUNCTION, OXYGEN_FUNCTION_RESET_CODEC);
+        msleep(1);
+        cs43xx_registers_init(chip);
+        xonar_enable_output(chip);
+}
+
+static void set_cs43xx_params(struct oxygen *chip,
+                              struct snd_pcm_hw_params *params)
+{
+        struct xonar_cs43xx *data = chip->model_data;
+        u8 cs4398_fm, cs4362a_fm;
+
+        if (params_rate(params) <= 50000) {
+                cs4398_fm = CS4398_FM_SINGLE;
+                cs4362a_fm = CS4362A_FM_SINGLE;
+        } else if (params_rate(params) <= 100000) {
+                cs4398_fm = CS4398_FM_DOUBLE;
+                cs4362a_fm = CS4362A_FM_DOUBLE;
+        } else {
+                cs4398_fm = CS4398_FM_QUAD;
+                cs4362a_fm = CS4362A_FM_QUAD;
+        }
+        cs4398_fm |= CS4398_DEM_NONE | CS4398_DIF_LJUST;
+        cs4398_write_cached(chip, 2, cs4398_fm);
+        cs4362a_fm |= data->cs4362a_regs[6] & ~CS4362A_FM_MASK;
+        cs4362a_write_cached(chip, 6, cs4362a_fm);
+        cs4362a_write_cached(chip, 12, cs4362a_fm);
+        cs4362a_fm &= CS4362A_FM_MASK;
+        cs4362a_fm |= data->cs4362a_regs[9] & ~CS4362A_FM_MASK;
+        cs4362a_write_cached(chip, 9, cs4362a_fm);
+}
+
+static void update_cs4362a_volumes(struct oxygen *chip)
+{
+        unsigned int i;
+        u8 mute;
+
+        mute = chip->dac_mute ? CS4362A_MUTE : 0;
+        for (i = 0; i < 6; ++i)
+                cs4362a_write_cached(chip, 7 + i + i / 2,
+                                     (127 - chip->dac_volume[2 + i]) | mute);
+}
+
+static void update_cs43xx_volume(struct oxygen *chip)
+{
+        cs4398_write_cached(chip, 5, (127 - chip->dac_volume[0]) * 2);
+        cs4398_write_cached(chip, 6, (127 - chip->dac_volume[1]) * 2);
+        update_cs4362a_volumes(chip);
+}
+
+static void update_cs43xx_mute(struct oxygen *chip)
+{
+        u8 reg;
+
+        reg = CS4398_MUTEP_LOW | CS4398_PAMUTE;
+        if (chip->dac_mute)
+                reg |= CS4398_MUTE_B | CS4398_MUTE_A;
+        cs4398_write_cached(chip, 4, reg);
+        update_cs4362a_volumes(chip);
+}
+
+static void update_cs43xx_center_lfe_mix(struct oxygen *chip, bool mixed)
+{
+        struct xonar_cs43xx *data = chip->model_data;
+        u8 reg;
+
+        reg = data->cs4362a_regs[9] & ~CS4362A_ATAPI_MASK;
+        if (mixed)
+                reg |= CS4362A_ATAPI_B_LR | CS4362A_ATAPI_A_LR;
+        else
+                reg |= CS4362A_ATAPI_B_R | CS4362A_ATAPI_A_L;
+        cs4362a_write_cached(chip, 9, reg);
+}
+
+static const struct snd_kcontrol_new front_panel_switch = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name = "Front Panel Switch",
+        .info = snd_ctl_boolean_mono_info,
+        .get = xonar_gpio_bit_switch_get,
+        .put = xonar_gpio_bit_switch_put,
+        .private_value = GPIO_D1_FRONT_PANEL,
+};
+
+static int rolloff_info(struct snd_kcontrol *ctl,
+                        struct snd_ctl_elem_info *info)
+{
+        static const char *const names[2] = {
+                "Fast Roll-off", "Slow Roll-off"
+        };
+
+        info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        info->count = 1;
+        info->value.enumerated.items = 2;
+        if (info->value.enumerated.item >= 2)
+                info->value.enumerated.item = 1;
+        strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
+        return 0;
+}
+
+static int rolloff_get(struct snd_kcontrol *ctl,
+                       struct snd_ctl_elem_value *value)
+{
+        struct oxygen *chip = ctl->private_data;
+        struct xonar_cs43xx *data = chip->model_data;
+
+        value->value.enumerated.item[0] =
+                (data->cs4398_regs[7] & CS4398_FILT_SEL) != 0;
+        return 0;
+}
+
+static int rolloff_put(struct snd_kcontrol *ctl,
+                       struct snd_ctl_elem_value *value)
+{
+        struct oxygen *chip = ctl->private_data;
+        struct xonar_cs43xx *data = chip->model_data;
+        int changed;
+        u8 reg;
+
+        mutex_lock(&chip->mutex);
+        reg = data->cs4398_regs[7];
+        if (value->value.enumerated.item[0])
+                reg |= CS4398_FILT_SEL;
+        else
+                reg &= ~CS4398_FILT_SEL;
+        changed = reg != data->cs4398_regs[7];
+        if (changed) {
+                cs4398_write(chip, 7, reg);
+                if (reg & CS4398_FILT_SEL)
+                        reg = data->cs4362a_regs[0x04] | CS4362A_FILT_SEL;
+                else
+                        reg = data->cs4362a_regs[0x04] & ~CS4362A_FILT_SEL;
+                cs4362a_write(chip, 0x04, reg);
+        }
+        mutex_unlock(&chip->mutex);
+        return changed;
+}
+
+static const struct snd_kcontrol_new rolloff_control = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name = "DAC Filter Playback Enum",
+        .info = rolloff_info,
+        .get = rolloff_get,
+        .put = rolloff_put,
+};
+
+static void xonar_d1_line_mic_ac97_switch(struct oxygen *chip,
+                                          unsigned int reg, unsigned int mute)
+{
+        if (reg == AC97_LINE) {
+                spin_lock_irq(&chip->reg_lock);
+                oxygen_write16_masked(chip, OXYGEN_GPIO_DATA,
+                                      mute ? GPIO_D1_INPUT_ROUTE : 0,
+                                      GPIO_D1_INPUT_ROUTE);
+                spin_unlock_irq(&chip->reg_lock);
+        }
+}
+
+static const DECLARE_TLV_DB_SCALE(cs4362a_db_scale, -6000, 100, 0);
+
+static int xonar_d1_control_filter(struct snd_kcontrol_new *template)
+{
+        if (!strncmp(template->name, "CD Capture ", 11))
+                return 1; /* no CD input */
+        return 0;
+}
+
+static int xonar_d1_mixer_init(struct oxygen *chip)
+{
+        int err;
+
+        err = snd_ctl_add(chip->card, snd_ctl_new1(&front_panel_switch, chip));
+        if (err < 0)
+                return err;
+        err = snd_ctl_add(chip->card, snd_ctl_new1(&rolloff_control, chip));
+        if (err < 0)
+                return err;
+        return 0;
+}
+
+static const struct oxygen_model model_xonar_d1 = {
+        .longname = "Asus Virtuoso 100",
+        .chip = "AV200",
+        .init = xonar_d1_init,
+        .control_filter = xonar_d1_control_filter,
+        .mixer_init = xonar_d1_mixer_init,
+        .cleanup = xonar_d1_cleanup,
+        .suspend = xonar_d1_suspend,
+        .resume = xonar_d1_resume,
+        .get_i2s_mclk = oxygen_default_i2s_mclk,
+        .set_dac_params = set_cs43xx_params,
+        .set_adc_params = xonar_set_cs53x1_params,
+        .update_dac_volume = update_cs43xx_volume,
+        .update_dac_mute = update_cs43xx_mute,
+        .update_center_lfe_mix = update_cs43xx_center_lfe_mix,
+        .ac97_switch = xonar_d1_line_mic_ac97_switch,
+        .dac_tlv = cs4362a_db_scale,
+        .model_data_size = sizeof(struct xonar_cs43xx),
+        .device_config = PLAYBACK_0_TO_I2S |
+                         PLAYBACK_1_TO_SPDIF |
+                         CAPTURE_0_FROM_I2S_2,
+        .dac_channels = 8,
+        .dac_volume_min = 127 - 60,
+        .dac_volume_max = 127,
+        .function_flags = OXYGEN_FUNCTION_2WIRE,
+        .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
+        .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
+};
+
+int __devinit get_xonar_cs43xx_model(struct oxygen *chip,
+                                     const struct pci_device_id *id)
+{
+        switch (id->subdevice) {
+        case 0x834f:
+                chip->model = model_xonar_d1;
+                chip->model.shortname = "Xonar D1";
+                break;
+        case 0x8275:
+        case 0x8327:
+                chip->model = model_xonar_d1;
+                chip->model.shortname = "Xonar DX";
+                chip->model.init = xonar_dx_init;
+                break;
+        default:
+                return -EINVAL;
+        }
+        return 0;
+}
diff --git a/sound/pci/oxygen/xonar_hdmi.c b/sound/pci/oxygen/xonar_hdmi.c
new file mode 100644
index 000000000000..b12db1f1cea9
--- /dev/null
+++ b/sound/pci/oxygen/xonar_hdmi.c
@@ -0,0 +1,128 @@
+/*
+ * helper functions for HDMI models (Xonar HDAV1.3)
+ *
+ * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
+ *
+ *
+ *  This driver is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License, version 2.
+ *
+ *  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 driver; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/pci.h>
+#include <linux/delay.h>
+#include <sound/asoundef.h>
+#include <sound/control.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/tlv.h>
+#include "xonar.h"
+
+static void hdmi_write_command(struct oxygen *chip, u8 command,
+                               unsigned int count, const u8 *params)
+{
+        unsigned int i;
+        u8 checksum;
+
+        oxygen_write_uart(chip, 0xfb);
+        oxygen_write_uart(chip, 0xef);
+        oxygen_write_uart(chip, command);
+        oxygen_write_uart(chip, count);
+        for (i = 0; i < count; ++i)
+                oxygen_write_uart(chip, params[i]);
+        checksum = 0xfb + 0xef + command + count;
+        for (i = 0; i < count; ++i)
+                checksum += params[i];
+        oxygen_write_uart(chip, checksum);
+}
+
+static void xonar_hdmi_init_commands(struct oxygen *chip,
+                                     struct xonar_hdmi *hdmi)
+{
+        u8 param;
+
+        oxygen_reset_uart(chip);
+        param = 0;
+        hdmi_write_command(chip, 0x61, 1, &param);
+        param = 1;
+        hdmi_write_command(chip, 0x74, 1, &param);
+        hdmi_write_command(chip, 0x54, 5, hdmi->params);
+}
+
+void xonar_hdmi_init(struct oxygen *chip, struct xonar_hdmi *hdmi)
+{
+        hdmi->params[1] = IEC958_AES3_CON_FS_48000;
+        hdmi->params[4] = 1;
+        xonar_hdmi_init_commands(chip, hdmi);
+}
+
+void xonar_hdmi_cleanup(struct oxygen *chip)
+{
+        u8 param = 0;
+
+        hdmi_write_command(chip, 0x74, 1, &param);
+}
+
+void xonar_hdmi_resume(struct oxygen *chip, struct xonar_hdmi *hdmi)
+{
+        xonar_hdmi_init_commands(chip, hdmi);
+}
+
+void xonar_hdmi_pcm_hardware_filter(unsigned int channel,
+                                    struct snd_pcm_hardware *hardware)
+{
+        if (channel == PCM_MULTICH) {
+                hardware->rates = SNDRV_PCM_RATE_44100 |
+                                  SNDRV_PCM_RATE_48000 |
+                                  SNDRV_PCM_RATE_96000 |
+                                  SNDRV_PCM_RATE_192000;
+                hardware->rate_min = 44100;
+        }
+}
+
+void xonar_set_hdmi_params(struct oxygen *chip, struct xonar_hdmi *hdmi,
+                           struct snd_pcm_hw_params *params)
+{
+        hdmi->params[0] = 0; /* 1 = non-audio */
+        switch (params_rate(params)) {
+        case 44100:
+                hdmi->params[1] = IEC958_AES3_CON_FS_44100;
+                break;
+        case 48000:
+                hdmi->params[1] = IEC958_AES3_CON_FS_48000;
+                break;
+        default: /* 96000 */
+                hdmi->params[1] = IEC958_AES3_CON_FS_96000;
+                break;
+        case 192000:
+                hdmi->params[1] = IEC958_AES3_CON_FS_192000;
+                break;
+        }
+        hdmi->params[2] = params_channels(params) / 2 - 1;
+        if (params_format(params) == SNDRV_PCM_FORMAT_S16_LE)
+                hdmi->params[3] = 0;
+        else
+                hdmi->params[3] = 0xc0;
+        hdmi->params[4] = 1; /* ? */
+        hdmi_write_command(chip, 0x54, 5, hdmi->params);
+}
+
+void xonar_hdmi_uart_input(struct oxygen *chip)
+{
+        if (chip->uart_input_count >= 2 &&
+            chip->uart_input[chip->uart_input_count - 2] == 'O' &&
+            chip->uart_input[chip->uart_input_count - 1] == 'K') {
+                printk(KERN_DEBUG "message from HDMI chip received:\n");
+                print_hex_dump_bytes("", DUMP_PREFIX_OFFSET,
+                                     chip->uart_input, chip->uart_input_count);
+                chip->uart_input_count = 0;
+        }
+}
diff --git a/sound/pci/oxygen/xonar_lib.c b/sound/pci/oxygen/xonar_lib.c
new file mode 100644
index 000000000000..b3ff71316653
--- /dev/null
+++ b/sound/pci/oxygen/xonar_lib.c
@@ -0,0 +1,132 @@
+/*
+ * helper functions for Asus Xonar cards
+ *
+ * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
+ *
+ *
+ *  This driver is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License, version 2.
+ *
+ *  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 driver; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/delay.h>
+#include <sound/core.h>
+#include <sound/control.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include "xonar.h"
+
+
+#define GPIO_CS53x1_M_MASK      0x000c
+#define GPIO_CS53x1_M_SINGLE    0x0000
+#define GPIO_CS53x1_M_DOUBLE    0x0004
+#define GPIO_CS53x1_M_QUAD      0x0008
+
+
+void xonar_enable_output(struct oxygen *chip)
+{
+        struct xonar_generic *data = chip->model_data;
+
+        oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, data->output_enable_bit);
+        msleep(data->anti_pop_delay);
+        oxygen_set_bits16(chip, OXYGEN_GPIO_DATA, data->output_enable_bit);
+}
+
+void xonar_disable_output(struct oxygen *chip)
+{
+        struct xonar_generic *data = chip->model_data;
+
+        oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA, data->output_enable_bit);
+}
+
+static void xonar_ext_power_gpio_changed(struct oxygen *chip)
+{
+        struct xonar_generic *data = chip->model_data;
+        u8 has_power;
+
+        has_power = !!(oxygen_read8(chip, data->ext_power_reg)
+                       & data->ext_power_bit);
+        if (has_power != data->has_power) {
+                data->has_power = has_power;
+                if (has_power) {
+                        snd_printk(KERN_NOTICE "power restored\n");
+                } else {
+                        snd_printk(KERN_CRIT
+                                   "Hey! Don't unplug the power cable!\n");
+                        /* TODO: stop PCMs */
+                }
+        }
+}
+
+void xonar_init_ext_power(struct oxygen *chip)
+{
+        struct xonar_generic *data = chip->model_data;
+
+        oxygen_set_bits8(chip, data->ext_power_int_reg,
+                         data->ext_power_bit);
+        chip->interrupt_mask |= OXYGEN_INT_GPIO;
+        chip->model.gpio_changed = xonar_ext_power_gpio_changed;
+        data->has_power = !!(oxygen_read8(chip, data->ext_power_reg)
+                             & data->ext_power_bit);
+}
+
+void xonar_init_cs53x1(struct oxygen *chip)
+{
+        oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_CS53x1_M_MASK);
+        oxygen_write16_masked(chip, OXYGEN_GPIO_DATA,
+                              GPIO_CS53x1_M_SINGLE, GPIO_CS53x1_M_MASK);
+}
+
+void xonar_set_cs53x1_params(struct oxygen *chip,
+                             struct snd_pcm_hw_params *params)
+{
+        unsigned int value;
+
+        if (params_rate(params) <= 54000)
+                value = GPIO_CS53x1_M_SINGLE;
+        else if (params_rate(params) <= 108000)
+                value = GPIO_CS53x1_M_DOUBLE;
+        else
+                value = GPIO_CS53x1_M_QUAD;
+        oxygen_write16_masked(chip, OXYGEN_GPIO_DATA,
+                              value, GPIO_CS53x1_M_MASK);
+}
+
+int xonar_gpio_bit_switch_get(struct snd_kcontrol *ctl,
+                              struct snd_ctl_elem_value *value)
+{
+        struct oxygen *chip = ctl->private_data;
+        u16 bit = ctl->private_value;
+
+        value->value.integer.value[0] =
+                !!(oxygen_read16(chip, OXYGEN_GPIO_DATA) & bit);
+        return 0;
+}
+
+int xonar_gpio_bit_switch_put(struct snd_kcontrol *ctl,
+                              struct snd_ctl_elem_value *value)
+{
+        struct oxygen *chip = ctl->private_data;
+        u16 bit = ctl->private_value;
+        u16 old_bits, new_bits;
+        int changed;
+
+        spin_lock_irq(&chip->reg_lock);
+        old_bits = oxygen_read16(chip, OXYGEN_GPIO_DATA);
+        if (value->value.integer.value[0])
+                new_bits = old_bits | bit;
+        else
+                new_bits = old_bits & ~bit;
+        changed = new_bits != old_bits;
+        if (changed)
+                oxygen_write16(chip, OXYGEN_GPIO_DATA, new_bits);
+        spin_unlock_irq(&chip->reg_lock);
+        return changed;
+}
diff --git a/sound/pci/oxygen/xonar_pcm179x.c b/sound/pci/oxygen/xonar_pcm179x.c
new file mode 100644
index 000000000000..ba18fb546b4f
--- /dev/null
+++ b/sound/pci/oxygen/xonar_pcm179x.c
@@ -0,0 +1,1115 @@
+/*
+ * card driver for models with PCM1796 DACs (Xonar D2/D2X/HDAV1.3/ST/STX)
+ *
+ * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
+ *
+ *
+ *  This driver is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License, version 2.
+ *
+ *  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 driver; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * Xonar D2/D2X
+ * ------------
+ *
+ * CMI8788:
+ *
+ * SPI 0 -> 1st PCM1796 (front)
+ * SPI 1 -> 2nd PCM1796 (surround)
+ * SPI 2 -> 3rd PCM1796 (center/LFE)
+ * SPI 4 -> 4th PCM1796 (back)
+ *
+ * GPIO 2 -> M0 of CS5381
+ * GPIO 3 -> M1 of CS5381
+ * GPIO 5 <- external power present (D2X only)
+ * GPIO 7 -> ALT
+ * GPIO 8 -> enable output to speakers
+ *
+ * CM9780:
+ *
+ * GPO 0 -> route line-in (0) or AC97 output (1) to CS5381 input
+ */
+
+/*
+ * Xonar HDAV1.3 (Deluxe)
+ * ----------------------
+ *
+ * CMI8788:
+ *
+ * I²C <-> PCM1796 (front)
+ *
+ * GPI 0 <- external power present
+ *
+ * GPIO 0 -> enable output to speakers
+ * GPIO 2 -> M0 of CS5381
+ * GPIO 3 -> M1 of CS5381
+ * GPIO 8 -> route input jack to line-in (0) or mic-in (1)
+ *
+ * TXD -> HDMI controller
+ * RXD <- HDMI controller
+ *
+ * PCM1796 front: AD1,0 <- 0,0
+ *
+ * CM9780:
+ *
+ * GPO 0 -> route line-in (0) or AC97 output (1) to CS5381 input
+ *
+ * no daughterboard
+ * ----------------
+ *
+ * GPIO 4 <- 1
+ *
+ * H6 daughterboard
+ * ----------------
+ *
+ * GPIO 4 <- 0
+ * GPIO 5 <- 0
+ *
+ * I²C <-> PCM1796 (surround)
+ *     <-> PCM1796 (center/LFE)
+ *     <-> PCM1796 (back)
+ *
+ * PCM1796 surround:   AD1,0 <- 0,1
+ * PCM1796 center/LFE: AD1,0 <- 1,0
+ * PCM1796 back:       AD1,0 <- 1,1
+ *
+ * unknown daughterboard
+ * ---------------------
+ *
+ * GPIO 4 <- 0
+ * GPIO 5 <- 1
+ *
+ * I²C <-> CS4362A (surround, center/LFE, back)
+ *
+ * CS4362A: AD0 <- 0
+ */
+
+/*
+ * Xonar Essence ST (Deluxe)/STX
+ * -----------------------------
+ *
+ * CMI8788:
+ *
+ * I²C <-> PCM1792A
+ *     <-> CS2000 (ST only)
+ *
+ * ADC1 MCLK -> REF_CLK of CS2000 (ST only)
+ *
+ * GPI 0 <- external power present (STX only)
+ *
+ * GPIO 0 -> enable output to speakers
+ * GPIO 1 -> route HP to front panel (0) or rear jack (1)
+ * GPIO 2 -> M0 of CS5381
+ * GPIO 3 -> M1 of CS5381
+ * GPIO 7 -> route output to speaker jacks (0) or HP (1)
+ * GPIO 8 -> route input jack to line-in (0) or mic-in (1)
+ *
+ * PCM1792A:
+ *
+ * AD1,0 <- 0,0
+ * SCK <- CLK_OUT of CS2000 (ST only)
+ *
+ * CS2000:
+ *
+ * AD0 <- 0
+ *
+ * CM9780:
+ *
+ * GPO 0 -> route line-in (0) or AC97 output (1) to CS5381 input
+ *
+ * H6 daughterboard
+ * ----------------
+ *
+ * GPIO 4 <- 0
+ * GPIO 5 <- 0
+ */
+
+#include <linux/pci.h>
+#include <linux/delay.h>
+#include <linux/mutex.h>
+#include <sound/ac97_codec.h>
+#include <sound/control.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/tlv.h>
+#include "xonar.h"
+#include "cm9780.h"
+#include "pcm1796.h"
+#include "cs2000.h"
+
+
+#define GPIO_D2X_EXT_POWER      0x0020
+#define GPIO_D2_ALT             0x0080
+#define GPIO_D2_OUTPUT_ENABLE   0x0100
+
+#define GPI_EXT_POWER           0x01
+#define GPIO_INPUT_ROUTE        0x0100
+
+#define GPIO_HDAV_OUTPUT_ENABLE 0x0001
+
+#define GPIO_DB_MASK            0x0030
+#define GPIO_DB_H6              0x0000
+
+#define GPIO_ST_OUTPUT_ENABLE   0x0001
+#define GPIO_ST_HP_REAR         0x0002
+#define GPIO_ST_HP              0x0080
+
+#define I2C_DEVICE_PCM1796(i)   (0x98 + ((i) << 1))     /* 10011, ii, /W=0 */
+#define I2C_DEVICE_CS2000       0x9c                    /* 100111, 0, /W=0 */
+
+#define PCM1796_REG_BASE        16
+
+
+struct xonar_pcm179x {
+        struct xonar_generic generic;
+        unsigned int dacs;
+        u8 pcm1796_regs[4][5];
+        unsigned int current_rate;
+        bool os_128;
+        bool hp_active;
+        s8 hp_gain_offset;
+        bool has_cs2000;
+        u8 cs2000_fun_cfg_1;
+};
+
+struct xonar_hdav {
+        struct xonar_pcm179x pcm179x;
+        struct xonar_hdmi hdmi;
+};
+
+
+static inline void pcm1796_write_spi(struct oxygen *chip, unsigned int codec,
+                                     u8 reg, u8 value)
+{
+        /* maps ALSA channel pair number to SPI output */
+        static const u8 codec_map[4] = {
+                0, 1, 2, 4
+        };
+        oxygen_write_spi(chip, OXYGEN_SPI_TRIGGER  |
+                         OXYGEN_SPI_DATA_LENGTH_2 |
+                         OXYGEN_SPI_CLOCK_160 |
+                         (codec_map[codec] << OXYGEN_SPI_CODEC_SHIFT) |
+                         OXYGEN_SPI_CEN_LATCH_CLOCK_HI,
+                         (reg << 8) | value);
+}
+
+static inline void pcm1796_write_i2c(struct oxygen *chip, unsigned int codec,
+                                     u8 reg, u8 value)
+{
+        oxygen_write_i2c(chip, I2C_DEVICE_PCM1796(codec), reg, value);
+}
+
+static void pcm1796_write(struct oxygen *chip, unsigned int codec,
+                          u8 reg, u8 value)
+{
+        struct xonar_pcm179x *data = chip->model_data;
+
+        if ((chip->model.function_flags & OXYGEN_FUNCTION_2WIRE_SPI_MASK) ==
+            OXYGEN_FUNCTION_SPI)
+                pcm1796_write_spi(chip, codec, reg, value);
+        else
+                pcm1796_write_i2c(chip, codec, reg, value);
+        if ((unsigned int)(reg - PCM1796_REG_BASE)
+            < ARRAY_SIZE(data->pcm1796_regs[codec]))
+                data->pcm1796_regs[codec][reg - PCM1796_REG_BASE] = value;
+}
+
+static void pcm1796_write_cached(struct oxygen *chip, unsigned int codec,
+                                 u8 reg, u8 value)
+{
+        struct xonar_pcm179x *data = chip->model_data;
+
+        if (value != data->pcm1796_regs[codec][reg - PCM1796_REG_BASE])
+                pcm1796_write(chip, codec, reg, value);
+}
+
+static void cs2000_write(struct oxygen *chip, u8 reg, u8 value)
+{
+        struct xonar_pcm179x *data = chip->model_data;
+
+        oxygen_write_i2c(chip, I2C_DEVICE_CS2000, reg, value);
+        if (reg == CS2000_FUN_CFG_1)
+                data->cs2000_fun_cfg_1 = value;
+}
+
+static void cs2000_write_cached(struct oxygen *chip, u8 reg, u8 value)
+{
+        struct xonar_pcm179x *data = chip->model_data;
+
+        if (reg != CS2000_FUN_CFG_1 ||
+            value != data->cs2000_fun_cfg_1)
+                cs2000_write(chip, reg, value);
+}
+
+static void pcm1796_registers_init(struct oxygen *chip)
+{
+        struct xonar_pcm179x *data = chip->model_data;
+        unsigned int i;
+        s8 gain_offset;
+
+        gain_offset = data->hp_active ? data->hp_gain_offset : 0;
+        for (i = 0; i < data->dacs; ++i) {
+                /* set ATLD before ATL/ATR */
+                pcm1796_write(chip, i, 18,
+                              data->pcm1796_regs[0][18 - PCM1796_REG_BASE]);
+                pcm1796_write(chip, i, 16, chip->dac_volume[i * 2]
+                              + gain_offset);
+                pcm1796_write(chip, i, 17, chip->dac_volume[i * 2 + 1]
+                              + gain_offset);
+                pcm1796_write(chip, i, 19,
+                              data->pcm1796_regs[0][19 - PCM1796_REG_BASE]);
+                pcm1796_write(chip, i, 20,
+                              data->pcm1796_regs[0][20 - PCM1796_REG_BASE]);
+                pcm1796_write(chip, i, 21, 0);
+        }
+}
+
+static void pcm1796_init(struct oxygen *chip)
+{
+        struct xonar_pcm179x *data = chip->model_data;
+
+        data->pcm1796_regs[0][18 - PCM1796_REG_BASE] = PCM1796_MUTE |
+                PCM1796_DMF_DISABLED | PCM1796_FMT_24_LJUST | PCM1796_ATLD;
+        data->pcm1796_regs[0][19 - PCM1796_REG_BASE] =
+                PCM1796_FLT_SHARP | PCM1796_ATS_1;
+        data->pcm1796_regs[0][20 - PCM1796_REG_BASE] = PCM1796_OS_64;
+        pcm1796_registers_init(chip);
+        data->current_rate = 48000;
+}
+
+static void xonar_d2_init(struct oxygen *chip)
+{
+        struct xonar_pcm179x *data = chip->model_data;
+
+        data->generic.anti_pop_delay = 300;
+        data->generic.output_enable_bit = GPIO_D2_OUTPUT_ENABLE;
+        data->dacs = 4;
+
+        pcm1796_init(chip);
+
+        oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_D2_ALT);
+        oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA, GPIO_D2_ALT);
+
+        oxygen_ac97_set_bits(chip, 0, CM9780_JACK, CM9780_FMIC2MIC);
+
+        xonar_init_cs53x1(chip);
+        xonar_enable_output(chip);
+
+        snd_component_add(chip->card, "PCM1796");
+        snd_component_add(chip->card, "CS5381");
+}
+
+static void xonar_d2x_init(struct oxygen *chip)
+{
+        struct xonar_pcm179x *data = chip->model_data;
+
+        data->generic.ext_power_reg = OXYGEN_GPIO_DATA;
+        data->generic.ext_power_int_reg = OXYGEN_GPIO_INTERRUPT_MASK;
+        data->generic.ext_power_bit = GPIO_D2X_EXT_POWER;
+        oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_D2X_EXT_POWER);
+        xonar_init_ext_power(chip);
+        xonar_d2_init(chip);
+}
+
+static void xonar_hdav_init(struct oxygen *chip)
+{
+        struct xonar_hdav *data = chip->model_data;
+
+        oxygen_write16(chip, OXYGEN_2WIRE_BUS_STATUS,
+                       OXYGEN_2WIRE_LENGTH_8 |
+                       OXYGEN_2WIRE_INTERRUPT_MASK |
+                       OXYGEN_2WIRE_SPEED_FAST);
+
+        data->pcm179x.generic.anti_pop_delay = 100;
+        data->pcm179x.generic.output_enable_bit = GPIO_HDAV_OUTPUT_ENABLE;
+        data->pcm179x.generic.ext_power_reg = OXYGEN_GPI_DATA;
+        data->pcm179x.generic.ext_power_int_reg = OXYGEN_GPI_INTERRUPT_MASK;
+        data->pcm179x.generic.ext_power_bit = GPI_EXT_POWER;
+        data->pcm179x.dacs = chip->model.private_data ? 4 : 1;
+
+        pcm1796_init(chip);
+
+        oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_INPUT_ROUTE);
+        oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA, GPIO_INPUT_ROUTE);
+
+        xonar_init_cs53x1(chip);
+        xonar_init_ext_power(chip);
+        xonar_hdmi_init(chip, &data->hdmi);
+        xonar_enable_output(chip);
+
+        snd_component_add(chip->card, "PCM1796");
+        snd_component_add(chip->card, "CS5381");
+}
+
+static void xonar_st_init_i2c(struct oxygen *chip)
+{
+        oxygen_write16(chip, OXYGEN_2WIRE_BUS_STATUS,
+                       OXYGEN_2WIRE_LENGTH_8 |
+                       OXYGEN_2WIRE_INTERRUPT_MASK |
+                       OXYGEN_2WIRE_SPEED_FAST);
+}
+
+static void xonar_st_init_common(struct oxygen *chip)
+{
+        struct xonar_pcm179x *data = chip->model_data;
+
+        data->generic.anti_pop_delay = 100;
+        data->generic.output_enable_bit = GPIO_ST_OUTPUT_ENABLE;
+        data->dacs = chip->model.private_data ? 4 : 1;
+        data->hp_gain_offset = 2*-18;
+
+        pcm1796_init(chip);
+
+        oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL,
+                          GPIO_INPUT_ROUTE | GPIO_ST_HP_REAR | GPIO_ST_HP);
+        oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA,
+                            GPIO_INPUT_ROUTE | GPIO_ST_HP_REAR | GPIO_ST_HP);
+
+        xonar_init_cs53x1(chip);
+        xonar_enable_output(chip);
+
+        snd_component_add(chip->card, "PCM1792A");
+        snd_component_add(chip->card, "CS5381");
+}
+
+static void cs2000_registers_init(struct oxygen *chip)
+{
+        struct xonar_pcm179x *data = chip->model_data;
+
+        cs2000_write(chip, CS2000_GLOBAL_CFG, CS2000_FREEZE);
+        cs2000_write(chip, CS2000_DEV_CTRL, 0);
+        cs2000_write(chip, CS2000_DEV_CFG_1,
+                     CS2000_R_MOD_SEL_1 |
+                     (0 << CS2000_R_SEL_SHIFT) |
+                     CS2000_AUX_OUT_SRC_REF_CLK |
+                     CS2000_EN_DEV_CFG_1);
+        cs2000_write(chip, CS2000_DEV_CFG_2,
+                     (0 << CS2000_LOCK_CLK_SHIFT) |
+                     CS2000_FRAC_N_SRC_STATIC);
+        cs2000_write(chip, CS2000_RATIO_0 + 0, 0x00); /* 1.0 */
+        cs2000_write(chip, CS2000_RATIO_0 + 1, 0x10);
+        cs2000_write(chip, CS2000_RATIO_0 + 2, 0x00);
+        cs2000_write(chip, CS2000_RATIO_0 + 3, 0x00);
+        cs2000_write(chip, CS2000_FUN_CFG_1, data->cs2000_fun_cfg_1);
+        cs2000_write(chip, CS2000_FUN_CFG_2, 0);
+        cs2000_write(chip, CS2000_GLOBAL_CFG, CS2000_EN_DEV_CFG_2);
+}
+
+static void xonar_st_init(struct oxygen *chip)
+{
+        struct xonar_pcm179x *data = chip->model_data;
+
+        data->has_cs2000 = 1;
+        data->cs2000_fun_cfg_1 = CS2000_REF_CLK_DIV_1;
+
+        oxygen_write16(chip, OXYGEN_I2S_A_FORMAT,
+                       OXYGEN_RATE_48000 | OXYGEN_I2S_FORMAT_I2S |
+                       OXYGEN_I2S_MCLK_128 | OXYGEN_I2S_BITS_16 |
+                       OXYGEN_I2S_MASTER | OXYGEN_I2S_BCLK_64);
+
+        xonar_st_init_i2c(chip);
+        cs2000_registers_init(chip);
+        xonar_st_init_common(chip);
+
+        snd_component_add(chip->card, "CS2000");
+}
+
+static void xonar_stx_init(struct oxygen *chip)
+{
+        struct xonar_pcm179x *data = chip->model_data;
+
+        xonar_st_init_i2c(chip);
+        data->generic.ext_power_reg = OXYGEN_GPI_DATA;
+        data->generic.ext_power_int_reg = OXYGEN_GPI_INTERRUPT_MASK;
+        data->generic.ext_power_bit = GPI_EXT_POWER;
+        xonar_init_ext_power(chip);
+        xonar_st_init_common(chip);
+}
+
+static void xonar_d2_cleanup(struct oxygen *chip)
+{
+        xonar_disable_output(chip);
+}
+
+static void xonar_hdav_cleanup(struct oxygen *chip)
+{
+        xonar_hdmi_cleanup(chip);
+        xonar_disable_output(chip);
+        msleep(2);
+}
+
+static void xonar_st_cleanup(struct oxygen *chip)
+{
+        xonar_disable_output(chip);
+}
+
+static void xonar_d2_suspend(struct oxygen *chip)
+{
+        xonar_d2_cleanup(chip);
+}
+
+static void xonar_hdav_suspend(struct oxygen *chip)
+{
+        xonar_hdav_cleanup(chip);
+}
+
+static void xonar_st_suspend(struct oxygen *chip)
+{
+        xonar_st_cleanup(chip);
+}
+
+static void xonar_d2_resume(struct oxygen *chip)
+{
+        pcm1796_registers_init(chip);
+        xonar_enable_output(chip);
+}
+
+static void xonar_hdav_resume(struct oxygen *chip)
+{
+        struct xonar_hdav *data = chip->model_data;
+
+        pcm1796_registers_init(chip);
+        xonar_hdmi_resume(chip, &data->hdmi);
+        xonar_enable_output(chip);
+}
+
+static void xonar_stx_resume(struct oxygen *chip)
+{
+        pcm1796_registers_init(chip);
+        xonar_enable_output(chip);
+}
+
+static void xonar_st_resume(struct oxygen *chip)
+{
+        cs2000_registers_init(chip);
+        xonar_stx_resume(chip);
+}
+
+static unsigned int mclk_from_rate(struct oxygen *chip, unsigned int rate)
+{
+        struct xonar_pcm179x *data = chip->model_data;
+
+        if (rate <= 32000)
+                return OXYGEN_I2S_MCLK_512;
+        else if (rate <= 48000 && data->os_128)
+                return OXYGEN_I2S_MCLK_512;
+        else if (rate <= 96000)
+                return OXYGEN_I2S_MCLK_256;
+        else
+                return OXYGEN_I2S_MCLK_128;
+}
+
+static unsigned int get_pcm1796_i2s_mclk(struct oxygen *chip,
+                                         unsigned int channel,
+                                         struct snd_pcm_hw_params *params)
+{
+        if (channel == PCM_MULTICH)
+                return mclk_from_rate(chip, params_rate(params));
+        else
+                return oxygen_default_i2s_mclk(chip, channel, params);
+}
+
+static void update_pcm1796_oversampling(struct oxygen *chip)
+{
+        struct xonar_pcm179x *data = chip->model_data;
+        unsigned int i;
+        u8 reg;
+
+        if (data->current_rate <= 32000)
+                reg = PCM1796_OS_128;
+        else if (data->current_rate <= 48000 && data->os_128)
+                reg = PCM1796_OS_128;
+        else if (data->current_rate <= 96000 || data->os_128)
+                reg = PCM1796_OS_64;
+        else
+                reg = PCM1796_OS_32;
+        for (i = 0; i < data->dacs; ++i)
+                pcm1796_write_cached(chip, i, 20, reg);
+}
+
+static void set_pcm1796_params(struct oxygen *chip,
+                               struct snd_pcm_hw_params *params)
+{
+        struct xonar_pcm179x *data = chip->model_data;
+
+        data->current_rate = params_rate(params);
+        update_pcm1796_oversampling(chip);
+}
+
+static void update_pcm1796_volume(struct oxygen *chip)
+{
+        struct xonar_pcm179x *data = chip->model_data;
+        unsigned int i;
+        s8 gain_offset;
+
+        gain_offset = data->hp_active ? data->hp_gain_offset : 0;
+        for (i = 0; i < data->dacs; ++i) {
+                pcm1796_write_cached(chip, i, 16, chip->dac_volume[i * 2]
+                                     + gain_offset);
+                pcm1796_write_cached(chip, i, 17, chip->dac_volume[i * 2 + 1]
+                                     + gain_offset);
+        }
+}
+
+static void update_pcm1796_mute(struct oxygen *chip)
+{
+        struct xonar_pcm179x *data = chip->model_data;
+        unsigned int i;
+        u8 value;
+
+        value = PCM1796_DMF_DISABLED | PCM1796_FMT_24_LJUST | PCM1796_ATLD;
+        if (chip->dac_mute)
+                value |= PCM1796_MUTE;
+        for (i = 0; i < data->dacs; ++i)
+                pcm1796_write_cached(chip, i, 18, value);
+}
+
+static void update_cs2000_rate(struct oxygen *chip, unsigned int rate)
+{
+        struct xonar_pcm179x *data = chip->model_data;
+        u8 rate_mclk, reg;
+
+        switch (rate) {
+                /* XXX Why is the I2S A MCLK half the actual I2S MCLK? */
+        case 32000:
+                rate_mclk = OXYGEN_RATE_32000 | OXYGEN_I2S_MCLK_256;
+                break;
+        case 44100:
+                if (data->os_128)
+                        rate_mclk = OXYGEN_RATE_44100 | OXYGEN_I2S_MCLK_256;
+                else
+                        rate_mclk = OXYGEN_RATE_44100 | OXYGEN_I2S_MCLK_128;
+                break;
+        default: /* 48000 */
+                if (data->os_128)
+                        rate_mclk = OXYGEN_RATE_48000 | OXYGEN_I2S_MCLK_256;
+                else
+                        rate_mclk = OXYGEN_RATE_48000 | OXYGEN_I2S_MCLK_128;
+                break;
+        case 64000:
+                rate_mclk = OXYGEN_RATE_32000 | OXYGEN_I2S_MCLK_256;
+                break;
+        case 88200:
+                rate_mclk = OXYGEN_RATE_44100 | OXYGEN_I2S_MCLK_256;
+                break;
+        case 96000:
+                rate_mclk = OXYGEN_RATE_48000 | OXYGEN_I2S_MCLK_256;
+                break;
+        case 176400:
+                rate_mclk = OXYGEN_RATE_44100 | OXYGEN_I2S_MCLK_256;
+                break;
+        case 192000:
+                rate_mclk = OXYGEN_RATE_48000 | OXYGEN_I2S_MCLK_256;
+                break;
+        }
+        oxygen_write16_masked(chip, OXYGEN_I2S_A_FORMAT, rate_mclk,
+                              OXYGEN_I2S_RATE_MASK | OXYGEN_I2S_MCLK_MASK);
+        if ((rate_mclk & OXYGEN_I2S_MCLK_MASK) <= OXYGEN_I2S_MCLK_128)
+                reg = CS2000_REF_CLK_DIV_1;
+        else
+                reg = CS2000_REF_CLK_DIV_2;
+        cs2000_write_cached(chip, CS2000_FUN_CFG_1, reg);
+}
+
+static void set_st_params(struct oxygen *chip,
+                          struct snd_pcm_hw_params *params)
+{
+        update_cs2000_rate(chip, params_rate(params));
+        set_pcm1796_params(chip, params);
+}
+
+static void set_hdav_params(struct oxygen *chip,
+                            struct snd_pcm_hw_params *params)
+{
+        struct xonar_hdav *data = chip->model_data;
+
+        set_pcm1796_params(chip, params);
+        xonar_set_hdmi_params(chip, &data->hdmi, params);
+}
+
+static const struct snd_kcontrol_new alt_switch = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name = "Analog Loopback Switch",
+        .info = snd_ctl_boolean_mono_info,
+        .get = xonar_gpio_bit_switch_get,
+        .put = xonar_gpio_bit_switch_put,
+        .private_value = GPIO_D2_ALT,
+};
+
+static int rolloff_info(struct snd_kcontrol *ctl,
+                        struct snd_ctl_elem_info *info)
+{
+        static const char *const names[2] = {
+                "Sharp Roll-off", "Slow Roll-off"
+        };
+
+        info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        info->count = 1;
+        info->value.enumerated.items = 2;
+        if (info->value.enumerated.item >= 2)
+                info->value.enumerated.item = 1;
+        strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
+        return 0;
+}
+
+static int rolloff_get(struct snd_kcontrol *ctl,
+                       struct snd_ctl_elem_value *value)
+{
+        struct oxygen *chip = ctl->private_data;
+        struct xonar_pcm179x *data = chip->model_data;
+
+        value->value.enumerated.item[0] =
+                (data->pcm1796_regs[0][19 - PCM1796_REG_BASE] &
+                 PCM1796_FLT_MASK) != PCM1796_FLT_SHARP;
+        return 0;
+}
+
+static int rolloff_put(struct snd_kcontrol *ctl,
+                       struct snd_ctl_elem_value *value)
+{
+        struct oxygen *chip = ctl->private_data;
+        struct xonar_pcm179x *data = chip->model_data;
+        unsigned int i;
+        int changed;
+        u8 reg;
+
+        mutex_lock(&chip->mutex);
+        reg = data->pcm1796_regs[0][19 - PCM1796_REG_BASE];
+        reg &= ~PCM1796_FLT_MASK;
+        if (!value->value.enumerated.item[0])
+                reg |= PCM1796_FLT_SHARP;
+        else
+                reg |= PCM1796_FLT_SLOW;
+        changed = reg != data->pcm1796_regs[0][19 - PCM1796_REG_BASE];
+        if (changed) {
+                for (i = 0; i < data->dacs; ++i)
+                        pcm1796_write(chip, i, 19, reg);
+        }
+        mutex_unlock(&chip->mutex);
+        return changed;
+}
+
+static const struct snd_kcontrol_new rolloff_control = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name = "DAC Filter Playback Enum",
+        .info = rolloff_info,
+        .get = rolloff_get,
+        .put = rolloff_put,
+};
+
+static int os_128_info(struct snd_kcontrol *ctl, struct snd_ctl_elem_info *info)
+{
+        static const char *const names[2] = { "64x", "128x" };
+
+        info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        info->count = 1;
+        info->value.enumerated.items = 2;
+        if (info->value.enumerated.item >= 2)
+                info->value.enumerated.item = 1;
+        strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
+        return 0;
+}
+
+static int os_128_get(struct snd_kcontrol *ctl,
+                      struct snd_ctl_elem_value *value)
+{
+        struct oxygen *chip = ctl->private_data;
+        struct xonar_pcm179x *data = chip->model_data;
+
+        value->value.enumerated.item[0] = data->os_128;
+        return 0;
+}
+
+static int os_128_put(struct snd_kcontrol *ctl,
+                      struct snd_ctl_elem_value *value)
+{
+        struct oxygen *chip = ctl->private_data;
+        struct xonar_pcm179x *data = chip->model_data;
+        int changed;
+
+        mutex_lock(&chip->mutex);
+        changed = value->value.enumerated.item[0] != data->os_128;
+        if (changed) {
+                data->os_128 = value->value.enumerated.item[0];
+                if (data->has_cs2000)
+                        update_cs2000_rate(chip, data->current_rate);
+                oxygen_write16_masked(chip, OXYGEN_I2S_MULTICH_FORMAT,
+                                      mclk_from_rate(chip, data->current_rate),
+                                      OXYGEN_I2S_MCLK_MASK);
+                update_pcm1796_oversampling(chip);
+        }
+        mutex_unlock(&chip->mutex);
+        return changed;
+}
+
+static const struct snd_kcontrol_new os_128_control = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name = "DAC Oversampling Playback Enum",
+        .info = os_128_info,
+        .get = os_128_get,
+        .put = os_128_put,
+};
+
+static int st_output_switch_info(struct snd_kcontrol *ctl,
+                                 struct snd_ctl_elem_info *info)
+{
+        static const char *const names[3] = {
+                "Speakers", "Headphones", "FP Headphones"
+        };
+
+        info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        info->count = 1;
+        info->value.enumerated.items = 3;
+        if (info->value.enumerated.item >= 3)
+                info->value.enumerated.item = 2;
+        strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
+        return 0;
+}
+
+static int st_output_switch_get(struct snd_kcontrol *ctl,
+                                struct snd_ctl_elem_value *value)
+{
+        struct oxygen *chip = ctl->private_data;
+        u16 gpio;
+
+        gpio = oxygen_read16(chip, OXYGEN_GPIO_DATA);
+        if (!(gpio & GPIO_ST_HP))
+                value->value.enumerated.item[0] = 0;
+        else if (gpio & GPIO_ST_HP_REAR)
+                value->value.enumerated.item[0] = 1;
+        else
+                value->value.enumerated.item[0] = 2;
+        return 0;
+}
+
+
+static int st_output_switch_put(struct snd_kcontrol *ctl,
+                                struct snd_ctl_elem_value *value)
+{
+        struct oxygen *chip = ctl->private_data;
+        struct xonar_pcm179x *data = chip->model_data;
+        u16 gpio_old, gpio;
+
+        mutex_lock(&chip->mutex);
+        gpio_old = oxygen_read16(chip, OXYGEN_GPIO_DATA);
+        gpio = gpio_old;
+        switch (value->value.enumerated.item[0]) {
+        case 0:
+                gpio &= ~(GPIO_ST_HP | GPIO_ST_HP_REAR);
+                break;
+        case 1:
+                gpio |= GPIO_ST_HP | GPIO_ST_HP_REAR;
+                break;
+        case 2:
+                gpio = (gpio | GPIO_ST_HP) & ~GPIO_ST_HP_REAR;
+                break;
+        }
+        oxygen_write16(chip, OXYGEN_GPIO_DATA, gpio);
+        data->hp_active = gpio & GPIO_ST_HP;
+        update_pcm1796_volume(chip);
+        mutex_unlock(&chip->mutex);
+        return gpio != gpio_old;
+}
+
+static int st_hp_volume_offset_info(struct snd_kcontrol *ctl,
+                                    struct snd_ctl_elem_info *info)
+{
+        static const char *const names[3] = {
+                "< 64 ohms", "64-300 ohms", "300-600 ohms"
+        };
+
+        info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        info->count = 1;
+        info->value.enumerated.items = 3;
+        if (info->value.enumerated.item > 2)
+                info->value.enumerated.item = 2;
+        strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
+        return 0;
+}
+
+static int st_hp_volume_offset_get(struct snd_kcontrol *ctl,
+                                   struct snd_ctl_elem_value *value)
+{
+        struct oxygen *chip = ctl->private_data;
+        struct xonar_pcm179x *data = chip->model_data;
+
+        mutex_lock(&chip->mutex);
+        if (data->hp_gain_offset < 2*-6)
+                value->value.enumerated.item[0] = 0;
+        else if (data->hp_gain_offset < 0)
+                value->value.enumerated.item[0] = 1;
+        else
+                value->value.enumerated.item[0] = 2;
+        mutex_unlock(&chip->mutex);
+        return 0;
+}
+
+
+static int st_hp_volume_offset_put(struct snd_kcontrol *ctl,
+                                   struct snd_ctl_elem_value *value)
+{
+        static const s8 offsets[] = { 2*-18, 2*-6, 0 };
+        struct oxygen *chip = ctl->private_data;
+        struct xonar_pcm179x *data = chip->model_data;
+        s8 offset;
+        int changed;
+
+        if (value->value.enumerated.item[0] > 2)
+                return -EINVAL;
+        offset = offsets[value->value.enumerated.item[0]];
+        mutex_lock(&chip->mutex);
+        changed = offset != data->hp_gain_offset;
+        if (changed) {
+                data->hp_gain_offset = offset;
+                update_pcm1796_volume(chip);
+        }
+        mutex_unlock(&chip->mutex);
+        return changed;
+}
+
+static const struct snd_kcontrol_new st_controls[] = {
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Analog Output",
+                .info = st_output_switch_info,
+                .get = st_output_switch_get,
+                .put = st_output_switch_put,
+        },
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Headphones Impedance Playback Enum",
+                .info = st_hp_volume_offset_info,
+                .get = st_hp_volume_offset_get,
+                .put = st_hp_volume_offset_put,
+        },
+};
+
+static void xonar_line_mic_ac97_switch(struct oxygen *chip,
+                                       unsigned int reg, unsigned int mute)
+{
+        if (reg == AC97_LINE) {
+                spin_lock_irq(&chip->reg_lock);
+                oxygen_write16_masked(chip, OXYGEN_GPIO_DATA,
+                                      mute ? GPIO_INPUT_ROUTE : 0,
+                                      GPIO_INPUT_ROUTE);
+                spin_unlock_irq(&chip->reg_lock);
+        }
+}
+
+static const DECLARE_TLV_DB_SCALE(pcm1796_db_scale, -6000, 50, 0);
+
+static int xonar_d2_control_filter(struct snd_kcontrol_new *template)
+{
+        if (!strncmp(template->name, "CD Capture ", 11))
+                /* CD in is actually connected to the video in pin */
+                template->private_value ^= AC97_CD ^ AC97_VIDEO;
+        return 0;
+}
+
+static int xonar_st_control_filter(struct snd_kcontrol_new *template)
+{
+        if (!strncmp(template->name, "CD Capture ", 11))
+                return 1; /* no CD input */
+        return 0;
+}
+
+static int add_pcm1796_controls(struct oxygen *chip)
+{
+        int err;
+
+        err = snd_ctl_add(chip->card, snd_ctl_new1(&rolloff_control, chip));
+        if (err < 0)
+                return err;
+        err = snd_ctl_add(chip->card, snd_ctl_new1(&os_128_control, chip));
+        if (err < 0)
+                return err;
+        return 0;
+}
+
+static int xonar_d2_mixer_init(struct oxygen *chip)
+{
+        int err;
+
+        err = snd_ctl_add(chip->card, snd_ctl_new1(&alt_switch, chip));
+        if (err < 0)
+                return err;
+        err = add_pcm1796_controls(chip);
+        if (err < 0)
+                return err;
+        return 0;
+}
+
+static int xonar_hdav_mixer_init(struct oxygen *chip)
+{
+        return add_pcm1796_controls(chip);
+}
+
+static int xonar_st_mixer_init(struct oxygen *chip)
+{
+        unsigned int i;
+        int err;
+
+        for (i = 0; i < ARRAY_SIZE(st_controls); ++i) {
+                err = snd_ctl_add(chip->card,
+                                  snd_ctl_new1(&st_controls[i], chip));
+                if (err < 0)
+                        return err;
+        }
+        err = add_pcm1796_controls(chip);
+        if (err < 0)
+                return err;
+        return 0;
+}
+
+static const struct oxygen_model model_xonar_d2 = {
+        .longname = "Asus Virtuoso 200",
+        .chip = "AV200",
+        .init = xonar_d2_init,
+        .control_filter = xonar_d2_control_filter,
+        .mixer_init = xonar_d2_mixer_init,
+        .cleanup = xonar_d2_cleanup,
+        .suspend = xonar_d2_suspend,
+        .resume = xonar_d2_resume,
+        .get_i2s_mclk = get_pcm1796_i2s_mclk,
+        .set_dac_params = set_pcm1796_params,
+        .set_adc_params = xonar_set_cs53x1_params,
+        .update_dac_volume = update_pcm1796_volume,
+        .update_dac_mute = update_pcm1796_mute,
+        .dac_tlv = pcm1796_db_scale,
+        .model_data_size = sizeof(struct xonar_pcm179x),
+        .device_config = PLAYBACK_0_TO_I2S |
+                         PLAYBACK_1_TO_SPDIF |
+                         CAPTURE_0_FROM_I2S_2 |
+                         CAPTURE_1_FROM_SPDIF |
+                         MIDI_OUTPUT |
+                         MIDI_INPUT,
+        .dac_channels = 8,
+        .dac_volume_min = 255 - 2*60,
+        .dac_volume_max = 255,
+        .misc_flags = OXYGEN_MISC_MIDI,
+        .function_flags = OXYGEN_FUNCTION_SPI |
+                          OXYGEN_FUNCTION_ENABLE_SPI_4_5,
+        .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
+        .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
+};
+
+static const struct oxygen_model model_xonar_hdav = {
+        .longname = "Asus Virtuoso 200",
+        .chip = "AV200",
+        .init = xonar_hdav_init,
+        .mixer_init = xonar_hdav_mixer_init,
+        .cleanup = xonar_hdav_cleanup,
+        .suspend = xonar_hdav_suspend,
+        .resume = xonar_hdav_resume,
+        .pcm_hardware_filter = xonar_hdmi_pcm_hardware_filter,
+        .get_i2s_mclk = get_pcm1796_i2s_mclk,
+        .set_dac_params = set_hdav_params,
+        .set_adc_params = xonar_set_cs53x1_params,
+        .update_dac_volume = update_pcm1796_volume,
+        .update_dac_mute = update_pcm1796_mute,
+        .uart_input = xonar_hdmi_uart_input,
+        .ac97_switch = xonar_line_mic_ac97_switch,
+        .dac_tlv = pcm1796_db_scale,
+        .model_data_size = sizeof(struct xonar_hdav),
+        .device_config = PLAYBACK_0_TO_I2S |
+                         PLAYBACK_1_TO_SPDIF |
+                         CAPTURE_0_FROM_I2S_2 |
+                         CAPTURE_1_FROM_SPDIF,
+        .dac_channels = 8,
+        .dac_volume_min = 255 - 2*60,
+        .dac_volume_max = 255,
+        .misc_flags = OXYGEN_MISC_MIDI,
+        .function_flags = OXYGEN_FUNCTION_2WIRE,
+        .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
+        .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
+};
+
+static const struct oxygen_model model_xonar_st = {
+        .longname = "Asus Virtuoso 100",
+        .chip = "AV200",
+        .init = xonar_st_init,
+        .control_filter = xonar_st_control_filter,
+        .mixer_init = xonar_st_mixer_init,
+        .cleanup = xonar_st_cleanup,
+        .suspend = xonar_st_suspend,
+        .resume = xonar_st_resume,
+        .get_i2s_mclk = get_pcm1796_i2s_mclk,
+        .set_dac_params = set_st_params,
+        .set_adc_params = xonar_set_cs53x1_params,
+        .update_dac_volume = update_pcm1796_volume,
+        .update_dac_mute = update_pcm1796_mute,
+        .ac97_switch = xonar_line_mic_ac97_switch,
+        .dac_tlv = pcm1796_db_scale,
+        .model_data_size = sizeof(struct xonar_pcm179x),
+        .device_config = PLAYBACK_0_TO_I2S |
+                         PLAYBACK_1_TO_SPDIF |
+                         CAPTURE_0_FROM_I2S_2,
+        .dac_channels = 2,
+        .dac_volume_min = 255 - 2*60,
+        .dac_volume_max = 255,
+        .function_flags = OXYGEN_FUNCTION_2WIRE,
+        .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
+        .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
+};
+
+int __devinit get_xonar_pcm179x_model(struct oxygen *chip,
+                                      const struct pci_device_id *id)
+{
+        switch (id->subdevice) {
+        case 0x8269:
+                chip->model = model_xonar_d2;
+                chip->model.shortname = "Xonar D2";
+                break;
+        case 0x82b7:
+                chip->model = model_xonar_d2;
+                chip->model.shortname = "Xonar D2X";
+                chip->model.init = xonar_d2x_init;
+                break;
+        case 0x8314:
+                chip->model = model_xonar_hdav;
+                oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_DB_MASK);
+                switch (oxygen_read16(chip, OXYGEN_GPIO_DATA) & GPIO_DB_MASK) {
+                default:
+                        chip->model.shortname = "Xonar HDAV1.3";
+                        break;
+                case GPIO_DB_H6:
+                        chip->model.shortname = "Xonar HDAV1.3+H6";
+                        chip->model.private_data = 1;
+                        break;
+                }
+                break;
+        case 0x835d:
+                chip->model = model_xonar_st;
+                oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_DB_MASK);
+                switch (oxygen_read16(chip, OXYGEN_GPIO_DATA) & GPIO_DB_MASK) {
+                default:
+                        chip->model.shortname = "Xonar ST";
+                        break;
+                case GPIO_DB_H6:
+                        chip->model.shortname = "Xonar ST+H6";
+                        chip->model.dac_channels = 8;
+                        chip->model.private_data = 1;
+                        break;
+                }
+                break;
+        case 0x835c:
+                chip->model = model_xonar_st;
+                chip->model.shortname = "Xonar STX";
+                chip->model.init = xonar_stx_init;
+                chip->model.resume = xonar_stx_resume;
+                chip->model.set_dac_params = set_pcm1796_params;
+                break;
+        default:
+                return -EINVAL;
+        }
+        return 0;
+}
diff --git a/sound/pci/oxygen/xonar_wm87x6.c b/sound/pci/oxygen/xonar_wm87x6.c
new file mode 100644
index 000000000000..dbc4b89d74e4
--- /dev/null
+++ b/sound/pci/oxygen/xonar_wm87x6.c
@@ -0,0 +1,1021 @@
+/*
+ * card driver for models with WM8776/WM8766 DACs (Xonar DS)
+ *
+ * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
+ *
+ *
+ *  This driver is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License, version 2.
+ *
+ *  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 driver; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * Xonar DS
+ * --------
+ *
+ * CMI8788:
+ *
+ * SPI 0 -> WM8766 (surround, center/LFE, back)
+ * SPI 1 -> WM8776 (front, input)
+ *
+ * GPIO 4 <- headphone detect
+ * GPIO 6 -> route input jack to input 1/2 (1/0)
+ * GPIO 7 -> enable output to speakers
+ * GPIO 8 -> enable output to speakers
+ */
+
+#include <linux/pci.h>
+#include <linux/delay.h>
+#include <sound/control.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/tlv.h>
+#include "xonar.h"
+#include "wm8776.h"
+#include "wm8766.h"
+
+#define GPIO_DS_HP_DETECT       0x0010
+#define GPIO_DS_INPUT_ROUTE     0x0040
+#define GPIO_DS_OUTPUT_ENABLE   0x0180
+
+#define LC_CONTROL_LIMITER      0x40000000
+#define LC_CONTROL_ALC          0x20000000
+
+struct xonar_wm87x6 {
+        struct xonar_generic generic;
+        u16 wm8776_regs[0x17];
+        u16 wm8766_regs[0x10];
+        struct snd_kcontrol *lc_controls[13];
+};
+
+static void wm8776_write(struct oxygen *chip,
+                         unsigned int reg, unsigned int value)
+{
+        struct xonar_wm87x6 *data = chip->model_data;
+
+        oxygen_write_spi(chip, OXYGEN_SPI_TRIGGER |
+                         OXYGEN_SPI_DATA_LENGTH_2 |
+                         OXYGEN_SPI_CLOCK_160 |
+                         (1 << OXYGEN_SPI_CODEC_SHIFT) |
+                         OXYGEN_SPI_CEN_LATCH_CLOCK_LO,
+                         (reg << 9) | value);
+        if (reg < ARRAY_SIZE(data->wm8776_regs)) {
+                if (reg >= WM8776_HPLVOL && reg <= WM8776_DACMASTER)
+                        value &= ~WM8776_UPDATE;
+                data->wm8776_regs[reg] = value;
+        }
+}
+
+static void wm8776_write_cached(struct oxygen *chip,
+                                unsigned int reg, unsigned int value)
+{
+        struct xonar_wm87x6 *data = chip->model_data;
+
+        if (reg >= ARRAY_SIZE(data->wm8776_regs) ||
+            value != data->wm8776_regs[reg])
+                wm8776_write(chip, reg, value);
+}
+
+static void wm8766_write(struct oxygen *chip,
+                         unsigned int reg, unsigned int value)
+{
+        struct xonar_wm87x6 *data = chip->model_data;
+
+        oxygen_write_spi(chip, OXYGEN_SPI_TRIGGER |
+                         OXYGEN_SPI_DATA_LENGTH_2 |
+                         OXYGEN_SPI_CLOCK_160 |
+                         (0 << OXYGEN_SPI_CODEC_SHIFT) |
+                         OXYGEN_SPI_CEN_LATCH_CLOCK_LO,
+                         (reg << 9) | value);
+        if (reg < ARRAY_SIZE(data->wm8766_regs))
+                data->wm8766_regs[reg] = value;
+}
+
+static void wm8766_write_cached(struct oxygen *chip,
+                                unsigned int reg, unsigned int value)
+{
+        struct xonar_wm87x6 *data = chip->model_data;
+
+        if (reg >= ARRAY_SIZE(data->wm8766_regs) ||
+            value != data->wm8766_regs[reg]) {
+                if ((reg >= WM8766_LDA1 && reg <= WM8766_RDA1) ||
+                    (reg >= WM8766_LDA2 && reg <= WM8766_MASTDA))
+                        value &= ~WM8766_UPDATE;
+                wm8766_write(chip, reg, value);
+        }
+}
+
+static void wm8776_registers_init(struct oxygen *chip)
+{
+        struct xonar_wm87x6 *data = chip->model_data;
+
+        wm8776_write(chip, WM8776_RESET, 0);
+        wm8776_write(chip, WM8776_DACCTRL1, WM8776_DZCEN |
+                     WM8776_PL_LEFT_LEFT | WM8776_PL_RIGHT_RIGHT);
+        wm8776_write(chip, WM8776_DACMUTE, chip->dac_mute ? WM8776_DMUTE : 0);
+        wm8776_write(chip, WM8776_DACIFCTRL,
+                     WM8776_DACFMT_LJUST | WM8776_DACWL_24);
+        wm8776_write(chip, WM8776_ADCIFCTRL,
+                     data->wm8776_regs[WM8776_ADCIFCTRL]);
+        wm8776_write(chip, WM8776_MSTRCTRL, data->wm8776_regs[WM8776_MSTRCTRL]);
+        wm8776_write(chip, WM8776_PWRDOWN, data->wm8776_regs[WM8776_PWRDOWN]);
+        wm8776_write(chip, WM8776_HPLVOL, data->wm8776_regs[WM8776_HPLVOL]);
+        wm8776_write(chip, WM8776_HPRVOL, data->wm8776_regs[WM8776_HPRVOL] |
+                     WM8776_UPDATE);
+        wm8776_write(chip, WM8776_ADCLVOL, data->wm8776_regs[WM8776_ADCLVOL]);
+        wm8776_write(chip, WM8776_ADCRVOL, data->wm8776_regs[WM8776_ADCRVOL]);
+        wm8776_write(chip, WM8776_ADCMUX, data->wm8776_regs[WM8776_ADCMUX]);
+        wm8776_write(chip, WM8776_DACLVOL, chip->dac_volume[0]);
+        wm8776_write(chip, WM8776_DACRVOL, chip->dac_volume[1] | WM8776_UPDATE);
+}
+
+static void wm8766_registers_init(struct oxygen *chip)
+{
+        wm8766_write(chip, WM8766_RESET, 0);
+        wm8766_write(chip, WM8766_INT_CTRL, WM8766_FMT_LJUST | WM8766_IWL_24);
+        wm8766_write(chip, WM8766_DAC_CTRL2,
+                     WM8766_ZCD | (chip->dac_mute ? WM8766_DMUTE_MASK : 0));
+        wm8766_write(chip, WM8766_LDA1, chip->dac_volume[2]);
+        wm8766_write(chip, WM8766_RDA1, chip->dac_volume[3]);
+        wm8766_write(chip, WM8766_LDA2, chip->dac_volume[4]);
+        wm8766_write(chip, WM8766_RDA2, chip->dac_volume[5]);
+        wm8766_write(chip, WM8766_LDA3, chip->dac_volume[6]);
+        wm8766_write(chip, WM8766_RDA3, chip->dac_volume[7] | WM8766_UPDATE);
+}
+
+static void wm8776_init(struct oxygen *chip)
+{
+        struct xonar_wm87x6 *data = chip->model_data;
+
+        data->wm8776_regs[WM8776_HPLVOL] = (0x79 - 60) | WM8776_HPZCEN;
+        data->wm8776_regs[WM8776_HPRVOL] = (0x79 - 60) | WM8776_HPZCEN;
+        data->wm8776_regs[WM8776_ADCIFCTRL] =
+                WM8776_ADCFMT_LJUST | WM8776_ADCWL_24 | WM8776_ADCMCLK;
+        data->wm8776_regs[WM8776_MSTRCTRL] =
+                WM8776_ADCRATE_256 | WM8776_DACRATE_256;
+        data->wm8776_regs[WM8776_PWRDOWN] = WM8776_HPPD;
+        data->wm8776_regs[WM8776_ADCLVOL] = 0xa5 | WM8776_ZCA;
+        data->wm8776_regs[WM8776_ADCRVOL] = 0xa5 | WM8776_ZCA;
+        data->wm8776_regs[WM8776_ADCMUX] = 0x001;
+        wm8776_registers_init(chip);
+}
+
+static void xonar_ds_init(struct oxygen *chip)
+{
+        struct xonar_wm87x6 *data = chip->model_data;
+
+        data->generic.anti_pop_delay = 300;
+        data->generic.output_enable_bit = GPIO_DS_OUTPUT_ENABLE;
+
+        wm8776_init(chip);
+        wm8766_registers_init(chip);
+
+        oxygen_write16_masked(chip, OXYGEN_GPIO_CONTROL, GPIO_DS_INPUT_ROUTE,
+                              GPIO_DS_HP_DETECT | GPIO_DS_INPUT_ROUTE);
+        oxygen_set_bits16(chip, OXYGEN_GPIO_DATA, GPIO_DS_INPUT_ROUTE);
+        oxygen_set_bits16(chip, OXYGEN_GPIO_INTERRUPT_MASK, GPIO_DS_HP_DETECT);
+        chip->interrupt_mask |= OXYGEN_INT_GPIO;
+
+        xonar_enable_output(chip);
+
+        snd_component_add(chip->card, "WM8776");
+        snd_component_add(chip->card, "WM8766");
+}
+
+static void xonar_ds_cleanup(struct oxygen *chip)
+{
+        xonar_disable_output(chip);
+}
+
+static void xonar_ds_suspend(struct oxygen *chip)
+{
+        xonar_ds_cleanup(chip);
+}
+
+static void xonar_ds_resume(struct oxygen *chip)
+{
+        wm8776_registers_init(chip);
+        wm8766_registers_init(chip);
+        xonar_enable_output(chip);
+}
+
+static void wm8776_adc_hardware_filter(unsigned int channel,
+                                       struct snd_pcm_hardware *hardware)
+{
+        if (channel == PCM_A) {
+                hardware->rates = SNDRV_PCM_RATE_32000 |
+                                  SNDRV_PCM_RATE_44100 |
+                                  SNDRV_PCM_RATE_48000 |
+                                  SNDRV_PCM_RATE_64000 |
+                                  SNDRV_PCM_RATE_88200 |
+                                  SNDRV_PCM_RATE_96000;
+                hardware->rate_max = 96000;
+        }
+}
+
+static void set_wm87x6_dac_params(struct oxygen *chip,
+                                  struct snd_pcm_hw_params *params)
+{
+}
+
+static void set_wm8776_adc_params(struct oxygen *chip,
+                                  struct snd_pcm_hw_params *params)
+{
+        u16 reg;
+
+        reg = WM8776_ADCRATE_256 | WM8776_DACRATE_256;
+        if (params_rate(params) > 48000)
+                reg |= WM8776_ADCOSR;
+        wm8776_write_cached(chip, WM8776_MSTRCTRL, reg);
+}
+
+static void update_wm8776_volume(struct oxygen *chip)
+{
+        struct xonar_wm87x6 *data = chip->model_data;
+        u8 to_change;
+
+        if (chip->dac_volume[0] == chip->dac_volume[1]) {
+                if (chip->dac_volume[0] != data->wm8776_regs[WM8776_DACLVOL] ||
+                    chip->dac_volume[1] != data->wm8776_regs[WM8776_DACRVOL]) {
+                        wm8776_write(chip, WM8776_DACMASTER,
+                                     chip->dac_volume[0] | WM8776_UPDATE);
+                        data->wm8776_regs[WM8776_DACLVOL] = chip->dac_volume[0];
+                        data->wm8776_regs[WM8776_DACRVOL] = chip->dac_volume[0];
+                }
+        } else {
+                to_change = (chip->dac_volume[0] !=
+                             data->wm8776_regs[WM8776_DACLVOL]) << 0;
+                to_change |= (chip->dac_volume[1] !=
+                              data->wm8776_regs[WM8776_DACLVOL]) << 1;
+                if (to_change & 1)
+                        wm8776_write(chip, WM8776_DACLVOL, chip->dac_volume[0] |
+                                     ((to_change & 2) ? 0 : WM8776_UPDATE));
+                if (to_change & 2)
+                        wm8776_write(chip, WM8776_DACRVOL,
+                                     chip->dac_volume[1] | WM8776_UPDATE);
+        }
+}
+
+static void update_wm87x6_volume(struct oxygen *chip)
+{
+        static const u8 wm8766_regs[6] = {
+                WM8766_LDA1, WM8766_RDA1,
+                WM8766_LDA2, WM8766_RDA2,
+                WM8766_LDA3, WM8766_RDA3,
+        };
+        struct xonar_wm87x6 *data = chip->model_data;
+        unsigned int i;
+        u8 to_change;
+
+        update_wm8776_volume(chip);
+        if (chip->dac_volume[2] == chip->dac_volume[3] &&
+            chip->dac_volume[2] == chip->dac_volume[4] &&
+            chip->dac_volume[2] == chip->dac_volume[5] &&
+            chip->dac_volume[2] == chip->dac_volume[6] &&
+            chip->dac_volume[2] == chip->dac_volume[7]) {
+                to_change = 0;
+                for (i = 0; i < 6; ++i)
+                        if (chip->dac_volume[2] !=
+                            data->wm8766_regs[wm8766_regs[i]])
+                                to_change = 1;
+                if (to_change) {
+                        wm8766_write(chip, WM8766_MASTDA,
+                                     chip->dac_volume[2] | WM8766_UPDATE);
+                        for (i = 0; i < 6; ++i)
+                                data->wm8766_regs[wm8766_regs[i]] =
+                                        chip->dac_volume[2];
+                }
+        } else {
+                to_change = 0;
+                for (i = 0; i < 6; ++i)
+                        to_change |= (chip->dac_volume[2 + i] !=
+                                      data->wm8766_regs[wm8766_regs[i]]) << i;
+                for (i = 0; i < 6; ++i)
+                        if (to_change & (1 << i))
+                                wm8766_write(chip, wm8766_regs[i],
+                                             chip->dac_volume[2 + i] |
+                                             ((to_change & (0x3e << i))
+                                              ? 0 : WM8766_UPDATE));
+        }
+}
+
+static void update_wm8776_mute(struct oxygen *chip)
+{
+        wm8776_write_cached(chip, WM8776_DACMUTE,
+                            chip->dac_mute ? WM8776_DMUTE : 0);
+}
+
+static void update_wm87x6_mute(struct oxygen *chip)
+{
+        update_wm8776_mute(chip);
+        wm8766_write_cached(chip, WM8766_DAC_CTRL2, WM8766_ZCD |
+                            (chip->dac_mute ? WM8766_DMUTE_MASK : 0));
+}
+
+static void xonar_ds_gpio_changed(struct oxygen *chip)
+{
+        u16 bits;
+
+        bits = oxygen_read16(chip, OXYGEN_GPIO_DATA);
+        snd_printk(KERN_INFO "HP detect: %d\n", !!(bits & GPIO_DS_HP_DETECT));
+}
+
+static int wm8776_bit_switch_get(struct snd_kcontrol *ctl,
+                                 struct snd_ctl_elem_value *value)
+{
+        struct oxygen *chip = ctl->private_data;
+        struct xonar_wm87x6 *data = chip->model_data;
+        u16 bit = ctl->private_value & 0xffff;
+        unsigned int reg_index = (ctl->private_value >> 16) & 0xff;
+        bool invert = (ctl->private_value >> 24) & 1;
+
+        value->value.integer.value[0] =
+                ((data->wm8776_regs[reg_index] & bit) != 0) ^ invert;
+        return 0;
+}
+
+static int wm8776_bit_switch_put(struct snd_kcontrol *ctl,
+                                 struct snd_ctl_elem_value *value)
+{
+        struct oxygen *chip = ctl->private_data;
+        struct xonar_wm87x6 *data = chip->model_data;
+        u16 bit = ctl->private_value & 0xffff;
+        u16 reg_value;
+        unsigned int reg_index = (ctl->private_value >> 16) & 0xff;
+        bool invert = (ctl->private_value >> 24) & 1;
+        int changed;
+
+        mutex_lock(&chip->mutex);
+        reg_value = data->wm8776_regs[reg_index] & ~bit;
+        if (value->value.integer.value[0] ^ invert)
+                reg_value |= bit;
+        changed = reg_value != data->wm8776_regs[reg_index];
+        if (changed)
+                wm8776_write(chip, reg_index, reg_value);
+        mutex_unlock(&chip->mutex);
+        return changed;
+}
+
+static int wm8776_field_enum_info(struct snd_kcontrol *ctl,
+                                  struct snd_ctl_elem_info *info)
+{
+        static const char *const hld[16] = {
+                "0 ms", "2.67 ms", "5.33 ms", "10.6 ms",
+                "21.3 ms", "42.7 ms", "85.3 ms", "171 ms",
+                "341 ms", "683 ms", "1.37 s", "2.73 s",
+                "5.46 s", "10.9 s", "21.8 s", "43.7 s",
+        };
+        static const char *const atk_lim[11] = {
+                "0.25 ms", "0.5 ms", "1 ms", "2 ms",
+                "4 ms", "8 ms", "16 ms", "32 ms",
+                "64 ms", "128 ms", "256 ms",
+        };
+        static const char *const atk_alc[11] = {
+                "8.40 ms", "16.8 ms", "33.6 ms", "67.2 ms",
+                "134 ms", "269 ms", "538 ms", "1.08 s",
+                "2.15 s", "4.3 s", "8.6 s",
+        };
+        static const char *const dcy_lim[11] = {
+                "1.2 ms", "2.4 ms", "4.8 ms", "9.6 ms",
+                "19.2 ms", "38.4 ms", "76.8 ms", "154 ms",
+                "307 ms", "614 ms", "1.23 s",
+        };
+        static const char *const dcy_alc[11] = {
+                "33.5 ms", "67.0 ms", "134 ms", "268 ms",
+                "536 ms", "1.07 s", "2.14 s", "4.29 s",
+                "8.58 s", "17.2 s", "34.3 s",
+        };
+        static const char *const tranwin[8] = {
+                "0 us", "62.5 us", "125 us", "250 us",
+                "500 us", "1 ms", "2 ms", "4 ms",
+        };
+        u8 max;
+        const char *const *names;
+
+        max = (ctl->private_value >> 12) & 0xf;
+        info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        info->count = 1;
+        info->value.enumerated.items = max + 1;
+        if (info->value.enumerated.item > max)
+                info->value.enumerated.item = max;
+        switch ((ctl->private_value >> 24) & 0x1f) {
+        case WM8776_ALCCTRL2:
+                names = hld;
+                break;
+        case WM8776_ALCCTRL3:
+                if (((ctl->private_value >> 20) & 0xf) == 0) {
+                        if (ctl->private_value & LC_CONTROL_LIMITER)
+                                names = atk_lim;
+                        else
+                                names = atk_alc;
+                } else {
+                        if (ctl->private_value & LC_CONTROL_LIMITER)
+                                names = dcy_lim;
+                        else
+                                names = dcy_alc;
+                }
+                break;
+        case WM8776_LIMITER:
+                names = tranwin;
+                break;
+        default:
+                return -ENXIO;
+        }
+        strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
+        return 0;
+}
+
+static int wm8776_field_volume_info(struct snd_kcontrol *ctl,
+                                    struct snd_ctl_elem_info *info)
+{
+        info->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+        info->count = 1;
+        info->value.integer.min = (ctl->private_value >> 8) & 0xf;
+        info->value.integer.max = (ctl->private_value >> 12) & 0xf;
+        return 0;
+}
+
+static void wm8776_field_set_from_ctl(struct snd_kcontrol *ctl)
+{
+        struct oxygen *chip = ctl->private_data;
+        struct xonar_wm87x6 *data = chip->model_data;
+        unsigned int value, reg_index, mode;
+        u8 min, max, shift;
+        u16 mask, reg_value;
+        bool invert;
+
+        if ((data->wm8776_regs[WM8776_ALCCTRL1] & WM8776_LCSEL_MASK) ==
+            WM8776_LCSEL_LIMITER)
+                mode = LC_CONTROL_LIMITER;
+        else
+                mode = LC_CONTROL_ALC;
+        if (!(ctl->private_value & mode))
+                return;
+
+        value = ctl->private_value & 0xf;
+        min = (ctl->private_value >> 8) & 0xf;
+        max = (ctl->private_value >> 12) & 0xf;
+        mask = (ctl->private_value >> 16) & 0xf;
+        shift = (ctl->private_value >> 20) & 0xf;
+        reg_index = (ctl->private_value >> 24) & 0x1f;
+        invert = (ctl->private_value >> 29) & 0x1;
+
+        if (invert)
+                value = max - (value - min);
+        reg_value = data->wm8776_regs[reg_index];
+        reg_value &= ~(mask << shift);
+        reg_value |= value << shift;
+        wm8776_write_cached(chip, reg_index, reg_value);
+}
+
+static int wm8776_field_set(struct snd_kcontrol *ctl, unsigned int value)
+{
+        struct oxygen *chip = ctl->private_data;
+        u8 min, max;
+        int changed;
+
+        min = (ctl->private_value >> 8) & 0xf;
+        max = (ctl->private_value >> 12) & 0xf;
+        if (value < min || value > max)
+                return -EINVAL;
+        mutex_lock(&chip->mutex);
+        changed = value != (ctl->private_value & 0xf);
+        if (changed) {
+                ctl->private_value = (ctl->private_value & ~0xf) | value;
+                wm8776_field_set_from_ctl(ctl);
+        }
+        mutex_unlock(&chip->mutex);
+        return changed;
+}
+
+static int wm8776_field_enum_get(struct snd_kcontrol *ctl,
+                                 struct snd_ctl_elem_value *value)
+{
+        value->value.enumerated.item[0] = ctl->private_value & 0xf;
+        return 0;
+}
+
+static int wm8776_field_volume_get(struct snd_kcontrol *ctl,
+                                   struct snd_ctl_elem_value *value)
+{
+        value->value.integer.value[0] = ctl->private_value & 0xf;
+        return 0;
+}
+
+static int wm8776_field_enum_put(struct snd_kcontrol *ctl,
+                                 struct snd_ctl_elem_value *value)
+{
+        return wm8776_field_set(ctl, value->value.enumerated.item[0]);
+}
+
+static int wm8776_field_volume_put(struct snd_kcontrol *ctl,
+                                   struct snd_ctl_elem_value *value)
+{
+        return wm8776_field_set(ctl, value->value.integer.value[0]);
+}
+
+static int wm8776_hp_vol_info(struct snd_kcontrol *ctl,
+                              struct snd_ctl_elem_info *info)
+{
+        info->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+        info->count = 2;
+        info->value.integer.min = 0x79 - 60;
+        info->value.integer.max = 0x7f;
+        return 0;
+}
+
+static int wm8776_hp_vol_get(struct snd_kcontrol *ctl,
+                             struct snd_ctl_elem_value *value)
+{
+        struct oxygen *chip = ctl->private_data;
+        struct xonar_wm87x6 *data = chip->model_data;
+
+        mutex_lock(&chip->mutex);
+        value->value.integer.value[0] =
+                data->wm8776_regs[WM8776_HPLVOL] & WM8776_HPATT_MASK;
+        value->value.integer.value[1] =
+                data->wm8776_regs[WM8776_HPRVOL] & WM8776_HPATT_MASK;
+        mutex_unlock(&chip->mutex);
+        return 0;
+}
+
+static int wm8776_hp_vol_put(struct snd_kcontrol *ctl,
+                             struct snd_ctl_elem_value *value)
+{
+        struct oxygen *chip = ctl->private_data;
+        struct xonar_wm87x6 *data = chip->model_data;
+        u8 to_update;
+
+        mutex_lock(&chip->mutex);
+        to_update = (value->value.integer.value[0] !=
+                     (data->wm8776_regs[WM8776_HPLVOL] & WM8776_HPATT_MASK))
+                << 0;
+        to_update |= (value->value.integer.value[1] !=
+                      (data->wm8776_regs[WM8776_HPRVOL] & WM8776_HPATT_MASK))
+                << 1;
+        if (value->value.integer.value[0] == value->value.integer.value[1]) {
+                if (to_update) {
+                        wm8776_write(chip, WM8776_HPMASTER,
+                                     value->value.integer.value[0] |
+                                     WM8776_HPZCEN | WM8776_UPDATE);
+                        data->wm8776_regs[WM8776_HPLVOL] =
+                                value->value.integer.value[0] | WM8776_HPZCEN;
+                        data->wm8776_regs[WM8776_HPRVOL] =
+                                value->value.integer.value[0] | WM8776_HPZCEN;
+                }
+        } else {
+                if (to_update & 1)
+                        wm8776_write(chip, WM8776_HPLVOL,
+                                     value->value.integer.value[0] |
+                                     WM8776_HPZCEN |
+                                     ((to_update & 2) ? 0 : WM8776_UPDATE));
+                if (to_update & 2)
+                        wm8776_write(chip, WM8776_HPRVOL,
+                                     value->value.integer.value[1] |
+                                     WM8776_HPZCEN | WM8776_UPDATE);
+        }
+        mutex_unlock(&chip->mutex);
+        return to_update != 0;
+}
+
+static int wm8776_input_mux_get(struct snd_kcontrol *ctl,
+                                struct snd_ctl_elem_value *value)
+{
+        struct oxygen *chip = ctl->private_data;
+        struct xonar_wm87x6 *data = chip->model_data;
+        unsigned int mux_bit = ctl->private_value;
+
+        value->value.integer.value[0] =
+                !!(data->wm8776_regs[WM8776_ADCMUX] & mux_bit);
+        return 0;
+}
+
+static int wm8776_input_mux_put(struct snd_kcontrol *ctl,
+                                struct snd_ctl_elem_value *value)
+{
+        struct oxygen *chip = ctl->private_data;
+        struct xonar_wm87x6 *data = chip->model_data;
+        unsigned int mux_bit = ctl->private_value;
+        u16 reg;
+        int changed;
+
+        mutex_lock(&chip->mutex);
+        reg = data->wm8776_regs[WM8776_ADCMUX];
+        if (value->value.integer.value[0]) {
+                reg &= ~0x003;
+                reg |= mux_bit;
+        } else
+                reg &= ~mux_bit;
+        changed = reg != data->wm8776_regs[WM8776_ADCMUX];
+        if (changed) {
+                oxygen_write16_masked(chip, OXYGEN_GPIO_DATA,
+                                      reg & 1 ? GPIO_DS_INPUT_ROUTE : 0,
+                                      GPIO_DS_INPUT_ROUTE);
+                wm8776_write(chip, WM8776_ADCMUX, reg);
+        }
+        mutex_unlock(&chip->mutex);
+        return changed;
+}
+
+static int wm8776_input_vol_info(struct snd_kcontrol *ctl,
+                                 struct snd_ctl_elem_info *info)
+{
+        info->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+        info->count = 2;
+        info->value.integer.min = 0xa5;
+        info->value.integer.max = 0xff;
+        return 0;
+}
+
+static int wm8776_input_vol_get(struct snd_kcontrol *ctl,
+                                struct snd_ctl_elem_value *value)
+{
+        struct oxygen *chip = ctl->private_data;
+        struct xonar_wm87x6 *data = chip->model_data;
+
+        mutex_lock(&chip->mutex);
+        value->value.integer.value[0] =
+                data->wm8776_regs[WM8776_ADCLVOL] & WM8776_AGMASK;
+        value->value.integer.value[1] =
+                data->wm8776_regs[WM8776_ADCRVOL] & WM8776_AGMASK;
+        mutex_unlock(&chip->mutex);
+        return 0;
+}
+
+static int wm8776_input_vol_put(struct snd_kcontrol *ctl,
+                                struct snd_ctl_elem_value *value)
+{
+        struct oxygen *chip = ctl->private_data;
+        struct xonar_wm87x6 *data = chip->model_data;
+        int changed = 0;
+
+        mutex_lock(&chip->mutex);
+        changed = (value->value.integer.value[0] !=
+                   (data->wm8776_regs[WM8776_ADCLVOL] & WM8776_AGMASK)) ||
+                  (value->value.integer.value[1] !=
+                   (data->wm8776_regs[WM8776_ADCRVOL] & WM8776_AGMASK));
+        wm8776_write_cached(chip, WM8776_ADCLVOL,
+                            value->value.integer.value[0] | WM8776_ZCA);
+        wm8776_write_cached(chip, WM8776_ADCRVOL,
+                            value->value.integer.value[1] | WM8776_ZCA);
+        mutex_unlock(&chip->mutex);
+        return changed;
+}
+
+static int wm8776_level_control_info(struct snd_kcontrol *ctl,
+                                     struct snd_ctl_elem_info *info)
+{
+        static const char *const names[3] = {
+                "None", "Peak Limiter", "Automatic Level Control"
+        };
+        info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        info->count = 1;
+        info->value.enumerated.items = 3;
+        if (info->value.enumerated.item >= 3)
+                info->value.enumerated.item = 2;
+        strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
+        return 0;
+}
+
+static int wm8776_level_control_get(struct snd_kcontrol *ctl,
+                                    struct snd_ctl_elem_value *value)
+{
+        struct oxygen *chip = ctl->private_data;
+        struct xonar_wm87x6 *data = chip->model_data;
+
+        if (!(data->wm8776_regs[WM8776_ALCCTRL2] & WM8776_LCEN))
+                value->value.enumerated.item[0] = 0;
+        else if ((data->wm8776_regs[WM8776_ALCCTRL1] & WM8776_LCSEL_MASK) ==
+                 WM8776_LCSEL_LIMITER)
+                value->value.enumerated.item[0] = 1;
+        else
+                value->value.enumerated.item[0] = 2;
+        return 0;
+}
+
+static void activate_control(struct oxygen *chip,
+                             struct snd_kcontrol *ctl, unsigned int mode)
+{
+        unsigned int access;
+
+        if (ctl->private_value & mode)
+                access = 0;
+        else
+                access = SNDRV_CTL_ELEM_ACCESS_INACTIVE;
+        if ((ctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_INACTIVE) != access) {
+                ctl->vd[0].access ^= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
+                snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_INFO, &ctl->id);
+        }
+}
+
+static int wm8776_level_control_put(struct snd_kcontrol *ctl,
+                                    struct snd_ctl_elem_value *value)
+{
+        struct oxygen *chip = ctl->private_data;
+        struct xonar_wm87x6 *data = chip->model_data;
+        unsigned int mode = 0, i;
+        u16 ctrl1, ctrl2;
+        int changed;
+
+        if (value->value.enumerated.item[0] >= 3)
+                return -EINVAL;
+        mutex_lock(&chip->mutex);
+        changed = value->value.enumerated.item[0] != ctl->private_value;
+        if (changed) {
+                ctl->private_value = value->value.enumerated.item[0];
+                ctrl1 = data->wm8776_regs[WM8776_ALCCTRL1];
+                ctrl2 = data->wm8776_regs[WM8776_ALCCTRL2];
+                switch (value->value.enumerated.item[0]) {
+                default:
+                        wm8776_write_cached(chip, WM8776_ALCCTRL2,
+                                            ctrl2 & ~WM8776_LCEN);
+                        break;
+                case 1:
+                        wm8776_write_cached(chip, WM8776_ALCCTRL1,
+                                            (ctrl1 & ~WM8776_LCSEL_MASK) |
+                                            WM8776_LCSEL_LIMITER);
+                        wm8776_write_cached(chip, WM8776_ALCCTRL2,
+                                            ctrl2 | WM8776_LCEN);
+                        mode = LC_CONTROL_LIMITER;
+                        break;
+                case 2:
+                        wm8776_write_cached(chip, WM8776_ALCCTRL1,
+                                            (ctrl1 & ~WM8776_LCSEL_MASK) |
+                                            WM8776_LCSEL_ALC_STEREO);
+                        wm8776_write_cached(chip, WM8776_ALCCTRL2,
+                                            ctrl2 | WM8776_LCEN);
+                        mode = LC_CONTROL_ALC;
+                        break;
+                }
+                for (i = 0; i < ARRAY_SIZE(data->lc_controls); ++i)
+                        activate_control(chip, data->lc_controls[i], mode);
+        }
+        mutex_unlock(&chip->mutex);
+        return changed;
+}
+
+static int hpf_info(struct snd_kcontrol *ctl, struct snd_ctl_elem_info *info)
+{
+        static const char *const names[2] = {
+                "None", "High-pass Filter"
+        };
+
+        info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        info->count = 1;
+        info->value.enumerated.items = 2;
+        if (info->value.enumerated.item >= 2)
+                info->value.enumerated.item = 1;
+        strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
+        return 0;
+}
+
+static int hpf_get(struct snd_kcontrol *ctl, struct snd_ctl_elem_value *value)
+{
+        struct oxygen *chip = ctl->private_data;
+        struct xonar_wm87x6 *data = chip->model_data;
+
+        value->value.enumerated.item[0] =
+                !(data->wm8776_regs[WM8776_ADCIFCTRL] & WM8776_ADCHPD);
+        return 0;
+}
+
+static int hpf_put(struct snd_kcontrol *ctl, struct snd_ctl_elem_value *value)
+{
+        struct oxygen *chip = ctl->private_data;
+        struct xonar_wm87x6 *data = chip->model_data;
+        unsigned int reg;
+        int changed;
+
+        mutex_lock(&chip->mutex);
+        reg = data->wm8776_regs[WM8776_ADCIFCTRL] & ~WM8776_ADCHPD;
+        if (!value->value.enumerated.item[0])
+                reg |= WM8776_ADCHPD;
+        changed = reg != data->wm8776_regs[WM8776_ADCIFCTRL];
+        if (changed)
+                wm8776_write(chip, WM8776_ADCIFCTRL, reg);
+        mutex_unlock(&chip->mutex);
+        return changed;
+}
+
+#define WM8776_BIT_SWITCH(xname, reg, bit, invert, flags) { \
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
+        .name = xname, \
+        .info = snd_ctl_boolean_mono_info, \
+        .get = wm8776_bit_switch_get, \
+        .put = wm8776_bit_switch_put, \
+        .private_value = ((reg) << 16) | (bit) | ((invert) << 24) | (flags), \
+}
+#define _WM8776_FIELD_CTL(xname, reg, shift, initval, min, max, mask, flags) \
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
+        .name = xname, \
+        .private_value = (initval) | ((min) << 8) | ((max) << 12) | \
+        ((mask) << 16) | ((shift) << 20) | ((reg) << 24) | (flags)
+#define WM8776_FIELD_CTL_ENUM(xname, reg, shift, init, min, max, mask, flags) {\
+        _WM8776_FIELD_CTL(xname " Capture Enum", \
+                          reg, shift, init, min, max, mask, flags), \
+        .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
+                  SNDRV_CTL_ELEM_ACCESS_INACTIVE, \
+        .info = wm8776_field_enum_info, \
+        .get = wm8776_field_enum_get, \
+        .put = wm8776_field_enum_put, \
+}
+#define WM8776_FIELD_CTL_VOLUME(a, b, c, d, e, f, g, h, tlv_p) { \
+        _WM8776_FIELD_CTL(a " Capture Volume", b, c, d, e, f, g, h), \
+        .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
+                  SNDRV_CTL_ELEM_ACCESS_INACTIVE | \
+                  SNDRV_CTL_ELEM_ACCESS_TLV_READ, \
+        .info = wm8776_field_volume_info, \
+        .get = wm8776_field_volume_get, \
+        .put = wm8776_field_volume_put, \
+        .tlv = { .p = tlv_p }, \
+}
+
+static const DECLARE_TLV_DB_SCALE(wm87x6_dac_db_scale, -6000, 50, 0);
+static const DECLARE_TLV_DB_SCALE(wm8776_adc_db_scale, -2100, 50, 0);
+static const DECLARE_TLV_DB_SCALE(wm8776_hp_db_scale, -6000, 100, 0);
+static const DECLARE_TLV_DB_SCALE(wm8776_lct_db_scale, -1600, 100, 0);
+static const DECLARE_TLV_DB_SCALE(wm8776_maxgain_db_scale, 0, 400, 0);
+static const DECLARE_TLV_DB_SCALE(wm8776_ngth_db_scale, -7800, 600, 0);
+static const DECLARE_TLV_DB_SCALE(wm8776_maxatten_lim_db_scale, -1200, 100, 0);
+static const DECLARE_TLV_DB_SCALE(wm8776_maxatten_alc_db_scale, -2100, 400, 0);
+
+static const struct snd_kcontrol_new ds_controls[] = {
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Headphone Playback Volume",
+                .info = wm8776_hp_vol_info,
+                .get = wm8776_hp_vol_get,
+                .put = wm8776_hp_vol_put,
+                .tlv = { .p = wm8776_hp_db_scale },
+        },
+        WM8776_BIT_SWITCH("Headphone Playback Switch",
+                          WM8776_PWRDOWN, WM8776_HPPD, 1, 0),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Input Capture Volume",
+                .info = wm8776_input_vol_info,
+                .get = wm8776_input_vol_get,
+                .put = wm8776_input_vol_put,
+                .tlv = { .p = wm8776_adc_db_scale },
+        },
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Line Capture Switch",
+                .info = snd_ctl_boolean_mono_info,
+                .get = wm8776_input_mux_get,
+                .put = wm8776_input_mux_put,
+                .private_value = 1 << 0,
+        },
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Mic Capture Switch",
+                .info = snd_ctl_boolean_mono_info,
+                .get = wm8776_input_mux_get,
+                .put = wm8776_input_mux_put,
+                .private_value = 1 << 1,
+        },
+        WM8776_BIT_SWITCH("Aux", WM8776_ADCMUX, 1 << 2, 0, 0),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "ADC Filter Capture Enum",
+                .info = hpf_info,
+                .get = hpf_get,
+                .put = hpf_put,
+        },
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Level Control Capture Enum",
+                .info = wm8776_level_control_info,
+                .get = wm8776_level_control_get,
+                .put = wm8776_level_control_put,
+                .private_value = 0,
+        },
+};
+static const struct snd_kcontrol_new lc_controls[] = {
+        WM8776_FIELD_CTL_VOLUME("Limiter Threshold",
+                                WM8776_ALCCTRL1, 0, 11, 0, 15, 0xf,
+                                LC_CONTROL_LIMITER, wm8776_lct_db_scale),
+        WM8776_FIELD_CTL_ENUM("Limiter Attack Time",
+                              WM8776_ALCCTRL3, 0, 2, 0, 10, 0xf,
+                              LC_CONTROL_LIMITER),
+        WM8776_FIELD_CTL_ENUM("Limiter Decay Time",
+                              WM8776_ALCCTRL3, 4, 3, 0, 10, 0xf,
+                              LC_CONTROL_LIMITER),
+        WM8776_FIELD_CTL_ENUM("Limiter Transient Window",
+                              WM8776_LIMITER, 4, 2, 0, 7, 0x7,
+                              LC_CONTROL_LIMITER),
+        WM8776_FIELD_CTL_VOLUME("Limiter Maximum Attenuation",
+                                WM8776_LIMITER, 0, 6, 3, 12, 0xf,
+                                LC_CONTROL_LIMITER,
+                                wm8776_maxatten_lim_db_scale),
+        WM8776_FIELD_CTL_VOLUME("ALC Target Level",
+                                WM8776_ALCCTRL1, 0, 11, 0, 15, 0xf,
+                                LC_CONTROL_ALC, wm8776_lct_db_scale),
+        WM8776_FIELD_CTL_ENUM("ALC Attack Time",
+                              WM8776_ALCCTRL3, 0, 2, 0, 10, 0xf,
+                              LC_CONTROL_ALC),
+        WM8776_FIELD_CTL_ENUM("ALC Decay Time",
+                              WM8776_ALCCTRL3, 4, 3, 0, 10, 0xf,
+                              LC_CONTROL_ALC),
+        WM8776_FIELD_CTL_VOLUME("ALC Maximum Gain",
+                                WM8776_ALCCTRL1, 4, 7, 1, 7, 0x7,
+                                LC_CONTROL_ALC, wm8776_maxgain_db_scale),
+        WM8776_FIELD_CTL_VOLUME("ALC Maximum Attenuation",
+                                WM8776_LIMITER, 0, 10, 10, 15, 0xf,
+                                LC_CONTROL_ALC, wm8776_maxatten_alc_db_scale),
+        WM8776_FIELD_CTL_ENUM("ALC Hold Time",
+                              WM8776_ALCCTRL2, 0, 0, 0, 15, 0xf,
+                              LC_CONTROL_ALC),
+        WM8776_BIT_SWITCH("Noise Gate Capture Switch",
+                          WM8776_NOISEGATE, WM8776_NGAT, 0,
+                          LC_CONTROL_ALC),
+        WM8776_FIELD_CTL_VOLUME("Noise Gate Threshold",
+                                WM8776_NOISEGATE, 2, 0, 0, 7, 0x7,
+                                LC_CONTROL_ALC, wm8776_ngth_db_scale),
+};
+
+static int xonar_ds_control_filter(struct snd_kcontrol_new *template)
+{
+        if (!strncmp(template->name, "CD Capture ", 11))
+                return 1; /* no CD input */
+        return 0;
+}
+
+static int xonar_ds_mixer_init(struct oxygen *chip)
+{
+        struct xonar_wm87x6 *data = chip->model_data;
+        unsigned int i;
+        struct snd_kcontrol *ctl;
+        int err;
+
+        for (i = 0; i < ARRAY_SIZE(ds_controls); ++i) {
+                ctl = snd_ctl_new1(&ds_controls[i], chip);
+                if (!ctl)
+                        return -ENOMEM;
+                err = snd_ctl_add(chip->card, ctl);
+                if (err < 0)
+                        return err;
+        }
+        BUILD_BUG_ON(ARRAY_SIZE(lc_controls) != ARRAY_SIZE(data->lc_controls));
+        for (i = 0; i < ARRAY_SIZE(lc_controls); ++i) {
+                ctl = snd_ctl_new1(&lc_controls[i], chip);
+                if (!ctl)
+                        return -ENOMEM;
+                err = snd_ctl_add(chip->card, ctl);
+                if (err < 0)
+                        return err;
+                data->lc_controls[i] = ctl;
+        }
+        return 0;
+}
+
+static const struct oxygen_model model_xonar_ds = {
+        .shortname = "Xonar DS",
+        .longname = "Asus Virtuoso 200",
+        .chip = "AV200",
+        .init = xonar_ds_init,
+        .control_filter = xonar_ds_control_filter,
+        .mixer_init = xonar_ds_mixer_init,
+        .cleanup = xonar_ds_cleanup,
+        .suspend = xonar_ds_suspend,
+        .resume = xonar_ds_resume,
+        .pcm_hardware_filter = wm8776_adc_hardware_filter,
+        .get_i2s_mclk = oxygen_default_i2s_mclk,
+        .set_dac_params = set_wm87x6_dac_params,
+        .set_adc_params = set_wm8776_adc_params,
+        .update_dac_volume = update_wm87x6_volume,
+        .update_dac_mute = update_wm87x6_mute,
+        .gpio_changed = xonar_ds_gpio_changed,
+        .dac_tlv = wm87x6_dac_db_scale,
+        .model_data_size = sizeof(struct xonar_wm87x6),
+        .device_config = PLAYBACK_0_TO_I2S |
+                         PLAYBACK_1_TO_SPDIF |
+                         CAPTURE_0_FROM_I2S_1,
+        .dac_channels = 8,
+        .dac_volume_min = 255 - 2*60,
+        .dac_volume_max = 255,
+        .function_flags = OXYGEN_FUNCTION_SPI,
+        .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
+        .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
+};
+
+int __devinit get_xonar_wm87x6_model(struct oxygen *chip,
+                                     const struct pci_device_id *id)
+{
+        switch (id->subdevice) {
+        case 0x838e:
+                chip->model = model_xonar_ds;
+                break;
+        default:
+                return -EINVAL;
+        }
+        return 0;
+}
diff --git a/sound/pci/pcxhr/pcxhr.c b/sound/pci/pcxhr/pcxhr.c
index 833e9c7b27c7..95cfde27d25c 100644
--- a/sound/pci/pcxhr/pcxhr.c
+++ b/sound/pci/pcxhr/pcxhr.c
@@ -94,7 +94,7 @@ enum {
         PCI_ID_LAST
 };
 
-static struct pci_device_id pcxhr_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(pcxhr_ids) = {
         { 0x10b5, 0x9656, 0x1369, 0xb001, 0, 0, PCI_ID_VX882HR, },
         { 0x10b5, 0x9656, 0x1369, 0xb101, 0, 0, PCI_ID_PCX882HR, },
         { 0x10b5, 0x9656, 0x1369, 0xb201, 0, 0, PCI_ID_VX881HR, },
diff --git a/sound/pci/riptide/riptide.c b/sound/pci/riptide/riptide.c
index b5ca02e2038c..ad4462677615 100644
--- a/sound/pci/riptide/riptide.c
+++ b/sound/pci/riptide/riptide.c
@@ -506,7 +506,7 @@ static int riptide_reset(struct cmdif *cif, struct snd_riptide *chip);
 /*
  */
 
-static struct pci_device_id snd_riptide_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_riptide_ids) = {
         { PCI_DEVICE(0x127a, 0x4310) },
         { PCI_DEVICE(0x127a, 0x4320) },
         { PCI_DEVICE(0x127a, 0x4330) },
@@ -515,7 +515,7 @@ static struct pci_device_id snd_riptide_ids[] = {
 };
 
 #ifdef SUPPORT_JOYSTICK
-static struct pci_device_id snd_riptide_joystick_ids[] __devinitdata = {
+static DEFINE_PCI_DEVICE_TABLE(snd_riptide_joystick_ids) = {
         { PCI_DEVICE(0x127a, 0x4312) },
         { PCI_DEVICE(0x127a, 0x4322) },
         { PCI_DEVICE(0x127a, 0x4332) },
@@ -1058,7 +1058,7 @@ setsamplerate(struct cmdif *cif, unsigned char *intdec, unsigned int rate)
                                  rptr.retwords[2] != M &&
                                  rptr.retwords[3] != N &&
                                  i++ < MAX_WRITE_RETRY);
-                        if (i == MAX_WRITE_RETRY) {
+                        if (i > MAX_WRITE_RETRY) {
                                 snd_printdd("sent samplerate %d: %d failed\n",
                                             *intdec, rate);
                                 return -EIO;
@@ -1974,9 +1974,9 @@ snd_riptide_proc_read(struct snd_info_entry *entry,
         }
         snd_iprintf(buffer, "Paths:\n");
         i = getpaths(cif, p);
-        while (i--) {
-                snd_iprintf(buffer, "%x->%x ", p[i - 1], p[i]);
-                i--;
+        while (i >= 2) {
+                i -= 2;
+                snd_iprintf(buffer, "%x->%x ", p[i], p[i + 1]);
         }
         snd_iprintf(buffer, "\n");
 }
diff --git a/sound/pci/rme32.c b/sound/pci/rme32.c
index f977dba7cbd0..3c04524de37c 100644
--- a/sound/pci/rme32.c
+++ b/sound/pci/rme32.c
@@ -70,10 +70,10 @@
 
 
 #include <linux/delay.h>
+#include <linux/gfp.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/pci.h>
-#include <linux/slab.h>
 #include <linux/moduleparam.h>
 
 #include <sound/core.h>
@@ -226,7 +226,7 @@ struct rme32 {
         struct snd_kcontrol *spdif_ctl;
 };
 
-static struct pci_device_id snd_rme32_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_rme32_ids) = {
         {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,},
diff --git a/sound/pci/rme96.c b/sound/pci/rme96.c
index 2ba5c0fd55db..d19dc052c391 100644
--- a/sound/pci/rme96.c
+++ b/sound/pci/rme96.c
@@ -27,7 +27,6 @@
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/pci.h>
-#include <linux/slab.h>
 #include <linux/moduleparam.h>
 
 #include <sound/core.h>
@@ -231,7 +230,7 @@ struct rme96 {
         struct snd_kcontrol   *spdif_ctl;
 };
 
-static struct pci_device_id snd_rme96_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_rme96_ids) = {
         { 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, },
diff --git a/sound/pci/rme9652/hdsp.c b/sound/pci/rme9652/hdsp.c
index 7bb827c7d806..b92adef8e81e 100644
--- a/sound/pci/rme9652/hdsp.c
+++ b/sound/pci/rme9652/hdsp.c
@@ -24,7 +24,6 @@
 #include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
-#include <linux/slab.h>
 #include <linux/pci.h>
 #include <linux/firmware.h>
 #include <linux/moduleparam.h>
@@ -585,7 +584,7 @@ static void snd_hammerfall_free_buffer(struct snd_dma_buffer *dmab, struct pci_d
 }
 
 
-static struct pci_device_id snd_hdsp_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_hdsp_ids) = {
         {
                 .vendor = PCI_VENDOR_ID_XILINX,
                 .device = PCI_DEVICE_ID_XILINX_HAMMERFALL_DSP,
diff --git a/sound/pci/rme9652/hdspm.c b/sound/pci/rme9652/hdspm.c
index 0dce331a2a3b..547b713d7204 100644
--- a/sound/pci/rme9652/hdspm.c
+++ b/sound/pci/rme9652/hdspm.c
@@ -512,7 +512,7 @@ static char channel_map_madi_ss[HDSPM_MAX_CHANNELS] = {
 };
 
 
-static struct pci_device_id snd_hdspm_ids[] __devinitdata = {
+static DEFINE_PCI_DEVICE_TABLE(snd_hdspm_ids) = {
         {
          .vendor = PCI_VENDOR_ID_XILINX,
          .device = PCI_DEVICE_ID_XILINX_HAMMERFALL_DSP_MADI,
@@ -2479,7 +2479,7 @@ static int snd_hdspm_put_qs_wire(struct snd_kcontrol *kcontrol,
    on MADICARD 
   - playback mixer matrix: [channelout+64] [output] [value]
   - input(thru) mixer matrix: [channelin] [output] [value]
-  (better do 2 kontrols for seperation ?)
+  (better do 2 kontrols for separation ?)
 */
 
 #define HDSPM_MIXER(xname, xindex) \
@@ -3017,7 +3017,7 @@ snd_hdspm_proc_read_madi(struct snd_info_entry * entry,
                 insel = "Coaxial";
                 break;
         default:
-                insel = "Unkown";
+                insel = "Unknown";
         }
 
         switch (hdspm->control_register & HDSPM_SyncRefMask) {
@@ -3028,7 +3028,7 @@ snd_hdspm_proc_read_madi(struct snd_info_entry * entry,
                 syncref = "MADI";
                 break;
         default:
-                syncref = "Unkown";
+                syncref = "Unknown";
         }
         snd_iprintf(buffer, "Inputsel = %s, SyncRef = %s\n", insel,
                     syncref);
diff --git a/sound/pci/rme9652/rme9652.c b/sound/pci/rme9652/rme9652.c
index bc539abb2105..c492af5b25f3 100644
--- a/sound/pci/rme9652/rme9652.c
+++ b/sound/pci/rme9652/rme9652.c
@@ -24,7 +24,6 @@
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/pci.h>
-#include <linux/slab.h>
 #include <linux/moduleparam.h>
 
 #include <sound/core.h>
@@ -314,7 +313,7 @@ static void snd_hammerfall_free_buffer(struct snd_dma_buffer *dmab, struct pci_d
 }
 
 
-static struct pci_device_id snd_rme9652_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_rme9652_ids) = {
         {
                 .vendor    = 0x10ee,
                 .device    = 0x3fc4,
diff --git a/sound/pci/sis7019.c b/sound/pci/sis7019.c
index 1a5ff0611072..9cc1b5aa0148 100644
--- a/sound/pci/sis7019.c
+++ b/sound/pci/sis7019.c
@@ -24,6 +24,7 @@
 #include <linux/init.h>
 #include <linux/pci.h>
 #include <linux/time.h>
+#include <linux/slab.h>
 #include <linux/moduleparam.h>
 #include <linux/interrupt.h>
 #include <linux/delay.h>
@@ -48,7 +49,7 @@ MODULE_PARM_DESC(id, "ID string for SiS7019 Audio Accelerator.");
 module_param(enable, bool, 0444);
 MODULE_PARM_DESC(enable, "Enable SiS7019 Audio Accelerator.");
 
-static struct pci_device_id snd_sis7019_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_sis7019_ids) = {
         { PCI_DEVICE(PCI_VENDOR_ID_SI, 0x7019) },
         { 0, }
 };
diff --git a/sound/pci/sonicvibes.c b/sound/pci/sonicvibes.c
index 1f6406c4534d..337b9facadfd 100644
--- a/sound/pci/sonicvibes.c
+++ b/sound/pci/sonicvibes.c
@@ -242,7 +242,7 @@ struct sonicvibes {
 #endif
 };
 
-static struct pci_device_id snd_sonic_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_sonic_ids) = {
         { PCI_VDEVICE(S3, 0xca00), 0, },
         { 0, }
 };
diff --git a/sound/pci/trident/trident.c b/sound/pci/trident/trident.c
index 21cef97d478d..6d0581841d7a 100644
--- a/sound/pci/trident/trident.c
+++ b/sound/pci/trident/trident.c
@@ -62,7 +62,7 @@ MODULE_PARM_DESC(pcm_channels, "Number of hardware channels assigned for PCM.");
 module_param_array(wavetable_size, int, NULL, 0444);
 MODULE_PARM_DESC(wavetable_size, "Maximum memory size in kB for wavetable synth.");
 
-static struct pci_device_id snd_trident_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_trident_ids) = {
         {PCI_DEVICE(PCI_VENDOR_ID_TRIDENT, PCI_DEVICE_ID_TRIDENT_4DWAVE_DX), 
                 PCI_CLASS_MULTIMEDIA_AUDIO << 8, 0xffff00, 0},
         {PCI_DEVICE(PCI_VENDOR_ID_TRIDENT, PCI_DEVICE_ID_TRIDENT_4DWAVE_NX), 
diff --git a/sound/pci/via82xx.c b/sound/pci/via82xx.c
index 8a332d2f615c..7e494b6a1d0e 100644
--- a/sound/pci/via82xx.c
+++ b/sound/pci/via82xx.c
@@ -401,7 +401,7 @@ struct via82xx {
 #endif
 };
 
-static struct pci_device_id snd_via82xx_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_via82xx_ids) = {
         /* 0x1106, 0x3058 */
         { PCI_VDEVICE(VIA, PCI_DEVICE_ID_VIA_82C686_5), TYPE_CARD_VIA686, },    /* 686A */
         /* 0x1106, 0x3059 */
@@ -1791,6 +1791,12 @@ static struct ac97_quirk ac97_quirks[] = {
                 .type = AC97_TUNE_HP_ONLY
         },
         {
+                .subvendor = 0x110a,
+                .subdevice = 0x0079,
+                .name = "Fujitsu Siemens D1289",
+                .type = AC97_TUNE_HP_ONLY
+        },
+        {
                 .subvendor = 0x1019,
                 .subdevice = 0x0a81,
                 .name = "ECS K7VTA3",
diff --git a/sound/pci/via82xx_modem.c b/sound/pci/via82xx_modem.c
index 47eb61561dfc..f7e8bbbe3953 100644
--- a/sound/pci/via82xx_modem.c
+++ b/sound/pci/via82xx_modem.c
@@ -260,7 +260,7 @@ struct via82xx_modem {
         struct snd_info_entry *proc_entry;
 };
 
-static struct pci_device_id snd_via82xx_modem_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_via82xx_modem_ids) = {
         { PCI_VDEVICE(VIA, 0x3068), TYPE_CARD_VIA82XX_MODEM, },
         { 0, }
 };
diff --git a/sound/pci/vx222/vx222.c b/sound/pci/vx222/vx222.c
index fc9136c3e0d7..99a9a814be0b 100644
--- a/sound/pci/vx222/vx222.c
+++ b/sound/pci/vx222/vx222.c
@@ -60,7 +60,7 @@ enum {
         VX_PCI_VX222_NEW
 };
 
-static struct pci_device_id snd_vx222_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_vx222_ids) = {
         { 0x10b5, 0x9050, 0x1369, PCI_ANY_ID, 0, 0, VX_PCI_VX222_OLD, },   /* PLX */
         { 0x10b5, 0x9030, 0x1369, PCI_ANY_ID, 0, 0, VX_PCI_VX222_NEW, },   /* PLX */
         { 0, }
diff --git a/sound/pci/ymfpci/ymfpci.c b/sound/pci/ymfpci/ymfpci.c
index e6b18b90d451..80c682113381 100644
--- a/sound/pci/ymfpci/ymfpci.c
+++ b/sound/pci/ymfpci/ymfpci.c
@@ -66,7 +66,7 @@ MODULE_PARM_DESC(joystick_port, "Joystick port address");
 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[] = {
+static DEFINE_PCI_DEVICE_TABLE(snd_ymfpci_ids) = {
         { PCI_VDEVICE(YAMAHA, 0x0004), 0, },   /* YMF724 */
         { PCI_VDEVICE(YAMAHA, 0x000d), 0, },   /* YMF724F */
         { PCI_VDEVICE(YAMAHA, 0x000a), 0, },   /* YMF740 */
diff --git a/sound/pcmcia/pdaudiocf/pdaudiocf.c b/sound/pcmcia/pdaudiocf/pdaudiocf.c
index 64b859925c0b..edaa729126bb 100644
--- a/sound/pcmcia/pdaudiocf/pdaudiocf.c
+++ b/sound/pcmcia/pdaudiocf/pdaudiocf.c
@@ -131,7 +131,7 @@ static int snd_pdacf_probe(struct pcmcia_device *link)
                 return err;
         }
 
-        snd_card_set_dev(card, &handle_to_dev(link));
+        snd_card_set_dev(card, &link->dev);
 
         pdacf->index = i;
         card_list[i] = card;
@@ -142,12 +142,11 @@ static int snd_pdacf_probe(struct pcmcia_device *link)
         link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
         link->io.NumPorts1 = 16;
 
-        link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT | IRQ_FORCED_PULSE;
-        // link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING|IRQ_FIRST_SHARED;
+        link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_FORCED_PULSE;
+        /* FIXME: This driver should be updated to allow for dynamic IRQ sharing */
+        /* link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING | IRQ_FORCED_PULSE; */
 
-        link->irq.IRQInfo1 = 0 /* | IRQ_LEVEL_ID */;
         link->irq.Handler = pdacf_interrupt;
-        link->irq.Instance = pdacf;
         link->conf.Attributes = CONF_ENABLE_IRQ;
         link->conf.IntType = INT_MEMORY_AND_IO;
         link->conf.ConfigIndex = 1;
diff --git a/sound/pcmcia/pdaudiocf/pdaudiocf_core.c b/sound/pcmcia/pdaudiocf/pdaudiocf_core.c
index 5d2afa0b0ce4..9dce0bde5c05 100644
--- a/sound/pcmcia/pdaudiocf/pdaudiocf_core.c
+++ b/sound/pcmcia/pdaudiocf/pdaudiocf_core.c
@@ -19,6 +19,7 @@
  */
 
 #include <linux/delay.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include "pdaudiocf.h"
diff --git a/sound/pcmcia/pdaudiocf/pdaudiocf_pcm.c b/sound/pcmcia/pdaudiocf/pdaudiocf_pcm.c
index d057e6489643..43f995a3f960 100644
--- a/sound/pcmcia/pdaudiocf/pdaudiocf_pcm.c
+++ b/sound/pcmcia/pdaudiocf/pdaudiocf_pcm.c
@@ -20,8 +20,6 @@
  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  */
 
-#include <linux/slab.h>
-#include <linux/vmalloc.h>
 #include <linux/delay.h>
 #include <sound/core.h>
 #include <sound/asoundef.h>
@@ -29,49 +27,6 @@
 
 
 /*
- * we use a vmalloc'ed (sg-)buffer
- */
-
-/* get the physical page pointer on the given offset */
-static struct page *snd_pcm_get_vmalloc_page(struct snd_pcm_substream *subs, unsigned long offset)
-{
-        void *pageptr = subs->runtime->dma_area + offset;
-        return vmalloc_to_page(pageptr);
-}
-
-/*
- * hw_params callback
- * NOTE: this may be called not only once per pcm open!
- */
-static int snd_pcm_alloc_vmalloc_buffer(struct snd_pcm_substream *subs, size_t size)
-{
-        struct snd_pcm_runtime *runtime = subs->runtime;
-        if (runtime->dma_area) {
-                if (runtime->dma_bytes >= size)
-                        return 0; /* already enough large */
-                vfree(runtime->dma_area);
-        }
-        runtime->dma_area = vmalloc_32(size);
-        if (! runtime->dma_area)
-                return -ENOMEM;
-        runtime->dma_bytes = size;
-        return 0;
-}
-
-/*
- * hw_free callback
- * NOTE: this may be called not only once per pcm open!
- */
-static int snd_pcm_free_vmalloc_buffer(struct snd_pcm_substream *subs)
-{
-        struct snd_pcm_runtime *runtime = subs->runtime;
-
-        vfree(runtime->dma_area);
-        runtime->dma_area = NULL;
-        return 0;
-}
-
-/*
  * clear the SRAM contents
  */
 static int pdacf_pcm_clear_sram(struct snd_pdacf *chip)
@@ -147,7 +102,8 @@ static int pdacf_pcm_trigger(struct snd_pcm_substream *subs, int cmd)
 static int pdacf_pcm_hw_params(struct snd_pcm_substream *subs,
                                      struct snd_pcm_hw_params *hw_params)
 {
-        return snd_pcm_alloc_vmalloc_buffer(subs, params_buffer_bytes(hw_params));
+        return snd_pcm_lib_alloc_vmalloc_32_buffer
+                                        (subs, params_buffer_bytes(hw_params));
 }
 
 /*
@@ -155,7 +111,7 @@ static int pdacf_pcm_hw_params(struct snd_pcm_substream *subs,
  */
 static int pdacf_pcm_hw_free(struct snd_pcm_substream *subs)
 {
-        return snd_pcm_free_vmalloc_buffer(subs);
+        return snd_pcm_lib_free_vmalloc_buffer(subs);
 }
 
 /*
@@ -319,7 +275,8 @@ static struct snd_pcm_ops pdacf_pcm_capture_ops = {
         .prepare =      pdacf_pcm_prepare,
         .trigger =      pdacf_pcm_trigger,
         .pointer =      pdacf_pcm_capture_pointer,
-        .page =         snd_pcm_get_vmalloc_page,
+        .page =         snd_pcm_lib_get_vmalloc_page,
+        .mmap =         snd_pcm_lib_mmap_vmalloc,
 };
 
 
diff --git a/sound/pcmcia/vx/vxpocket.c b/sound/pcmcia/vx/vxpocket.c
index 1492744ad67f..cfd1438bcc64 100644
--- a/sound/pcmcia/vx/vxpocket.c
+++ b/sound/pcmcia/vx/vxpocket.c
@@ -21,6 +21,7 @@
 
 #include <linux/init.h>
 #include <linux/moduleparam.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include "vxpocket.h"
 #include <pcmcia/ciscode.h>
@@ -161,11 +162,9 @@ static int snd_vxpocket_new(struct snd_card *card, int ibl,
         link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
         link->io.NumPorts1 = 16;
 
-        link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
+        link->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
 
-        link->irq.IRQInfo1 = IRQ_LEVEL_ID;
         link->irq.Handler = &snd_vx_irq_handler;
-        link->irq.Instance = chip;
 
         link->conf.Attributes = CONF_ENABLE_IRQ;
         link->conf.IntType = INT_MEMORY_AND_IO;
@@ -244,7 +243,7 @@ static int vxpocket_config(struct pcmcia_device *link)
         if (ret)
                 goto failed;
 
-        chip->dev = &handle_to_dev(link);
+        chip->dev = &link->dev;
         snd_card_set_dev(chip->card, chip->dev);
 
         if (snd_vxpocket_assign_resources(chip, link->io.BasePort1, link->irq.AssignedIRQ) < 0)
diff --git a/sound/ppc/awacs.c b/sound/ppc/awacs.c
index 2cc0eda4f20e..b36679384b27 100644
--- a/sound/ppc/awacs.c
+++ b/sound/ppc/awacs.c
@@ -479,7 +479,7 @@ static int snd_pmac_awacs_put_master_amp(struct snd_kcontrol *kcontrol,
 
 static struct snd_kcontrol_new snd_pmac_awacs_amp_vol[] __devinitdata = {
         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-          .name = "PC Speaker Playback Volume",
+          .name = "Speaker Playback Volume",
           .info = snd_pmac_awacs_info_volume_amp,
           .get = snd_pmac_awacs_get_volume_amp,
           .put = snd_pmac_awacs_put_volume_amp,
@@ -525,7 +525,7 @@ static struct snd_kcontrol_new snd_pmac_awacs_amp_hp_sw __devinitdata = {
 
 static struct snd_kcontrol_new snd_pmac_awacs_amp_spk_sw __devinitdata = {
         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "PC Speaker Playback Switch",
+        .name = "Speaker Playback Switch",
         .info = snd_pmac_boolean_stereo_info,
         .get = snd_pmac_awacs_get_switch_amp,
         .put = snd_pmac_awacs_put_switch_amp,
@@ -696,17 +696,17 @@ static struct snd_kcontrol_new snd_pmac_screamer_mic_boost_imac[] __devinitdata
 };
 
 static struct snd_kcontrol_new snd_pmac_awacs_speaker_vol[] __devinitdata = {
-        AWACS_VOLUME("PC Speaker Playback Volume", 4, 6, 1),
+        AWACS_VOLUME("Speaker Playback Volume", 4, 6, 1),
 };
 
 static struct snd_kcontrol_new snd_pmac_awacs_speaker_sw __devinitdata =
-AWACS_SWITCH("PC Speaker Playback Switch", 1, SHIFT_SPKMUTE, 1);
+AWACS_SWITCH("Speaker Playback Switch", 1, SHIFT_SPKMUTE, 1);
 
 static struct snd_kcontrol_new snd_pmac_awacs_speaker_sw_imac1 __devinitdata =
-AWACS_SWITCH("PC Speaker Playback Switch", 1, SHIFT_PAROUT1, 1);
+AWACS_SWITCH("Speaker Playback Switch", 1, SHIFT_PAROUT1, 1);
 
 static struct snd_kcontrol_new snd_pmac_awacs_speaker_sw_imac2 __devinitdata =
-AWACS_SWITCH("PC Speaker Playback Switch", 1, SHIFT_PAROUT1, 0);
+AWACS_SWITCH("Speaker Playback Switch", 1, SHIFT_PAROUT1, 0);
 
 
 /*
@@ -751,8 +751,8 @@ static void snd_pmac_awacs_suspend(struct snd_pmac *chip)
 
 static void snd_pmac_awacs_resume(struct snd_pmac *chip)
 {
-        if (machine_is_compatible("PowerBook3,1")
-            || machine_is_compatible("PowerBook3,2")) {
+        if (of_machine_is_compatible("PowerBook3,1")
+            || of_machine_is_compatible("PowerBook3,2")) {
                 msleep(100);
                 snd_pmac_awacs_write_reg(chip, 1,
                         chip->awacs_reg[1] & ~MASK_PAROUT);
@@ -780,16 +780,16 @@ static void snd_pmac_awacs_resume(struct snd_pmac *chip)
 }
 #endif /* CONFIG_PM */
 
-#define IS_PM7500 (machine_is_compatible("AAPL,7500") \
-                || machine_is_compatible("AAPL,8500") \
-                || machine_is_compatible("AAPL,9500"))
-#define IS_PM5500 (machine_is_compatible("AAPL,e411"))
-#define IS_BEIGE (machine_is_compatible("AAPL,Gossamer"))
-#define IS_IMAC1 (machine_is_compatible("PowerMac2,1"))
-#define IS_IMAC2 (machine_is_compatible("PowerMac2,2") \
-                || machine_is_compatible("PowerMac4,1"))
-#define IS_G4AGP (machine_is_compatible("PowerMac3,1"))
-#define IS_LOMBARD (machine_is_compatible("PowerBook1,1"))
+#define IS_PM7500 (of_machine_is_compatible("AAPL,7500") \
+                || of_machine_is_compatible("AAPL,8500") \
+                || of_machine_is_compatible("AAPL,9500"))
+#define IS_PM5500 (of_machine_is_compatible("AAPL,e411"))
+#define IS_BEIGE (of_machine_is_compatible("AAPL,Gossamer"))
+#define IS_IMAC1 (of_machine_is_compatible("PowerMac2,1"))
+#define IS_IMAC2 (of_machine_is_compatible("PowerMac2,2") \
+                || of_machine_is_compatible("PowerMac4,1"))
+#define IS_G4AGP (of_machine_is_compatible("PowerMac3,1"))
+#define IS_LOMBARD (of_machine_is_compatible("PowerBook1,1"))
 
 static int imac1, imac2;
 
diff --git a/sound/ppc/burgundy.c b/sound/ppc/burgundy.c
index 16ed240e423c..00e2d5166d0a 100644
--- a/sound/ppc/burgundy.c
+++ b/sound/ppc/burgundy.c
@@ -21,7 +21,6 @@
 
 #include <asm/io.h>
 #include <linux/init.h>
-#include <linux/slab.h>
 #include <linux/delay.h>
 #include <sound/core.h>
 #include "pmac.h"
@@ -505,7 +504,7 @@ static struct snd_kcontrol_new snd_pmac_burgundy_mixers_imac[] __devinitdata = {
                         MASK_ADDR_BURGUNDY_GAINLINE, 1, 0),
         BURGUNDY_VOLUME_B("Mic Gain Capture Volume", 0,
                         MASK_ADDR_BURGUNDY_GAINMIC, 1, 0),
-        BURGUNDY_VOLUME_B("PC Speaker Playback Volume", 0,
+        BURGUNDY_VOLUME_B("Speaker Playback Volume", 0,
                         MASK_ADDR_BURGUNDY_ATTENSPEAKER, 1, 1),
         BURGUNDY_VOLUME_B("Line out Playback Volume", 0,
                         MASK_ADDR_BURGUNDY_ATTENLINEOUT, 1, 1),
@@ -527,7 +526,7 @@ static struct snd_kcontrol_new snd_pmac_burgundy_mixers_pmac[] __devinitdata = {
                         MASK_ADDR_BURGUNDY_VOLMIC, 16),
         BURGUNDY_VOLUME_B("Line in Gain Capture Volume", 0,
                         MASK_ADDR_BURGUNDY_GAINMIC, 1, 0),
-        BURGUNDY_VOLUME_B("PC Speaker Playback Volume", 0,
+        BURGUNDY_VOLUME_B("Speaker Playback Volume", 0,
                         MASK_ADDR_BURGUNDY_ATTENMONO, 0, 1),
         BURGUNDY_VOLUME_B("Line out Playback Volume", 0,
                         MASK_ADDR_BURGUNDY_ATTENSPEAKER, 1, 1),
@@ -549,11 +548,11 @@ BURGUNDY_SWITCH_B("Master Playback Switch", 0,
         BURGUNDY_OUTPUT_INTERN
         | BURGUNDY_OUTPUT_LEFT, BURGUNDY_OUTPUT_RIGHT, 1);
 static struct snd_kcontrol_new snd_pmac_burgundy_speaker_sw_imac __devinitdata =
-BURGUNDY_SWITCH_B("PC Speaker Playback Switch", 0,
+BURGUNDY_SWITCH_B("Speaker Playback Switch", 0,
         MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES,
         BURGUNDY_OUTPUT_LEFT, BURGUNDY_OUTPUT_RIGHT, 1);
 static struct snd_kcontrol_new snd_pmac_burgundy_speaker_sw_pmac __devinitdata =
-BURGUNDY_SWITCH_B("PC Speaker Playback Switch", 0,
+BURGUNDY_SWITCH_B("Speaker Playback Switch", 0,
         MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES,
         BURGUNDY_OUTPUT_INTERN, 0, 0);
 static struct snd_kcontrol_new snd_pmac_burgundy_line_sw_imac __devinitdata =
@@ -582,7 +581,7 @@ static int snd_pmac_burgundy_detect_headphone(struct snd_pmac *chip)
 static void snd_pmac_burgundy_update_automute(struct snd_pmac *chip, int do_notify)
 {
         if (chip->auto_mute) {
-                int imac = machine_is_compatible("iMac");
+                int imac = of_machine_is_compatible("iMac");
                 int reg, oreg;
                 reg = oreg = snd_pmac_burgundy_rcb(chip,
                                 MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES);
@@ -620,7 +619,7 @@ static void snd_pmac_burgundy_update_automute(struct snd_pmac *chip, int do_noti
  */
 int __devinit snd_pmac_burgundy_init(struct snd_pmac *chip)
 {
-        int imac = machine_is_compatible("iMac");
+        int imac = of_machine_is_compatible("iMac");
         int i, err;
 
         /* Checks to see the chip is alive and kicking */
diff --git a/sound/ppc/keywest.c b/sound/ppc/keywest.c
index d06f780bd7e8..8f064c7ce745 100644
--- a/sound/ppc/keywest.c
+++ b/sound/ppc/keywest.c
@@ -22,7 +22,6 @@
 #include <linux/init.h>
 #include <linux/i2c.h>
 #include <linux/delay.h>
-#include <linux/slab.h>
 #include <sound/core.h>
 #include "pmac.h"
 
diff --git a/sound/ppc/pmac.c b/sound/ppc/pmac.c
index 7bc492ee77ec..85081172403f 100644
--- a/sound/ppc/pmac.c
+++ b/sound/ppc/pmac.c
@@ -922,11 +922,11 @@ static void __devinit detect_byte_swap(struct snd_pmac *chip)
         }
 
         /* it seems the Pismo & iBook can't byte-swap in hardware. */
-        if (machine_is_compatible("PowerBook3,1") ||
-            machine_is_compatible("PowerBook2,1"))
+        if (of_machine_is_compatible("PowerBook3,1") ||
+            of_machine_is_compatible("PowerBook2,1"))
                 chip->can_byte_swap = 0 ;
 
-        if (machine_is_compatible("PowerBook2,1"))
+        if (of_machine_is_compatible("PowerBook2,1"))
                 chip->can_duplex = 0;
 }
 
@@ -959,11 +959,11 @@ static int __devinit snd_pmac_detect(struct snd_pmac *chip)
         chip->control_mask = MASK_IEPC | MASK_IEE | 0x11; /* default */
 
         /* check machine type */
-        if (machine_is_compatible("AAPL,3400/2400")
-            || machine_is_compatible("AAPL,3500"))
+        if (of_machine_is_compatible("AAPL,3400/2400")
+            || of_machine_is_compatible("AAPL,3500"))
                 chip->is_pbook_3400 = 1;
-        else if (machine_is_compatible("PowerBook1,1")
-                 || machine_is_compatible("AAPL,PowerBook1998"))
+        else if (of_machine_is_compatible("PowerBook1,1")
+                 || of_machine_is_compatible("AAPL,PowerBook1998"))
                 chip->is_pbook_G3 = 1;
         chip->node = of_find_node_by_name(NULL, "awacs");
         sound = of_node_get(chip->node);
@@ -1033,8 +1033,8 @@ static int __devinit snd_pmac_detect(struct snd_pmac *chip)
         }
         if (of_device_is_compatible(sound, "tumbler")) {
                 chip->model = PMAC_TUMBLER;
-                chip->can_capture = machine_is_compatible("PowerMac4,2")
-                                || machine_is_compatible("PowerBook4,1");
+                chip->can_capture = of_machine_is_compatible("PowerMac4,2")
+                                || of_machine_is_compatible("PowerBook4,1");
                 chip->can_duplex = 0;
                 // chip->can_byte_swap = 0; /* FIXME: check this */
                 chip->num_freqs = ARRAY_SIZE(tumbler_freqs);
diff --git a/sound/ppc/snd_ps3.c b/sound/ppc/snd_ps3.c
index 53c81a547613..2f12da4da561 100644
--- a/sound/ppc/snd_ps3.c
+++ b/sound/ppc/snd_ps3.c
@@ -20,10 +20,10 @@
 
 #include <linux/dma-mapping.h>
 #include <linux/dmapool.h>
+#include <linux/gfp.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/io.h>
-#include <linux/slab.h>
 
 #include <sound/asound.h>
 #include <sound/control.h>
diff --git a/sound/ppc/tumbler.c b/sound/ppc/tumbler.c
index 08e584d1453a..789f44f4ac78 100644
--- a/sound/ppc/tumbler.c
+++ b/sound/ppc/tumbler.c
@@ -905,7 +905,7 @@ static struct snd_kcontrol_new tumbler_hp_sw __devinitdata = {
 };
 static struct snd_kcontrol_new tumbler_speaker_sw __devinitdata = {
         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "PC Speaker Playback Switch",
+        .name = "Speaker Playback Switch",
         .info = snd_pmac_boolean_mono_info,
         .get = tumbler_get_mute_switch,
         .put = tumbler_put_mute_switch,
diff --git a/sound/sh/Kconfig b/sound/sh/Kconfig
index aed0f90c3919..61139f3c1614 100644
--- a/sound/sh/Kconfig
+++ b/sound/sh/Kconfig
@@ -19,5 +19,13 @@ config SND_AICA
         help
           ALSA Sound driver for the SEGA Dreamcast console.
 
+config SND_SH_DAC_AUDIO
+        tristate "SuperH DAC audio support"
+        depends on SND
+        depends on CPU_SH3 && HIGH_RES_TIMERS
+        select SND_PCM
+        help
+          Say Y here to include support for the on-chip DAC.
+
 endif   # SND_SUPERH
 
diff --git a/sound/sh/Makefile b/sound/sh/Makefile
index 8fdcb6e26f00..7d09b5188cf7 100644
--- a/sound/sh/Makefile
+++ b/sound/sh/Makefile
@@ -3,6 +3,8 @@
 #
 
 snd-aica-objs := aica.o
+snd-sh_dac_audio-objs := sh_dac_audio.o
 
 # Toplevel Module Dependency
 obj-$(CONFIG_SND_AICA) += snd-aica.o
+obj-$(CONFIG_SND_SH_DAC_AUDIO) += snd-sh_dac_audio.o
diff --git a/sound/sh/sh_dac_audio.c b/sound/sh/sh_dac_audio.c
new file mode 100644
index 000000000000..68e0dee4ff05
--- /dev/null
+++ b/sound/sh/sh_dac_audio.c
@@ -0,0 +1,454 @@
+/*
+ * sh_dac_audio.c - SuperH DAC audio driver for ALSA
+ *
+ * Copyright (c) 2009 by Rafael Ignacio Zurita <rizurita@yahoo.com>
+ *
+ *
+ * Based on sh_dac_audio.c (Copyright (C) 2004, 2005 by Andriy Skulysh)
+ *
+ *   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
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program 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/hrtimer.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <sound/core.h>
+#include <sound/initval.h>
+#include <sound/pcm.h>
+#include <sound/sh_dac_audio.h>
+#include <asm/clock.h>
+#include <asm/hd64461.h>
+#include <mach/hp6xx.h>
+#include <cpu/dac.h>
+
+MODULE_AUTHOR("Rafael Ignacio Zurita <rizurita@yahoo.com>");
+MODULE_DESCRIPTION("SuperH DAC audio driver");
+MODULE_LICENSE("GPL");
+MODULE_SUPPORTED_DEVICE("{{SuperH DAC audio support}}");
+
+/* Module Parameters */
+static int index = SNDRV_DEFAULT_IDX1;
+static char *id = SNDRV_DEFAULT_STR1;
+module_param(index, int, 0444);
+MODULE_PARM_DESC(index, "Index value for SuperH DAC audio.");
+module_param(id, charp, 0444);
+MODULE_PARM_DESC(id, "ID string for SuperH DAC audio.");
+
+/* main struct */
+struct snd_sh_dac {
+        struct snd_card *card;
+        struct snd_pcm_substream *substream;
+        struct hrtimer hrtimer;
+        ktime_t wakeups_per_second;
+
+        int rate;
+        int empty;
+        char *data_buffer, *buffer_begin, *buffer_end;
+        int processed; /* bytes proccesed, to compare with period_size */
+        int buffer_size;
+        struct dac_audio_pdata *pdata;
+};
+
+
+static void dac_audio_start_timer(struct snd_sh_dac *chip)
+{
+        hrtimer_start(&chip->hrtimer, chip->wakeups_per_second,
+                      HRTIMER_MODE_REL);
+}
+
+static void dac_audio_stop_timer(struct snd_sh_dac *chip)
+{
+        hrtimer_cancel(&chip->hrtimer);
+}
+
+static void dac_audio_reset(struct snd_sh_dac *chip)
+{
+        dac_audio_stop_timer(chip);
+        chip->buffer_begin = chip->buffer_end = chip->data_buffer;
+        chip->processed = 0;
+        chip->empty = 1;
+}
+
+static void dac_audio_set_rate(struct snd_sh_dac *chip)
+{
+        chip->wakeups_per_second = ktime_set(0, 1000000000 / chip->rate);
+}
+
+
+/* PCM INTERFACE */
+
+static struct snd_pcm_hardware snd_sh_dac_pcm_hw = {
+        .info                   = (SNDRV_PCM_INFO_MMAP |
+                                        SNDRV_PCM_INFO_MMAP_VALID |
+                                        SNDRV_PCM_INFO_INTERLEAVED |
+                                        SNDRV_PCM_INFO_HALF_DUPLEX),
+        .formats                = SNDRV_PCM_FMTBIT_U8,
+        .rates                  = SNDRV_PCM_RATE_8000,
+        .rate_min               = 8000,
+        .rate_max               = 8000,
+        .channels_min           = 1,
+        .channels_max           = 1,
+        .buffer_bytes_max       = (48*1024),
+        .period_bytes_min       = 1,
+        .period_bytes_max       = (48*1024),
+        .periods_min            = 1,
+        .periods_max            = 1024,
+};
+
+static int snd_sh_dac_pcm_open(struct snd_pcm_substream *substream)
+{
+        struct snd_sh_dac *chip = snd_pcm_substream_chip(substream);
+        struct snd_pcm_runtime *runtime = substream->runtime;
+
+        runtime->hw = snd_sh_dac_pcm_hw;
+
+        chip->substream = substream;
+        chip->buffer_begin = chip->buffer_end = chip->data_buffer;
+        chip->processed = 0;
+        chip->empty = 1;
+
+        chip->pdata->start(chip->pdata);
+
+        return 0;
+}
+
+static int snd_sh_dac_pcm_close(struct snd_pcm_substream *substream)
+{
+        struct snd_sh_dac *chip = snd_pcm_substream_chip(substream);
+
+        chip->substream = NULL;
+
+        dac_audio_stop_timer(chip);
+        chip->pdata->stop(chip->pdata);
+
+        return 0;
+}
+
+static int snd_sh_dac_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));
+}
+
+static int snd_sh_dac_pcm_hw_free(struct snd_pcm_substream *substream)
+{
+        return snd_pcm_lib_free_pages(substream);
+}
+
+static int snd_sh_dac_pcm_prepare(struct snd_pcm_substream *substream)
+{
+        struct snd_sh_dac *chip = snd_pcm_substream_chip(substream);
+        struct snd_pcm_runtime *runtime = chip->substream->runtime;
+
+        chip->buffer_size = runtime->buffer_size;
+        memset(chip->data_buffer, 0, chip->pdata->buffer_size);
+
+        return 0;
+}
+
+static int snd_sh_dac_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
+{
+        struct snd_sh_dac *chip = snd_pcm_substream_chip(substream);
+
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+                dac_audio_start_timer(chip);
+                break;
+        case SNDRV_PCM_TRIGGER_STOP:
+                chip->buffer_begin = chip->buffer_end = chip->data_buffer;
+                chip->processed = 0;
+                chip->empty = 1;
+                dac_audio_stop_timer(chip);
+                break;
+        default:
+                 return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int snd_sh_dac_pcm_copy(struct snd_pcm_substream *substream, int channel,
+        snd_pcm_uframes_t pos, void __user *src, snd_pcm_uframes_t count)
+{
+        /* channel is not used (interleaved data) */
+        struct snd_sh_dac *chip = snd_pcm_substream_chip(substream);
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        ssize_t b_count = frames_to_bytes(runtime , count);
+        ssize_t b_pos = frames_to_bytes(runtime , pos);
+
+        if (count < 0)
+                return -EINVAL;
+
+        if (!count)
+                return 0;
+
+        memcpy_toio(chip->data_buffer + b_pos, src, b_count);
+        chip->buffer_end = chip->data_buffer + b_pos + b_count;
+
+        if (chip->empty) {
+                chip->empty = 0;
+                dac_audio_start_timer(chip);
+        }
+
+        return 0;
+}
+
+static int snd_sh_dac_pcm_silence(struct snd_pcm_substream *substream,
+                                  int channel, snd_pcm_uframes_t pos,
+                                  snd_pcm_uframes_t count)
+{
+        /* channel is not used (interleaved data) */
+        struct snd_sh_dac *chip = snd_pcm_substream_chip(substream);
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        ssize_t b_count = frames_to_bytes(runtime , count);
+        ssize_t b_pos = frames_to_bytes(runtime , pos);
+
+        if (count < 0)
+                return -EINVAL;
+
+        if (!count)
+                return 0;
+
+        memset_io(chip->data_buffer + b_pos, 0, b_count);
+        chip->buffer_end = chip->data_buffer + b_pos + b_count;
+
+        if (chip->empty) {
+                chip->empty = 0;
+                dac_audio_start_timer(chip);
+        }
+
+        return 0;
+}
+
+static
+snd_pcm_uframes_t snd_sh_dac_pcm_pointer(struct snd_pcm_substream *substream)
+{
+        struct snd_sh_dac *chip = snd_pcm_substream_chip(substream);
+        int pointer = chip->buffer_begin - chip->data_buffer;
+
+        return pointer;
+}
+
+/* pcm ops */
+static struct snd_pcm_ops snd_sh_dac_pcm_ops = {
+        .open           = snd_sh_dac_pcm_open,
+        .close          = snd_sh_dac_pcm_close,
+        .ioctl          = snd_pcm_lib_ioctl,
+        .hw_params      = snd_sh_dac_pcm_hw_params,
+        .hw_free        = snd_sh_dac_pcm_hw_free,
+        .prepare        = snd_sh_dac_pcm_prepare,
+        .trigger        = snd_sh_dac_pcm_trigger,
+        .pointer        = snd_sh_dac_pcm_pointer,
+        .copy           = snd_sh_dac_pcm_copy,
+        .silence        = snd_sh_dac_pcm_silence,
+        .mmap           = snd_pcm_lib_mmap_iomem,
+};
+
+static int __devinit snd_sh_dac_pcm(struct snd_sh_dac *chip, int device)
+{
+        int err;
+        struct snd_pcm *pcm;
+
+        /* device should be always 0 for us */
+        err = snd_pcm_new(chip->card, "SH_DAC PCM", device, 1, 0, &pcm);
+        if (err < 0)
+                return err;
+
+        pcm->private_data = chip;
+        strcpy(pcm->name, "SH_DAC PCM");
+        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_sh_dac_pcm_ops);
+
+        /* buffer size=48K */
+        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS,
+                                          snd_dma_continuous_data(GFP_KERNEL),
+                                                        48 * 1024,
+                                                        48 * 1024);
+
+        return 0;
+}
+/* END OF PCM INTERFACE */
+
+
+/* driver .remove  --  destructor */
+static int snd_sh_dac_remove(struct platform_device *devptr)
+{
+        snd_card_free(platform_get_drvdata(devptr));
+        platform_set_drvdata(devptr, NULL);
+
+        return 0;
+}
+
+/* free -- it has been defined by create */
+static int snd_sh_dac_free(struct snd_sh_dac *chip)
+{
+        /* release the data */
+        kfree(chip->data_buffer);
+        kfree(chip);
+
+        return 0;
+}
+
+static int snd_sh_dac_dev_free(struct snd_device *device)
+{
+        struct snd_sh_dac *chip = device->device_data;
+
+        return snd_sh_dac_free(chip);
+}
+
+static enum hrtimer_restart sh_dac_audio_timer(struct hrtimer *handle)
+{
+        struct snd_sh_dac *chip = container_of(handle, struct snd_sh_dac,
+                                               hrtimer);
+        struct snd_pcm_runtime *runtime = chip->substream->runtime;
+        ssize_t b_ps = frames_to_bytes(runtime, runtime->period_size);
+
+        if (!chip->empty) {
+                sh_dac_output(*chip->buffer_begin, chip->pdata->channel);
+                chip->buffer_begin++;
+
+                chip->processed++;
+                if (chip->processed >= b_ps) {
+                        chip->processed -= b_ps;
+                        snd_pcm_period_elapsed(chip->substream);
+                }
+
+                if (chip->buffer_begin == (chip->data_buffer +
+                                           chip->buffer_size - 1))
+                        chip->buffer_begin = chip->data_buffer;
+
+                if (chip->buffer_begin == chip->buffer_end)
+                        chip->empty = 1;
+
+        }
+
+        if (!chip->empty)
+                hrtimer_start(&chip->hrtimer, chip->wakeups_per_second,
+                              HRTIMER_MODE_REL);
+
+        return HRTIMER_NORESTART;
+}
+
+/* create  --  chip-specific constructor for the cards components */
+static int __devinit snd_sh_dac_create(struct snd_card *card,
+                                       struct platform_device *devptr,
+                                       struct snd_sh_dac **rchip)
+{
+        struct snd_sh_dac *chip;
+        int err;
+
+        static struct snd_device_ops ops = {
+                   .dev_free = snd_sh_dac_dev_free,
+        };
+
+        *rchip = NULL;
+
+        chip = kzalloc(sizeof(*chip), GFP_KERNEL);
+        if (chip == NULL)
+                return -ENOMEM;
+
+        chip->card = card;
+
+        hrtimer_init(&chip->hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
+        chip->hrtimer.function = sh_dac_audio_timer;
+
+        dac_audio_reset(chip);
+        chip->rate = 8000;
+        dac_audio_set_rate(chip);
+
+        chip->pdata = devptr->dev.platform_data;
+
+        chip->data_buffer = kmalloc(chip->pdata->buffer_size, GFP_KERNEL);
+        if (chip->data_buffer == NULL) {
+                kfree(chip);
+                return -ENOMEM;
+        }
+
+        err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
+        if (err < 0) {
+                snd_sh_dac_free(chip);
+                return err;
+        }
+
+        *rchip = chip;
+
+        return 0;
+}
+
+/* driver .probe  --  constructor */
+static int __devinit snd_sh_dac_probe(struct platform_device *devptr)
+{
+        struct snd_sh_dac *chip;
+        struct snd_card *card;
+        int err;
+
+        err = snd_card_create(index, id, THIS_MODULE, 0, &card);
+        if (err < 0) {
+                        snd_printk(KERN_ERR "cannot allocate the card\n");
+                        return err;
+        }
+
+        err = snd_sh_dac_create(card, devptr, &chip);
+        if (err < 0)
+                goto probe_error;
+
+        err = snd_sh_dac_pcm(chip, 0);
+        if (err < 0)
+                goto probe_error;
+
+        strcpy(card->driver, "snd_sh_dac");
+        strcpy(card->shortname, "SuperH DAC audio driver");
+        printk(KERN_INFO "%s %s", card->longname, card->shortname);
+
+        err = snd_card_register(card);
+        if (err < 0)
+                goto probe_error;
+
+        snd_printk("ALSA driver for SuperH DAC audio");
+
+        platform_set_drvdata(devptr, card);
+        return 0;
+
+probe_error:
+        snd_card_free(card);
+        return err;
+}
+
+/*
+ * "driver" definition
+ */
+static struct platform_driver driver = {
+        .probe  = snd_sh_dac_probe,
+        .remove = snd_sh_dac_remove,
+        .driver = {
+                .name = "dac_audio",
+        },
+};
+
+static int __init sh_dac_init(void)
+{
+        return platform_driver_register(&driver);
+}
+
+static void __exit sh_dac_exit(void)
+{
+        platform_driver_unregister(&driver);
+}
+
+module_init(sh_dac_init);
+module_exit(sh_dac_exit);
diff --git a/sound/soc/Makefile b/sound/soc/Makefile
index 0c5eac01bf2e..1470141d4167 100644
--- a/sound/soc/Makefile
+++ b/sound/soc/Makefile
@@ -1,4 +1,4 @@
-snd-soc-core-objs := soc-core.o soc-dapm.o soc-jack.o soc-cache.o
+snd-soc-core-objs := soc-core.o soc-dapm.o soc-jack.o soc-cache.o soc-utils.o
 
 obj-$(CONFIG_SND_SOC)   += snd-soc-core.o
 obj-$(CONFIG_SND_SOC)   += codecs/
diff --git a/sound/soc/atmel/atmel-pcm.c b/sound/soc/atmel/atmel-pcm.c
index 9ef6b96373f5..3e6628c8e665 100644
--- a/sound/soc/atmel/atmel-pcm.c
+++ b/sound/soc/atmel/atmel-pcm.c
@@ -180,7 +180,7 @@ static int atmel_pcm_hw_params(struct snd_pcm_substream *substream,
         snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer);
         runtime->dma_bytes = params_buffer_bytes(params);
 
-        prtd->params = rtd->dai->cpu_dai->dma_data;
+        prtd->params = snd_soc_dai_get_dma_data(rtd->dai->cpu_dai, substream);
         prtd->params->dma_intr_handler = atmel_pcm_dma_irq;
 
         prtd->dma_buffer = runtime->dma_addr;
diff --git a/sound/soc/atmel/atmel_ssc_dai.c b/sound/soc/atmel/atmel_ssc_dai.c
index e588e63f18d2..0b59806905d1 100644
--- a/sound/soc/atmel/atmel_ssc_dai.c
+++ b/sound/soc/atmel/atmel_ssc_dai.c
@@ -363,12 +363,12 @@ static int atmel_ssc_hw_params(struct snd_pcm_substream *substream,
         ssc_p->dma_params[dir] = dma_params;
 
         /*
-         * The cpu_dai->dma_data field is only used to communicate the
-         * appropriate DMA parameters to the pcm driver hw_params()
+         * The snd_soc_pcm_stream->dma_data field is only used to communicate
+         * the appropriate DMA parameters to the pcm driver hw_params()
          * function.  It should not be used for other purposes
          * as it is common to all substreams.
          */
-        rtd->dai->cpu_dai->dma_data = dma_params;
+        snd_soc_dai_set_dma_data(rtd->dai->cpu_dai, substream, dma_params);
 
         channels = params_channels(params);
 
diff --git a/sound/soc/atmel/playpaq_wm8510.c b/sound/soc/atmel/playpaq_wm8510.c
index 9eb610c2ba91..9df4c68ef000 100644
--- a/sound/soc/atmel/playpaq_wm8510.c
+++ b/sound/soc/atmel/playpaq_wm8510.c
@@ -268,7 +268,7 @@ static int playpaq_wm8510_hw_params(struct snd_pcm_substream *substream,
 #endif /* CONFIG_SND_AT32_SOC_PLAYPAQ_SLAVE */
 
 
-        ret = snd_soc_dai_set_pll(codec_dai, 0,
+        ret = snd_soc_dai_set_pll(codec_dai, 0, 0,
                                          clk_get_rate(CODEC_CLK), pll_out);
         if (ret < 0) {
                 pr_warning("playpaq_wm8510: Failed to set CODEC DAI PLL (%d)\n",
diff --git a/sound/soc/atmel/sam9g20_wm8731.c b/sound/soc/atmel/sam9g20_wm8731.c
index 885ba012557e..e028744c32ce 100644
--- a/sound/soc/atmel/sam9g20_wm8731.c
+++ b/sound/soc/atmel/sam9g20_wm8731.c
@@ -207,7 +207,7 @@ static int __init at91sam9g20ek_init(void)
         struct clk *pllb;
         int ret;
 
-        if (!machine_is_at91sam9g20ek())
+        if (!(machine_is_at91sam9g20ek() || machine_is_at91sam9g20ek_2mmc()))
                 return -ENODEV;
 
         /*
diff --git a/sound/soc/au1x/Kconfig b/sound/soc/au1x/Kconfig
index 410a893aa66b..4b67140fdec3 100644
--- a/sound/soc/au1x/Kconfig
+++ b/sound/soc/au1x/Kconfig
@@ -22,11 +22,13 @@ config SND_SOC_AU1XPSC_AC97
 ##
 ## Boards
 ##
-config SND_SOC_SAMPLE_PSC_AC97
-        tristate "Sample Au12x0/Au1550 PSC AC97 sound machine"
+config SND_SOC_DB1200
+        tristate "DB1200 AC97+I2S audio support"
         depends on SND_SOC_AU1XPSC
         select SND_SOC_AU1XPSC_AC97
         select SND_SOC_AC97_CODEC
+        select SND_SOC_AU1XPSC_I2S
+        select SND_SOC_WM8731
         help
-          This is a sample AC97 sound machine for use in Au12x0/Au1550
-          based systems which have audio on PSC1 (e.g. Db1200 demoboard).
+          Select this option to enable audio (AC97 or I2S) on the
+          Alchemy/AMD/RMI DB1200 demoboard.
diff --git a/sound/soc/au1x/Makefile b/sound/soc/au1x/Makefile
index 6c6950b8003a..16873076e8c4 100644
--- a/sound/soc/au1x/Makefile
+++ b/sound/soc/au1x/Makefile
@@ -8,6 +8,6 @@ obj-$(CONFIG_SND_SOC_AU1XPSC_I2S) += snd-soc-au1xpsc-i2s.o
 obj-$(CONFIG_SND_SOC_AU1XPSC_AC97) += snd-soc-au1xpsc-ac97.o
 
 # Boards
-snd-soc-sample-ac97-objs := sample-ac97.o
+snd-soc-db1200-objs := db1200.o
 
-obj-$(CONFIG_SND_SOC_SAMPLE_PSC_AC97) += snd-soc-sample-ac97.o
+obj-$(CONFIG_SND_SOC_DB1200) += snd-soc-db1200.o
diff --git a/sound/soc/au1x/db1200.c b/sound/soc/au1x/db1200.c
new file mode 100644
index 000000000000..cdf7be1b9b91
--- /dev/null
+++ b/sound/soc/au1x/db1200.c
@@ -0,0 +1,141 @@
+/*
+ * DB1200 ASoC audio fabric support code.
+ *
+ * (c) 2008-9 Manuel Lauss <manuel.lauss@gmail.com>
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/timer.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+#include <asm/mach-au1x00/au1000.h>
+#include <asm/mach-au1x00/au1xxx_psc.h>
+#include <asm/mach-au1x00/au1xxx_dbdma.h>
+#include <asm/mach-db1x00/bcsr.h>
+
+#include "../codecs/ac97.h"
+#include "../codecs/wm8731.h"
+#include "psc.h"
+
+/*-------------------------  AC97 PART  ---------------------------*/
+
+static struct snd_soc_dai_link db1200_ac97_dai = {
+        .name           = "AC97",
+        .stream_name    = "AC97 HiFi",
+        .cpu_dai        = &au1xpsc_ac97_dai,
+        .codec_dai      = &ac97_dai,
+};
+
+static struct snd_soc_card db1200_ac97_machine = {
+        .name           = "DB1200_AC97",
+        .dai_link       = &db1200_ac97_dai,
+        .num_links      = 1,
+        .platform       = &au1xpsc_soc_platform,
+};
+
+static struct snd_soc_device db1200_ac97_devdata = {
+        .card           = &db1200_ac97_machine,
+        .codec_dev      = &soc_codec_dev_ac97,
+};
+
+/*-------------------------  I2S PART  ---------------------------*/
+
+static int db1200_i2s_startup(struct snd_pcm_substream *substream)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
+        struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
+        int ret;
+
+        /* WM8731 has its own 12MHz crystal */
+        snd_soc_dai_set_sysclk(codec_dai, WM8731_SYSCLK,
+                                12000000, SND_SOC_CLOCK_IN);
+
+        /* codec is bitclock and lrclk master */
+        ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_LEFT_J |
+                        SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBM_CFM);
+        if (ret < 0)
+                goto out;
+
+        ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_LEFT_J |
+                        SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBM_CFM);
+        if (ret < 0)
+                goto out;
+
+        ret = 0;
+out:
+        return ret;
+}
+
+static struct snd_soc_ops db1200_i2s_wm8731_ops = {
+        .startup        = db1200_i2s_startup,
+};
+
+static struct snd_soc_dai_link db1200_i2s_dai = {
+        .name           = "WM8731",
+        .stream_name    = "WM8731 PCM",
+        .cpu_dai        = &au1xpsc_i2s_dai,
+        .codec_dai      = &wm8731_dai,
+        .ops            = &db1200_i2s_wm8731_ops,
+};
+
+static struct snd_soc_card db1200_i2s_machine = {
+        .name           = "DB1200_I2S",
+        .dai_link       = &db1200_i2s_dai,
+        .num_links      = 1,
+        .platform       = &au1xpsc_soc_platform,
+};
+
+static struct snd_soc_device db1200_i2s_devdata = {
+        .card           = &db1200_i2s_machine,
+        .codec_dev      = &soc_codec_dev_wm8731,
+};
+
+/*-------------------------  COMMON PART  ---------------------------*/
+
+static struct platform_device *db1200_asoc_dev;
+
+static int __init db1200_audio_load(void)
+{
+        int ret;
+
+        ret = -ENOMEM;
+        db1200_asoc_dev = platform_device_alloc("soc-audio", -1);
+        if (!db1200_asoc_dev)
+                goto out;
+
+        /* DB1200 board setup set PSC1MUX to preferred audio device */
+        if (bcsr_read(BCSR_RESETS) & BCSR_RESETS_PSC1MUX)
+                platform_set_drvdata(db1200_asoc_dev, &db1200_i2s_devdata);
+        else
+                platform_set_drvdata(db1200_asoc_dev, &db1200_ac97_devdata);
+
+        db1200_ac97_devdata.dev = &db1200_asoc_dev->dev;
+        db1200_i2s_devdata.dev = &db1200_asoc_dev->dev;
+        ret = platform_device_add(db1200_asoc_dev);
+
+        if (ret) {
+                platform_device_put(db1200_asoc_dev);
+                db1200_asoc_dev = NULL;
+        }
+out:
+        return ret;
+}
+
+static void __exit db1200_audio_unload(void)
+{
+        platform_device_unregister(db1200_asoc_dev);
+}
+
+module_init(db1200_audio_load);
+module_exit(db1200_audio_unload);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("DB1200 ASoC audio support");
+MODULE_AUTHOR("Manuel Lauss");
diff --git a/sound/soc/au1x/dbdma2.c b/sound/soc/au1x/dbdma2.c
index 594c6c5b7838..6d9f4c624949 100644
--- a/sound/soc/au1x/dbdma2.c
+++ b/sound/soc/au1x/dbdma2.c
@@ -2,7 +2,7 @@
  * Au12x0/Au1550 PSC ALSA ASoC audio support.
  *
  * (c) 2007-2008 MSC Vertriebsges.m.b.H.,
- *      Manuel Lauss <mano@roarinelk.homelinux.net>
+ *      Manuel Lauss <manuel.lauss@gmail.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -51,8 +51,8 @@ struct au1xpsc_audio_dmadata {
         struct snd_pcm_substream *substream;
         unsigned long curr_period;      /* current segment DDMA is working on */
         unsigned long q_period;         /* queue period(s) */
-        unsigned long dma_area;         /* address of queued DMA area */
-        unsigned long dma_area_s;       /* start address of DMA area */
+        dma_addr_t dma_area;            /* address of queued DMA area */
+        dma_addr_t dma_area_s;          /* start address of DMA area */
         unsigned long pos;              /* current byte position being played */
         unsigned long periods;          /* number of SG segments in total */
         unsigned long period_bytes;     /* size in bytes of one SG segment */
@@ -94,8 +94,7 @@ static const struct snd_pcm_hardware au1xpsc_pcm_hardware = {
 
 static void au1x_pcm_queue_tx(struct au1xpsc_audio_dmadata *cd)
 {
-        au1xxx_dbdma_put_source_flags(cd->ddma_chan,
-                                (void *)phys_to_virt(cd->dma_area),
+        au1xxx_dbdma_put_source(cd->ddma_chan, cd->dma_area,
                                 cd->period_bytes, DDMA_FLAGS_IE);
 
         /* update next-to-queue period */
@@ -109,9 +108,8 @@ static void au1x_pcm_queue_tx(struct au1xpsc_audio_dmadata *cd)
 
 static void au1x_pcm_queue_rx(struct au1xpsc_audio_dmadata *cd)
 {
-        au1xxx_dbdma_put_dest_flags(cd->ddma_chan,
-                                (void *)phys_to_virt(cd->dma_area),
-                                cd->period_bytes, DDMA_FLAGS_IE);
+        au1xxx_dbdma_put_dest(cd->ddma_chan, cd->dma_area,
+                              cd->period_bytes, DDMA_FLAGS_IE);
 
         /* update next-to-queue period */
         ++cd->q_period;
@@ -233,7 +231,7 @@ static int au1xpsc_pcm_hw_params(struct snd_pcm_substream *substream,
         pcd->substream = substream;
         pcd->period_bytes = params_period_bytes(params);
         pcd->periods = params_periods(params);
-        pcd->dma_area_s = pcd->dma_area = (unsigned long)runtime->dma_addr;
+        pcd->dma_area_s = pcd->dma_area = runtime->dma_addr;
         pcd->q_period = 0;
         pcd->curr_period = 0;
         pcd->pos = 0;
@@ -333,6 +331,30 @@ static int au1xpsc_pcm_new(struct snd_card *card,
 
 static int au1xpsc_pcm_probe(struct platform_device *pdev)
 {
+        if (!au1xpsc_audio_pcmdma[PCM_TX] || !au1xpsc_audio_pcmdma[PCM_RX])
+                return -ENODEV;
+
+        return 0;
+}
+
+static int au1xpsc_pcm_remove(struct platform_device *pdev)
+{
+        return 0;
+}
+
+/* au1xpsc audio platform */
+struct snd_soc_platform au1xpsc_soc_platform = {
+        .name           = "au1xpsc-pcm-dbdma",
+        .probe          = au1xpsc_pcm_probe,
+        .remove         = au1xpsc_pcm_remove,
+        .pcm_ops        = &au1xpsc_pcm_ops,
+        .pcm_new        = au1xpsc_pcm_new,
+        .pcm_free       = au1xpsc_pcm_free_dma_buffers,
+};
+EXPORT_SYMBOL_GPL(au1xpsc_soc_platform);
+
+static int __devinit au1xpsc_pcm_drvprobe(struct platform_device *pdev)
+{
         struct resource *r;
         int ret;
 
@@ -365,7 +387,9 @@ static int au1xpsc_pcm_probe(struct platform_device *pdev)
         }
         (au1xpsc_audio_pcmdma[PCM_RX])->ddma_id = r->start;
 
-        return 0;
+        ret = snd_soc_register_platform(&au1xpsc_soc_platform);
+        if (!ret)
+                return ret;
 
 out2:
         kfree(au1xpsc_audio_pcmdma[PCM_RX]);
@@ -376,10 +400,12 @@ out1:
         return ret;
 }
 
-static int au1xpsc_pcm_remove(struct platform_device *pdev)
+static int __devexit au1xpsc_pcm_drvremove(struct platform_device *pdev)
 {
         int i;
 
+        snd_soc_unregister_platform(&au1xpsc_soc_platform);
+
         for (i = 0; i < 2; i++) {
                 if (au1xpsc_audio_pcmdma[i]) {
                         au1x_pcm_dbdma_free(au1xpsc_audio_pcmdma[i]);
@@ -391,32 +417,81 @@ static int au1xpsc_pcm_remove(struct platform_device *pdev)
         return 0;
 }
 
-/* au1xpsc audio platform */
-struct snd_soc_platform au1xpsc_soc_platform = {
-        .name           = "au1xpsc-pcm-dbdma",
-        .probe          = au1xpsc_pcm_probe,
-        .remove         = au1xpsc_pcm_remove,
-        .pcm_ops        = &au1xpsc_pcm_ops,
-        .pcm_new        = au1xpsc_pcm_new,
-        .pcm_free       = au1xpsc_pcm_free_dma_buffers,
+static struct platform_driver au1xpsc_pcm_driver = {
+        .driver = {
+                .name   = "au1xpsc-pcm",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = au1xpsc_pcm_drvprobe,
+        .remove         = __devexit_p(au1xpsc_pcm_drvremove),
 };
-EXPORT_SYMBOL_GPL(au1xpsc_soc_platform);
 
-static int __init au1xpsc_audio_dbdma_init(void)
+static int __init au1xpsc_audio_dbdma_load(void)
 {
         au1xpsc_audio_pcmdma[PCM_TX] = NULL;
         au1xpsc_audio_pcmdma[PCM_RX] = NULL;
-        return snd_soc_register_platform(&au1xpsc_soc_platform);
+        return platform_driver_register(&au1xpsc_pcm_driver);
 }
 
-static void __exit au1xpsc_audio_dbdma_exit(void)
+static void __exit au1xpsc_audio_dbdma_unload(void)
 {
-        snd_soc_unregister_platform(&au1xpsc_soc_platform);
+        platform_driver_unregister(&au1xpsc_pcm_driver);
+}
+
+module_init(au1xpsc_audio_dbdma_load);
+module_exit(au1xpsc_audio_dbdma_unload);
+
+
+struct platform_device *au1xpsc_pcm_add(struct platform_device *pdev)
+{
+        struct resource *res, *r;
+        struct platform_device *pd;
+        int id[2];
+        int ret;
+
+        r = platform_get_resource(pdev, IORESOURCE_DMA, 0);
+        if (!r)
+                return NULL;
+        id[0] = r->start;
+
+        r = platform_get_resource(pdev, IORESOURCE_DMA, 1);
+        if (!r)
+                return NULL;
+        id[1] = r->start;
+
+        res = kzalloc(sizeof(struct resource) * 2, GFP_KERNEL);
+        if (!res)
+                return NULL;
+
+        res[0].start = res[0].end = id[0];
+        res[1].start = res[1].end = id[1];
+        res[0].flags = res[1].flags = IORESOURCE_DMA;
+
+        pd = platform_device_alloc("au1xpsc-pcm", -1);
+        if (!pd)
+                goto out;
+
+        pd->resource = res;
+        pd->num_resources = 2;
+
+        ret = platform_device_add(pd);
+        if (!ret)
+                return pd;
+
+        platform_device_put(pd);
+out:
+        kfree(res);
+        return NULL;
 }
+EXPORT_SYMBOL_GPL(au1xpsc_pcm_add);
 
-module_init(au1xpsc_audio_dbdma_init);
-module_exit(au1xpsc_audio_dbdma_exit);
+void au1xpsc_pcm_destroy(struct platform_device *dmapd)
+{
+        if (dmapd)
+                platform_device_unregister(dmapd);
+}
+EXPORT_SYMBOL_GPL(au1xpsc_pcm_destroy);
 
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("Au12x0/Au1550 PSC Audio DMA driver");
-MODULE_AUTHOR("Manuel Lauss <mano@roarinelk.homelinux.net>");
+MODULE_AUTHOR("Manuel Lauss");
diff --git a/sound/soc/au1x/psc-ac97.c b/sound/soc/au1x/psc-ac97.c
index a521aa90ddee..a61ccd2d505f 100644
--- a/sound/soc/au1x/psc-ac97.c
+++ b/sound/soc/au1x/psc-ac97.c
@@ -17,6 +17,7 @@
 
 #include <linux/init.h>
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/device.h>
 #include <linux/delay.h>
 #include <linux/mutex.h>
@@ -61,7 +62,8 @@ static unsigned short au1xpsc_ac97_read(struct snd_ac97 *ac97,
 {
         /* FIXME */
         struct au1xpsc_audio_data *pscdata = au1xpsc_ac97_workdata;
-        unsigned short data, retry, tmo;
+        unsigned short retry, tmo;
+        unsigned long data;
 
         au_writel(PSC_AC97EVNT_CD, AC97_EVNT(pscdata));
         au_sync();
@@ -74,20 +76,26 @@ static unsigned short au1xpsc_ac97_read(struct snd_ac97 *ac97,
                           AC97_CDC(pscdata));
                 au_sync();
 
-                tmo = 2000;
-                while ((!(au_readl(AC97_EVNT(pscdata)) & PSC_AC97EVNT_CD))
-                        && --tmo)
-                        udelay(2);
+                tmo = 20;
+                do {
+                        udelay(21);
+                        if (au_readl(AC97_EVNT(pscdata)) & PSC_AC97EVNT_CD)
+                                break;
+                } while (--tmo);
 
-                data = au_readl(AC97_CDC(pscdata)) & 0xffff;
+                data = au_readl(AC97_CDC(pscdata));
 
                 au_writel(PSC_AC97EVNT_CD, AC97_EVNT(pscdata));
                 au_sync();
 
                 mutex_unlock(&pscdata->lock);
+
+                if (reg != ((data >> 16) & 0x7f))
+                        tmo = 1;        /* wrong register, try again */
+
         } while (--retry && !tmo);
 
-        return retry ? data : 0xffff;
+        return retry ? data & 0xffff : 0xffff;
 }
 
 /* AC97 controller writes to codec register */
@@ -109,10 +117,12 @@ static void au1xpsc_ac97_write(struct snd_ac97 *ac97, unsigned short reg,
                           AC97_CDC(pscdata));
                 au_sync();
 
-                tmo = 2000;
-                while ((!(au_readl(AC97_EVNT(pscdata)) & PSC_AC97EVNT_CD))
-                       && --tmo)
-                        udelay(2);
+                tmo = 20;
+                do {
+                        udelay(21);
+                        if (au_readl(AC97_EVNT(pscdata)) & PSC_AC97EVNT_CD)
+                                break;
+                } while (--tmo);
 
                 au_writel(PSC_AC97EVNT_CD, AC97_EVNT(pscdata));
                 au_sync();
@@ -195,7 +205,7 @@ static int au1xpsc_ac97_hw_params(struct snd_pcm_substream *substream,
         /* FIXME */
         struct au1xpsc_audio_data *pscdata = au1xpsc_ac97_workdata;
         unsigned long r, ro, stat;
-        int chans, stype = SUBSTREAM_TYPE(substream);
+        int chans, t, stype = SUBSTREAM_TYPE(substream);
 
         chans = params_channels(params);
 
@@ -237,8 +247,12 @@ static int au1xpsc_ac97_hw_params(struct snd_pcm_substream *substream,
                 au_sync();
 
                 /* ...wait for it... */
-                while (au_readl(AC97_STAT(pscdata)) & PSC_AC97STAT_DR)
-                        asm volatile ("nop");
+                t = 100;
+                while ((au_readl(AC97_STAT(pscdata)) & PSC_AC97STAT_DR) && --t)
+                        msleep(1);
+
+                if (!t)
+                        printk(KERN_ERR "PSC-AC97: can't disable!\n");
 
                 /* ...write config... */
                 au_writel(r, AC97_CFG(pscdata));
@@ -249,8 +263,12 @@ static int au1xpsc_ac97_hw_params(struct snd_pcm_substream *substream,
                 au_sync();
 
                 /* ...and wait for ready bit */
-                while (!(au_readl(AC97_STAT(pscdata)) & PSC_AC97STAT_DR))
-                        asm volatile ("nop");
+                t = 100;
+                while ((!(au_readl(AC97_STAT(pscdata)) & PSC_AC97STAT_DR)) && --t)
+                        msleep(1);
+
+                if (!t)
+                        printk(KERN_ERR "PSC-AC97: can't enable!\n");
 
                 mutex_unlock(&pscdata->lock);
 
@@ -300,19 +318,55 @@ static int au1xpsc_ac97_trigger(struct snd_pcm_substream *substream,
 static int au1xpsc_ac97_probe(struct platform_device *pdev,
                               struct snd_soc_dai *dai)
 {
+        return au1xpsc_ac97_workdata ? 0 : -ENODEV;
+}
+
+static void au1xpsc_ac97_remove(struct platform_device *pdev,
+                                struct snd_soc_dai *dai)
+{
+}
+
+static struct snd_soc_dai_ops au1xpsc_ac97_dai_ops = {
+        .trigger        = au1xpsc_ac97_trigger,
+        .hw_params      = au1xpsc_ac97_hw_params,
+};
+
+struct snd_soc_dai au1xpsc_ac97_dai = {
+        .name                   = "au1xpsc_ac97",
+        .ac97_control           = 1,
+        .probe                  = au1xpsc_ac97_probe,
+        .remove                 = au1xpsc_ac97_remove,
+        .playback = {
+                .rates          = AC97_RATES,
+                .formats        = AC97_FMTS,
+                .channels_min   = 2,
+                .channels_max   = 2,
+        },
+        .capture = {
+                .rates          = AC97_RATES,
+                .formats        = AC97_FMTS,
+                .channels_min   = 2,
+                .channels_max   = 2,
+        },
+        .ops = &au1xpsc_ac97_dai_ops,
+};
+EXPORT_SYMBOL_GPL(au1xpsc_ac97_dai);
+
+static int __devinit au1xpsc_ac97_drvprobe(struct platform_device *pdev)
+{
         int ret;
         struct resource *r;
         unsigned long sel;
+        struct au1xpsc_audio_data *wd;
 
         if (au1xpsc_ac97_workdata)
                 return -EBUSY;
 
-        au1xpsc_ac97_workdata =
-                kzalloc(sizeof(struct au1xpsc_audio_data), GFP_KERNEL);
-        if (!au1xpsc_ac97_workdata)
+        wd = kzalloc(sizeof(struct au1xpsc_audio_data), GFP_KERNEL);
+        if (!wd)
                 return -ENOMEM;
 
-        mutex_init(&au1xpsc_ac97_workdata->lock);
+        mutex_init(&wd->lock);
 
         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!r) {
@@ -321,81 +375,95 @@ static int au1xpsc_ac97_probe(struct platform_device *pdev,
         }
 
         ret = -EBUSY;
-        au1xpsc_ac97_workdata->ioarea =
-                request_mem_region(r->start, r->end - r->start + 1,
+        wd->ioarea = request_mem_region(r->start, r->end - r->start + 1,
                                         "au1xpsc_ac97");
-        if (!au1xpsc_ac97_workdata->ioarea)
+        if (!wd->ioarea)
                 goto out0;
 
-        au1xpsc_ac97_workdata->mmio = ioremap(r->start, 0xffff);
-        if (!au1xpsc_ac97_workdata->mmio)
+        wd->mmio = ioremap(r->start, 0xffff);
+        if (!wd->mmio)
                 goto out1;
 
         /* configuration: max dma trigger threshold, enable ac97 */
-        au1xpsc_ac97_workdata->cfg = PSC_AC97CFG_RT_FIFO8 |
-                                     PSC_AC97CFG_TT_FIFO8 |
-                                     PSC_AC97CFG_DE_ENABLE;
+        wd->cfg = PSC_AC97CFG_RT_FIFO8 | PSC_AC97CFG_TT_FIFO8 |
+                  PSC_AC97CFG_DE_ENABLE;
 
-        /* preserve PSC clock source set up by platform (dev.platform_data
-         * is already occupied by soc layer)
-         */
-        sel = au_readl(PSC_SEL(au1xpsc_ac97_workdata)) & PSC_SEL_CLK_MASK;
-        au_writel(PSC_CTRL_DISABLE, PSC_CTRL(au1xpsc_ac97_workdata));
+        /* preserve PSC clock source set up by platform  */
+        sel = au_readl(PSC_SEL(wd)) & PSC_SEL_CLK_MASK;
+        au_writel(PSC_CTRL_DISABLE, PSC_CTRL(wd));
         au_sync();
-        au_writel(0, PSC_SEL(au1xpsc_ac97_workdata));
+        au_writel(0, PSC_SEL(wd));
         au_sync();
-        au_writel(PSC_SEL_PS_AC97MODE | sel, PSC_SEL(au1xpsc_ac97_workdata));
+        au_writel(PSC_SEL_PS_AC97MODE | sel, PSC_SEL(wd));
         au_sync();
-        /* next up: cold reset.  Dont check for PSC-ready now since
-         * there may not be any codec clock yet.
-         */
 
-        return 0;
+        ret = snd_soc_register_dai(&au1xpsc_ac97_dai);
+        if (ret)
+                goto out1;
 
+        wd->dmapd = au1xpsc_pcm_add(pdev);
+        if (wd->dmapd) {
+                platform_set_drvdata(pdev, wd);
+                au1xpsc_ac97_workdata = wd;     /* MDEV */
+                return 0;
+        }
+
+        snd_soc_unregister_dai(&au1xpsc_ac97_dai);
 out1:
-        release_resource(au1xpsc_ac97_workdata->ioarea);
-        kfree(au1xpsc_ac97_workdata->ioarea);
+        release_resource(wd->ioarea);
+        kfree(wd->ioarea);
 out0:
-        kfree(au1xpsc_ac97_workdata);
-        au1xpsc_ac97_workdata = NULL;
+        kfree(wd);
         return ret;
 }
 
-static void au1xpsc_ac97_remove(struct platform_device *pdev,
-                                struct snd_soc_dai *dai)
+static int __devexit au1xpsc_ac97_drvremove(struct platform_device *pdev)
 {
+        struct au1xpsc_audio_data *wd = platform_get_drvdata(pdev);
+
+        if (wd->dmapd)
+                au1xpsc_pcm_destroy(wd->dmapd);
+
+        snd_soc_unregister_dai(&au1xpsc_ac97_dai);
+
         /* disable PSC completely */
-        au_writel(0, AC97_CFG(au1xpsc_ac97_workdata));
+        au_writel(0, AC97_CFG(wd));
         au_sync();
-        au_writel(PSC_CTRL_DISABLE, PSC_CTRL(au1xpsc_ac97_workdata));
+        au_writel(PSC_CTRL_DISABLE, PSC_CTRL(wd));
         au_sync();
 
-        iounmap(au1xpsc_ac97_workdata->mmio);
-        release_resource(au1xpsc_ac97_workdata->ioarea);
-        kfree(au1xpsc_ac97_workdata->ioarea);
-        kfree(au1xpsc_ac97_workdata);
-        au1xpsc_ac97_workdata = NULL;
+        iounmap(wd->mmio);
+        release_resource(wd->ioarea);
+        kfree(wd->ioarea);
+        kfree(wd);
+
+        au1xpsc_ac97_workdata = NULL;   /* MDEV */
+
+        return 0;
 }
 
-static int au1xpsc_ac97_suspend(struct snd_soc_dai *dai)
+#ifdef CONFIG_PM
+static int au1xpsc_ac97_drvsuspend(struct device *dev)
 {
+        struct au1xpsc_audio_data *wd = dev_get_drvdata(dev);
+
         /* save interesting registers and disable PSC */
-        au1xpsc_ac97_workdata->pm[0] =
-                        au_readl(PSC_SEL(au1xpsc_ac97_workdata));
+        wd->pm[0] = au_readl(PSC_SEL(wd));
 
-        au_writel(0, AC97_CFG(au1xpsc_ac97_workdata));
+        au_writel(0, AC97_CFG(wd));
         au_sync();
-        au_writel(PSC_CTRL_DISABLE, PSC_CTRL(au1xpsc_ac97_workdata));
+        au_writel(PSC_CTRL_DISABLE, PSC_CTRL(wd));
         au_sync();
 
         return 0;
 }
 
-static int au1xpsc_ac97_resume(struct snd_soc_dai *dai)
+static int au1xpsc_ac97_drvresume(struct device *dev)
 {
+        struct au1xpsc_audio_data *wd = dev_get_drvdata(dev);
+
         /* restore PSC clock config */
-        au_writel(au1xpsc_ac97_workdata->pm[0] | PSC_SEL_PS_AC97MODE,
-                        PSC_SEL(au1xpsc_ac97_workdata));
+        au_writel(wd->pm[0] | PSC_SEL_PS_AC97MODE, PSC_SEL(wd));
         au_sync();
 
         /* after this point the ac97 core will cold-reset the codec.
@@ -405,48 +473,44 @@ static int au1xpsc_ac97_resume(struct snd_soc_dai *dai)
         return 0;
 }
 
-static struct snd_soc_dai_ops au1xpsc_ac97_dai_ops = {
-        .trigger        = au1xpsc_ac97_trigger,
-        .hw_params      = au1xpsc_ac97_hw_params,
+static struct dev_pm_ops au1xpscac97_pmops = {
+        .suspend        = au1xpsc_ac97_drvsuspend,
+        .resume         = au1xpsc_ac97_drvresume,
 };
 
-struct snd_soc_dai au1xpsc_ac97_dai = {
-        .name                   = "au1xpsc_ac97",
-        .ac97_control           = 1,
-        .probe                  = au1xpsc_ac97_probe,
-        .remove                 = au1xpsc_ac97_remove,
-        .suspend                = au1xpsc_ac97_suspend,
-        .resume                 = au1xpsc_ac97_resume,
-        .playback = {
-                .rates          = AC97_RATES,
-                .formats        = AC97_FMTS,
-                .channels_min   = 2,
-                .channels_max   = 2,
-        },
-        .capture = {
-                .rates          = AC97_RATES,
-                .formats        = AC97_FMTS,
-                .channels_min   = 2,
-                .channels_max   = 2,
+#define AU1XPSCAC97_PMOPS &au1xpscac97_pmops
+
+#else
+
+#define AU1XPSCAC97_PMOPS NULL
+
+#endif
+
+static struct platform_driver au1xpsc_ac97_driver = {
+        .driver = {
+                .name   = "au1xpsc_ac97",
+                .owner  = THIS_MODULE,
+                .pm     = AU1XPSCAC97_PMOPS,
         },
-        .ops = &au1xpsc_ac97_dai_ops,
+        .probe          = au1xpsc_ac97_drvprobe,
+        .remove         = __devexit_p(au1xpsc_ac97_drvremove),
 };
-EXPORT_SYMBOL_GPL(au1xpsc_ac97_dai);
 
-static int __init au1xpsc_ac97_init(void)
+static int __init au1xpsc_ac97_load(void)
 {
         au1xpsc_ac97_workdata = NULL;
-        return snd_soc_register_dai(&au1xpsc_ac97_dai);
+        return platform_driver_register(&au1xpsc_ac97_driver);
 }
 
-static void __exit au1xpsc_ac97_exit(void)
+static void __exit au1xpsc_ac97_unload(void)
 {
-        snd_soc_unregister_dai(&au1xpsc_ac97_dai);
+        platform_driver_unregister(&au1xpsc_ac97_driver);
 }
 
-module_init(au1xpsc_ac97_init);
-module_exit(au1xpsc_ac97_exit);
+module_init(au1xpsc_ac97_load);
+module_exit(au1xpsc_ac97_unload);
 
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("Au12x0/Au1550 PSC AC97 ALSA ASoC audio driver");
-MODULE_AUTHOR("Manuel Lauss <manuel.lauss@gmail.com>");
+MODULE_AUTHOR("Manuel Lauss");
+
diff --git a/sound/soc/au1x/psc-i2s.c b/sound/soc/au1x/psc-i2s.c
index bb589327ee32..495be6e71931 100644
--- a/sound/soc/au1x/psc-i2s.c
+++ b/sound/soc/au1x/psc-i2s.c
@@ -2,7 +2,7 @@
  * Au12x0/Au1550 PSC ALSA ASoC audio support.
  *
  * (c) 2007-2008 MSC Vertriebsges.m.b.H.,
- *      Manuel Lauss <mano@roarinelk.homelinux.net>
+ *      Manuel Lauss <manuel.lauss@gmail.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -18,6 +18,7 @@
 
 #include <linux/init.h>
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/suspend.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
@@ -265,16 +266,52 @@ static int au1xpsc_i2s_trigger(struct snd_pcm_substream *substream, int cmd,
 static int au1xpsc_i2s_probe(struct platform_device *pdev,
                              struct snd_soc_dai *dai)
 {
+        return  au1xpsc_i2s_workdata ? 0 : -ENODEV;
+}
+
+static void au1xpsc_i2s_remove(struct platform_device *pdev,
+                               struct snd_soc_dai *dai)
+{
+}
+
+static struct snd_soc_dai_ops au1xpsc_i2s_dai_ops = {
+        .trigger        = au1xpsc_i2s_trigger,
+        .hw_params      = au1xpsc_i2s_hw_params,
+        .set_fmt        = au1xpsc_i2s_set_fmt,
+};
+
+struct snd_soc_dai au1xpsc_i2s_dai = {
+        .name                   = "au1xpsc_i2s",
+        .probe                  = au1xpsc_i2s_probe,
+        .remove                 = au1xpsc_i2s_remove,
+        .playback = {
+                .rates          = AU1XPSC_I2S_RATES,
+                .formats        = AU1XPSC_I2S_FMTS,
+                .channels_min   = 2,
+                .channels_max   = 8,    /* 2 without external help */
+        },
+        .capture = {
+                .rates          = AU1XPSC_I2S_RATES,
+                .formats        = AU1XPSC_I2S_FMTS,
+                .channels_min   = 2,
+                .channels_max   = 8,    /* 2 without external help */
+        },
+        .ops = &au1xpsc_i2s_dai_ops,
+};
+EXPORT_SYMBOL(au1xpsc_i2s_dai);
+
+static int __init au1xpsc_i2s_drvprobe(struct platform_device *pdev)
+{
         struct resource *r;
         unsigned long sel;
         int ret;
+        struct au1xpsc_audio_data *wd;
 
         if (au1xpsc_i2s_workdata)
                 return -EBUSY;
 
-        au1xpsc_i2s_workdata =
-                kzalloc(sizeof(struct au1xpsc_audio_data), GFP_KERNEL);
-        if (!au1xpsc_i2s_workdata)
+        wd = kzalloc(sizeof(struct au1xpsc_audio_data), GFP_KERNEL);
+        if (!wd)
                 return -ENOMEM;
 
         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
@@ -284,131 +321,146 @@ static int au1xpsc_i2s_probe(struct platform_device *pdev,
         }
 
         ret = -EBUSY;
-        au1xpsc_i2s_workdata->ioarea =
-                request_mem_region(r->start, r->end - r->start + 1,
+        wd->ioarea = request_mem_region(r->start, r->end - r->start + 1,
                                         "au1xpsc_i2s");
-        if (!au1xpsc_i2s_workdata->ioarea)
+        if (!wd->ioarea)
                 goto out0;
 
-        au1xpsc_i2s_workdata->mmio = ioremap(r->start, 0xffff);
-        if (!au1xpsc_i2s_workdata->mmio)
+        wd->mmio = ioremap(r->start, 0xffff);
+        if (!wd->mmio)
                 goto out1;
 
         /* preserve PSC clock source set up by platform (dev.platform_data
          * is already occupied by soc layer)
          */
-        sel = au_readl(PSC_SEL(au1xpsc_i2s_workdata)) & PSC_SEL_CLK_MASK;
-        au_writel(PSC_CTRL_DISABLE, PSC_CTRL(au1xpsc_i2s_workdata));
+        sel = au_readl(PSC_SEL(wd)) & PSC_SEL_CLK_MASK;
+        au_writel(PSC_CTRL_DISABLE, PSC_CTRL(wd));
         au_sync();
-        au_writel(PSC_SEL_PS_I2SMODE | sel, PSC_SEL(au1xpsc_i2s_workdata));
-        au_writel(0, I2S_CFG(au1xpsc_i2s_workdata));
+        au_writel(PSC_SEL_PS_I2SMODE | sel, PSC_SEL(wd));
+        au_writel(0, I2S_CFG(wd));
         au_sync();
 
         /* preconfigure: set max rx/tx fifo depths */
-        au1xpsc_i2s_workdata->cfg |=
-                        PSC_I2SCFG_RT_FIFO8 | PSC_I2SCFG_TT_FIFO8;
+        wd->cfg |= PSC_I2SCFG_RT_FIFO8 | PSC_I2SCFG_TT_FIFO8;
 
         /* don't wait for I2S core to become ready now; clocks may not
          * be running yet; depending on clock input for PSC a wait might
          * time out.
          */
 
-        return 0;
+        ret = snd_soc_register_dai(&au1xpsc_i2s_dai);
+        if (ret)
+                goto out1;
 
+        /* finally add the DMA device for this PSC */
+        wd->dmapd = au1xpsc_pcm_add(pdev);
+        if (wd->dmapd) {
+                platform_set_drvdata(pdev, wd);
+                au1xpsc_i2s_workdata = wd;
+                return 0;
+        }
+
+        snd_soc_unregister_dai(&au1xpsc_i2s_dai);
 out1:
-        release_resource(au1xpsc_i2s_workdata->ioarea);
-        kfree(au1xpsc_i2s_workdata->ioarea);
+        release_resource(wd->ioarea);
+        kfree(wd->ioarea);
 out0:
-        kfree(au1xpsc_i2s_workdata);
-        au1xpsc_i2s_workdata = NULL;
+        kfree(wd);
         return ret;
 }
 
-static void au1xpsc_i2s_remove(struct platform_device *pdev,
-                               struct snd_soc_dai *dai)
+static int __devexit au1xpsc_i2s_drvremove(struct platform_device *pdev)
 {
-        au_writel(0, I2S_CFG(au1xpsc_i2s_workdata));
+        struct au1xpsc_audio_data *wd = platform_get_drvdata(pdev);
+
+        if (wd->dmapd)
+                au1xpsc_pcm_destroy(wd->dmapd);
+
+        snd_soc_unregister_dai(&au1xpsc_i2s_dai);
+
+        au_writel(0, I2S_CFG(wd));
         au_sync();
-        au_writel(PSC_CTRL_DISABLE, PSC_CTRL(au1xpsc_i2s_workdata));
+        au_writel(PSC_CTRL_DISABLE, PSC_CTRL(wd));
         au_sync();
 
-        iounmap(au1xpsc_i2s_workdata->mmio);
-        release_resource(au1xpsc_i2s_workdata->ioarea);
-        kfree(au1xpsc_i2s_workdata->ioarea);
-        kfree(au1xpsc_i2s_workdata);
-        au1xpsc_i2s_workdata = NULL;
+        iounmap(wd->mmio);
+        release_resource(wd->ioarea);
+        kfree(wd->ioarea);
+        kfree(wd);
+
+        au1xpsc_i2s_workdata = NULL;    /* MDEV */
+
+        return 0;
 }
 
-static int au1xpsc_i2s_suspend(struct snd_soc_dai *cpu_dai)
+#ifdef CONFIG_PM
+static int au1xpsc_i2s_drvsuspend(struct device *dev)
 {
+        struct au1xpsc_audio_data *wd = dev_get_drvdata(dev);
+
         /* save interesting register and disable PSC */
-        au1xpsc_i2s_workdata->pm[0] =
-                au_readl(PSC_SEL(au1xpsc_i2s_workdata));
+        wd->pm[0] = au_readl(PSC_SEL(wd));
 
-        au_writel(0, I2S_CFG(au1xpsc_i2s_workdata));
+        au_writel(0, I2S_CFG(wd));
         au_sync();
-        au_writel(PSC_CTRL_DISABLE, PSC_CTRL(au1xpsc_i2s_workdata));
+        au_writel(PSC_CTRL_DISABLE, PSC_CTRL(wd));
         au_sync();
 
         return 0;
 }
 
-static int au1xpsc_i2s_resume(struct snd_soc_dai *cpu_dai)
+static int au1xpsc_i2s_drvresume(struct device *dev)
 {
+        struct au1xpsc_audio_data *wd = dev_get_drvdata(dev);
+
         /* select I2S mode and PSC clock */
-        au_writel(PSC_CTRL_DISABLE, PSC_CTRL(au1xpsc_i2s_workdata));
+        au_writel(PSC_CTRL_DISABLE, PSC_CTRL(wd));
         au_sync();
-        au_writel(0, PSC_SEL(au1xpsc_i2s_workdata));
+        au_writel(0, PSC_SEL(wd));
         au_sync();
-        au_writel(au1xpsc_i2s_workdata->pm[0],
-                        PSC_SEL(au1xpsc_i2s_workdata));
+        au_writel(wd->pm[0], PSC_SEL(wd));
         au_sync();
 
         return 0;
 }
 
-static struct snd_soc_dai_ops au1xpsc_i2s_dai_ops = {
-        .trigger        = au1xpsc_i2s_trigger,
-        .hw_params      = au1xpsc_i2s_hw_params,
-        .set_fmt        = au1xpsc_i2s_set_fmt,
+static struct dev_pm_ops au1xpsci2s_pmops = {
+        .suspend        = au1xpsc_i2s_drvsuspend,
+        .resume         = au1xpsc_i2s_drvresume,
 };
 
-struct snd_soc_dai au1xpsc_i2s_dai = {
-        .name                   = "au1xpsc_i2s",
-        .probe                  = au1xpsc_i2s_probe,
-        .remove                 = au1xpsc_i2s_remove,
-        .suspend                = au1xpsc_i2s_suspend,
-        .resume                 = au1xpsc_i2s_resume,
-        .playback = {
-                .rates          = AU1XPSC_I2S_RATES,
-                .formats        = AU1XPSC_I2S_FMTS,
-                .channels_min   = 2,
-                .channels_max   = 8,    /* 2 without external help */
-        },
-        .capture = {
-                .rates          = AU1XPSC_I2S_RATES,
-                .formats        = AU1XPSC_I2S_FMTS,
-                .channels_min   = 2,
-                .channels_max   = 8,    /* 2 without external help */
+#define AU1XPSCI2S_PMOPS &au1xpsci2s_pmops
+
+#else
+
+#define AU1XPSCI2S_PMOPS NULL
+
+#endif
+
+static struct platform_driver au1xpsc_i2s_driver = {
+        .driver         = {
+                .name   = "au1xpsc_i2s",
+                .owner  = THIS_MODULE,
+                .pm     = AU1XPSCI2S_PMOPS,
         },
-        .ops = &au1xpsc_i2s_dai_ops,
+        .probe          = au1xpsc_i2s_drvprobe,
+        .remove         = __devexit_p(au1xpsc_i2s_drvremove),
 };
-EXPORT_SYMBOL(au1xpsc_i2s_dai);
 
-static int __init au1xpsc_i2s_init(void)
+static int __init au1xpsc_i2s_load(void)
 {
         au1xpsc_i2s_workdata = NULL;
-        return snd_soc_register_dai(&au1xpsc_i2s_dai);
+        return platform_driver_register(&au1xpsc_i2s_driver);
 }
 
-static void __exit au1xpsc_i2s_exit(void)
+static void __exit au1xpsc_i2s_unload(void)
 {
-        snd_soc_unregister_dai(&au1xpsc_i2s_dai);
+        platform_driver_unregister(&au1xpsc_i2s_driver);
 }
 
-module_init(au1xpsc_i2s_init);
-module_exit(au1xpsc_i2s_exit);
+module_init(au1xpsc_i2s_load);
+module_exit(au1xpsc_i2s_unload);
 
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("Au12x0/Au1550 PSC I2S ALSA ASoC audio driver");
-MODULE_AUTHOR("Manuel Lauss <mano@roarinelk.homelinux.net>");
+MODULE_AUTHOR("Manuel Lauss");
diff --git a/sound/soc/au1x/psc.h b/sound/soc/au1x/psc.h
index 3f474e8ed4f6..32d3807d3f5a 100644
--- a/sound/soc/au1x/psc.h
+++ b/sound/soc/au1x/psc.h
@@ -2,7 +2,7 @@
  * Au12x0/Au1550 PSC ALSA ASoC audio support.
  *
  * (c) 2007-2008 MSC Vertriebsges.m.b.H.,
- *      Manuel Lauss <mano@roarinelk.homelinux.net>
+ *      Manuel Lauss <manuel.lauss@gmail.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -21,6 +21,10 @@ extern struct snd_soc_dai au1xpsc_i2s_dai;
 extern struct snd_soc_platform au1xpsc_soc_platform;
 extern struct snd_ac97_bus_ops soc_ac97_ops;
 
+/* DBDMA helpers */
+extern struct platform_device *au1xpsc_pcm_add(struct platform_device *pdev);
+extern void au1xpsc_pcm_destroy(struct platform_device *dmapd);
+
 struct au1xpsc_audio_data {
         void __iomem *mmio;
 
@@ -30,6 +34,7 @@ struct au1xpsc_audio_data {
         unsigned long pm[2];
         struct resource *ioarea;
         struct mutex lock;
+        struct platform_device *dmapd;
 };
 
 #define PCM_TX  0
diff --git a/sound/soc/au1x/sample-ac97.c b/sound/soc/au1x/sample-ac97.c
deleted file mode 100644
index 27683eb7905e..000000000000
--- a/sound/soc/au1x/sample-ac97.c
+++ /dev/null
@@ -1,144 +0,0 @@
-/*
- * Sample Au12x0/Au1550 PSC AC97 sound machine.
- *
- * Copyright (c) 2007-2008 Manuel Lauss <mano@roarinelk.homelinux.net>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms outlined in the file COPYING at the root of this
- *  source archive.
- *
- * This is a very generic AC97 sound machine driver for boards which
- * have (AC97) audio at PSC1 (e.g. DB1200 demoboards).
- */
-
-#include <linux/module.h>
-#include <linux/moduleparam.h>
-#include <linux/timer.h>
-#include <linux/interrupt.h>
-#include <linux/platform_device.h>
-#include <sound/core.h>
-#include <sound/pcm.h>
-#include <sound/soc.h>
-#include <sound/soc-dapm.h>
-#include <asm/mach-au1x00/au1000.h>
-#include <asm/mach-au1x00/au1xxx_psc.h>
-#include <asm/mach-au1x00/au1xxx_dbdma.h>
-
-#include "../codecs/ac97.h"
-#include "psc.h"
-
-static int au1xpsc_sample_ac97_init(struct snd_soc_codec *codec)
-{
-        snd_soc_dapm_sync(codec);
-        return 0;
-}
-
-static struct snd_soc_dai_link au1xpsc_sample_ac97_dai = {
-        .name           = "AC97",
-        .stream_name    = "AC97 HiFi",
-        .cpu_dai        = &au1xpsc_ac97_dai,    /* see psc-ac97.c */
-        .codec_dai      = &ac97_dai,            /* see codecs/ac97.c */
-        .init           = au1xpsc_sample_ac97_init,
-        .ops            = NULL,
-};
-
-static struct snd_soc_card au1xpsc_sample_ac97_machine = {
-        .name           = "Au1xxx PSC AC97 Audio",
-        .dai_link       = &au1xpsc_sample_ac97_dai,
-        .num_links      = 1,
-};
-
-static struct snd_soc_device au1xpsc_sample_ac97_devdata = {
-        .card           = &au1xpsc_sample_ac97_machine,
-        .platform       = &au1xpsc_soc_platform, /* see dbdma2.c */
-        .codec_dev      = &soc_codec_dev_ac97,
-};
-
-static struct resource au1xpsc_psc1_res[] = {
-        [0] = {
-                .start  = CPHYSADDR(PSC1_BASE_ADDR),
-                .end    = CPHYSADDR(PSC1_BASE_ADDR) + 0x000fffff,
-                .flags  = IORESOURCE_MEM,
-        },
-        [1] = {
-#ifdef CONFIG_SOC_AU1200
-                .start  = AU1200_PSC1_INT,
-                .end    = AU1200_PSC1_INT,
-#elif defined(CONFIG_SOC_AU1550)
-                .start  = AU1550_PSC1_INT,
-                .end    = AU1550_PSC1_INT,
-#endif
-                .flags  = IORESOURCE_IRQ,
-        },
-        [2] = {
-                .start  = DSCR_CMD0_PSC1_TX,
-                .end    = DSCR_CMD0_PSC1_TX,
-                .flags  = IORESOURCE_DMA,
-        },
-        [3] = {
-                .start  = DSCR_CMD0_PSC1_RX,
-                .end    = DSCR_CMD0_PSC1_RX,
-                .flags  = IORESOURCE_DMA,
-        },
-};
-
-static struct platform_device *au1xpsc_sample_ac97_dev;
-
-static int __init au1xpsc_sample_ac97_load(void)
-{
-        int ret;
-
-#ifdef CONFIG_SOC_AU1200
-        unsigned long io;
-
-        /* modify sys_pinfunc for AC97 on PSC1 */
-        io = au_readl(SYS_PINFUNC);
-        io |= SYS_PINFUNC_P1C;
-        io &= ~(SYS_PINFUNC_P1A | SYS_PINFUNC_P1B);
-        au_writel(io, SYS_PINFUNC);
-        au_sync();
-#endif
-
-        ret = -ENOMEM;
-
-        /* setup PSC clock source for AC97 part: external clock provided
-         * by codec.  The psc-ac97.c driver depends on this setting!
-         */
-        au_writel(PSC_SEL_CLK_SERCLK, PSC1_BASE_ADDR + PSC_SEL_OFFSET);
-        au_sync();
-
-        au1xpsc_sample_ac97_dev = platform_device_alloc("soc-audio", -1);
-        if (!au1xpsc_sample_ac97_dev)
-                goto out;
-
-        au1xpsc_sample_ac97_dev->resource =
-                kmemdup(au1xpsc_psc1_res, sizeof(struct resource) *
-                        ARRAY_SIZE(au1xpsc_psc1_res), GFP_KERNEL);
-        au1xpsc_sample_ac97_dev->num_resources = ARRAY_SIZE(au1xpsc_psc1_res);
-        au1xpsc_sample_ac97_dev->id = 1;
-
-        platform_set_drvdata(au1xpsc_sample_ac97_dev,
-                             &au1xpsc_sample_ac97_devdata);
-        au1xpsc_sample_ac97_devdata.dev = &au1xpsc_sample_ac97_dev->dev;
-        ret = platform_device_add(au1xpsc_sample_ac97_dev);
-
-        if (ret) {
-                platform_device_put(au1xpsc_sample_ac97_dev);
-                au1xpsc_sample_ac97_dev = NULL;
-        }
-
-out:
-        return ret;
-}
-
-static void __exit au1xpsc_sample_ac97_exit(void)
-{
-        platform_device_unregister(au1xpsc_sample_ac97_dev);
-}
-
-module_init(au1xpsc_sample_ac97_load);
-module_exit(au1xpsc_sample_ac97_exit);
-
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("Au1xxx PSC sample AC97 machine");
-MODULE_AUTHOR("Manuel Lauss <mano@roarinelk.homelinux.net>");
diff --git a/sound/soc/blackfin/bf5xx-ac97-pcm.c b/sound/soc/blackfin/bf5xx-ac97-pcm.c
index cf0dfb7ca221..5e7aacf3bb5a 100644
--- a/sound/soc/blackfin/bf5xx-ac97-pcm.c
+++ b/sound/soc/blackfin/bf5xx-ac97-pcm.c
@@ -29,8 +29,8 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/platform_device.h>
-#include <linux/slab.h>
 #include <linux/dma-mapping.h>
+#include <linux/gfp.h>
 
 #include <sound/core.h>
 #include <sound/pcm.h>
@@ -349,9 +349,7 @@ static int bf5xx_pcm_preallocate_dma_buffer(struct snd_pcm *pcm, int stream)
                         sport_handle->tx_dma_buf = dma_alloc_coherent(NULL, \
                                 size, &sport_handle->tx_dma_phy, GFP_KERNEL);
                         if (!sport_handle->tx_dma_buf) {
-                                pr_err("Failed to allocate memory for tx dma \
-                                        buf - Please increase uncached DMA \
-                                        memory region\n");
+                                pr_err("Failed to allocate memory for tx dma buf - Please increase uncached DMA memory region\n");
                                 return -ENOMEM;
                         } else
                                 memset(sport_handle->tx_dma_buf, 0, size);
@@ -362,9 +360,7 @@ static int bf5xx_pcm_preallocate_dma_buffer(struct snd_pcm *pcm, int stream)
                         sport_handle->rx_dma_buf = dma_alloc_coherent(NULL, \
                                 size, &sport_handle->rx_dma_phy, GFP_KERNEL);
                         if (!sport_handle->rx_dma_buf) {
-                                pr_err("Failed to allocate memory for rx dma \
-                                        buf - Please increase uncached DMA \
-                                        memory region\n");
+                                pr_err("Failed to allocate memory for rx dma buf - Please increase uncached DMA memory region\n");
                                 return -ENOMEM;
                         } else
                                 memset(sport_handle->rx_dma_buf, 0, size);
diff --git a/sound/soc/blackfin/bf5xx-ac97.c b/sound/soc/blackfin/bf5xx-ac97.c
index e69322978739..523b7fc33f4e 100644
--- a/sound/soc/blackfin/bf5xx-ac97.c
+++ b/sound/soc/blackfin/bf5xx-ac97.c
@@ -16,6 +16,7 @@
 #include <linux/interrupt.h>
 #include <linux/wait.h>
 #include <linux/delay.h>
+#include <linux/slab.h>
 
 #include <sound/core.h>
 #include <sound/pcm.h>
diff --git a/sound/soc/blackfin/bf5xx-ad1836.c b/sound/soc/blackfin/bf5xx-ad1836.c
index cd361e304b0f..0f45a3f56be8 100644
--- a/sound/soc/blackfin/bf5xx-ad1836.c
+++ b/sound/soc/blackfin/bf5xx-ad1836.c
@@ -52,6 +52,7 @@ static int bf5xx_ad1836_hw_params(struct snd_pcm_substream *substream,
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
         struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
         struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
+        unsigned int channel_map[] = {0, 4, 1, 5, 2, 6, 3, 7};
         int ret = 0;
         /* set cpu DAI configuration */
         ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_DSP_A |
@@ -65,6 +66,12 @@ static int bf5xx_ad1836_hw_params(struct snd_pcm_substream *substream,
         if (ret < 0)
                 return ret;
 
+        /* set cpu DAI channel mapping */
+        ret = snd_soc_dai_set_channel_map(cpu_dai, ARRAY_SIZE(channel_map),
+                channel_map, ARRAY_SIZE(channel_map), channel_map);
+        if (ret < 0)
+                return ret;
+
         return 0;
 }
 
diff --git a/sound/soc/blackfin/bf5xx-ad1938.c b/sound/soc/blackfin/bf5xx-ad1938.c
index 08269e91810c..2ef1e5013b8c 100644
--- a/sound/soc/blackfin/bf5xx-ad1938.c
+++ b/sound/soc/blackfin/bf5xx-ad1938.c
@@ -61,6 +61,7 @@ static int bf5xx_ad1938_hw_params(struct snd_pcm_substream *substream,
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
         struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
         struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
+        unsigned int channel_map[] = {0, 1, 2, 3, 4, 5, 6, 7};
         int ret = 0;
         /* set cpu DAI configuration */
         ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_DSP_A |
@@ -75,7 +76,13 @@ static int bf5xx_ad1938_hw_params(struct snd_pcm_substream *substream,
                 return ret;
 
         /* set codec DAI slots, 8 channels, all channels are enabled */
-        ret = snd_soc_dai_set_tdm_slot(codec_dai, 0xFF, 8);
+        ret = snd_soc_dai_set_tdm_slot(codec_dai, 0xFF, 0xFF, 8, 32);
+        if (ret < 0)
+                return ret;
+
+        /* set cpu DAI channel mapping */
+        ret = snd_soc_dai_set_channel_map(cpu_dai, ARRAY_SIZE(channel_map),
+                channel_map, ARRAY_SIZE(channel_map), channel_map);
         if (ret < 0)
                 return ret;
 
diff --git a/sound/soc/blackfin/bf5xx-i2s-pcm.c b/sound/soc/blackfin/bf5xx-i2s-pcm.c
index 62fbb8459569..1d2a1adf2575 100644
--- a/sound/soc/blackfin/bf5xx-i2s-pcm.c
+++ b/sound/soc/blackfin/bf5xx-i2s-pcm.c
@@ -29,8 +29,8 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/platform_device.h>
-#include <linux/slab.h>
 #include <linux/dma-mapping.h>
+#include <linux/gfp.h>
 
 #include <sound/core.h>
 #include <sound/pcm.h>
@@ -207,8 +207,7 @@ static int bf5xx_pcm_preallocate_dma_buffer(struct snd_pcm *pcm, int stream)
         buf->area = dma_alloc_coherent(pcm->card->dev, size,
                         &buf->addr, GFP_KERNEL);
         if (!buf->area) {
-                pr_err("Failed to allocate dma memory \
-                        Please increase uncached DMA memory region\n");
+                pr_err("Failed to allocate dma memory - Please increase uncached DMA memory region\n");
                 return -ENOMEM;
         }
         buf->bytes = size;
diff --git a/sound/soc/blackfin/bf5xx-i2s.c b/sound/soc/blackfin/bf5xx-i2s.c
index 084b68884ada..3e6ada0dd1c4 100644
--- a/sound/soc/blackfin/bf5xx-i2s.c
+++ b/sound/soc/blackfin/bf5xx-i2s.c
@@ -49,7 +49,6 @@ struct bf5xx_i2s_port {
         u16 rcr1;
         u16 tcr2;
         u16 rcr2;
-        int counter;
         int configured;
 };
 
@@ -133,16 +132,6 @@ static int bf5xx_i2s_set_dai_fmt(struct snd_soc_dai *cpu_dai,
         return ret;
 }
 
-static int bf5xx_i2s_startup(struct snd_pcm_substream *substream,
-                             struct snd_soc_dai *dai)
-{
-        pr_debug("%s enter\n", __func__);
-
-        /*this counter is used for counting how many pcm streams are opened*/
-        bf5xx_i2s.counter++;
-        return 0;
-}
-
 static int bf5xx_i2s_hw_params(struct snd_pcm_substream *substream,
                                 struct snd_pcm_hw_params *params,
                                 struct snd_soc_dai *dai)
@@ -201,9 +190,8 @@ static void bf5xx_i2s_shutdown(struct snd_pcm_substream *substream,
                                struct snd_soc_dai *dai)
 {
         pr_debug("%s enter\n", __func__);
-        bf5xx_i2s.counter--;
         /* No active stream, SPORT is allowed to be configured again. */
-        if (!bf5xx_i2s.counter)
+        if (!dai->active)
                 bf5xx_i2s.configured = 0;
 }
 
@@ -284,7 +272,6 @@ static int bf5xx_i2s_resume(struct snd_soc_dai *dai)
         SNDRV_PCM_FMTBIT_S32_LE)
 
 static struct snd_soc_dai_ops bf5xx_i2s_dai_ops = {
-        .startup        = bf5xx_i2s_startup,
         .shutdown       = bf5xx_i2s_shutdown,
         .hw_params      = bf5xx_i2s_hw_params,
         .set_fmt        = bf5xx_i2s_set_dai_fmt,
diff --git a/sound/soc/blackfin/bf5xx-tdm-pcm.c b/sound/soc/blackfin/bf5xx-tdm-pcm.c
index ccb5e823bd18..6bac1ac1a315 100644
--- a/sound/soc/blackfin/bf5xx-tdm-pcm.c
+++ b/sound/soc/blackfin/bf5xx-tdm-pcm.c
@@ -29,8 +29,8 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/platform_device.h>
-#include <linux/slab.h>
 #include <linux/dma-mapping.h>
+#include <linux/gfp.h>
 
 #include <sound/core.h>
 #include <sound/pcm.h>
@@ -43,7 +43,7 @@
 #include "bf5xx-tdm.h"
 #include "bf5xx-sport.h"
 
-#define PCM_BUFFER_MAX  0x10000
+#define PCM_BUFFER_MAX  0x8000
 #define FRAGMENT_SIZE_MIN  (4*1024)
 #define FRAGMENTS_MIN  2
 #define FRAGMENTS_MAX  32
@@ -177,6 +177,9 @@ out:
 static int bf5xx_pcm_copy(struct snd_pcm_substream *substream, int channel,
         snd_pcm_uframes_t pos, void *buf, snd_pcm_uframes_t count)
 {
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct sport_device *sport = runtime->private_data;
+        struct bf5xx_tdm_port *tdm_port = sport->private_data;
         unsigned int *src;
         unsigned int *dst;
         int i;
@@ -188,7 +191,7 @@ static int bf5xx_pcm_copy(struct snd_pcm_substream *substream, int channel,
                 dst += pos * 8;
                 while (count--) {
                         for (i = 0; i < substream->runtime->channels; i++)
-                                *(dst + i) = *src++;
+                                *(dst + tdm_port->tx_map[i]) = *src++;
                         dst += 8;
                 }
         } else {
@@ -198,7 +201,7 @@ static int bf5xx_pcm_copy(struct snd_pcm_substream *substream, int channel,
                 src += pos * 8;
                 while (count--) {
                         for (i = 0; i < substream->runtime->channels; i++)
-                                *dst++ = *(src+i);
+                                *dst++ = *(src + tdm_port->rx_map[i]);
                         src += 8;
                 }
         }
@@ -241,8 +244,7 @@ static int bf5xx_pcm_preallocate_dma_buffer(struct snd_pcm *pcm, int stream)
         buf->area = dma_alloc_coherent(pcm->card->dev, size * 4,
                 &buf->addr, GFP_KERNEL);
         if (!buf->area) {
-                pr_err("Failed to allocate dma memory \
-                        Please increase uncached DMA memory region\n");
+                pr_err("Failed to allocate dma memory - Please increase uncached DMA memory region\n");
                 return -ENOMEM;
         }
         buf->bytes = size;
diff --git a/sound/soc/blackfin/bf5xx-tdm.c b/sound/soc/blackfin/bf5xx-tdm.c
index ff546e91a22e..4b360124083e 100644
--- a/sound/soc/blackfin/bf5xx-tdm.c
+++ b/sound/soc/blackfin/bf5xx-tdm.c
@@ -46,14 +46,6 @@
 #include "bf5xx-sport.h"
 #include "bf5xx-tdm.h"
 
-struct bf5xx_tdm_port {
-        u16 tcr1;
-        u16 rcr1;
-        u16 tcr2;
-        u16 rcr2;
-        int configured;
-};
-
 static struct bf5xx_tdm_port bf5xx_tdm;
 static int sport_num = CONFIG_SND_BF5XX_SPORT_NUM;
 
@@ -181,6 +173,40 @@ static void bf5xx_tdm_shutdown(struct snd_pcm_substream *substream,
                 bf5xx_tdm.configured = 0;
 }
 
+static int bf5xx_tdm_set_channel_map(struct snd_soc_dai *dai,
+                unsigned int tx_num, unsigned int *tx_slot,
+                unsigned int rx_num, unsigned int *rx_slot)
+{
+        int i;
+        unsigned int slot;
+        unsigned int tx_mapped = 0, rx_mapped = 0;
+
+        if ((tx_num > BFIN_TDM_DAI_MAX_SLOTS) ||
+                        (rx_num > BFIN_TDM_DAI_MAX_SLOTS))
+                return -EINVAL;
+
+        for (i = 0; i < tx_num; i++) {
+                slot = tx_slot[i];
+                if ((slot < BFIN_TDM_DAI_MAX_SLOTS) &&
+                                (!(tx_mapped & (1 << slot)))) {
+                        bf5xx_tdm.tx_map[i] = slot;
+                        tx_mapped |= 1 << slot;
+                } else
+                        return -EINVAL;
+        }
+        for (i = 0; i < rx_num; i++) {
+                slot = rx_slot[i];
+                if ((slot < BFIN_TDM_DAI_MAX_SLOTS) &&
+                                (!(rx_mapped & (1 << slot)))) {
+                        bf5xx_tdm.rx_map[i] = slot;
+                        rx_mapped |= 1 << slot;
+                } else
+                        return -EINVAL;
+        }
+
+        return 0;
+}
+
 #ifdef CONFIG_PM
 static int bf5xx_tdm_suspend(struct snd_soc_dai *dai)
 {
@@ -235,6 +261,7 @@ static struct snd_soc_dai_ops bf5xx_tdm_dai_ops = {
         .hw_params      = bf5xx_tdm_hw_params,
         .set_fmt        = bf5xx_tdm_set_dai_fmt,
         .shutdown       = bf5xx_tdm_shutdown,
+        .set_channel_map   = bf5xx_tdm_set_channel_map,
 };
 
 struct snd_soc_dai bf5xx_tdm_dai = {
@@ -300,6 +327,8 @@ static int __devinit bfin_tdm_probe(struct platform_device *pdev)
                 pr_err("Failed to register DAI: %d\n", ret);
                 goto sport_config_err;
         }
+
+        sport_handle->private_data = &bf5xx_tdm;
         return 0;
 
 sport_config_err:
diff --git a/sound/soc/blackfin/bf5xx-tdm.h b/sound/soc/blackfin/bf5xx-tdm.h
index 618ec3d90cd4..04189a18c1ba 100644
--- a/sound/soc/blackfin/bf5xx-tdm.h
+++ b/sound/soc/blackfin/bf5xx-tdm.h
@@ -9,6 +9,17 @@
 #ifndef _BF5XX_TDM_H
 #define _BF5XX_TDM_H
 
+#define BFIN_TDM_DAI_MAX_SLOTS 8
+struct bf5xx_tdm_port {
+        u16 tcr1;
+        u16 rcr1;
+        u16 tcr2;
+        u16 rcr2;
+        unsigned int tx_map[BFIN_TDM_DAI_MAX_SLOTS];
+        unsigned int rx_map[BFIN_TDM_DAI_MAX_SLOTS];
+        int configured;
+};
+
 extern struct snd_soc_dai bf5xx_tdm_dai;
 
 #endif
diff --git a/sound/soc/codecs/Kconfig b/sound/soc/codecs/Kconfig
index 0edca93af3b0..1743d565e996 100644
--- a/sound/soc/codecs/Kconfig
+++ b/sound/soc/codecs/Kconfig
@@ -15,12 +15,15 @@ config SND_SOC_ALL_CODECS
         select SND_SOC_AD1836 if SPI_MASTER
         select SND_SOC_AD1938 if SPI_MASTER
         select SND_SOC_AD1980 if SND_SOC_AC97_BUS
+        select SND_SOC_ADS117X
         select SND_SOC_AD73311 if I2C
         select SND_SOC_AK4104 if SPI_MASTER
         select SND_SOC_AK4535 if I2C
         select SND_SOC_AK4642 if I2C
+        select SND_SOC_AK4671 if I2C
         select SND_SOC_CS4270 if I2C
         select SND_SOC_MAX9877 if I2C
+        select SND_SOC_DA7210 if I2C
         select SND_SOC_PCM3008
         select SND_SOC_SPDIF
         select SND_SOC_SSM2602 if I2C
@@ -28,14 +31,19 @@ config SND_SOC_ALL_CODECS
         select SND_SOC_TLV320AIC23 if I2C
         select SND_SOC_TLV320AIC26 if SPI_MASTER
         select SND_SOC_TLV320AIC3X if I2C
+        select SND_SOC_TPA6130A2 if I2C
+        select SND_SOC_TLV320DAC33 if I2C
         select SND_SOC_TWL4030 if TWL4030_CORE
         select SND_SOC_UDA134X
         select SND_SOC_UDA1380 if I2C
+        select SND_SOC_WM2000 if I2C
         select SND_SOC_WM8350 if MFD_WM8350
         select SND_SOC_WM8400 if MFD_WM8400
         select SND_SOC_WM8510 if SND_SOC_I2C_AND_SPI
         select SND_SOC_WM8523 if I2C
         select SND_SOC_WM8580 if I2C
+        select SND_SOC_WM8711 if SND_SOC_I2C_AND_SPI
+        select SND_SOC_WM8727
         select SND_SOC_WM8728 if SND_SOC_I2C_AND_SPI
         select SND_SOC_WM8731 if SND_SOC_I2C_AND_SPI
         select SND_SOC_WM8750 if SND_SOC_I2C_AND_SPI
@@ -43,14 +51,18 @@ config SND_SOC_ALL_CODECS
         select SND_SOC_WM8776 if SND_SOC_I2C_AND_SPI
         select SND_SOC_WM8900 if I2C
         select SND_SOC_WM8903 if I2C
+        select SND_SOC_WM8904 if I2C
         select SND_SOC_WM8940 if I2C
+        select SND_SOC_WM8955 if I2C
         select SND_SOC_WM8960 if I2C
         select SND_SOC_WM8961 if I2C
         select SND_SOC_WM8971 if I2C
         select SND_SOC_WM8974 if I2C
+        select SND_SOC_WM8978 if I2C
         select SND_SOC_WM8988 if SND_SOC_I2C_AND_SPI
         select SND_SOC_WM8990 if I2C
         select SND_SOC_WM8993 if I2C
+        select SND_SOC_WM8994 if MFD_WM8994
         select SND_SOC_WM9081 if I2C
         select SND_SOC_WM9705 if SND_SOC_AC97_BUS
         select SND_SOC_WM9712 if SND_SOC_AC97_BUS
@@ -86,6 +98,9 @@ config SND_SOC_AD1980
 
 config SND_SOC_AD73311
         tristate
+        
+config SND_SOC_ADS117X
+        tristate
 
 config SND_SOC_AK4104
         tristate
@@ -96,10 +111,16 @@ config SND_SOC_AK4535
 config SND_SOC_AK4642
         tristate
 
+config SND_SOC_AK4671
+        tristate
+
 # Cirrus Logic CS4270 Codec
 config SND_SOC_CS4270
         tristate
 
+config SND_SOC_DA7210
+        tristate
+
 # Cirrus Logic CS4270 Codec VD = 3.3V Errata
 # Select if you are affected by the errata where the part will not function
 # if MCLK divide-by-1.5 is selected and VD is set to 3.3V.  The driver will
@@ -136,7 +157,11 @@ config SND_SOC_TLV320AIC26
 config SND_SOC_TLV320AIC3X
         tristate
 
+config SND_SOC_TLV320DAC33
+        tristate
+
 config SND_SOC_TWL4030
+        select TWL4030_CODEC
         tristate
 
 config SND_SOC_UDA134X
@@ -160,6 +185,12 @@ config SND_SOC_WM8523
 config SND_SOC_WM8580
         tristate
 
+config SND_SOC_WM8711
+        tristate
+
+config SND_SOC_WM8727
+        tristate
+
 config SND_SOC_WM8728
         tristate
 
@@ -181,9 +212,15 @@ config SND_SOC_WM8900
 config SND_SOC_WM8903
         tristate
 
+config SND_SOC_WM8904
+        tristate
+
 config SND_SOC_WM8940
         tristate
 
+config SND_SOC_WM8955
+        tristate
+
 config SND_SOC_WM8960
         tristate
 
@@ -196,6 +233,9 @@ config SND_SOC_WM8971
 config SND_SOC_WM8974
         tristate
 
+config SND_SOC_WM8978
+        tristate
+
 config SND_SOC_WM8988
         tristate
 
@@ -205,6 +245,9 @@ config SND_SOC_WM8990
 config SND_SOC_WM8993
         tristate
 
+config SND_SOC_WM8994
+        tristate
+
 config SND_SOC_WM9081
         tristate
 
@@ -220,3 +263,9 @@ config SND_SOC_WM9713
 # Amp
 config SND_SOC_MAX9877
         tristate
+
+config SND_SOC_TPA6130A2
+        tristate
+
+config SND_SOC_WM2000
+        tristate
diff --git a/sound/soc/codecs/Makefile b/sound/soc/codecs/Makefile
index fb4af28486ba..dd5ce6df6292 100644
--- a/sound/soc/codecs/Makefile
+++ b/sound/soc/codecs/Makefile
@@ -3,11 +3,14 @@ snd-soc-ad1836-objs := ad1836.o
 snd-soc-ad1938-objs := ad1938.o
 snd-soc-ad1980-objs := ad1980.o
 snd-soc-ad73311-objs := ad73311.o
+snd-soc-ads117x-objs := ads117x.o
 snd-soc-ak4104-objs := ak4104.o
 snd-soc-ak4535-objs := ak4535.o
 snd-soc-ak4642-objs := ak4642.o
+snd-soc-ak4671-objs := ak4671.o
 snd-soc-cs4270-objs := cs4270.o
 snd-soc-cx20442-objs := cx20442.o
+snd-soc-da7210-objs := da7210.o
 snd-soc-l3-objs := l3.o
 snd-soc-pcm3008-objs := pcm3008.o
 snd-soc-spdif-objs := spdif_transciever.o
@@ -16,6 +19,7 @@ snd-soc-stac9766-objs := stac9766.o
 snd-soc-tlv320aic23-objs := tlv320aic23.o
 snd-soc-tlv320aic26-objs := tlv320aic26.o
 snd-soc-tlv320aic3x-objs := tlv320aic3x.o
+snd-soc-tlv320dac33-objs := tlv320dac33.o
 snd-soc-twl4030-objs := twl4030.o
 snd-soc-uda134x-objs := uda134x.o
 snd-soc-uda1380-objs := uda1380.o
@@ -24,6 +28,8 @@ snd-soc-wm8400-objs := wm8400.o
 snd-soc-wm8510-objs := wm8510.o
 snd-soc-wm8523-objs := wm8523.o
 snd-soc-wm8580-objs := wm8580.o
+snd-soc-wm8711-objs := wm8711.o
+snd-soc-wm8727-objs := wm8727.o
 snd-soc-wm8728-objs := wm8728.o
 snd-soc-wm8731-objs := wm8731.o
 snd-soc-wm8750-objs := wm8750.o
@@ -31,14 +37,18 @@ snd-soc-wm8753-objs := wm8753.o
 snd-soc-wm8776-objs := wm8776.o
 snd-soc-wm8900-objs := wm8900.o
 snd-soc-wm8903-objs := wm8903.o
+snd-soc-wm8904-objs := wm8904.o
 snd-soc-wm8940-objs := wm8940.o
+snd-soc-wm8955-objs := wm8955.o
 snd-soc-wm8960-objs := wm8960.o
 snd-soc-wm8961-objs := wm8961.o
 snd-soc-wm8971-objs := wm8971.o
 snd-soc-wm8974-objs := wm8974.o
+snd-soc-wm8978-objs := wm8978.o
 snd-soc-wm8988-objs := wm8988.o
 snd-soc-wm8990-objs := wm8990.o
 snd-soc-wm8993-objs := wm8993.o
+snd-soc-wm8994-objs := wm8994.o
 snd-soc-wm9081-objs := wm9081.o
 snd-soc-wm9705-objs := wm9705.o
 snd-soc-wm9712-objs := wm9712.o
@@ -47,17 +57,22 @@ snd-soc-wm-hubs-objs := wm_hubs.o
 
 # Amp
 snd-soc-max9877-objs := max9877.o
+snd-soc-tpa6130a2-objs := tpa6130a2.o
+snd-soc-wm2000-objs := wm2000.o
 
 obj-$(CONFIG_SND_SOC_AC97_CODEC)        += snd-soc-ac97.o
 obj-$(CONFIG_SND_SOC_AD1836)    += snd-soc-ad1836.o
 obj-$(CONFIG_SND_SOC_AD1938)    += snd-soc-ad1938.o
 obj-$(CONFIG_SND_SOC_AD1980)    += snd-soc-ad1980.o
 obj-$(CONFIG_SND_SOC_AD73311) += snd-soc-ad73311.o
+obj-$(CONFIG_SND_SOC_ADS117X)   += snd-soc-ads117x.o
 obj-$(CONFIG_SND_SOC_AK4104)    += snd-soc-ak4104.o
 obj-$(CONFIG_SND_SOC_AK4535)    += snd-soc-ak4535.o
 obj-$(CONFIG_SND_SOC_AK4642)    += snd-soc-ak4642.o
+obj-$(CONFIG_SND_SOC_AK4671)    += snd-soc-ak4671.o
 obj-$(CONFIG_SND_SOC_CS4270)    += snd-soc-cs4270.o
 obj-$(CONFIG_SND_SOC_CX20442)   += snd-soc-cx20442.o
+obj-$(CONFIG_SND_SOC_DA7210)    += snd-soc-da7210.o
 obj-$(CONFIG_SND_SOC_L3)        += snd-soc-l3.o
 obj-$(CONFIG_SND_SOC_PCM3008)   += snd-soc-pcm3008.o
 obj-$(CONFIG_SND_SOC_SPDIF)     += snd-soc-spdif.o
@@ -66,6 +81,7 @@ obj-$(CONFIG_SND_SOC_STAC9766)	+= snd-soc-stac9766.o
 obj-$(CONFIG_SND_SOC_TLV320AIC23)       += snd-soc-tlv320aic23.o
 obj-$(CONFIG_SND_SOC_TLV320AIC26)       += snd-soc-tlv320aic26.o
 obj-$(CONFIG_SND_SOC_TLV320AIC3X)       += snd-soc-tlv320aic3x.o
+obj-$(CONFIG_SND_SOC_TLV320DAC33)       += snd-soc-tlv320dac33.o
 obj-$(CONFIG_SND_SOC_TWL4030)   += snd-soc-twl4030.o
 obj-$(CONFIG_SND_SOC_UDA134X)   += snd-soc-uda134x.o
 obj-$(CONFIG_SND_SOC_UDA1380)   += snd-soc-uda1380.o
@@ -74,6 +90,8 @@ obj-$(CONFIG_SND_SOC_WM8400)	+= snd-soc-wm8400.o
 obj-$(CONFIG_SND_SOC_WM8510)    += snd-soc-wm8510.o
 obj-$(CONFIG_SND_SOC_WM8523)    += snd-soc-wm8523.o
 obj-$(CONFIG_SND_SOC_WM8580)    += snd-soc-wm8580.o
+obj-$(CONFIG_SND_SOC_WM8711)    += snd-soc-wm8711.o
+obj-$(CONFIG_SND_SOC_WM8727)    += snd-soc-wm8727.o
 obj-$(CONFIG_SND_SOC_WM8728)    += snd-soc-wm8728.o
 obj-$(CONFIG_SND_SOC_WM8731)    += snd-soc-wm8731.o
 obj-$(CONFIG_SND_SOC_WM8750)    += snd-soc-wm8750.o
@@ -81,14 +99,18 @@ obj-$(CONFIG_SND_SOC_WM8753)	+= snd-soc-wm8753.o
 obj-$(CONFIG_SND_SOC_WM8776)    += snd-soc-wm8776.o
 obj-$(CONFIG_SND_SOC_WM8900)    += snd-soc-wm8900.o
 obj-$(CONFIG_SND_SOC_WM8903)    += snd-soc-wm8903.o
-obj-$(CONFIG_SND_SOC_WM8971)    += snd-soc-wm8971.o
-obj-$(CONFIG_SND_SOC_WM8974)    += snd-soc-wm8974.o
+obj-$(CONFIG_SND_SOC_WM8904)    += snd-soc-wm8904.o
 obj-$(CONFIG_SND_SOC_WM8940)    += snd-soc-wm8940.o
+obj-$(CONFIG_SND_SOC_WM8955)    += snd-soc-wm8955.o
 obj-$(CONFIG_SND_SOC_WM8960)    += snd-soc-wm8960.o
 obj-$(CONFIG_SND_SOC_WM8961)    += snd-soc-wm8961.o
+obj-$(CONFIG_SND_SOC_WM8971)    += snd-soc-wm8971.o
+obj-$(CONFIG_SND_SOC_WM8974)    += snd-soc-wm8974.o
+obj-$(CONFIG_SND_SOC_WM8978)    += snd-soc-wm8978.o
 obj-$(CONFIG_SND_SOC_WM8988)    += snd-soc-wm8988.o
 obj-$(CONFIG_SND_SOC_WM8990)    += snd-soc-wm8990.o
 obj-$(CONFIG_SND_SOC_WM8993)    += snd-soc-wm8993.o
+obj-$(CONFIG_SND_SOC_WM8994)    += snd-soc-wm8994.o
 obj-$(CONFIG_SND_SOC_WM9081)    += snd-soc-wm9081.o
 obj-$(CONFIG_SND_SOC_WM9705)    += snd-soc-wm9705.o
 obj-$(CONFIG_SND_SOC_WM9712)    += snd-soc-wm9712.o
@@ -97,3 +119,5 @@ obj-$(CONFIG_SND_SOC_WM_HUBS)	+= snd-soc-wm-hubs.o
 
 # Amp
 obj-$(CONFIG_SND_SOC_MAX9877)   += snd-soc-max9877.o
+obj-$(CONFIG_SND_SOC_TPA6130A2) += snd-soc-tpa6130a2.o
+obj-$(CONFIG_SND_SOC_WM2000)    += snd-soc-wm2000.o
diff --git a/sound/soc/codecs/ac97.c b/sound/soc/codecs/ac97.c
index 932299bb5d1e..1f5e57a4bb7a 100644
--- a/sound/soc/codecs/ac97.c
+++ b/sound/soc/codecs/ac97.c
@@ -13,6 +13,7 @@
  */
 
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <linux/kernel.h>
 #include <linux/device.h>
 #include <sound/core.h>
@@ -80,9 +81,11 @@ static int ac97_write(struct snd_soc_codec *codec, unsigned int reg,
 static int ac97_soc_probe(struct platform_device *pdev)
 {
         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_card *card = socdev->card;
         struct snd_soc_codec *codec;
         struct snd_ac97_bus *ac97_bus;
         struct snd_ac97_template ac97_template;
+        int i;
         int ret = 0;
 
         printk(KERN_INFO "AC97 SoC Audio Codec %s\n", AC97_VERSION);
@@ -117,9 +120,13 @@ static int ac97_soc_probe(struct platform_device *pdev)
         if (ret < 0)
                 goto bus_err;
 
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0)
-                goto bus_err;
+        for (i = 0; i < card->num_links; i++) {
+                if (card->dai_link[i].codec_dai->ac97_control) {
+                        snd_ac97_dev_add_pdata(codec->ac97,
+                                card->dai_link[i].cpu_dai->ac97_pdata);
+                }
+        }
+
         return 0;
 
 bus_err:
diff --git a/sound/soc/codecs/ad1836.c b/sound/soc/codecs/ad1836.c
index c48485f2c55d..11b62dee842c 100644
--- a/sound/soc/codecs/ad1836.c
+++ b/sound/soc/codecs/ad1836.c
@@ -17,6 +17,7 @@
  */
 
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/device.h>
@@ -171,57 +172,35 @@ static int ad1836_hw_params(struct snd_pcm_substream *substream,
         return 0;
 }
 
-
-/*
- * interface to read/write ad1836 register
- */
-#define AD1836_SPI_REG_SHFT 12
-#define AD1836_SPI_READ     (1 << 11)
-#define AD1836_SPI_VAL_MSK  0x3FF
-
-/*
- * write to the ad1836 register space
- */
-
-static int ad1836_write_reg(struct snd_soc_codec *codec, unsigned int reg,
-                unsigned int value)
+#ifdef CONFIG_PM
+static int ad1836_soc_suspend(struct platform_device *pdev,
+                pm_message_t state)
 {
-        u16 *reg_cache = codec->reg_cache;
-        int ret = 0;
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec = socdev->card->codec;
 
-        if (value != reg_cache[reg]) {
-                unsigned short buf;
-                struct spi_transfer t = {
-                        .tx_buf = &buf,
-                        .len = 2,
-                };
-                struct spi_message m;
-
-                buf = (reg << AD1836_SPI_REG_SHFT) |
-                        (value & AD1836_SPI_VAL_MSK);
-                spi_message_init(&m);
-                spi_message_add_tail(&t, &m);
-                ret = spi_sync(codec->control_data, &m);
-                if (ret == 0)
-                        reg_cache[reg] = value;
-        }
+        /* reset clock control mode */
+        u16 adc_ctrl2 = snd_soc_read(codec, AD1836_ADC_CTRL2);
+        adc_ctrl2 &= ~AD1836_ADC_SERFMT_MASK;
 
-        return ret;
+        return snd_soc_write(codec, AD1836_ADC_CTRL2, adc_ctrl2);
 }
 
-/*
- * read from the ad1836 register space cache
- */
-static unsigned int ad1836_read_reg_cache(struct snd_soc_codec *codec,
-                                          unsigned int reg)
+static int ad1836_soc_resume(struct platform_device *pdev)
 {
-        u16 *reg_cache = codec->reg_cache;
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec = socdev->card->codec;
 
-        if (reg >= codec->reg_cache_size)
-                return -EINVAL;
+        /* restore clock control mode */
+        u16 adc_ctrl2 = snd_soc_read(codec, AD1836_ADC_CTRL2);
+        adc_ctrl2 |= AD1836_ADC_AUX;
 
-        return reg_cache[reg];
+        return snd_soc_write(codec, AD1836_ADC_CTRL2, adc_ctrl2);
 }
+#else
+#define ad1836_soc_suspend NULL
+#define ad1836_soc_resume  NULL
+#endif
 
 static int __devinit ad1836_spi_probe(struct spi_device *spi)
 {
@@ -306,32 +285,38 @@ static int ad1836_register(struct ad1836_priv *ad1836)
         codec->owner = THIS_MODULE;
         codec->dai = &ad1836_dai;
         codec->num_dai = 1;
-        codec->write = ad1836_write_reg;
-        codec->read = ad1836_read_reg_cache;
         INIT_LIST_HEAD(&codec->dapm_widgets);
         INIT_LIST_HEAD(&codec->dapm_paths);
 
         ad1836_dai.dev = codec->dev;
         ad1836_codec = codec;
 
+        ret = snd_soc_codec_set_cache_io(codec, 4, 12, SND_SOC_SPI);
+        if (ret < 0) {
+                dev_err(codec->dev, "failed to set cache I/O: %d\n",
+                                ret);
+                kfree(ad1836);
+                return ret;
+        }
+
         /* default setting for ad1836 */
         /* de-emphasis: 48kHz, power-on dac */
-        codec->write(codec, AD1836_DAC_CTRL1, 0x300);
+        snd_soc_write(codec, AD1836_DAC_CTRL1, 0x300);
         /* unmute dac channels */
-        codec->write(codec, AD1836_DAC_CTRL2, 0x0);
+        snd_soc_write(codec, AD1836_DAC_CTRL2, 0x0);
         /* high-pass filter enable, power-on adc */
-        codec->write(codec, AD1836_ADC_CTRL1, 0x100);
+        snd_soc_write(codec, AD1836_ADC_CTRL1, 0x100);
         /* unmute adc channles, adc aux mode */
-        codec->write(codec, AD1836_ADC_CTRL2, 0x180);
+        snd_soc_write(codec, AD1836_ADC_CTRL2, 0x180);
         /* left/right diff:PGA/MUX */
-        codec->write(codec, AD1836_ADC_CTRL3, 0x3A);
+        snd_soc_write(codec, AD1836_ADC_CTRL3, 0x3A);
         /* volume */
-        codec->write(codec, AD1836_DAC_L1_VOL, 0x3FF);
-        codec->write(codec, AD1836_DAC_R1_VOL, 0x3FF);
-        codec->write(codec, AD1836_DAC_L2_VOL, 0x3FF);
-        codec->write(codec, AD1836_DAC_R2_VOL, 0x3FF);
-        codec->write(codec, AD1836_DAC_L3_VOL, 0x3FF);
-        codec->write(codec, AD1836_DAC_R3_VOL, 0x3FF);
+        snd_soc_write(codec, AD1836_DAC_L1_VOL, 0x3FF);
+        snd_soc_write(codec, AD1836_DAC_R1_VOL, 0x3FF);
+        snd_soc_write(codec, AD1836_DAC_L2_VOL, 0x3FF);
+        snd_soc_write(codec, AD1836_DAC_R2_VOL, 0x3FF);
+        snd_soc_write(codec, AD1836_DAC_L3_VOL, 0x3FF);
+        snd_soc_write(codec, AD1836_DAC_R3_VOL, 0x3FF);
 
         ret = snd_soc_register_codec(codec);
         if (ret != 0) {
@@ -385,19 +370,7 @@ static int ad1836_probe(struct platform_device *pdev)
         snd_soc_dapm_new_controls(codec, ad1836_dapm_widgets,
                                   ARRAY_SIZE(ad1836_dapm_widgets));
         snd_soc_dapm_add_routes(codec, audio_paths, ARRAY_SIZE(audio_paths));
-        snd_soc_dapm_new_widgets(codec);
 
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                dev_err(codec->dev, "failed to register card: %d\n", ret);
-                goto card_err;
-        }
-
-        return ret;
-
-card_err:
-        snd_soc_free_pcms(socdev);
-        snd_soc_dapm_free(socdev);
 pcm_err:
         return ret;
 }
@@ -416,6 +389,8 @@ static int ad1836_remove(struct platform_device *pdev)
 struct snd_soc_codec_device soc_codec_dev_ad1836 = {
         .probe =        ad1836_probe,
         .remove =       ad1836_remove,
+        .suspend =      ad1836_soc_suspend,
+        .resume =       ad1836_soc_resume,
 };
 EXPORT_SYMBOL_GPL(soc_codec_dev_ad1836);
 
diff --git a/sound/soc/codecs/ad1836.h b/sound/soc/codecs/ad1836.h
index 7660ee6973c0..e9d90d3951c5 100644
--- a/sound/soc/codecs/ad1836.h
+++ b/sound/soc/codecs/ad1836.h
@@ -54,6 +54,7 @@
 #define AD1836_ADC_SERFMT_MASK         (7 << 6)
 #define AD1836_ADC_SERFMT_PCK256       (0x4 << 6)
 #define AD1836_ADC_SERFMT_PCK128       (0x5 << 6)
+#define AD1836_ADC_AUX                 (0x6 << 6)
 
 #define AD1836_ADC_CTRL3               14
 
diff --git a/sound/soc/codecs/ad1938.c b/sound/soc/codecs/ad1938.c
index 34b30efc3cb0..240cd155b313 100644
--- a/sound/soc/codecs/ad1938.c
+++ b/sound/soc/codecs/ad1938.c
@@ -27,6 +27,7 @@
  */
 
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/device.h>
@@ -46,6 +47,11 @@ struct ad1938_priv {
         u8 reg_cache[AD1938_NUM_REGS];
 };
 
+/* ad1938 register cache & default register settings */
+static const u8 ad1938_reg[AD1938_NUM_REGS] = {
+        0, 0, 0, 0, 0, 0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0, 0, 0,
+};
+
 static struct snd_soc_codec *ad1938_codec;
 struct snd_soc_codec_device soc_codec_dev_ad1938;
 static int ad1938_register(struct ad1938_priv *ad1938);
@@ -97,6 +103,7 @@ static const struct snd_kcontrol_new ad1938_snd_controls[] = {
 static const struct snd_soc_dapm_widget ad1938_dapm_widgets[] = {
         SND_SOC_DAPM_DAC("DAC", "Playback", AD1938_DAC_CTRL0, 0, 1),
         SND_SOC_DAPM_ADC("ADC", "Capture", SND_SOC_NOPM, 0, 0),
+        SND_SOC_DAPM_SUPPLY("PLL_PWR", AD1938_PLL_CLK_CTRL0, 0, 1, NULL, 0),
         SND_SOC_DAPM_SUPPLY("ADC_PWR", AD1938_ADC_CTRL0, 0, 1, NULL, 0),
         SND_SOC_DAPM_OUTPUT("DAC1OUT"),
         SND_SOC_DAPM_OUTPUT("DAC2OUT"),
@@ -107,6 +114,8 @@ static const struct snd_soc_dapm_widget ad1938_dapm_widgets[] = {
 };
 
 static const struct snd_soc_dapm_route audio_paths[] = {
+        { "DAC", NULL, "PLL_PWR" },
+        { "ADC", NULL, "PLL_PWR" },
         { "DAC", NULL, "ADC_PWR" },
         { "ADC", NULL, "ADC_PWR" },
         { "DAC1OUT", "DAC1 Switch", "DAC" },
@@ -126,30 +135,20 @@ static int ad1938_mute(struct snd_soc_dai *dai, int mute)
         struct snd_soc_codec *codec = dai->codec;
         int reg;
 
-        reg = codec->read(codec, AD1938_DAC_CTRL2);
+        reg = snd_soc_read(codec, AD1938_DAC_CTRL2);
         reg = (mute > 0) ? reg | AD1938_DAC_MASTER_MUTE : reg &
                 (~AD1938_DAC_MASTER_MUTE);
-        codec->write(codec, AD1938_DAC_CTRL2, reg);
-
-        return 0;
-}
-
-static inline int ad1938_pll_powerctrl(struct snd_soc_codec *codec, int cmd)
-{
-        int reg = codec->read(codec, AD1938_PLL_CLK_CTRL0);
-        reg = (cmd > 0) ? reg & (~AD1938_PLL_POWERDOWN) : reg |
-                AD1938_PLL_POWERDOWN;
-        codec->write(codec, AD1938_PLL_CLK_CTRL0, reg);
+        snd_soc_write(codec, AD1938_DAC_CTRL2, reg);
 
         return 0;
 }
 
 static int ad1938_set_tdm_slot(struct snd_soc_dai *dai, unsigned int tx_mask,
-                               unsigned int mask, int slots, int width)
+                               unsigned int rx_mask, int slots, int width)
 {
         struct snd_soc_codec *codec = dai->codec;
-        int dac_reg = codec->read(codec, AD1938_DAC_CTRL1);
-        int adc_reg = codec->read(codec, AD1938_ADC_CTRL2);
+        int dac_reg = snd_soc_read(codec, AD1938_DAC_CTRL1);
+        int adc_reg = snd_soc_read(codec, AD1938_ADC_CTRL2);
 
         dac_reg &= ~AD1938_DAC_CHAN_MASK;
         adc_reg &= ~AD1938_ADC_CHAN_MASK;
@@ -175,8 +174,8 @@ static int ad1938_set_tdm_slot(struct snd_soc_dai *dai, unsigned int tx_mask,
                 return -EINVAL;
         }
 
-        codec->write(codec, AD1938_DAC_CTRL1, dac_reg);
-        codec->write(codec, AD1938_ADC_CTRL2, adc_reg);
+        snd_soc_write(codec, AD1938_DAC_CTRL1, dac_reg);
+        snd_soc_write(codec, AD1938_ADC_CTRL2, adc_reg);
 
         return 0;
 }
@@ -187,8 +186,8 @@ static int ad1938_set_dai_fmt(struct snd_soc_dai *codec_dai,
         struct snd_soc_codec *codec = codec_dai->codec;
         int adc_reg, dac_reg;
 
-        adc_reg = codec->read(codec, AD1938_ADC_CTRL2);
-        dac_reg = codec->read(codec, AD1938_DAC_CTRL1);
+        adc_reg = snd_soc_read(codec, AD1938_ADC_CTRL2);
+        dac_reg = snd_soc_read(codec, AD1938_DAC_CTRL1);
 
         /* At present, the driver only support AUX ADC mode(SND_SOC_DAIFMT_I2S
          * with TDM) and ADC&DAC TDM mode(SND_SOC_DAIFMT_DSP_A)
@@ -265,8 +264,8 @@ static int ad1938_set_dai_fmt(struct snd_soc_dai *codec_dai,
                 return -EINVAL;
         }
 
-        codec->write(codec, AD1938_ADC_CTRL2, adc_reg);
-        codec->write(codec, AD1938_DAC_CTRL1, dac_reg);
+        snd_soc_write(codec, AD1938_ADC_CTRL2, adc_reg);
+        snd_soc_write(codec, AD1938_DAC_CTRL1, dac_reg);
 
         return 0;
 }
@@ -295,134 +294,13 @@ static int ad1938_hw_params(struct snd_pcm_substream *substream,
                 break;
         }
 
-        reg = codec->read(codec, AD1938_DAC_CTRL2);
+        reg = snd_soc_read(codec, AD1938_DAC_CTRL2);
         reg = (reg & (~AD1938_DAC_WORD_LEN_MASK)) | word_len;
-        codec->write(codec, AD1938_DAC_CTRL2, reg);
+        snd_soc_write(codec, AD1938_DAC_CTRL2, reg);
 
-        reg = codec->read(codec, AD1938_ADC_CTRL1);
+        reg = snd_soc_read(codec, AD1938_ADC_CTRL1);
         reg = (reg & (~AD1938_ADC_WORD_LEN_MASK)) | word_len;
-        codec->write(codec, AD1938_ADC_CTRL1, reg);
-
-        return 0;
-}
-
-static int ad1938_set_bias_level(struct snd_soc_codec *codec,
-                enum snd_soc_bias_level level)
-{
-        switch (level) {
-        case SND_SOC_BIAS_ON:
-                ad1938_pll_powerctrl(codec, 1);
-                break;
-        case SND_SOC_BIAS_PREPARE:
-                break;
-        case SND_SOC_BIAS_STANDBY:
-        case SND_SOC_BIAS_OFF:
-                ad1938_pll_powerctrl(codec, 0);
-                break;
-        }
-        codec->bias_level = level;
-        return 0;
-}
-
-/*
- * interface to read/write ad1938 register
- */
-
-#define AD1938_SPI_ADDR    0x4
-#define AD1938_SPI_READ    0x1
-#define AD1938_SPI_BUFLEN  3
-
-/*
- * write to the ad1938 register space
- */
-
-static int ad1938_write_reg(struct snd_soc_codec *codec, unsigned int reg,
-                unsigned int value)
-{
-        u8 *reg_cache = codec->reg_cache;
-        int ret = 0;
-
-        if (value != reg_cache[reg]) {
-                uint8_t buf[AD1938_SPI_BUFLEN];
-                struct spi_transfer t = {
-                        .tx_buf = buf,
-                        .len = AD1938_SPI_BUFLEN,
-                };
-                struct spi_message m;
-
-                buf[0] = AD1938_SPI_ADDR << 1;
-                buf[1] = reg;
-                buf[2] = value;
-                spi_message_init(&m);
-                spi_message_add_tail(&t, &m);
-                ret = spi_sync(codec->control_data, &m);
-                if (ret == 0)
-                        reg_cache[reg] = value;
-        }
-
-        return ret;
-}
-
-/*
- * read from the ad1938 register space cache
- */
-
-static unsigned int ad1938_read_reg_cache(struct snd_soc_codec *codec,
-                                          unsigned int reg)
-{
-        u8 *reg_cache = codec->reg_cache;
-
-        if (reg >= codec->reg_cache_size)
-                return -EINVAL;
-
-        return reg_cache[reg];
-}
-
-/*
- * read from the ad1938 register space
- */
-
-static unsigned int ad1938_read_reg(struct snd_soc_codec *codec,
-                                                unsigned int reg)
-{
-        char w_buf[AD1938_SPI_BUFLEN];
-        char r_buf[AD1938_SPI_BUFLEN];
-        int ret;
-
-        struct spi_transfer t = {
-                .tx_buf = w_buf,
-                .rx_buf = r_buf,
-                .len = AD1938_SPI_BUFLEN,
-        };
-        struct spi_message m;
-
-        w_buf[0] = (AD1938_SPI_ADDR << 1) | AD1938_SPI_READ;
-        w_buf[1] = reg;
-        w_buf[2] = 0;
-
-        spi_message_init(&m);
-        spi_message_add_tail(&t, &m);
-        ret = spi_sync(codec->control_data, &m);
-        if (ret == 0)
-                return  r_buf[2];
-        else
-                return -EIO;
-}
-
-static int ad1938_fill_cache(struct snd_soc_codec *codec)
-{
-        int i;
-        u8 *reg_cache = codec->reg_cache;
-        struct spi_device *spi = codec->control_data;
-
-        for (i = 0; i < codec->reg_cache_size; i++) {
-                int ret = ad1938_read_reg(codec, i);
-                if (ret == -EIO) {
-                        dev_err(&spi->dev, "AD1938 SPI read failure\n");
-                        return ret;
-                }
-                reg_cache[i] = ret;
-        }
+        snd_soc_write(codec, AD1938_ADC_CTRL1, reg);
 
         return 0;
 }
@@ -512,32 +390,37 @@ static int ad1938_register(struct ad1938_priv *ad1938)
         codec->owner = THIS_MODULE;
         codec->dai = &ad1938_dai;
         codec->num_dai = 1;
-        codec->write = ad1938_write_reg;
-        codec->read = ad1938_read_reg_cache;
-        codec->set_bias_level = ad1938_set_bias_level;
         INIT_LIST_HEAD(&codec->dapm_widgets);
         INIT_LIST_HEAD(&codec->dapm_paths);
 
         ad1938_dai.dev = codec->dev;
         ad1938_codec = codec;
 
+        memcpy(codec->reg_cache, ad1938_reg, AD1938_NUM_REGS);
+
+        ret = snd_soc_codec_set_cache_io(codec, 16, 8, SND_SOC_SPI);
+        if (ret < 0) {
+                dev_err(codec->dev, "failed to set cache I/O: %d\n",
+                                ret);
+                kfree(ad1938);
+                return ret;
+        }
+
         /* default setting for ad1938 */
 
         /* unmute dac channels */
-        codec->write(codec, AD1938_DAC_CHNL_MUTE, 0x0);
+        snd_soc_write(codec, AD1938_DAC_CHNL_MUTE, 0x0);
         /* de-emphasis: 48kHz, powedown dac */
-        codec->write(codec, AD1938_DAC_CTRL2, 0x1A);
+        snd_soc_write(codec, AD1938_DAC_CTRL2, 0x1A);
         /* powerdown dac, dac in tdm mode */
-        codec->write(codec, AD1938_DAC_CTRL0, 0x41);
+        snd_soc_write(codec, AD1938_DAC_CTRL0, 0x41);
         /* high-pass filter enable */
-        codec->write(codec, AD1938_ADC_CTRL0, 0x3);
+        snd_soc_write(codec, AD1938_ADC_CTRL0, 0x3);
         /* sata delay=1, adc aux mode */
-        codec->write(codec, AD1938_ADC_CTRL1, 0x43);
+        snd_soc_write(codec, AD1938_ADC_CTRL1, 0x43);
         /* pll input: mclki/xi */
-        codec->write(codec, AD1938_PLL_CLK_CTRL0, 0x9D);
-        codec->write(codec, AD1938_PLL_CLK_CTRL1, 0x04);
-
-        ad1938_fill_cache(codec);
+        snd_soc_write(codec, AD1938_PLL_CLK_CTRL0, 0x9D);
+        snd_soc_write(codec, AD1938_PLL_CLK_CTRL1, 0x04);
 
         ret = snd_soc_register_codec(codec);
         if (ret != 0) {
@@ -559,7 +442,6 @@ static int ad1938_register(struct ad1938_priv *ad1938)
 
 static void ad1938_unregister(struct ad1938_priv *ad1938)
 {
-        ad1938_set_bias_level(&ad1938->codec, SND_SOC_BIAS_OFF);
         snd_soc_unregister_dai(&ad1938_dai);
         snd_soc_unregister_codec(&ad1938->codec);
         kfree(ad1938);
@@ -592,21 +474,8 @@ static int ad1938_probe(struct platform_device *pdev)
         snd_soc_dapm_new_controls(codec, ad1938_dapm_widgets,
                                   ARRAY_SIZE(ad1938_dapm_widgets));
         snd_soc_dapm_add_routes(codec, audio_paths, ARRAY_SIZE(audio_paths));
-        snd_soc_dapm_new_widgets(codec);
 
-        ad1938_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
 
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                dev_err(codec->dev, "failed to register card: %d\n", ret);
-                goto card_err;
-        }
-
-        return ret;
-
-card_err:
-        snd_soc_free_pcms(socdev);
-        snd_soc_dapm_free(socdev);
 pcm_err:
         return ret;
 }
@@ -622,37 +491,9 @@ static int ad1938_remove(struct platform_device *pdev)
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int ad1938_suspend(struct platform_device *pdev,
-                pm_message_t state)
-{
-        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
-        struct snd_soc_codec *codec = socdev->card->codec;
-
-        ad1938_set_bias_level(codec, SND_SOC_BIAS_OFF);
-        return 0;
-}
-
-static int ad1938_resume(struct platform_device *pdev)
-{
-        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
-        struct snd_soc_codec *codec = socdev->card->codec;
-
-        if (codec->suspend_bias_level == SND_SOC_BIAS_ON)
-                ad1938_set_bias_level(codec, SND_SOC_BIAS_ON);
-
-        return 0;
-}
-#else
-#define ad1938_suspend NULL
-#define ad1938_resume NULL
-#endif
-
 struct snd_soc_codec_device soc_codec_dev_ad1938 = {
         .probe =        ad1938_probe,
         .remove =       ad1938_remove,
-        .suspend =      ad1938_suspend,
-        .resume =       ad1938_resume,
 };
 EXPORT_SYMBOL_GPL(soc_codec_dev_ad1938);
 
diff --git a/sound/soc/codecs/ad1980.c b/sound/soc/codecs/ad1980.c
index d7440a982d22..042072738cdc 100644
--- a/sound/soc/codecs/ad1980.c
+++ b/sound/soc/codecs/ad1980.c
@@ -12,6 +12,7 @@
  */
 
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/device.h>
@@ -257,11 +258,6 @@ static int ad1980_soc_probe(struct platform_device *pdev)
 
         snd_soc_add_controls(codec, ad1980_snd_ac97_controls,
                                 ARRAY_SIZE(ad1980_snd_ac97_controls));
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                printk(KERN_ERR "ad1980: failed to register card\n");
-                goto reset_err;
-        }
 
         return 0;
 
diff --git a/sound/soc/codecs/ad73311.c b/sound/soc/codecs/ad73311.c
index e61dac5e7b8f..475807bea2c2 100644
--- a/sound/soc/codecs/ad73311.c
+++ b/sound/soc/codecs/ad73311.c
@@ -11,6 +11,7 @@
  */
 
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/device.h>
@@ -64,16 +65,8 @@ static int ad73311_soc_probe(struct platform_device *pdev)
                 goto pcm_err;
         }
 
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                printk(KERN_ERR "ad73311: failed to register card\n");
-                goto register_err;
-        }
-
         return ret;
 
-register_err:
-        snd_soc_free_pcms(socdev);
 pcm_err:
         kfree(socdev->card->codec);
         socdev->card->codec = NULL;
diff --git a/sound/soc/codecs/ads117x.c b/sound/soc/codecs/ads117x.c
new file mode 100644
index 000000000000..f8e75edb27b7
--- /dev/null
+++ b/sound/soc/codecs/ads117x.c
@@ -0,0 +1,124 @@
+/*
+ * ads117x.c  --  Driver for ads1174/8 ADC chips
+ *
+ * Copyright 2009 ShotSpotter Inc.
+ * Author: Graeme Gregory <gg@slimlogic.co.uk>
+ *
+ *  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 the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ */
+
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/init.h>
+#include <linux/device.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/initval.h>
+#include <sound/soc.h>
+
+#include "ads117x.h"
+
+#define ADS117X_RATES (SNDRV_PCM_RATE_8000_48000)
+
+#define ADS117X_FORMATS (SNDRV_PCM_FMTBIT_S16_LE)
+
+struct snd_soc_dai ads117x_dai = {
+/* ADC */
+        .name = "ADS117X ADC",
+        .id = 1,
+        .capture = {
+                .stream_name = "Capture",
+                .channels_min = 1,
+                .channels_max = 32,
+                .rates = ADS117X_RATES,
+                .formats = ADS117X_FORMATS,},
+};
+EXPORT_SYMBOL_GPL(ads117x_dai);
+
+static int ads117x_probe(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec;
+        int ret;
+
+        codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
+        if (codec == NULL)
+                return -ENOMEM;
+
+        socdev->card->codec = codec;
+        mutex_init(&codec->mutex);
+        INIT_LIST_HEAD(&codec->dapm_widgets);
+        INIT_LIST_HEAD(&codec->dapm_paths);
+        codec->name = "ADS117X";
+        codec->owner = THIS_MODULE;
+        codec->dai = &ads117x_dai;
+        codec->num_dai = 1;
+
+        /* register pcms */
+        ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
+        if (ret < 0) {
+                printk(KERN_ERR "ads117x: failed to create pcms\n");
+                kfree(codec);
+                return ret;
+        }
+
+        return 0;
+}
+
+static int ads117x_remove(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec = socdev->card->codec;
+
+        snd_soc_free_pcms(socdev);
+        kfree(codec);
+
+        return 0;
+}
+
+struct snd_soc_codec_device soc_codec_dev_ads117x = {
+        .probe =        ads117x_probe,
+        .remove =       ads117x_remove,
+};
+EXPORT_SYMBOL_GPL(soc_codec_dev_ads117x);
+
+static __devinit int ads117x_platform_probe(struct platform_device *pdev)
+{
+        ads117x_dai.dev = &pdev->dev;
+        return snd_soc_register_dai(&ads117x_dai);
+}
+
+static int __devexit ads117x_platform_remove(struct platform_device *pdev)
+{
+        snd_soc_unregister_dai(&ads117x_dai);
+        return 0;
+}
+
+static struct platform_driver ads117x_codec_driver = {
+        .driver = {
+                        .name = "ads117x",
+                        .owner = THIS_MODULE,
+        },
+
+        .probe = ads117x_platform_probe,
+        .remove = __devexit_p(ads117x_platform_remove),
+};
+
+static int __init ads117x_init(void)
+{
+        return platform_driver_register(&ads117x_codec_driver);
+}
+module_init(ads117x_init);
+
+static void __exit ads117x_exit(void)
+{
+        platform_driver_unregister(&ads117x_codec_driver);
+}
+module_exit(ads117x_exit);
+
+MODULE_DESCRIPTION("ASoC ads117x driver");
+MODULE_AUTHOR("Graeme Gregory");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/codecs/ads117x.h b/sound/soc/codecs/ads117x.h
new file mode 100644
index 000000000000..dbcf50ec9bd1
--- /dev/null
+++ b/sound/soc/codecs/ads117x.h
@@ -0,0 +1,13 @@
+/*
+ * ads117x.h  --  Driver for ads1174/8 ADC chips
+ *
+ * Copyright 2009 ShotSpotter Inc.
+ * Author: Graeme Gregory <gg@slimlogic.co.uk>
+ *
+ *  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 the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ */
+extern struct snd_soc_dai ads117x_dai;
+extern struct snd_soc_codec_device soc_codec_dev_ads117x;
diff --git a/sound/soc/codecs/ak4104.c b/sound/soc/codecs/ak4104.c
index 4d47bc4f7428..bdeb10dfd887 100644
--- a/sound/soc/codecs/ak4104.c
+++ b/sound/soc/codecs/ak4104.c
@@ -10,6 +10,7 @@
  */
 
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/soc.h>
 #include <sound/initval.h>
@@ -90,12 +91,10 @@ static int ak4104_spi_write(struct snd_soc_codec *codec, unsigned int reg,
         if (reg >= codec->reg_cache_size)
                 return -EINVAL;
 
-        reg &= AK4104_REG_MASK;
-        reg |= AK4104_WRITE;
-
         /* only write to the hardware if value has changed */
         if (cache[reg] != value) {
-                u8 tmp[2] = { reg, value };
+                u8 tmp[2] = { (reg & AK4104_REG_MASK) | AK4104_WRITE, value };
+
                 if (spi_write(spi, tmp, sizeof(tmp))) {
                         dev_err(&spi->dev, "SPI write failed\n");
                         return -EIO;
@@ -185,9 +184,7 @@ struct snd_soc_dai ak4104_dai = {
                 .stream_name = "Playback",
                 .channels_min = 2,
                 .channels_max = 2,
-                .rates = SNDRV_PCM_RATE_44100 |
-                         SNDRV_PCM_RATE_48000 |
-                         SNDRV_PCM_RATE_32000,
+                .rates = SNDRV_PCM_RATE_8000_192000,
                 .formats = SNDRV_PCM_FMTBIT_S16_LE  |
                            SNDRV_PCM_FMTBIT_S24_3LE |
                            SNDRV_PCM_FMTBIT_S24_LE
@@ -313,14 +310,6 @@ static int ak4104_probe(struct platform_device *pdev)
                 return ret;
         }
 
-        /* Register the socdev */
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                dev_err(codec->dev, "failed to register card\n");
-                snd_soc_free_pcms(socdev);
-                return ret;
-        }
-
         return 0;
 }
 
diff --git a/sound/soc/codecs/ak4535.c b/sound/soc/codecs/ak4535.c
index 0abec0d29a96..352d1d08dbd9 100644
--- a/sound/soc/codecs/ak4535.c
+++ b/sound/soc/codecs/ak4535.c
@@ -19,6 +19,7 @@
 #include <linux/pm.h>
 #include <linux/i2c.h>
 #include <linux/platform_device.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
@@ -294,7 +295,6 @@ static int ak4535_add_widgets(struct snd_soc_codec *codec)
 
         snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
 
-        snd_soc_dapm_new_widgets(codec);
         return 0;
 }
 
@@ -485,17 +485,9 @@ static int ak4535_init(struct snd_soc_device *socdev)
         snd_soc_add_controls(codec, ak4535_snd_controls,
                                 ARRAY_SIZE(ak4535_snd_controls));
         ak4535_add_widgets(codec);
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                printk(KERN_ERR "ak4535: failed to register card\n");
-                goto card_err;
-        }
 
         return ret;
 
-card_err:
-        snd_soc_free_pcms(socdev);
-        snd_soc_dapm_free(socdev);
 pcm_err:
         kfree(codec->reg_cache);
 
diff --git a/sound/soc/codecs/ak4642.c b/sound/soc/codecs/ak4642.c
index e057c7b578df..729859cf6ca8 100644
--- a/sound/soc/codecs/ak4642.c
+++ b/sound/soc/codecs/ak4642.c
@@ -29,6 +29,7 @@
 #include <linux/pm.h>
 #include <linux/i2c.h>
 #include <linux/platform_device.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
@@ -442,18 +443,9 @@ static int ak4642_probe(struct platform_device *pdev)
                 goto pcm_err;
         }
 
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                printk(KERN_ERR "ak4642: failed to register card\n");
-                goto card_err;
-        }
-
         dev_info(&pdev->dev, "AK4642 Audio Codec %s", AK4642_VERSION);
         return ret;
 
-card_err:
-        snd_soc_free_pcms(socdev);
-        snd_soc_dapm_free(socdev);
 pcm_err:
         return ret;
 
@@ -479,7 +471,7 @@ EXPORT_SYMBOL_GPL(soc_codec_dev_ak4642);
 
 static int __init ak4642_modinit(void)
 {
-        int ret;
+        int ret = 0;
 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
         ret = i2c_add_driver(&ak4642_i2c_driver);
 #endif
diff --git a/sound/soc/codecs/ak4671.c b/sound/soc/codecs/ak4671.c
new file mode 100644
index 000000000000..926797a014c7
--- /dev/null
+++ b/sound/soc/codecs/ak4671.c
@@ -0,0 +1,816 @@
+/*
+ * ak4671.c  --  audio driver for AK4671
+ *
+ * Copyright (C) 2009 Samsung Electronics Co.Ltd
+ * Author: Joonyoung Shim <jy0922.shim@samsung.com>
+ *
+ *  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 the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/i2c.h>
+#include <linux/delay.h>
+#include <linux/slab.h>
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+#include <sound/initval.h>
+#include <sound/tlv.h>
+
+#include "ak4671.h"
+
+static struct snd_soc_codec *ak4671_codec;
+
+/* codec private data */
+struct ak4671_priv {
+        struct snd_soc_codec codec;
+        u8 reg_cache[AK4671_CACHEREGNUM];
+};
+
+/* ak4671 register cache & default register settings */
+static const u8 ak4671_reg[AK4671_CACHEREGNUM] = {
+        0x00,   /* AK4671_AD_DA_POWER_MANAGEMENT        (0x00)  */
+        0xf6,   /* AK4671_PLL_MODE_SELECT0              (0x01)  */
+        0x00,   /* AK4671_PLL_MODE_SELECT1              (0x02)  */
+        0x02,   /* AK4671_FORMAT_SELECT                 (0x03)  */
+        0x00,   /* AK4671_MIC_SIGNAL_SELECT             (0x04)  */
+        0x55,   /* AK4671_MIC_AMP_GAIN                  (0x05)  */
+        0x00,   /* AK4671_MIXING_POWER_MANAGEMENT0      (0x06)  */
+        0x00,   /* AK4671_MIXING_POWER_MANAGEMENT1      (0x07)  */
+        0xb5,   /* AK4671_OUTPUT_VOLUME_CONTROL         (0x08)  */
+        0x00,   /* AK4671_LOUT1_SIGNAL_SELECT           (0x09)  */
+        0x00,   /* AK4671_ROUT1_SIGNAL_SELECT           (0x0a)  */
+        0x00,   /* AK4671_LOUT2_SIGNAL_SELECT           (0x0b)  */
+        0x00,   /* AK4671_ROUT2_SIGNAL_SELECT           (0x0c)  */
+        0x00,   /* AK4671_LOUT3_SIGNAL_SELECT           (0x0d)  */
+        0x00,   /* AK4671_ROUT3_SIGNAL_SELECT           (0x0e)  */
+        0x00,   /* AK4671_LOUT1_POWER_MANAGERMENT       (0x0f)  */
+        0x00,   /* AK4671_LOUT2_POWER_MANAGERMENT       (0x10)  */
+        0x80,   /* AK4671_LOUT3_POWER_MANAGERMENT       (0x11)  */
+        0x91,   /* AK4671_LCH_INPUT_VOLUME_CONTROL      (0x12)  */
+        0x91,   /* AK4671_RCH_INPUT_VOLUME_CONTROL      (0x13)  */
+        0xe1,   /* AK4671_ALC_REFERENCE_SELECT          (0x14)  */
+        0x00,   /* AK4671_DIGITAL_MIXING_CONTROL        (0x15)  */
+        0x00,   /* AK4671_ALC_TIMER_SELECT              (0x16)  */
+        0x00,   /* AK4671_ALC_MODE_CONTROL              (0x17)  */
+        0x02,   /* AK4671_MODE_CONTROL1                 (0x18)  */
+        0x01,   /* AK4671_MODE_CONTROL2                 (0x19)  */
+        0x18,   /* AK4671_LCH_OUTPUT_VOLUME_CONTROL     (0x1a)  */
+        0x18,   /* AK4671_RCH_OUTPUT_VOLUME_CONTROL     (0x1b)  */
+        0x00,   /* AK4671_SIDETONE_A_CONTROL            (0x1c)  */
+        0x02,   /* AK4671_DIGITAL_FILTER_SELECT         (0x1d)  */
+        0x00,   /* AK4671_FIL3_COEFFICIENT0             (0x1e)  */
+        0x00,   /* AK4671_FIL3_COEFFICIENT1             (0x1f)  */
+        0x00,   /* AK4671_FIL3_COEFFICIENT2             (0x20)  */
+        0x00,   /* AK4671_FIL3_COEFFICIENT3             (0x21)  */
+        0x00,   /* AK4671_EQ_COEFFICIENT0               (0x22)  */
+        0x00,   /* AK4671_EQ_COEFFICIENT1               (0x23)  */
+        0x00,   /* AK4671_EQ_COEFFICIENT2               (0x24)  */
+        0x00,   /* AK4671_EQ_COEFFICIENT3               (0x25)  */
+        0x00,   /* AK4671_EQ_COEFFICIENT4               (0x26)  */
+        0x00,   /* AK4671_EQ_COEFFICIENT5               (0x27)  */
+        0xa9,   /* AK4671_FIL1_COEFFICIENT0             (0x28)  */
+        0x1f,   /* AK4671_FIL1_COEFFICIENT1             (0x29)  */
+        0xad,   /* AK4671_FIL1_COEFFICIENT2             (0x2a)  */
+        0x20,   /* AK4671_FIL1_COEFFICIENT3             (0x2b)  */
+        0x00,   /* AK4671_FIL2_COEFFICIENT0             (0x2c)  */
+        0x00,   /* AK4671_FIL2_COEFFICIENT1             (0x2d)  */
+        0x00,   /* AK4671_FIL2_COEFFICIENT2             (0x2e)  */
+        0x00,   /* AK4671_FIL2_COEFFICIENT3             (0x2f)  */
+        0x00,   /* AK4671_DIGITAL_FILTER_SELECT2        (0x30)  */
+        0x00,   /* this register not used                       */
+        0x00,   /* AK4671_E1_COEFFICIENT0               (0x32)  */
+        0x00,   /* AK4671_E1_COEFFICIENT1               (0x33)  */
+        0x00,   /* AK4671_E1_COEFFICIENT2               (0x34)  */
+        0x00,   /* AK4671_E1_COEFFICIENT3               (0x35)  */
+        0x00,   /* AK4671_E1_COEFFICIENT4               (0x36)  */
+        0x00,   /* AK4671_E1_COEFFICIENT5               (0x37)  */
+        0x00,   /* AK4671_E2_COEFFICIENT0               (0x38)  */
+        0x00,   /* AK4671_E2_COEFFICIENT1               (0x39)  */
+        0x00,   /* AK4671_E2_COEFFICIENT2               (0x3a)  */
+        0x00,   /* AK4671_E2_COEFFICIENT3               (0x3b)  */
+        0x00,   /* AK4671_E2_COEFFICIENT4               (0x3c)  */
+        0x00,   /* AK4671_E2_COEFFICIENT5               (0x3d)  */
+        0x00,   /* AK4671_E3_COEFFICIENT0               (0x3e)  */
+        0x00,   /* AK4671_E3_COEFFICIENT1               (0x3f)  */
+        0x00,   /* AK4671_E3_COEFFICIENT2               (0x40)  */
+        0x00,   /* AK4671_E3_COEFFICIENT3               (0x41)  */
+        0x00,   /* AK4671_E3_COEFFICIENT4               (0x42)  */
+        0x00,   /* AK4671_E3_COEFFICIENT5               (0x43)  */
+        0x00,   /* AK4671_E4_COEFFICIENT0               (0x44)  */
+        0x00,   /* AK4671_E4_COEFFICIENT1               (0x45)  */
+        0x00,   /* AK4671_E4_COEFFICIENT2               (0x46)  */
+        0x00,   /* AK4671_E4_COEFFICIENT3               (0x47)  */
+        0x00,   /* AK4671_E4_COEFFICIENT4               (0x48)  */
+        0x00,   /* AK4671_E4_COEFFICIENT5               (0x49)  */
+        0x00,   /* AK4671_E5_COEFFICIENT0               (0x4a)  */
+        0x00,   /* AK4671_E5_COEFFICIENT1               (0x4b)  */
+        0x00,   /* AK4671_E5_COEFFICIENT2               (0x4c)  */
+        0x00,   /* AK4671_E5_COEFFICIENT3               (0x4d)  */
+        0x00,   /* AK4671_E5_COEFFICIENT4               (0x4e)  */
+        0x00,   /* AK4671_E5_COEFFICIENT5               (0x4f)  */
+        0x88,   /* AK4671_EQ_CONTROL_250HZ_100HZ        (0x50)  */
+        0x88,   /* AK4671_EQ_CONTROL_3500HZ_1KHZ        (0x51)  */
+        0x08,   /* AK4671_EQ_CONTRO_10KHZ               (0x52)  */
+        0x00,   /* AK4671_PCM_IF_CONTROL0               (0x53)  */
+        0x00,   /* AK4671_PCM_IF_CONTROL1               (0x54)  */
+        0x00,   /* AK4671_PCM_IF_CONTROL2               (0x55)  */
+        0x18,   /* AK4671_DIGITAL_VOLUME_B_CONTROL      (0x56)  */
+        0x18,   /* AK4671_DIGITAL_VOLUME_C_CONTROL      (0x57)  */
+        0x00,   /* AK4671_SIDETONE_VOLUME_CONTROL       (0x58)  */
+        0x00,   /* AK4671_DIGITAL_MIXING_CONTROL2       (0x59)  */
+        0x00,   /* AK4671_SAR_ADC_CONTROL               (0x5a)  */
+};
+
+/*
+ * LOUT1/ROUT1 output volume control:
+ * from -24 to 6 dB in 6 dB steps (mute instead of -30 dB)
+ */
+static DECLARE_TLV_DB_SCALE(out1_tlv, -3000, 600, 1);
+
+/*
+ * LOUT2/ROUT2 output volume control:
+ * from -33 to 6 dB in 3 dB steps (mute instead of -33 dB)
+ */
+static DECLARE_TLV_DB_SCALE(out2_tlv, -3300, 300, 1);
+
+/*
+ * LOUT3/ROUT3 output volume control:
+ * from -6 to 3 dB in 3 dB steps
+ */
+static DECLARE_TLV_DB_SCALE(out3_tlv, -600, 300, 0);
+
+/*
+ * Mic amp gain control:
+ * from -15 to 30 dB in 3 dB steps
+ * REVISIT: The actual min value(0x01) is -12 dB and the reg value 0x00 is not
+ * available
+ */
+static DECLARE_TLV_DB_SCALE(mic_amp_tlv, -1500, 300, 0);
+
+static const struct snd_kcontrol_new ak4671_snd_controls[] = {
+        /* Common playback gain controls */
+        SOC_SINGLE_TLV("Line Output1 Playback Volume",
+                        AK4671_OUTPUT_VOLUME_CONTROL, 0, 0x6, 0, out1_tlv),
+        SOC_SINGLE_TLV("Headphone Output2 Playback Volume",
+                        AK4671_OUTPUT_VOLUME_CONTROL, 4, 0xd, 0, out2_tlv),
+        SOC_SINGLE_TLV("Line Output3 Playback Volume",
+                        AK4671_LOUT3_POWER_MANAGERMENT, 6, 0x3, 0, out3_tlv),
+
+        /* Common capture gain controls */
+        SOC_DOUBLE_TLV("Mic Amp Capture Volume",
+                        AK4671_MIC_AMP_GAIN, 0, 4, 0xf, 0, mic_amp_tlv),
+};
+
+/* event handlers */
+static int ak4671_out2_event(struct snd_soc_dapm_widget *w,
+                struct snd_kcontrol *kcontrol, int event)
+{
+        struct snd_soc_codec *codec = w->codec;
+        u8 reg;
+
+        switch (event) {
+        case SND_SOC_DAPM_POST_PMU:
+                reg = snd_soc_read(codec, AK4671_LOUT2_POWER_MANAGERMENT);
+                reg |= AK4671_MUTEN;
+                snd_soc_write(codec, AK4671_LOUT2_POWER_MANAGERMENT, reg);
+                break;
+        case SND_SOC_DAPM_PRE_PMD:
+                reg = snd_soc_read(codec, AK4671_LOUT2_POWER_MANAGERMENT);
+                reg &= ~AK4671_MUTEN;
+                snd_soc_write(codec, AK4671_LOUT2_POWER_MANAGERMENT, reg);
+                break;
+        }
+
+        return 0;
+}
+
+/* Output Mixers */
+static const struct snd_kcontrol_new ak4671_lout1_mixer_controls[] = {
+        SOC_DAPM_SINGLE("DACL", AK4671_LOUT1_SIGNAL_SELECT, 0, 1, 0),
+        SOC_DAPM_SINGLE("LINL1", AK4671_LOUT1_SIGNAL_SELECT, 1, 1, 0),
+        SOC_DAPM_SINGLE("LINL2", AK4671_LOUT1_SIGNAL_SELECT, 2, 1, 0),
+        SOC_DAPM_SINGLE("LINL3", AK4671_LOUT1_SIGNAL_SELECT, 3, 1, 0),
+        SOC_DAPM_SINGLE("LINL4", AK4671_LOUT1_SIGNAL_SELECT, 4, 1, 0),
+        SOC_DAPM_SINGLE("LOOPL", AK4671_LOUT1_SIGNAL_SELECT, 5, 1, 0),
+};
+
+static const struct snd_kcontrol_new ak4671_rout1_mixer_controls[] = {
+        SOC_DAPM_SINGLE("DACR", AK4671_ROUT1_SIGNAL_SELECT, 0, 1, 0),
+        SOC_DAPM_SINGLE("RINR1", AK4671_ROUT1_SIGNAL_SELECT, 1, 1, 0),
+        SOC_DAPM_SINGLE("RINR2", AK4671_ROUT1_SIGNAL_SELECT, 2, 1, 0),
+        SOC_DAPM_SINGLE("RINR3", AK4671_ROUT1_SIGNAL_SELECT, 3, 1, 0),
+        SOC_DAPM_SINGLE("RINR4", AK4671_ROUT1_SIGNAL_SELECT, 4, 1, 0),
+        SOC_DAPM_SINGLE("LOOPR", AK4671_ROUT1_SIGNAL_SELECT, 5, 1, 0),
+};
+
+static const struct snd_kcontrol_new ak4671_lout2_mixer_controls[] = {
+        SOC_DAPM_SINGLE("DACHL", AK4671_LOUT2_SIGNAL_SELECT, 0, 1, 0),
+        SOC_DAPM_SINGLE("LINH1", AK4671_LOUT2_SIGNAL_SELECT, 1, 1, 0),
+        SOC_DAPM_SINGLE("LINH2", AK4671_LOUT2_SIGNAL_SELECT, 2, 1, 0),
+        SOC_DAPM_SINGLE("LINH3", AK4671_LOUT2_SIGNAL_SELECT, 3, 1, 0),
+        SOC_DAPM_SINGLE("LINH4", AK4671_LOUT2_SIGNAL_SELECT, 4, 1, 0),
+        SOC_DAPM_SINGLE("LOOPHL", AK4671_LOUT2_SIGNAL_SELECT, 5, 1, 0),
+};
+
+static const struct snd_kcontrol_new ak4671_rout2_mixer_controls[] = {
+        SOC_DAPM_SINGLE("DACHR", AK4671_ROUT2_SIGNAL_SELECT, 0, 1, 0),
+        SOC_DAPM_SINGLE("RINH1", AK4671_ROUT2_SIGNAL_SELECT, 1, 1, 0),
+        SOC_DAPM_SINGLE("RINH2", AK4671_ROUT2_SIGNAL_SELECT, 2, 1, 0),
+        SOC_DAPM_SINGLE("RINH3", AK4671_ROUT2_SIGNAL_SELECT, 3, 1, 0),
+        SOC_DAPM_SINGLE("RINH4", AK4671_ROUT2_SIGNAL_SELECT, 4, 1, 0),
+        SOC_DAPM_SINGLE("LOOPHR", AK4671_ROUT2_SIGNAL_SELECT, 5, 1, 0),
+};
+
+static const struct snd_kcontrol_new ak4671_lout3_mixer_controls[] = {
+        SOC_DAPM_SINGLE("DACSL", AK4671_LOUT3_SIGNAL_SELECT, 0, 1, 0),
+        SOC_DAPM_SINGLE("LINS1", AK4671_LOUT3_SIGNAL_SELECT, 1, 1, 0),
+        SOC_DAPM_SINGLE("LINS2", AK4671_LOUT3_SIGNAL_SELECT, 2, 1, 0),
+        SOC_DAPM_SINGLE("LINS3", AK4671_LOUT3_SIGNAL_SELECT, 3, 1, 0),
+        SOC_DAPM_SINGLE("LINS4", AK4671_LOUT3_SIGNAL_SELECT, 4, 1, 0),
+        SOC_DAPM_SINGLE("LOOPSL", AK4671_LOUT3_SIGNAL_SELECT, 5, 1, 0),
+};
+
+static const struct snd_kcontrol_new ak4671_rout3_mixer_controls[] = {
+        SOC_DAPM_SINGLE("DACSR", AK4671_ROUT3_SIGNAL_SELECT, 0, 1, 0),
+        SOC_DAPM_SINGLE("RINS1", AK4671_ROUT3_SIGNAL_SELECT, 1, 1, 0),
+        SOC_DAPM_SINGLE("RINS2", AK4671_ROUT3_SIGNAL_SELECT, 2, 1, 0),
+        SOC_DAPM_SINGLE("RINS3", AK4671_ROUT3_SIGNAL_SELECT, 3, 1, 0),
+        SOC_DAPM_SINGLE("RINS4", AK4671_ROUT3_SIGNAL_SELECT, 4, 1, 0),
+        SOC_DAPM_SINGLE("LOOPSR", AK4671_ROUT3_SIGNAL_SELECT, 5, 1, 0),
+};
+
+/* Input MUXs */
+static const char *ak4671_lin_mux_texts[] =
+                {"LIN1", "LIN2", "LIN3", "LIN4"};
+static const struct soc_enum ak4671_lin_mux_enum =
+        SOC_ENUM_SINGLE(AK4671_MIC_SIGNAL_SELECT, 0,
+                        ARRAY_SIZE(ak4671_lin_mux_texts),
+                        ak4671_lin_mux_texts);
+static const struct snd_kcontrol_new ak4671_lin_mux_control =
+        SOC_DAPM_ENUM("Route", ak4671_lin_mux_enum);
+
+static const char *ak4671_rin_mux_texts[] =
+                {"RIN1", "RIN2", "RIN3", "RIN4"};
+static const struct soc_enum ak4671_rin_mux_enum =
+        SOC_ENUM_SINGLE(AK4671_MIC_SIGNAL_SELECT, 2,
+                        ARRAY_SIZE(ak4671_rin_mux_texts),
+                        ak4671_rin_mux_texts);
+static const struct snd_kcontrol_new ak4671_rin_mux_control =
+        SOC_DAPM_ENUM("Route", ak4671_rin_mux_enum);
+
+static const struct snd_soc_dapm_widget ak4671_dapm_widgets[] = {
+        /* Inputs */
+        SND_SOC_DAPM_INPUT("LIN1"),
+        SND_SOC_DAPM_INPUT("RIN1"),
+        SND_SOC_DAPM_INPUT("LIN2"),
+        SND_SOC_DAPM_INPUT("RIN2"),
+        SND_SOC_DAPM_INPUT("LIN3"),
+        SND_SOC_DAPM_INPUT("RIN3"),
+        SND_SOC_DAPM_INPUT("LIN4"),
+        SND_SOC_DAPM_INPUT("RIN4"),
+
+        /* Outputs */
+        SND_SOC_DAPM_OUTPUT("LOUT1"),
+        SND_SOC_DAPM_OUTPUT("ROUT1"),
+        SND_SOC_DAPM_OUTPUT("LOUT2"),
+        SND_SOC_DAPM_OUTPUT("ROUT2"),
+        SND_SOC_DAPM_OUTPUT("LOUT3"),
+        SND_SOC_DAPM_OUTPUT("ROUT3"),
+
+        /* DAC */
+        SND_SOC_DAPM_DAC("DAC Left", "Left HiFi Playback",
+                        AK4671_AD_DA_POWER_MANAGEMENT, 6, 0),
+        SND_SOC_DAPM_DAC("DAC Right", "Right HiFi Playback",
+                        AK4671_AD_DA_POWER_MANAGEMENT, 7, 0),
+
+        /* ADC */
+        SND_SOC_DAPM_ADC("ADC Left", "Left HiFi Capture",
+                        AK4671_AD_DA_POWER_MANAGEMENT, 4, 0),
+        SND_SOC_DAPM_ADC("ADC Right", "Right HiFi Capture",
+                        AK4671_AD_DA_POWER_MANAGEMENT, 5, 0),
+
+        /* PGA */
+        SND_SOC_DAPM_PGA("LOUT2 Mix Amp",
+                        AK4671_LOUT2_POWER_MANAGERMENT, 5, 0, NULL, 0),
+        SND_SOC_DAPM_PGA("ROUT2 Mix Amp",
+                        AK4671_LOUT2_POWER_MANAGERMENT, 6, 0, NULL, 0),
+
+        SND_SOC_DAPM_PGA("LIN1 Mixing Circuit",
+                        AK4671_MIXING_POWER_MANAGEMENT1, 0, 0, NULL, 0),
+        SND_SOC_DAPM_PGA("RIN1 Mixing Circuit",
+                        AK4671_MIXING_POWER_MANAGEMENT1, 1, 0, NULL, 0),
+        SND_SOC_DAPM_PGA("LIN2 Mixing Circuit",
+                        AK4671_MIXING_POWER_MANAGEMENT1, 2, 0, NULL, 0),
+        SND_SOC_DAPM_PGA("RIN2 Mixing Circuit",
+                        AK4671_MIXING_POWER_MANAGEMENT1, 3, 0, NULL, 0),
+        SND_SOC_DAPM_PGA("LIN3 Mixing Circuit",
+                        AK4671_MIXING_POWER_MANAGEMENT1, 4, 0, NULL, 0),
+        SND_SOC_DAPM_PGA("RIN3 Mixing Circuit",
+                        AK4671_MIXING_POWER_MANAGEMENT1, 5, 0, NULL, 0),
+        SND_SOC_DAPM_PGA("LIN4 Mixing Circuit",
+                        AK4671_MIXING_POWER_MANAGEMENT1, 6, 0, NULL, 0),
+        SND_SOC_DAPM_PGA("RIN4 Mixing Circuit",
+                        AK4671_MIXING_POWER_MANAGEMENT1, 7, 0, NULL, 0),
+
+        /* Output Mixers */
+        SND_SOC_DAPM_MIXER("LOUT1 Mixer", AK4671_LOUT1_POWER_MANAGERMENT, 0, 0,
+                        &ak4671_lout1_mixer_controls[0],
+                        ARRAY_SIZE(ak4671_lout1_mixer_controls)),
+        SND_SOC_DAPM_MIXER("ROUT1 Mixer", AK4671_LOUT1_POWER_MANAGERMENT, 1, 0,
+                        &ak4671_rout1_mixer_controls[0],
+                        ARRAY_SIZE(ak4671_rout1_mixer_controls)),
+        SND_SOC_DAPM_MIXER_E("LOUT2 Mixer", AK4671_LOUT2_POWER_MANAGERMENT,
+                        0, 0, &ak4671_lout2_mixer_controls[0],
+                        ARRAY_SIZE(ak4671_lout2_mixer_controls),
+                        ak4671_out2_event,
+                        SND_SOC_DAPM_POST_PMU|SND_SOC_DAPM_PRE_PMD),
+        SND_SOC_DAPM_MIXER_E("ROUT2 Mixer", AK4671_LOUT2_POWER_MANAGERMENT,
+                        1, 0, &ak4671_rout2_mixer_controls[0],
+                        ARRAY_SIZE(ak4671_rout2_mixer_controls),
+                        ak4671_out2_event,
+                        SND_SOC_DAPM_POST_PMU|SND_SOC_DAPM_PRE_PMD),
+        SND_SOC_DAPM_MIXER("LOUT3 Mixer", AK4671_LOUT3_POWER_MANAGERMENT, 0, 0,
+                        &ak4671_lout3_mixer_controls[0],
+                        ARRAY_SIZE(ak4671_lout3_mixer_controls)),
+        SND_SOC_DAPM_MIXER("ROUT3 Mixer", AK4671_LOUT3_POWER_MANAGERMENT, 1, 0,
+                        &ak4671_rout3_mixer_controls[0],
+                        ARRAY_SIZE(ak4671_rout3_mixer_controls)),
+
+        /* Input MUXs */
+        SND_SOC_DAPM_MUX("LIN MUX", AK4671_AD_DA_POWER_MANAGEMENT, 2, 0,
+                        &ak4671_lin_mux_control),
+        SND_SOC_DAPM_MUX("RIN MUX", AK4671_AD_DA_POWER_MANAGEMENT, 3, 0,
+                        &ak4671_rin_mux_control),
+
+        /* Mic Power */
+        SND_SOC_DAPM_MICBIAS("Mic Bias", AK4671_AD_DA_POWER_MANAGEMENT, 1, 0),
+
+        /* Supply */
+        SND_SOC_DAPM_SUPPLY("PMPLL", AK4671_PLL_MODE_SELECT1, 0, 0, NULL, 0),
+};
+
+static const struct snd_soc_dapm_route intercon[] = {
+        {"DAC Left", "NULL", "PMPLL"},
+        {"DAC Right", "NULL", "PMPLL"},
+        {"ADC Left", "NULL", "PMPLL"},
+        {"ADC Right", "NULL", "PMPLL"},
+
+        /* Outputs */
+        {"LOUT1", "NULL", "LOUT1 Mixer"},
+        {"ROUT1", "NULL", "ROUT1 Mixer"},
+        {"LOUT2", "NULL", "LOUT2 Mix Amp"},
+        {"ROUT2", "NULL", "ROUT2 Mix Amp"},
+        {"LOUT3", "NULL", "LOUT3 Mixer"},
+        {"ROUT3", "NULL", "ROUT3 Mixer"},
+
+        {"LOUT1 Mixer", "DACL", "DAC Left"},
+        {"ROUT1 Mixer", "DACR", "DAC Right"},
+        {"LOUT2 Mixer", "DACHL", "DAC Left"},
+        {"ROUT2 Mixer", "DACHR", "DAC Right"},
+        {"LOUT2 Mix Amp", "NULL", "LOUT2 Mixer"},
+        {"ROUT2 Mix Amp", "NULL", "ROUT2 Mixer"},
+        {"LOUT3 Mixer", "DACSL", "DAC Left"},
+        {"ROUT3 Mixer", "DACSR", "DAC Right"},
+
+        /* Inputs */
+        {"LIN MUX", "LIN1", "LIN1"},
+        {"LIN MUX", "LIN2", "LIN2"},
+        {"LIN MUX", "LIN3", "LIN3"},
+        {"LIN MUX", "LIN4", "LIN4"},
+
+        {"RIN MUX", "RIN1", "RIN1"},
+        {"RIN MUX", "RIN2", "RIN2"},
+        {"RIN MUX", "RIN3", "RIN3"},
+        {"RIN MUX", "RIN4", "RIN4"},
+
+        {"LIN1", NULL, "Mic Bias"},
+        {"RIN1", NULL, "Mic Bias"},
+        {"LIN2", NULL, "Mic Bias"},
+        {"RIN2", NULL, "Mic Bias"},
+
+        {"ADC Left", "NULL", "LIN MUX"},
+        {"ADC Right", "NULL", "RIN MUX"},
+
+        /* Analog Loops */
+        {"LIN1 Mixing Circuit", "NULL", "LIN1"},
+        {"RIN1 Mixing Circuit", "NULL", "RIN1"},
+        {"LIN2 Mixing Circuit", "NULL", "LIN2"},
+        {"RIN2 Mixing Circuit", "NULL", "RIN2"},
+        {"LIN3 Mixing Circuit", "NULL", "LIN3"},
+        {"RIN3 Mixing Circuit", "NULL", "RIN3"},
+        {"LIN4 Mixing Circuit", "NULL", "LIN4"},
+        {"RIN4 Mixing Circuit", "NULL", "RIN4"},
+
+        {"LOUT1 Mixer", "LINL1", "LIN1 Mixing Circuit"},
+        {"ROUT1 Mixer", "RINR1", "RIN1 Mixing Circuit"},
+        {"LOUT2 Mixer", "LINH1", "LIN1 Mixing Circuit"},
+        {"ROUT2 Mixer", "RINH1", "RIN1 Mixing Circuit"},
+        {"LOUT3 Mixer", "LINS1", "LIN1 Mixing Circuit"},
+        {"ROUT3 Mixer", "RINS1", "RIN1 Mixing Circuit"},
+
+        {"LOUT1 Mixer", "LINL2", "LIN2 Mixing Circuit"},
+        {"ROUT1 Mixer", "RINR2", "RIN2 Mixing Circuit"},
+        {"LOUT2 Mixer", "LINH2", "LIN2 Mixing Circuit"},
+        {"ROUT2 Mixer", "RINH2", "RIN2 Mixing Circuit"},
+        {"LOUT3 Mixer", "LINS2", "LIN2 Mixing Circuit"},
+        {"ROUT3 Mixer", "RINS2", "RIN2 Mixing Circuit"},
+
+        {"LOUT1 Mixer", "LINL3", "LIN3 Mixing Circuit"},
+        {"ROUT1 Mixer", "RINR3", "RIN3 Mixing Circuit"},
+        {"LOUT2 Mixer", "LINH3", "LIN3 Mixing Circuit"},
+        {"ROUT2 Mixer", "RINH3", "RIN3 Mixing Circuit"},
+        {"LOUT3 Mixer", "LINS3", "LIN3 Mixing Circuit"},
+        {"ROUT3 Mixer", "RINS3", "RIN3 Mixing Circuit"},
+
+        {"LOUT1 Mixer", "LINL4", "LIN4 Mixing Circuit"},
+        {"ROUT1 Mixer", "RINR4", "RIN4 Mixing Circuit"},
+        {"LOUT2 Mixer", "LINH4", "LIN4 Mixing Circuit"},
+        {"ROUT2 Mixer", "RINH4", "RIN4 Mixing Circuit"},
+        {"LOUT3 Mixer", "LINS4", "LIN4 Mixing Circuit"},
+        {"ROUT3 Mixer", "RINS4", "RIN4 Mixing Circuit"},
+};
+
+static int ak4671_add_widgets(struct snd_soc_codec *codec)
+{
+        snd_soc_dapm_new_controls(codec, ak4671_dapm_widgets,
+                                  ARRAY_SIZE(ak4671_dapm_widgets));
+
+        snd_soc_dapm_add_routes(codec, intercon, ARRAY_SIZE(intercon));
+
+        return 0;
+}
+
+static int ak4671_hw_params(struct snd_pcm_substream *substream,
+                struct snd_pcm_hw_params *params,
+                struct snd_soc_dai *dai)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        u8 fs;
+
+        fs = snd_soc_read(codec, AK4671_PLL_MODE_SELECT0);
+        fs &= ~AK4671_FS;
+
+        switch (params_rate(params)) {
+        case 8000:
+                fs |= AK4671_FS_8KHZ;
+                break;
+        case 12000:
+                fs |= AK4671_FS_12KHZ;
+                break;
+        case 16000:
+                fs |= AK4671_FS_16KHZ;
+                break;
+        case 24000:
+                fs |= AK4671_FS_24KHZ;
+                break;
+        case 11025:
+                fs |= AK4671_FS_11_025KHZ;
+                break;
+        case 22050:
+                fs |= AK4671_FS_22_05KHZ;
+                break;
+        case 32000:
+                fs |= AK4671_FS_32KHZ;
+                break;
+        case 44100:
+                fs |= AK4671_FS_44_1KHZ;
+                break;
+        case 48000:
+                fs |= AK4671_FS_48KHZ;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        snd_soc_write(codec, AK4671_PLL_MODE_SELECT0, fs);
+
+        return 0;
+}
+
+static int ak4671_set_dai_sysclk(struct snd_soc_dai *dai, int clk_id,
+                unsigned int freq, int dir)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        u8 pll;
+
+        pll = snd_soc_read(codec, AK4671_PLL_MODE_SELECT0);
+        pll &= ~AK4671_PLL;
+
+        switch (freq) {
+        case 11289600:
+                pll |= AK4671_PLL_11_2896MHZ;
+                break;
+        case 12000000:
+                pll |= AK4671_PLL_12MHZ;
+                break;
+        case 12288000:
+                pll |= AK4671_PLL_12_288MHZ;
+                break;
+        case 13000000:
+                pll |= AK4671_PLL_13MHZ;
+                break;
+        case 13500000:
+                pll |= AK4671_PLL_13_5MHZ;
+                break;
+        case 19200000:
+                pll |= AK4671_PLL_19_2MHZ;
+                break;
+        case 24000000:
+                pll |= AK4671_PLL_24MHZ;
+                break;
+        case 26000000:
+                pll |= AK4671_PLL_26MHZ;
+                break;
+        case 27000000:
+                pll |= AK4671_PLL_27MHZ;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        snd_soc_write(codec, AK4671_PLL_MODE_SELECT0, pll);
+
+        return 0;
+}
+
+static int ak4671_set_dai_fmt(struct snd_soc_dai *dai, unsigned int fmt)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        u8 mode;
+        u8 format;
+
+        /* set master/slave audio interface */
+        mode = snd_soc_read(codec, AK4671_PLL_MODE_SELECT1);
+
+        switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
+        case SND_SOC_DAIFMT_CBM_CFM:
+                mode |= AK4671_M_S;
+                break;
+        case SND_SOC_DAIFMT_CBM_CFS:
+                mode &= ~(AK4671_M_S);
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        /* interface format */
+        format = snd_soc_read(codec, AK4671_FORMAT_SELECT);
+        format &= ~AK4671_DIF;
+
+        switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
+        case SND_SOC_DAIFMT_I2S:
+                format |= AK4671_DIF_I2S_MODE;
+                break;
+        case SND_SOC_DAIFMT_LEFT_J:
+                format |= AK4671_DIF_MSB_MODE;
+                break;
+        case SND_SOC_DAIFMT_DSP_A:
+                format |= AK4671_DIF_DSP_MODE;
+                format |= AK4671_BCKP;
+                format |= AK4671_MSBS;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        /* set mode and format */
+        snd_soc_write(codec, AK4671_PLL_MODE_SELECT1, mode);
+        snd_soc_write(codec, AK4671_FORMAT_SELECT, format);
+
+        return 0;
+}
+
+static int ak4671_set_bias_level(struct snd_soc_codec *codec,
+                enum snd_soc_bias_level level)
+{
+        u8 reg;
+
+        switch (level) {
+        case SND_SOC_BIAS_ON:
+        case SND_SOC_BIAS_PREPARE:
+        case SND_SOC_BIAS_STANDBY:
+                reg = snd_soc_read(codec, AK4671_AD_DA_POWER_MANAGEMENT);
+                snd_soc_write(codec, AK4671_AD_DA_POWER_MANAGEMENT,
+                                reg | AK4671_PMVCM);
+                break;
+        case SND_SOC_BIAS_OFF:
+                snd_soc_write(codec, AK4671_AD_DA_POWER_MANAGEMENT, 0x00);
+                break;
+        }
+        codec->bias_level = level;
+        return 0;
+}
+
+#define AK4671_RATES            (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_11025 |\
+                                SNDRV_PCM_RATE_16000 | SNDRV_PCM_RATE_22050 |\
+                                SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 |\
+                                SNDRV_PCM_RATE_48000)
+
+#define AK4671_FORMATS          SNDRV_PCM_FMTBIT_S16_LE
+
+static struct snd_soc_dai_ops ak4671_dai_ops = {
+        .hw_params      = ak4671_hw_params,
+        .set_sysclk     = ak4671_set_dai_sysclk,
+        .set_fmt        = ak4671_set_dai_fmt,
+};
+
+struct snd_soc_dai ak4671_dai = {
+        .name = "AK4671",
+        .playback = {
+                .stream_name = "Playback",
+                .channels_min = 1,
+                .channels_max = 2,
+                .rates = AK4671_RATES,
+                .formats = AK4671_FORMATS,},
+        .capture = {
+                .stream_name = "Capture",
+                .channels_min = 1,
+                .channels_max = 2,
+                .rates = AK4671_RATES,
+                .formats = AK4671_FORMATS,},
+        .ops = &ak4671_dai_ops,
+};
+EXPORT_SYMBOL_GPL(ak4671_dai);
+
+static int ak4671_probe(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec;
+        int ret = 0;
+
+        if (ak4671_codec == NULL) {
+                dev_err(&pdev->dev, "Codec device not registered\n");
+                return -ENODEV;
+        }
+
+        socdev->card->codec = ak4671_codec;
+        codec = ak4671_codec;
+
+        /* register pcms */
+        ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
+        if (ret < 0) {
+                dev_err(codec->dev, "failed to create pcms: %d\n", ret);
+                goto pcm_err;
+        }
+
+        snd_soc_add_controls(codec, ak4671_snd_controls,
+                             ARRAY_SIZE(ak4671_snd_controls));
+        ak4671_add_widgets(codec);
+
+        ak4671_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+
+        return ret;
+
+pcm_err:
+        return ret;
+}
+
+static int ak4671_remove(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+
+        snd_soc_free_pcms(socdev);
+        snd_soc_dapm_free(socdev);
+
+        return 0;
+}
+
+struct snd_soc_codec_device soc_codec_dev_ak4671 = {
+        .probe = ak4671_probe,
+        .remove = ak4671_remove,
+};
+EXPORT_SYMBOL_GPL(soc_codec_dev_ak4671);
+
+static int ak4671_register(struct ak4671_priv *ak4671,
+                enum snd_soc_control_type control)
+{
+        int ret;
+        struct snd_soc_codec *codec = &ak4671->codec;
+
+        if (ak4671_codec) {
+                dev_err(codec->dev, "Another AK4671 is registered\n");
+                ret = -EINVAL;
+                goto err;
+        }
+
+        mutex_init(&codec->mutex);
+        INIT_LIST_HEAD(&codec->dapm_widgets);
+        INIT_LIST_HEAD(&codec->dapm_paths);
+
+        codec->private_data = ak4671;
+        codec->name = "AK4671";
+        codec->owner = THIS_MODULE;
+        codec->bias_level = SND_SOC_BIAS_OFF;
+        codec->set_bias_level = ak4671_set_bias_level;
+        codec->dai = &ak4671_dai;
+        codec->num_dai = 1;
+        codec->reg_cache_size = AK4671_CACHEREGNUM;
+        codec->reg_cache = &ak4671->reg_cache;
+
+        memcpy(codec->reg_cache, ak4671_reg, sizeof(ak4671_reg));
+
+        ret = snd_soc_codec_set_cache_io(codec, 8, 8, control);
+        if (ret < 0) {
+                dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
+                goto err;
+        }
+
+        ak4671_dai.dev = codec->dev;
+        ak4671_codec = codec;
+
+        ret = snd_soc_register_codec(codec);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to register codec: %d\n", ret);
+                goto err;
+        }
+
+        ret = snd_soc_register_dai(&ak4671_dai);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to register DAI: %d\n", ret);
+                goto err_codec;
+        }
+
+        return 0;
+
+err_codec:
+        snd_soc_unregister_codec(codec);
+err:
+        kfree(ak4671);
+        return ret;
+}
+
+static void ak4671_unregister(struct ak4671_priv *ak4671)
+{
+        ak4671_set_bias_level(&ak4671->codec, SND_SOC_BIAS_OFF);
+        snd_soc_unregister_dai(&ak4671_dai);
+        snd_soc_unregister_codec(&ak4671->codec);
+        kfree(ak4671);
+        ak4671_codec = NULL;
+}
+
+static int __devinit ak4671_i2c_probe(struct i2c_client *client,
+                const struct i2c_device_id *id)
+{
+        struct ak4671_priv *ak4671;
+        struct snd_soc_codec *codec;
+
+        ak4671 = kzalloc(sizeof(struct ak4671_priv), GFP_KERNEL);
+        if (ak4671 == NULL)
+                return -ENOMEM;
+
+        codec = &ak4671->codec;
+        codec->hw_write = (hw_write_t)i2c_master_send;
+
+        i2c_set_clientdata(client, ak4671);
+        codec->control_data = client;
+
+        codec->dev = &client->dev;
+
+        return ak4671_register(ak4671, SND_SOC_I2C);
+}
+
+static __devexit int ak4671_i2c_remove(struct i2c_client *client)
+{
+        struct ak4671_priv *ak4671 = i2c_get_clientdata(client);
+
+        ak4671_unregister(ak4671);
+
+        return 0;
+}
+
+static const struct i2c_device_id ak4671_i2c_id[] = {
+        { "ak4671", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, ak4671_i2c_id);
+
+static struct i2c_driver ak4671_i2c_driver = {
+        .driver = {
+                .name = "ak4671",
+                .owner = THIS_MODULE,
+        },
+        .probe = ak4671_i2c_probe,
+        .remove = __devexit_p(ak4671_i2c_remove),
+        .id_table = ak4671_i2c_id,
+};
+
+static int __init ak4671_modinit(void)
+{
+        return i2c_add_driver(&ak4671_i2c_driver);
+}
+module_init(ak4671_modinit);
+
+static void __exit ak4671_exit(void)
+{
+        i2c_del_driver(&ak4671_i2c_driver);
+}
+module_exit(ak4671_exit);
+
+MODULE_DESCRIPTION("ASoC AK4671 codec driver");
+MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/codecs/ak4671.h b/sound/soc/codecs/ak4671.h
new file mode 100644
index 000000000000..e2fad964e88b
--- /dev/null
+++ b/sound/soc/codecs/ak4671.h
@@ -0,0 +1,156 @@
+/*
+ * ak4671.h  --  audio driver for AK4671
+ *
+ * Copyright (C) 2009 Samsung Electronics Co.Ltd
+ * Author: Joonyoung Shim <jy0922.shim@samsung.com>
+ *
+ *  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 the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ *
+ */
+
+#ifndef _AK4671_H
+#define _AK4671_H
+
+#define AK4671_AD_DA_POWER_MANAGEMENT           0x00
+#define AK4671_PLL_MODE_SELECT0                 0x01
+#define AK4671_PLL_MODE_SELECT1                 0x02
+#define AK4671_FORMAT_SELECT                    0x03
+#define AK4671_MIC_SIGNAL_SELECT                0x04
+#define AK4671_MIC_AMP_GAIN                     0x05
+#define AK4671_MIXING_POWER_MANAGEMENT0         0x06
+#define AK4671_MIXING_POWER_MANAGEMENT1         0x07
+#define AK4671_OUTPUT_VOLUME_CONTROL            0x08
+#define AK4671_LOUT1_SIGNAL_SELECT              0x09
+#define AK4671_ROUT1_SIGNAL_SELECT              0x0a
+#define AK4671_LOUT2_SIGNAL_SELECT              0x0b
+#define AK4671_ROUT2_SIGNAL_SELECT              0x0c
+#define AK4671_LOUT3_SIGNAL_SELECT              0x0d
+#define AK4671_ROUT3_SIGNAL_SELECT              0x0e
+#define AK4671_LOUT1_POWER_MANAGERMENT          0x0f
+#define AK4671_LOUT2_POWER_MANAGERMENT          0x10
+#define AK4671_LOUT3_POWER_MANAGERMENT          0x11
+#define AK4671_LCH_INPUT_VOLUME_CONTROL         0x12
+#define AK4671_RCH_INPUT_VOLUME_CONTROL         0x13
+#define AK4671_ALC_REFERENCE_SELECT             0x14
+#define AK4671_DIGITAL_MIXING_CONTROL           0x15
+#define AK4671_ALC_TIMER_SELECT                 0x16
+#define AK4671_ALC_MODE_CONTROL                 0x17
+#define AK4671_MODE_CONTROL1                    0x18
+#define AK4671_MODE_CONTROL2                    0x19
+#define AK4671_LCH_OUTPUT_VOLUME_CONTROL        0x1a
+#define AK4671_RCH_OUTPUT_VOLUME_CONTROL        0x1b
+#define AK4671_SIDETONE_A_CONTROL               0x1c
+#define AK4671_DIGITAL_FILTER_SELECT            0x1d
+#define AK4671_FIL3_COEFFICIENT0                0x1e
+#define AK4671_FIL3_COEFFICIENT1                0x1f
+#define AK4671_FIL3_COEFFICIENT2                0x20
+#define AK4671_FIL3_COEFFICIENT3                0x21
+#define AK4671_EQ_COEFFICIENT0                  0x22
+#define AK4671_EQ_COEFFICIENT1                  0x23
+#define AK4671_EQ_COEFFICIENT2                  0x24
+#define AK4671_EQ_COEFFICIENT3                  0x25
+#define AK4671_EQ_COEFFICIENT4                  0x26
+#define AK4671_EQ_COEFFICIENT5                  0x27
+#define AK4671_FIL1_COEFFICIENT0                0x28
+#define AK4671_FIL1_COEFFICIENT1                0x29
+#define AK4671_FIL1_COEFFICIENT2                0x2a
+#define AK4671_FIL1_COEFFICIENT3                0x2b
+#define AK4671_FIL2_COEFFICIENT0                0x2c
+#define AK4671_FIL2_COEFFICIENT1                0x2d
+#define AK4671_FIL2_COEFFICIENT2                0x2e
+#define AK4671_FIL2_COEFFICIENT3                0x2f
+#define AK4671_DIGITAL_FILTER_SELECT2           0x30
+#define AK4671_E1_COEFFICIENT0                  0x32
+#define AK4671_E1_COEFFICIENT1                  0x33
+#define AK4671_E1_COEFFICIENT2                  0x34
+#define AK4671_E1_COEFFICIENT3                  0x35
+#define AK4671_E1_COEFFICIENT4                  0x36
+#define AK4671_E1_COEFFICIENT5                  0x37
+#define AK4671_E2_COEFFICIENT0                  0x38
+#define AK4671_E2_COEFFICIENT1                  0x39
+#define AK4671_E2_COEFFICIENT2                  0x3a
+#define AK4671_E2_COEFFICIENT3                  0x3b
+#define AK4671_E2_COEFFICIENT4                  0x3c
+#define AK4671_E2_COEFFICIENT5                  0x3d
+#define AK4671_E3_COEFFICIENT0                  0x3e
+#define AK4671_E3_COEFFICIENT1                  0x3f
+#define AK4671_E3_COEFFICIENT2                  0x40
+#define AK4671_E3_COEFFICIENT3                  0x41
+#define AK4671_E3_COEFFICIENT4                  0x42
+#define AK4671_E3_COEFFICIENT5                  0x43
+#define AK4671_E4_COEFFICIENT0                  0x44
+#define AK4671_E4_COEFFICIENT1                  0x45
+#define AK4671_E4_COEFFICIENT2                  0x46
+#define AK4671_E4_COEFFICIENT3                  0x47
+#define AK4671_E4_COEFFICIENT4                  0x48
+#define AK4671_E4_COEFFICIENT5                  0x49
+#define AK4671_E5_COEFFICIENT0                  0x4a
+#define AK4671_E5_COEFFICIENT1                  0x4b
+#define AK4671_E5_COEFFICIENT2                  0x4c
+#define AK4671_E5_COEFFICIENT3                  0x4d
+#define AK4671_E5_COEFFICIENT4                  0x4e
+#define AK4671_E5_COEFFICIENT5                  0x4f
+#define AK4671_EQ_CONTROL_250HZ_100HZ           0x50
+#define AK4671_EQ_CONTROL_3500HZ_1KHZ           0x51
+#define AK4671_EQ_CONTRO_10KHZ                  0x52
+#define AK4671_PCM_IF_CONTROL0                  0x53
+#define AK4671_PCM_IF_CONTROL1                  0x54
+#define AK4671_PCM_IF_CONTROL2                  0x55
+#define AK4671_DIGITAL_VOLUME_B_CONTROL         0x56
+#define AK4671_DIGITAL_VOLUME_C_CONTROL         0x57
+#define AK4671_SIDETONE_VOLUME_CONTROL          0x58
+#define AK4671_DIGITAL_MIXING_CONTROL2          0x59
+#define AK4671_SAR_ADC_CONTROL                  0x5a
+
+#define AK4671_CACHEREGNUM                      (AK4671_SAR_ADC_CONTROL + 1)
+
+/* Bitfield Definitions */
+
+/* AK4671_AD_DA_POWER_MANAGEMENT (0x00) Fields */
+#define AK4671_PMVCM                            0x01
+
+/* AK4671_PLL_MODE_SELECT0 (0x01) Fields */
+#define AK4671_PLL                              0x0f
+#define AK4671_PLL_11_2896MHZ                   (4 << 0)
+#define AK4671_PLL_12_288MHZ                    (5 << 0)
+#define AK4671_PLL_12MHZ                        (6 << 0)
+#define AK4671_PLL_24MHZ                        (7 << 0)
+#define AK4671_PLL_19_2MHZ                      (8 << 0)
+#define AK4671_PLL_13_5MHZ                      (12 << 0)
+#define AK4671_PLL_27MHZ                        (13 << 0)
+#define AK4671_PLL_13MHZ                        (14 << 0)
+#define AK4671_PLL_26MHZ                        (15 << 0)
+#define AK4671_FS                               0xf0
+#define AK4671_FS_8KHZ                          (0 << 4)
+#define AK4671_FS_12KHZ                         (1 << 4)
+#define AK4671_FS_16KHZ                         (2 << 4)
+#define AK4671_FS_24KHZ                         (3 << 4)
+#define AK4671_FS_11_025KHZ                     (5 << 4)
+#define AK4671_FS_22_05KHZ                      (7 << 4)
+#define AK4671_FS_32KHZ                         (10 << 4)
+#define AK4671_FS_48KHZ                         (11 << 4)
+#define AK4671_FS_44_1KHZ                       (15 << 4)
+
+/* AK4671_PLL_MODE_SELECT1 (0x02) Fields */
+#define AK4671_PMPLL                            0x01
+#define AK4671_M_S                              0x02
+
+/* AK4671_FORMAT_SELECT (0x03) Fields */
+#define AK4671_DIF                              0x03
+#define AK4671_DIF_DSP_MODE                     (0 << 0)
+#define AK4671_DIF_MSB_MODE                     (2 << 0)
+#define AK4671_DIF_I2S_MODE                     (3 << 0)
+#define AK4671_BCKP                             0x04
+#define AK4671_MSBS                             0x08
+#define AK4671_SDOD                             0x10
+
+/* AK4671_LOUT2_POWER_MANAGEMENT (0x10) Fields */
+#define AK4671_MUTEN                            0x04
+
+extern struct snd_soc_dai ak4671_dai;
+extern struct snd_soc_codec_device soc_codec_dev_ak4671;
+
+#endif
diff --git a/sound/soc/codecs/cs4270.c b/sound/soc/codecs/cs4270.c
index ca1e24a8f12a..81a62d198b70 100644
--- a/sound/soc/codecs/cs4270.c
+++ b/sound/soc/codecs/cs4270.c
@@ -23,11 +23,13 @@
 
 #include <linux/module.h>
 #include <linux/platform_device.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/soc.h>
 #include <sound/initval.h>
 #include <linux/i2c.h>
 #include <linux/delay.h>
+#include <linux/regulator/consumer.h>
 
 #include "cs4270.h"
 
@@ -106,6 +108,10 @@
 #define CS4270_MUTE_DAC_A       0x01
 #define CS4270_MUTE_DAC_B       0x02
 
+static const char *supply_names[] = {
+        "va", "vd", "vlc"
+};
+
 /* Private data for the CS4270 */
 struct cs4270_private {
         struct snd_soc_codec codec;
@@ -114,6 +120,9 @@ struct cs4270_private {
         unsigned int mode; /* The mode (I2S or left-justified) */
         unsigned int slave_mode;
         unsigned int manual_mute;
+
+        /* power domain regulators */
+        struct regulator_bulk_data supplies[ARRAY_SIZE(supply_names)];
 };
 
 /**
@@ -192,6 +201,11 @@ static struct cs4270_mode_ratios cs4270_mode_ratios[] = {
  * This function must be called by the machine driver's 'startup' function,
  * otherwise the list of supported sample rates will not be available in
  * time for ALSA.
+ *
+ * For setups with variable MCLKs, pass 0 as 'freq' argument. This will cause
+ * theoretically possible sample rates to be enabled. Call it again with a
+ * proper value set one the external clock is set (most probably you would do
+ * that from a machine's driver 'hw_param' hook.
  */
 static int cs4270_set_dai_sysclk(struct snd_soc_dai *codec_dai,
                                  int clk_id, unsigned int freq, int dir)
@@ -205,20 +219,27 @@ static int cs4270_set_dai_sysclk(struct snd_soc_dai *codec_dai,
 
         cs4270->mclk = freq;
 
-        for (i = 0; i < NUM_MCLK_RATIOS; i++) {
-                unsigned int rate = freq / cs4270_mode_ratios[i].ratio;
-                rates |= snd_pcm_rate_to_rate_bit(rate);
-                if (rate < rate_min)
-                        rate_min = rate;
-                if (rate > rate_max)
-                        rate_max = rate;
-        }
-        /* FIXME: soc should support a rate list */
-        rates &= ~SNDRV_PCM_RATE_KNOT;
+        if (cs4270->mclk) {
+                for (i = 0; i < NUM_MCLK_RATIOS; i++) {
+                        unsigned int rate = freq / cs4270_mode_ratios[i].ratio;
+                        rates |= snd_pcm_rate_to_rate_bit(rate);
+                        if (rate < rate_min)
+                                rate_min = rate;
+                        if (rate > rate_max)
+                                rate_max = rate;
+                }
+                /* FIXME: soc should support a rate list */
+                rates &= ~SNDRV_PCM_RATE_KNOT;
 
-        if (!rates) {
-                dev_err(codec->dev, "could not find a valid sample rate\n");
-                return -EINVAL;
+                if (!rates) {
+                        dev_err(codec->dev, "could not find a valid sample rate\n");
+                        return -EINVAL;
+                }
+        } else {
+                /* enable all possible rates */
+                rates = SNDRV_PCM_RATE_8000_192000;
+                rate_min = 8000;
+                rate_max = 192000;
         }
 
         codec_dai->playback.rates = rates;
@@ -520,6 +541,7 @@ static const struct snd_kcontrol_new cs4270_snd_controls[] = {
         SOC_SINGLE("Digital Sidetone Switch", CS4270_FORMAT, 5, 1, 0),
         SOC_SINGLE("Soft Ramp Switch", CS4270_TRANS, 6, 1, 0),
         SOC_SINGLE("Zero Cross Switch", CS4270_TRANS, 5, 1, 0),
+        SOC_SINGLE("De-emphasis filter", CS4270_TRANS, 0, 1, 0),
         SOC_SINGLE("Popguard Switch", CS4270_MODE, 0, 1, 1),
         SOC_SINGLE("Auto-Mute Switch", CS4270_MUTE, 5, 1, 0),
         SOC_DOUBLE("Master Capture Switch", CS4270_MUTE, 3, 4, 1, 1),
@@ -578,7 +600,8 @@ static int cs4270_probe(struct platform_device *pdev)
 {
         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
         struct snd_soc_codec *codec = cs4270_codec;
-        int ret;
+        struct cs4270_private *cs4270 = codec->private_data;
+        int i, ret;
 
         /* Connect the codec to the socdev.  snd_soc_new_pcms() needs this. */
         socdev->card->codec = codec;
@@ -598,15 +621,26 @@ static int cs4270_probe(struct platform_device *pdev)
                 goto error_free_pcms;
         }
 
-        /* And finally, register the socdev */
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                dev_err(codec->dev, "failed to register card\n");
+        /* get the power supply regulators */
+        for (i = 0; i < ARRAY_SIZE(supply_names); i++)
+                cs4270->supplies[i].supply = supply_names[i];
+
+        ret = regulator_bulk_get(codec->dev, ARRAY_SIZE(cs4270->supplies),
+                                 cs4270->supplies);
+        if (ret < 0)
                 goto error_free_pcms;
-        }
+
+        ret = regulator_bulk_enable(ARRAY_SIZE(cs4270->supplies),
+                                    cs4270->supplies);
+        if (ret < 0)
+                goto error_free_regulators;
 
         return 0;
 
+error_free_regulators:
+        regulator_bulk_free(ARRAY_SIZE(cs4270->supplies),
+                            cs4270->supplies);
+
 error_free_pcms:
         snd_soc_free_pcms(socdev);
 
@@ -622,8 +656,12 @@ error_free_pcms:
 static int cs4270_remove(struct platform_device *pdev)
 {
         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec = cs4270_codec;
+        struct cs4270_private *cs4270 = codec->private_data;
 
         snd_soc_free_pcms(socdev);
+        regulator_bulk_disable(ARRAY_SIZE(cs4270->supplies), cs4270->supplies);
+        regulator_bulk_free(ARRAY_SIZE(cs4270->supplies), cs4270->supplies);
 
         return 0;
 };
@@ -802,36 +840,36 @@ MODULE_DEVICE_TABLE(i2c, cs4270_id);
  * and all registers are written back to the hardware when resuming.
  */
 
-static int cs4270_i2c_suspend(struct i2c_client *client, pm_message_t mesg)
+static int cs4270_soc_suspend(struct platform_device *pdev, pm_message_t mesg)
 {
-        struct cs4270_private *cs4270 = i2c_get_clientdata(client);
-        struct snd_soc_codec *codec = &cs4270->codec;
-
-        return snd_soc_suspend_device(codec->dev);
-}
+        struct snd_soc_codec *codec = cs4270_codec;
+        struct cs4270_private *cs4270 = codec->private_data;
+        int reg, ret;
 
-static int cs4270_i2c_resume(struct i2c_client *client)
-{
-        struct cs4270_private *cs4270 = i2c_get_clientdata(client);
-        struct snd_soc_codec *codec = &cs4270->codec;
+        reg = snd_soc_read(codec, CS4270_PWRCTL) | CS4270_PWRCTL_PDN_ALL;
+        if (reg < 0)
+                return reg;
 
-        return snd_soc_resume_device(codec->dev);
-}
+        ret = snd_soc_write(codec, CS4270_PWRCTL, reg);
+        if (ret < 0)
+                return ret;
 
-static int cs4270_soc_suspend(struct platform_device *pdev, pm_message_t mesg)
-{
-        struct snd_soc_codec *codec = cs4270_codec;
-        int reg = snd_soc_read(codec, CS4270_PWRCTL) | CS4270_PWRCTL_PDN_ALL;
+        regulator_bulk_disable(ARRAY_SIZE(cs4270->supplies),
+                               cs4270->supplies);
 
-        return snd_soc_write(codec, CS4270_PWRCTL, reg);
+        return 0;
 }
 
 static int cs4270_soc_resume(struct platform_device *pdev)
 {
         struct snd_soc_codec *codec = cs4270_codec;
+        struct cs4270_private *cs4270 = codec->private_data;
         struct i2c_client *i2c_client = codec->control_data;
         int reg;
 
+        regulator_bulk_enable(ARRAY_SIZE(cs4270->supplies),
+                              cs4270->supplies);
+
         /* In case the device was put to hard reset during sleep, we need to
          * wait 500ns here before any I2C communication. */
         ndelay(500);
@@ -853,8 +891,6 @@ static int cs4270_soc_resume(struct platform_device *pdev)
         return snd_soc_write(codec, CS4270_PWRCTL, reg);
 }
 #else
-#define cs4270_i2c_suspend      NULL
-#define cs4270_i2c_resume       NULL
 #define cs4270_soc_suspend      NULL
 #define cs4270_soc_resume       NULL
 #endif /* CONFIG_PM */
@@ -873,8 +909,6 @@ static struct i2c_driver cs4270_i2c_driver = {
         .id_table = cs4270_id,
         .probe = cs4270_i2c_probe,
         .remove = cs4270_i2c_remove,
-        .suspend = cs4270_i2c_suspend,
-        .resume = cs4270_i2c_resume,
 };
 
 /*
diff --git a/sound/soc/codecs/cx20442.c b/sound/soc/codecs/cx20442.c
index 38eac9c866e1..9f169c477108 100644
--- a/sound/soc/codecs/cx20442.c
+++ b/sound/soc/codecs/cx20442.c
@@ -14,6 +14,7 @@
  */
 
 #include <linux/tty.h>
+#include <linux/slab.h>
 
 #include <sound/core.h>
 #include <sound/initval.h>
@@ -93,7 +94,6 @@ static int cx20442_add_widgets(struct snd_soc_codec *codec)
         snd_soc_dapm_add_routes(codec, cx20442_audio_map,
                                 ARRAY_SIZE(cx20442_audio_map));
 
-        snd_soc_dapm_new_widgets(codec);
         return 0;
 }
 
@@ -355,17 +355,6 @@ static int cx20442_codec_probe(struct platform_device *pdev)
 
         cx20442_add_widgets(codec);
 
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                dev_err(&pdev->dev, "failed to register card\n");
-                goto card_err;
-        }
-
-        return ret;
-
-card_err:
-        snd_soc_free_pcms(socdev);
-        snd_soc_dapm_free(socdev);
 pcm_err:
         return ret;
 }
diff --git a/sound/soc/codecs/da7210.c b/sound/soc/codecs/da7210.c
new file mode 100644
index 000000000000..366daf1d044e
--- /dev/null
+++ b/sound/soc/codecs/da7210.c
@@ -0,0 +1,590 @@
+/*
+ * DA7210 ALSA Soc codec driver
+ *
+ * Copyright (c) 2009 Dialog Semiconductor
+ * Written by David Chen <Dajun.chen@diasemi.com>
+ *
+ * Copyright (C) 2009 Renesas Solutions Corp.
+ * Cleanups by Kuninori Morimoto <morimoto.kuninori@renesas.com>
+ *
+ * Tested on SuperH Ecovec24 board with S16/S24 LE in 48KHz using I2S
+ *
+ * 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 the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/pm.h>
+#include <linux/i2c.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+#include <sound/tlv.h>
+#include <sound/initval.h>
+#include <asm/div64.h>
+
+#include "da7210.h"
+
+/* DA7210 register space */
+#define DA7210_STATUS                   0x02
+#define DA7210_STARTUP1                 0x03
+#define DA7210_MIC_L                    0x07
+#define DA7210_MIC_R                    0x08
+#define DA7210_INMIX_L                  0x0D
+#define DA7210_INMIX_R                  0x0E
+#define DA7210_ADC_HPF                  0x0F
+#define DA7210_ADC                      0x10
+#define DA7210_DAC_HPF                  0x14
+#define DA7210_DAC_L                    0x15
+#define DA7210_DAC_R                    0x16
+#define DA7210_DAC_SEL                  0x17
+#define DA7210_OUTMIX_L                 0x1C
+#define DA7210_OUTMIX_R                 0x1D
+#define DA7210_HP_L_VOL                 0x21
+#define DA7210_HP_R_VOL                 0x22
+#define DA7210_HP_CFG                   0x23
+#define DA7210_DAI_SRC_SEL              0x25
+#define DA7210_DAI_CFG1                 0x26
+#define DA7210_DAI_CFG3                 0x28
+#define DA7210_PLL_DIV3                 0x2B
+#define DA7210_PLL                      0x2C
+
+/* STARTUP1 bit fields */
+#define DA7210_SC_MST_EN                (1 << 0)
+
+/* MIC_L bit fields */
+#define DA7210_MICBIAS_EN               (1 << 6)
+#define DA7210_MIC_L_EN                 (1 << 7)
+
+/* MIC_R bit fields */
+#define DA7210_MIC_R_EN                 (1 << 7)
+
+/* INMIX_L bit fields */
+#define DA7210_IN_L_EN                  (1 << 7)
+
+/* INMIX_R bit fields */
+#define DA7210_IN_R_EN                  (1 << 7)
+
+/* ADC_HPF bit fields */
+#define DA7210_ADC_VOICE_EN             (1 << 7)
+
+/* ADC bit fields */
+#define DA7210_ADC_L_EN                 (1 << 3)
+#define DA7210_ADC_R_EN                 (1 << 7)
+
+/* DAC_HPF fields */
+#define DA7210_DAC_VOICE_EN             (1 << 7)
+
+/* DAC_SEL bit fields */
+#define DA7210_DAC_L_SRC_DAI_L          (4 << 0)
+#define DA7210_DAC_L_EN                 (1 << 3)
+#define DA7210_DAC_R_SRC_DAI_R          (5 << 4)
+#define DA7210_DAC_R_EN                 (1 << 7)
+
+/* OUTMIX_L bit fields */
+#define DA7210_OUT_L_EN                 (1 << 7)
+
+/* OUTMIX_R bit fields */
+#define DA7210_OUT_R_EN                 (1 << 7)
+
+/* HP_CFG bit fields */
+#define DA7210_HP_2CAP_MODE             (1 << 1)
+#define DA7210_HP_SENSE_EN              (1 << 2)
+#define DA7210_HP_L_EN                  (1 << 3)
+#define DA7210_HP_MODE                  (1 << 6)
+#define DA7210_HP_R_EN                  (1 << 7)
+
+/* DAI_SRC_SEL bit fields */
+#define DA7210_DAI_OUT_L_SRC            (6 << 0)
+#define DA7210_DAI_OUT_R_SRC            (7 << 4)
+
+/* DAI_CFG1 bit fields */
+#define DA7210_DAI_WORD_S16_LE          (0 << 0)
+#define DA7210_DAI_WORD_S24_LE          (2 << 0)
+#define DA7210_DAI_FLEN_64BIT           (1 << 2)
+#define DA7210_DAI_MODE_MASTER          (1 << 7)
+
+/* DAI_CFG3 bit fields */
+#define DA7210_DAI_FORMAT_I2SMODE       (0 << 0)
+#define DA7210_DAI_OE                   (1 << 3)
+#define DA7210_DAI_EN                   (1 << 7)
+
+/*PLL_DIV3 bit fields */
+#define DA7210_MCLK_RANGE_10_20_MHZ     (1 << 4)
+#define DA7210_PLL_BYP                  (1 << 6)
+
+/* PLL bit fields */
+#define DA7210_PLL_FS_48000             (11 << 0)
+
+#define DA7210_VERSION "0.0.1"
+
+/* Codec private data */
+struct da7210_priv {
+        struct snd_soc_codec codec;
+};
+
+static struct snd_soc_codec *da7210_codec;
+
+/*
+ * Register cache
+ */
+static const u8 da7210_reg[] = {
+        0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* R0  - R7  */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, /* R8  - RF  */
+        0x00, 0x00, 0x00, 0x00, 0x08, 0x10, 0x10, 0x54, /* R10 - R17 */
+        0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* R18 - R1F */
+        0x00, 0x00, 0x00, 0x02, 0x00, 0x76, 0x00, 0x00, /* R20 - R27 */
+        0x04, 0x00, 0x00, 0x30, 0x2A, 0x00, 0x40, 0x00, /* R28 - R2F */
+        0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, /* R30 - R37 */
+        0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x00, 0x00, /* R38 - R3F */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* R40 - R4F */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* R48 - R4F */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* R50 - R57 */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* R58 - R5F */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* R60 - R67 */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* R68 - R6F */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* R70 - R77 */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x54, 0x54, 0x00, /* R78 - R7F */
+        0x00, 0x00, 0x2C, 0x00, 0x00, 0x00, 0x00, 0x00, /* R80 - R87 */
+        0x00,                                           /* R88       */
+};
+
+/*
+ * Read da7210 register cache
+ */
+static inline u32 da7210_read_reg_cache(struct snd_soc_codec *codec, u32 reg)
+{
+        u8 *cache = codec->reg_cache;
+        BUG_ON(reg > ARRAY_SIZE(da7210_reg));
+        return cache[reg];
+}
+
+/*
+ * Write to the da7210 register space
+ */
+static int da7210_write(struct snd_soc_codec *codec, u32 reg, u32 value)
+{
+        u8 *cache = codec->reg_cache;
+        u8 data[2];
+
+        BUG_ON(codec->volatile_register);
+
+        data[0] = reg & 0xff;
+        data[1] = value & 0xff;
+
+        if (reg >= codec->reg_cache_size)
+                return -EIO;
+
+        if (2 != codec->hw_write(codec->control_data, data, 2))
+                return -EIO;
+
+        cache[reg] = value;
+        return 0;
+}
+
+/*
+ * Read from the da7210 register space.
+ */
+static inline u32 da7210_read(struct snd_soc_codec *codec, u32 reg)
+{
+        if (DA7210_STATUS == reg)
+                return i2c_smbus_read_byte_data(codec->control_data, reg);
+
+        return da7210_read_reg_cache(codec, reg);
+}
+
+static int da7210_startup(struct snd_pcm_substream *substream,
+                          struct snd_soc_dai *dai)
+{
+        int is_play = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;
+        struct snd_soc_codec *codec = dai->codec;
+
+        if (is_play) {
+                /* PlayBack Volume 40 */
+                snd_soc_update_bits(codec, DA7210_HP_L_VOL, 0x3F, 40);
+                snd_soc_update_bits(codec, DA7210_HP_R_VOL, 0x3F, 40);
+
+                /* Enable Out */
+                snd_soc_update_bits(codec, DA7210_OUTMIX_L, 0x1F, 0x10);
+                snd_soc_update_bits(codec, DA7210_OUTMIX_R, 0x1F, 0x10);
+
+        } else {
+                /* Volume 7 */
+                snd_soc_update_bits(codec, DA7210_MIC_L, 0x7, 0x7);
+                snd_soc_update_bits(codec, DA7210_MIC_R, 0x7, 0x7);
+
+                /* Enable Mic */
+                snd_soc_update_bits(codec, DA7210_INMIX_L, 0x1F, 0x1);
+                snd_soc_update_bits(codec, DA7210_INMIX_R, 0x1F, 0x1);
+        }
+
+        return 0;
+}
+
+/*
+ * Set PCM DAI word length.
+ */
+static int da7210_hw_params(struct snd_pcm_substream *substream,
+                            struct snd_pcm_hw_params *params,
+                            struct snd_soc_dai *dai)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_device *socdev = rtd->socdev;
+        struct snd_soc_codec *codec = socdev->card->codec;
+        u32 dai_cfg1;
+        u32 reg, mask;
+
+        /* set DAI source to Left and Right ADC */
+        da7210_write(codec, DA7210_DAI_SRC_SEL,
+                     DA7210_DAI_OUT_R_SRC | DA7210_DAI_OUT_L_SRC);
+
+        /* Enable DAI */
+        da7210_write(codec, DA7210_DAI_CFG3, DA7210_DAI_OE | DA7210_DAI_EN);
+
+        dai_cfg1 = 0xFC & da7210_read(codec, DA7210_DAI_CFG1);
+
+        switch (params_format(params)) {
+        case SNDRV_PCM_FORMAT_S16_LE:
+                dai_cfg1 |= DA7210_DAI_WORD_S16_LE;
+                break;
+        case SNDRV_PCM_FORMAT_S24_LE:
+                dai_cfg1 |= DA7210_DAI_WORD_S24_LE;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        da7210_write(codec, DA7210_DAI_CFG1, dai_cfg1);
+
+        /* FIXME
+         *
+         * It support 48K only now
+         */
+        switch (params_rate(params)) {
+        case 48000:
+                if (SNDRV_PCM_STREAM_PLAYBACK == substream->stream) {
+                        reg  = DA7210_DAC_HPF;
+                        mask = DA7210_DAC_VOICE_EN;
+                } else {
+                        reg  = DA7210_ADC_HPF;
+                        mask = DA7210_ADC_VOICE_EN;
+                }
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        snd_soc_update_bits(codec, reg, mask, 0);
+
+        return 0;
+}
+
+/*
+ * Set DAI mode and Format
+ */
+static int da7210_set_dai_fmt(struct snd_soc_dai *codec_dai, u32 fmt)
+{
+        struct snd_soc_codec *codec = codec_dai->codec;
+        u32 dai_cfg1;
+        u32 dai_cfg3;
+
+        dai_cfg1 = 0x7f & da7210_read(codec, DA7210_DAI_CFG1);
+        dai_cfg3 = 0xfc & da7210_read(codec, DA7210_DAI_CFG3);
+
+        switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
+        case SND_SOC_DAIFMT_CBM_CFM:
+                dai_cfg1 |= DA7210_DAI_MODE_MASTER;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        /* FIXME
+         *
+         * It support I2S only now
+         */
+        switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
+        case SND_SOC_DAIFMT_I2S:
+                dai_cfg3 |= DA7210_DAI_FORMAT_I2SMODE;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        /* FIXME
+         *
+         * It support 64bit data transmission only now
+         */
+        dai_cfg1 |= DA7210_DAI_FLEN_64BIT;
+
+        da7210_write(codec, DA7210_DAI_CFG1, dai_cfg1);
+        da7210_write(codec, DA7210_DAI_CFG3, dai_cfg3);
+
+        return 0;
+}
+
+#define DA7210_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE)
+
+/* DAI operations */
+static struct snd_soc_dai_ops da7210_dai_ops = {
+        .startup        = da7210_startup,
+        .hw_params      = da7210_hw_params,
+        .set_fmt        = da7210_set_dai_fmt,
+};
+
+struct snd_soc_dai da7210_dai = {
+        .name = "DA7210 IIS",
+        .id = 0,
+        /* playback capabilities */
+        .playback = {
+                .stream_name = "Playback",
+                .channels_min = 1,
+                .channels_max = 2,
+                .rates = SNDRV_PCM_RATE_8000_96000,
+                .formats = DA7210_FORMATS,
+        },
+        /* capture capabilities */
+        .capture = {
+                .stream_name = "Capture",
+                .channels_min = 1,
+                .channels_max = 2,
+                .rates = SNDRV_PCM_RATE_8000_96000,
+                .formats = DA7210_FORMATS,
+        },
+        .ops = &da7210_dai_ops,
+};
+EXPORT_SYMBOL_GPL(da7210_dai);
+
+/*
+ * Initialize the DA7210 driver
+ * register the mixer and dsp interfaces with the kernel
+ */
+static int da7210_init(struct da7210_priv *da7210)
+{
+        struct snd_soc_codec *codec = &da7210->codec;
+        int ret = 0;
+
+        if (da7210_codec) {
+                dev_err(codec->dev, "Another da7210 is registered\n");
+                return -EINVAL;
+        }
+
+        mutex_init(&codec->mutex);
+        INIT_LIST_HEAD(&codec->dapm_widgets);
+        INIT_LIST_HEAD(&codec->dapm_paths);
+
+        codec->private_data     = da7210;
+        codec->name             = "DA7210";
+        codec->owner            = THIS_MODULE;
+        codec->read             = da7210_read;
+        codec->write            = da7210_write;
+        codec->dai              = &da7210_dai;
+        codec->num_dai          = 1;
+        codec->hw_write         = (hw_write_t)i2c_master_send;
+        codec->reg_cache_size   = ARRAY_SIZE(da7210_reg);
+        codec->reg_cache        = kmemdup(da7210_reg,
+                                          sizeof(da7210_reg), GFP_KERNEL);
+
+        if (!codec->reg_cache)
+                return -ENOMEM;
+
+        da7210_dai.dev = codec->dev;
+        da7210_codec = codec;
+
+        ret = snd_soc_register_codec(codec);
+        if (ret) {
+                dev_err(codec->dev, "Failed to register CODEC: %d\n", ret);
+                goto init_err;
+        }
+
+        ret = snd_soc_register_dai(&da7210_dai);
+        if (ret) {
+                dev_err(codec->dev, "Failed to register DAI: %d\n", ret);
+                goto init_err;
+        }
+
+        /* FIXME
+         *
+         * This driver use fixed value here
+         */
+
+        /*
+         * ADC settings
+         */
+
+        /* Enable Left & Right MIC PGA and Mic Bias */
+        da7210_write(codec, DA7210_MIC_L, DA7210_MIC_L_EN | DA7210_MICBIAS_EN);
+        da7210_write(codec, DA7210_MIC_R, DA7210_MIC_R_EN);
+
+        /* Enable Left and Right input PGA */
+        da7210_write(codec, DA7210_INMIX_L, DA7210_IN_L_EN);
+        da7210_write(codec, DA7210_INMIX_R, DA7210_IN_R_EN);
+
+        /* Enable Left and Right ADC */
+        da7210_write(codec, DA7210_ADC, DA7210_ADC_L_EN | DA7210_ADC_R_EN);
+
+        /*
+         * DAC settings
+         */
+
+        /* Enable Left and Right DAC */
+        da7210_write(codec, DA7210_DAC_SEL,
+                     DA7210_DAC_L_SRC_DAI_L | DA7210_DAC_L_EN |
+                     DA7210_DAC_R_SRC_DAI_R | DA7210_DAC_R_EN);
+
+        /* Enable Left and Right out PGA */
+        da7210_write(codec, DA7210_OUTMIX_L, DA7210_OUT_L_EN);
+        da7210_write(codec, DA7210_OUTMIX_R, DA7210_OUT_R_EN);
+
+        /* Enable Left and Right HeadPhone PGA */
+        da7210_write(codec, DA7210_HP_CFG,
+                     DA7210_HP_2CAP_MODE | DA7210_HP_SENSE_EN |
+                     DA7210_HP_L_EN | DA7210_HP_MODE | DA7210_HP_R_EN);
+
+        /* Diable PLL and bypass it */
+        da7210_write(codec, DA7210_PLL, DA7210_PLL_FS_48000);
+
+        /* Bypass PLL and set MCLK freq rang to 10-20MHz */
+        da7210_write(codec, DA7210_PLL_DIV3,
+                     DA7210_MCLK_RANGE_10_20_MHZ | DA7210_PLL_BYP);
+
+        /* Activate all enabled subsystem */
+        da7210_write(codec, DA7210_STARTUP1, DA7210_SC_MST_EN);
+
+        return ret;
+
+init_err:
+        kfree(codec->reg_cache);
+        codec->reg_cache = NULL;
+
+        return ret;
+
+}
+
+#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+static int __devinit da7210_i2c_probe(struct i2c_client *i2c,
+                                      const struct i2c_device_id *id)
+{
+        struct da7210_priv *da7210;
+        struct snd_soc_codec *codec;
+        int ret;
+
+        da7210 = kzalloc(sizeof(struct da7210_priv), GFP_KERNEL);
+        if (!da7210)
+                return -ENOMEM;
+
+        codec = &da7210->codec;
+        codec->dev = &i2c->dev;
+
+        i2c_set_clientdata(i2c, da7210);
+        codec->control_data = i2c;
+
+        ret = da7210_init(da7210);
+        if (ret < 0)
+                pr_err("Failed to initialise da7210 audio codec\n");
+
+        return ret;
+}
+
+static int __devexit da7210_i2c_remove(struct i2c_client *client)
+{
+        struct da7210_priv *da7210 = i2c_get_clientdata(client);
+
+        snd_soc_unregister_dai(&da7210_dai);
+        kfree(da7210->codec.reg_cache);
+        kfree(da7210);
+        da7210_codec = NULL;
+
+        return 0;
+}
+
+static const struct i2c_device_id da7210_i2c_id[] = {
+        { "da7210", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, da7210_i2c_id);
+
+/* I2C codec control layer */
+static struct i2c_driver da7210_i2c_driver = {
+        .driver = {
+                .name = "DA7210 I2C Codec",
+                .owner = THIS_MODULE,
+        },
+        .probe = da7210_i2c_probe,
+        .remove =  __devexit_p(da7210_i2c_remove),
+        .id_table = da7210_i2c_id,
+};
+#endif
+
+static int da7210_probe(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec;
+        int ret;
+
+        if (!da7210_codec) {
+                dev_err(&pdev->dev, "Codec device not registered\n");
+                return -ENODEV;
+        }
+
+        socdev->card->codec = da7210_codec;
+        codec = da7210_codec;
+
+        /* Register pcms */
+        ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
+        if (ret < 0)
+                goto pcm_err;
+
+        dev_info(&pdev->dev, "DA7210 Audio Codec %s\n", DA7210_VERSION);
+
+pcm_err:
+        return ret;
+}
+
+static int da7210_remove(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+
+        snd_soc_free_pcms(socdev);
+        snd_soc_dapm_free(socdev);
+
+        return 0;
+}
+
+struct snd_soc_codec_device soc_codec_dev_da7210 = {
+        .probe =        da7210_probe,
+        .remove =       da7210_remove,
+};
+EXPORT_SYMBOL_GPL(soc_codec_dev_da7210);
+
+static int __init da7210_modinit(void)
+{
+        int ret = 0;
+#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+        ret = i2c_add_driver(&da7210_i2c_driver);
+#endif
+        return ret;
+}
+module_init(da7210_modinit);
+
+static void __exit da7210_exit(void)
+{
+#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+        i2c_del_driver(&da7210_i2c_driver);
+#endif
+}
+module_exit(da7210_exit);
+
+MODULE_DESCRIPTION("ASoC DA7210 driver");
+MODULE_AUTHOR("David Chen, Kuninori Morimoto");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/codecs/da7210.h b/sound/soc/codecs/da7210.h
new file mode 100644
index 000000000000..390d621eb742
--- /dev/null
+++ b/sound/soc/codecs/da7210.h
@@ -0,0 +1,24 @@
+/*
+ * da7210.h  --  audio driver for da7210
+ *
+ * Copyright (c) 2009 Dialog Semiconductor
+ * Written by David Chen <Dajun.chen@diasemi.com>
+ *
+ * Copyright (C) 2009 Renesas Solutions Corp.
+ * Cleanups by Kuninori Morimoto <morimoto.kuninori@renesas.com>
+ *
+ * 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 the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ *
+ */
+
+#ifndef _DA7210_H
+#define _DA7210_H
+
+extern struct snd_soc_dai da7210_dai;
+extern struct snd_soc_codec_device soc_codec_dev_da7210;
+
+#endif
+
diff --git a/sound/soc/codecs/pcm3008.c b/sound/soc/codecs/pcm3008.c
index 5cda9e6b5a74..5a5f187a2657 100644
--- a/sound/soc/codecs/pcm3008.c
+++ b/sound/soc/codecs/pcm3008.c
@@ -19,6 +19,7 @@
 #include <linux/kernel.h>
 #include <linux/device.h>
 #include <linux/gpio.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/initval.h>
@@ -90,13 +91,6 @@ static int pcm3008_soc_probe(struct platform_device *pdev)
                 goto pcm_err;
         }
 
-        /* Register Card. */
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                printk(KERN_ERR "pcm3008: failed to register card\n");
-                goto card_err;
-        }
-
         /* DEM1  DEM0  DE-EMPHASIS_MODE
          * Low   Low   De-emphasis 44.1 kHz ON
          * Low   High  De-emphasis OFF
@@ -136,8 +130,6 @@ static int pcm3008_soc_probe(struct platform_device *pdev)
 
 gpio_err:
         pcm3008_gpio_free(setup);
-card_err:
-        snd_soc_free_pcms(socdev);
 pcm_err:
         kfree(socdev->card->codec);
 
diff --git a/sound/soc/codecs/ssm2602.c b/sound/soc/codecs/ssm2602.c
index c550750c79c0..29d0906a924a 100644
--- a/sound/soc/codecs/ssm2602.c
+++ b/sound/soc/codecs/ssm2602.c
@@ -33,6 +33,7 @@
 #include <linux/pm.h>
 #include <linux/i2c.h>
 #include <linux/platform_device.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
@@ -210,7 +211,6 @@ static int ssm2602_add_widgets(struct snd_soc_codec *codec)
 
         snd_soc_dapm_add_routes(codec, audio_conn, ARRAY_SIZE(audio_conn));
 
-        snd_soc_dapm_new_widgets(codec);
         return 0;
 }
 
@@ -613,17 +613,9 @@ static int ssm2602_init(struct snd_soc_device *socdev)
         snd_soc_add_controls(codec, ssm2602_snd_controls,
                                 ARRAY_SIZE(ssm2602_snd_controls));
         ssm2602_add_widgets(codec);
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                pr_err("ssm2602: failed to register card\n");
-                goto card_err;
-        }
 
         return ret;
 
-card_err:
-        snd_soc_free_pcms(socdev);
-        snd_soc_dapm_free(socdev);
 pcm_err:
         kfree(codec->reg_cache);
         return ret;
diff --git a/sound/soc/codecs/stac9766.c b/sound/soc/codecs/stac9766.c
index befc6488c39a..3293629dcb3b 100644
--- a/sound/soc/codecs/stac9766.c
+++ b/sound/soc/codecs/stac9766.c
@@ -15,6 +15,7 @@
  */
 
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/device.h>
 #include <sound/core.h>
@@ -191,6 +192,7 @@ static int ac97_analog_prepare(struct snd_pcm_substream *substream,
         vra = stac9766_ac97_read(codec, AC97_EXTENDED_STATUS);
 
         vra |= 0x1; /* enable variable rate audio */
+        vra &= ~0x4; /* disable SPDIF output */
 
         stac9766_ac97_write(codec, AC97_EXTENDED_STATUS, vra);
 
@@ -221,22 +223,6 @@ static int ac97_digital_prepare(struct snd_pcm_substream *substream,
         return stac9766_ac97_write(codec, reg, runtime->rate);
 }
 
-static int ac97_digital_trigger(struct snd_pcm_substream *substream,
-                                int cmd, struct snd_soc_dai *dai)
-{
-        struct snd_soc_codec *codec = dai->codec;
-        unsigned short vra;
-
-        switch (cmd) {
-        case SNDRV_PCM_TRIGGER_STOP:
-                vra = stac9766_ac97_read(codec, AC97_EXTENDED_STATUS);
-                vra &= !0x04;
-                stac9766_ac97_write(codec, AC97_EXTENDED_STATUS, vra);
-                break;
-        }
-        return 0;
-}
-
 static int stac9766_set_bias_level(struct snd_soc_codec *codec,
                                    enum snd_soc_bias_level level)
 {
@@ -315,7 +301,6 @@ static struct snd_soc_dai_ops stac9766_dai_ops_analog = {
 
 static struct snd_soc_dai_ops stac9766_dai_ops_digital = {
         .prepare = ac97_digital_prepare,
-        .trigger = ac97_digital_trigger,
 };
 
 struct snd_soc_dai stac9766_dai[] = {
@@ -418,9 +403,6 @@ static int stac9766_codec_probe(struct platform_device *pdev)
         snd_soc_add_controls(codec, stac9766_snd_ac97_controls,
                              ARRAY_SIZE(stac9766_snd_ac97_controls));
 
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0)
-                goto reset_err;
         return 0;
 
 reset_err:
diff --git a/sound/soc/codecs/tlv320aic23.c b/sound/soc/codecs/tlv320aic23.c
index 90a0264f7538..776b79cde904 100644
--- a/sound/soc/codecs/tlv320aic23.c
+++ b/sound/soc/codecs/tlv320aic23.c
@@ -25,6 +25,7 @@
 #include <linux/pm.h>
 #include <linux/i2c.h>
 #include <linux/platform_device.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
@@ -85,7 +86,7 @@ static int tlv320aic23_write(struct snd_soc_codec *codec, unsigned int reg,
          * of data into val
          */
 
-        if ((reg < 0 || reg > 9) && (reg != 15)) {
+        if (reg > 9 && reg != 15) {
                 printk(KERN_WARNING "%s Invalid register R%u\n", __func__, reg);
                 return -1;
         }
@@ -395,7 +396,6 @@ static int tlv320aic23_add_widgets(struct snd_soc_codec *codec)
         /* set up audio path interconnects */
         snd_soc_dapm_add_routes(codec, intercon, ARRAY_SIZE(intercon));
 
-        snd_soc_dapm_new_widgets(codec);
         return 0;
 }
 
@@ -628,7 +628,7 @@ static int tlv320aic23_resume(struct platform_device *pdev)
         u16 reg;
 
         /* Sync reg_cache with the hardware */
-        for (reg = 0; reg < TLV320AIC23_RESET; reg++) {
+        for (reg = 0; reg <= TLV320AIC23_ACTIVE; reg++) {
                 u16 val = tlv320aic23_read_reg_cache(codec, reg);
                 tlv320aic23_write(codec, reg, val);
         }
@@ -706,17 +706,9 @@ static int tlv320aic23_init(struct snd_soc_device *socdev)
         snd_soc_add_controls(codec, tlv320aic23_snd_controls,
                                 ARRAY_SIZE(tlv320aic23_snd_controls));
         tlv320aic23_add_widgets(codec);
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                printk(KERN_ERR "tlv320aic23: failed to register card\n");
-                goto card_err;
-        }
 
         return ret;
 
-card_err:
-        snd_soc_free_pcms(socdev);
-        snd_soc_dapm_free(socdev);
 pcm_err:
         kfree(codec->reg_cache);
         return ret;
diff --git a/sound/soc/codecs/tlv320aic26.c b/sound/soc/codecs/tlv320aic26.c
index 3387d9e736ea..b5b7d6a03844 100644
--- a/sound/soc/codecs/tlv320aic26.c
+++ b/sound/soc/codecs/tlv320aic26.c
@@ -13,6 +13,7 @@
 #include <linux/device.h>
 #include <linux/sysfs.h>
 #include <linux/spi/spi.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
@@ -356,18 +357,7 @@ static int aic26_probe(struct platform_device *pdev)
                         ARRAY_SIZE(aic26_snd_controls));
         WARN_ON(err < 0);
 
-        /* CODEC is setup, we can register the card now */
-        dev_dbg(&pdev->dev, "Registering card\n");
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                dev_err(&pdev->dev, "aic26: failed to register card\n");
-                goto card_err;
-        }
         return 0;
-
- card_err:
-        snd_soc_free_pcms(socdev);
-        return ret;
 }
 
 static int aic26_remove(struct platform_device *pdev)
diff --git a/sound/soc/codecs/tlv320aic3x.c b/sound/soc/codecs/tlv320aic3x.c
index 3395cf945d56..4a6d56c3fed9 100644
--- a/sound/soc/codecs/tlv320aic3x.c
+++ b/sound/soc/codecs/tlv320aic3x.c
@@ -39,6 +39,7 @@
 #include <linux/pm.h>
 #include <linux/i2c.h>
 #include <linux/platform_device.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
@@ -753,7 +754,6 @@ static int aic3x_add_widgets(struct snd_soc_codec *codec)
         /* set up audio path interconnects */
         snd_soc_dapm_add_routes(codec, intercon, ARRAY_SIZE(intercon));
 
-        snd_soc_dapm_new_widgets(codec);
         return 0;
 }
 
@@ -766,9 +766,10 @@ static int aic3x_hw_params(struct snd_pcm_substream *substream,
         struct snd_soc_codec *codec = socdev->card->codec;
         struct aic3x_priv *aic3x = codec->private_data;
         int codec_clk = 0, bypass_pll = 0, fsref, last_clk = 0;
-        u8 data, r, p, pll_q, pll_p = 1, pll_r = 1, pll_j = 1;
-        u16 pll_d = 1;
+        u8 data, j, r, p, pll_q, pll_p = 1, pll_r = 1, pll_j = 1;
+        u16 d, pll_d = 1;
         u8 reg;
+        int clk;
 
         /* select data word length */
         data =
@@ -834,48 +835,70 @@ static int aic3x_hw_params(struct snd_pcm_substream *substream,
         if (bypass_pll)
                 return 0;
 
-        /* Use PLL
-         * find an apropriate setup for j, d, r and p by iterating over
-         * p and r - j and d are calculated for each fraction.
-         * Up to 128 values are probed, the closest one wins the game.
+        /* Use PLL, compute apropriate setup for j, d, r and p, the closest
+         * one wins the game. Try with d==0 first, next with d!=0.
+         * Constraints for j are according to the datasheet.
          * The sysclk is divided by 1000 to prevent integer overflows.
          */
+
         codec_clk = (2048 * fsref) / (aic3x->sysclk / 1000);
 
         for (r = 1; r <= 16; r++)
                 for (p = 1; p <= 8; p++) {
-                        int clk, tmp = (codec_clk * pll_r * 10) / pll_p;
-                        u8 j = tmp / 10000;
-                        u16 d = tmp % 10000;
+                        for (j = 4; j <= 55; j++) {
+                                /* This is actually 1000*((j+(d/10000))*r)/p
+                                 * The term had to be converted to get
+                                 * rid of the division by 10000; d = 0 here
+                                 */
+                                int tmp_clk = (1000 * j * r) / p;
+
+                                /* Check whether this values get closer than
+                                 * the best ones we had before
+                                 */
+                                if (abs(codec_clk - tmp_clk) <
+                                        abs(codec_clk - last_clk)) {
+                                        pll_j = j; pll_d = 0;
+                                        pll_r = r; pll_p = p;
+                                        last_clk = tmp_clk;
+                                }
+
+                                /* Early exit for exact matches */
+                                if (tmp_clk == codec_clk)
+                                        goto found;
+                        }
+                }
 
-                        if (j > 63)
-                                continue;
+        /* try with d != 0 */
+        for (p = 1; p <= 8; p++) {
+                j = codec_clk * p / 1000;
 
-                        if (d != 0 && aic3x->sysclk < 10000000)
-                                continue;
+                if (j < 4 || j > 11)
+                        continue;
 
-                        /* This is actually 1000 * ((j + (d/10000)) * r) / p
-                         * The term had to be converted to get rid of the
-                         * division by 10000 */
-                        clk = ((10000 * j * r) + (d * r)) / (10 * p);
+                /* do not use codec_clk here since we'd loose precision */
+                d = ((2048 * p * fsref) - j * aic3x->sysclk)
+                        * 100 / (aic3x->sysclk/100);
 
-                        /* check whether this values get closer than the best
-                         * ones we had before */
-                        if (abs(codec_clk - clk) < abs(codec_clk - last_clk)) {
-                                pll_j = j; pll_d = d; pll_r = r; pll_p = p;
-                                last_clk = clk;
-                        }
+                clk = (10000 * j + d) / (10 * p);
 
-                        /* Early exit for exact matches */
-                        if (clk == codec_clk)
-                                break;
+                /* check whether this values get closer than the best
+                 * ones we had before */
+                if (abs(codec_clk - clk) < abs(codec_clk - last_clk)) {
+                        pll_j = j; pll_d = d; pll_r = 1; pll_p = p;
+                        last_clk = clk;
                 }
 
+                /* Early exit for exact matches */
+                if (clk == codec_clk)
+                        goto found;
+        }
+
         if (last_clk == 0) {
                 printk(KERN_ERR "%s(): unable to setup PLL\n", __func__);
                 return -EINVAL;
         }
 
+found:
         data = aic3x_read_reg_cache(codec, AIC3X_PLL_PROGA_REG);
         aic3x_write(codec, AIC3X_PLL_PROGA_REG, data | (pll_p << PLLP_SHIFT));
         aic3x_write(codec, AIC3X_OVRF_STATUS_AND_PLLR_REG, pll_r << PLLR_SHIFT);
@@ -1405,18 +1428,8 @@ static int aic3x_probe(struct platform_device *pdev)
 
         aic3x_add_widgets(codec);
 
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                printk(KERN_ERR "aic3x: failed to register card\n");
-                goto card_err;
-        }
-
         return ret;
 
-card_err:
-        snd_soc_free_pcms(socdev);
-        snd_soc_dapm_free(socdev);
-
 pcm_err:
         kfree(codec->reg_cache);
         return ret;
diff --git a/sound/soc/codecs/tlv320dac33.c b/sound/soc/codecs/tlv320dac33.c
new file mode 100644
index 000000000000..d1e0e81ef30c
--- /dev/null
+++ b/sound/soc/codecs/tlv320dac33.c
@@ -0,0 +1,1423 @@
+/*
+ * ALSA SoC Texas Instruments TLV320DAC33 codec driver
+ *
+ * Author:      Peter Ujfalusi <peter.ujfalusi@nokia.com>
+ *
+ * Copyright:   (C) 2009 Nokia Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program 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., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/pm.h>
+#include <linux/i2c.h>
+#include <linux/platform_device.h>
+#include <linux/interrupt.h>
+#include <linux/gpio.h>
+#include <linux/regulator/consumer.h>
+#include <linux/slab.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+#include <sound/initval.h>
+#include <sound/tlv.h>
+
+#include <sound/tlv320dac33-plat.h>
+#include "tlv320dac33.h"
+
+#define DAC33_BUFFER_SIZE_BYTES         24576   /* bytes, 12288 16 bit words,
+                                                 * 6144 stereo */
+#define DAC33_BUFFER_SIZE_SAMPLES       6144
+
+#define NSAMPLE_MAX             5700
+
+#define LATENCY_TIME_MS         20
+
+static struct snd_soc_codec *tlv320dac33_codec;
+
+enum dac33_state {
+        DAC33_IDLE = 0,
+        DAC33_PREFILL,
+        DAC33_PLAYBACK,
+        DAC33_FLUSH,
+};
+
+enum dac33_fifo_modes {
+        DAC33_FIFO_BYPASS = 0,
+        DAC33_FIFO_MODE1,
+        DAC33_FIFO_MODE7,
+        DAC33_FIFO_LAST_MODE,
+};
+
+#define DAC33_NUM_SUPPLIES 3
+static const char *dac33_supply_names[DAC33_NUM_SUPPLIES] = {
+        "AVDD",
+        "DVDD",
+        "IOVDD",
+};
+
+struct tlv320dac33_priv {
+        struct mutex mutex;
+        struct workqueue_struct *dac33_wq;
+        struct work_struct work;
+        struct snd_soc_codec codec;
+        struct regulator_bulk_data supplies[DAC33_NUM_SUPPLIES];
+        int power_gpio;
+        int chip_power;
+        int irq;
+        unsigned int refclk;
+
+        unsigned int alarm_threshold;   /* set to be half of LATENCY_TIME_MS */
+        unsigned int nsample_min;       /* nsample should not be lower than
+                                         * this */
+        unsigned int nsample_max;       /* nsample should not be higher than
+                                         * this */
+        enum dac33_fifo_modes fifo_mode;/* FIFO mode selection */
+        unsigned int nsample;           /* burst read amount from host */
+        u8 burst_bclkdiv;               /* BCLK divider value in burst mode */
+
+        enum dac33_state state;
+};
+
+static const u8 dac33_reg[DAC33_CACHEREGNUM] = {
+0x00, 0x00, 0x00, 0x00, /* 0x00 - 0x03 */
+0x00, 0x00, 0x00, 0x00, /* 0x04 - 0x07 */
+0x00, 0x00, 0x00, 0x00, /* 0x08 - 0x0b */
+0x00, 0x00, 0x00, 0x00, /* 0x0c - 0x0f */
+0x00, 0x00, 0x00, 0x00, /* 0x10 - 0x13 */
+0x00, 0x00, 0x00, 0x00, /* 0x14 - 0x17 */
+0x00, 0x00, 0x00, 0x00, /* 0x18 - 0x1b */
+0x00, 0x00, 0x00, 0x00, /* 0x1c - 0x1f */
+0x00, 0x00, 0x00, 0x00, /* 0x20 - 0x23 */
+0x00, 0x00, 0x00, 0x00, /* 0x24 - 0x27 */
+0x00, 0x00, 0x00, 0x00, /* 0x28 - 0x2b */
+0x00, 0x00, 0x00, 0x80, /* 0x2c - 0x2f */
+0x80, 0x00, 0x00, 0x00, /* 0x30 - 0x33 */
+0x00, 0x00, 0x00, 0x00, /* 0x34 - 0x37 */
+0x00, 0x00,             /* 0x38 - 0x39 */
+/* Registers 0x3a - 0x3f are reserved  */
+            0x00, 0x00, /* 0x3a - 0x3b */
+0x00, 0x00, 0x00, 0x00, /* 0x3c - 0x3f */
+
+0x00, 0x00, 0x00, 0x00, /* 0x40 - 0x43 */
+0x00, 0x80,             /* 0x44 - 0x45 */
+/* Registers 0x46 - 0x47 are reserved  */
+            0x80, 0x80, /* 0x46 - 0x47 */
+
+0x80, 0x00, 0x00,       /* 0x48 - 0x4a */
+/* Registers 0x4b - 0x7c are reserved  */
+                  0x00, /* 0x4b        */
+0x00, 0x00, 0x00, 0x00, /* 0x4c - 0x4f */
+0x00, 0x00, 0x00, 0x00, /* 0x50 - 0x53 */
+0x00, 0x00, 0x00, 0x00, /* 0x54 - 0x57 */
+0x00, 0x00, 0x00, 0x00, /* 0x58 - 0x5b */
+0x00, 0x00, 0x00, 0x00, /* 0x5c - 0x5f */
+0x00, 0x00, 0x00, 0x00, /* 0x60 - 0x63 */
+0x00, 0x00, 0x00, 0x00, /* 0x64 - 0x67 */
+0x00, 0x00, 0x00, 0x00, /* 0x68 - 0x6b */
+0x00, 0x00, 0x00, 0x00, /* 0x6c - 0x6f */
+0x00, 0x00, 0x00, 0x00, /* 0x70 - 0x73 */
+0x00, 0x00, 0x00, 0x00, /* 0x74 - 0x77 */
+0x00, 0x00, 0x00, 0x00, /* 0x78 - 0x7b */
+0x00,                   /* 0x7c        */
+
+      0xda, 0x33, 0x03, /* 0x7d - 0x7f */
+};
+
+/* Register read and write */
+static inline unsigned int dac33_read_reg_cache(struct snd_soc_codec *codec,
+                                                unsigned reg)
+{
+        u8 *cache = codec->reg_cache;
+        if (reg >= DAC33_CACHEREGNUM)
+                return 0;
+
+        return cache[reg];
+}
+
+static inline void dac33_write_reg_cache(struct snd_soc_codec *codec,
+                                         u8 reg, u8 value)
+{
+        u8 *cache = codec->reg_cache;
+        if (reg >= DAC33_CACHEREGNUM)
+                return;
+
+        cache[reg] = value;
+}
+
+static int dac33_read(struct snd_soc_codec *codec, unsigned int reg,
+                      u8 *value)
+{
+        struct tlv320dac33_priv *dac33 = codec->private_data;
+        int val;
+
+        *value = reg & 0xff;
+
+        /* If powered off, return the cached value */
+        if (dac33->chip_power) {
+                val = i2c_smbus_read_byte_data(codec->control_data, value[0]);
+                if (val < 0) {
+                        dev_err(codec->dev, "Read failed (%d)\n", val);
+                        value[0] = dac33_read_reg_cache(codec, reg);
+                } else {
+                        value[0] = val;
+                        dac33_write_reg_cache(codec, reg, val);
+                }
+        } else {
+                value[0] = dac33_read_reg_cache(codec, reg);
+        }
+
+        return 0;
+}
+
+static int dac33_write(struct snd_soc_codec *codec, unsigned int reg,
+                       unsigned int value)
+{
+        struct tlv320dac33_priv *dac33 = codec->private_data;
+        u8 data[2];
+        int ret = 0;
+
+        /*
+         * data is
+         *   D15..D8 dac33 register offset
+         *   D7...D0 register data
+         */
+        data[0] = reg & 0xff;
+        data[1] = value & 0xff;
+
+        dac33_write_reg_cache(codec, data[0], data[1]);
+        if (dac33->chip_power) {
+                ret = codec->hw_write(codec->control_data, data, 2);
+                if (ret != 2)
+                        dev_err(codec->dev, "Write failed (%d)\n", ret);
+                else
+                        ret = 0;
+        }
+
+        return ret;
+}
+
+static int dac33_write_locked(struct snd_soc_codec *codec, unsigned int reg,
+                       unsigned int value)
+{
+        struct tlv320dac33_priv *dac33 = codec->private_data;
+        int ret;
+
+        mutex_lock(&dac33->mutex);
+        ret = dac33_write(codec, reg, value);
+        mutex_unlock(&dac33->mutex);
+
+        return ret;
+}
+
+#define DAC33_I2C_ADDR_AUTOINC  0x80
+static int dac33_write16(struct snd_soc_codec *codec, unsigned int reg,
+                       unsigned int value)
+{
+        struct tlv320dac33_priv *dac33 = codec->private_data;
+        u8 data[3];
+        int ret = 0;
+
+        /*
+         * data is
+         *   D23..D16 dac33 register offset
+         *   D15..D8  register data MSB
+         *   D7...D0  register data LSB
+         */
+        data[0] = reg & 0xff;
+        data[1] = (value >> 8) & 0xff;
+        data[2] = value & 0xff;
+
+        dac33_write_reg_cache(codec, data[0], data[1]);
+        dac33_write_reg_cache(codec, data[0] + 1, data[2]);
+
+        if (dac33->chip_power) {
+                /* We need to set autoincrement mode for 16 bit writes */
+                data[0] |= DAC33_I2C_ADDR_AUTOINC;
+                ret = codec->hw_write(codec->control_data, data, 3);
+                if (ret != 3)
+                        dev_err(codec->dev, "Write failed (%d)\n", ret);
+                else
+                        ret = 0;
+        }
+
+        return ret;
+}
+
+static void dac33_restore_regs(struct snd_soc_codec *codec)
+{
+        struct tlv320dac33_priv *dac33 = codec->private_data;
+        u8 *cache = codec->reg_cache;
+        u8 data[2];
+        int i, ret;
+
+        if (!dac33->chip_power)
+                return;
+
+        for (i = DAC33_PWR_CTRL; i <= DAC33_INTP_CTRL_B; i++) {
+                data[0] = i;
+                data[1] = cache[i];
+                /* Skip the read only registers */
+                if ((i >= DAC33_INT_OSC_STATUS &&
+                                i <= DAC33_INT_OSC_FREQ_RAT_READ_B) ||
+                    (i >= DAC33_FIFO_WPTR_MSB && i <= DAC33_FIFO_IRQ_FLAG) ||
+                    i == DAC33_DAC_STATUS_FLAGS ||
+                    i == DAC33_SRC_EST_REF_CLK_RATIO_A ||
+                    i == DAC33_SRC_EST_REF_CLK_RATIO_B)
+                        continue;
+                ret = codec->hw_write(codec->control_data, data, 2);
+                if (ret != 2)
+                        dev_err(codec->dev, "Write failed (%d)\n", ret);
+        }
+        for (i = DAC33_LDAC_PWR_CTRL; i <= DAC33_LINEL_TO_LLO_VOL; i++) {
+                data[0] = i;
+                data[1] = cache[i];
+                ret = codec->hw_write(codec->control_data, data, 2);
+                if (ret != 2)
+                        dev_err(codec->dev, "Write failed (%d)\n", ret);
+        }
+        for (i = DAC33_LINER_TO_RLO_VOL; i <= DAC33_OSC_TRIM; i++) {
+                data[0] = i;
+                data[1] = cache[i];
+                ret = codec->hw_write(codec->control_data, data, 2);
+                if (ret != 2)
+                        dev_err(codec->dev, "Write failed (%d)\n", ret);
+        }
+}
+
+static inline void dac33_soft_power(struct snd_soc_codec *codec, int power)
+{
+        u8 reg;
+
+        reg = dac33_read_reg_cache(codec, DAC33_PWR_CTRL);
+        if (power)
+                reg |= DAC33_PDNALLB;
+        else
+                reg &= ~DAC33_PDNALLB;
+        dac33_write(codec, DAC33_PWR_CTRL, reg);
+}
+
+static int dac33_hard_power(struct snd_soc_codec *codec, int power)
+{
+        struct tlv320dac33_priv *dac33 = codec->private_data;
+        int ret;
+
+        mutex_lock(&dac33->mutex);
+        if (power) {
+                ret = regulator_bulk_enable(ARRAY_SIZE(dac33->supplies),
+                                          dac33->supplies);
+                if (ret != 0) {
+                        dev_err(codec->dev,
+                                "Failed to enable supplies: %d\n", ret);
+                                goto exit;
+                }
+
+                if (dac33->power_gpio >= 0)
+                        gpio_set_value(dac33->power_gpio, 1);
+
+                dac33->chip_power = 1;
+
+                /* Restore registers */
+                dac33_restore_regs(codec);
+
+                dac33_soft_power(codec, 1);
+        } else {
+                dac33_soft_power(codec, 0);
+                if (dac33->power_gpio >= 0)
+                        gpio_set_value(dac33->power_gpio, 0);
+
+                ret = regulator_bulk_disable(ARRAY_SIZE(dac33->supplies),
+                                             dac33->supplies);
+                if (ret != 0) {
+                        dev_err(codec->dev,
+                                "Failed to disable supplies: %d\n", ret);
+                        goto exit;
+                }
+
+                dac33->chip_power = 0;
+        }
+
+exit:
+        mutex_unlock(&dac33->mutex);
+        return ret;
+}
+
+static int dac33_get_nsample(struct snd_kcontrol *kcontrol,
+                         struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct tlv320dac33_priv *dac33 = codec->private_data;
+
+        ucontrol->value.integer.value[0] = dac33->nsample;
+
+        return 0;
+}
+
+static int dac33_set_nsample(struct snd_kcontrol *kcontrol,
+                         struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct tlv320dac33_priv *dac33 = codec->private_data;
+        int ret = 0;
+
+        if (dac33->nsample == ucontrol->value.integer.value[0])
+                return 0;
+
+        if (ucontrol->value.integer.value[0] < dac33->nsample_min ||
+            ucontrol->value.integer.value[0] > dac33->nsample_max)
+                ret = -EINVAL;
+        else
+                dac33->nsample = ucontrol->value.integer.value[0];
+
+        return ret;
+}
+
+static int dac33_get_fifo_mode(struct snd_kcontrol *kcontrol,
+                         struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct tlv320dac33_priv *dac33 = codec->private_data;
+
+        ucontrol->value.integer.value[0] = dac33->fifo_mode;
+
+        return 0;
+}
+
+static int dac33_set_fifo_mode(struct snd_kcontrol *kcontrol,
+                         struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct tlv320dac33_priv *dac33 = codec->private_data;
+        int ret = 0;
+
+        if (dac33->fifo_mode == ucontrol->value.integer.value[0])
+                return 0;
+        /* Do not allow changes while stream is running*/
+        if (codec->active)
+                return -EPERM;
+
+        if (ucontrol->value.integer.value[0] < 0 ||
+            ucontrol->value.integer.value[0] >= DAC33_FIFO_LAST_MODE)
+                ret = -EINVAL;
+        else
+                dac33->fifo_mode = ucontrol->value.integer.value[0];
+
+        return ret;
+}
+
+/* Codec operation modes */
+static const char *dac33_fifo_mode_texts[] = {
+        "Bypass", "Mode 1", "Mode 7"
+};
+
+static const struct soc_enum dac33_fifo_mode_enum =
+        SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(dac33_fifo_mode_texts),
+                            dac33_fifo_mode_texts);
+
+/*
+ * DACL/R digital volume control:
+ * from 0 dB to -63.5 in 0.5 dB steps
+ * Need to be inverted later on:
+ * 0x00 == 0 dB
+ * 0x7f == -63.5 dB
+ */
+static DECLARE_TLV_DB_SCALE(dac_digivol_tlv, -6350, 50, 0);
+
+static const struct snd_kcontrol_new dac33_snd_controls[] = {
+        SOC_DOUBLE_R_TLV("DAC Digital Playback Volume",
+                DAC33_LDAC_DIG_VOL_CTRL, DAC33_RDAC_DIG_VOL_CTRL,
+                0, 0x7f, 1, dac_digivol_tlv),
+        SOC_DOUBLE_R("DAC Digital Playback Switch",
+                 DAC33_LDAC_DIG_VOL_CTRL, DAC33_RDAC_DIG_VOL_CTRL, 7, 1, 1),
+        SOC_DOUBLE_R("Line to Line Out Volume",
+                 DAC33_LINEL_TO_LLO_VOL, DAC33_LINER_TO_RLO_VOL, 0, 127, 1),
+};
+
+static const struct snd_kcontrol_new dac33_nsample_snd_controls[] = {
+        SOC_SINGLE_EXT("nSample", 0, 0, 5900, 0,
+                 dac33_get_nsample, dac33_set_nsample),
+        SOC_ENUM_EXT("FIFO Mode", dac33_fifo_mode_enum,
+                 dac33_get_fifo_mode, dac33_set_fifo_mode),
+};
+
+/* Analog bypass */
+static const struct snd_kcontrol_new dac33_dapm_abypassl_control =
+        SOC_DAPM_SINGLE("Switch", DAC33_LINEL_TO_LLO_VOL, 7, 1, 1);
+
+static const struct snd_kcontrol_new dac33_dapm_abypassr_control =
+        SOC_DAPM_SINGLE("Switch", DAC33_LINER_TO_RLO_VOL, 7, 1, 1);
+
+static const struct snd_soc_dapm_widget dac33_dapm_widgets[] = {
+        SND_SOC_DAPM_OUTPUT("LEFT_LO"),
+        SND_SOC_DAPM_OUTPUT("RIGHT_LO"),
+
+        SND_SOC_DAPM_INPUT("LINEL"),
+        SND_SOC_DAPM_INPUT("LINER"),
+
+        SND_SOC_DAPM_DAC("DACL", "Left Playback", DAC33_LDAC_PWR_CTRL, 2, 0),
+        SND_SOC_DAPM_DAC("DACR", "Right Playback", DAC33_RDAC_PWR_CTRL, 2, 0),
+
+        /* Analog bypass */
+        SND_SOC_DAPM_SWITCH("Analog Left Bypass", SND_SOC_NOPM, 0, 0,
+                                &dac33_dapm_abypassl_control),
+        SND_SOC_DAPM_SWITCH("Analog Right Bypass", SND_SOC_NOPM, 0, 0,
+                                &dac33_dapm_abypassr_control),
+
+        SND_SOC_DAPM_REG(snd_soc_dapm_mixer, "Output Left Amp Power",
+                         DAC33_OUT_AMP_PWR_CTRL, 6, 3, 3, 0),
+        SND_SOC_DAPM_REG(snd_soc_dapm_mixer, "Output Right Amp Power",
+                         DAC33_OUT_AMP_PWR_CTRL, 4, 3, 3, 0),
+};
+
+static const struct snd_soc_dapm_route audio_map[] = {
+        /* Analog bypass */
+        {"Analog Left Bypass", "Switch", "LINEL"},
+        {"Analog Right Bypass", "Switch", "LINER"},
+
+        {"Output Left Amp Power", NULL, "DACL"},
+        {"Output Right Amp Power", NULL, "DACR"},
+
+        {"Output Left Amp Power", NULL, "Analog Left Bypass"},
+        {"Output Right Amp Power", NULL, "Analog Right Bypass"},
+
+        /* output */
+        {"LEFT_LO", NULL, "Output Left Amp Power"},
+        {"RIGHT_LO", NULL, "Output Right Amp Power"},
+};
+
+static int dac33_add_widgets(struct snd_soc_codec *codec)
+{
+        snd_soc_dapm_new_controls(codec, dac33_dapm_widgets,
+                                  ARRAY_SIZE(dac33_dapm_widgets));
+
+        /* set up audio path interconnects */
+        snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
+
+        return 0;
+}
+
+static int dac33_set_bias_level(struct snd_soc_codec *codec,
+                                enum snd_soc_bias_level level)
+{
+        int ret;
+
+        switch (level) {
+        case SND_SOC_BIAS_ON:
+                dac33_soft_power(codec, 1);
+                break;
+        case SND_SOC_BIAS_PREPARE:
+                break;
+        case SND_SOC_BIAS_STANDBY:
+                if (codec->bias_level == SND_SOC_BIAS_OFF) {
+                        ret = dac33_hard_power(codec, 1);
+                        if (ret != 0)
+                                return ret;
+                }
+
+                dac33_soft_power(codec, 0);
+                break;
+        case SND_SOC_BIAS_OFF:
+                ret = dac33_hard_power(codec, 0);
+                if (ret != 0)
+                        return ret;
+
+                break;
+        }
+        codec->bias_level = level;
+
+        return 0;
+}
+
+static inline void dac33_prefill_handler(struct tlv320dac33_priv *dac33)
+{
+        struct snd_soc_codec *codec;
+
+        codec = &dac33->codec;
+
+        switch (dac33->fifo_mode) {
+        case DAC33_FIFO_MODE1:
+                dac33_write16(codec, DAC33_NSAMPLE_MSB,
+                                DAC33_THRREG(dac33->nsample));
+                dac33_write16(codec, DAC33_PREFILL_MSB,
+                                DAC33_THRREG(dac33->alarm_threshold));
+                break;
+        case DAC33_FIFO_MODE7:
+                dac33_write16(codec, DAC33_PREFILL_MSB,
+                                DAC33_THRREG(10));
+                break;
+        default:
+                dev_warn(codec->dev, "Unhandled FIFO mode: %d\n",
+                                                        dac33->fifo_mode);
+                break;
+        }
+}
+
+static inline void dac33_playback_handler(struct tlv320dac33_priv *dac33)
+{
+        struct snd_soc_codec *codec;
+
+        codec = &dac33->codec;
+
+        switch (dac33->fifo_mode) {
+        case DAC33_FIFO_MODE1:
+                dac33_write16(codec, DAC33_NSAMPLE_MSB,
+                                DAC33_THRREG(dac33->nsample));
+                break;
+        case DAC33_FIFO_MODE7:
+                /* At the moment we are not using interrupts in mode7 */
+                break;
+        default:
+                dev_warn(codec->dev, "Unhandled FIFO mode: %d\n",
+                                                        dac33->fifo_mode);
+                break;
+        }
+}
+
+static void dac33_work(struct work_struct *work)
+{
+        struct snd_soc_codec *codec;
+        struct tlv320dac33_priv *dac33;
+        u8 reg;
+
+        dac33 = container_of(work, struct tlv320dac33_priv, work);
+        codec = &dac33->codec;
+
+        mutex_lock(&dac33->mutex);
+        switch (dac33->state) {
+        case DAC33_PREFILL:
+                dac33->state = DAC33_PLAYBACK;
+                dac33_prefill_handler(dac33);
+                break;
+        case DAC33_PLAYBACK:
+                dac33_playback_handler(dac33);
+                break;
+        case DAC33_IDLE:
+                break;
+        case DAC33_FLUSH:
+                dac33->state = DAC33_IDLE;
+                /* Mask all interrupts from dac33 */
+                dac33_write(codec, DAC33_FIFO_IRQ_MASK, 0);
+
+                /* flush fifo */
+                reg = dac33_read_reg_cache(codec, DAC33_FIFO_CTRL_A);
+                reg |= DAC33_FIFOFLUSH;
+                dac33_write(codec, DAC33_FIFO_CTRL_A, reg);
+                break;
+        }
+        mutex_unlock(&dac33->mutex);
+}
+
+static irqreturn_t dac33_interrupt_handler(int irq, void *dev)
+{
+        struct snd_soc_codec *codec = dev;
+        struct tlv320dac33_priv *dac33 = codec->private_data;
+
+        queue_work(dac33->dac33_wq, &dac33->work);
+
+        return IRQ_HANDLED;
+}
+
+static void dac33_shutdown(struct snd_pcm_substream *substream,
+                             struct snd_soc_dai *dai)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_device *socdev = rtd->socdev;
+        struct snd_soc_codec *codec = socdev->card->codec;
+        struct tlv320dac33_priv *dac33 = codec->private_data;
+        unsigned int pwr_ctrl;
+
+        /* Stop pending workqueue */
+        if (dac33->fifo_mode)
+                cancel_work_sync(&dac33->work);
+
+        mutex_lock(&dac33->mutex);
+        pwr_ctrl = dac33_read_reg_cache(codec, DAC33_PWR_CTRL);
+        pwr_ctrl &= ~(DAC33_OSCPDNB | DAC33_DACRPDNB | DAC33_DACLPDNB);
+        dac33_write(codec, DAC33_PWR_CTRL, pwr_ctrl);
+        mutex_unlock(&dac33->mutex);
+}
+
+static void dac33_oscwait(struct snd_soc_codec *codec)
+{
+        int timeout = 20;
+        u8 reg;
+
+        do {
+                msleep(1);
+                dac33_read(codec, DAC33_INT_OSC_STATUS, &reg);
+        } while (((reg & 0x03) != DAC33_OSCSTATUS_NORMAL) && timeout--);
+        if ((reg & 0x03) != DAC33_OSCSTATUS_NORMAL)
+                dev_err(codec->dev,
+                        "internal oscillator calibration failed\n");
+}
+
+static int dac33_hw_params(struct snd_pcm_substream *substream,
+                           struct snd_pcm_hw_params *params,
+                           struct snd_soc_dai *dai)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_device *socdev = rtd->socdev;
+        struct snd_soc_codec *codec = socdev->card->codec;
+
+        /* Check parameters for validity */
+        switch (params_rate(params)) {
+        case 44100:
+        case 48000:
+                break;
+        default:
+                dev_err(codec->dev, "unsupported rate %d\n",
+                        params_rate(params));
+                return -EINVAL;
+        }
+
+        switch (params_format(params)) {
+        case SNDRV_PCM_FORMAT_S16_LE:
+                break;
+        default:
+                dev_err(codec->dev, "unsupported format %d\n",
+                        params_format(params));
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+#define CALC_OSCSET(rate, refclk) ( \
+        ((((rate * 10000) / refclk) * 4096) + 7000) / 10000)
+#define CALC_RATIOSET(rate, refclk) ( \
+        ((((refclk  * 100000) / rate) * 16384) + 50000) / 100000)
+
+/*
+ * tlv320dac33 is strict on the sequence of the register writes, if the register
+ * writes happens in different order, than dac33 might end up in unknown state.
+ * Use the known, working sequence of register writes to initialize the dac33.
+ */
+static int dac33_prepare_chip(struct snd_pcm_substream *substream)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_device *socdev = rtd->socdev;
+        struct snd_soc_codec *codec = socdev->card->codec;
+        struct tlv320dac33_priv *dac33 = codec->private_data;
+        unsigned int oscset, ratioset, pwr_ctrl, reg_tmp;
+        u8 aictrl_a, aictrl_b, fifoctrl_a;
+
+        switch (substream->runtime->rate) {
+        case 44100:
+        case 48000:
+                oscset = CALC_OSCSET(substream->runtime->rate, dac33->refclk);
+                ratioset = CALC_RATIOSET(substream->runtime->rate,
+                                         dac33->refclk);
+                break;
+        default:
+                dev_err(codec->dev, "unsupported rate %d\n",
+                        substream->runtime->rate);
+                return -EINVAL;
+        }
+
+
+        aictrl_a = dac33_read_reg_cache(codec, DAC33_SER_AUDIOIF_CTRL_A);
+        aictrl_a &= ~(DAC33_NCYCL_MASK | DAC33_WLEN_MASK);
+        /* Read FIFO control A, and clear FIFO flush bit */
+        fifoctrl_a = dac33_read_reg_cache(codec, DAC33_FIFO_CTRL_A);
+        fifoctrl_a &= ~DAC33_FIFOFLUSH;
+
+        fifoctrl_a &= ~DAC33_WIDTH;
+        switch (substream->runtime->format) {
+        case SNDRV_PCM_FORMAT_S16_LE:
+                aictrl_a |= (DAC33_NCYCL_16 | DAC33_WLEN_16);
+                fifoctrl_a |= DAC33_WIDTH;
+                break;
+        default:
+                dev_err(codec->dev, "unsupported format %d\n",
+                        substream->runtime->format);
+                return -EINVAL;
+        }
+
+        mutex_lock(&dac33->mutex);
+        dac33_soft_power(codec, 1);
+
+        reg_tmp = dac33_read_reg_cache(codec, DAC33_INT_OSC_CTRL);
+        dac33_write(codec, DAC33_INT_OSC_CTRL, reg_tmp);
+
+        /* Write registers 0x08 and 0x09 (MSB, LSB) */
+        dac33_write16(codec, DAC33_INT_OSC_FREQ_RAT_A, oscset);
+
+        /* calib time: 128 is a nice number ;) */
+        dac33_write(codec, DAC33_CALIB_TIME, 128);
+
+        /* adjustment treshold & step */
+        dac33_write(codec, DAC33_INT_OSC_CTRL_B, DAC33_ADJTHRSHLD(2) |
+                                                 DAC33_ADJSTEP(1));
+
+        /* div=4 / gain=1 / div */
+        dac33_write(codec, DAC33_INT_OSC_CTRL_C, DAC33_REFDIV(4));
+
+        pwr_ctrl = dac33_read_reg_cache(codec, DAC33_PWR_CTRL);
+        pwr_ctrl |= DAC33_OSCPDNB | DAC33_DACRPDNB | DAC33_DACLPDNB;
+        dac33_write(codec, DAC33_PWR_CTRL, pwr_ctrl);
+
+        dac33_oscwait(codec);
+
+        if (dac33->fifo_mode) {
+                /* Generic for all FIFO modes */
+                /* 50-51 : ASRC Control registers */
+                dac33_write(codec, DAC33_ASRC_CTRL_A, DAC33_SRCLKDIV(1));
+                dac33_write(codec, DAC33_ASRC_CTRL_B, 1); /* ??? */
+
+                /* Write registers 0x34 and 0x35 (MSB, LSB) */
+                dac33_write16(codec, DAC33_SRC_REF_CLK_RATIO_A, ratioset);
+
+                /* Set interrupts to high active */
+                dac33_write(codec, DAC33_INTP_CTRL_A, DAC33_INTPM_AHIGH);
+        } else {
+                /* FIFO bypass mode */
+                /* 50-51 : ASRC Control registers */
+                dac33_write(codec, DAC33_ASRC_CTRL_A, DAC33_SRCBYP);
+                dac33_write(codec, DAC33_ASRC_CTRL_B, 0); /* ??? */
+        }
+
+        /* Interrupt behaviour configuration */
+        switch (dac33->fifo_mode) {
+        case DAC33_FIFO_MODE1:
+                dac33_write(codec, DAC33_FIFO_IRQ_MODE_B,
+                            DAC33_ATM(DAC33_FIFO_IRQ_MODE_LEVEL));
+                dac33_write(codec, DAC33_FIFO_IRQ_MASK, DAC33_MAT);
+                break;
+        case DAC33_FIFO_MODE7:
+                /* Disable all interrupts */
+                dac33_write(codec, DAC33_FIFO_IRQ_MASK, 0);
+                break;
+        default:
+                /* in FIFO bypass mode, the interrupts are not used */
+                break;
+        }
+
+        aictrl_b = dac33_read_reg_cache(codec, DAC33_SER_AUDIOIF_CTRL_B);
+
+        switch (dac33->fifo_mode) {
+        case DAC33_FIFO_MODE1:
+                /*
+                 * For mode1:
+                 * Disable the FIFO bypass (Enable the use of FIFO)
+                 * Select nSample mode
+                 * BCLK is only running when data is needed by DAC33
+                 */
+                fifoctrl_a &= ~DAC33_FBYPAS;
+                fifoctrl_a &= ~DAC33_FAUTO;
+                aictrl_b &= ~DAC33_BCLKON;
+                break;
+        case DAC33_FIFO_MODE7:
+                /*
+                 * For mode1:
+                 * Disable the FIFO bypass (Enable the use of FIFO)
+                 * Select Threshold mode
+                 * BCLK is only running when data is needed by DAC33
+                 */
+                fifoctrl_a &= ~DAC33_FBYPAS;
+                fifoctrl_a |= DAC33_FAUTO;
+                aictrl_b &= ~DAC33_BCLKON;
+                break;
+        default:
+                /*
+                 * For FIFO bypass mode:
+                 * Enable the FIFO bypass (Disable the FIFO use)
+                 * Set the BCLK as continous
+                 */
+                fifoctrl_a |= DAC33_FBYPAS;
+                aictrl_b |= DAC33_BCLKON;
+                break;
+        }
+
+        dac33_write(codec, DAC33_FIFO_CTRL_A, fifoctrl_a);
+        dac33_write(codec, DAC33_SER_AUDIOIF_CTRL_A, aictrl_a);
+        dac33_write(codec, DAC33_SER_AUDIOIF_CTRL_B, aictrl_b);
+
+        /*
+         * BCLK divide ratio
+         * 0: 1.5
+         * 1: 1
+         * 2: 2
+         * ...
+         * 254: 254
+         * 255: 255
+         */
+        if (dac33->fifo_mode)
+                dac33_write(codec, DAC33_SER_AUDIOIF_CTRL_C,
+                                                        dac33->burst_bclkdiv);
+        else
+                dac33_write(codec, DAC33_SER_AUDIOIF_CTRL_C, 32);
+
+        switch (dac33->fifo_mode) {
+        case DAC33_FIFO_MODE1:
+                dac33_write16(codec, DAC33_ATHR_MSB,
+                              DAC33_THRREG(dac33->alarm_threshold));
+                break;
+        case DAC33_FIFO_MODE7:
+                /*
+                 * Configure the threshold levels, and leave 10 sample space
+                 * at the bottom, and also at the top of the FIFO
+                 */
+                dac33_write16(codec, DAC33_UTHR_MSB,
+                        DAC33_THRREG(DAC33_BUFFER_SIZE_SAMPLES - 10));
+                dac33_write16(codec, DAC33_LTHR_MSB,
+                        DAC33_THRREG(10));
+                break;
+        default:
+                break;
+        }
+
+        mutex_unlock(&dac33->mutex);
+
+        return 0;
+}
+
+static void dac33_calculate_times(struct snd_pcm_substream *substream)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_device *socdev = rtd->socdev;
+        struct snd_soc_codec *codec = socdev->card->codec;
+        struct tlv320dac33_priv *dac33 = codec->private_data;
+        unsigned int nsample_limit;
+
+        /* Number of samples (16bit, stereo) in one period */
+        dac33->nsample_min = snd_pcm_lib_period_bytes(substream) / 4;
+
+        /* Number of samples (16bit, stereo) in ALSA buffer */
+        dac33->nsample_max = snd_pcm_lib_buffer_bytes(substream) / 4;
+        /* Subtract one period from the total */
+        dac33->nsample_max -= dac33->nsample_min;
+
+        /* Number of samples for LATENCY_TIME_MS / 2 */
+        dac33->alarm_threshold = substream->runtime->rate /
+                                 (1000 / (LATENCY_TIME_MS / 2));
+
+        /* Find and fix up the lowest nsmaple limit */
+        nsample_limit = substream->runtime->rate / (1000 / LATENCY_TIME_MS);
+
+        if (dac33->nsample_min < nsample_limit)
+                dac33->nsample_min = nsample_limit;
+
+        if (dac33->nsample < dac33->nsample_min)
+                dac33->nsample = dac33->nsample_min;
+
+        /*
+         * Find and fix up the highest nsmaple limit
+         * In order to not overflow the DAC33 buffer substract the
+         * alarm_threshold value from the size of the DAC33 buffer
+         */
+        nsample_limit = DAC33_BUFFER_SIZE_SAMPLES - dac33->alarm_threshold;
+
+        if (dac33->nsample_max > nsample_limit)
+                dac33->nsample_max = nsample_limit;
+
+        if (dac33->nsample > dac33->nsample_max)
+                dac33->nsample = dac33->nsample_max;
+}
+
+static int dac33_pcm_prepare(struct snd_pcm_substream *substream,
+                             struct snd_soc_dai *dai)
+{
+        dac33_calculate_times(substream);
+        dac33_prepare_chip(substream);
+
+        return 0;
+}
+
+static int dac33_pcm_trigger(struct snd_pcm_substream *substream, int cmd,
+                             struct snd_soc_dai *dai)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_device *socdev = rtd->socdev;
+        struct snd_soc_codec *codec = socdev->card->codec;
+        struct tlv320dac33_priv *dac33 = codec->private_data;
+        int ret = 0;
+
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+        case SNDRV_PCM_TRIGGER_RESUME:
+        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
+                if (dac33->fifo_mode) {
+                        dac33->state = DAC33_PREFILL;
+                        queue_work(dac33->dac33_wq, &dac33->work);
+                }
+                break;
+        case SNDRV_PCM_TRIGGER_STOP:
+        case SNDRV_PCM_TRIGGER_SUSPEND:
+        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
+                if (dac33->fifo_mode) {
+                        dac33->state = DAC33_FLUSH;
+                        queue_work(dac33->dac33_wq, &dac33->work);
+                }
+                break;
+        default:
+                ret = -EINVAL;
+        }
+
+        return ret;
+}
+
+static int dac33_set_dai_sysclk(struct snd_soc_dai *codec_dai,
+                int clk_id, unsigned int freq, int dir)
+{
+        struct snd_soc_codec *codec = codec_dai->codec;
+        struct tlv320dac33_priv *dac33 = codec->private_data;
+        u8 ioc_reg, asrcb_reg;
+
+        ioc_reg = dac33_read_reg_cache(codec, DAC33_INT_OSC_CTRL);
+        asrcb_reg = dac33_read_reg_cache(codec, DAC33_ASRC_CTRL_B);
+        switch (clk_id) {
+        case TLV320DAC33_MCLK:
+                ioc_reg |= DAC33_REFSEL;
+                asrcb_reg |= DAC33_SRCREFSEL;
+                break;
+        case TLV320DAC33_SLEEPCLK:
+                ioc_reg &= ~DAC33_REFSEL;
+                asrcb_reg &= ~DAC33_SRCREFSEL;
+                break;
+        default:
+                dev_err(codec->dev, "Invalid clock ID (%d)\n", clk_id);
+                break;
+        }
+        dac33->refclk = freq;
+
+        dac33_write_reg_cache(codec, DAC33_INT_OSC_CTRL, ioc_reg);
+        dac33_write_reg_cache(codec, DAC33_ASRC_CTRL_B, asrcb_reg);
+
+        return 0;
+}
+
+static int dac33_set_dai_fmt(struct snd_soc_dai *codec_dai,
+                             unsigned int fmt)
+{
+        struct snd_soc_codec *codec = codec_dai->codec;
+        struct tlv320dac33_priv *dac33 = codec->private_data;
+        u8 aictrl_a, aictrl_b;
+
+        aictrl_a = dac33_read_reg_cache(codec, DAC33_SER_AUDIOIF_CTRL_A);
+        aictrl_b = dac33_read_reg_cache(codec, DAC33_SER_AUDIOIF_CTRL_B);
+        /* set master/slave audio interface */
+        switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
+        case SND_SOC_DAIFMT_CBM_CFM:
+                /* Codec Master */
+                aictrl_a |= (DAC33_MSBCLK | DAC33_MSWCLK);
+                break;
+        case SND_SOC_DAIFMT_CBS_CFS:
+                /* Codec Slave */
+                if (dac33->fifo_mode) {
+                        dev_err(codec->dev, "FIFO mode requires master mode\n");
+                        return -EINVAL;
+                } else
+                        aictrl_a &= ~(DAC33_MSBCLK | DAC33_MSWCLK);
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        aictrl_a &= ~DAC33_AFMT_MASK;
+        switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
+        case SND_SOC_DAIFMT_I2S:
+                aictrl_a |= DAC33_AFMT_I2S;
+                break;
+        case SND_SOC_DAIFMT_DSP_A:
+                aictrl_a |= DAC33_AFMT_DSP;
+                aictrl_b &= ~DAC33_DATA_DELAY_MASK;
+                aictrl_b |= DAC33_DATA_DELAY(0);
+                break;
+        case SND_SOC_DAIFMT_RIGHT_J:
+                aictrl_a |= DAC33_AFMT_RIGHT_J;
+                break;
+        case SND_SOC_DAIFMT_LEFT_J:
+                aictrl_a |= DAC33_AFMT_LEFT_J;
+                break;
+        default:
+                dev_err(codec->dev, "Unsupported format (%u)\n",
+                        fmt & SND_SOC_DAIFMT_FORMAT_MASK);
+                return -EINVAL;
+        }
+
+        dac33_write_reg_cache(codec, DAC33_SER_AUDIOIF_CTRL_A, aictrl_a);
+        dac33_write_reg_cache(codec, DAC33_SER_AUDIOIF_CTRL_B, aictrl_b);
+
+        return 0;
+}
+
+static void dac33_init_chip(struct snd_soc_codec *codec)
+{
+        /* 44-46: DAC Control Registers */
+        /* A : DAC sample rate Fsref/1.5 */
+        dac33_write(codec, DAC33_DAC_CTRL_A, DAC33_DACRATE(0));
+        /* B : DAC src=normal, not muted */
+        dac33_write(codec, DAC33_DAC_CTRL_B, DAC33_DACSRCR_RIGHT |
+                                             DAC33_DACSRCL_LEFT);
+        /* C : (defaults) */
+        dac33_write(codec, DAC33_DAC_CTRL_C, 0x00);
+
+        /* 64-65 : L&R DAC power control
+         Line In -> OUT 1V/V Gain, DAC -> OUT 4V/V Gain*/
+        dac33_write(codec, DAC33_LDAC_PWR_CTRL, DAC33_LROUT_GAIN(2));
+        dac33_write(codec, DAC33_RDAC_PWR_CTRL, DAC33_LROUT_GAIN(2));
+
+        /* 73 : volume soft stepping control,
+         clock source = internal osc (?) */
+        dac33_write(codec, DAC33_ANA_VOL_SOFT_STEP_CTRL, DAC33_VOLCLKEN);
+
+        /* 66 : LOP/LOM Modes */
+        dac33_write(codec, DAC33_OUT_AMP_CM_CTRL, 0xff);
+
+        /* 68 : LOM inverted from LOP */
+        dac33_write(codec, DAC33_OUT_AMP_CTRL, (3<<2));
+
+        dac33_write(codec, DAC33_PWR_CTRL, DAC33_PDNALLB);
+}
+
+static int dac33_soc_probe(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec;
+        struct tlv320dac33_priv *dac33;
+        int ret = 0;
+
+        BUG_ON(!tlv320dac33_codec);
+
+        codec = tlv320dac33_codec;
+        socdev->card->codec = codec;
+        dac33 = codec->private_data;
+
+        /* Power up the codec */
+        dac33_hard_power(codec, 1);
+        /* Set default configuration */
+        dac33_init_chip(codec);
+
+        /* register pcms */
+        ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
+        if (ret < 0) {
+                dev_err(codec->dev, "failed to create pcms\n");
+                goto pcm_err;
+        }
+
+        snd_soc_add_controls(codec, dac33_snd_controls,
+                             ARRAY_SIZE(dac33_snd_controls));
+        /* Only add the nSample controls, if we have valid IRQ number */
+        if (dac33->irq >= 0)
+                snd_soc_add_controls(codec, dac33_nsample_snd_controls,
+                                     ARRAY_SIZE(dac33_nsample_snd_controls));
+
+        dac33_add_widgets(codec);
+
+        /* power on device */
+        dac33_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+
+        /* Bias level configuration has enabled regulator an extra time */
+        regulator_bulk_disable(ARRAY_SIZE(dac33->supplies), dac33->supplies);
+
+        return 0;
+
+pcm_err:
+        dac33_hard_power(codec, 0);
+        return ret;
+}
+
+static int dac33_soc_remove(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec = socdev->card->codec;
+
+        dac33_set_bias_level(codec, SND_SOC_BIAS_OFF);
+
+        snd_soc_free_pcms(socdev);
+        snd_soc_dapm_free(socdev);
+
+        return 0;
+}
+
+static int dac33_soc_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec = socdev->card->codec;
+
+        dac33_set_bias_level(codec, SND_SOC_BIAS_OFF);
+
+        return 0;
+}
+
+static int dac33_soc_resume(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec = socdev->card->codec;
+
+        dac33_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+        dac33_set_bias_level(codec, codec->suspend_bias_level);
+
+        return 0;
+}
+
+struct snd_soc_codec_device soc_codec_dev_tlv320dac33 = {
+        .probe = dac33_soc_probe,
+        .remove = dac33_soc_remove,
+        .suspend = dac33_soc_suspend,
+        .resume = dac33_soc_resume,
+};
+EXPORT_SYMBOL_GPL(soc_codec_dev_tlv320dac33);
+
+#define DAC33_RATES     (SNDRV_PCM_RATE_44100 | \
+                         SNDRV_PCM_RATE_48000)
+#define DAC33_FORMATS   SNDRV_PCM_FMTBIT_S16_LE
+
+static struct snd_soc_dai_ops dac33_dai_ops = {
+        .shutdown       = dac33_shutdown,
+        .hw_params      = dac33_hw_params,
+        .prepare        = dac33_pcm_prepare,
+        .trigger        = dac33_pcm_trigger,
+        .set_sysclk     = dac33_set_dai_sysclk,
+        .set_fmt        = dac33_set_dai_fmt,
+};
+
+struct snd_soc_dai dac33_dai = {
+        .name = "tlv320dac33",
+        .playback = {
+                .stream_name = "Playback",
+                .channels_min = 2,
+                .channels_max = 2,
+                .rates = DAC33_RATES,
+                .formats = DAC33_FORMATS,},
+        .ops = &dac33_dai_ops,
+};
+EXPORT_SYMBOL_GPL(dac33_dai);
+
+static int __devinit dac33_i2c_probe(struct i2c_client *client,
+                                     const struct i2c_device_id *id)
+{
+        struct tlv320dac33_platform_data *pdata;
+        struct tlv320dac33_priv *dac33;
+        struct snd_soc_codec *codec;
+        int ret, i;
+
+        if (client->dev.platform_data == NULL) {
+                dev_err(&client->dev, "Platform data not set\n");
+                return -ENODEV;
+        }
+        pdata = client->dev.platform_data;
+
+        dac33 = kzalloc(sizeof(struct tlv320dac33_priv), GFP_KERNEL);
+        if (dac33 == NULL)
+                return -ENOMEM;
+
+        codec = &dac33->codec;
+        codec->private_data = dac33;
+        codec->control_data = client;
+
+        mutex_init(&codec->mutex);
+        mutex_init(&dac33->mutex);
+        INIT_LIST_HEAD(&codec->dapm_widgets);
+        INIT_LIST_HEAD(&codec->dapm_paths);
+
+        codec->name = "tlv320dac33";
+        codec->owner = THIS_MODULE;
+        codec->read = dac33_read_reg_cache;
+        codec->write = dac33_write_locked;
+        codec->hw_write = (hw_write_t) i2c_master_send;
+        codec->bias_level = SND_SOC_BIAS_OFF;
+        codec->set_bias_level = dac33_set_bias_level;
+        codec->dai = &dac33_dai;
+        codec->num_dai = 1;
+        codec->reg_cache_size = ARRAY_SIZE(dac33_reg);
+        codec->reg_cache = kmemdup(dac33_reg, ARRAY_SIZE(dac33_reg),
+                                   GFP_KERNEL);
+        if (codec->reg_cache == NULL) {
+                ret = -ENOMEM;
+                goto error_reg;
+        }
+
+        i2c_set_clientdata(client, dac33);
+
+        dac33->power_gpio = pdata->power_gpio;
+        dac33->burst_bclkdiv = pdata->burst_bclkdiv;
+        dac33->irq = client->irq;
+        dac33->nsample = NSAMPLE_MAX;
+        /* Disable FIFO use by default */
+        dac33->fifo_mode = DAC33_FIFO_BYPASS;
+
+        tlv320dac33_codec = codec;
+
+        codec->dev = &client->dev;
+        dac33_dai.dev = codec->dev;
+
+        /* Check if the reset GPIO number is valid and request it */
+        if (dac33->power_gpio >= 0) {
+                ret = gpio_request(dac33->power_gpio, "tlv320dac33 reset");
+                if (ret < 0) {
+                        dev_err(codec->dev,
+                                "Failed to request reset GPIO (%d)\n",
+                                dac33->power_gpio);
+                        snd_soc_unregister_dai(&dac33_dai);
+                        snd_soc_unregister_codec(codec);
+                        goto error_gpio;
+                }
+                gpio_direction_output(dac33->power_gpio, 0);
+        } else {
+                dac33->chip_power = 1;
+        }
+
+        /* Check if the IRQ number is valid and request it */
+        if (dac33->irq >= 0) {
+                ret = request_irq(dac33->irq, dac33_interrupt_handler,
+                                  IRQF_TRIGGER_RISING | IRQF_DISABLED,
+                                  codec->name, codec);
+                if (ret < 0) {
+                        dev_err(codec->dev, "Could not request IRQ%d (%d)\n",
+                                                dac33->irq, ret);
+                        dac33->irq = -1;
+                }
+                if (dac33->irq != -1) {
+                        /* Setup work queue */
+                        dac33->dac33_wq =
+                                create_singlethread_workqueue("tlv320dac33");
+                        if (dac33->dac33_wq == NULL) {
+                                free_irq(dac33->irq, &dac33->codec);
+                                ret = -ENOMEM;
+                                goto error_wq;
+                        }
+
+                        INIT_WORK(&dac33->work, dac33_work);
+                }
+        }
+
+        for (i = 0; i < ARRAY_SIZE(dac33->supplies); i++)
+                dac33->supplies[i].supply = dac33_supply_names[i];
+
+        ret = regulator_bulk_get(codec->dev, ARRAY_SIZE(dac33->supplies),
+                                 dac33->supplies);
+
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to request supplies: %d\n", ret);
+                goto err_get;
+        }
+
+        ret = regulator_bulk_enable(ARRAY_SIZE(dac33->supplies),
+                                    dac33->supplies);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to enable supplies: %d\n", ret);
+                goto err_enable;
+        }
+
+        ret = snd_soc_register_codec(codec);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to register codec: %d\n", ret);
+                goto error_codec;
+        }
+
+        ret = snd_soc_register_dai(&dac33_dai);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to register DAI: %d\n", ret);
+                snd_soc_unregister_codec(codec);
+                goto error_codec;
+        }
+
+        /* Shut down the codec for now */
+        dac33_hard_power(codec, 0);
+
+        return ret;
+
+error_codec:
+        regulator_bulk_disable(ARRAY_SIZE(dac33->supplies), dac33->supplies);
+err_enable:
+        regulator_bulk_free(ARRAY_SIZE(dac33->supplies), dac33->supplies);
+err_get:
+        if (dac33->irq >= 0) {
+                free_irq(dac33->irq, &dac33->codec);
+                destroy_workqueue(dac33->dac33_wq);
+        }
+error_wq:
+        if (dac33->power_gpio >= 0)
+                gpio_free(dac33->power_gpio);
+error_gpio:
+        kfree(codec->reg_cache);
+error_reg:
+        tlv320dac33_codec = NULL;
+        kfree(dac33);
+
+        return ret;
+}
+
+static int __devexit dac33_i2c_remove(struct i2c_client *client)
+{
+        struct tlv320dac33_priv *dac33;
+
+        dac33 = i2c_get_clientdata(client);
+        dac33_hard_power(&dac33->codec, 0);
+
+        if (dac33->power_gpio >= 0)
+                gpio_free(dac33->power_gpio);
+        if (dac33->irq >= 0)
+                free_irq(dac33->irq, &dac33->codec);
+
+        regulator_bulk_free(ARRAY_SIZE(dac33->supplies), dac33->supplies);
+
+        destroy_workqueue(dac33->dac33_wq);
+        snd_soc_unregister_dai(&dac33_dai);
+        snd_soc_unregister_codec(&dac33->codec);
+        kfree(dac33->codec.reg_cache);
+        kfree(dac33);
+        tlv320dac33_codec = NULL;
+
+        return 0;
+}
+
+static const struct i2c_device_id tlv320dac33_i2c_id[] = {
+        {
+                .name = "tlv320dac33",
+                .driver_data = 0,
+        },
+        { },
+};
+
+static struct i2c_driver tlv320dac33_i2c_driver = {
+        .driver = {
+                .name = "tlv320dac33",
+                .owner = THIS_MODULE,
+        },
+        .probe          = dac33_i2c_probe,
+        .remove         = __devexit_p(dac33_i2c_remove),
+        .id_table       = tlv320dac33_i2c_id,
+};
+
+static int __init dac33_module_init(void)
+{
+        int r;
+        r = i2c_add_driver(&tlv320dac33_i2c_driver);
+        if (r < 0) {
+                printk(KERN_ERR "DAC33: driver registration failed\n");
+                return r;
+        }
+        return 0;
+}
+module_init(dac33_module_init);
+
+static void __exit dac33_module_exit(void)
+{
+        i2c_del_driver(&tlv320dac33_i2c_driver);
+}
+module_exit(dac33_module_exit);
+
+
+MODULE_DESCRIPTION("ASoC TLV320DAC33 codec driver");
+MODULE_AUTHOR("Peter Ujfalusi <peter.ujfalusi@nokia.com>");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/codecs/tlv320dac33.h b/sound/soc/codecs/tlv320dac33.h
new file mode 100644
index 000000000000..eb8ae07f0bd2
--- /dev/null
+++ b/sound/soc/codecs/tlv320dac33.h
@@ -0,0 +1,267 @@
+/*
+ * ALSA SoC Texas Instruments TLV320DAC33 codec driver
+ *
+ * Author:      Peter Ujfalusi <peter.ujfalusi@nokia.com>
+ *
+ * Copyright:   (C) 2009 Nokia Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program 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., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#ifndef __TLV320DAC33_H
+#define __TLV320DAC33_H
+
+#define DAC33_PAGE_SELECT               0x00
+#define DAC33_PWR_CTRL                  0x01
+#define DAC33_PLL_CTRL_A                0x02
+#define DAC33_PLL_CTRL_B                0x03
+#define DAC33_PLL_CTRL_C                0x04
+#define DAC33_PLL_CTRL_D                0x05
+#define DAC33_PLL_CTRL_E                0x06
+#define DAC33_INT_OSC_CTRL              0x07
+#define DAC33_INT_OSC_FREQ_RAT_A        0x08
+#define DAC33_INT_OSC_FREQ_RAT_B        0x09
+#define DAC33_INT_OSC_DAC_RATIO_SET     0x0A
+#define DAC33_CALIB_TIME                0x0B
+#define DAC33_INT_OSC_CTRL_B            0x0C
+#define DAC33_INT_OSC_CTRL_C            0x0D
+#define DAC33_INT_OSC_STATUS            0x0E
+#define DAC33_INT_OSC_DAC_RATIO_READ    0x0F
+#define DAC33_INT_OSC_FREQ_RAT_READ_A   0x10
+#define DAC33_INT_OSC_FREQ_RAT_READ_B   0x11
+#define DAC33_SER_AUDIOIF_CTRL_A        0x12
+#define DAC33_SER_AUDIOIF_CTRL_B        0x13
+#define DAC33_SER_AUDIOIF_CTRL_C        0x14
+#define DAC33_FIFO_CTRL_A               0x15
+#define DAC33_UTHR_MSB                  0x16
+#define DAC33_UTHR_LSB                  0x17
+#define DAC33_ATHR_MSB                  0x18
+#define DAC33_ATHR_LSB                  0x19
+#define DAC33_LTHR_MSB                  0x1A
+#define DAC33_LTHR_LSB                  0x1B
+#define DAC33_PREFILL_MSB               0x1C
+#define DAC33_PREFILL_LSB               0x1D
+#define DAC33_NSAMPLE_MSB               0x1E
+#define DAC33_NSAMPLE_LSB               0x1F
+#define DAC33_FIFO_WPTR_MSB             0x20
+#define DAC33_FIFO_WPTR_LSB             0x21
+#define DAC33_FIFO_RPTR_MSB             0x22
+#define DAC33_FIFO_RPTR_LSB             0x23
+#define DAC33_FIFO_DEPTH_MSB            0x24
+#define DAC33_FIFO_DEPTH_LSB            0x25
+#define DAC33_SAMPLES_REMAINING_MSB     0x26
+#define DAC33_SAMPLES_REMAINING_LSB     0x27
+#define DAC33_FIFO_IRQ_FLAG             0x28
+#define DAC33_FIFO_IRQ_MASK             0x29
+#define DAC33_FIFO_IRQ_MODE_A           0x2A
+#define DAC33_FIFO_IRQ_MODE_B           0x2B
+#define DAC33_DAC_CTRL_A                0x2C
+#define DAC33_DAC_CTRL_B                0x2D
+#define DAC33_DAC_CTRL_C                0x2E
+#define DAC33_LDAC_DIG_VOL_CTRL         0x2F
+#define DAC33_RDAC_DIG_VOL_CTRL         0x30
+#define DAC33_DAC_STATUS_FLAGS          0x31
+#define DAC33_ASRC_CTRL_A               0x32
+#define DAC33_ASRC_CTRL_B               0x33
+#define DAC33_SRC_REF_CLK_RATIO_A       0x34
+#define DAC33_SRC_REF_CLK_RATIO_B       0x35
+#define DAC33_SRC_EST_REF_CLK_RATIO_A   0x36
+#define DAC33_SRC_EST_REF_CLK_RATIO_B   0x37
+#define DAC33_INTP_CTRL_A               0x38
+#define DAC33_INTP_CTRL_B               0x39
+/* Registers 0x3A - 0x3F Reserved */
+#define DAC33_LDAC_PWR_CTRL             0x40
+#define DAC33_RDAC_PWR_CTRL             0x41
+#define DAC33_OUT_AMP_CM_CTRL           0x42
+#define DAC33_OUT_AMP_PWR_CTRL          0x43
+#define DAC33_OUT_AMP_CTRL              0x44
+#define DAC33_LINEL_TO_LLO_VOL          0x45
+/* Registers 0x45 - 0x47 Reserved */
+#define DAC33_LINER_TO_RLO_VOL          0x48
+#define DAC33_ANA_VOL_SOFT_STEP_CTRL    0x49
+#define DAC33_OSC_TRIM                  0x4A
+/* Registers 0x4B - 0x7C Reserved */
+#define DAC33_DEVICE_ID_MSB             0x7D
+#define DAC33_DEVICE_ID_LSB             0x7E
+#define DAC33_DEVICE_REV_ID             0x7F
+
+#define DAC33_CACHEREGNUM               128
+
+/* Bit definitions */
+
+/* DAC33_PWR_CTRL (0x01) */
+#define DAC33_DACRPDNB                  (0x01 << 0)
+#define DAC33_DACLPDNB                  (0x01 << 1)
+#define DAC33_OSCPDNB                   (0x01 << 2)
+#define DAC33_PLLPDNB                   (0x01 << 3)
+#define DAC33_PDNALLB                   (0x01 << 4)
+#define DAC33_SOFT_RESET                (0x01 << 7)
+
+/* DAC33_INT_OSC_CTRL (0x07) */
+#define DAC33_REFSEL                    (0x01 << 1)
+
+/* DAC33_INT_OSC_CTRL_B (0x0C) */
+#define DAC33_ADJSTEP(x)                (x << 0)
+#define DAC33_ADJTHRSHLD(x)             (x << 4)
+
+/* DAC33_INT_OSC_CTRL_C (0x0D) */
+#define DAC33_REFDIV(x)                 (x << 4)
+
+/* DAC33_INT_OSC_STATUS (0x0E) */
+#define DAC33_OSCSTATUS_IDLE_CALIB      (0x00)
+#define DAC33_OSCSTATUS_NORMAL          (0x01)
+#define DAC33_OSCSTATUS_ADJUSTMENT      (0x03)
+#define DAC33_OSCSTATUS_NOT_USED        (0x02)
+
+/* DAC33_SER_AUDIOIF_CTRL_A (0x12) */
+#define DAC33_MSWCLK                    (0x01 << 0)
+#define DAC33_MSBCLK                    (0x01 << 1)
+#define DAC33_AFMT_MASK                 (0x03 << 2)
+#define DAC33_AFMT_I2S                  (0x00 << 2)
+#define DAC33_AFMT_DSP                  (0x01 << 2)
+#define DAC33_AFMT_RIGHT_J              (0x02 << 2)
+#define DAC33_AFMT_LEFT_J               (0x03 << 2)
+#define DAC33_WLEN_MASK                 (0x03 << 4)
+#define DAC33_WLEN_16                   (0x00 << 4)
+#define DAC33_WLEN_20                   (0x01 << 4)
+#define DAC33_WLEN_24                   (0x02 << 4)
+#define DAC33_WLEN_32                   (0x03 << 4)
+#define DAC33_NCYCL_MASK                (0x03 << 6)
+#define DAC33_NCYCL_16                  (0x00 << 6)
+#define DAC33_NCYCL_20                  (0x01 << 6)
+#define DAC33_NCYCL_24                  (0x02 << 6)
+#define DAC33_NCYCL_32                  (0x03 << 6)
+
+/* DAC33_SER_AUDIOIF_CTRL_B (0x13) */
+#define DAC33_DATA_DELAY_MASK           (0x03 << 2)
+#define DAC33_DATA_DELAY(x)             (x << 2)
+#define DAC33_BCLKON                    (0x01 << 5)
+
+/* DAC33_FIFO_CTRL_A (0x15) */
+#define DAC33_WIDTH                             (0x01 << 0)
+#define DAC33_FBYPAS                            (0x01 << 1)
+#define DAC33_FAUTO                             (0x01 << 2)
+#define DAC33_FIFOFLUSH                 (0x01 << 3)
+
+/*
+ * UTHR, ATHR, LTHR, PREFILL, NSAMPLE (0x16 - 0x1F)
+ * 13-bit values
+*/
+#define DAC33_THRREG(x)                 (((x) & 0x1FFF) << 3)
+
+/* DAC33_FIFO_IRQ_MASK (0x29) */
+#define DAC33_MNS                       (0x01 << 0)
+#define DAC33_MPS                       (0x01 << 1)
+#define DAC33_MAT                       (0x01 << 2)
+#define DAC33_MLT                       (0x01 << 3)
+#define DAC33_MUT                       (0x01 << 4)
+#define DAC33_MUF                       (0x01 << 5)
+#define DAC33_MOF                       (0x01 << 6)
+
+#define DAC33_FIFO_IRQ_MODE_MASK        (0x03)
+#define DAC33_FIFO_IRQ_MODE_RISING      (0x00)
+#define DAC33_FIFO_IRQ_MODE_FALLING     (0x01)
+#define DAC33_FIFO_IRQ_MODE_LEVEL       (0x02)
+#define DAC33_FIFO_IRQ_MODE_EDGE        (0x03)
+
+/* DAC33_FIFO_IRQ_MODE_A (0x2A) */
+#define DAC33_UTM(x)                    (x << 0)
+#define DAC33_UFM(x)                    (x << 2)
+#define DAC33_OFM(x)                    (x << 4)
+
+/* DAC33_FIFO_IRQ_MODE_B (0x2B) */
+#define DAC33_NSM(x)                    (x << 0)
+#define DAC33_PSM(x)                    (x << 2)
+#define DAC33_ATM(x)                    (x << 4)
+#define DAC33_LTM(x)                    (x << 6)
+
+/* DAC33_DAC_CTRL_A (0x2C) */
+#define DAC33_DACRATE(x)                (x << 0)
+#define DAC33_DACDUAL                   (0x01 << 4)
+#define DAC33_DACLKSEL_MASK             (0x03 << 5)
+#define DAC33_DACLKSEL_INTSOC           (0x00 << 5)
+#define DAC33_DACLKSEL_PLL              (0x01 << 5)
+#define DAC33_DACLKSEL_MCLK             (0x02 << 5)
+#define DAC33_DACLKSEL_BCLK             (0x03 << 5)
+
+/* DAC33_DAC_CTRL_B (0x2D) */
+#define DAC33_DACSRCR_MASK              (0x03 << 0)
+#define DAC33_DACSRCR_MUTE              (0x00 << 0)
+#define DAC33_DACSRCR_RIGHT             (0x01 << 0)
+#define DAC33_DACSRCR_LEFT              (0x02 << 0)
+#define DAC33_DACSRCR_MONOMIX           (0x03 << 0)
+#define DAC33_DACSRCL_MASK              (0x03 << 2)
+#define DAC33_DACSRCL_MUTE              (0x00 << 2)
+#define DAC33_DACSRCL_LEFT              (0x01 << 2)
+#define DAC33_DACSRCL_RIGHT             (0x02 << 2)
+#define DAC33_DACSRCL_MONOMIX           (0x03 << 2)
+#define DAC33_DVOLSTEP_MASK             (0x03 << 4)
+#define DAC33_DVOLSTEP_SS_PERFS         (0x00 << 4)
+#define DAC33_DVOLSTEP_SS_PER2FS        (0x01 << 4)
+#define DAC33_DVOLSTEP_SS_DISABLED      (0x02 << 4)
+#define DAC33_DVOLCTRL_MASK             (0x03 << 6)
+#define DAC33_DVOLCTRL_LR_INDEPENDENT1  (0x00 << 6)
+#define DAC33_DVOLCTRL_LR_RIGHT_CONTROL (0x01 << 6)
+#define DAC33_DVOLCTRL_LR_LEFT_CONTROL  (0x02 << 6)
+#define DAC33_DVOLCTRL_LR_INDEPENDENT2  (0x03 << 6)
+
+/* DAC33_DAC_CTRL_C (0x2E) */
+#define DAC33_DEEMENR                   (0x01 << 0)
+#define DAC33_EFFENR                    (0x01 << 1)
+#define DAC33_DEEMENL                   (0x01 << 2)
+#define DAC33_EFFENL                    (0x01 << 3)
+#define DAC33_EN3D                      (0x01 << 4)
+#define DAC33_RESYNMUTE                 (0x01 << 5)
+#define DAC33_RESYNEN                   (0x01 << 6)
+
+/* DAC33_ASRC_CTRL_A (0x32) */
+#define DAC33_SRCBYP                    (0x01 << 0)
+#define DAC33_SRCLKSEL_MASK             (0x03 << 1)
+#define DAC33_SRCLKSEL_INTSOC           (0x00 << 1)
+#define DAC33_SRCLKSEL_PLL              (0x01 << 1)
+#define DAC33_SRCLKSEL_MCLK             (0x02 << 1)
+#define DAC33_SRCLKSEL_BCLK             (0x03 << 1)
+#define DAC33_SRCLKDIV(x)               (x << 3)
+
+/* DAC33_ASRC_CTRL_B (0x33) */
+#define DAC33_SRCSETUP(x)               (x << 0)
+#define DAC33_SRCREFSEL                 (0x01 << 4)
+#define DAC33_SRCREFDIV(x)              (x << 5)
+
+/* DAC33_INTP_CTRL_A (0x38) */
+#define DAC33_INTPSEL                   (0x01 << 0)
+#define DAC33_INTPM_MASK                (0x03 << 1)
+#define DAC33_INTPM_ALOW_OPENDRAIN      (0x00 << 1)
+#define DAC33_INTPM_ALOW                (0x01 << 1)
+#define DAC33_INTPM_AHIGH               (0x02 << 1)
+
+/* DAC33_LDAC_PWR_CTRL (0x40) */
+/* DAC33_RDAC_PWR_CTRL (0x41) */
+#define DAC33_DACLRNUM                  (0x01 << 2)
+#define DAC33_LROUT_GAIN(x)             (x << 0)
+
+/* DAC33_ANA_VOL_SOFT_STEP_CTRL (0x49) */
+#define DAC33_VOLCLKSEL                 (0x01 << 0)
+#define DAC33_VOLCLKEN                  (0x01 << 1)
+#define DAC33_VOLBYPASS                 (0x01 << 2)
+
+#define TLV320DAC33_MCLK                0
+#define TLV320DAC33_SLEEPCLK            1
+
+extern struct snd_soc_dai dac33_dai;
+extern struct snd_soc_codec_device soc_codec_dev_tlv320dac33;
+
+#endif /* __TLV320DAC33_H */
diff --git a/sound/soc/codecs/tpa6130a2.c b/sound/soc/codecs/tpa6130a2.c
new file mode 100644
index 000000000000..569ad8758a84
--- /dev/null
+++ b/sound/soc/codecs/tpa6130a2.c
@@ -0,0 +1,531 @@
+/*
+ * ALSA SoC Texas Instruments TPA6130A2 headset stereo amplifier driver
+ *
+ * Copyright (C) Nokia Corporation
+ *
+ * Author: Peter Ujfalusi <peter.ujfalusi@nokia.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program 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., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ */
+
+#include <linux/module.h>
+#include <linux/errno.h>
+#include <linux/device.h>
+#include <linux/i2c.h>
+#include <linux/gpio.h>
+#include <linux/regulator/consumer.h>
+#include <linux/slab.h>
+#include <sound/tpa6130a2-plat.h>
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+#include <sound/tlv.h>
+
+#include "tpa6130a2.h"
+
+static struct i2c_client *tpa6130a2_client;
+
+#define TPA6130A2_NUM_SUPPLIES 2
+static const char *tpa6130a2_supply_names[TPA6130A2_NUM_SUPPLIES] = {
+        "CPVSS",
+        "Vdd",
+};
+
+static const char *tpa6140a2_supply_names[TPA6130A2_NUM_SUPPLIES] = {
+        "HPVdd",
+        "AVdd",
+};
+
+/* This struct is used to save the context */
+struct tpa6130a2_data {
+        struct mutex mutex;
+        unsigned char regs[TPA6130A2_CACHEREGNUM];
+        struct regulator_bulk_data supplies[TPA6130A2_NUM_SUPPLIES];
+        int power_gpio;
+        unsigned char power_state;
+};
+
+static int tpa6130a2_i2c_read(int reg)
+{
+        struct tpa6130a2_data *data;
+        int val;
+
+        BUG_ON(tpa6130a2_client == NULL);
+        data = i2c_get_clientdata(tpa6130a2_client);
+
+        /* If powered off, return the cached value */
+        if (data->power_state) {
+                val = i2c_smbus_read_byte_data(tpa6130a2_client, reg);
+                if (val < 0)
+                        dev_err(&tpa6130a2_client->dev, "Read failed\n");
+                else
+                        data->regs[reg] = val;
+        } else {
+                val = data->regs[reg];
+        }
+
+        return val;
+}
+
+static int tpa6130a2_i2c_write(int reg, u8 value)
+{
+        struct tpa6130a2_data *data;
+        int val = 0;
+
+        BUG_ON(tpa6130a2_client == NULL);
+        data = i2c_get_clientdata(tpa6130a2_client);
+
+        if (data->power_state) {
+                val = i2c_smbus_write_byte_data(tpa6130a2_client, reg, value);
+                if (val < 0)
+                        dev_err(&tpa6130a2_client->dev, "Write failed\n");
+        }
+
+        /* Either powered on or off, we save the context */
+        data->regs[reg] = value;
+
+        return val;
+}
+
+static u8 tpa6130a2_read(int reg)
+{
+        struct tpa6130a2_data *data;
+
+        BUG_ON(tpa6130a2_client == NULL);
+        data = i2c_get_clientdata(tpa6130a2_client);
+
+        return data->regs[reg];
+}
+
+static void tpa6130a2_initialize(void)
+{
+        struct tpa6130a2_data *data;
+        int i;
+
+        BUG_ON(tpa6130a2_client == NULL);
+        data = i2c_get_clientdata(tpa6130a2_client);
+
+        for (i = 1; i < TPA6130A2_REG_VERSION; i++)
+                tpa6130a2_i2c_write(i, data->regs[i]);
+}
+
+static int tpa6130a2_power(int power)
+{
+        struct  tpa6130a2_data *data;
+        u8      val;
+        int     ret;
+
+        BUG_ON(tpa6130a2_client == NULL);
+        data = i2c_get_clientdata(tpa6130a2_client);
+
+        mutex_lock(&data->mutex);
+        if (power) {
+                /* Power on */
+                if (data->power_gpio >= 0)
+                        gpio_set_value(data->power_gpio, 1);
+
+                ret = regulator_bulk_enable(ARRAY_SIZE(data->supplies),
+                                            data->supplies);
+                if (ret != 0) {
+                        dev_err(&tpa6130a2_client->dev,
+                                "Failed to enable supplies: %d\n", ret);
+                        goto exit;
+                }
+
+                data->power_state = 1;
+                tpa6130a2_initialize();
+
+                /* Clear SWS */
+                val = tpa6130a2_read(TPA6130A2_REG_CONTROL);
+                val &= ~TPA6130A2_SWS;
+                tpa6130a2_i2c_write(TPA6130A2_REG_CONTROL, val);
+        } else {
+                /* set SWS */
+                val = tpa6130a2_read(TPA6130A2_REG_CONTROL);
+                val |= TPA6130A2_SWS;
+                tpa6130a2_i2c_write(TPA6130A2_REG_CONTROL, val);
+
+                /* Power off */
+                if (data->power_gpio >= 0)
+                        gpio_set_value(data->power_gpio, 0);
+
+                ret = regulator_bulk_disable(ARRAY_SIZE(data->supplies),
+                                             data->supplies);
+                if (ret != 0) {
+                        dev_err(&tpa6130a2_client->dev,
+                                "Failed to disable supplies: %d\n", ret);
+                        goto exit;
+                }
+
+                data->power_state = 0;
+        }
+
+exit:
+        mutex_unlock(&data->mutex);
+        return ret;
+}
+
+static int tpa6130a2_get_reg(struct snd_kcontrol *kcontrol,
+                struct snd_ctl_elem_value *ucontrol)
+{
+        struct soc_mixer_control *mc =
+                (struct soc_mixer_control *)kcontrol->private_value;
+        struct tpa6130a2_data *data;
+        unsigned int reg = mc->reg;
+        unsigned int shift = mc->shift;
+        unsigned int mask = mc->max;
+        unsigned int invert = mc->invert;
+
+        BUG_ON(tpa6130a2_client == NULL);
+        data = i2c_get_clientdata(tpa6130a2_client);
+
+        mutex_lock(&data->mutex);
+
+        ucontrol->value.integer.value[0] =
+                (tpa6130a2_read(reg) >> shift) & mask;
+
+        if (invert)
+                ucontrol->value.integer.value[0] =
+                        mask - ucontrol->value.integer.value[0];
+
+        mutex_unlock(&data->mutex);
+        return 0;
+}
+
+static int tpa6130a2_set_reg(struct snd_kcontrol *kcontrol,
+                struct snd_ctl_elem_value *ucontrol)
+{
+        struct soc_mixer_control *mc =
+                (struct soc_mixer_control *)kcontrol->private_value;
+        struct tpa6130a2_data *data;
+        unsigned int reg = mc->reg;
+        unsigned int shift = mc->shift;
+        unsigned int mask = mc->max;
+        unsigned int invert = mc->invert;
+        unsigned int val = (ucontrol->value.integer.value[0] & mask);
+        unsigned int val_reg;
+
+        BUG_ON(tpa6130a2_client == NULL);
+        data = i2c_get_clientdata(tpa6130a2_client);
+
+        if (invert)
+                val = mask - val;
+
+        mutex_lock(&data->mutex);
+
+        val_reg = tpa6130a2_read(reg);
+        if (((val_reg >> shift) & mask) == val) {
+                mutex_unlock(&data->mutex);
+                return 0;
+        }
+
+        val_reg &= ~(mask << shift);
+        val_reg |= val << shift;
+        tpa6130a2_i2c_write(reg, val_reg);
+
+        mutex_unlock(&data->mutex);
+
+        return 1;
+}
+
+/*
+ * TPA6130 volume. From -59.5 to 4 dB with increasing step size when going
+ * down in gain.
+ */
+static const unsigned int tpa6130_tlv[] = {
+        TLV_DB_RANGE_HEAD(10),
+        0, 1, TLV_DB_SCALE_ITEM(-5950, 600, 0),
+        2, 3, TLV_DB_SCALE_ITEM(-5000, 250, 0),
+        4, 5, TLV_DB_SCALE_ITEM(-4550, 160, 0),
+        6, 7, TLV_DB_SCALE_ITEM(-4140, 190, 0),
+        8, 9, TLV_DB_SCALE_ITEM(-3650, 120, 0),
+        10, 11, TLV_DB_SCALE_ITEM(-3330, 160, 0),
+        12, 13, TLV_DB_SCALE_ITEM(-3040, 180, 0),
+        14, 20, TLV_DB_SCALE_ITEM(-2710, 110, 0),
+        21, 37, TLV_DB_SCALE_ITEM(-1960, 74, 0),
+        38, 63, TLV_DB_SCALE_ITEM(-720, 45, 0),
+};
+
+static const struct snd_kcontrol_new tpa6130a2_controls[] = {
+        SOC_SINGLE_EXT_TLV("TPA6130A2 Headphone Playback Volume",
+                       TPA6130A2_REG_VOL_MUTE, 0, 0x3f, 0,
+                       tpa6130a2_get_reg, tpa6130a2_set_reg,
+                       tpa6130_tlv),
+};
+
+/*
+ * Enable or disable channel (left or right)
+ * The bit number for mute and amplifier are the same per channel:
+ * bit 6: Right channel
+ * bit 7: Left channel
+ * in both registers.
+ */
+static void tpa6130a2_channel_enable(u8 channel, int enable)
+{
+        u8      val;
+
+        if (enable) {
+                /* Enable channel */
+                /* Enable amplifier */
+                val = tpa6130a2_read(TPA6130A2_REG_CONTROL);
+                val |= channel;
+                tpa6130a2_i2c_write(TPA6130A2_REG_CONTROL, val);
+
+                /* Unmute channel */
+                val = tpa6130a2_read(TPA6130A2_REG_VOL_MUTE);
+                val &= ~channel;
+                tpa6130a2_i2c_write(TPA6130A2_REG_VOL_MUTE, val);
+        } else {
+                /* Disable channel */
+                /* Mute channel */
+                val = tpa6130a2_read(TPA6130A2_REG_VOL_MUTE);
+                val |= channel;
+                tpa6130a2_i2c_write(TPA6130A2_REG_VOL_MUTE, val);
+
+                /* Disable amplifier */
+                val = tpa6130a2_read(TPA6130A2_REG_CONTROL);
+                val &= ~channel;
+                tpa6130a2_i2c_write(TPA6130A2_REG_CONTROL, val);
+        }
+}
+
+static int tpa6130a2_left_event(struct snd_soc_dapm_widget *w,
+                struct snd_kcontrol *kcontrol, int event)
+{
+        switch (event) {
+        case SND_SOC_DAPM_POST_PMU:
+                tpa6130a2_channel_enable(TPA6130A2_HP_EN_L, 1);
+                break;
+        case SND_SOC_DAPM_POST_PMD:
+                tpa6130a2_channel_enable(TPA6130A2_HP_EN_L, 0);
+                break;
+        }
+        return 0;
+}
+
+static int tpa6130a2_right_event(struct snd_soc_dapm_widget *w,
+                struct snd_kcontrol *kcontrol, int event)
+{
+        switch (event) {
+        case SND_SOC_DAPM_POST_PMU:
+                tpa6130a2_channel_enable(TPA6130A2_HP_EN_R, 1);
+                break;
+        case SND_SOC_DAPM_POST_PMD:
+                tpa6130a2_channel_enable(TPA6130A2_HP_EN_R, 0);
+                break;
+        }
+        return 0;
+}
+
+static int tpa6130a2_supply_event(struct snd_soc_dapm_widget *w,
+                struct snd_kcontrol *kcontrol, int event)
+{
+        int ret = 0;
+
+        switch (event) {
+        case SND_SOC_DAPM_POST_PMU:
+                ret = tpa6130a2_power(1);
+                break;
+        case SND_SOC_DAPM_POST_PMD:
+                ret = tpa6130a2_power(0);
+                break;
+        }
+        return ret;
+}
+
+static const struct snd_soc_dapm_widget tpa6130a2_dapm_widgets[] = {
+        SND_SOC_DAPM_PGA_E("TPA6130A2 Left", SND_SOC_NOPM,
+                        0, 0, NULL, 0, tpa6130a2_left_event,
+                        SND_SOC_DAPM_POST_PMU|SND_SOC_DAPM_POST_PMD),
+        SND_SOC_DAPM_PGA_E("TPA6130A2 Right", SND_SOC_NOPM,
+                        0, 0, NULL, 0, tpa6130a2_right_event,
+                        SND_SOC_DAPM_POST_PMU|SND_SOC_DAPM_POST_PMD),
+        SND_SOC_DAPM_SUPPLY("TPA6130A2 Enable", SND_SOC_NOPM,
+                        0, 0, tpa6130a2_supply_event,
+                        SND_SOC_DAPM_POST_PMU|SND_SOC_DAPM_POST_PMD),
+        /* Outputs */
+        SND_SOC_DAPM_HP("TPA6130A2 Headphone Left", NULL),
+        SND_SOC_DAPM_HP("TPA6130A2 Headphone Right", NULL),
+};
+
+static const struct snd_soc_dapm_route audio_map[] = {
+        {"TPA6130A2 Headphone Left", NULL, "TPA6130A2 Left"},
+        {"TPA6130A2 Headphone Right", NULL, "TPA6130A2 Right"},
+
+        {"TPA6130A2 Headphone Left", NULL, "TPA6130A2 Enable"},
+        {"TPA6130A2 Headphone Right", NULL, "TPA6130A2 Enable"},
+};
+
+int tpa6130a2_add_controls(struct snd_soc_codec *codec)
+{
+        snd_soc_dapm_new_controls(codec, tpa6130a2_dapm_widgets,
+                                ARRAY_SIZE(tpa6130a2_dapm_widgets));
+
+        snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
+
+        return snd_soc_add_controls(codec, tpa6130a2_controls,
+                                ARRAY_SIZE(tpa6130a2_controls));
+
+}
+EXPORT_SYMBOL_GPL(tpa6130a2_add_controls);
+
+static int __devinit tpa6130a2_probe(struct i2c_client *client,
+                                     const struct i2c_device_id *id)
+{
+        struct device *dev;
+        struct tpa6130a2_data *data;
+        struct tpa6130a2_platform_data *pdata;
+        int i, ret;
+
+        dev = &client->dev;
+
+        if (client->dev.platform_data == NULL) {
+                dev_err(dev, "Platform data not set\n");
+                dump_stack();
+                return -ENODEV;
+        }
+
+        data = kzalloc(sizeof(*data), GFP_KERNEL);
+        if (data == NULL) {
+                dev_err(dev, "Can not allocate memory\n");
+                return -ENOMEM;
+        }
+
+        tpa6130a2_client = client;
+
+        i2c_set_clientdata(tpa6130a2_client, data);
+
+        pdata = client->dev.platform_data;
+        data->power_gpio = pdata->power_gpio;
+
+        mutex_init(&data->mutex);
+
+        /* Set default register values */
+        data->regs[TPA6130A2_REG_CONTROL] =     TPA6130A2_SWS;
+        data->regs[TPA6130A2_REG_VOL_MUTE] =    TPA6130A2_MUTE_R |
+                                                TPA6130A2_MUTE_L;
+
+        if (data->power_gpio >= 0) {
+                ret = gpio_request(data->power_gpio, "tpa6130a2 enable");
+                if (ret < 0) {
+                        dev_err(dev, "Failed to request power GPIO (%d)\n",
+                                data->power_gpio);
+                        goto err_gpio;
+                }
+                gpio_direction_output(data->power_gpio, 0);
+        }
+
+        switch (pdata->id) {
+        case TPA6130A2:
+                for (i = 0; i < ARRAY_SIZE(data->supplies); i++)
+                        data->supplies[i].supply = tpa6130a2_supply_names[i];
+                break;
+        case TPA6140A2:
+                for (i = 0; i < ARRAY_SIZE(data->supplies); i++)
+                        data->supplies[i].supply = tpa6140a2_supply_names[i];;
+                break;
+        default:
+                dev_warn(dev, "Unknown TPA model (%d). Assuming 6130A2\n",
+                         pdata->id);
+                for (i = 0; i < ARRAY_SIZE(data->supplies); i++)
+                        data->supplies[i].supply = tpa6130a2_supply_names[i];
+        }
+
+        ret = regulator_bulk_get(dev, ARRAY_SIZE(data->supplies),
+                                 data->supplies);
+        if (ret != 0) {
+                dev_err(dev, "Failed to request supplies: %d\n", ret);
+                goto err_regulator;
+        }
+
+        ret = tpa6130a2_power(1);
+        if (ret != 0)
+                goto err_power;
+
+
+        /* Read version */
+        ret = tpa6130a2_i2c_read(TPA6130A2_REG_VERSION) &
+                                 TPA6130A2_VERSION_MASK;
+        if ((ret != 1) && (ret != 2))
+                dev_warn(dev, "UNTESTED version detected (%d)\n", ret);
+
+        /* Disable the chip */
+        ret = tpa6130a2_power(0);
+        if (ret != 0)
+                goto err_power;
+
+        return 0;
+
+err_power:
+        regulator_bulk_free(ARRAY_SIZE(data->supplies), data->supplies);
+err_regulator:
+        if (data->power_gpio >= 0)
+                gpio_free(data->power_gpio);
+err_gpio:
+        kfree(data);
+        i2c_set_clientdata(tpa6130a2_client, NULL);
+        tpa6130a2_client = NULL;
+
+        return ret;
+}
+
+static int __devexit tpa6130a2_remove(struct i2c_client *client)
+{
+        struct tpa6130a2_data *data = i2c_get_clientdata(client);
+
+        tpa6130a2_power(0);
+
+        if (data->power_gpio >= 0)
+                gpio_free(data->power_gpio);
+
+        regulator_bulk_free(ARRAY_SIZE(data->supplies), data->supplies);
+
+        kfree(data);
+        tpa6130a2_client = NULL;
+
+        return 0;
+}
+
+static const struct i2c_device_id tpa6130a2_id[] = {
+        { "tpa6130a2", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, tpa6130a2_id);
+
+static struct i2c_driver tpa6130a2_i2c_driver = {
+        .driver = {
+                .name = "tpa6130a2",
+                .owner = THIS_MODULE,
+        },
+        .probe = tpa6130a2_probe,
+        .remove = __devexit_p(tpa6130a2_remove),
+        .id_table = tpa6130a2_id,
+};
+
+static int __init tpa6130a2_init(void)
+{
+        return i2c_add_driver(&tpa6130a2_i2c_driver);
+}
+
+static void __exit tpa6130a2_exit(void)
+{
+        i2c_del_driver(&tpa6130a2_i2c_driver);
+}
+
+MODULE_AUTHOR("Peter Ujfalusi");
+MODULE_DESCRIPTION("TPA6130A2 Headphone amplifier driver");
+MODULE_LICENSE("GPL");
+
+module_init(tpa6130a2_init);
+module_exit(tpa6130a2_exit);
diff --git a/sound/soc/codecs/tpa6130a2.h b/sound/soc/codecs/tpa6130a2.h
new file mode 100644
index 000000000000..57e867fd86d1
--- /dev/null
+++ b/sound/soc/codecs/tpa6130a2.h
@@ -0,0 +1,61 @@
+/*
+ * ALSA SoC TPA6130A2 amplifier driver
+ *
+ * Copyright (C) Nokia Corporation
+ *
+ * Author: Peter Ujfalusi <peter.ujfalusi@nokia.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program 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., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#ifndef __TPA6130A2_H__
+#define __TPA6130A2_H__
+
+/* Register addresses */
+#define TPA6130A2_REG_CONTROL           0x01
+#define TPA6130A2_REG_VOL_MUTE          0x02
+#define TPA6130A2_REG_OUT_IMPEDANCE     0x03
+#define TPA6130A2_REG_VERSION           0x04
+
+#define TPA6130A2_CACHEREGNUM   (TPA6130A2_REG_VERSION + 1)
+
+/* Register bits */
+/* TPA6130A2_REG_CONTROL (0x01) */
+#define TPA6130A2_SWS                   (0x01 << 0)
+#define TPA6130A2_TERMAL                (0x01 << 1)
+#define TPA6130A2_MODE(x)               (x << 4)
+#define TPA6130A2_MODE_STEREO           (0x00)
+#define TPA6130A2_MODE_DUAL_MONO        (0x01)
+#define TPA6130A2_MODE_BRIDGE           (0x02)
+#define TPA6130A2_MODE_MASK             (0x03)
+#define TPA6130A2_HP_EN_R               (0x01 << 6)
+#define TPA6130A2_HP_EN_L               (0x01 << 7)
+
+/* TPA6130A2_REG_VOL_MUTE (0x02) */
+#define TPA6130A2_VOLUME(x)             ((x & 0x3f) << 0)
+#define TPA6130A2_MUTE_R                (0x01 << 6)
+#define TPA6130A2_MUTE_L                (0x01 << 7)
+
+/* TPA6130A2_REG_OUT_IMPEDANCE (0x03) */
+#define TPA6130A2_HIZ_R                 (0x01 << 0)
+#define TPA6130A2_HIZ_L                 (0x01 << 1)
+
+/* TPA6130A2_REG_VERSION (0x04) */
+#define TPA6130A2_VERSION_MASK          (0x0f)
+
+extern int tpa6130a2_add_controls(struct snd_soc_codec *codec);
+
+#endif /* __TPA6130A2_H__ */
diff --git a/sound/soc/codecs/twl4030.c b/sound/soc/codecs/twl4030.c
index 4df7c6c61c76..520ffd6536c3 100644
--- a/sound/soc/codecs/twl4030.c
+++ b/sound/soc/codecs/twl4030.c
@@ -26,7 +26,8 @@
 #include <linux/pm.h>
 #include <linux/i2c.h>
 #include <linux/platform_device.h>
-#include <linux/i2c/twl4030.h>
+#include <linux/i2c/twl.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
@@ -55,7 +56,7 @@ static const u8 twl4030_reg[TWL4030_CACHEREGNUM] = {
         0x0c, /* REG_ATXR1PGA           (0xB)   */
         0x00, /* REG_AVTXL2PGA          (0xC)   */
         0x00, /* REG_AVTXR2PGA          (0xD)   */
-        0x01, /* REG_AUDIO_IF           (0xE)   */
+        0x00, /* REG_AUDIO_IF           (0xE)   */
         0x00, /* REG_VOICE_IF           (0xF)   */
         0x00, /* REG_ARXR1PGA           (0x10)  */
         0x00, /* REG_ARXL1PGA           (0x11)  */
@@ -64,19 +65,19 @@ static const u8 twl4030_reg[TWL4030_CACHEREGNUM] = {
         0x00, /* REG_VRXPGA             (0x14)  */
         0x00, /* REG_VSTPGA             (0x15)  */
         0x00, /* REG_VRX2ARXPGA         (0x16)  */
-        0x0c, /* REG_AVDAC_CTL          (0x17)  */
+        0x00, /* REG_AVDAC_CTL          (0x17)  */
         0x00, /* REG_ARX2VTXPGA         (0x18)  */
         0x00, /* REG_ARXL1_APGA_CTL     (0x19)  */
         0x00, /* REG_ARXR1_APGA_CTL     (0x1A)  */
-        0x4b, /* REG_ARXL2_APGA_CTL     (0x1B)  */
-        0x4b, /* REG_ARXR2_APGA_CTL     (0x1C)  */
+        0x4a, /* REG_ARXL2_APGA_CTL     (0x1B)  */
+        0x4a, /* REG_ARXR2_APGA_CTL     (0x1C)  */
         0x00, /* REG_ATX2ARXPGA         (0x1D)  */
         0x00, /* REG_BT_IF              (0x1E)  */
         0x00, /* REG_BTPGA              (0x1F)  */
         0x00, /* REG_BTSTPGA            (0x20)  */
         0x00, /* REG_EAR_CTL            (0x21)  */
-        0x24, /* REG_HS_SEL             (0x22)  */
-        0x0a, /* REG_HS_GAIN_SET        (0x23)  */
+        0x00, /* REG_HS_SEL             (0x22)  */
+        0x00, /* REG_HS_GAIN_SET        (0x23)  */
         0x00, /* REG_HS_POPN_SET        (0x24)  */
         0x00, /* REG_PREDL_CTL          (0x25)  */
         0x00, /* REG_PREDR_CTL          (0x26)  */
@@ -99,7 +100,7 @@ static const u8 twl4030_reg[TWL4030_CACHEREGNUM] = {
         0x00, /* REG_I2S_RX_SCRAMBLE_H  (0x37)  */
         0x00, /* REG_I2S_RX_SCRAMBLE_M  (0x38)  */
         0x00, /* REG_I2S_RX_SCRAMBLE_L  (0x39)  */
-        0x16, /* REG_APLL_CTL           (0x3A)  */
+        0x06, /* REG_APLL_CTL           (0x3A)  */
         0x00, /* REG_DTMF_CTL           (0x3B)  */
         0x00, /* REG_DTMF_PGA_CTL2      (0x3C)  */
         0x00, /* REG_DTMF_PGA_CTL1      (0x3D)  */
@@ -120,9 +121,10 @@ static const u8 twl4030_reg[TWL4030_CACHEREGNUM] = {
 
 /* codec private data */
 struct twl4030_priv {
-        unsigned int bypass_state;
+        struct snd_soc_codec codec;
+
         unsigned int codec_powered;
-        unsigned int codec_muted;
+        unsigned int apll_enabled;
 
         struct snd_pcm_substream *master_substream;
         struct snd_pcm_substream *slave_substream;
@@ -174,7 +176,7 @@ static int twl4030_write(struct snd_soc_codec *codec,
 {
         twl4030_write_reg_cache(codec, reg, value);
         if (likely(reg < TWL4030_REG_SW_SHADOW))
-                return twl4030_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE, value,
+                return twl_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE, value,
                                             reg);
         else
                 return 0;
@@ -183,19 +185,20 @@ static int twl4030_write(struct snd_soc_codec *codec,
 static void twl4030_codec_enable(struct snd_soc_codec *codec, int enable)
 {
         struct twl4030_priv *twl4030 = codec->private_data;
-        u8 mode;
+        int mode;
 
         if (enable == twl4030->codec_powered)
                 return;
 
-        mode = twl4030_read_reg_cache(codec, TWL4030_REG_CODEC_MODE);
         if (enable)
-                mode |= TWL4030_CODECPDZ;
+                mode = twl4030_codec_enable_resource(TWL4030_CODEC_RES_POWER);
         else
-                mode &= ~TWL4030_CODECPDZ;
+                mode = twl4030_codec_disable_resource(TWL4030_CODEC_RES_POWER);
 
-        twl4030_write(codec, TWL4030_REG_CODEC_MODE, mode);
-        twl4030->codec_powered = enable;
+        if (mode >= 0) {
+                twl4030_write_reg_cache(codec, TWL4030_REG_CODEC_MODE, mode);
+                twl4030->codec_powered = enable;
+        }
 
         /* REVISIT: this delay is present in TI sample drivers */
         /* but there seems to be no TRM requirement for it     */
@@ -212,31 +215,30 @@ static void twl4030_init_chip(struct snd_soc_codec *codec)
 
         /* set all audio section registers to reasonable defaults */
         for (i = TWL4030_REG_OPTION; i <= TWL4030_REG_MISC_SET_2; i++)
-                twl4030_write(codec, i, cache[i]);
+                if (i != TWL4030_REG_APLL_CTL)
+                        twl4030_write(codec, i, cache[i]);
 
 }
 
-static void twl4030_codec_mute(struct snd_soc_codec *codec, int mute)
+static void twl4030_apll_enable(struct snd_soc_codec *codec, int enable)
 {
         struct twl4030_priv *twl4030 = codec->private_data;
-        u8 reg_val;
+        int status;
 
-        if (mute == twl4030->codec_muted)
+        if (enable == twl4030->apll_enabled)
                 return;
 
-        if (mute) {
-                /* Disable PLL */
-                reg_val = twl4030_read_reg_cache(codec, TWL4030_REG_APLL_CTL);
-                reg_val &= ~TWL4030_APLL_EN;
-                twl4030_write(codec, TWL4030_REG_APLL_CTL, reg_val);
-        } else {
+        if (enable)
                 /* Enable PLL */
-                reg_val = twl4030_read_reg_cache(codec, TWL4030_REG_APLL_CTL);
-                reg_val |= TWL4030_APLL_EN;
-                twl4030_write(codec, TWL4030_REG_APLL_CTL, reg_val);
-        }
+                status = twl4030_codec_enable_resource(TWL4030_CODEC_RES_APLL);
+        else
+                /* Disable PLL */
+                status = twl4030_codec_disable_resource(TWL4030_CODEC_RES_APLL);
+
+        if (status >= 0)
+                twl4030_write_reg_cache(codec, TWL4030_REG_APLL_CTL, status);
 
-        twl4030->codec_muted = mute;
+        twl4030->apll_enabled = enable;
 }
 
 static void twl4030_power_up(struct snd_soc_codec *codec)
@@ -260,7 +262,7 @@ static void twl4030_power_up(struct snd_soc_codec *codec)
         do {
                 /* this takes a little while, so don't slam i2c */
                 udelay(2000);
-                twl4030_i2c_read_u8(TWL4030_MODULE_AUDIO_VOICE, &byte,
+                twl_i2c_read_u8(TWL4030_MODULE_AUDIO_VOICE, &byte,
                                     TWL4030_REG_ANAMICL);
         } while ((i++ < 100) &&
                  ((byte & TWL4030_CNCL_OFFSET_START) ==
@@ -541,7 +543,7 @@ static int pin_name##pga_event(struct snd_soc_dapm_widget *w,		\
                 break;                                                  \
         case SND_SOC_DAPM_POST_PMD:                                     \
                 reg_val = twl4030_read_reg_cache(w->codec, reg);        \
-                twl4030_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE,        \
+                twl_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE,    \
                                         reg_val & (~mask),              \
                                         reg);                           \
                 break;                                                  \
@@ -613,6 +615,27 @@ static int handsfreerpga_event(struct snd_soc_dapm_widget *w,
         return 0;
 }
 
+static int vibramux_event(struct snd_soc_dapm_widget *w,
+                struct snd_kcontrol *kcontrol, int event)
+{
+        twl4030_write(w->codec, TWL4030_REG_VIBRA_SET, 0xff);
+        return 0;
+}
+
+static int apll_event(struct snd_soc_dapm_widget *w,
+                struct snd_kcontrol *kcontrol, int event)
+{
+        switch (event) {
+        case SND_SOC_DAPM_PRE_PMU:
+                twl4030_apll_enable(w->codec, 1);
+                break;
+        case SND_SOC_DAPM_POST_PMD:
+                twl4030_apll_enable(w->codec, 0);
+                break;
+        }
+        return 0;
+}
+
 static void headset_ramp(struct snd_soc_codec *codec, int ramp)
 {
         struct snd_soc_device *socdev = codec->socdev;
@@ -657,7 +680,7 @@ static void headset_ramp(struct snd_soc_codec *codec, int ramp)
                 mdelay((ramp_base[(hs_pop & TWL4030_RAMP_DELAY) >> 2] /
                         twl4030->sysclk) + 1);
                 /* Bypass the reg_cache to mute the headset */
-                twl4030_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE,
+                twl_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE,
                                         hs_gain & (~0x0f),
                                         TWL4030_REG_HS_GAIN_SET);
 
@@ -724,67 +747,6 @@ static int headsetrpga_event(struct snd_soc_dapm_widget *w,
         return 0;
 }
 
-static int bypass_event(struct snd_soc_dapm_widget *w,
-                struct snd_kcontrol *kcontrol, int event)
-{
-        struct soc_mixer_control *m =
-                (struct soc_mixer_control *)w->kcontrols->private_value;
-        struct twl4030_priv *twl4030 = w->codec->private_data;
-        unsigned char reg, misc;
-
-        reg = twl4030_read_reg_cache(w->codec, m->reg);
-
-        /*
-         * bypass_state[0:3] - analog HiFi bypass
-         * bypass_state[4]   - analog voice bypass
-         * bypass_state[5]   - digital voice bypass
-         * bypass_state[6:7] - digital HiFi bypass
-         */
-        if (m->reg == TWL4030_REG_VSTPGA) {
-                /* Voice digital bypass */
-                if (reg)
-                        twl4030->bypass_state |= (1 << 5);
-                else
-                        twl4030->bypass_state &= ~(1 << 5);
-        } else if (m->reg <= TWL4030_REG_ARXR2_APGA_CTL) {
-                /* Analog bypass */
-                if (reg & (1 << m->shift))
-                        twl4030->bypass_state |=
-                                (1 << (m->reg - TWL4030_REG_ARXL1_APGA_CTL));
-                else
-                        twl4030->bypass_state &=
-                                ~(1 << (m->reg - TWL4030_REG_ARXL1_APGA_CTL));
-        } else if (m->reg == TWL4030_REG_VDL_APGA_CTL) {
-                /* Analog voice bypass */
-                if (reg & (1 << m->shift))
-                        twl4030->bypass_state |= (1 << 4);
-                else
-                        twl4030->bypass_state &= ~(1 << 4);
-        } else {
-                /* Digital bypass */
-                if (reg & (0x7 << m->shift))
-                        twl4030->bypass_state |= (1 << (m->shift ? 7 : 6));
-                else
-                        twl4030->bypass_state &= ~(1 << (m->shift ? 7 : 6));
-        }
-
-        /* Enable master analog loopback mode if any analog switch is enabled*/
-        misc = twl4030_read_reg_cache(w->codec, TWL4030_REG_MISC_SET_1);
-        if (twl4030->bypass_state & 0x1F)
-                misc |= TWL4030_FMLOOP_EN;
-        else
-                misc &= ~TWL4030_FMLOOP_EN;
-        twl4030_write(w->codec, TWL4030_REG_MISC_SET_1, misc);
-
-        if (w->codec->bias_level == SND_SOC_BIAS_STANDBY) {
-                if (twl4030->bypass_state)
-                        twl4030_codec_mute(w->codec, 0);
-                else
-                        twl4030_codec_mute(w->codec, 1);
-        }
-        return 0;
-}
-
 /*
  * Some of the gain controls in TWL (mostly those which are associated with
  * the outputs) are implemented in an interesting way:
@@ -1192,32 +1154,28 @@ static const struct snd_soc_dapm_widget twl4030_dapm_widgets[] = {
                         SND_SOC_NOPM, 0, 0),
 
         /* Analog bypasses */
-        SND_SOC_DAPM_SWITCH_E("Right1 Analog Loopback", SND_SOC_NOPM, 0, 0,
-                        &twl4030_dapm_abypassr1_control, bypass_event,
-                        SND_SOC_DAPM_POST_REG),
-        SND_SOC_DAPM_SWITCH_E("Left1 Analog Loopback", SND_SOC_NOPM, 0, 0,
-                        &twl4030_dapm_abypassl1_control,
-                        bypass_event, SND_SOC_DAPM_POST_REG),
-        SND_SOC_DAPM_SWITCH_E("Right2 Analog Loopback", SND_SOC_NOPM, 0, 0,
-                        &twl4030_dapm_abypassr2_control,
-                        bypass_event, SND_SOC_DAPM_POST_REG),
-        SND_SOC_DAPM_SWITCH_E("Left2 Analog Loopback", SND_SOC_NOPM, 0, 0,
-                        &twl4030_dapm_abypassl2_control,
-                        bypass_event, SND_SOC_DAPM_POST_REG),
-        SND_SOC_DAPM_SWITCH_E("Voice Analog Loopback", SND_SOC_NOPM, 0, 0,
-                        &twl4030_dapm_abypassv_control,
-                        bypass_event, SND_SOC_DAPM_POST_REG),
+        SND_SOC_DAPM_SWITCH("Right1 Analog Loopback", SND_SOC_NOPM, 0, 0,
+                        &twl4030_dapm_abypassr1_control),
+        SND_SOC_DAPM_SWITCH("Left1 Analog Loopback", SND_SOC_NOPM, 0, 0,
+                        &twl4030_dapm_abypassl1_control),
+        SND_SOC_DAPM_SWITCH("Right2 Analog Loopback", SND_SOC_NOPM, 0, 0,
+                        &twl4030_dapm_abypassr2_control),
+        SND_SOC_DAPM_SWITCH("Left2 Analog Loopback", SND_SOC_NOPM, 0, 0,
+                        &twl4030_dapm_abypassl2_control),
+        SND_SOC_DAPM_SWITCH("Voice Analog Loopback", SND_SOC_NOPM, 0, 0,
+                        &twl4030_dapm_abypassv_control),
+
+        /* Master analog loopback switch */
+        SND_SOC_DAPM_SUPPLY("FM Loop Enable", TWL4030_REG_MISC_SET_1, 5, 0,
+                            NULL, 0),
 
         /* Digital bypasses */
-        SND_SOC_DAPM_SWITCH_E("Left Digital Loopback", SND_SOC_NOPM, 0, 0,
-                        &twl4030_dapm_dbypassl_control, bypass_event,
-                        SND_SOC_DAPM_POST_REG),
-        SND_SOC_DAPM_SWITCH_E("Right Digital Loopback", SND_SOC_NOPM, 0, 0,
-                        &twl4030_dapm_dbypassr_control, bypass_event,
-                        SND_SOC_DAPM_POST_REG),
-        SND_SOC_DAPM_SWITCH_E("Voice Digital Loopback", SND_SOC_NOPM, 0, 0,
-                        &twl4030_dapm_dbypassv_control, bypass_event,
-                        SND_SOC_DAPM_POST_REG),
+        SND_SOC_DAPM_SWITCH("Left Digital Loopback", SND_SOC_NOPM, 0, 0,
+                        &twl4030_dapm_dbypassl_control),
+        SND_SOC_DAPM_SWITCH("Right Digital Loopback", SND_SOC_NOPM, 0, 0,
+                        &twl4030_dapm_dbypassr_control),
+        SND_SOC_DAPM_SWITCH("Voice Digital Loopback", SND_SOC_NOPM, 0, 0,
+                        &twl4030_dapm_dbypassv_control),
 
         /* Digital mixers, power control for the physical DACs */
         SND_SOC_DAPM_MIXER("Digital R1 Playback Mixer",
@@ -1243,6 +1201,11 @@ static const struct snd_soc_dapm_widget twl4030_dapm_widgets[] = {
         SND_SOC_DAPM_MIXER("Analog Voice Playback Mixer",
                         TWL4030_REG_VDL_APGA_CTL, 0, 0, NULL, 0),
 
+        SND_SOC_DAPM_SUPPLY("APLL Enable", SND_SOC_NOPM, 0, 0, apll_event,
+                            SND_SOC_DAPM_PRE_PMU|SND_SOC_DAPM_POST_PMD),
+
+        SND_SOC_DAPM_SUPPLY("AIF Enable", TWL4030_REG_AUDIO_IF, 0, 0, NULL, 0),
+
         /* Output MIXER controls */
         /* Earpiece */
         SND_SOC_DAPM_MIXER("Earpiece Mixer", SND_SOC_NOPM, 0, 0,
@@ -1308,8 +1271,9 @@ static const struct snd_soc_dapm_widget twl4030_dapm_widgets[] = {
                         0, 0, NULL, 0, handsfreerpga_event,
                         SND_SOC_DAPM_POST_PMU|SND_SOC_DAPM_POST_PMD),
         /* Vibra */
-        SND_SOC_DAPM_MUX("Vibra Mux", TWL4030_REG_VIBRA_CTL, 0, 0,
-                &twl4030_dapm_vibra_control),
+        SND_SOC_DAPM_MUX_E("Vibra Mux", TWL4030_REG_VIBRA_CTL, 0, 0,
+                           &twl4030_dapm_vibra_control, vibramux_event,
+                           SND_SOC_DAPM_PRE_PMU),
         SND_SOC_DAPM_MUX("Vibra Route", SND_SOC_NOPM, 0, 0,
                 &twl4030_dapm_vibrapath_control),
 
@@ -1369,6 +1333,18 @@ static const struct snd_soc_dapm_route intercon[] = {
         {"Digital R2 Playback Mixer", NULL, "DAC Right2"},
         {"Digital Voice Playback Mixer", NULL, "DAC Voice"},
 
+        /* Supply for the digital part (APLL) */
+        {"Digital R1 Playback Mixer", NULL, "APLL Enable"},
+        {"Digital L1 Playback Mixer", NULL, "APLL Enable"},
+        {"Digital R2 Playback Mixer", NULL, "APLL Enable"},
+        {"Digital L2 Playback Mixer", NULL, "APLL Enable"},
+        {"Digital Voice Playback Mixer", NULL, "APLL Enable"},
+
+        {"Digital R1 Playback Mixer", NULL, "AIF Enable"},
+        {"Digital L1 Playback Mixer", NULL, "AIF Enable"},
+        {"Digital R2 Playback Mixer", NULL, "AIF Enable"},
+        {"Digital L2 Playback Mixer", NULL, "AIF Enable"},
+
         {"Analog L1 Playback Mixer", NULL, "Digital L1 Playback Mixer"},
         {"Analog R1 Playback Mixer", NULL, "Digital R1 Playback Mixer"},
         {"Analog L2 Playback Mixer", NULL, "Digital L2 Playback Mixer"},
@@ -1482,6 +1458,16 @@ static const struct snd_soc_dapm_route intercon[] = {
         {"ADC Virtual Left2", NULL, "TX2 Capture Route"},
         {"ADC Virtual Right2", NULL, "TX2 Capture Route"},
 
+        {"ADC Virtual Left1", NULL, "APLL Enable"},
+        {"ADC Virtual Right1", NULL, "APLL Enable"},
+        {"ADC Virtual Left2", NULL, "APLL Enable"},
+        {"ADC Virtual Right2", NULL, "APLL Enable"},
+
+        {"ADC Virtual Left1", NULL, "AIF Enable"},
+        {"ADC Virtual Right1", NULL, "AIF Enable"},
+        {"ADC Virtual Left2", NULL, "AIF Enable"},
+        {"ADC Virtual Right2", NULL, "AIF Enable"},
+
         /* Analog bypass routes */
         {"Right1 Analog Loopback", "Switch", "Analog Right"},
         {"Left1 Analog Loopback", "Switch", "Analog Left"},
@@ -1489,6 +1475,13 @@ static const struct snd_soc_dapm_route intercon[] = {
         {"Left2 Analog Loopback", "Switch", "Analog Left"},
         {"Voice Analog Loopback", "Switch", "Analog Left"},
 
+        /* Supply for the Analog loopbacks */
+        {"Right1 Analog Loopback", NULL, "FM Loop Enable"},
+        {"Left1 Analog Loopback", NULL, "FM Loop Enable"},
+        {"Right2 Analog Loopback", NULL, "FM Loop Enable"},
+        {"Left2 Analog Loopback", NULL, "FM Loop Enable"},
+        {"Voice Analog Loopback", NULL, "FM Loop Enable"},
+
         {"Analog R1 Playback Mixer", NULL, "Right1 Analog Loopback"},
         {"Analog L1 Playback Mixer", NULL, "Left1 Analog Loopback"},
         {"Analog R2 Playback Mixer", NULL, "Right2 Analog Loopback"},
@@ -1513,32 +1506,20 @@ static int twl4030_add_widgets(struct snd_soc_codec *codec)
 
         snd_soc_dapm_add_routes(codec, intercon, ARRAY_SIZE(intercon));
 
-        snd_soc_dapm_new_widgets(codec);
         return 0;
 }
 
 static int twl4030_set_bias_level(struct snd_soc_codec *codec,
                                   enum snd_soc_bias_level level)
 {
-        struct twl4030_priv *twl4030 = codec->private_data;
-
         switch (level) {
         case SND_SOC_BIAS_ON:
-                twl4030_codec_mute(codec, 0);
                 break;
         case SND_SOC_BIAS_PREPARE:
-                twl4030_power_up(codec);
-                if (twl4030->bypass_state)
-                        twl4030_codec_mute(codec, 0);
-                else
-                        twl4030_codec_mute(codec, 1);
                 break;
         case SND_SOC_BIAS_STANDBY:
-                twl4030_power_up(codec);
-                if (twl4030->bypass_state)
-                        twl4030_codec_mute(codec, 0);
-                else
-                        twl4030_codec_mute(codec, 1);
+                if (codec->bias_level == SND_SOC_BIAS_OFF)
+                        twl4030_power_up(codec);
                 break;
         case SND_SOC_BIAS_OFF:
                 twl4030_power_down(codec);
@@ -1785,29 +1766,23 @@ static int twl4030_set_dai_sysclk(struct snd_soc_dai *codec_dai,
 {
         struct snd_soc_codec *codec = codec_dai->codec;
         struct twl4030_priv *twl4030 = codec->private_data;
-        u8 infreq;
 
         switch (freq) {
         case 19200000:
-                infreq = TWL4030_APLL_INFREQ_19200KHZ;
-                twl4030->sysclk = 19200;
-                break;
         case 26000000:
-                infreq = TWL4030_APLL_INFREQ_26000KHZ;
-                twl4030->sysclk = 26000;
-                break;
         case 38400000:
-                infreq = TWL4030_APLL_INFREQ_38400KHZ;
-                twl4030->sysclk = 38400;
                 break;
         default:
-                printk(KERN_ERR "TWL4030 set sysclk: unknown rate %d\n",
-                        freq);
+                dev_err(codec->dev, "Unsupported APLL mclk: %u\n", freq);
                 return -EINVAL;
         }
 
-        infreq |= TWL4030_APLL_EN;
-        twl4030_write(codec, TWL4030_REG_APLL_CTL, infreq);
+        if ((freq / 1000) != twl4030->sysclk) {
+                dev_err(codec->dev,
+                        "Mismatch in APLL mclk: %u (configured: %u)\n",
+                        freq, twl4030->sysclk * 1000);
+                return -EINVAL;
+        }
 
         return 0;
 }
@@ -1905,18 +1880,16 @@ static int twl4030_voice_startup(struct snd_pcm_substream *substream,
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
         struct snd_soc_device *socdev = rtd->socdev;
         struct snd_soc_codec *codec = socdev->card->codec;
-        u8 infreq;
+        struct twl4030_priv *twl4030 = codec->private_data;
         u8 mode;
 
         /* If the system master clock is not 26MHz, the voice PCM interface is
          * not avilable.
          */
-        infreq = twl4030_read_reg_cache(codec, TWL4030_REG_APLL_CTL)
-                & TWL4030_APLL_INFREQ;
-
-        if (infreq != TWL4030_APLL_INFREQ_26000KHZ) {
-                printk(KERN_ERR "TWL4030 voice startup: "
-                        "MCLK is not 26MHz, call set_sysclk() on init\n");
+        if (twl4030->sysclk != 26000) {
+                dev_err(codec->dev, "The board is configured for %u Hz, while"
+                        "the Voice interface needs 26MHz APLL mclk\n",
+                        twl4030->sysclk * 1000);
                 return -EINVAL;
         }
 
@@ -1989,21 +1962,19 @@ static int twl4030_voice_set_dai_sysclk(struct snd_soc_dai *codec_dai,
                 int clk_id, unsigned int freq, int dir)
 {
         struct snd_soc_codec *codec = codec_dai->codec;
-        u8 infreq;
+        struct twl4030_priv *twl4030 = codec->private_data;
 
-        switch (freq) {
-        case 26000000:
-                infreq = TWL4030_APLL_INFREQ_26000KHZ;
-                break;
-        default:
-                printk(KERN_ERR "TWL4030 voice set sysclk: unknown rate %d\n",
-                        freq);
+        if (freq != 26000000) {
+                dev_err(codec->dev, "Unsupported APLL mclk: %u, the Voice"
+                        "interface needs 26MHz APLL mclk\n", freq);
+                return -EINVAL;
+        }
+        if ((freq / 1000) != twl4030->sysclk) {
+                dev_err(codec->dev,
+                        "Mismatch in APLL mclk: %u (configured: %u)\n",
+                        freq, twl4030->sysclk * 1000);
                 return -EINVAL;
         }
-
-        infreq |= TWL4030_APLL_EN;
-        twl4030_write(codec, TWL4030_REG_APLL_CTL, infreq);
-
         return 0;
 }
 
@@ -2121,7 +2092,7 @@ struct snd_soc_dai twl4030_dai[] = {
 };
 EXPORT_SYMBOL_GPL(twl4030_dai);
 
-static int twl4030_suspend(struct platform_device *pdev, pm_message_t state)
+static int twl4030_soc_suspend(struct platform_device *pdev, pm_message_t state)
 {
         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
         struct snd_soc_codec *codec = socdev->card->codec;
@@ -2131,7 +2102,7 @@ static int twl4030_suspend(struct platform_device *pdev, pm_message_t state)
         return 0;
 }
 
-static int twl4030_resume(struct platform_device *pdev)
+static int twl4030_soc_resume(struct platform_device *pdev)
 {
         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
         struct snd_soc_codec *codec = socdev->card->codec;
@@ -2141,147 +2112,182 @@ static int twl4030_resume(struct platform_device *pdev)
         return 0;
 }
 
-/*
- * initialize the driver
- * register the mixer and dsp interfaces with the kernel
- */
+static struct snd_soc_codec *twl4030_codec;
 
-static int twl4030_init(struct snd_soc_device *socdev)
+static int twl4030_soc_probe(struct platform_device *pdev)
 {
-        struct snd_soc_codec *codec = socdev->card->codec;
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
         struct twl4030_setup_data *setup = socdev->codec_data;
-        struct twl4030_priv *twl4030 = codec->private_data;
-        int ret = 0;
+        struct snd_soc_codec *codec;
+        struct twl4030_priv *twl4030;
+        int ret;
 
-        printk(KERN_INFO "TWL4030 Audio Codec init \n");
+        BUG_ON(!twl4030_codec);
 
-        codec->name = "twl4030";
-        codec->owner = THIS_MODULE;
-        codec->read = twl4030_read_reg_cache;
-        codec->write = twl4030_write;
-        codec->set_bias_level = twl4030_set_bias_level;
-        codec->dai = twl4030_dai;
-        codec->num_dai = ARRAY_SIZE(twl4030_dai),
-        codec->reg_cache_size = sizeof(twl4030_reg);
-        codec->reg_cache = kmemdup(twl4030_reg, sizeof(twl4030_reg),
-                                        GFP_KERNEL);
-        if (codec->reg_cache == NULL)
-                return -ENOMEM;
+        codec = twl4030_codec;
+        twl4030 = codec->private_data;
+        socdev->card->codec = codec;
 
         /* Configuration for headset ramp delay from setup data */
         if (setup) {
                 unsigned char hs_pop;
 
-                if (setup->sysclk)
-                        twl4030->sysclk = setup->sysclk;
-                else
-                        twl4030->sysclk = 26000;
+                if (setup->sysclk != twl4030->sysclk)
+                        dev_warn(&pdev->dev,
+                                 "Mismatch in APLL mclk: %u (configured: %u)\n",
+                                 setup->sysclk, twl4030->sysclk);
 
                 hs_pop = twl4030_read_reg_cache(codec, TWL4030_REG_HS_POPN_SET);
                 hs_pop &= ~TWL4030_RAMP_DELAY;
                 hs_pop |= (setup->ramp_delay_value << 2);
                 twl4030_write_reg_cache(codec, TWL4030_REG_HS_POPN_SET, hs_pop);
-        } else {
-                twl4030->sysclk = 26000;
         }
 
         /* register pcms */
         ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
         if (ret < 0) {
-                printk(KERN_ERR "twl4030: failed to create pcms\n");
-                goto pcm_err;
+                dev_err(&pdev->dev, "failed to create pcms\n");
+                return ret;
         }
 
-        twl4030_init_chip(codec);
-
-        /* power on device */
-        twl4030_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
-
         snd_soc_add_controls(codec, twl4030_snd_controls,
                                 ARRAY_SIZE(twl4030_snd_controls));
         twl4030_add_widgets(codec);
 
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                printk(KERN_ERR "twl4030: failed to register card\n");
-                goto card_err;
-        }
+        return 0;
+}
 
-        return ret;
+static int twl4030_soc_remove(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec = socdev->card->codec;
 
-card_err:
+        twl4030_set_bias_level(codec, SND_SOC_BIAS_OFF);
         snd_soc_free_pcms(socdev);
         snd_soc_dapm_free(socdev);
-pcm_err:
-        kfree(codec->reg_cache);
-        return ret;
-}
 
-static struct snd_soc_device *twl4030_socdev;
+        return 0;
+}
 
-static int twl4030_probe(struct platform_device *pdev)
+static int __devinit twl4030_codec_probe(struct platform_device *pdev)
 {
-        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct twl4030_codec_audio_data *pdata = pdev->dev.platform_data;
         struct snd_soc_codec *codec;
         struct twl4030_priv *twl4030;
+        int ret;
 
-        codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
-        if (codec == NULL)
-                return -ENOMEM;
+        if (!pdata) {
+                dev_err(&pdev->dev, "platform_data is missing\n");
+                return -EINVAL;
+        }
 
         twl4030 = kzalloc(sizeof(struct twl4030_priv), GFP_KERNEL);
         if (twl4030 == NULL) {
-                kfree(codec);
+                dev_err(&pdev->dev, "Can not allocate memroy\n");
                 return -ENOMEM;
         }
 
+        codec = &twl4030->codec;
         codec->private_data = twl4030;
-        socdev->card->codec = codec;
+        codec->dev = &pdev->dev;
+        twl4030_dai[0].dev = &pdev->dev;
+        twl4030_dai[1].dev = &pdev->dev;
+
         mutex_init(&codec->mutex);
         INIT_LIST_HEAD(&codec->dapm_widgets);
         INIT_LIST_HEAD(&codec->dapm_paths);
 
-        twl4030_socdev = socdev;
-        twl4030_init(socdev);
+        codec->name = "twl4030";
+        codec->owner = THIS_MODULE;
+        codec->read = twl4030_read_reg_cache;
+        codec->write = twl4030_write;
+        codec->set_bias_level = twl4030_set_bias_level;
+        codec->dai = twl4030_dai;
+        codec->num_dai = ARRAY_SIZE(twl4030_dai);
+        codec->reg_cache_size = sizeof(twl4030_reg);
+        codec->reg_cache = kmemdup(twl4030_reg, sizeof(twl4030_reg),
+                                        GFP_KERNEL);
+        if (codec->reg_cache == NULL) {
+                ret = -ENOMEM;
+                goto error_cache;
+        }
+
+        platform_set_drvdata(pdev, twl4030);
+        twl4030_codec = codec;
+
+        /* Set the defaults, and power up the codec */
+        twl4030->sysclk = twl4030_codec_get_mclk() / 1000;
+        twl4030_init_chip(codec);
+        codec->bias_level = SND_SOC_BIAS_OFF;
+        twl4030_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+
+        ret = snd_soc_register_codec(codec);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to register codec: %d\n", ret);
+                goto error_codec;
+        }
+
+        ret = snd_soc_register_dais(&twl4030_dai[0], ARRAY_SIZE(twl4030_dai));
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to register DAIs: %d\n", ret);
+                snd_soc_unregister_codec(codec);
+                goto error_codec;
+        }
 
         return 0;
+
+error_codec:
+        twl4030_power_down(codec);
+        kfree(codec->reg_cache);
+error_cache:
+        kfree(twl4030);
+        return ret;
 }
 
-static int twl4030_remove(struct platform_device *pdev)
+static int __devexit twl4030_codec_remove(struct platform_device *pdev)
 {
-        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
-        struct snd_soc_codec *codec = socdev->card->codec;
+        struct twl4030_priv *twl4030 = platform_get_drvdata(pdev);
 
-        printk(KERN_INFO "TWL4030 Audio Codec remove\n");
-        twl4030_set_bias_level(codec, SND_SOC_BIAS_OFF);
-        snd_soc_free_pcms(socdev);
-        snd_soc_dapm_free(socdev);
-        kfree(codec->private_data);
-        kfree(codec);
+        snd_soc_unregister_dais(&twl4030_dai[0], ARRAY_SIZE(twl4030_dai));
+        snd_soc_unregister_codec(&twl4030->codec);
+        kfree(twl4030->codec.reg_cache);
+        kfree(twl4030);
 
+        twl4030_codec = NULL;
         return 0;
 }
 
-struct snd_soc_codec_device soc_codec_dev_twl4030 = {
-        .probe = twl4030_probe,
-        .remove = twl4030_remove,
-        .suspend = twl4030_suspend,
-        .resume = twl4030_resume,
+MODULE_ALIAS("platform:twl4030_codec_audio");
+
+static struct platform_driver twl4030_codec_driver = {
+        .probe          = twl4030_codec_probe,
+        .remove         = __devexit_p(twl4030_codec_remove),
+        .driver         = {
+                .name   = "twl4030_codec_audio",
+                .owner  = THIS_MODULE,
+        },
 };
-EXPORT_SYMBOL_GPL(soc_codec_dev_twl4030);
 
 static int __init twl4030_modinit(void)
 {
-        return snd_soc_register_dais(&twl4030_dai[0], ARRAY_SIZE(twl4030_dai));
+        return platform_driver_register(&twl4030_codec_driver);
 }
 module_init(twl4030_modinit);
 
 static void __exit twl4030_exit(void)
 {
-        snd_soc_unregister_dais(&twl4030_dai[0], ARRAY_SIZE(twl4030_dai));
+        platform_driver_unregister(&twl4030_codec_driver);
 }
 module_exit(twl4030_exit);
 
+struct snd_soc_codec_device soc_codec_dev_twl4030 = {
+        .probe = twl4030_soc_probe,
+        .remove = twl4030_soc_remove,
+        .suspend = twl4030_soc_suspend,
+        .resume = twl4030_soc_resume,
+};
+EXPORT_SYMBOL_GPL(soc_codec_dev_twl4030);
+
 MODULE_DESCRIPTION("ASoC TWL4030 codec driver");
 MODULE_AUTHOR("Steve Sakoman");
 MODULE_LICENSE("GPL");
diff --git a/sound/soc/codecs/twl4030.h b/sound/soc/codecs/twl4030.h
index 2b4bfa23f985..f206d242ca31 100644
--- a/sound/soc/codecs/twl4030.h
+++ b/sound/soc/codecs/twl4030.h
@@ -22,245 +22,13 @@
 #ifndef __TWL4030_AUDIO_H__
 #define __TWL4030_AUDIO_H__
 
-#define TWL4030_REG_CODEC_MODE          0x1
-#define TWL4030_REG_OPTION              0x2
-#define TWL4030_REG_UNKNOWN             0x3
-#define TWL4030_REG_MICBIAS_CTL         0x4
-#define TWL4030_REG_ANAMICL             0x5
-#define TWL4030_REG_ANAMICR             0x6
-#define TWL4030_REG_AVADC_CTL           0x7
-#define TWL4030_REG_ADCMICSEL           0x8
-#define TWL4030_REG_DIGMIXING           0x9
-#define TWL4030_REG_ATXL1PGA            0xA
-#define TWL4030_REG_ATXR1PGA            0xB
-#define TWL4030_REG_AVTXL2PGA           0xC
-#define TWL4030_REG_AVTXR2PGA           0xD
-#define TWL4030_REG_AUDIO_IF            0xE
-#define TWL4030_REG_VOICE_IF            0xF
-#define TWL4030_REG_ARXR1PGA            0x10
-#define TWL4030_REG_ARXL1PGA            0x11
-#define TWL4030_REG_ARXR2PGA            0x12
-#define TWL4030_REG_ARXL2PGA            0x13
-#define TWL4030_REG_VRXPGA              0x14
-#define TWL4030_REG_VSTPGA              0x15
-#define TWL4030_REG_VRX2ARXPGA          0x16
-#define TWL4030_REG_AVDAC_CTL           0x17
-#define TWL4030_REG_ARX2VTXPGA          0x18
-#define TWL4030_REG_ARXL1_APGA_CTL      0x19
-#define TWL4030_REG_ARXR1_APGA_CTL      0x1A
-#define TWL4030_REG_ARXL2_APGA_CTL      0x1B
-#define TWL4030_REG_ARXR2_APGA_CTL      0x1C
-#define TWL4030_REG_ATX2ARXPGA          0x1D
-#define TWL4030_REG_BT_IF               0x1E
-#define TWL4030_REG_BTPGA               0x1F
-#define TWL4030_REG_BTSTPGA             0x20
-#define TWL4030_REG_EAR_CTL             0x21
-#define TWL4030_REG_HS_SEL              0x22
-#define TWL4030_REG_HS_GAIN_SET         0x23
-#define TWL4030_REG_HS_POPN_SET         0x24
-#define TWL4030_REG_PREDL_CTL           0x25
-#define TWL4030_REG_PREDR_CTL           0x26
-#define TWL4030_REG_PRECKL_CTL          0x27
-#define TWL4030_REG_PRECKR_CTL          0x28
-#define TWL4030_REG_HFL_CTL             0x29
-#define TWL4030_REG_HFR_CTL             0x2A
-#define TWL4030_REG_ALC_CTL             0x2B
-#define TWL4030_REG_ALC_SET1            0x2C
-#define TWL4030_REG_ALC_SET2            0x2D
-#define TWL4030_REG_BOOST_CTL           0x2E
-#define TWL4030_REG_SOFTVOL_CTL         0x2F
-#define TWL4030_REG_DTMF_FREQSEL        0x30
-#define TWL4030_REG_DTMF_TONEXT1H       0x31
-#define TWL4030_REG_DTMF_TONEXT1L       0x32
-#define TWL4030_REG_DTMF_TONEXT2H       0x33
-#define TWL4030_REG_DTMF_TONEXT2L       0x34
-#define TWL4030_REG_DTMF_TONOFF         0x35
-#define TWL4030_REG_DTMF_WANONOFF       0x36
-#define TWL4030_REG_I2S_RX_SCRAMBLE_H   0x37
-#define TWL4030_REG_I2S_RX_SCRAMBLE_M   0x38
-#define TWL4030_REG_I2S_RX_SCRAMBLE_L   0x39
-#define TWL4030_REG_APLL_CTL            0x3A
-#define TWL4030_REG_DTMF_CTL            0x3B
-#define TWL4030_REG_DTMF_PGA_CTL2       0x3C
-#define TWL4030_REG_DTMF_PGA_CTL1       0x3D
-#define TWL4030_REG_MISC_SET_1          0x3E
-#define TWL4030_REG_PCMBTMUX            0x3F
-#define TWL4030_REG_RX_PATH_SEL         0x43
-#define TWL4030_REG_VDL_APGA_CTL        0x44
-#define TWL4030_REG_VIBRA_CTL           0x45
-#define TWL4030_REG_VIBRA_SET           0x46
-#define TWL4030_REG_VIBRA_PWM_SET       0x47
-#define TWL4030_REG_ANAMIC_GAIN         0x48
-#define TWL4030_REG_MISC_SET_2          0x49
-#define TWL4030_REG_SW_SHADOW           0x4A
+/* Register descriptions are here */
+#include <linux/mfd/twl4030-codec.h>
 
+/* Shadow register used by the audio driver */
+#define TWL4030_REG_SW_SHADOW           0x4A
 #define TWL4030_CACHEREGNUM     (TWL4030_REG_SW_SHADOW + 1)
 
-/* Bitfield Definitions */
-
-/* TWL4030_CODEC_MODE (0x01) Fields */
-
-#define TWL4030_APLL_RATE               0xF0
-#define TWL4030_APLL_RATE_8000          0x00
-#define TWL4030_APLL_RATE_11025         0x10
-#define TWL4030_APLL_RATE_12000         0x20
-#define TWL4030_APLL_RATE_16000         0x40
-#define TWL4030_APLL_RATE_22050         0x50
-#define TWL4030_APLL_RATE_24000         0x60
-#define TWL4030_APLL_RATE_32000         0x80
-#define TWL4030_APLL_RATE_44100         0x90
-#define TWL4030_APLL_RATE_48000         0xA0
-#define TWL4030_APLL_RATE_96000         0xE0
-#define TWL4030_SEL_16K                 0x08
-#define TWL4030_CODECPDZ                0x02
-#define TWL4030_OPT_MODE                0x01
-#define TWL4030_OPTION_1                (1 << 0)
-#define TWL4030_OPTION_2                (0 << 0)
-
-/* TWL4030_OPTION (0x02) Fields */
-
-#define TWL4030_ATXL1_EN                (1 << 0)
-#define TWL4030_ATXR1_EN                (1 << 1)
-#define TWL4030_ATXL2_VTXL_EN           (1 << 2)
-#define TWL4030_ATXR2_VTXR_EN           (1 << 3)
-#define TWL4030_ARXL1_VRX_EN            (1 << 4)
-#define TWL4030_ARXR1_EN                (1 << 5)
-#define TWL4030_ARXL2_EN                (1 << 6)
-#define TWL4030_ARXR2_EN                (1 << 7)
-
-/* TWL4030_REG_MICBIAS_CTL (0x04) Fields */
-
-#define TWL4030_MICBIAS2_CTL            0x40
-#define TWL4030_MICBIAS1_CTL            0x20
-#define TWL4030_HSMICBIAS_EN            0x04
-#define TWL4030_MICBIAS2_EN             0x02
-#define TWL4030_MICBIAS1_EN             0x01
-
-/* ANAMICL (0x05) Fields */
-
-#define TWL4030_CNCL_OFFSET_START       0x80
-#define TWL4030_OFFSET_CNCL_SEL         0x60
-#define TWL4030_OFFSET_CNCL_SEL_ARX1    0x00
-#define TWL4030_OFFSET_CNCL_SEL_ARX2    0x20
-#define TWL4030_OFFSET_CNCL_SEL_VRX     0x40
-#define TWL4030_OFFSET_CNCL_SEL_ALL     0x60
-#define TWL4030_MICAMPL_EN              0x10
-#define TWL4030_CKMIC_EN                0x08
-#define TWL4030_AUXL_EN                 0x04
-#define TWL4030_HSMIC_EN                0x02
-#define TWL4030_MAINMIC_EN              0x01
-
-/* ANAMICR (0x06) Fields */
-
-#define TWL4030_MICAMPR_EN              0x10
-#define TWL4030_AUXR_EN                 0x04
-#define TWL4030_SUBMIC_EN               0x01
-
-/* AVADC_CTL (0x07) Fields */
-
-#define TWL4030_ADCL_EN                 0x08
-#define TWL4030_AVADC_CLK_PRIORITY      0x04
-#define TWL4030_ADCR_EN                 0x02
-
-/* TWL4030_REG_ADCMICSEL (0x08) Fields */
-
-#define TWL4030_DIGMIC1_EN              0x08
-#define TWL4030_TX2IN_SEL               0x04
-#define TWL4030_DIGMIC0_EN              0x02
-#define TWL4030_TX1IN_SEL               0x01
-
-/* AUDIO_IF (0x0E) Fields */
-
-#define TWL4030_AIF_SLAVE_EN            0x80
-#define TWL4030_DATA_WIDTH              0x60
-#define TWL4030_DATA_WIDTH_16S_16W      0x00
-#define TWL4030_DATA_WIDTH_32S_16W      0x40
-#define TWL4030_DATA_WIDTH_32S_24W      0x60
-#define TWL4030_AIF_FORMAT              0x18
-#define TWL4030_AIF_FORMAT_CODEC        0x00
-#define TWL4030_AIF_FORMAT_LEFT         0x08
-#define TWL4030_AIF_FORMAT_RIGHT        0x10
-#define TWL4030_AIF_FORMAT_TDM          0x18
-#define TWL4030_AIF_TRI_EN              0x04
-#define TWL4030_CLK256FS_EN             0x02
-#define TWL4030_AIF_EN                  0x01
-
-/* VOICE_IF (0x0F) Fields */
-
-#define TWL4030_VIF_SLAVE_EN            0x80
-#define TWL4030_VIF_DIN_EN              0x40
-#define TWL4030_VIF_DOUT_EN             0x20
-#define TWL4030_VIF_SWAP                0x10
-#define TWL4030_VIF_FORMAT              0x08
-#define TWL4030_VIF_TRI_EN              0x04
-#define TWL4030_VIF_SUB_EN              0x02
-#define TWL4030_VIF_EN                  0x01
-
-/* EAR_CTL (0x21) */
-#define TWL4030_EAR_GAIN                0x30
-
-/* HS_GAIN_SET (0x23) Fields */
-
-#define TWL4030_HSR_GAIN                0x0C
-#define TWL4030_HSR_GAIN_PWR_DOWN       0x00
-#define TWL4030_HSR_GAIN_PLUS_6DB       0x04
-#define TWL4030_HSR_GAIN_0DB            0x08
-#define TWL4030_HSR_GAIN_MINUS_6DB      0x0C
-#define TWL4030_HSL_GAIN                0x03
-#define TWL4030_HSL_GAIN_PWR_DOWN       0x00
-#define TWL4030_HSL_GAIN_PLUS_6DB       0x01
-#define TWL4030_HSL_GAIN_0DB            0x02
-#define TWL4030_HSL_GAIN_MINUS_6DB      0x03
-
-/* HS_POPN_SET (0x24) Fields */
-
-#define TWL4030_VMID_EN                 0x40
-#define TWL4030_EXTMUTE                 0x20
-#define TWL4030_RAMP_DELAY              0x1C
-#define TWL4030_RAMP_DELAY_20MS         0x00
-#define TWL4030_RAMP_DELAY_40MS         0x04
-#define TWL4030_RAMP_DELAY_81MS         0x08
-#define TWL4030_RAMP_DELAY_161MS        0x0C
-#define TWL4030_RAMP_DELAY_323MS        0x10
-#define TWL4030_RAMP_DELAY_645MS        0x14
-#define TWL4030_RAMP_DELAY_1291MS       0x18
-#define TWL4030_RAMP_DELAY_2581MS       0x1C
-#define TWL4030_RAMP_EN                 0x02
-
-/* PREDL_CTL (0x25) */
-#define TWL4030_PREDL_GAIN              0x30
-
-/* PREDR_CTL (0x26) */
-#define TWL4030_PREDR_GAIN              0x30
-
-/* PRECKL_CTL (0x27) */
-#define TWL4030_PRECKL_GAIN             0x30
-
-/* PRECKR_CTL (0x28) */
-#define TWL4030_PRECKR_GAIN             0x30
-
-/* HFL_CTL (0x29, 0x2A) Fields */
-#define TWL4030_HF_CTL_HB_EN            0x04
-#define TWL4030_HF_CTL_LOOP_EN          0x08
-#define TWL4030_HF_CTL_RAMP_EN          0x10
-#define TWL4030_HF_CTL_REF_EN           0x20
-
-/* APLL_CTL (0x3A) Fields */
-
-#define TWL4030_APLL_EN                 0x10
-#define TWL4030_APLL_INFREQ             0x0F
-#define TWL4030_APLL_INFREQ_19200KHZ    0x05
-#define TWL4030_APLL_INFREQ_26000KHZ    0x06
-#define TWL4030_APLL_INFREQ_38400KHZ    0x0F
-
-/* REG_MISC_SET_1 (0x3E) Fields */
-
-#define TWL4030_CLK64_EN                0x80
-#define TWL4030_SCRAMBLE_EN             0x40
-#define TWL4030_FMLOOP_EN               0x20
-#define TWL4030_SMOOTH_ANAVOL_EN        0x02
-#define TWL4030_DIGMIC_LR_SWAP_EN       0x01
-
 /* TWL4030_REG_SW_SHADOW (0x4A) Fields */
 #define TWL4030_HFL_EN                  0x01
 #define TWL4030_HFR_EN                  0x02
@@ -279,3 +47,5 @@ struct twl4030_setup_data {
 };
 
 #endif  /* End of __TWL4030_AUDIO_H__ */
+
+
diff --git a/sound/soc/codecs/uda134x.c b/sound/soc/codecs/uda134x.c
index c33b92edbded..a8dcd5a5bbcb 100644
--- a/sound/soc/codecs/uda134x.c
+++ b/sound/soc/codecs/uda134x.c
@@ -15,6 +15,7 @@
 
 #include <linux/module.h>
 #include <linux/delay.h>
+#include <linux/slab.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
 #include <sound/soc.h>
@@ -101,7 +102,7 @@ static int uda134x_write(struct snd_soc_codec *codec, unsigned int reg,
         pr_debug("%s reg: %02X, value:%02X\n", __func__, reg, value);
 
         if (reg >= UDA134X_REGS_NUM) {
-                printk(KERN_ERR "%s unkown register: reg: %u",
+                printk(KERN_ERR "%s unknown register: reg: %u",
                        __func__, reg);
                 return -EINVAL;
         }
@@ -552,7 +553,7 @@ static int uda134x_soc_probe(struct platform_device *pdev)
                                         ARRAY_SIZE(uda1341_snd_controls));
         break;
         default:
-                printk(KERN_ERR "%s unkown codec type: %d",
+                printk(KERN_ERR "%s unknown codec type: %d",
                         __func__, pd->model);
         return -EINVAL;
         }
@@ -562,17 +563,8 @@ static int uda134x_soc_probe(struct platform_device *pdev)
                 goto pcm_err;
         }
 
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                printk(KERN_ERR "UDA134X: failed to register card\n");
-                goto card_err;
-        }
-
         return 0;
 
-card_err:
-        snd_soc_free_pcms(socdev);
-        snd_soc_dapm_free(socdev);
 pcm_err:
         kfree(codec->reg_cache);
 reg_err:
diff --git a/sound/soc/codecs/uda1380.c b/sound/soc/codecs/uda1380.c
index 92ec03442154..9cd0a66b7663 100644
--- a/sound/soc/codecs/uda1380.c
+++ b/sound/soc/codecs/uda1380.c
@@ -137,7 +137,7 @@ static void uda1380_flush_work(struct work_struct *work)
 {
         int bit, reg;
 
-        for_each_bit(bit, &uda1380_cache_dirty, UDA1380_CACHEREGNUM - 0x10) {
+        for_each_set_bit(bit, &uda1380_cache_dirty, UDA1380_CACHEREGNUM - 0x10) {
                 reg = 0x10 + bit;
                 pr_debug("uda1380: flush reg %x val %x:\n", reg,
                                 uda1380_read_reg_cache(uda1380_codec, reg));
@@ -378,7 +378,6 @@ static int uda1380_add_widgets(struct snd_soc_codec *codec)
 
         snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
 
-        snd_soc_dapm_new_widgets(codec);
         return 0;
 }
 
@@ -713,17 +712,9 @@ static int uda1380_probe(struct platform_device *pdev)
         snd_soc_add_controls(codec, uda1380_snd_controls,
                                 ARRAY_SIZE(uda1380_snd_controls));
         uda1380_add_widgets(codec);
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                dev_err(codec->dev, "failed to register card: %d\n", ret);
-                goto card_err;
-        }
 
         return ret;
 
-card_err:
-        snd_soc_free_pcms(socdev);
-        snd_soc_dapm_free(socdev);
 pcm_err:
         return ret;
 }
diff --git a/sound/soc/codecs/wm2000.c b/sound/soc/codecs/wm2000.c
new file mode 100644
index 000000000000..002e289d1255
--- /dev/null
+++ b/sound/soc/codecs/wm2000.c
@@ -0,0 +1,888 @@
+/*
+ * wm2000.c  --  WM2000 ALSA Soc Audio driver
+ *
+ * Copyright 2008-2010 Wolfson Microelectronics PLC.
+ *
+ * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * The download image for the WM2000 will be requested as
+ * 'wm2000_anc.bin' by default (overridable via platform data) at
+ * runtime and is expected to be in flat binary format.  This is
+ * generated by Wolfson configuration tools and includes
+ * system-specific callibration information.  If supplied as a
+ * sequence of ASCII-encoded hexidecimal bytes this can be converted
+ * into a flat binary with a command such as this on the command line:
+ *
+ * perl -e 'while (<>) { s/[\r\n]+// ; printf("%c", hex($_)); }'
+ *                 < file  > wm2000_anc.bin
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/firmware.h>
+#include <linux/delay.h>
+#include <linux/pm.h>
+#include <linux/i2c.h>
+#include <linux/platform_device.h>
+#include <linux/debugfs.h>
+#include <linux/slab.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+#include <sound/initval.h>
+#include <sound/tlv.h>
+
+#include <sound/wm2000.h>
+
+#include "wm2000.h"
+
+enum wm2000_anc_mode {
+        ANC_ACTIVE = 0,
+        ANC_BYPASS = 1,
+        ANC_STANDBY = 2,
+        ANC_OFF = 3,
+};
+
+struct wm2000_priv {
+        struct i2c_client *i2c;
+
+        enum wm2000_anc_mode anc_mode;
+
+        unsigned int anc_active:1;
+        unsigned int anc_eng_ena:1;
+        unsigned int spk_ena:1;
+
+        unsigned int mclk_div:1;
+        unsigned int speech_clarity:1;
+
+        int anc_download_size;
+        char *anc_download;
+};
+
+static struct i2c_client *wm2000_i2c;
+
+static int wm2000_write(struct i2c_client *i2c, unsigned int reg,
+                        unsigned int value)
+{
+        u8 data[3];
+        int ret;
+
+        data[0] = (reg >> 8) & 0xff;
+        data[1] = reg & 0xff;
+        data[2] = value & 0xff;
+
+        dev_vdbg(&i2c->dev, "write %x = %x\n", reg, value);
+
+        ret = i2c_master_send(i2c, data, 3);
+        if (ret == 3)
+                return 0;
+        if (ret < 0)
+                return ret;
+        else
+                return -EIO;
+}
+
+static unsigned int wm2000_read(struct i2c_client *i2c, unsigned int r)
+{
+        struct i2c_msg xfer[2];
+        u8 reg[2];
+        u8 data;
+        int ret;
+
+        /* Write register */
+        reg[0] = (r >> 8) & 0xff;
+        reg[1] = r & 0xff;
+        xfer[0].addr = i2c->addr;
+        xfer[0].flags = 0;
+        xfer[0].len = sizeof(reg);
+        xfer[0].buf = &reg[0];
+
+        /* Read data */
+        xfer[1].addr = i2c->addr;
+        xfer[1].flags = I2C_M_RD;
+        xfer[1].len = 1;
+        xfer[1].buf = &data;
+
+        ret = i2c_transfer(i2c->adapter, xfer, 2);
+        if (ret != 2) {
+                dev_err(&i2c->dev, "i2c_transfer() returned %d\n", ret);
+                return 0;
+        }
+
+        dev_vdbg(&i2c->dev, "read %x from %x\n", data, r);
+
+        return data;
+}
+
+static void wm2000_reset(struct wm2000_priv *wm2000)
+{
+        struct i2c_client *i2c = wm2000->i2c;
+
+        wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_ANC_ENG_CLR);
+        wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_RAM_CLR);
+        wm2000_write(i2c, WM2000_REG_ID1, 0);
+
+        wm2000->anc_mode = ANC_OFF;
+}
+
+static int wm2000_poll_bit(struct i2c_client *i2c,
+                           unsigned int reg, u8 mask, int timeout)
+{
+        int val;
+
+        val = wm2000_read(i2c, reg);
+
+        while (!(val & mask) && --timeout) {
+                msleep(1);
+                val = wm2000_read(i2c, reg);
+        }
+
+        if (timeout == 0)
+                return 0;
+        else
+                return 1;
+}
+
+static int wm2000_power_up(struct i2c_client *i2c, int analogue)
+{
+        struct wm2000_priv *wm2000 = dev_get_drvdata(&i2c->dev);
+        int ret, timeout;
+
+        BUG_ON(wm2000->anc_mode != ANC_OFF);
+
+        dev_dbg(&i2c->dev, "Beginning power up\n");
+
+        if (!wm2000->mclk_div) {
+                dev_dbg(&i2c->dev, "Disabling MCLK divider\n");
+                wm2000_write(i2c, WM2000_REG_SYS_CTL2,
+                             WM2000_MCLK_DIV2_ENA_CLR);
+        } else {
+                dev_dbg(&i2c->dev, "Enabling MCLK divider\n");
+                wm2000_write(i2c, WM2000_REG_SYS_CTL2,
+                             WM2000_MCLK_DIV2_ENA_SET);
+        }
+
+        wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_ANC_ENG_CLR);
+        wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_ANC_ENG_SET);
+
+        /* Wait for ANC engine to become ready */
+        if (!wm2000_poll_bit(i2c, WM2000_REG_ANC_STAT,
+                             WM2000_ANC_ENG_IDLE, 1)) {
+                dev_err(&i2c->dev, "ANC engine failed to reset\n");
+                return -ETIMEDOUT;
+        }
+
+        if (!wm2000_poll_bit(i2c, WM2000_REG_SYS_STATUS,
+                             WM2000_STATUS_BOOT_COMPLETE, 1)) {
+                dev_err(&i2c->dev, "ANC engine failed to initialise\n");
+                return -ETIMEDOUT;
+        }
+
+        wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_RAM_SET);
+
+        /* Open code download of the data since it is the only bulk
+         * write we do. */
+        dev_dbg(&i2c->dev, "Downloading %d bytes\n",
+                wm2000->anc_download_size - 2);
+
+        ret = i2c_master_send(i2c, wm2000->anc_download,
+                              wm2000->anc_download_size);
+        if (ret < 0) {
+                dev_err(&i2c->dev, "i2c_transfer() failed: %d\n", ret);
+                return ret;
+        }
+        if (ret != wm2000->anc_download_size) {
+                dev_err(&i2c->dev, "i2c_transfer() failed, %d != %d\n",
+                        ret, wm2000->anc_download_size);
+                return -EIO;
+        }
+
+        dev_dbg(&i2c->dev, "Download complete\n");
+
+        if (analogue) {
+                timeout = 248;
+                wm2000_write(i2c, WM2000_REG_ANA_VMID_PU_TIME, timeout / 4);
+
+                wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
+                             WM2000_MODE_ANA_SEQ_INCLUDE |
+                             WM2000_MODE_MOUSE_ENABLE |
+                             WM2000_MODE_THERMAL_ENABLE);
+        } else {
+                timeout = 10;
+
+                wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
+                             WM2000_MODE_MOUSE_ENABLE |
+                             WM2000_MODE_THERMAL_ENABLE);
+        }
+
+        ret = wm2000_read(i2c, WM2000_REG_SPEECH_CLARITY);
+        if (wm2000->speech_clarity)
+                ret &= ~WM2000_SPEECH_CLARITY;
+        else
+                ret |= WM2000_SPEECH_CLARITY;
+        wm2000_write(i2c, WM2000_REG_SPEECH_CLARITY, ret);
+
+        wm2000_write(i2c, WM2000_REG_SYS_START0, 0x33);
+        wm2000_write(i2c, WM2000_REG_SYS_START1, 0x02);
+
+        wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_ANC_INT_N_CLR);
+
+        if (!wm2000_poll_bit(i2c, WM2000_REG_SYS_STATUS,
+                             WM2000_STATUS_MOUSE_ACTIVE, timeout)) {
+                dev_err(&i2c->dev, "Timed out waiting for device after %dms\n",
+                        timeout * 10);
+                return -ETIMEDOUT;
+        }
+
+        dev_dbg(&i2c->dev, "ANC active\n");
+        if (analogue)
+                dev_dbg(&i2c->dev, "Analogue active\n");
+        wm2000->anc_mode = ANC_ACTIVE;
+
+        return 0;
+}
+
+static int wm2000_power_down(struct i2c_client *i2c, int analogue)
+{
+        struct wm2000_priv *wm2000 = dev_get_drvdata(&i2c->dev);
+        int timeout;
+
+        if (analogue) {
+                timeout = 248;
+                wm2000_write(i2c, WM2000_REG_ANA_VMID_PD_TIME, timeout / 4);
+                wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
+                             WM2000_MODE_ANA_SEQ_INCLUDE |
+                             WM2000_MODE_POWER_DOWN);
+        } else {
+                timeout = 10;
+                wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
+                             WM2000_MODE_POWER_DOWN);
+        }
+
+        if (!wm2000_poll_bit(i2c, WM2000_REG_SYS_STATUS,
+                             WM2000_STATUS_POWER_DOWN_COMPLETE, timeout)) {
+                dev_err(&i2c->dev, "Timeout waiting for ANC power down\n");
+                return -ETIMEDOUT;
+        }
+
+        if (!wm2000_poll_bit(i2c, WM2000_REG_ANC_STAT,
+                             WM2000_ANC_ENG_IDLE, 1)) {
+                dev_err(&i2c->dev, "Timeout waiting for ANC engine idle\n");
+                return -ETIMEDOUT;
+        }
+
+        dev_dbg(&i2c->dev, "powered off\n");
+        wm2000->anc_mode = ANC_OFF;
+
+        return 0;
+}
+
+static int wm2000_enter_bypass(struct i2c_client *i2c, int analogue)
+{
+        struct wm2000_priv *wm2000 = dev_get_drvdata(&i2c->dev);
+
+        BUG_ON(wm2000->anc_mode != ANC_ACTIVE);
+
+        if (analogue) {
+                wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
+                             WM2000_MODE_ANA_SEQ_INCLUDE |
+                             WM2000_MODE_THERMAL_ENABLE |
+                             WM2000_MODE_BYPASS_ENTRY);
+        } else {
+                wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
+                             WM2000_MODE_THERMAL_ENABLE |
+                             WM2000_MODE_BYPASS_ENTRY);
+        }
+
+        if (!wm2000_poll_bit(i2c, WM2000_REG_SYS_STATUS,
+                             WM2000_STATUS_ANC_DISABLED, 10)) {
+                dev_err(&i2c->dev, "Timeout waiting for ANC disable\n");
+                return -ETIMEDOUT;
+        }
+
+        if (!wm2000_poll_bit(i2c, WM2000_REG_ANC_STAT,
+                             WM2000_ANC_ENG_IDLE, 1)) {
+                dev_err(&i2c->dev, "Timeout waiting for ANC engine idle\n");
+                return -ETIMEDOUT;
+        }
+
+        wm2000_write(i2c, WM2000_REG_SYS_CTL1, WM2000_SYS_STBY);
+        wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_RAM_CLR);
+
+        wm2000->anc_mode = ANC_BYPASS;
+        dev_dbg(&i2c->dev, "bypass enabled\n");
+
+        return 0;
+}
+
+static int wm2000_exit_bypass(struct i2c_client *i2c, int analogue)
+{
+        struct wm2000_priv *wm2000 = dev_get_drvdata(&i2c->dev);
+
+        BUG_ON(wm2000->anc_mode != ANC_BYPASS);
+        
+        wm2000_write(i2c, WM2000_REG_SYS_CTL1, 0);
+
+        if (analogue) {
+                wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
+                             WM2000_MODE_ANA_SEQ_INCLUDE |
+                             WM2000_MODE_MOUSE_ENABLE |
+                             WM2000_MODE_THERMAL_ENABLE);
+        } else {
+                wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
+                             WM2000_MODE_MOUSE_ENABLE |
+                             WM2000_MODE_THERMAL_ENABLE);
+        }
+
+        wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_RAM_SET);
+        wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_ANC_INT_N_CLR);
+
+        if (!wm2000_poll_bit(i2c, WM2000_REG_SYS_STATUS,
+                             WM2000_STATUS_MOUSE_ACTIVE, 10)) {
+                dev_err(&i2c->dev, "Timed out waiting for MOUSE\n");
+                return -ETIMEDOUT;
+        }
+
+        wm2000->anc_mode = ANC_ACTIVE;
+        dev_dbg(&i2c->dev, "MOUSE active\n");
+
+        return 0;
+}
+
+static int wm2000_enter_standby(struct i2c_client *i2c, int analogue)
+{
+        struct wm2000_priv *wm2000 = dev_get_drvdata(&i2c->dev);
+        int timeout;
+
+        BUG_ON(wm2000->anc_mode != ANC_ACTIVE);
+
+        if (analogue) {
+                timeout = 248;
+                wm2000_write(i2c, WM2000_REG_ANA_VMID_PD_TIME, timeout / 4);
+
+                wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
+                             WM2000_MODE_ANA_SEQ_INCLUDE |
+                             WM2000_MODE_THERMAL_ENABLE |
+                             WM2000_MODE_STANDBY_ENTRY);
+        } else {
+                timeout = 10;
+
+                wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
+                             WM2000_MODE_THERMAL_ENABLE |
+                             WM2000_MODE_STANDBY_ENTRY);
+        }
+
+        if (!wm2000_poll_bit(i2c, WM2000_REG_SYS_STATUS,
+                             WM2000_STATUS_ANC_DISABLED, timeout)) {
+                dev_err(&i2c->dev,
+                        "Timed out waiting for ANC disable after 1ms\n");
+                return -ETIMEDOUT;
+        }
+
+        if (!wm2000_poll_bit(i2c, WM2000_REG_ANC_STAT, WM2000_ANC_ENG_IDLE,
+                             1)) {
+                dev_err(&i2c->dev,
+                        "Timed out waiting for standby after %dms\n",
+                        timeout * 10);
+                return -ETIMEDOUT;
+        }
+
+        wm2000_write(i2c, WM2000_REG_SYS_CTL1, WM2000_SYS_STBY);
+        wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_RAM_CLR);
+
+        wm2000->anc_mode = ANC_STANDBY;
+        dev_dbg(&i2c->dev, "standby\n");
+        if (analogue)
+                dev_dbg(&i2c->dev, "Analogue disabled\n");
+
+        return 0;
+}
+
+static int wm2000_exit_standby(struct i2c_client *i2c, int analogue)
+{
+        struct wm2000_priv *wm2000 = dev_get_drvdata(&i2c->dev);
+        int timeout;
+
+        BUG_ON(wm2000->anc_mode != ANC_STANDBY);
+
+        wm2000_write(i2c, WM2000_REG_SYS_CTL1, 0);
+
+        if (analogue) {
+                timeout = 248;
+                wm2000_write(i2c, WM2000_REG_ANA_VMID_PU_TIME, timeout / 4);
+
+                wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
+                             WM2000_MODE_ANA_SEQ_INCLUDE |
+                             WM2000_MODE_THERMAL_ENABLE |
+                             WM2000_MODE_MOUSE_ENABLE);
+        } else {
+                timeout = 10;
+
+                wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
+                             WM2000_MODE_THERMAL_ENABLE |
+                             WM2000_MODE_MOUSE_ENABLE);
+        }
+
+        wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_RAM_SET);
+        wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_ANC_INT_N_CLR);
+
+        if (!wm2000_poll_bit(i2c, WM2000_REG_SYS_STATUS,
+                             WM2000_STATUS_MOUSE_ACTIVE, timeout)) {
+                dev_err(&i2c->dev, "Timed out waiting for MOUSE after %dms\n",
+                        timeout * 10);
+                return -ETIMEDOUT;
+        }
+
+        wm2000->anc_mode = ANC_ACTIVE;
+        dev_dbg(&i2c->dev, "MOUSE active\n");
+        if (analogue)
+                dev_dbg(&i2c->dev, "Analogue enabled\n");
+
+        return 0;
+}
+
+typedef int (*wm2000_mode_fn)(struct i2c_client *i2c, int analogue);
+
+static struct {
+        enum wm2000_anc_mode source;
+        enum wm2000_anc_mode dest;
+        int analogue;
+        wm2000_mode_fn step[2];
+} anc_transitions[] = {
+        {
+                .source = ANC_OFF,
+                .dest = ANC_ACTIVE,
+                .analogue = 1,
+                .step = {
+                        wm2000_power_up,
+                },
+        },
+        {
+                .source = ANC_OFF,
+                .dest = ANC_STANDBY,
+                .step = {
+                        wm2000_power_up,
+                        wm2000_enter_standby,
+                },
+        },
+        {
+                .source = ANC_OFF,
+                .dest = ANC_BYPASS,
+                .analogue = 1,
+                .step = {
+                        wm2000_power_up,
+                        wm2000_enter_bypass,
+                },
+        },
+        {
+                .source = ANC_ACTIVE,
+                .dest = ANC_BYPASS,
+                .analogue = 1,
+                .step = {
+                        wm2000_enter_bypass,
+                },
+        },
+        {
+                .source = ANC_ACTIVE,
+                .dest = ANC_STANDBY,
+                .analogue = 1,
+                .step = {
+                        wm2000_enter_standby,
+                },
+        },
+        {
+                .source = ANC_ACTIVE,
+                .dest = ANC_OFF,
+                .analogue = 1,
+                .step = {
+                        wm2000_power_down,
+                },
+        },
+        {
+                .source = ANC_BYPASS,
+                .dest = ANC_ACTIVE,
+                .analogue = 1,
+                .step = {
+                        wm2000_exit_bypass,
+                },
+        },
+        {
+                .source = ANC_BYPASS,
+                .dest = ANC_STANDBY,
+                .analogue = 1,
+                .step = {
+                        wm2000_exit_bypass,
+                        wm2000_enter_standby,
+                },
+        },
+        {
+                .source = ANC_BYPASS,
+                .dest = ANC_OFF,
+                .step = {
+                        wm2000_exit_bypass,
+                        wm2000_power_down,
+                },
+        },
+        {
+                .source = ANC_STANDBY,
+                .dest = ANC_ACTIVE,
+                .analogue = 1,
+                .step = {
+                        wm2000_exit_standby,
+                },
+        },
+        {
+                .source = ANC_STANDBY,
+                .dest = ANC_BYPASS,
+                .analogue = 1,
+                .step = {
+                        wm2000_exit_standby,
+                        wm2000_enter_bypass,
+                },
+        },
+        {
+                .source = ANC_STANDBY,
+                .dest = ANC_OFF,
+                .step = {
+                        wm2000_exit_standby,
+                        wm2000_power_down,
+                },
+        },
+};
+
+static int wm2000_anc_transition(struct wm2000_priv *wm2000,
+                                 enum wm2000_anc_mode mode)
+{
+        struct i2c_client *i2c = wm2000->i2c;
+        int i, j;
+        int ret;
+
+        if (wm2000->anc_mode == mode)
+                return 0;
+
+        for (i = 0; i < ARRAY_SIZE(anc_transitions); i++)
+                if (anc_transitions[i].source == wm2000->anc_mode &&
+                    anc_transitions[i].dest == mode)
+                        break;
+        if (i == ARRAY_SIZE(anc_transitions)) {
+                dev_err(&i2c->dev, "No transition for %d->%d\n",
+                        wm2000->anc_mode, mode);
+                return -EINVAL;
+        }
+
+        for (j = 0; j < ARRAY_SIZE(anc_transitions[j].step); j++) {
+                if (!anc_transitions[i].step[j])
+                        break;
+                ret = anc_transitions[i].step[j](i2c,
+                                                 anc_transitions[i].analogue);
+                if (ret != 0)
+                        return ret;
+        }
+
+        return 0;
+}
+
+static int wm2000_anc_set_mode(struct wm2000_priv *wm2000)
+{
+        struct i2c_client *i2c = wm2000->i2c;
+        enum wm2000_anc_mode mode;
+
+        if (wm2000->anc_eng_ena && wm2000->spk_ena)
+                if (wm2000->anc_active)
+                        mode = ANC_ACTIVE;
+                else
+                        mode = ANC_BYPASS;
+        else
+                mode = ANC_STANDBY;
+
+        dev_dbg(&i2c->dev, "Set mode %d (enabled %d, mute %d, active %d)\n",
+                mode, wm2000->anc_eng_ena, !wm2000->spk_ena,
+                wm2000->anc_active);
+
+        return wm2000_anc_transition(wm2000, mode);
+}
+
+static int wm2000_anc_mode_get(struct snd_kcontrol *kcontrol,
+                               struct snd_ctl_elem_value *ucontrol)
+{
+        struct wm2000_priv *wm2000 = dev_get_drvdata(&wm2000_i2c->dev);
+
+        ucontrol->value.enumerated.item[0] = wm2000->anc_active;
+
+        return 0;
+}
+
+static int wm2000_anc_mode_put(struct snd_kcontrol *kcontrol,
+                               struct snd_ctl_elem_value *ucontrol)
+{
+        struct wm2000_priv *wm2000 = dev_get_drvdata(&wm2000_i2c->dev);
+        int anc_active = ucontrol->value.enumerated.item[0];
+
+        if (anc_active > 1)
+                return -EINVAL;
+
+        wm2000->anc_active = anc_active;
+
+        return wm2000_anc_set_mode(wm2000);
+}
+
+static int wm2000_speaker_get(struct snd_kcontrol *kcontrol,
+                              struct snd_ctl_elem_value *ucontrol)
+{
+        struct wm2000_priv *wm2000 = dev_get_drvdata(&wm2000_i2c->dev);
+
+        ucontrol->value.enumerated.item[0] = wm2000->spk_ena;
+
+        return 0;
+}
+
+static int wm2000_speaker_put(struct snd_kcontrol *kcontrol,
+                              struct snd_ctl_elem_value *ucontrol)
+{
+        struct wm2000_priv *wm2000 = dev_get_drvdata(&wm2000_i2c->dev);
+        int val = ucontrol->value.enumerated.item[0];
+
+        if (val > 1)
+                return -EINVAL;
+
+        wm2000->spk_ena = val;
+
+        return wm2000_anc_set_mode(wm2000);
+}
+
+static const struct snd_kcontrol_new wm2000_controls[] = {
+        SOC_SINGLE_BOOL_EXT("WM2000 ANC Switch", 0,
+                            wm2000_anc_mode_get,
+                            wm2000_anc_mode_put),
+        SOC_SINGLE_BOOL_EXT("WM2000 Switch", 0,
+                            wm2000_speaker_get,
+                            wm2000_speaker_put),
+};
+
+static int wm2000_anc_power_event(struct snd_soc_dapm_widget *w,
+                                  struct snd_kcontrol *kcontrol, int event)
+{
+        struct wm2000_priv *wm2000 = dev_get_drvdata(&wm2000_i2c->dev);
+
+        if (SND_SOC_DAPM_EVENT_ON(event))
+                wm2000->anc_eng_ena = 1;
+
+        if (SND_SOC_DAPM_EVENT_OFF(event))
+                wm2000->anc_eng_ena = 0;
+
+        return wm2000_anc_set_mode(wm2000);
+}
+
+static const struct snd_soc_dapm_widget wm2000_dapm_widgets[] = {
+/* Externally visible pins */
+SND_SOC_DAPM_OUTPUT("WM2000 SPKN"),
+SND_SOC_DAPM_OUTPUT("WM2000 SPKP"),
+
+SND_SOC_DAPM_INPUT("WM2000 LINN"),
+SND_SOC_DAPM_INPUT("WM2000 LINP"),
+
+SND_SOC_DAPM_PGA_E("ANC Engine", SND_SOC_NOPM, 0, 0, NULL, 0,
+                   wm2000_anc_power_event,
+                   SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
+};
+
+/* Target, Path, Source */
+static const struct snd_soc_dapm_route audio_map[] = {
+        { "WM2000 SPKN", NULL, "ANC Engine" },
+        { "WM2000 SPKP", NULL, "ANC Engine" },
+        { "ANC Engine", NULL, "WM2000 LINN" },
+        { "ANC Engine", NULL, "WM2000 LINP" },
+};
+
+/* Called from the machine driver */
+int wm2000_add_controls(struct snd_soc_codec *codec)
+{
+        int ret;
+
+        if (!wm2000_i2c) {
+                pr_err("WM2000 not yet probed\n");
+                return -ENODEV;
+        }
+
+        ret = snd_soc_dapm_new_controls(codec, wm2000_dapm_widgets,
+                                        ARRAY_SIZE(wm2000_dapm_widgets));
+        if (ret < 0)
+                return ret;
+
+        ret = snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
+        if (ret < 0)
+                return ret;
+
+        return snd_soc_add_controls(codec, wm2000_controls,
+                        ARRAY_SIZE(wm2000_controls));
+}
+EXPORT_SYMBOL_GPL(wm2000_add_controls);
+
+static int __devinit wm2000_i2c_probe(struct i2c_client *i2c,
+                                      const struct i2c_device_id *i2c_id)
+{
+        struct wm2000_priv *wm2000;
+        struct wm2000_platform_data *pdata;
+        const char *filename;
+        const struct firmware *fw;
+        int reg, ret;
+        u16 id;
+
+        if (wm2000_i2c) {
+                dev_err(&i2c->dev, "Another WM2000 is already registered\n");
+                return -EINVAL;
+        }
+
+        wm2000 = kzalloc(sizeof(struct wm2000_priv), GFP_KERNEL);
+        if (wm2000 == NULL) {
+                dev_err(&i2c->dev, "Unable to allocate private data\n");
+                return -ENOMEM;
+        }
+
+        /* Verify that this is a WM2000 */
+        reg = wm2000_read(i2c, WM2000_REG_ID1);
+        id = reg << 8;
+        reg = wm2000_read(i2c, WM2000_REG_ID2);
+        id |= reg & 0xff;
+
+        if (id != 0x2000) {
+                dev_err(&i2c->dev, "Device is not a WM2000 - ID %x\n", id);
+                ret = -ENODEV;
+                goto err;
+        }
+
+        reg = wm2000_read(i2c, WM2000_REG_REVISON);
+        dev_info(&i2c->dev, "revision %c\n", reg + 'A');
+
+        filename = "wm2000_anc.bin";
+        pdata = dev_get_platdata(&i2c->dev);
+        if (pdata) {
+                wm2000->mclk_div = pdata->mclkdiv2;
+                wm2000->speech_clarity = !pdata->speech_enh_disable;
+
+                if (pdata->download_file)
+                        filename = pdata->download_file;
+        }
+
+        ret = request_firmware(&fw, filename, &i2c->dev);
+        if (ret != 0) {
+                dev_err(&i2c->dev, "Failed to acquire ANC data: %d\n", ret);
+                goto err;
+        }
+
+        /* Pre-cook the concatenation of the register address onto the image */
+        wm2000->anc_download_size = fw->size + 2;
+        wm2000->anc_download = kmalloc(wm2000->anc_download_size, GFP_KERNEL);
+        if (wm2000->anc_download == NULL) {
+                dev_err(&i2c->dev, "Out of memory\n");
+                ret = -ENOMEM;
+                goto err_fw;
+        }
+
+        wm2000->anc_download[0] = 0x80;
+        wm2000->anc_download[1] = 0x00;
+        memcpy(wm2000->anc_download + 2, fw->data, fw->size);
+
+        release_firmware(fw);
+
+        dev_set_drvdata(&i2c->dev, wm2000);
+        wm2000->anc_eng_ena = 1;
+        wm2000->i2c = i2c;
+
+        wm2000_reset(wm2000);
+
+        /* This will trigger a transition to standby mode by default */
+        wm2000_anc_set_mode(wm2000);    
+
+        wm2000_i2c = i2c;
+
+        return 0;
+
+err_fw:
+        release_firmware(fw);
+err:
+        kfree(wm2000);
+        return ret;
+}
+
+static __devexit int wm2000_i2c_remove(struct i2c_client *i2c)
+{
+        struct wm2000_priv *wm2000 = dev_get_drvdata(&i2c->dev);
+
+        wm2000_anc_transition(wm2000, ANC_OFF);
+
+        wm2000_i2c = NULL;
+        kfree(wm2000->anc_download);
+        kfree(wm2000);
+
+        return 0;
+}
+
+static void wm2000_i2c_shutdown(struct i2c_client *i2c)
+{
+        struct wm2000_priv *wm2000 = dev_get_drvdata(&i2c->dev);
+
+        wm2000_anc_transition(wm2000, ANC_OFF);
+}
+
+#ifdef CONFIG_PM
+static int wm2000_i2c_suspend(struct i2c_client *i2c, pm_message_t mesg)
+{
+        struct wm2000_priv *wm2000 = dev_get_drvdata(&i2c->dev);
+
+        return wm2000_anc_transition(wm2000, ANC_OFF);
+}
+
+static int wm2000_i2c_resume(struct i2c_client *i2c)
+{
+        struct wm2000_priv *wm2000 = dev_get_drvdata(&i2c->dev);
+
+        return wm2000_anc_set_mode(wm2000);
+}
+#else
+#define wm2000_i2c_suspend NULL
+#define wm2000_i2c_resume NULL
+#endif
+
+static const struct i2c_device_id wm2000_i2c_id[] = {
+        { "wm2000", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, wm2000_i2c_id);
+
+static struct i2c_driver wm2000_i2c_driver = {
+        .driver = {
+                .name = "wm2000",
+                .owner = THIS_MODULE,
+        },
+        .probe = wm2000_i2c_probe,
+        .remove = __devexit_p(wm2000_i2c_remove),
+        .suspend = wm2000_i2c_suspend,
+        .resume = wm2000_i2c_resume,
+        .shutdown = wm2000_i2c_shutdown,
+        .id_table = wm2000_i2c_id,
+};
+
+static int __init wm2000_init(void)
+{
+        return i2c_add_driver(&wm2000_i2c_driver);
+}
+module_init(wm2000_init);
+
+static void __exit wm2000_exit(void)
+{
+        i2c_del_driver(&wm2000_i2c_driver);
+}
+module_exit(wm2000_exit);
+
+MODULE_DESCRIPTION("ASoC WM2000 driver");
+MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfonmicro.com>");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/codecs/wm2000.h b/sound/soc/codecs/wm2000.h
new file mode 100644
index 000000000000..c18e261c3c7f
--- /dev/null
+++ b/sound/soc/codecs/wm2000.h
@@ -0,0 +1,79 @@
+/*
+ * wm2000.h  --  WM2000 Soc Audio driver
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef _WM2000_H
+#define _WM2000_H
+
+struct wm2000_setup_data {
+        unsigned short i2c_address;
+        int mclk_div;   /* Set to a non-zero value if MCLK_DIV_2 required */
+};
+
+extern int wm2000_add_controls(struct snd_soc_codec *codec);
+
+extern struct snd_soc_dai wm2000_dai;
+extern struct snd_soc_codec_device soc_codec_dev_wm2000;
+
+#define WM2000_REG_SYS_START        0x8000
+#define WM2000_REG_SPEECH_CLARITY   0x8fef
+#define WM2000_REG_SYS_WATCHDOG     0x8ff6
+#define WM2000_REG_ANA_VMID_PD_TIME 0x8ff7
+#define WM2000_REG_ANA_VMID_PU_TIME 0x8ff8
+#define WM2000_REG_CAT_FLTR_INDX    0x8ff9
+#define WM2000_REG_CAT_GAIN_0       0x8ffa
+#define WM2000_REG_SYS_STATUS       0x8ffc
+#define WM2000_REG_SYS_MODE_CNTRL   0x8ffd
+#define WM2000_REG_SYS_START0       0x8ffe
+#define WM2000_REG_SYS_START1       0x8fff
+#define WM2000_REG_ID1              0xf000
+#define WM2000_REG_ID2              0xf001
+#define WM2000_REG_REVISON          0xf002
+#define WM2000_REG_SYS_CTL1         0xf003
+#define WM2000_REG_SYS_CTL2         0xf004
+#define WM2000_REG_ANC_STAT         0xf005
+#define WM2000_REG_IF_CTL           0xf006
+
+/* SPEECH_CLARITY */
+#define WM2000_SPEECH_CLARITY   0x01
+
+/* SYS_STATUS */
+#define WM2000_STATUS_MOUSE_ACTIVE              0x40
+#define WM2000_STATUS_CAT_FREQ_COMPLETE         0x20
+#define WM2000_STATUS_CAT_GAIN_COMPLETE         0x10
+#define WM2000_STATUS_THERMAL_SHUTDOWN_COMPLETE 0x08
+#define WM2000_STATUS_ANC_DISABLED              0x04
+#define WM2000_STATUS_POWER_DOWN_COMPLETE       0x02
+#define WM2000_STATUS_BOOT_COMPLETE             0x01
+
+/* SYS_MODE_CNTRL */
+#define WM2000_MODE_ANA_SEQ_INCLUDE 0x80
+#define WM2000_MODE_MOUSE_ENABLE    0x40
+#define WM2000_MODE_CAT_FREQ_ENABLE 0x20
+#define WM2000_MODE_CAT_GAIN_ENABLE 0x10
+#define WM2000_MODE_BYPASS_ENTRY    0x08
+#define WM2000_MODE_STANDBY_ENTRY   0x04
+#define WM2000_MODE_THERMAL_ENABLE  0x02
+#define WM2000_MODE_POWER_DOWN      0x01
+
+/* SYS_CTL1 */
+#define WM2000_SYS_STBY          0x01
+
+/* SYS_CTL2 */
+#define WM2000_MCLK_DIV2_ENA_CLR 0x80
+#define WM2000_MCLK_DIV2_ENA_SET 0x40
+#define WM2000_ANC_ENG_CLR       0x20
+#define WM2000_ANC_ENG_SET       0x10
+#define WM2000_ANC_INT_N_CLR     0x08
+#define WM2000_ANC_INT_N_SET     0x04
+#define WM2000_RAM_CLR           0x02
+#define WM2000_RAM_SET           0x01
+
+/* ANC_STAT */
+#define WM2000_ANC_ENG_IDLE      0x01
+
+#endif
diff --git a/sound/soc/codecs/wm8350.c b/sound/soc/codecs/wm8350.c
index 593d5b9c9f03..2e0772f9c456 100644
--- a/sound/soc/codecs/wm8350.c
+++ b/sound/soc/codecs/wm8350.c
@@ -13,6 +13,7 @@
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <linux/delay.h>
 #include <linux/pm.h>
 #include <linux/platform_device.h>
@@ -800,7 +801,7 @@ static int wm8350_add_widgets(struct snd_soc_codec *codec)
                 return ret;
         }
 
-        return snd_soc_dapm_new_widgets(codec);
+        return 0;
 }
 
 static int wm8350_set_dai_sysclk(struct snd_soc_dai *codec_dai,
@@ -925,7 +926,7 @@ static int wm8350_set_dai_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt)
                 iface |= 0x3 << 8;
                 break;
         case SND_SOC_DAIFMT_DSP_B:
-                iface |= 0x3 << 8;      /* lg not sure which mode */
+                iface |= 0x3 << 8 | WM8350_AIF_LRCLK_INV;
                 break;
         default:
                 return -EINVAL;
@@ -1101,7 +1102,7 @@ static inline int fll_factors(struct _fll_div *fll_div, unsigned int input,
 }
 
 static int wm8350_set_fll(struct snd_soc_dai *codec_dai,
-                          int pll_id, unsigned int freq_in,
+                          int pll_id, int source, unsigned int freq_in,
                           unsigned int freq_out)
 {
         struct snd_soc_codec *codec = codec_dai->codec;
@@ -1340,15 +1341,16 @@ static int wm8350_resume(struct platform_device *pdev)
         return 0;
 }
 
-static void wm8350_hp_jack_handler(struct wm8350 *wm8350, int irq, void *data)
+static irqreturn_t wm8350_hp_jack_handler(int irq, void *data)
 {
         struct wm8350_data *priv = data;
+        struct wm8350 *wm8350 = priv->codec.control_data;
         u16 reg;
         int report;
         int mask;
         struct wm8350_jack_data *jack = NULL;
 
-        switch (irq) {
+        switch (irq - wm8350->irq_base) {
         case WM8350_IRQ_CODEC_JCK_DET_L:
                 jack = &priv->hpl;
                 mask = WM8350_JACK_L_LVL;
@@ -1365,7 +1367,7 @@ static void wm8350_hp_jack_handler(struct wm8350 *wm8350, int irq, void *data)
 
         if (!jack->jack) {
                 dev_warn(wm8350->dev, "Jack interrupt called with no jack\n");
-                return;
+                return IRQ_NONE;
         }
 
         /* Debounce */
@@ -1378,6 +1380,8 @@ static void wm8350_hp_jack_handler(struct wm8350 *wm8350, int irq, void *data)
                 report = 0;
 
         snd_soc_jack_report(jack->jack, report, jack->report);
+
+        return IRQ_HANDLED;
 }
 
 /**
@@ -1421,9 +1425,7 @@ int wm8350_hp_jack_detect(struct snd_soc_codec *codec, enum wm8350_jack which,
         wm8350_set_bits(wm8350, WM8350_JACK_DETECT, ena);
 
         /* Sync status */
-        wm8350_hp_jack_handler(wm8350, irq, priv);
-
-        wm8350_unmask_irq(wm8350, irq);
+        wm8350_hp_jack_handler(irq + wm8350->irq_base, priv);
 
         return 0;
 }
@@ -1482,12 +1484,16 @@ static int wm8350_probe(struct platform_device *pdev)
         wm8350_set_bits(wm8350, WM8350_ROUT2_VOLUME,
                         WM8350_OUT2_VU | WM8350_OUT2R_MUTE);
 
-        wm8350_mask_irq(wm8350, WM8350_IRQ_CODEC_JCK_DET_L);
-        wm8350_mask_irq(wm8350, WM8350_IRQ_CODEC_JCK_DET_R);
+        /* Make sure jack detect is disabled to start off with */
+        wm8350_clear_bits(wm8350, WM8350_JACK_DETECT,
+                          WM8350_JDL_ENA | WM8350_JDR_ENA);
+
         wm8350_register_irq(wm8350, WM8350_IRQ_CODEC_JCK_DET_L,
-                            wm8350_hp_jack_handler, priv);
+                            wm8350_hp_jack_handler, 0, "Left jack detect",
+                            priv);
         wm8350_register_irq(wm8350, WM8350_IRQ_CODEC_JCK_DET_R,
-                            wm8350_hp_jack_handler, priv);
+                            wm8350_hp_jack_handler, 0, "Right jack detect",
+                            priv);
 
         ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
         if (ret < 0) {
@@ -1501,18 +1507,7 @@ static int wm8350_probe(struct platform_device *pdev)
 
         wm8350_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
 
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                dev_err(&pdev->dev, "failed to register card\n");
-                goto card_err;
-        }
-
         return 0;
-
-card_err:
-        snd_soc_free_pcms(socdev);
-        snd_soc_dapm_free(socdev);
-        return ret;
 }
 
 static int wm8350_remove(struct platform_device *pdev)
@@ -1527,10 +1522,8 @@ static int wm8350_remove(struct platform_device *pdev)
                           WM8350_JDL_ENA | WM8350_JDR_ENA);
         wm8350_clear_bits(wm8350, WM8350_POWER_MGMT_4, WM8350_TOCLK_ENA);
 
-        wm8350_mask_irq(wm8350, WM8350_IRQ_CODEC_JCK_DET_L);
-        wm8350_mask_irq(wm8350, WM8350_IRQ_CODEC_JCK_DET_R);
-        wm8350_free_irq(wm8350, WM8350_IRQ_CODEC_JCK_DET_L);
-        wm8350_free_irq(wm8350, WM8350_IRQ_CODEC_JCK_DET_R);
+        wm8350_free_irq(wm8350, WM8350_IRQ_CODEC_JCK_DET_L, priv);
+        wm8350_free_irq(wm8350, WM8350_IRQ_CODEC_JCK_DET_R, priv);
 
         priv->hpl.jack = NULL;
         priv->hpr.jack = NULL;
@@ -1680,21 +1673,6 @@ static int __devexit wm8350_codec_remove(struct platform_device *pdev)
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int wm8350_codec_suspend(struct platform_device *pdev, pm_message_t m)
-{
-        return snd_soc_suspend_device(&pdev->dev);
-}
-
-static int wm8350_codec_resume(struct platform_device *pdev)
-{
-        return snd_soc_resume_device(&pdev->dev);
-}
-#else
-#define wm8350_codec_suspend NULL
-#define wm8350_codec_resume NULL
-#endif
-
 static struct platform_driver wm8350_codec_driver = {
         .driver = {
                    .name = "wm8350-codec",
@@ -1702,8 +1680,6 @@ static struct platform_driver wm8350_codec_driver = {
                    },
         .probe = wm8350_codec_probe,
         .remove = __devexit_p(wm8350_codec_remove),
-        .suspend = wm8350_codec_suspend,
-        .resume = wm8350_codec_resume,
 };
 
 static __init int wm8350_init(void)
diff --git a/sound/soc/codecs/wm8400.c b/sound/soc/codecs/wm8400.c
index b9ef4d915221..6acc885cf9b7 100644
--- a/sound/soc/codecs/wm8400.c
+++ b/sound/soc/codecs/wm8400.c
@@ -14,6 +14,7 @@
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/pm.h>
@@ -915,7 +916,6 @@ static int wm8400_add_widgets(struct snd_soc_codec *codec)
 
         snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
 
-        snd_soc_dapm_new_widgets(codec);
         return 0;
 }
 
@@ -1011,7 +1011,8 @@ static int fll_factors(struct wm8400_priv *wm8400, struct fll_factors *factors,
 }
 
 static int wm8400_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id,
-                              unsigned int freq_in, unsigned int freq_out)
+                              int source, unsigned int freq_in,
+                              unsigned int freq_out)
 {
         struct snd_soc_codec *codec = codec_dai->codec;
         struct wm8400_priv *wm8400 = codec->private_data;
@@ -1399,17 +1400,6 @@ static int wm8400_probe(struct platform_device *pdev)
         wm8400_add_controls(codec);
         wm8400_add_widgets(codec);
 
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                dev_err(&pdev->dev, "failed to register card\n");
-                goto card_err;
-        }
-
-        return ret;
-
-card_err:
-        snd_soc_free_pcms(socdev);
-        snd_soc_dapm_free(socdev);
 pcm_err:
         return ret;
 }
@@ -1558,21 +1548,6 @@ static int __exit wm8400_codec_remove(struct platform_device *dev)
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int wm8400_pdev_suspend(struct platform_device *pdev, pm_message_t msg)
-{
-        return snd_soc_suspend_device(&pdev->dev);
-}
-
-static int wm8400_pdev_resume(struct platform_device *pdev)
-{
-        return snd_soc_resume_device(&pdev->dev);
-}
-#else
-#define wm8400_pdev_suspend NULL
-#define wm8400_pdev_resume NULL
-#endif
-
 static struct platform_driver wm8400_codec_driver = {
         .driver = {
                 .name = "wm8400-codec",
@@ -1580,8 +1555,6 @@ static struct platform_driver wm8400_codec_driver = {
         },
         .probe = wm8400_codec_probe,
         .remove = __exit_p(wm8400_codec_remove),
-        .suspend = wm8400_pdev_suspend,
-        .resume = wm8400_pdev_resume,
 };
 
 static int __init wm8400_codec_init(void)
diff --git a/sound/soc/codecs/wm8510.c b/sound/soc/codecs/wm8510.c
index 060d5d06ba95..9000b1d19afb 100644
--- a/sound/soc/codecs/wm8510.c
+++ b/sound/soc/codecs/wm8510.c
@@ -19,6 +19,7 @@
 #include <linux/i2c.h>
 #include <linux/platform_device.h>
 #include <linux/spi/spi.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
@@ -219,7 +220,6 @@ static int wm8510_add_widgets(struct snd_soc_codec *codec)
 
         snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
 
-        snd_soc_dapm_new_widgets(codec);
         return 0;
 }
 
@@ -271,8 +271,8 @@ static void pll_factors(unsigned int target, unsigned int source)
         pll_div.k = K;
 }
 
-static int wm8510_set_dai_pll(struct snd_soc_dai *codec_dai,
-                int pll_id, unsigned int freq_in, unsigned int freq_out)
+static int wm8510_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id,
+                int source, unsigned int freq_in, unsigned int freq_out)
 {
         struct snd_soc_codec *codec = codec_dai->codec;
         u16 reg;
@@ -425,23 +425,23 @@ static int wm8510_pcm_hw_params(struct snd_pcm_substream *substream,
 
         /* filter coefficient */
         switch (params_rate(params)) {
-        case SNDRV_PCM_RATE_8000:
+        case 8000:
                 adn |= 0x5 << 1;
                 break;
-        case SNDRV_PCM_RATE_11025:
+        case 11025:
                 adn |= 0x4 << 1;
                 break;
-        case SNDRV_PCM_RATE_16000:
+        case 16000:
                 adn |= 0x3 << 1;
                 break;
-        case SNDRV_PCM_RATE_22050:
+        case 22050:
                 adn |= 0x2 << 1;
                 break;
-        case SNDRV_PCM_RATE_32000:
+        case 32000:
                 adn |= 0x1 << 1;
                 break;
-        case SNDRV_PCM_RATE_44100:
-        case SNDRV_PCM_RATE_48000:
+        case 44100:
+        case 48000:
                 break;
         }
 
@@ -604,16 +604,9 @@ static int wm8510_init(struct snd_soc_device *socdev,
         snd_soc_add_controls(codec, wm8510_snd_controls,
                                 ARRAY_SIZE(wm8510_snd_controls));
         wm8510_add_widgets(codec);
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                printk(KERN_ERR "wm8510: failed to register card\n");
-                goto card_err;
-        }
+
         return ret;
 
-card_err:
-        snd_soc_free_pcms(socdev);
-        snd_soc_dapm_free(socdev);
 err:
         kfree(codec->reg_cache);
         return ret;
diff --git a/sound/soc/codecs/wm8523.c b/sound/soc/codecs/wm8523.c
index 25870a4652fb..19cd47293424 100644
--- a/sound/soc/codecs/wm8523.c
+++ b/sound/soc/codecs/wm8523.c
@@ -19,6 +19,7 @@
 #include <linux/i2c.h>
 #include <linux/platform_device.h>
 #include <linux/regulator/consumer.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
@@ -117,7 +118,6 @@ static int wm8523_add_widgets(struct snd_soc_codec *codec)
 
         snd_soc_dapm_add_routes(codec, intercon, ARRAY_SIZE(intercon));
 
-        snd_soc_dapm_new_widgets(codec);
         return 0;
 }
 
@@ -448,17 +448,9 @@ static int wm8523_probe(struct platform_device *pdev)
         snd_soc_add_controls(codec, wm8523_snd_controls,
                              ARRAY_SIZE(wm8523_snd_controls));
         wm8523_add_widgets(codec);
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                dev_err(codec->dev, "failed to register card: %d\n", ret);
-                goto card_err;
-        }
 
         return ret;
 
-card_err:
-        snd_soc_free_pcms(socdev);
-        snd_soc_dapm_free(socdev);
 pcm_err:
         return ret;
 }
@@ -638,21 +630,6 @@ static __devexit int wm8523_i2c_remove(struct i2c_client *client)
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int wm8523_i2c_suspend(struct i2c_client *i2c, pm_message_t msg)
-{
-        return snd_soc_suspend_device(&i2c->dev);
-}
-
-static int wm8523_i2c_resume(struct i2c_client *i2c)
-{
-        return snd_soc_resume_device(&i2c->dev);
-}
-#else
-#define wm8523_i2c_suspend NULL
-#define wm8523_i2c_resume NULL
-#endif
-
 static const struct i2c_device_id wm8523_i2c_id[] = {
         { "wm8523", 0 },
         { }
@@ -666,8 +643,6 @@ static struct i2c_driver wm8523_i2c_driver = {
         },
         .probe =    wm8523_i2c_probe,
         .remove =   __devexit_p(wm8523_i2c_remove),
-        .suspend =  wm8523_i2c_suspend,
-        .resume =   wm8523_i2c_resume,
         .id_table = wm8523_i2c_id,
 };
 #endif
diff --git a/sound/soc/codecs/wm8580.c b/sound/soc/codecs/wm8580.c
index 6bded8c78150..8cc9042965eb 100644
--- a/sound/soc/codecs/wm8580.c
+++ b/sound/soc/codecs/wm8580.c
@@ -25,6 +25,7 @@
 #include <linux/i2c.h>
 #include <linux/platform_device.h>
 #include <linux/regulator/consumer.h>
+#include <linux/slab.h>
 
 #include <sound/core.h>
 #include <sound/pcm.h>
@@ -315,7 +316,6 @@ static int wm8580_add_widgets(struct snd_soc_codec *codec)
 
         snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
 
-        snd_soc_dapm_new_widgets(codec);
         return 0;
 }
 
@@ -407,8 +407,8 @@ static int pll_factors(struct _pll_div *pll_div, unsigned int target,
         return 0;
 }
 
-static int wm8580_set_dai_pll(struct snd_soc_dai *codec_dai,
-                int pll_id, unsigned int freq_in, unsigned int freq_out)
+static int wm8580_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id,
+                int source, unsigned int freq_in, unsigned int freq_out)
 {
         int offset;
         struct snd_soc_codec *codec = codec_dai->codec;
@@ -800,17 +800,9 @@ static int wm8580_probe(struct platform_device *pdev)
         snd_soc_add_controls(codec, wm8580_snd_controls,
                              ARRAY_SIZE(wm8580_snd_controls));
         wm8580_add_widgets(codec);
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                dev_err(codec->dev, "failed to register card: %d\n", ret);
-                goto card_err;
-        }
 
         return ret;
 
-card_err:
-        snd_soc_free_pcms(socdev);
-        snd_soc_dapm_free(socdev);
 pcm_err:
         return ret;
 }
@@ -961,21 +953,6 @@ static int wm8580_i2c_remove(struct i2c_client *client)
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int wm8580_i2c_suspend(struct i2c_client *client, pm_message_t msg)
-{
-        return snd_soc_suspend_device(&client->dev);
-}
-
-static int wm8580_i2c_resume(struct i2c_client *client)
-{
-        return snd_soc_resume_device(&client->dev);
-}
-#else
-#define wm8580_i2c_suspend NULL
-#define wm8580_i2c_resume NULL
-#endif
-
 static const struct i2c_device_id wm8580_i2c_id[] = {
         { "wm8580", 0 },
         { }
@@ -989,8 +966,6 @@ static struct i2c_driver wm8580_i2c_driver = {
         },
         .probe =    wm8580_i2c_probe,
         .remove =   wm8580_i2c_remove,
-        .suspend =  wm8580_i2c_suspend,
-        .resume =   wm8580_i2c_resume,
         .id_table = wm8580_i2c_id,
 };
 #endif
diff --git a/sound/soc/codecs/wm8711.c b/sound/soc/codecs/wm8711.c
new file mode 100644
index 000000000000..8ca3812f2f2f
--- /dev/null
+++ b/sound/soc/codecs/wm8711.c
@@ -0,0 +1,634 @@
+/*
+ * wm8711.c  --  WM8711 ALSA SoC Audio driver
+ *
+ * Copyright 2006 Wolfson Microelectronics
+ *
+ * Author: Mike Arthur <linux@wolfsonmicro.com>
+ *
+ * Based on wm8731.c by Richard Purdie
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/pm.h>
+#include <linux/i2c.h>
+#include <linux/platform_device.h>
+#include <linux/spi/spi.h>
+#include <linux/slab.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+#include <sound/tlv.h>
+#include <sound/initval.h>
+
+#include "wm8711.h"
+
+static struct snd_soc_codec *wm8711_codec;
+
+/* codec private data */
+struct wm8711_priv {
+        struct snd_soc_codec codec;
+        u16 reg_cache[WM8711_CACHEREGNUM];
+        unsigned int sysclk;
+};
+
+/*
+ * wm8711 register cache
+ * We can't read the WM8711 register space when we are
+ * using 2 wire for device control, so we cache them instead.
+ * There is no point in caching the reset register
+ */
+static const u16 wm8711_reg[WM8711_CACHEREGNUM] = {
+        0x0079, 0x0079, 0x000a, 0x0008,
+        0x009f, 0x000a, 0x0000, 0x0000
+};
+
+#define wm8711_reset(c) snd_soc_write(c, WM8711_RESET, 0)
+
+static const DECLARE_TLV_DB_SCALE(out_tlv, -12100, 100, 1);
+
+static const struct snd_kcontrol_new wm8711_snd_controls[] = {
+
+SOC_DOUBLE_R_TLV("Master Playback Volume", WM8711_LOUT1V, WM8711_ROUT1V,
+                 0, 127, 0, out_tlv),
+SOC_DOUBLE_R("Master Playback ZC Switch", WM8711_LOUT1V, WM8711_ROUT1V,
+        7, 1, 0),
+
+};
+
+/* Output Mixer */
+static const struct snd_kcontrol_new wm8711_output_mixer_controls[] = {
+SOC_DAPM_SINGLE("Line Bypass Switch", WM8711_APANA, 3, 1, 0),
+SOC_DAPM_SINGLE("HiFi Playback Switch", WM8711_APANA, 4, 1, 0),
+};
+
+static const struct snd_soc_dapm_widget wm8711_dapm_widgets[] = {
+SND_SOC_DAPM_MIXER("Output Mixer", WM8711_PWR, 4, 1,
+        &wm8711_output_mixer_controls[0],
+        ARRAY_SIZE(wm8711_output_mixer_controls)),
+SND_SOC_DAPM_DAC("DAC", "HiFi Playback", WM8711_PWR, 3, 1),
+SND_SOC_DAPM_OUTPUT("LOUT"),
+SND_SOC_DAPM_OUTPUT("LHPOUT"),
+SND_SOC_DAPM_OUTPUT("ROUT"),
+SND_SOC_DAPM_OUTPUT("RHPOUT"),
+};
+
+static const struct snd_soc_dapm_route intercon[] = {
+        /* output mixer */
+        {"Output Mixer", "Line Bypass Switch", "Line Input"},
+        {"Output Mixer", "HiFi Playback Switch", "DAC"},
+
+        /* outputs */
+        {"RHPOUT", NULL, "Output Mixer"},
+        {"ROUT", NULL, "Output Mixer"},
+        {"LHPOUT", NULL, "Output Mixer"},
+        {"LOUT", NULL, "Output Mixer"},
+};
+
+static int wm8711_add_widgets(struct snd_soc_codec *codec)
+{
+        snd_soc_dapm_new_controls(codec, wm8711_dapm_widgets,
+                                  ARRAY_SIZE(wm8711_dapm_widgets));
+
+        snd_soc_dapm_add_routes(codec, intercon, ARRAY_SIZE(intercon));
+
+        return 0;
+}
+
+struct _coeff_div {
+        u32 mclk;
+        u32 rate;
+        u16 fs;
+        u8 sr:4;
+        u8 bosr:1;
+        u8 usb:1;
+};
+
+/* codec mclk clock divider coefficients */
+static const struct _coeff_div coeff_div[] = {
+        /* 48k */
+        {12288000, 48000, 256, 0x0, 0x0, 0x0},
+        {18432000, 48000, 384, 0x0, 0x1, 0x0},
+        {12000000, 48000, 250, 0x0, 0x0, 0x1},
+
+        /* 32k */
+        {12288000, 32000, 384, 0x6, 0x0, 0x0},
+        {18432000, 32000, 576, 0x6, 0x1, 0x0},
+        {12000000, 32000, 375, 0x6, 0x0, 0x1},
+
+        /* 8k */
+        {12288000, 8000, 1536, 0x3, 0x0, 0x0},
+        {18432000, 8000, 2304, 0x3, 0x1, 0x0},
+        {11289600, 8000, 1408, 0xb, 0x0, 0x0},
+        {16934400, 8000, 2112, 0xb, 0x1, 0x0},
+        {12000000, 8000, 1500, 0x3, 0x0, 0x1},
+
+        /* 96k */
+        {12288000, 96000, 128, 0x7, 0x0, 0x0},
+        {18432000, 96000, 192, 0x7, 0x1, 0x0},
+        {12000000, 96000, 125, 0x7, 0x0, 0x1},
+
+        /* 44.1k */
+        {11289600, 44100, 256, 0x8, 0x0, 0x0},
+        {16934400, 44100, 384, 0x8, 0x1, 0x0},
+        {12000000, 44100, 272, 0x8, 0x1, 0x1},
+
+        /* 88.2k */
+        {11289600, 88200, 128, 0xf, 0x0, 0x0},
+        {16934400, 88200, 192, 0xf, 0x1, 0x0},
+        {12000000, 88200, 136, 0xf, 0x1, 0x1},
+};
+
+static inline int get_coeff(int mclk, int rate)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(coeff_div); i++) {
+                if (coeff_div[i].rate == rate && coeff_div[i].mclk == mclk)
+                        return i;
+        }
+        return 0;
+}
+
+static int wm8711_hw_params(struct snd_pcm_substream *substream,
+        struct snd_pcm_hw_params *params,
+        struct snd_soc_dai *dai)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        struct wm8711_priv *wm8711 = codec->private_data;
+        u16 iface = snd_soc_read(codec, WM8711_IFACE) & 0xfffc;
+        int i = get_coeff(wm8711->sysclk, params_rate(params));
+        u16 srate = (coeff_div[i].sr << 2) |
+                (coeff_div[i].bosr << 1) | coeff_div[i].usb;
+
+        snd_soc_write(codec, WM8711_SRATE, srate);
+
+        /* bit size */
+        switch (params_format(params)) {
+        case SNDRV_PCM_FORMAT_S16_LE:
+                break;
+        case SNDRV_PCM_FORMAT_S20_3LE:
+                iface |= 0x0004;
+                break;
+        case SNDRV_PCM_FORMAT_S24_LE:
+                iface |= 0x0008;
+                break;
+        }
+
+        snd_soc_write(codec, WM8711_IFACE, iface);
+        return 0;
+}
+
+static int wm8711_pcm_prepare(struct snd_pcm_substream *substream,
+                              struct snd_soc_dai *dai)
+{
+        struct snd_soc_codec *codec = dai->codec;
+
+        /* set active */
+        snd_soc_write(codec, WM8711_ACTIVE, 0x0001);
+
+        return 0;
+}
+
+static void wm8711_shutdown(struct snd_pcm_substream *substream,
+                            struct snd_soc_dai *dai)
+{
+        struct snd_soc_codec *codec = dai->codec;
+
+        /* deactivate */
+        if (!codec->active) {
+                udelay(50);
+                snd_soc_write(codec, WM8711_ACTIVE, 0x0);
+        }
+}
+
+static int wm8711_mute(struct snd_soc_dai *dai, int mute)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        u16 mute_reg = snd_soc_read(codec, WM8711_APDIGI) & 0xfff7;
+
+        if (mute)
+                snd_soc_write(codec, WM8711_APDIGI, mute_reg | 0x8);
+        else
+                snd_soc_write(codec, WM8711_APDIGI, mute_reg);
+
+        return 0;
+}
+
+static int wm8711_set_dai_sysclk(struct snd_soc_dai *codec_dai,
+                int clk_id, unsigned int freq, int dir)
+{
+        struct snd_soc_codec *codec = codec_dai->codec;
+        struct wm8711_priv *wm8711 = codec->private_data;
+
+        switch (freq) {
+        case 11289600:
+        case 12000000:
+        case 12288000:
+        case 16934400:
+        case 18432000:
+                wm8711->sysclk = freq;
+                return 0;
+        }
+        return -EINVAL;
+}
+
+static int wm8711_set_dai_fmt(struct snd_soc_dai *codec_dai,
+                unsigned int fmt)
+{
+        struct snd_soc_codec *codec = codec_dai->codec;
+        u16 iface = 0;
+
+        /* set master/slave audio interface */
+        switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
+        case SND_SOC_DAIFMT_CBM_CFM:
+                iface |= 0x0040;
+                break;
+        case SND_SOC_DAIFMT_CBS_CFS:
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        /* interface format */
+        switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
+        case SND_SOC_DAIFMT_I2S:
+                iface |= 0x0002;
+                break;
+        case SND_SOC_DAIFMT_RIGHT_J:
+                break;
+        case SND_SOC_DAIFMT_LEFT_J:
+                iface |= 0x0001;
+                break;
+        case SND_SOC_DAIFMT_DSP_A:
+                iface |= 0x0003;
+                break;
+        case SND_SOC_DAIFMT_DSP_B:
+                iface |= 0x0013;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        /* clock inversion */
+        switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
+        case SND_SOC_DAIFMT_NB_NF:
+                break;
+        case SND_SOC_DAIFMT_IB_IF:
+                iface |= 0x0090;
+                break;
+        case SND_SOC_DAIFMT_IB_NF:
+                iface |= 0x0080;
+                break;
+        case SND_SOC_DAIFMT_NB_IF:
+                iface |= 0x0010;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        /* set iface */
+        snd_soc_write(codec, WM8711_IFACE, iface);
+        return 0;
+}
+
+
+static int wm8711_set_bias_level(struct snd_soc_codec *codec,
+        enum snd_soc_bias_level level)
+{
+        u16 reg = snd_soc_read(codec, WM8711_PWR) & 0xff7f;
+
+        switch (level) {
+        case SND_SOC_BIAS_ON:
+                snd_soc_write(codec, WM8711_PWR, reg);
+                break;
+        case SND_SOC_BIAS_PREPARE:
+                break;
+        case SND_SOC_BIAS_STANDBY:
+                snd_soc_write(codec, WM8711_PWR, reg | 0x0040);
+                break;
+        case SND_SOC_BIAS_OFF:
+                snd_soc_write(codec, WM8711_ACTIVE, 0x0);
+                snd_soc_write(codec, WM8711_PWR, 0xffff);
+                break;
+        }
+        codec->bias_level = level;
+        return 0;
+}
+
+#define WM8711_RATES SNDRV_PCM_RATE_8000_96000
+
+#define WM8711_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
+        SNDRV_PCM_FMTBIT_S24_LE)
+
+static struct snd_soc_dai_ops wm8711_ops = {
+        .prepare = wm8711_pcm_prepare,
+        .hw_params = wm8711_hw_params,
+        .shutdown = wm8711_shutdown,
+        .digital_mute = wm8711_mute,
+        .set_sysclk = wm8711_set_dai_sysclk,
+        .set_fmt = wm8711_set_dai_fmt,
+};
+
+struct snd_soc_dai wm8711_dai = {
+        .name = "WM8711",
+        .playback = {
+                .stream_name = "Playback",
+                .channels_min = 1,
+                .channels_max = 2,
+                .rates = WM8711_RATES,
+                .formats = WM8711_FORMATS,
+        },
+        .ops = &wm8711_ops,
+};
+EXPORT_SYMBOL_GPL(wm8711_dai);
+
+static int wm8711_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec = socdev->card->codec;
+
+        snd_soc_write(codec, WM8711_ACTIVE, 0x0);
+        wm8711_set_bias_level(codec, SND_SOC_BIAS_OFF);
+        return 0;
+}
+
+static int wm8711_resume(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec = socdev->card->codec;
+        int i;
+        u8 data[2];
+        u16 *cache = codec->reg_cache;
+
+        /* Sync reg_cache with the hardware */
+        for (i = 0; i < ARRAY_SIZE(wm8711_reg); i++) {
+                data[0] = (i << 1) | ((cache[i] >> 8) & 0x0001);
+                data[1] = cache[i] & 0x00ff;
+                codec->hw_write(codec->control_data, data, 2);
+        }
+        wm8711_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+        wm8711_set_bias_level(codec, codec->suspend_bias_level);
+        return 0;
+}
+
+static int wm8711_probe(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec;
+        int ret = 0;
+
+        if (wm8711_codec == NULL) {
+                dev_err(&pdev->dev, "Codec device not registered\n");
+                return -ENODEV;
+        }
+
+        socdev->card->codec = wm8711_codec;
+        codec = wm8711_codec;
+
+        /* register pcms */
+        ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
+        if (ret < 0) {
+                dev_err(codec->dev, "failed to create pcms: %d\n", ret);
+                goto pcm_err;
+        }
+
+        snd_soc_add_controls(codec, wm8711_snd_controls,
+                             ARRAY_SIZE(wm8711_snd_controls));
+        wm8711_add_widgets(codec);
+
+        return ret;
+
+pcm_err:
+        return ret;
+}
+
+/* power down chip */
+static int wm8711_remove(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+
+        snd_soc_free_pcms(socdev);
+        snd_soc_dapm_free(socdev);
+
+        return 0;
+}
+
+struct snd_soc_codec_device soc_codec_dev_wm8711 = {
+        .probe =        wm8711_probe,
+        .remove =       wm8711_remove,
+        .suspend =      wm8711_suspend,
+        .resume =       wm8711_resume,
+};
+EXPORT_SYMBOL_GPL(soc_codec_dev_wm8711);
+
+static int wm8711_register(struct wm8711_priv *wm8711,
+                           enum snd_soc_control_type control)
+{
+        int ret;
+        struct snd_soc_codec *codec = &wm8711->codec;
+        u16 reg;
+
+        if (wm8711_codec) {
+                dev_err(codec->dev, "Another WM8711 is registered\n");
+                return -EINVAL;
+        }
+
+        mutex_init(&codec->mutex);
+        INIT_LIST_HEAD(&codec->dapm_widgets);
+        INIT_LIST_HEAD(&codec->dapm_paths);
+
+        codec->private_data = wm8711;
+        codec->name = "WM8711";
+        codec->owner = THIS_MODULE;
+        codec->bias_level = SND_SOC_BIAS_OFF;
+        codec->set_bias_level = wm8711_set_bias_level;
+        codec->dai = &wm8711_dai;
+        codec->num_dai = 1;
+        codec->reg_cache_size = WM8711_CACHEREGNUM;
+        codec->reg_cache = &wm8711->reg_cache;
+
+        memcpy(codec->reg_cache, wm8711_reg, sizeof(wm8711_reg));
+
+        ret = snd_soc_codec_set_cache_io(codec, 7, 9, control);
+        if (ret < 0) {
+                dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
+                goto err;
+        }
+
+        ret = wm8711_reset(codec);
+        if (ret < 0) {
+                dev_err(codec->dev, "Failed to issue reset\n");
+                goto err;
+        }
+
+        wm8711_dai.dev = codec->dev;
+
+        wm8711_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+
+        /* Latch the update bits */
+        reg = snd_soc_read(codec, WM8711_LOUT1V);
+        snd_soc_write(codec, WM8711_LOUT1V, reg | 0x0100);
+        reg = snd_soc_read(codec, WM8711_ROUT1V);
+        snd_soc_write(codec, WM8711_ROUT1V, reg | 0x0100);
+
+        wm8711_codec = codec;
+
+        ret = snd_soc_register_codec(codec);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to register codec: %d\n", ret);
+                goto err;
+        }
+
+        ret = snd_soc_register_dai(&wm8711_dai);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to register DAI: %d\n", ret);
+                goto err_codec;
+        }
+
+        return 0;
+
+err_codec:
+        snd_soc_unregister_codec(codec);
+err:
+        kfree(wm8711);
+        return ret;
+}
+
+static void wm8711_unregister(struct wm8711_priv *wm8711)
+{
+        wm8711_set_bias_level(&wm8711->codec, SND_SOC_BIAS_OFF);
+        snd_soc_unregister_dai(&wm8711_dai);
+        snd_soc_unregister_codec(&wm8711->codec);
+        kfree(wm8711);
+        wm8711_codec = NULL;
+}
+
+#if defined(CONFIG_SPI_MASTER)
+static int __devinit wm8711_spi_probe(struct spi_device *spi)
+{
+        struct snd_soc_codec *codec;
+        struct wm8711_priv *wm8711;
+
+        wm8711 = kzalloc(sizeof(struct wm8711_priv), GFP_KERNEL);
+        if (wm8711 == NULL)
+                return -ENOMEM;
+
+        codec = &wm8711->codec;
+        codec->control_data = spi;
+        codec->dev = &spi->dev;
+
+        dev_set_drvdata(&spi->dev, wm8711);
+
+        return wm8711_register(wm8711, SND_SOC_SPI);
+}
+
+static int __devexit wm8711_spi_remove(struct spi_device *spi)
+{
+        struct wm8711_priv *wm8711 = dev_get_drvdata(&spi->dev);
+
+        wm8711_unregister(wm8711);
+
+        return 0;
+}
+
+static struct spi_driver wm8711_spi_driver = {
+        .driver = {
+                .name   = "wm8711",
+                .bus    = &spi_bus_type,
+                .owner  = THIS_MODULE,
+        },
+        .probe          = wm8711_spi_probe,
+        .remove         = __devexit_p(wm8711_spi_remove),
+};
+#endif /* CONFIG_SPI_MASTER */
+
+#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+static __devinit int wm8711_i2c_probe(struct i2c_client *i2c,
+                                      const struct i2c_device_id *id)
+{
+        struct wm8711_priv *wm8711;
+        struct snd_soc_codec *codec;
+
+        wm8711 = kzalloc(sizeof(struct wm8711_priv), GFP_KERNEL);
+        if (wm8711 == NULL)
+                return -ENOMEM;
+
+        codec = &wm8711->codec;
+        codec->hw_write = (hw_write_t)i2c_master_send;
+
+        i2c_set_clientdata(i2c, wm8711);
+        codec->control_data = i2c;
+
+        codec->dev = &i2c->dev;
+
+        return wm8711_register(wm8711, SND_SOC_I2C);
+}
+
+static __devexit int wm8711_i2c_remove(struct i2c_client *client)
+{
+        struct wm8711_priv *wm8711 = i2c_get_clientdata(client);
+        wm8711_unregister(wm8711);
+        return 0;
+}
+
+static const struct i2c_device_id wm8711_i2c_id[] = {
+        { "wm8711", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, wm8711_i2c_id);
+
+static struct i2c_driver wm8711_i2c_driver = {
+        .driver = {
+                .name = "WM8711 I2C Codec",
+                .owner = THIS_MODULE,
+        },
+        .probe =    wm8711_i2c_probe,
+        .remove =   __devexit_p(wm8711_i2c_remove),
+        .id_table = wm8711_i2c_id,
+};
+#endif
+
+static int __init wm8711_modinit(void)
+{
+        int ret;
+#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+        ret = i2c_add_driver(&wm8711_i2c_driver);
+        if (ret != 0) {
+                printk(KERN_ERR "Failed to register WM8711 I2C driver: %d\n",
+                       ret);
+        }
+#endif
+#if defined(CONFIG_SPI_MASTER)
+        ret = spi_register_driver(&wm8711_spi_driver);
+        if (ret != 0) {
+                printk(KERN_ERR "Failed to register WM8711 SPI driver: %d\n",
+                       ret);
+        }
+#endif
+        return 0;
+}
+module_init(wm8711_modinit);
+
+static void __exit wm8711_exit(void)
+{
+#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+        i2c_del_driver(&wm8711_i2c_driver);
+#endif
+#if defined(CONFIG_SPI_MASTER)
+        spi_unregister_driver(&wm8711_spi_driver);
+#endif
+}
+module_exit(wm8711_exit);
+
+MODULE_DESCRIPTION("ASoC WM8711 driver");
+MODULE_AUTHOR("Mike Arthur");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/codecs/wm8711.h b/sound/soc/codecs/wm8711.h
new file mode 100644
index 000000000000..381e84a43816
--- /dev/null
+++ b/sound/soc/codecs/wm8711.h
@@ -0,0 +1,42 @@
+/*
+ * wm8711.h  --  WM8711 Soc Audio driver
+ *
+ * Copyright 2006 Wolfson Microelectronics
+ *
+ * Author: Mike Arthur <linux@wolfsonmicro.com>
+ *
+ * Based on wm8731.h
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef _WM8711_H
+#define _WM8711_H
+
+/* WM8711 register space */
+
+#define WM8711_LOUT1V   0x02
+#define WM8711_ROUT1V   0x03
+#define WM8711_APANA    0x04
+#define WM8711_APDIGI   0x05
+#define WM8711_PWR      0x06
+#define WM8711_IFACE    0x07
+#define WM8711_SRATE    0x08
+#define WM8711_ACTIVE   0x09
+#define WM8711_RESET    0x0f
+
+#define WM8711_CACHEREGNUM      8
+
+#define WM8711_SYSCLK   0
+#define WM8711_DAI              0
+
+struct wm8711_setup_data {
+        unsigned short i2c_address;
+};
+
+extern struct snd_soc_dai wm8711_dai;
+extern struct snd_soc_codec_device soc_codec_dev_wm8711;
+
+#endif
diff --git a/sound/soc/codecs/wm8727.c b/sound/soc/codecs/wm8727.c
new file mode 100644
index 000000000000..1072621e93fd
--- /dev/null
+++ b/sound/soc/codecs/wm8727.c
@@ -0,0 +1,168 @@
+/*
+ * wm8727.c
+ *
+ *  Created on: 15-Oct-2009
+ *      Author: neil.jones@imgtec.com
+ *
+ * Copyright (C) 2009 Imagination Technologies Ltd.
+ *
+ *  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 the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ */
+
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/device.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/ac97_codec.h>
+#include <sound/initval.h>
+#include <sound/soc.h>
+
+#include "wm8727.h"
+/*
+ * Note this is a simple chip with no configuration interface, sample rate is
+ * determined automatically by examining the Master clock and Bit clock ratios
+ */
+#define WM8727_RATES  (SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 |\
+                        SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_96000 |\
+                        SNDRV_PCM_RATE_192000)
+
+
+struct snd_soc_dai wm8727_dai = {
+        .name = "WM8727",
+        .playback = {
+                .stream_name = "Playback",
+                .channels_min = 2,
+                .channels_max = 2,
+                .rates = WM8727_RATES,
+                .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE,
+                },
+};
+EXPORT_SYMBOL_GPL(wm8727_dai);
+
+static struct snd_soc_codec *wm8727_codec;
+
+static int wm8727_soc_probe(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        int ret = 0;
+
+        BUG_ON(!wm8727_codec);
+
+        socdev->card->codec = wm8727_codec;
+
+        /* register pcms */
+        ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
+        if (ret < 0) {
+                printk(KERN_ERR "wm8727: failed to create pcms\n");
+                goto pcm_err;
+        }
+
+        return ret;
+
+pcm_err:
+        kfree(socdev->card->codec);
+        socdev->card->codec = NULL;
+        return ret;
+}
+
+static int wm8727_soc_remove(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+
+        snd_soc_free_pcms(socdev);
+
+        return 0;
+}
+
+struct snd_soc_codec_device soc_codec_dev_wm8727 = {
+        .probe =        wm8727_soc_probe,
+        .remove =       wm8727_soc_remove,
+};
+EXPORT_SYMBOL_GPL(soc_codec_dev_wm8727);
+
+
+static __devinit int wm8727_platform_probe(struct platform_device *pdev)
+{
+        struct snd_soc_codec *codec;
+        int ret;
+
+        if (wm8727_codec) {
+                dev_err(&pdev->dev, "Another WM8727 is registered\n");
+                return -EBUSY;
+        }
+
+        codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
+        if (codec == NULL)
+                return -ENOMEM;
+        wm8727_codec = codec;
+
+        platform_set_drvdata(pdev, codec);
+
+        mutex_init(&codec->mutex);
+        codec->dev = &pdev->dev;
+        codec->name = "WM8727";
+        codec->owner = THIS_MODULE;
+        codec->dai = &wm8727_dai;
+        codec->num_dai = 1;
+        INIT_LIST_HEAD(&codec->dapm_widgets);
+        INIT_LIST_HEAD(&codec->dapm_paths);
+
+        wm8727_dai.dev = &pdev->dev;
+
+        ret = snd_soc_register_codec(codec);
+        if (ret != 0) {
+                dev_err(&pdev->dev, "Failed to register CODEC: %d\n", ret);
+                goto err;
+        }
+
+        ret = snd_soc_register_dai(&wm8727_dai);
+        if (ret != 0) {
+                dev_err(&pdev->dev, "Failed to register DAI: %d\n", ret);
+                goto err_codec;
+        }
+
+err_codec:
+        snd_soc_unregister_codec(codec);
+err:
+        kfree(codec);
+        return ret;
+}
+
+static int __devexit wm8727_platform_remove(struct platform_device *pdev)
+{
+        snd_soc_unregister_dai(&wm8727_dai);
+        snd_soc_unregister_codec(platform_get_drvdata(pdev));
+        return 0;
+}
+
+static struct platform_driver wm8727_codec_driver = {
+        .driver = {
+                        .name = "wm8727-codec",
+                        .owner = THIS_MODULE,
+        },
+
+        .probe = wm8727_platform_probe,
+        .remove = __devexit_p(wm8727_platform_remove),
+};
+
+static int __init wm8727_init(void)
+{
+        return platform_driver_register(&wm8727_codec_driver);
+}
+module_init(wm8727_init);
+
+static void __exit wm8727_exit(void)
+{
+        platform_driver_unregister(&wm8727_codec_driver);
+}
+module_exit(wm8727_exit);
+
+MODULE_DESCRIPTION("ASoC wm8727 driver");
+MODULE_AUTHOR("Neil Jones");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/codecs/wm8727.h b/sound/soc/codecs/wm8727.h
new file mode 100644
index 000000000000..ee19aa71bcdc
--- /dev/null
+++ b/sound/soc/codecs/wm8727.h
@@ -0,0 +1,21 @@
+/*
+ * wm8727.h
+ *
+ *  Created on: 15-Oct-2009
+ *      Author: neil.jones@imgtec.com
+ *
+ * Copyright (C) 2009 Imagination Technologies Ltd.
+ *
+ *  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 the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ */
+
+#ifndef WM8727_H_
+#define WM8727_H_
+
+extern struct snd_soc_dai wm8727_dai;
+extern struct snd_soc_codec_device soc_codec_dev_wm8727;
+
+#endif /* WM8727_H_ */
diff --git a/sound/soc/codecs/wm8728.c b/sound/soc/codecs/wm8728.c
index 16e969a762c3..07adc375a706 100644
--- a/sound/soc/codecs/wm8728.c
+++ b/sound/soc/codecs/wm8728.c
@@ -18,6 +18,7 @@
 #include <linux/i2c.h>
 #include <linux/platform_device.h>
 #include <linux/spi/spi.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
@@ -74,8 +75,6 @@ static int wm8728_add_widgets(struct snd_soc_codec *codec)
 
         snd_soc_dapm_add_routes(codec, intercon, ARRAY_SIZE(intercon));
 
-        snd_soc_dapm_new_widgets(codec);
-
         return 0;
 }
 
@@ -287,17 +286,9 @@ static int wm8728_init(struct snd_soc_device *socdev,
         snd_soc_add_controls(codec, wm8728_snd_controls,
                                 ARRAY_SIZE(wm8728_snd_controls));
         wm8728_add_widgets(codec);
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                printk(KERN_ERR "wm8728: failed to register card\n");
-                goto card_err;
-        }
 
         return ret;
 
-card_err:
-        snd_soc_free_pcms(socdev);
-        snd_soc_dapm_free(socdev);
 err:
         kfree(codec->reg_cache);
         return ret;
diff --git a/sound/soc/codecs/wm8731.c b/sound/soc/codecs/wm8731.c
index d3fd4f28d96e..e7c6bf163185 100644
--- a/sound/soc/codecs/wm8731.c
+++ b/sound/soc/codecs/wm8731.c
@@ -18,7 +18,9 @@
 #include <linux/delay.h>
 #include <linux/pm.h>
 #include <linux/i2c.h>
+#include <linux/slab.h>
 #include <linux/platform_device.h>
+#include <linux/regulator/consumer.h>
 #include <linux/spi/spi.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
@@ -33,9 +35,18 @@
 static struct snd_soc_codec *wm8731_codec;
 struct snd_soc_codec_device soc_codec_dev_wm8731;
 
+#define WM8731_NUM_SUPPLIES 4
+static const char *wm8731_supply_names[WM8731_NUM_SUPPLIES] = {
+        "AVDD",
+        "HPVDD",
+        "DCVDD",
+        "DBVDD",
+};
+
 /* codec private data */
 struct wm8731_priv {
         struct snd_soc_codec codec;
+        struct regulator_bulk_data supplies[WM8731_NUM_SUPPLIES];
         u16 reg_cache[WM8731_CACHEREGNUM];
         unsigned int sysclk;
 };
@@ -149,7 +160,6 @@ static int wm8731_add_widgets(struct snd_soc_codec *codec)
 
         snd_soc_dapm_add_routes(codec, intercon, ARRAY_SIZE(intercon));
 
-        snd_soc_dapm_new_widgets(codec);
         return 0;
 }
 
@@ -422,9 +432,12 @@ static int wm8731_suspend(struct platform_device *pdev, pm_message_t state)
 {
         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
         struct snd_soc_codec *codec = socdev->card->codec;
+        struct wm8731_priv *wm8731 = codec->private_data;
 
         snd_soc_write(codec, WM8731_ACTIVE, 0x0);
         wm8731_set_bias_level(codec, SND_SOC_BIAS_OFF);
+        regulator_bulk_disable(ARRAY_SIZE(wm8731->supplies),
+                               wm8731->supplies);
         return 0;
 }
 
@@ -432,18 +445,28 @@ static int wm8731_resume(struct platform_device *pdev)
 {
         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
         struct snd_soc_codec *codec = socdev->card->codec;
-        int i;
+        struct wm8731_priv *wm8731 = codec->private_data;
+        int i, ret;
         u8 data[2];
         u16 *cache = codec->reg_cache;
 
+        ret = regulator_bulk_enable(ARRAY_SIZE(wm8731->supplies),
+                                    wm8731->supplies);
+        if (ret != 0)
+                return ret;
+
         /* Sync reg_cache with the hardware */
         for (i = 0; i < ARRAY_SIZE(wm8731_reg); i++) {
+                if (cache[i] == wm8731_reg[i])
+                        continue;
+
                 data[0] = (i << 1) | ((cache[i] >> 8) & 0x0001);
                 data[1] = cache[i] & 0x00ff;
                 codec->hw_write(codec->control_data, data, 2);
         }
         wm8731_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
         wm8731_set_bias_level(codec, codec->suspend_bias_level);
+
         return 0;
 }
 #else
@@ -475,17 +498,9 @@ static int wm8731_probe(struct platform_device *pdev)
         snd_soc_add_controls(codec, wm8731_snd_controls,
                              ARRAY_SIZE(wm8731_snd_controls));
         wm8731_add_widgets(codec);
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                dev_err(codec->dev, "failed to register card: %d\n", ret);
-                goto card_err;
-        }
 
         return ret;
 
-card_err:
-        snd_soc_free_pcms(socdev);
-        snd_soc_dapm_free(socdev);
 pcm_err:
         return ret;
 }
@@ -512,7 +527,7 @@ EXPORT_SYMBOL_GPL(soc_codec_dev_wm8731);
 static int wm8731_register(struct wm8731_priv *wm8731,
                            enum snd_soc_control_type control)
 {
-        int ret;
+        int ret, i;
         struct snd_soc_codec *codec = &wm8731->codec;
 
         if (wm8731_codec) {
@@ -543,10 +558,27 @@ static int wm8731_register(struct wm8731_priv *wm8731,
                 goto err;
         }
 
+        for (i = 0; i < ARRAY_SIZE(wm8731->supplies); i++)
+                wm8731->supplies[i].supply = wm8731_supply_names[i];
+
+        ret = regulator_bulk_get(codec->dev, ARRAY_SIZE(wm8731->supplies),
+                                 wm8731->supplies);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to request supplies: %d\n", ret);
+                goto err;
+        }
+
+        ret = regulator_bulk_enable(ARRAY_SIZE(wm8731->supplies),
+                                    wm8731->supplies);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to enable supplies: %d\n", ret);
+                goto err_regulator_get;
+        }
+
         ret = wm8731_reset(codec);
         if (ret < 0) {
                 dev_err(codec->dev, "Failed to issue reset: %d\n", ret);
-                goto err;
+                goto err_regulator_enable;
         }
 
         wm8731_dai.dev = codec->dev;
@@ -567,7 +599,7 @@ static int wm8731_register(struct wm8731_priv *wm8731,
         ret = snd_soc_register_codec(codec);
         if (ret != 0) {
                 dev_err(codec->dev, "Failed to register codec: %d\n", ret);
-                goto err;
+                goto err_regulator_enable;
         }
 
         ret = snd_soc_register_dai(&wm8731_dai);
@@ -581,6 +613,10 @@ static int wm8731_register(struct wm8731_priv *wm8731,
 
 err_codec:
         snd_soc_unregister_codec(codec);
+err_regulator_enable:
+        regulator_bulk_disable(ARRAY_SIZE(wm8731->supplies), wm8731->supplies);
+err_regulator_get:
+        regulator_bulk_free(ARRAY_SIZE(wm8731->supplies), wm8731->supplies);
 err:
         kfree(wm8731);
         return ret;
@@ -591,6 +627,8 @@ static void wm8731_unregister(struct wm8731_priv *wm8731)
         wm8731_set_bias_level(&wm8731->codec, SND_SOC_BIAS_OFF);
         snd_soc_unregister_dai(&wm8731_dai);
         snd_soc_unregister_codec(&wm8731->codec);
+        regulator_bulk_disable(ARRAY_SIZE(wm8731->supplies), wm8731->supplies);
+        regulator_bulk_free(ARRAY_SIZE(wm8731->supplies), wm8731->supplies);
         kfree(wm8731);
         wm8731_codec = NULL;
 }
@@ -623,21 +661,6 @@ static int __devexit wm8731_spi_remove(struct spi_device *spi)
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int wm8731_spi_suspend(struct spi_device *spi, pm_message_t msg)
-{
-        return snd_soc_suspend_device(&spi->dev);
-}
-
-static int wm8731_spi_resume(struct spi_device *spi)
-{
-        return snd_soc_resume_device(&spi->dev);
-}
-#else
-#define wm8731_spi_suspend NULL
-#define wm8731_spi_resume NULL
-#endif
-
 static struct spi_driver wm8731_spi_driver = {
         .driver = {
                 .name   = "wm8731",
@@ -645,8 +668,6 @@ static struct spi_driver wm8731_spi_driver = {
                 .owner  = THIS_MODULE,
         },
         .probe          = wm8731_spi_probe,
-        .suspend        = wm8731_spi_suspend,
-        .resume         = wm8731_spi_resume,
         .remove         = __devexit_p(wm8731_spi_remove),
 };
 #endif /* CONFIG_SPI_MASTER */
@@ -679,21 +700,6 @@ static __devexit int wm8731_i2c_remove(struct i2c_client *client)
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int wm8731_i2c_suspend(struct i2c_client *i2c, pm_message_t msg)
-{
-        return snd_soc_suspend_device(&i2c->dev);
-}
-
-static int wm8731_i2c_resume(struct i2c_client *i2c)
-{
-        return snd_soc_resume_device(&i2c->dev);
-}
-#else
-#define wm8731_i2c_suspend NULL
-#define wm8731_i2c_resume NULL
-#endif
-
 static const struct i2c_device_id wm8731_i2c_id[] = {
         { "wm8731", 0 },
         { }
@@ -707,8 +713,6 @@ static struct i2c_driver wm8731_i2c_driver = {
         },
         .probe =    wm8731_i2c_probe,
         .remove =   __devexit_p(wm8731_i2c_remove),
-        .suspend =  wm8731_i2c_suspend,
-        .resume =   wm8731_i2c_resume,
         .id_table = wm8731_i2c_id,
 };
 #endif
diff --git a/sound/soc/codecs/wm8750.c b/sound/soc/codecs/wm8750.c
index 4ba1e7e93fb4..2916ed4d3844 100644
--- a/sound/soc/codecs/wm8750.c
+++ b/sound/soc/codecs/wm8750.c
@@ -20,6 +20,7 @@
 #include <linux/i2c.h>
 #include <linux/platform_device.h>
 #include <linux/spi/spi.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
@@ -403,7 +404,6 @@ static int wm8750_add_widgets(struct snd_soc_codec *codec)
 
         snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
 
-        snd_soc_dapm_new_widgets(codec);
         return 0;
 }
 
@@ -772,16 +772,8 @@ static int wm8750_init(struct snd_soc_device *socdev,
         snd_soc_add_controls(codec, wm8750_snd_controls,
                                 ARRAY_SIZE(wm8750_snd_controls));
         wm8750_add_widgets(codec);
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                printk(KERN_ERR "wm8750: failed to register card\n");
-                goto card_err;
-        }
         return ret;
 
-card_err:
-        snd_soc_free_pcms(socdev);
-        snd_soc_dapm_free(socdev);
 err:
         kfree(codec->reg_cache);
         return ret;
diff --git a/sound/soc/codecs/wm8753.c b/sound/soc/codecs/wm8753.c
index 5ad677ce80da..613199a0f799 100644
--- a/sound/soc/codecs/wm8753.c
+++ b/sound/soc/codecs/wm8753.c
@@ -40,6 +40,7 @@
 #include <linux/i2c.h>
 #include <linux/platform_device.h>
 #include <linux/spi/spi.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
@@ -673,7 +674,6 @@ static int wm8753_add_widgets(struct snd_soc_codec *codec)
 
         snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
 
-        snd_soc_dapm_new_widgets(codec);
         return 0;
 }
 
@@ -724,8 +724,8 @@ static void pll_factors(struct _pll_div *pll_div, unsigned int target,
         pll_div->k = K;
 }
 
-static int wm8753_set_dai_pll(struct snd_soc_dai *codec_dai,
-                int pll_id, unsigned int freq_in, unsigned int freq_out)
+static int wm8753_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id,
+                int source, unsigned int freq_in, unsigned int freq_out)
 {
         u16 reg, enable;
         int offset;
@@ -1508,10 +1508,6 @@ static int wm8753_suspend(struct platform_device *pdev, pm_message_t state)
         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
         struct snd_soc_codec *codec = socdev->card->codec;
 
-        /* we only need to suspend if we are a valid card */
-        if (!codec->card)
-                return 0;
-
         wm8753_set_bias_level(codec, SND_SOC_BIAS_OFF);
         return 0;
 }
@@ -1524,10 +1520,6 @@ static int wm8753_resume(struct platform_device *pdev)
         u8 data[2];
         u16 *cache = codec->reg_cache;
 
-        /* we only need to resume if we are a valid card */
-        if (!codec->card)
-                return 0;
-
         /* Sync reg_cache with the hardware */
         for (i = 0; i < ARRAY_SIZE(wm8753_reg); i++) {
                 if (i + 1 == WM8753_RESET)
@@ -1583,18 +1575,9 @@ static int wm8753_probe(struct platform_device *pdev)
         snd_soc_add_controls(codec, wm8753_snd_controls,
                              ARRAY_SIZE(wm8753_snd_controls));
         wm8753_add_widgets(codec);
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                printk(KERN_ERR "wm8753: failed to register card\n");
-                goto card_err;
-        }
 
         return 0;
 
-card_err:
-        snd_soc_free_pcms(socdev);
-        snd_soc_dapm_free(socdev);
-
 pcm_err:
         return ret;
 }
@@ -1767,21 +1750,6 @@ static int wm8753_i2c_remove(struct i2c_client *client)
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int wm8753_i2c_suspend(struct i2c_client *client, pm_message_t msg)
-{
-        return snd_soc_suspend_device(&client->dev);
-}
-
-static int wm8753_i2c_resume(struct i2c_client *client)
-{
-        return snd_soc_resume_device(&client->dev);
-}
-#else
-#define wm8753_i2c_suspend NULL
-#define wm8753_i2c_resume NULL
-#endif
-
 static const struct i2c_device_id wm8753_i2c_id[] = {
         { "wm8753", 0 },
         { }
@@ -1795,8 +1763,6 @@ static struct i2c_driver wm8753_i2c_driver = {
         },
         .probe =    wm8753_i2c_probe,
         .remove =   wm8753_i2c_remove,
-        .suspend =  wm8753_i2c_suspend,
-        .resume =   wm8753_i2c_resume,
         .id_table = wm8753_i2c_id,
 };
 #endif
@@ -1852,22 +1818,6 @@ static int __devexit wm8753_spi_remove(struct spi_device *spi)
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int wm8753_spi_suspend(struct spi_device *spi, pm_message_t msg)
-{
-        return snd_soc_suspend_device(&spi->dev);
-}
-
-static int wm8753_spi_resume(struct spi_device *spi)
-{
-        return snd_soc_resume_device(&spi->dev);
-}
-
-#else
-#define wm8753_spi_suspend NULL
-#define wm8753_spi_resume NULL
-#endif
-
 static struct spi_driver wm8753_spi_driver = {
         .driver = {
                 .name   = "wm8753",
@@ -1876,8 +1826,6 @@ static struct spi_driver wm8753_spi_driver = {
         },
         .probe          = wm8753_spi_probe,
         .remove         = __devexit_p(wm8753_spi_remove),
-        .suspend        = wm8753_spi_suspend,
-        .resume         = wm8753_spi_resume,
 };
 #endif
 
diff --git a/sound/soc/codecs/wm8776.c b/sound/soc/codecs/wm8776.c
index a9829aa26e53..60b1b3e1094b 100644
--- a/sound/soc/codecs/wm8776.c
+++ b/sound/soc/codecs/wm8776.c
@@ -20,6 +20,7 @@
 #include <linux/i2c.h>
 #include <linux/platform_device.h>
 #include <linux/spi/spi.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
@@ -406,6 +407,8 @@ static int wm8776_resume(struct platform_device *pdev)
 
         /* Sync reg_cache with the hardware */
         for (i = 0; i < ARRAY_SIZE(wm8776_reg); i++) {
+                if (cache[i] == wm8776_reg[i])
+                        continue;
                 data[0] = (i << 1) | ((cache[i] >> 8) & 0x0001);
                 data[1] = cache[i] & 0x00ff;
                 codec->hw_write(codec->control_data, data, 2);
@@ -447,17 +450,8 @@ static int wm8776_probe(struct platform_device *pdev)
                                   ARRAY_SIZE(wm8776_dapm_widgets));
         snd_soc_dapm_add_routes(codec, routes, ARRAY_SIZE(routes));
 
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                dev_err(codec->dev, "failed to register card: %d\n", ret);
-                goto card_err;
-        }
-
         return ret;
 
-card_err:
-        snd_soc_free_pcms(socdev);
-        snd_soc_dapm_free(socdev);
 pcm_err:
         return ret;
 }
@@ -616,21 +610,6 @@ static int __devexit wm8776_spi_remove(struct spi_device *spi)
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int wm8776_spi_suspend(struct spi_device *spi, pm_message_t msg)
-{
-        return snd_soc_suspend_device(&spi->dev);
-}
-
-static int wm8776_spi_resume(struct spi_device *spi)
-{
-        return snd_soc_resume_device(&spi->dev);
-}
-#else
-#define wm8776_spi_suspend NULL
-#define wm8776_spi_resume NULL
-#endif
-
 static struct spi_driver wm8776_spi_driver = {
         .driver = {
                 .name   = "wm8776",
@@ -638,8 +617,6 @@ static struct spi_driver wm8776_spi_driver = {
                 .owner  = THIS_MODULE,
         },
         .probe          = wm8776_spi_probe,
-        .suspend        = wm8776_spi_suspend,
-        .resume         = wm8776_spi_resume,
         .remove         = __devexit_p(wm8776_spi_remove),
 };
 #endif /* CONFIG_SPI_MASTER */
@@ -673,21 +650,6 @@ static __devexit int wm8776_i2c_remove(struct i2c_client *client)
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int wm8776_i2c_suspend(struct i2c_client *i2c, pm_message_t msg)
-{
-        return snd_soc_suspend_device(&i2c->dev);
-}
-
-static int wm8776_i2c_resume(struct i2c_client *i2c)
-{
-        return snd_soc_resume_device(&i2c->dev);
-}
-#else
-#define wm8776_i2c_suspend NULL
-#define wm8776_i2c_resume NULL
-#endif
-
 static const struct i2c_device_id wm8776_i2c_id[] = {
         { "wm8776", 0 },
         { }
@@ -701,8 +663,6 @@ static struct i2c_driver wm8776_i2c_driver = {
         },
         .probe =    wm8776_i2c_probe,
         .remove =   __devexit_p(wm8776_i2c_remove),
-        .suspend =  wm8776_i2c_suspend,
-        .resume =   wm8776_i2c_resume,
         .id_table = wm8776_i2c_id,
 };
 #endif
diff --git a/sound/soc/codecs/wm8900.c b/sound/soc/codecs/wm8900.c
index 5e9c855c0036..b7fd96adac64 100644
--- a/sound/soc/codecs/wm8900.c
+++ b/sound/soc/codecs/wm8900.c
@@ -24,6 +24,7 @@
 #include <linux/pm.h>
 #include <linux/i2c.h>
 #include <linux/platform_device.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
@@ -199,7 +200,7 @@ static void wm8900_reset(struct snd_soc_codec *codec)
         snd_soc_write(codec, WM8900_REG_RESET, 0);
 
         memcpy(codec->reg_cache, wm8900_reg_defaults,
-               sizeof(codec->reg_cache));
+               sizeof(wm8900_reg_defaults));
 }
 
 static int wm8900_hp_event(struct snd_soc_dapm_widget *w,
@@ -618,8 +619,6 @@ static int wm8900_add_widgets(struct snd_soc_codec *codec)
 
         snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
 
-        snd_soc_dapm_new_widgets(codec);
-
         return 0;
 }
 
@@ -814,8 +813,8 @@ reenable:
         return 0;
 }
 
-static int wm8900_set_dai_pll(struct snd_soc_dai *codec_dai,
-                int pll_id, unsigned int freq_in, unsigned int freq_out)
+static int wm8900_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id,
+                int source, unsigned int freq_in, unsigned int freq_out)
 {
         return wm8900_set_fll(codec_dai->codec, pll_id, freq_in, freq_out);
 }
@@ -1312,21 +1311,6 @@ static __devexit int wm8900_i2c_remove(struct i2c_client *client)
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int wm8900_i2c_suspend(struct i2c_client *client, pm_message_t msg)
-{
-        return snd_soc_suspend_device(&client->dev);
-}
-
-static int wm8900_i2c_resume(struct i2c_client *client)
-{
-        return snd_soc_resume_device(&client->dev);
-}
-#else
-#define wm8900_i2c_suspend NULL
-#define wm8900_i2c_resume NULL
-#endif
-
 static const struct i2c_device_id wm8900_i2c_id[] = {
         { "wm8900", 0 },
         { }
@@ -1340,8 +1324,6 @@ static struct i2c_driver wm8900_i2c_driver = {
         },
         .probe = wm8900_i2c_probe,
         .remove = __devexit_p(wm8900_i2c_remove),
-        .suspend = wm8900_i2c_suspend,
-        .resume = wm8900_i2c_resume,
         .id_table = wm8900_i2c_id,
 };
 
@@ -1370,17 +1352,6 @@ static int wm8900_probe(struct platform_device *pdev)
                                 ARRAY_SIZE(wm8900_snd_controls));
         wm8900_add_widgets(codec);
 
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                dev_err(&pdev->dev, "Failed to register card\n");
-                goto card_err;
-        }
-
-        return ret;
-
-card_err:
-        snd_soc_free_pcms(socdev);
-        snd_soc_dapm_free(socdev);
 pcm_err:
         return ret;
 }
diff --git a/sound/soc/codecs/wm8903.c b/sound/soc/codecs/wm8903.c
index fe1307b500cf..fa5f99fde68b 100644
--- a/sound/soc/codecs/wm8903.c
+++ b/sound/soc/codecs/wm8903.c
@@ -23,6 +23,7 @@
 #include <linux/pm.h>
 #include <linux/i2c.h>
 #include <linux/platform_device.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
@@ -607,7 +608,7 @@ SOC_SINGLE("Right Input PGA Common Mode Switch", WM8903_ANALOGUE_RIGHT_INPUT_1,
 SOC_SINGLE("DRC Switch", WM8903_DRC_0, 15, 1, 0),
 SOC_ENUM("DRC Compressor Slope R0", drc_slope_r0),
 SOC_ENUM("DRC Compressor Slope R1", drc_slope_r1),
-SOC_SINGLE_TLV("DRC Compressor Threashold Volume", WM8903_DRC_3, 5, 124, 1,
+SOC_SINGLE_TLV("DRC Compressor Threshold Volume", WM8903_DRC_3, 5, 124, 1,
                drc_tlv_thresh),
 SOC_SINGLE_TLV("DRC Volume", WM8903_DRC_3, 0, 30, 1, drc_tlv_amp),
 SOC_SINGLE_TLV("DRC Minimum Gain Volume", WM8903_DRC_1, 2, 3, 1, drc_tlv_min),
@@ -617,11 +618,11 @@ SOC_ENUM("DRC Decay Rate", drc_decay),
 SOC_ENUM("DRC FF Delay", drc_ff_delay),
 SOC_SINGLE("DRC Anticlip Switch", WM8903_DRC_0, 1, 1, 0),
 SOC_SINGLE("DRC QR Switch", WM8903_DRC_0, 2, 1, 0),
-SOC_SINGLE_TLV("DRC QR Threashold Volume", WM8903_DRC_0, 6, 3, 0, drc_tlv_max),
+SOC_SINGLE_TLV("DRC QR Threshold Volume", WM8903_DRC_0, 6, 3, 0, drc_tlv_max),
 SOC_ENUM("DRC QR Decay Rate", drc_qr_decay),
 SOC_SINGLE("DRC Smoothing Switch", WM8903_DRC_0, 3, 1, 0),
 SOC_SINGLE("DRC Smoothing Hysteresis Switch", WM8903_DRC_0, 0, 1, 0),
-SOC_ENUM("DRC Smoothing Threashold", drc_smoothing),
+SOC_ENUM("DRC Smoothing Threshold", drc_smoothing),
 SOC_SINGLE_TLV("DRC Startup Volume", WM8903_DRC_0, 6, 18, 0, drc_tlv_startup),
 
 SOC_DOUBLE_R_TLV("Digital Capture Volume", WM8903_ADC_DIGITAL_VOLUME_LEFT,
@@ -919,8 +920,6 @@ static int wm8903_add_widgets(struct snd_soc_codec *codec)
 
         snd_soc_dapm_add_routes(codec, intercon, ARRAY_SIZE(intercon));
 
-        snd_soc_dapm_new_widgets(codec);
-
         return 0;
 }
 
@@ -1506,7 +1505,7 @@ static int wm8903_resume(struct platform_device *pdev)
         struct i2c_client *i2c = codec->control_data;
         int i;
         u16 *reg_cache = codec->reg_cache;
-        u16 *tmp_cache = kmemdup(codec->reg_cache, sizeof(wm8903_reg_defaults),
+        u16 *tmp_cache = kmemdup(reg_cache, sizeof(wm8903_reg_defaults),
                                  GFP_KERNEL);
 
         /* Bring the codec back up to standby first to minimise pop/clicks */
@@ -1518,6 +1517,7 @@ static int wm8903_resume(struct platform_device *pdev)
                 for (i = 2; i < ARRAY_SIZE(wm8903_reg_defaults); i++)
                         if (tmp_cache[i] != reg_cache[i])
                                 snd_soc_write(codec, i, tmp_cache[i]);
+                kfree(tmp_cache);
         } else {
                 dev_err(&i2c->dev, "Failed to allocate temporary cache\n");
         }
@@ -1655,21 +1655,6 @@ static __devexit int wm8903_i2c_remove(struct i2c_client *client)
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int wm8903_i2c_suspend(struct i2c_client *client, pm_message_t msg)
-{
-        return snd_soc_suspend_device(&client->dev);
-}
-
-static int wm8903_i2c_resume(struct i2c_client *client)
-{
-        return snd_soc_resume_device(&client->dev);
-}
-#else
-#define wm8903_i2c_suspend NULL
-#define wm8903_i2c_resume NULL
-#endif
-
 /* i2c codec control layer */
 static const struct i2c_device_id wm8903_i2c_id[] = {
        { "wm8903", 0 },
@@ -1684,8 +1669,6 @@ static struct i2c_driver wm8903_i2c_driver = {
         },
         .probe    = wm8903_i2c_probe,
         .remove   = __devexit_p(wm8903_i2c_remove),
-        .suspend  = wm8903_i2c_suspend,
-        .resume   = wm8903_i2c_resume,
         .id_table = wm8903_i2c_id,
 };
 
@@ -1712,17 +1695,8 @@ static int wm8903_probe(struct platform_device *pdev)
                                 ARRAY_SIZE(wm8903_snd_controls));
         wm8903_add_widgets(socdev->card->codec);
 
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                dev_err(&pdev->dev, "wm8903: failed to register card\n");
-                goto card_err;
-        }
-
         return ret;
 
-card_err:
-        snd_soc_free_pcms(socdev);
-        snd_soc_dapm_free(socdev);
 err:
         return ret;
 }
diff --git a/sound/soc/codecs/wm8904.c b/sound/soc/codecs/wm8904.c
new file mode 100644
index 000000000000..c6f0abcc5711
--- /dev/null
+++ b/sound/soc/codecs/wm8904.c
@@ -0,0 +1,2657 @@
+/*
+ * wm8904.c  --  WM8904 ALSA SoC Audio driver
+ *
+ * Copyright 2009 Wolfson Microelectronics plc
+ *
+ * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
+ *
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/pm.h>
+#include <linux/i2c.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/consumer.h>
+#include <linux/slab.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+#include <sound/initval.h>
+#include <sound/tlv.h>
+#include <sound/wm8904.h>
+
+#include "wm8904.h"
+
+static struct snd_soc_codec *wm8904_codec;
+struct snd_soc_codec_device soc_codec_dev_wm8904;
+
+enum wm8904_type {
+        WM8904,
+        WM8912,
+};
+
+#define WM8904_NUM_DCS_CHANNELS 4
+
+#define WM8904_NUM_SUPPLIES 5
+static const char *wm8904_supply_names[WM8904_NUM_SUPPLIES] = {
+        "DCVDD",
+        "DBVDD",
+        "AVDD",
+        "CPVDD",
+        "MICVDD",
+};
+
+/* codec private data */
+struct wm8904_priv {
+        struct snd_soc_codec codec;
+        u16 reg_cache[WM8904_MAX_REGISTER + 1];
+
+        enum wm8904_type devtype;
+
+        struct regulator_bulk_data supplies[WM8904_NUM_SUPPLIES];
+
+        struct wm8904_pdata *pdata;
+
+        int deemph;
+
+        /* Platform provided DRC configuration */
+        const char **drc_texts;
+        int drc_cfg;
+        struct soc_enum drc_enum;
+
+        /* Platform provided ReTune mobile configuration */
+        int num_retune_mobile_texts;
+        const char **retune_mobile_texts;
+        int retune_mobile_cfg;
+        struct soc_enum retune_mobile_enum;
+
+        /* FLL setup */
+        int fll_src;
+        int fll_fref;
+        int fll_fout;
+
+        /* Clocking configuration */
+        unsigned int mclk_rate;
+        int sysclk_src;
+        unsigned int sysclk_rate;
+
+        int tdm_width;
+        int tdm_slots;
+        int bclk;
+        int fs;
+
+        /* DC servo configuration - cached offset values */
+        int dcs_state[WM8904_NUM_DCS_CHANNELS];
+};
+
+static const u16 wm8904_reg[WM8904_MAX_REGISTER + 1] = {
+        0x8904,     /* R0   - SW Reset and ID */
+        0x0000,     /* R1   - Revision */
+        0x0000,     /* R2 */
+        0x0000,     /* R3 */
+        0x0018,     /* R4   - Bias Control 0 */
+        0x0000,     /* R5   - VMID Control 0 */
+        0x0000,     /* R6   - Mic Bias Control 0 */
+        0x0000,     /* R7   - Mic Bias Control 1 */
+        0x0001,     /* R8   - Analogue DAC 0 */
+        0x9696,     /* R9   - mic Filter Control */
+        0x0001,     /* R10  - Analogue ADC 0 */
+        0x0000,     /* R11 */
+        0x0000,     /* R12  - Power Management 0 */
+        0x0000,     /* R13 */
+        0x0000,     /* R14  - Power Management 2 */
+        0x0000,     /* R15  - Power Management 3 */
+        0x0000,     /* R16 */
+        0x0000,     /* R17 */
+        0x0000,     /* R18  - Power Management 6 */
+        0x0000,     /* R19 */
+        0x945E,     /* R20  - Clock Rates 0 */
+        0x0C05,     /* R21  - Clock Rates 1 */
+        0x0006,     /* R22  - Clock Rates 2 */
+        0x0000,     /* R23 */
+        0x0050,     /* R24  - Audio Interface 0 */
+        0x000A,     /* R25  - Audio Interface 1 */
+        0x00E4,     /* R26  - Audio Interface 2 */
+        0x0040,     /* R27  - Audio Interface 3 */
+        0x0000,     /* R28 */
+        0x0000,     /* R29 */
+        0x00C0,     /* R30  - DAC Digital Volume Left */
+        0x00C0,     /* R31  - DAC Digital Volume Right */
+        0x0000,     /* R32  - DAC Digital 0 */
+        0x0008,     /* R33  - DAC Digital 1 */
+        0x0000,     /* R34 */
+        0x0000,     /* R35 */
+        0x00C0,     /* R36  - ADC Digital Volume Left */
+        0x00C0,     /* R37  - ADC Digital Volume Right */
+        0x0010,     /* R38  - ADC Digital 0 */
+        0x0000,     /* R39  - Digital Microphone 0 */
+        0x01AF,     /* R40  - DRC 0 */
+        0x3248,     /* R41  - DRC 1 */
+        0x0000,     /* R42  - DRC 2 */
+        0x0000,     /* R43  - DRC 3 */
+        0x0085,     /* R44  - Analogue Left Input 0 */
+        0x0085,     /* R45  - Analogue Right Input 0 */
+        0x0044,     /* R46  - Analogue Left Input 1 */
+        0x0044,     /* R47  - Analogue Right Input 1 */
+        0x0000,     /* R48 */
+        0x0000,     /* R49 */
+        0x0000,     /* R50 */
+        0x0000,     /* R51 */
+        0x0000,     /* R52 */
+        0x0000,     /* R53 */
+        0x0000,     /* R54 */
+        0x0000,     /* R55 */
+        0x0000,     /* R56 */
+        0x002D,     /* R57  - Analogue OUT1 Left */
+        0x002D,     /* R58  - Analogue OUT1 Right */
+        0x0039,     /* R59  - Analogue OUT2 Left */
+        0x0039,     /* R60  - Analogue OUT2 Right */
+        0x0000,     /* R61  - Analogue OUT12 ZC */
+        0x0000,     /* R62 */
+        0x0000,     /* R63 */
+        0x0000,     /* R64 */
+        0x0000,     /* R65 */
+        0x0000,     /* R66 */
+        0x0000,     /* R67  - DC Servo 0 */
+        0x0000,     /* R68  - DC Servo 1 */
+        0xAAAA,     /* R69  - DC Servo 2 */
+        0x0000,     /* R70 */
+        0xAAAA,     /* R71  - DC Servo 4 */
+        0xAAAA,     /* R72  - DC Servo 5 */
+        0x0000,     /* R73  - DC Servo 6 */
+        0x0000,     /* R74  - DC Servo 7 */
+        0x0000,     /* R75  - DC Servo 8 */
+        0x0000,     /* R76  - DC Servo 9 */
+        0x0000,     /* R77  - DC Servo Readback 0 */
+        0x0000,     /* R78 */
+        0x0000,     /* R79 */
+        0x0000,     /* R80 */
+        0x0000,     /* R81 */
+        0x0000,     /* R82 */
+        0x0000,     /* R83 */
+        0x0000,     /* R84 */
+        0x0000,     /* R85 */
+        0x0000,     /* R86 */
+        0x0000,     /* R87 */
+        0x0000,     /* R88 */
+        0x0000,     /* R89 */
+        0x0000,     /* R90  - Analogue HP 0 */
+        0x0000,     /* R91 */
+        0x0000,     /* R92 */
+        0x0000,     /* R93 */
+        0x0000,     /* R94  - Analogue Lineout 0 */
+        0x0000,     /* R95 */
+        0x0000,     /* R96 */
+        0x0000,     /* R97 */
+        0x0000,     /* R98  - Charge Pump 0 */
+        0x0000,     /* R99 */
+        0x0000,     /* R100 */
+        0x0000,     /* R101 */
+        0x0000,     /* R102 */
+        0x0000,     /* R103 */
+        0x0004,     /* R104 - Class W 0 */
+        0x0000,     /* R105 */
+        0x0000,     /* R106 */
+        0x0000,     /* R107 */
+        0x0000,     /* R108 - Write Sequencer 0 */
+        0x0000,     /* R109 - Write Sequencer 1 */
+        0x0000,     /* R110 - Write Sequencer 2 */
+        0x0000,     /* R111 - Write Sequencer 3 */
+        0x0000,     /* R112 - Write Sequencer 4 */
+        0x0000,     /* R113 */
+        0x0000,     /* R114 */
+        0x0000,     /* R115 */
+        0x0000,     /* R116 - FLL Control 1 */
+        0x0007,     /* R117 - FLL Control 2 */
+        0x0000,     /* R118 - FLL Control 3 */
+        0x2EE0,     /* R119 - FLL Control 4 */
+        0x0004,     /* R120 - FLL Control 5 */
+        0x0014,     /* R121 - GPIO Control 1 */
+        0x0010,     /* R122 - GPIO Control 2 */
+        0x0010,     /* R123 - GPIO Control 3 */
+        0x0000,     /* R124 - GPIO Control 4 */
+        0x0000,     /* R125 */
+        0x0000,     /* R126 - Digital Pulls */
+        0x0000,     /* R127 - Interrupt Status */
+        0xFFFF,     /* R128 - Interrupt Status Mask */
+        0x0000,     /* R129 - Interrupt Polarity */
+        0x0000,     /* R130 - Interrupt Debounce */
+        0x0000,     /* R131 */
+        0x0000,     /* R132 */
+        0x0000,     /* R133 */
+        0x0000,     /* R134 - EQ1 */
+        0x000C,     /* R135 - EQ2 */
+        0x000C,     /* R136 - EQ3 */
+        0x000C,     /* R137 - EQ4 */
+        0x000C,     /* R138 - EQ5 */
+        0x000C,     /* R139 - EQ6 */
+        0x0FCA,     /* R140 - EQ7 */
+        0x0400,     /* R141 - EQ8 */
+        0x00D8,     /* R142 - EQ9 */
+        0x1EB5,     /* R143 - EQ10 */
+        0xF145,     /* R144 - EQ11 */
+        0x0B75,     /* R145 - EQ12 */
+        0x01C5,     /* R146 - EQ13 */
+        0x1C58,     /* R147 - EQ14 */
+        0xF373,     /* R148 - EQ15 */
+        0x0A54,     /* R149 - EQ16 */
+        0x0558,     /* R150 - EQ17 */
+        0x168E,     /* R151 - EQ18 */
+        0xF829,     /* R152 - EQ19 */
+        0x07AD,     /* R153 - EQ20 */
+        0x1103,     /* R154 - EQ21 */
+        0x0564,     /* R155 - EQ22 */
+        0x0559,     /* R156 - EQ23 */
+        0x4000,     /* R157 - EQ24 */
+        0x0000,     /* R158 */
+        0x0000,     /* R159 */
+        0x0000,     /* R160 */
+        0x0000,     /* R161 - Control Interface Test 1 */
+        0x0000,     /* R162 */
+        0x0000,     /* R163 */
+        0x0000,     /* R164 */
+        0x0000,     /* R165 */
+        0x0000,     /* R166 */
+        0x0000,     /* R167 */
+        0x0000,     /* R168 */
+        0x0000,     /* R169 */
+        0x0000,     /* R170 */
+        0x0000,     /* R171 */
+        0x0000,     /* R172 */
+        0x0000,     /* R173 */
+        0x0000,     /* R174 */
+        0x0000,     /* R175 */
+        0x0000,     /* R176 */
+        0x0000,     /* R177 */
+        0x0000,     /* R178 */
+        0x0000,     /* R179 */
+        0x0000,     /* R180 */
+        0x0000,     /* R181 */
+        0x0000,     /* R182 */
+        0x0000,     /* R183 */
+        0x0000,     /* R184 */
+        0x0000,     /* R185 */
+        0x0000,     /* R186 */
+        0x0000,     /* R187 */
+        0x0000,     /* R188 */
+        0x0000,     /* R189 */
+        0x0000,     /* R190 */
+        0x0000,     /* R191 */
+        0x0000,     /* R192 */
+        0x0000,     /* R193 */
+        0x0000,     /* R194 */
+        0x0000,     /* R195 */
+        0x0000,     /* R196 */
+        0x0000,     /* R197 */
+        0x0000,     /* R198 */
+        0x0000,     /* R199 */
+        0x0000,     /* R200 */
+        0x0000,     /* R201 */
+        0x0000,     /* R202 */
+        0x0000,     /* R203 */
+        0x0000,     /* R204 - Analogue Output Bias 0 */
+        0x0000,     /* R205 */
+        0x0000,     /* R206 */
+        0x0000,     /* R207 */
+        0x0000,     /* R208 */
+        0x0000,     /* R209 */
+        0x0000,     /* R210 */
+        0x0000,     /* R211 */
+        0x0000,     /* R212 */
+        0x0000,     /* R213 */
+        0x0000,     /* R214 */
+        0x0000,     /* R215 */
+        0x0000,     /* R216 */
+        0x0000,     /* R217 */
+        0x0000,     /* R218 */
+        0x0000,     /* R219 */
+        0x0000,     /* R220 */
+        0x0000,     /* R221 */
+        0x0000,     /* R222 */
+        0x0000,     /* R223 */
+        0x0000,     /* R224 */
+        0x0000,     /* R225 */
+        0x0000,     /* R226 */
+        0x0000,     /* R227 */
+        0x0000,     /* R228 */
+        0x0000,     /* R229 */
+        0x0000,     /* R230 */
+        0x0000,     /* R231 */
+        0x0000,     /* R232 */
+        0x0000,     /* R233 */
+        0x0000,     /* R234 */
+        0x0000,     /* R235 */
+        0x0000,     /* R236 */
+        0x0000,     /* R237 */
+        0x0000,     /* R238 */
+        0x0000,     /* R239 */
+        0x0000,     /* R240 */
+        0x0000,     /* R241 */
+        0x0000,     /* R242 */
+        0x0000,     /* R243 */
+        0x0000,     /* R244 */
+        0x0000,     /* R245 */
+        0x0000,     /* R246 */
+        0x0000,     /* R247 - FLL NCO Test 0 */
+        0x0019,     /* R248 - FLL NCO Test 1 */
+};
+
+static struct {
+        int readable;
+        int writable;
+        int vol;
+} wm8904_access[] = {
+        { 0xFFFF, 0xFFFF, 1 }, /* R0   - SW Reset and ID */
+        { 0x0000, 0x0000, 0 }, /* R1   - Revision */
+        { 0x0000, 0x0000, 0 }, /* R2 */
+        { 0x0000, 0x0000, 0 }, /* R3 */
+        { 0x001F, 0x001F, 0 }, /* R4   - Bias Control 0 */
+        { 0x0047, 0x0047, 0 }, /* R5   - VMID Control 0 */
+        { 0x007F, 0x007F, 0 }, /* R6   - Mic Bias Control 0 */
+        { 0xC007, 0xC007, 0 }, /* R7   - Mic Bias Control 1 */
+        { 0x001E, 0x001E, 0 }, /* R8   - Analogue DAC 0 */
+        { 0xFFFF, 0xFFFF, 0 }, /* R9   - mic Filter Control */
+        { 0x0001, 0x0001, 0 }, /* R10  - Analogue ADC 0 */
+        { 0x0000, 0x0000, 0 }, /* R11 */
+        { 0x0003, 0x0003, 0 }, /* R12  - Power Management 0 */
+        { 0x0000, 0x0000, 0 }, /* R13 */
+        { 0x0003, 0x0003, 0 }, /* R14  - Power Management 2 */
+        { 0x0003, 0x0003, 0 }, /* R15  - Power Management 3 */
+        { 0x0000, 0x0000, 0 }, /* R16 */
+        { 0x0000, 0x0000, 0 }, /* R17 */
+        { 0x000F, 0x000F, 0 }, /* R18  - Power Management 6 */
+        { 0x0000, 0x0000, 0 }, /* R19 */
+        { 0x7001, 0x7001, 0 }, /* R20  - Clock Rates 0 */
+        { 0x3C07, 0x3C07, 0 }, /* R21  - Clock Rates 1 */
+        { 0xD00F, 0xD00F, 0 }, /* R22  - Clock Rates 2 */
+        { 0x0000, 0x0000, 0 }, /* R23 */
+        { 0x1FFF, 0x1FFF, 0 }, /* R24  - Audio Interface 0 */
+        { 0x3DDF, 0x3DDF, 0 }, /* R25  - Audio Interface 1 */
+        { 0x0F1F, 0x0F1F, 0 }, /* R26  - Audio Interface 2 */
+        { 0x0FFF, 0x0FFF, 0 }, /* R27  - Audio Interface 3 */
+        { 0x0000, 0x0000, 0 }, /* R28 */
+        { 0x0000, 0x0000, 0 }, /* R29 */
+        { 0x00FF, 0x01FF, 0 }, /* R30  - DAC Digital Volume Left */
+        { 0x00FF, 0x01FF, 0 }, /* R31  - DAC Digital Volume Right */
+        { 0x0FFF, 0x0FFF, 0 }, /* R32  - DAC Digital 0 */
+        { 0x1E4E, 0x1E4E, 0 }, /* R33  - DAC Digital 1 */
+        { 0x0000, 0x0000, 0 }, /* R34 */
+        { 0x0000, 0x0000, 0 }, /* R35 */
+        { 0x00FF, 0x01FF, 0 }, /* R36  - ADC Digital Volume Left */
+        { 0x00FF, 0x01FF, 0 }, /* R37  - ADC Digital Volume Right */
+        { 0x0073, 0x0073, 0 }, /* R38  - ADC Digital 0 */
+        { 0x1800, 0x1800, 0 }, /* R39  - Digital Microphone 0 */
+        { 0xDFEF, 0xDFEF, 0 }, /* R40  - DRC 0 */
+        { 0xFFFF, 0xFFFF, 0 }, /* R41  - DRC 1 */
+        { 0x003F, 0x003F, 0 }, /* R42  - DRC 2 */
+        { 0x07FF, 0x07FF, 0 }, /* R43  - DRC 3 */
+        { 0x009F, 0x009F, 0 }, /* R44  - Analogue Left Input 0 */
+        { 0x009F, 0x009F, 0 }, /* R45  - Analogue Right Input 0 */
+        { 0x007F, 0x007F, 0 }, /* R46  - Analogue Left Input 1 */
+        { 0x007F, 0x007F, 0 }, /* R47  - Analogue Right Input 1 */
+        { 0x0000, 0x0000, 0 }, /* R48 */
+        { 0x0000, 0x0000, 0 }, /* R49 */
+        { 0x0000, 0x0000, 0 }, /* R50 */
+        { 0x0000, 0x0000, 0 }, /* R51 */
+        { 0x0000, 0x0000, 0 }, /* R52 */
+        { 0x0000, 0x0000, 0 }, /* R53 */
+        { 0x0000, 0x0000, 0 }, /* R54 */
+        { 0x0000, 0x0000, 0 }, /* R55 */
+        { 0x0000, 0x0000, 0 }, /* R56 */
+        { 0x017F, 0x01FF, 0 }, /* R57  - Analogue OUT1 Left */
+        { 0x017F, 0x01FF, 0 }, /* R58  - Analogue OUT1 Right */
+        { 0x017F, 0x01FF, 0 }, /* R59  - Analogue OUT2 Left */
+        { 0x017F, 0x01FF, 0 }, /* R60  - Analogue OUT2 Right */
+        { 0x000F, 0x000F, 0 }, /* R61  - Analogue OUT12 ZC */
+        { 0x0000, 0x0000, 0 }, /* R62 */
+        { 0x0000, 0x0000, 0 }, /* R63 */
+        { 0x0000, 0x0000, 0 }, /* R64 */
+        { 0x0000, 0x0000, 0 }, /* R65 */
+        { 0x0000, 0x0000, 0 }, /* R66 */
+        { 0x000F, 0x000F, 0 }, /* R67  - DC Servo 0 */
+        { 0xFFFF, 0xFFFF, 1 }, /* R68  - DC Servo 1 */
+        { 0x0F0F, 0x0F0F, 0 }, /* R69  - DC Servo 2 */
+        { 0x0000, 0x0000, 0 }, /* R70 */
+        { 0x007F, 0x007F, 0 }, /* R71  - DC Servo 4 */
+        { 0x007F, 0x007F, 0 }, /* R72  - DC Servo 5 */
+        { 0x00FF, 0x00FF, 1 }, /* R73  - DC Servo 6 */
+        { 0x00FF, 0x00FF, 1 }, /* R74  - DC Servo 7 */
+        { 0x00FF, 0x00FF, 1 }, /* R75  - DC Servo 8 */
+        { 0x00FF, 0x00FF, 1 }, /* R76  - DC Servo 9 */
+        { 0x0FFF, 0x0000, 1 }, /* R77  - DC Servo Readback 0 */
+        { 0x0000, 0x0000, 0 }, /* R78 */
+        { 0x0000, 0x0000, 0 }, /* R79 */
+        { 0x0000, 0x0000, 0 }, /* R80 */
+        { 0x0000, 0x0000, 0 }, /* R81 */
+        { 0x0000, 0x0000, 0 }, /* R82 */
+        { 0x0000, 0x0000, 0 }, /* R83 */
+        { 0x0000, 0x0000, 0 }, /* R84 */
+        { 0x0000, 0x0000, 0 }, /* R85 */
+        { 0x0000, 0x0000, 0 }, /* R86 */
+        { 0x0000, 0x0000, 0 }, /* R87 */
+        { 0x0000, 0x0000, 0 }, /* R88 */
+        { 0x0000, 0x0000, 0 }, /* R89 */
+        { 0x00FF, 0x00FF, 0 }, /* R90  - Analogue HP 0 */
+        { 0x0000, 0x0000, 0 }, /* R91 */
+        { 0x0000, 0x0000, 0 }, /* R92 */
+        { 0x0000, 0x0000, 0 }, /* R93 */
+        { 0x00FF, 0x00FF, 0 }, /* R94  - Analogue Lineout 0 */
+        { 0x0000, 0x0000, 0 }, /* R95 */
+        { 0x0000, 0x0000, 0 }, /* R96 */
+        { 0x0000, 0x0000, 0 }, /* R97 */
+        { 0x0001, 0x0001, 0 }, /* R98  - Charge Pump 0 */
+        { 0x0000, 0x0000, 0 }, /* R99 */
+        { 0x0000, 0x0000, 0 }, /* R100 */
+        { 0x0000, 0x0000, 0 }, /* R101 */
+        { 0x0000, 0x0000, 0 }, /* R102 */
+        { 0x0000, 0x0000, 0 }, /* R103 */
+        { 0x0001, 0x0001, 0 }, /* R104 - Class W 0 */
+        { 0x0000, 0x0000, 0 }, /* R105 */
+        { 0x0000, 0x0000, 0 }, /* R106 */
+        { 0x0000, 0x0000, 0 }, /* R107 */
+        { 0x011F, 0x011F, 0 }, /* R108 - Write Sequencer 0 */
+        { 0x7FFF, 0x7FFF, 0 }, /* R109 - Write Sequencer 1 */
+        { 0x4FFF, 0x4FFF, 0 }, /* R110 - Write Sequencer 2 */
+        { 0x003F, 0x033F, 0 }, /* R111 - Write Sequencer 3 */
+        { 0x03F1, 0x0000, 0 }, /* R112 - Write Sequencer 4 */
+        { 0x0000, 0x0000, 0 }, /* R113 */
+        { 0x0000, 0x0000, 0 }, /* R114 */
+        { 0x0000, 0x0000, 0 }, /* R115 */
+        { 0x0007, 0x0007, 0 }, /* R116 - FLL Control 1 */
+        { 0x3F77, 0x3F77, 0 }, /* R117 - FLL Control 2 */
+        { 0xFFFF, 0xFFFF, 0 }, /* R118 - FLL Control 3 */
+        { 0x7FEF, 0x7FEF, 0 }, /* R119 - FLL Control 4 */
+        { 0x001B, 0x001B, 0 }, /* R120 - FLL Control 5 */
+        { 0x003F, 0x003F, 0 }, /* R121 - GPIO Control 1 */
+        { 0x003F, 0x003F, 0 }, /* R122 - GPIO Control 2 */
+        { 0x003F, 0x003F, 0 }, /* R123 - GPIO Control 3 */
+        { 0x038F, 0x038F, 0 }, /* R124 - GPIO Control 4 */
+        { 0x0000, 0x0000, 0 }, /* R125 */
+        { 0x00FF, 0x00FF, 0 }, /* R126 - Digital Pulls */
+        { 0x07FF, 0x03FF, 1 }, /* R127 - Interrupt Status */
+        { 0x03FF, 0x03FF, 0 }, /* R128 - Interrupt Status Mask */
+        { 0x03FF, 0x03FF, 0 }, /* R129 - Interrupt Polarity */
+        { 0x03FF, 0x03FF, 0 }, /* R130 - Interrupt Debounce */
+        { 0x0000, 0x0000, 0 }, /* R131 */
+        { 0x0000, 0x0000, 0 }, /* R132 */
+        { 0x0000, 0x0000, 0 }, /* R133 */
+        { 0x0001, 0x0001, 0 }, /* R134 - EQ1 */
+        { 0x001F, 0x001F, 0 }, /* R135 - EQ2 */
+        { 0x001F, 0x001F, 0 }, /* R136 - EQ3 */
+        { 0x001F, 0x001F, 0 }, /* R137 - EQ4 */
+        { 0x001F, 0x001F, 0 }, /* R138 - EQ5 */
+        { 0x001F, 0x001F, 0 }, /* R139 - EQ6 */
+        { 0xFFFF, 0xFFFF, 0 }, /* R140 - EQ7 */
+        { 0xFFFF, 0xFFFF, 0 }, /* R141 - EQ8 */
+        { 0xFFFF, 0xFFFF, 0 }, /* R142 - EQ9 */
+        { 0xFFFF, 0xFFFF, 0 }, /* R143 - EQ10 */
+        { 0xFFFF, 0xFFFF, 0 }, /* R144 - EQ11 */
+        { 0xFFFF, 0xFFFF, 0 }, /* R145 - EQ12 */
+        { 0xFFFF, 0xFFFF, 0 }, /* R146 - EQ13 */
+        { 0xFFFF, 0xFFFF, 0 }, /* R147 - EQ14 */
+        { 0xFFFF, 0xFFFF, 0 }, /* R148 - EQ15 */
+        { 0xFFFF, 0xFFFF, 0 }, /* R149 - EQ16 */
+        { 0xFFFF, 0xFFFF, 0 }, /* R150 - EQ17 */
+        { 0xFFFF, 0xFFFF, 0 }, /* R151wm8523_dai - EQ18 */
+        { 0xFFFF, 0xFFFF, 0 }, /* R152 - EQ19 */
+        { 0xFFFF, 0xFFFF, 0 }, /* R153 - EQ20 */
+        { 0xFFFF, 0xFFFF, 0 }, /* R154 - EQ21 */
+        { 0xFFFF, 0xFFFF, 0 }, /* R155 - EQ22 */
+        { 0xFFFF, 0xFFFF, 0 }, /* R156 - EQ23 */
+        { 0xFFFF, 0xFFFF, 0 }, /* R157 - EQ24 */
+        { 0x0000, 0x0000, 0 }, /* R158 */
+        { 0x0000, 0x0000, 0 }, /* R159 */
+        { 0x0000, 0x0000, 0 }, /* R160 */
+        { 0x0002, 0x0002, 0 }, /* R161 - Control Interface Test 1 */
+        { 0x0000, 0x0000, 0 }, /* R162 */
+        { 0x0000, 0x0000, 0 }, /* R163 */
+        { 0x0000, 0x0000, 0 }, /* R164 */
+        { 0x0000, 0x0000, 0 }, /* R165 */
+        { 0x0000, 0x0000, 0 }, /* R166 */
+        { 0x0000, 0x0000, 0 }, /* R167 */
+        { 0x0000, 0x0000, 0 }, /* R168 */
+        { 0x0000, 0x0000, 0 }, /* R169 */
+        { 0x0000, 0x0000, 0 }, /* R170 */
+        { 0x0000, 0x0000, 0 }, /* R171 */
+        { 0x0000, 0x0000, 0 }, /* R172 */
+        { 0x0000, 0x0000, 0 }, /* R173 */
+        { 0x0000, 0x0000, 0 }, /* R174 */
+        { 0x0000, 0x0000, 0 }, /* R175 */
+        { 0x0000, 0x0000, 0 }, /* R176 */
+        { 0x0000, 0x0000, 0 }, /* R177 */
+        { 0x0000, 0x0000, 0 }, /* R178 */
+        { 0x0000, 0x0000, 0 }, /* R179 */
+        { 0x0000, 0x0000, 0 }, /* R180 */
+        { 0x0000, 0x0000, 0 }, /* R181 */
+        { 0x0000, 0x0000, 0 }, /* R182 */
+        { 0x0000, 0x0000, 0 }, /* R183 */
+        { 0x0000, 0x0000, 0 }, /* R184 */
+        { 0x0000, 0x0000, 0 }, /* R185 */
+        { 0x0000, 0x0000, 0 }, /* R186 */
+        { 0x0000, 0x0000, 0 }, /* R187 */
+        { 0x0000, 0x0000, 0 }, /* R188 */
+        { 0x0000, 0x0000, 0 }, /* R189 */
+        { 0x0000, 0x0000, 0 }, /* R190 */
+        { 0x0000, 0x0000, 0 }, /* R191 */
+        { 0x0000, 0x0000, 0 }, /* R192 */
+        { 0x0000, 0x0000, 0 }, /* R193 */
+        { 0x0000, 0x0000, 0 }, /* R194 */
+        { 0x0000, 0x0000, 0 }, /* R195 */
+        { 0x0000, 0x0000, 0 }, /* R196 */
+        { 0x0000, 0x0000, 0 }, /* R197 */
+        { 0x0000, 0x0000, 0 }, /* R198 */
+        { 0x0000, 0x0000, 0 }, /* R199 */
+        { 0x0000, 0x0000, 0 }, /* R200 */
+        { 0x0000, 0x0000, 0 }, /* R201 */
+        { 0x0000, 0x0000, 0 }, /* R202 */
+        { 0x0000, 0x0000, 0 }, /* R203 */
+        { 0x0070, 0x0070, 0 }, /* R204 - Analogue Output Bias 0 */
+        { 0x0000, 0x0000, 0 }, /* R205 */
+        { 0x0000, 0x0000, 0 }, /* R206 */
+        { 0x0000, 0x0000, 0 }, /* R207 */
+        { 0x0000, 0x0000, 0 }, /* R208 */
+        { 0x0000, 0x0000, 0 }, /* R209 */
+        { 0x0000, 0x0000, 0 }, /* R210 */
+        { 0x0000, 0x0000, 0 }, /* R211 */
+        { 0x0000, 0x0000, 0 }, /* R212 */
+        { 0x0000, 0x0000, 0 }, /* R213 */
+        { 0x0000, 0x0000, 0 }, /* R214 */
+        { 0x0000, 0x0000, 0 }, /* R215 */
+        { 0x0000, 0x0000, 0 }, /* R216 */
+        { 0x0000, 0x0000, 0 }, /* R217 */
+        { 0x0000, 0x0000, 0 }, /* R218 */
+        { 0x0000, 0x0000, 0 }, /* R219 */
+        { 0x0000, 0x0000, 0 }, /* R220 */
+        { 0x0000, 0x0000, 0 }, /* R221 */
+        { 0x0000, 0x0000, 0 }, /* R222 */
+        { 0x0000, 0x0000, 0 }, /* R223 */
+        { 0x0000, 0x0000, 0 }, /* R224 */
+        { 0x0000, 0x0000, 0 }, /* R225 */
+        { 0x0000, 0x0000, 0 }, /* R226 */
+        { 0x0000, 0x0000, 0 }, /* R227 */
+        { 0x0000, 0x0000, 0 }, /* R228 */
+        { 0x0000, 0x0000, 0 }, /* R229 */
+        { 0x0000, 0x0000, 0 }, /* R230 */
+        { 0x0000, 0x0000, 0 }, /* R231 */
+        { 0x0000, 0x0000, 0 }, /* R232 */
+        { 0x0000, 0x0000, 0 }, /* R233 */
+        { 0x0000, 0x0000, 0 }, /* R234 */
+        { 0x0000, 0x0000, 0 }, /* R235 */
+        { 0x0000, 0x0000, 0 }, /* R236 */
+        { 0x0000, 0x0000, 0 }, /* R237 */
+        { 0x0000, 0x0000, 0 }, /* R238 */
+        { 0x0000, 0x0000, 0 }, /* R239 */
+        { 0x0000, 0x0000, 0 }, /* R240 */
+        { 0x0000, 0x0000, 0 }, /* R241 */
+        { 0x0000, 0x0000, 0 }, /* R242 */
+        { 0x0000, 0x0000, 0 }, /* R243 */
+        { 0x0000, 0x0000, 0 }, /* R244 */
+        { 0x0000, 0x0000, 0 }, /* R245 */
+        { 0x0000, 0x0000, 0 }, /* R246 */
+        { 0x0001, 0x0001, 0 }, /* R247 - FLL NCO Test 0 */
+        { 0x003F, 0x003F, 0 }, /* R248 - FLL NCO Test 1 */
+};
+
+static int wm8904_volatile_register(unsigned int reg)
+{
+        return wm8904_access[reg].vol;
+}
+
+static int wm8904_reset(struct snd_soc_codec *codec)
+{
+        return snd_soc_write(codec, WM8904_SW_RESET_AND_ID, 0);
+}
+
+static int wm8904_configure_clocking(struct snd_soc_codec *codec)
+{
+        struct wm8904_priv *wm8904 = codec->private_data;
+        unsigned int clock0, clock2, rate;
+
+        /* Gate the clock while we're updating to avoid misclocking */
+        clock2 = snd_soc_read(codec, WM8904_CLOCK_RATES_2);
+        snd_soc_update_bits(codec, WM8904_CLOCK_RATES_2,
+                            WM8904_SYSCLK_SRC, 0);
+
+        /* This should be done on init() for bypass paths */
+        switch (wm8904->sysclk_src) {
+        case WM8904_CLK_MCLK:
+                dev_dbg(codec->dev, "Using %dHz MCLK\n", wm8904->mclk_rate);
+
+                clock2 &= ~WM8904_SYSCLK_SRC;
+                rate = wm8904->mclk_rate;
+
+                /* Ensure the FLL is stopped */
+                snd_soc_update_bits(codec, WM8904_FLL_CONTROL_1,
+                                    WM8904_FLL_OSC_ENA | WM8904_FLL_ENA, 0);
+                break;
+
+        case WM8904_CLK_FLL:
+                dev_dbg(codec->dev, "Using %dHz FLL clock\n",
+                        wm8904->fll_fout);
+
+                clock2 |= WM8904_SYSCLK_SRC;
+                rate = wm8904->fll_fout;
+                break;
+
+        default:
+                dev_err(codec->dev, "System clock not configured\n");
+                return -EINVAL;
+        }
+
+        /* SYSCLK shouldn't be over 13.5MHz */
+        if (rate > 13500000) {
+                clock0 = WM8904_MCLK_DIV;
+                wm8904->sysclk_rate = rate / 2;
+        } else {
+                clock0 = 0;
+                wm8904->sysclk_rate = rate;
+        }
+
+        snd_soc_update_bits(codec, WM8904_CLOCK_RATES_0, WM8904_MCLK_DIV,
+                            clock0);
+
+        snd_soc_update_bits(codec, WM8904_CLOCK_RATES_2,
+                            WM8904_CLK_SYS_ENA | WM8904_SYSCLK_SRC, clock2);
+
+        dev_dbg(codec->dev, "CLK_SYS is %dHz\n", wm8904->sysclk_rate);
+
+        return 0;
+}
+
+static void wm8904_set_drc(struct snd_soc_codec *codec)
+{
+        struct wm8904_priv *wm8904 = codec->private_data;
+        struct wm8904_pdata *pdata = wm8904->pdata;
+        int save, i;
+
+        /* Save any enables; the configuration should clear them. */
+        save = snd_soc_read(codec, WM8904_DRC_0);
+
+        for (i = 0; i < WM8904_DRC_REGS; i++)
+                snd_soc_update_bits(codec, WM8904_DRC_0 + i, 0xffff,
+                                    pdata->drc_cfgs[wm8904->drc_cfg].regs[i]);
+
+        /* Reenable the DRC */
+        snd_soc_update_bits(codec, WM8904_DRC_0,
+                            WM8904_DRC_ENA | WM8904_DRC_DAC_PATH, save);
+}
+
+static int wm8904_put_drc_enum(struct snd_kcontrol *kcontrol,
+                               struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct wm8904_priv *wm8904 = codec->private_data;       
+        struct wm8904_pdata *pdata = wm8904->pdata;
+        int value = ucontrol->value.integer.value[0];
+
+        if (value >= pdata->num_drc_cfgs)
+                return -EINVAL;
+
+        wm8904->drc_cfg = value;
+
+        wm8904_set_drc(codec);
+
+        return 0;
+}
+
+static int wm8904_get_drc_enum(struct snd_kcontrol *kcontrol,
+                               struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct wm8904_priv *wm8904 = codec->private_data;
+
+        ucontrol->value.enumerated.item[0] = wm8904->drc_cfg;
+
+        return 0;
+}
+
+static void wm8904_set_retune_mobile(struct snd_soc_codec *codec)
+{
+        struct wm8904_priv *wm8904 = codec->private_data;
+        struct wm8904_pdata *pdata = wm8904->pdata;
+        int best, best_val, save, i, cfg;
+
+        if (!pdata || !wm8904->num_retune_mobile_texts)
+                return;
+
+        /* Find the version of the currently selected configuration
+         * with the nearest sample rate. */
+        cfg = wm8904->retune_mobile_cfg;
+        best = 0;
+        best_val = INT_MAX;
+        for (i = 0; i < pdata->num_retune_mobile_cfgs; i++) {
+                if (strcmp(pdata->retune_mobile_cfgs[i].name,
+                           wm8904->retune_mobile_texts[cfg]) == 0 &&
+                    abs(pdata->retune_mobile_cfgs[i].rate
+                        - wm8904->fs) < best_val) {
+                        best = i;
+                        best_val = abs(pdata->retune_mobile_cfgs[i].rate
+                                       - wm8904->fs);
+                }
+        }
+
+        dev_dbg(codec->dev, "ReTune Mobile %s/%dHz for %dHz sample rate\n",
+                pdata->retune_mobile_cfgs[best].name,
+                pdata->retune_mobile_cfgs[best].rate,
+                wm8904->fs);
+
+        /* The EQ will be disabled while reconfiguring it, remember the
+         * current configuration. 
+         */
+        save = snd_soc_read(codec, WM8904_EQ1);
+
+        for (i = 0; i < WM8904_EQ_REGS; i++)
+                snd_soc_update_bits(codec, WM8904_EQ1 + i, 0xffff,
+                                pdata->retune_mobile_cfgs[best].regs[i]);
+
+        snd_soc_update_bits(codec, WM8904_EQ1, WM8904_EQ_ENA, save);
+}
+
+static int wm8904_put_retune_mobile_enum(struct snd_kcontrol *kcontrol,
+                                         struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct wm8904_priv *wm8904 = codec->private_data;       
+        struct wm8904_pdata *pdata = wm8904->pdata;
+        int value = ucontrol->value.integer.value[0];
+
+        if (value >= pdata->num_retune_mobile_cfgs)
+                return -EINVAL;
+
+        wm8904->retune_mobile_cfg = value;
+
+        wm8904_set_retune_mobile(codec);
+
+        return 0;
+}
+
+static int wm8904_get_retune_mobile_enum(struct snd_kcontrol *kcontrol,
+                                         struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct wm8904_priv *wm8904 = codec->private_data;
+
+        ucontrol->value.enumerated.item[0] = wm8904->retune_mobile_cfg;
+
+        return 0;
+}
+
+static int deemph_settings[] = { 0, 32000, 44100, 48000 };
+
+static int wm8904_set_deemph(struct snd_soc_codec *codec)
+{
+        struct wm8904_priv *wm8904 = codec->private_data;
+        int val, i, best;
+
+        /* If we're using deemphasis select the nearest available sample 
+         * rate.
+         */
+        if (wm8904->deemph) {
+                best = 1;
+                for (i = 2; i < ARRAY_SIZE(deemph_settings); i++) {
+                        if (abs(deemph_settings[i] - wm8904->fs) <
+                            abs(deemph_settings[best] - wm8904->fs))
+                                best = i;
+                }
+
+                val = best << WM8904_DEEMPH_SHIFT;
+        } else {
+                val = 0;
+        }
+
+        dev_dbg(codec->dev, "Set deemphasis %d\n", val);
+
+        return snd_soc_update_bits(codec, WM8904_DAC_DIGITAL_1,
+                                   WM8904_DEEMPH_MASK, val);
+}
+
+static int wm8904_get_deemph(struct snd_kcontrol *kcontrol,
+                             struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct wm8904_priv *wm8904 = codec->private_data;
+
+        return wm8904->deemph;
+}
+
+static int wm8904_put_deemph(struct snd_kcontrol *kcontrol,
+                              struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct wm8904_priv *wm8904 = codec->private_data;
+        int deemph = ucontrol->value.enumerated.item[0];
+
+        if (deemph > 1)
+                return -EINVAL;
+
+        wm8904->deemph = deemph;
+
+        return wm8904_set_deemph(codec);
+}
+
+static const DECLARE_TLV_DB_SCALE(dac_boost_tlv, 0, 600, 0);
+static const DECLARE_TLV_DB_SCALE(digital_tlv, -7200, 75, 1);
+static const DECLARE_TLV_DB_SCALE(out_tlv, -5700, 100, 0);
+static const DECLARE_TLV_DB_SCALE(sidetone_tlv, -3600, 300, 0);
+static const DECLARE_TLV_DB_SCALE(eq_tlv, -1200, 100, 0);
+
+static const char *input_mode_text[] = {
+        "Single-Ended", "Differential Line", "Differential Mic"
+};
+
+static const struct soc_enum lin_mode =
+        SOC_ENUM_SINGLE(WM8904_ANALOGUE_LEFT_INPUT_1, 0, 3, input_mode_text);
+
+static const struct soc_enum rin_mode =
+        SOC_ENUM_SINGLE(WM8904_ANALOGUE_RIGHT_INPUT_1, 0, 3, input_mode_text);
+
+static const char *hpf_mode_text[] = {
+        "Hi-fi", "Voice 1", "Voice 2", "Voice 3"
+};
+
+static const struct soc_enum hpf_mode =
+        SOC_ENUM_SINGLE(WM8904_ADC_DIGITAL_0, 5, 4, hpf_mode_text);
+
+static const struct snd_kcontrol_new wm8904_adc_snd_controls[] = {
+SOC_DOUBLE_R_TLV("Digital Capture Volume", WM8904_ADC_DIGITAL_VOLUME_LEFT,
+                 WM8904_ADC_DIGITAL_VOLUME_RIGHT, 1, 119, 0, digital_tlv),
+
+SOC_ENUM("Left Caputure Mode", lin_mode),
+SOC_ENUM("Right Capture Mode", rin_mode),
+
+/* No TLV since it depends on mode */
+SOC_DOUBLE_R("Capture Volume", WM8904_ANALOGUE_LEFT_INPUT_0,
+             WM8904_ANALOGUE_RIGHT_INPUT_0, 0, 31, 0),
+SOC_DOUBLE_R("Capture Switch", WM8904_ANALOGUE_LEFT_INPUT_0,
+             WM8904_ANALOGUE_RIGHT_INPUT_0, 7, 1, 0),
+
+SOC_SINGLE("High Pass Filter Switch", WM8904_ADC_DIGITAL_0, 4, 1, 0),
+SOC_ENUM("High Pass Filter Mode", hpf_mode),
+
+SOC_SINGLE("ADC 128x OSR Switch", WM8904_ANALOGUE_ADC_0, 0, 1, 0),
+};
+
+static const char *drc_path_text[] = {
+        "ADC", "DAC"
+};
+
+static const struct soc_enum drc_path =
+        SOC_ENUM_SINGLE(WM8904_DRC_0, 14, 2, drc_path_text);
+
+static const struct snd_kcontrol_new wm8904_dac_snd_controls[] = {
+SOC_SINGLE_TLV("Digital Playback Boost Volume", 
+               WM8904_AUDIO_INTERFACE_0, 9, 3, 0, dac_boost_tlv),
+SOC_DOUBLE_R_TLV("Digital Playback Volume", WM8904_DAC_DIGITAL_VOLUME_LEFT,
+                 WM8904_DAC_DIGITAL_VOLUME_RIGHT, 1, 96, 0, digital_tlv),
+
+SOC_DOUBLE_R_TLV("Headphone Volume", WM8904_ANALOGUE_OUT1_LEFT,
+                 WM8904_ANALOGUE_OUT1_RIGHT, 0, 63, 0, out_tlv),
+SOC_DOUBLE_R("Headphone Switch", WM8904_ANALOGUE_OUT1_LEFT,
+             WM8904_ANALOGUE_OUT1_RIGHT, 8, 1, 1),
+SOC_DOUBLE_R("Headphone ZC Switch", WM8904_ANALOGUE_OUT1_LEFT,
+             WM8904_ANALOGUE_OUT1_RIGHT, 6, 1, 0),
+
+SOC_DOUBLE_R_TLV("Line Output Volume", WM8904_ANALOGUE_OUT2_LEFT,
+                 WM8904_ANALOGUE_OUT2_RIGHT, 0, 63, 0, out_tlv),
+SOC_DOUBLE_R("Line Output Switch", WM8904_ANALOGUE_OUT2_LEFT,
+             WM8904_ANALOGUE_OUT2_RIGHT, 8, 1, 1),
+SOC_DOUBLE_R("Line Output ZC Switch", WM8904_ANALOGUE_OUT2_LEFT,
+             WM8904_ANALOGUE_OUT2_RIGHT, 6, 1, 0),
+
+SOC_SINGLE("EQ Switch", WM8904_EQ1, 0, 1, 0),
+SOC_SINGLE("DRC Switch", WM8904_DRC_0, 15, 1, 0),
+SOC_ENUM("DRC Path", drc_path),
+SOC_SINGLE("DAC OSRx2 Switch", WM8904_DAC_DIGITAL_1, 6, 1, 0),
+SOC_SINGLE_BOOL_EXT("DAC Deemphasis Switch", 0,
+                    wm8904_get_deemph, wm8904_put_deemph),
+};
+
+static const struct snd_kcontrol_new wm8904_snd_controls[] = {
+SOC_DOUBLE_TLV("Digital Sidetone Volume", WM8904_DAC_DIGITAL_0, 4, 8, 15, 0,
+               sidetone_tlv),
+};
+
+static const struct snd_kcontrol_new wm8904_eq_controls[] = {
+SOC_SINGLE_TLV("EQ1 Volume", WM8904_EQ2, 0, 24, 0, eq_tlv),
+SOC_SINGLE_TLV("EQ2 Volume", WM8904_EQ3, 0, 24, 0, eq_tlv),
+SOC_SINGLE_TLV("EQ3 Volume", WM8904_EQ4, 0, 24, 0, eq_tlv),
+SOC_SINGLE_TLV("EQ4 Volume", WM8904_EQ5, 0, 24, 0, eq_tlv),
+SOC_SINGLE_TLV("EQ5 Volume", WM8904_EQ6, 0, 24, 0, eq_tlv),
+};
+
+static int cp_event(struct snd_soc_dapm_widget *w,
+                    struct snd_kcontrol *kcontrol, int event)
+{
+        BUG_ON(event != SND_SOC_DAPM_POST_PMU);
+
+        /* Maximum startup time */
+        udelay(500);
+
+        return 0;
+}
+
+static int sysclk_event(struct snd_soc_dapm_widget *w,
+                         struct snd_kcontrol *kcontrol, int event)
+{
+        struct snd_soc_codec *codec = w->codec;
+        struct wm8904_priv *wm8904 = codec->private_data;
+
+        switch (event) {
+        case SND_SOC_DAPM_PRE_PMU:
+                /* If we're using the FLL then we only start it when
+                 * required; we assume that the configuration has been
+                 * done previously and all we need to do is kick it
+                 * off.
+                 */
+                switch (wm8904->sysclk_src) {
+                case WM8904_CLK_FLL:
+                        snd_soc_update_bits(codec, WM8904_FLL_CONTROL_1,
+                                            WM8904_FLL_OSC_ENA,
+                                            WM8904_FLL_OSC_ENA);
+
+                        snd_soc_update_bits(codec, WM8904_FLL_CONTROL_1,
+                                            WM8904_FLL_ENA,
+                                            WM8904_FLL_ENA);
+                        break;
+
+                default:
+                        break;
+                }
+                break;
+
+        case SND_SOC_DAPM_POST_PMD:
+                snd_soc_update_bits(codec, WM8904_FLL_CONTROL_1,
+                                    WM8904_FLL_OSC_ENA | WM8904_FLL_ENA, 0);
+                break;
+        }
+
+        return 0;
+}
+
+static int out_pga_event(struct snd_soc_dapm_widget *w,
+                         struct snd_kcontrol *kcontrol, int event)
+{
+        struct snd_soc_codec *codec = w->codec;
+        struct wm8904_priv *wm8904 = codec->private_data;
+        int reg, val;
+        int dcs_mask;
+        int dcs_l, dcs_r;
+        int dcs_l_reg, dcs_r_reg;
+        int timeout;
+        int pwr_reg;
+
+        /* This code is shared between HP and LINEOUT; we do all our
+         * power management in stereo pairs to avoid latency issues so
+         * we reuse shift to identify which rather than strcmp() the
+         * name. */
+        reg = w->shift;
+
+        switch (reg) {
+        case WM8904_ANALOGUE_HP_0:
+                pwr_reg = WM8904_POWER_MANAGEMENT_2;
+                dcs_mask = WM8904_DCS_ENA_CHAN_0 | WM8904_DCS_ENA_CHAN_1;
+                dcs_r_reg = WM8904_DC_SERVO_8;
+                dcs_l_reg = WM8904_DC_SERVO_9;
+                dcs_l = 0;
+                dcs_r = 1;
+                break;
+        case WM8904_ANALOGUE_LINEOUT_0:
+                pwr_reg = WM8904_POWER_MANAGEMENT_3;
+                dcs_mask = WM8904_DCS_ENA_CHAN_2 | WM8904_DCS_ENA_CHAN_3;
+                dcs_r_reg = WM8904_DC_SERVO_6;
+                dcs_l_reg = WM8904_DC_SERVO_7;
+                dcs_l = 2;
+                dcs_r = 3;
+                break;
+        default:
+                BUG();
+                return -EINVAL;
+        }
+
+        switch (event) {
+        case SND_SOC_DAPM_PRE_PMU:
+                /* Power on the PGAs */
+                snd_soc_update_bits(codec, pwr_reg,
+                                    WM8904_HPL_PGA_ENA | WM8904_HPR_PGA_ENA,
+                                    WM8904_HPL_PGA_ENA | WM8904_HPR_PGA_ENA);
+
+                /* Power on the amplifier */
+                snd_soc_update_bits(codec, reg,
+                                    WM8904_HPL_ENA | WM8904_HPR_ENA,
+                                    WM8904_HPL_ENA | WM8904_HPR_ENA);
+
+
+                /* Enable the first stage */
+                snd_soc_update_bits(codec, reg,
+                                    WM8904_HPL_ENA_DLY | WM8904_HPR_ENA_DLY,
+                                    WM8904_HPL_ENA_DLY | WM8904_HPR_ENA_DLY);
+
+                /* Power up the DC servo */
+                snd_soc_update_bits(codec, WM8904_DC_SERVO_0,
+                                    dcs_mask, dcs_mask);
+
+                /* Either calibrate the DC servo or restore cached state
+                 * if we have that.
+                 */
+                if (wm8904->dcs_state[dcs_l] || wm8904->dcs_state[dcs_r]) {
+                        dev_dbg(codec->dev, "Restoring DC servo state\n");
+
+                        snd_soc_write(codec, dcs_l_reg,
+                                      wm8904->dcs_state[dcs_l]);
+                        snd_soc_write(codec, dcs_r_reg,
+                                      wm8904->dcs_state[dcs_r]);
+
+                        snd_soc_write(codec, WM8904_DC_SERVO_1, dcs_mask);
+
+                        timeout = 20;
+                } else {
+                        dev_dbg(codec->dev, "Calibrating DC servo\n");
+
+                        snd_soc_write(codec, WM8904_DC_SERVO_1,
+                                dcs_mask << WM8904_DCS_TRIG_STARTUP_0_SHIFT);
+
+                        timeout = 500;
+                }
+
+                /* Wait for DC servo to complete */
+                dcs_mask <<= WM8904_DCS_CAL_COMPLETE_SHIFT;
+                do {
+                        val = snd_soc_read(codec, WM8904_DC_SERVO_READBACK_0);
+                        if ((val & dcs_mask) == dcs_mask)
+                                break;
+
+                        msleep(1);
+                } while (--timeout);
+
+                if ((val & dcs_mask) != dcs_mask)
+                        dev_warn(codec->dev, "DC servo timed out\n");
+                else
+                        dev_dbg(codec->dev, "DC servo ready\n");
+
+                /* Enable the output stage */
+                snd_soc_update_bits(codec, reg,
+                                    WM8904_HPL_ENA_OUTP | WM8904_HPR_ENA_OUTP,
+                                    WM8904_HPL_ENA_OUTP | WM8904_HPR_ENA_OUTP);
+                break;
+
+        case SND_SOC_DAPM_POST_PMU:
+                /* Unshort the output itself */
+                snd_soc_update_bits(codec, reg,
+                                    WM8904_HPL_RMV_SHORT |
+                                    WM8904_HPR_RMV_SHORT,
+                                    WM8904_HPL_RMV_SHORT |
+                                    WM8904_HPR_RMV_SHORT);
+
+                break;
+
+        case SND_SOC_DAPM_PRE_PMD:
+                /* Short the output */
+                snd_soc_update_bits(codec, reg,
+                                    WM8904_HPL_RMV_SHORT |
+                                    WM8904_HPR_RMV_SHORT, 0);
+                break;
+
+        case SND_SOC_DAPM_POST_PMD:
+                /* Cache the DC servo configuration; this will be
+                 * invalidated if we change the configuration. */
+                wm8904->dcs_state[dcs_l] = snd_soc_read(codec, dcs_l_reg);
+                wm8904->dcs_state[dcs_r] = snd_soc_read(codec, dcs_r_reg);
+
+                snd_soc_update_bits(codec, WM8904_DC_SERVO_0,
+                                    dcs_mask, 0);
+
+                /* Disable the amplifier input and output stages */
+                snd_soc_update_bits(codec, reg,
+                                    WM8904_HPL_ENA | WM8904_HPR_ENA |
+                                    WM8904_HPL_ENA_DLY | WM8904_HPR_ENA_DLY |
+                                    WM8904_HPL_ENA_OUTP | WM8904_HPR_ENA_OUTP,
+                                    0);
+
+                /* PGAs too */
+                snd_soc_update_bits(codec, pwr_reg,
+                                    WM8904_HPL_PGA_ENA | WM8904_HPR_PGA_ENA,
+                                    0);
+                break;
+        }
+
+        return 0;
+}
+
+static const char *lin_text[] = {
+        "IN1L", "IN2L", "IN3L"
+};
+
+static const struct soc_enum lin_enum =
+        SOC_ENUM_SINGLE(WM8904_ANALOGUE_LEFT_INPUT_1, 2, 3, lin_text);
+
+static const struct snd_kcontrol_new lin_mux =
+        SOC_DAPM_ENUM("Left Capture Mux", lin_enum);
+
+static const struct soc_enum lin_inv_enum =
+        SOC_ENUM_SINGLE(WM8904_ANALOGUE_LEFT_INPUT_1, 4, 3, lin_text);
+
+static const struct snd_kcontrol_new lin_inv_mux =
+        SOC_DAPM_ENUM("Left Capture Inveting Mux", lin_inv_enum);
+
+static const char *rin_text[] = {
+        "IN1R", "IN2R", "IN3R"
+};
+
+static const struct soc_enum rin_enum =
+        SOC_ENUM_SINGLE(WM8904_ANALOGUE_RIGHT_INPUT_1, 2, 3, rin_text);
+
+static const struct snd_kcontrol_new rin_mux =
+        SOC_DAPM_ENUM("Right Capture Mux", rin_enum);
+
+static const struct soc_enum rin_inv_enum =
+        SOC_ENUM_SINGLE(WM8904_ANALOGUE_RIGHT_INPUT_1, 4, 3, rin_text);
+
+static const struct snd_kcontrol_new rin_inv_mux =
+        SOC_DAPM_ENUM("Right Capture Inveting Mux", rin_inv_enum);
+
+static const char *aif_text[] = {
+        "Left", "Right"
+};
+
+static const struct soc_enum aifoutl_enum =
+        SOC_ENUM_SINGLE(WM8904_AUDIO_INTERFACE_0, 7, 2, aif_text);
+
+static const struct snd_kcontrol_new aifoutl_mux =
+        SOC_DAPM_ENUM("AIFOUTL Mux", aifoutl_enum);
+
+static const struct soc_enum aifoutr_enum =
+        SOC_ENUM_SINGLE(WM8904_AUDIO_INTERFACE_0, 6, 2, aif_text);
+
+static const struct snd_kcontrol_new aifoutr_mux =
+        SOC_DAPM_ENUM("AIFOUTR Mux", aifoutr_enum);
+
+static const struct soc_enum aifinl_enum =
+        SOC_ENUM_SINGLE(WM8904_AUDIO_INTERFACE_0, 5, 2, aif_text);
+
+static const struct snd_kcontrol_new aifinl_mux =
+        SOC_DAPM_ENUM("AIFINL Mux", aifinl_enum);
+
+static const struct soc_enum aifinr_enum =
+        SOC_ENUM_SINGLE(WM8904_AUDIO_INTERFACE_0, 4, 2, aif_text);
+
+static const struct snd_kcontrol_new aifinr_mux =
+        SOC_DAPM_ENUM("AIFINR Mux", aifinr_enum);
+
+static const struct snd_soc_dapm_widget wm8904_core_dapm_widgets[] = {
+SND_SOC_DAPM_SUPPLY("SYSCLK", WM8904_CLOCK_RATES_2, 2, 0, sysclk_event,
+                    SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
+SND_SOC_DAPM_SUPPLY("CLK_DSP", WM8904_CLOCK_RATES_2, 1, 0, NULL, 0),
+SND_SOC_DAPM_SUPPLY("TOCLK", WM8904_CLOCK_RATES_2, 0, 0, NULL, 0),
+};
+
+static const struct snd_soc_dapm_widget wm8904_adc_dapm_widgets[] = {
+SND_SOC_DAPM_INPUT("IN1L"),
+SND_SOC_DAPM_INPUT("IN1R"),
+SND_SOC_DAPM_INPUT("IN2L"),
+SND_SOC_DAPM_INPUT("IN2R"),
+SND_SOC_DAPM_INPUT("IN3L"),
+SND_SOC_DAPM_INPUT("IN3R"),
+
+SND_SOC_DAPM_MICBIAS("MICBIAS", WM8904_MIC_BIAS_CONTROL_0, 0, 0),
+
+SND_SOC_DAPM_MUX("Left Capture Mux", SND_SOC_NOPM, 0, 0, &lin_mux),
+SND_SOC_DAPM_MUX("Left Capture Inverting Mux", SND_SOC_NOPM, 0, 0,
+                 &lin_inv_mux),
+SND_SOC_DAPM_MUX("Right Capture Mux", SND_SOC_NOPM, 0, 0, &rin_mux),
+SND_SOC_DAPM_MUX("Right Capture Inverting Mux", SND_SOC_NOPM, 0, 0,
+                 &rin_inv_mux),
+
+SND_SOC_DAPM_PGA("Left Capture PGA", WM8904_POWER_MANAGEMENT_0, 1, 0,
+                 NULL, 0),
+SND_SOC_DAPM_PGA("Right Capture PGA", WM8904_POWER_MANAGEMENT_0, 0, 0,
+                 NULL, 0),
+
+SND_SOC_DAPM_ADC("ADCL", NULL, WM8904_POWER_MANAGEMENT_6, 1, 0),
+SND_SOC_DAPM_ADC("ADCR", NULL, WM8904_POWER_MANAGEMENT_6, 0, 0),
+
+SND_SOC_DAPM_MUX("AIFOUTL Mux", SND_SOC_NOPM, 0, 0, &aifoutl_mux),
+SND_SOC_DAPM_MUX("AIFOUTR Mux", SND_SOC_NOPM, 0, 0, &aifoutr_mux),
+
+SND_SOC_DAPM_AIF_OUT("AIFOUTL", "Capture", 0, SND_SOC_NOPM, 0, 0),
+SND_SOC_DAPM_AIF_OUT("AIFOUTR", "Capture", 1, SND_SOC_NOPM, 0, 0),
+};
+
+static const struct snd_soc_dapm_widget wm8904_dac_dapm_widgets[] = {
+SND_SOC_DAPM_AIF_IN("AIFINL", "Playback", 0, SND_SOC_NOPM, 0, 0),
+SND_SOC_DAPM_AIF_IN("AIFINR", "Playback", 1, SND_SOC_NOPM, 0, 0),
+
+SND_SOC_DAPM_MUX("DACL Mux", SND_SOC_NOPM, 0, 0, &aifinl_mux),
+SND_SOC_DAPM_MUX("DACR Mux", SND_SOC_NOPM, 0, 0, &aifinr_mux),
+
+SND_SOC_DAPM_DAC("DACL", NULL, WM8904_POWER_MANAGEMENT_6, 3, 0),
+SND_SOC_DAPM_DAC("DACR", NULL, WM8904_POWER_MANAGEMENT_6, 2, 0),
+
+SND_SOC_DAPM_SUPPLY("Charge pump", WM8904_CHARGE_PUMP_0, 0, 0, cp_event,
+                    SND_SOC_DAPM_POST_PMU),
+
+SND_SOC_DAPM_PGA("HPL PGA", SND_SOC_NOPM, 1, 0, NULL, 0),
+SND_SOC_DAPM_PGA("HPR PGA", SND_SOC_NOPM, 0, 0, NULL, 0),
+
+SND_SOC_DAPM_PGA("LINEL PGA", SND_SOC_NOPM, 1, 0, NULL, 0),
+SND_SOC_DAPM_PGA("LINER PGA", SND_SOC_NOPM, 0, 0, NULL, 0),
+
+SND_SOC_DAPM_PGA_E("Headphone Output", SND_SOC_NOPM, WM8904_ANALOGUE_HP_0,
+                   0, NULL, 0, out_pga_event,
+                   SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
+                   SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMD),
+SND_SOC_DAPM_PGA_E("Line Output", SND_SOC_NOPM, WM8904_ANALOGUE_LINEOUT_0,
+                   0, NULL, 0, out_pga_event,
+                   SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
+                   SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMD),
+
+SND_SOC_DAPM_OUTPUT("HPOUTL"),
+SND_SOC_DAPM_OUTPUT("HPOUTR"),
+SND_SOC_DAPM_OUTPUT("LINEOUTL"),
+SND_SOC_DAPM_OUTPUT("LINEOUTR"),
+};
+
+static const char *out_mux_text[] = {
+        "DAC", "Bypass"
+};
+
+static const struct soc_enum hpl_enum =
+        SOC_ENUM_SINGLE(WM8904_ANALOGUE_OUT12_ZC, 3, 2, out_mux_text);
+
+static const struct snd_kcontrol_new hpl_mux =
+        SOC_DAPM_ENUM("HPL Mux", hpl_enum);
+
+static const struct soc_enum hpr_enum =
+        SOC_ENUM_SINGLE(WM8904_ANALOGUE_OUT12_ZC, 2, 2, out_mux_text);
+
+static const struct snd_kcontrol_new hpr_mux =
+        SOC_DAPM_ENUM("HPR Mux", hpr_enum);
+
+static const struct soc_enum linel_enum =
+        SOC_ENUM_SINGLE(WM8904_ANALOGUE_OUT12_ZC, 1, 2, out_mux_text);
+
+static const struct snd_kcontrol_new linel_mux =
+        SOC_DAPM_ENUM("LINEL Mux", linel_enum);
+
+static const struct soc_enum liner_enum =
+        SOC_ENUM_SINGLE(WM8904_ANALOGUE_OUT12_ZC, 0, 2, out_mux_text);
+
+static const struct snd_kcontrol_new liner_mux =
+        SOC_DAPM_ENUM("LINEL Mux", liner_enum);
+
+static const char *sidetone_text[] = {
+        "None", "Left", "Right"
+};
+
+static const struct soc_enum dacl_sidetone_enum =
+        SOC_ENUM_SINGLE(WM8904_DAC_DIGITAL_0, 2, 3, sidetone_text);
+
+static const struct snd_kcontrol_new dacl_sidetone_mux =
+        SOC_DAPM_ENUM("Left Sidetone Mux", dacl_sidetone_enum);
+
+static const struct soc_enum dacr_sidetone_enum =
+        SOC_ENUM_SINGLE(WM8904_DAC_DIGITAL_0, 0, 3, sidetone_text);
+
+static const struct snd_kcontrol_new dacr_sidetone_mux =
+        SOC_DAPM_ENUM("Right Sidetone Mux", dacr_sidetone_enum);
+
+static const struct snd_soc_dapm_widget wm8904_dapm_widgets[] = {
+SND_SOC_DAPM_SUPPLY("Class G", WM8904_CLASS_W_0, 0, 1, NULL, 0),
+SND_SOC_DAPM_PGA("Left Bypass", SND_SOC_NOPM, 0, 0, NULL, 0),
+SND_SOC_DAPM_PGA("Right Bypass", SND_SOC_NOPM, 0, 0, NULL, 0),
+
+SND_SOC_DAPM_MUX("Left Sidetone", SND_SOC_NOPM, 0, 0, &dacl_sidetone_mux),
+SND_SOC_DAPM_MUX("Right Sidetone", SND_SOC_NOPM, 0, 0, &dacr_sidetone_mux),
+
+SND_SOC_DAPM_MUX("HPL Mux", SND_SOC_NOPM, 0, 0, &hpl_mux),
+SND_SOC_DAPM_MUX("HPR Mux", SND_SOC_NOPM, 0, 0, &hpr_mux),
+SND_SOC_DAPM_MUX("LINEL Mux", SND_SOC_NOPM, 0, 0, &linel_mux),
+SND_SOC_DAPM_MUX("LINER Mux", SND_SOC_NOPM, 0, 0, &liner_mux),
+};
+
+static const struct snd_soc_dapm_route core_intercon[] = {
+        { "CLK_DSP", NULL, "SYSCLK" },
+        { "TOCLK", NULL, "SYSCLK" },
+};
+
+static const struct snd_soc_dapm_route adc_intercon[] = {
+        { "Left Capture Mux", "IN1L", "IN1L" },
+        { "Left Capture Mux", "IN2L", "IN2L" },
+        { "Left Capture Mux", "IN3L", "IN3L" },
+
+        { "Left Capture Inverting Mux", "IN1L", "IN1L" },
+        { "Left Capture Inverting Mux", "IN2L", "IN2L" },
+        { "Left Capture Inverting Mux", "IN3L", "IN3L" },
+
+        { "Right Capture Mux", "IN1R", "IN1R" },
+        { "Right Capture Mux", "IN2R", "IN2R" },
+        { "Right Capture Mux", "IN3R", "IN3R" },
+
+        { "Right Capture Inverting Mux", "IN1R", "IN1R" },
+        { "Right Capture Inverting Mux", "IN2R", "IN2R" },
+        { "Right Capture Inverting Mux", "IN3R", "IN3R" },
+
+        { "Left Capture PGA", NULL, "Left Capture Mux" },
+        { "Left Capture PGA", NULL, "Left Capture Inverting Mux" },
+
+        { "Right Capture PGA", NULL, "Right Capture Mux" },
+        { "Right Capture PGA", NULL, "Right Capture Inverting Mux" },
+
+        { "AIFOUTL", "Left",  "ADCL" },
+        { "AIFOUTL", "Right", "ADCR" },
+        { "AIFOUTR", "Left",  "ADCL" },
+        { "AIFOUTR", "Right", "ADCR" },
+
+        { "ADCL", NULL, "CLK_DSP" },
+        { "ADCL", NULL, "Left Capture PGA" },
+
+        { "ADCR", NULL, "CLK_DSP" },
+        { "ADCR", NULL, "Right Capture PGA" },
+};
+
+static const struct snd_soc_dapm_route dac_intercon[] = {
+        { "DACL", "Right", "AIFINR" },
+        { "DACL", "Left",  "AIFINL" },
+        { "DACL", NULL, "CLK_DSP" },
+
+        { "DACR", "Right", "AIFINR" },
+        { "DACR", "Left",  "AIFINL" },
+        { "DACR", NULL, "CLK_DSP" },
+
+        { "Charge pump", NULL, "SYSCLK" },
+
+        { "Headphone Output", NULL, "HPL PGA" },
+        { "Headphone Output", NULL, "HPR PGA" },
+        { "Headphone Output", NULL, "Charge pump" },
+        { "Headphone Output", NULL, "TOCLK" },
+
+        { "Line Output", NULL, "LINEL PGA" },
+        { "Line Output", NULL, "LINER PGA" },
+        { "Line Output", NULL, "Charge pump" },
+        { "Line Output", NULL, "TOCLK" },
+
+        { "HPOUTL", NULL, "Headphone Output" },
+        { "HPOUTR", NULL, "Headphone Output" },
+
+        { "LINEOUTL", NULL, "Line Output" },
+        { "LINEOUTR", NULL, "Line Output" },
+};
+
+static const struct snd_soc_dapm_route wm8904_intercon[] = {
+        { "Left Sidetone", "Left", "ADCL" },
+        { "Left Sidetone", "Right", "ADCR" },
+        { "DACL", NULL, "Left Sidetone" },
+        
+        { "Right Sidetone", "Left", "ADCL" },
+        { "Right Sidetone", "Right", "ADCR" },
+        { "DACR", NULL, "Right Sidetone" },
+
+        { "Left Bypass", NULL, "Class G" },
+        { "Left Bypass", NULL, "Left Capture PGA" },
+
+        { "Right Bypass", NULL, "Class G" },
+        { "Right Bypass", NULL, "Right Capture PGA" },
+
+        { "HPL Mux", "DAC", "DACL" },
+        { "HPL Mux", "Bypass", "Left Bypass" },
+
+        { "HPR Mux", "DAC", "DACR" },
+        { "HPR Mux", "Bypass", "Right Bypass" },
+
+        { "LINEL Mux", "DAC", "DACL" },
+        { "LINEL Mux", "Bypass", "Left Bypass" },
+
+        { "LINER Mux", "DAC", "DACR" },
+        { "LINER Mux", "Bypass", "Right Bypass" },
+
+        { "HPL PGA", NULL, "HPL Mux" },
+        { "HPR PGA", NULL, "HPR Mux" },
+
+        { "LINEL PGA", NULL, "LINEL Mux" },
+        { "LINER PGA", NULL, "LINER Mux" },
+};
+
+static const struct snd_soc_dapm_route wm8912_intercon[] = {
+        { "HPL PGA", NULL, "DACL" },
+        { "HPR PGA", NULL, "DACR" },
+
+        { "LINEL PGA", NULL, "DACL" },
+        { "LINER PGA", NULL, "DACR" },
+};
+
+static int wm8904_add_widgets(struct snd_soc_codec *codec)
+{
+        struct wm8904_priv *wm8904 = codec->private_data;
+
+        snd_soc_dapm_new_controls(codec, wm8904_core_dapm_widgets,
+                                  ARRAY_SIZE(wm8904_core_dapm_widgets));
+        snd_soc_dapm_add_routes(codec, core_intercon,
+                                ARRAY_SIZE(core_intercon));
+
+        switch (wm8904->devtype) {
+        case WM8904:
+                snd_soc_add_controls(codec, wm8904_adc_snd_controls,
+                                     ARRAY_SIZE(wm8904_adc_snd_controls));
+                snd_soc_add_controls(codec, wm8904_dac_snd_controls,
+                                     ARRAY_SIZE(wm8904_dac_snd_controls));
+                snd_soc_add_controls(codec, wm8904_snd_controls,
+                                     ARRAY_SIZE(wm8904_snd_controls));
+
+                snd_soc_dapm_new_controls(codec, wm8904_adc_dapm_widgets,
+                                          ARRAY_SIZE(wm8904_adc_dapm_widgets));
+                snd_soc_dapm_new_controls(codec, wm8904_dac_dapm_widgets,
+                                          ARRAY_SIZE(wm8904_dac_dapm_widgets));
+                snd_soc_dapm_new_controls(codec, wm8904_dapm_widgets,
+                                          ARRAY_SIZE(wm8904_dapm_widgets));
+
+                snd_soc_dapm_add_routes(codec, core_intercon,
+                                        ARRAY_SIZE(core_intercon));
+                snd_soc_dapm_add_routes(codec, adc_intercon,
+                                        ARRAY_SIZE(adc_intercon));
+                snd_soc_dapm_add_routes(codec, dac_intercon,
+                                        ARRAY_SIZE(dac_intercon));
+                snd_soc_dapm_add_routes(codec, wm8904_intercon,
+                                        ARRAY_SIZE(wm8904_intercon));
+                break;
+
+        case WM8912:
+                snd_soc_add_controls(codec, wm8904_dac_snd_controls,
+                                     ARRAY_SIZE(wm8904_dac_snd_controls));
+
+                snd_soc_dapm_new_controls(codec, wm8904_dac_dapm_widgets,
+                                          ARRAY_SIZE(wm8904_dac_dapm_widgets));
+
+                snd_soc_dapm_add_routes(codec, dac_intercon,
+                                        ARRAY_SIZE(dac_intercon));
+                snd_soc_dapm_add_routes(codec, wm8912_intercon,
+                                        ARRAY_SIZE(wm8912_intercon));
+                break;
+        }
+
+        snd_soc_dapm_new_widgets(codec);
+        return 0;
+}
+
+static struct {
+        int ratio;
+        unsigned int clk_sys_rate;
+} clk_sys_rates[] = {
+        {   64,  0 },
+        {  128,  1 },
+        {  192,  2 },
+        {  256,  3 },
+        {  384,  4 },
+        {  512,  5 },
+        {  786,  6 },
+        { 1024,  7 },
+        { 1408,  8 },
+        { 1536,  9 },
+};
+
+static struct {
+        int rate;
+        int sample_rate;
+} sample_rates[] = {
+        { 8000,  0  },
+        { 11025, 1  },
+        { 12000, 1  },
+        { 16000, 2  },
+        { 22050, 3  },
+        { 24000, 3  },
+        { 32000, 4  },
+        { 44100, 5  },
+        { 48000, 5  },
+};
+
+static struct {
+        int div; /* *10 due to .5s */
+        int bclk_div;
+} bclk_divs[] = {
+        { 10,  0  },
+        { 15,  1  },
+        { 20,  2  },
+        { 30,  3  },
+        { 40,  4  },
+        { 50,  5  },
+        { 55,  6  },
+        { 60,  7  },
+        { 80,  8  },
+        { 100, 9  },
+        { 110, 10 },
+        { 120, 11 },
+        { 160, 12 },
+        { 200, 13 },
+        { 220, 14 },
+        { 240, 16 },
+        { 200, 17 },
+        { 320, 18 },
+        { 440, 19 },
+        { 480, 20 },
+};
+
+
+static int wm8904_hw_params(struct snd_pcm_substream *substream,
+                            struct snd_pcm_hw_params *params,
+                            struct snd_soc_dai *dai)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        struct wm8904_priv *wm8904 = codec->private_data;
+        int ret, i, best, best_val, cur_val;
+        unsigned int aif1 = 0;
+        unsigned int aif2 = 0;
+        unsigned int aif3 = 0;
+        unsigned int clock1 = 0;
+        unsigned int dac_digital1 = 0;
+
+        /* What BCLK do we need? */
+        wm8904->fs = params_rate(params);
+        if (wm8904->tdm_slots) {
+                dev_dbg(codec->dev, "Configuring for %d %d bit TDM slots\n",
+                        wm8904->tdm_slots, wm8904->tdm_width);
+                wm8904->bclk = snd_soc_calc_bclk(wm8904->fs,
+                                                 wm8904->tdm_width, 2,
+                                                 wm8904->tdm_slots);
+        } else {
+                wm8904->bclk = snd_soc_params_to_bclk(params);
+        }
+
+        switch (params_format(params)) {
+        case SNDRV_PCM_FORMAT_S16_LE:
+                break;
+        case SNDRV_PCM_FORMAT_S20_3LE:
+                aif1 |= 0x40;
+                break;
+        case SNDRV_PCM_FORMAT_S24_LE:
+                aif1 |= 0x80;
+                break;
+        case SNDRV_PCM_FORMAT_S32_LE:
+                aif1 |= 0xc0;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+
+        dev_dbg(codec->dev, "Target BCLK is %dHz\n", wm8904->bclk);
+
+        ret = wm8904_configure_clocking(codec);
+        if (ret != 0)
+                return ret;
+
+        /* Select nearest CLK_SYS_RATE */
+        best = 0;
+        best_val = abs((wm8904->sysclk_rate / clk_sys_rates[0].ratio)
+                       - wm8904->fs);
+        for (i = 1; i < ARRAY_SIZE(clk_sys_rates); i++) {
+                cur_val = abs((wm8904->sysclk_rate /
+                               clk_sys_rates[i].ratio) - wm8904->fs);;
+                if (cur_val < best_val) {
+                        best = i;
+                        best_val = cur_val;
+                }
+        }
+        dev_dbg(codec->dev, "Selected CLK_SYS_RATIO of %d\n",
+                clk_sys_rates[best].ratio);
+        clock1 |= (clk_sys_rates[best].clk_sys_rate
+                   << WM8904_CLK_SYS_RATE_SHIFT);
+
+        /* SAMPLE_RATE */
+        best = 0;
+        best_val = abs(wm8904->fs - sample_rates[0].rate);
+        for (i = 1; i < ARRAY_SIZE(sample_rates); i++) {
+                /* Closest match */
+                cur_val = abs(wm8904->fs - sample_rates[i].rate);
+                if (cur_val < best_val) {
+                        best = i;
+                        best_val = cur_val;
+                }
+        }
+        dev_dbg(codec->dev, "Selected SAMPLE_RATE of %dHz\n",
+                sample_rates[best].rate);
+        clock1 |= (sample_rates[best].sample_rate
+                   << WM8904_SAMPLE_RATE_SHIFT);
+
+        /* Enable sloping stopband filter for low sample rates */
+        if (wm8904->fs <= 24000)
+                dac_digital1 |= WM8904_DAC_SB_FILT;
+
+        /* BCLK_DIV */
+        best = 0;
+        best_val = INT_MAX;
+        for (i = 0; i < ARRAY_SIZE(bclk_divs); i++) {
+                cur_val = ((wm8904->sysclk_rate * 10) / bclk_divs[i].div)
+                        - wm8904->bclk;
+                if (cur_val < 0) /* Table is sorted */
+                        break;
+                if (cur_val < best_val) {
+                        best = i;
+                        best_val = cur_val;
+                }
+        }
+        wm8904->bclk = (wm8904->sysclk_rate * 10) / bclk_divs[best].div;
+        dev_dbg(codec->dev, "Selected BCLK_DIV of %d for %dHz BCLK\n",
+                bclk_divs[best].div, wm8904->bclk);
+        aif2 |= bclk_divs[best].bclk_div;
+
+        /* LRCLK is a simple fraction of BCLK */
+        dev_dbg(codec->dev, "LRCLK_RATE is %d\n", wm8904->bclk / wm8904->fs);
+        aif3 |= wm8904->bclk / wm8904->fs;
+
+        /* Apply the settings */
+        snd_soc_update_bits(codec, WM8904_DAC_DIGITAL_1,
+                            WM8904_DAC_SB_FILT, dac_digital1);
+        snd_soc_update_bits(codec, WM8904_AUDIO_INTERFACE_1,
+                            WM8904_AIF_WL_MASK, aif1);
+        snd_soc_update_bits(codec, WM8904_AUDIO_INTERFACE_2,
+                            WM8904_BCLK_DIV_MASK, aif2);
+        snd_soc_update_bits(codec, WM8904_AUDIO_INTERFACE_3,
+                            WM8904_LRCLK_RATE_MASK, aif3);
+        snd_soc_update_bits(codec, WM8904_CLOCK_RATES_1,
+                            WM8904_SAMPLE_RATE_MASK |
+                            WM8904_CLK_SYS_RATE_MASK, clock1);
+
+        /* Update filters for the new settings */
+        wm8904_set_retune_mobile(codec);
+        wm8904_set_deemph(codec);
+
+        return 0;
+}
+
+
+static int wm8904_set_sysclk(struct snd_soc_dai *dai, int clk_id,
+                             unsigned int freq, int dir)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        struct wm8904_priv *priv = codec->private_data;
+
+        switch (clk_id) {
+        case WM8904_CLK_MCLK:
+                priv->sysclk_src = clk_id;
+                priv->mclk_rate = freq;
+                break;
+
+        case WM8904_CLK_FLL:
+                priv->sysclk_src = clk_id;
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        dev_dbg(dai->dev, "Clock source is %d at %uHz\n", clk_id, freq);
+
+        wm8904_configure_clocking(codec);
+
+        return 0;
+}
+
+static int wm8904_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        unsigned int aif1 = 0;
+        unsigned int aif3 = 0;
+
+        switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
+        case SND_SOC_DAIFMT_CBS_CFS:
+                break;
+        case SND_SOC_DAIFMT_CBS_CFM:
+                aif3 |= WM8904_LRCLK_DIR;
+                break;
+        case SND_SOC_DAIFMT_CBM_CFS:
+                aif1 |= WM8904_BCLK_DIR;
+                break;
+        case SND_SOC_DAIFMT_CBM_CFM:
+                aif1 |= WM8904_BCLK_DIR;
+                aif3 |= WM8904_LRCLK_DIR;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
+        case SND_SOC_DAIFMT_DSP_B:
+                aif1 |= WM8904_AIF_LRCLK_INV;
+        case SND_SOC_DAIFMT_DSP_A:
+                aif1 |= 0x3;
+                break;
+        case SND_SOC_DAIFMT_I2S:
+                aif1 |= 0x2;
+                break;
+        case SND_SOC_DAIFMT_RIGHT_J:
+                break;
+        case SND_SOC_DAIFMT_LEFT_J:
+                aif1 |= 0x1;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
+        case SND_SOC_DAIFMT_DSP_A:
+        case SND_SOC_DAIFMT_DSP_B:
+                /* frame inversion not valid for DSP modes */
+                switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
+                case SND_SOC_DAIFMT_NB_NF:
+                        break;
+                case SND_SOC_DAIFMT_IB_NF:
+                        aif1 |= WM8904_AIF_BCLK_INV;
+                        break;
+                default:
+                        return -EINVAL;
+                }
+                break;
+
+        case SND_SOC_DAIFMT_I2S:
+        case SND_SOC_DAIFMT_RIGHT_J:
+        case SND_SOC_DAIFMT_LEFT_J:
+                switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
+                case SND_SOC_DAIFMT_NB_NF:
+                        break;
+                case SND_SOC_DAIFMT_IB_IF:
+                        aif1 |= WM8904_AIF_BCLK_INV | WM8904_AIF_LRCLK_INV;
+                        break;
+                case SND_SOC_DAIFMT_IB_NF:
+                        aif1 |= WM8904_AIF_BCLK_INV;
+                        break;
+                case SND_SOC_DAIFMT_NB_IF:
+                        aif1 |= WM8904_AIF_LRCLK_INV;
+                        break;
+                default:
+                        return -EINVAL;
+                }
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        snd_soc_update_bits(codec, WM8904_AUDIO_INTERFACE_1,
+                            WM8904_AIF_BCLK_INV | WM8904_AIF_LRCLK_INV |
+                            WM8904_AIF_FMT_MASK | WM8904_BCLK_DIR, aif1);
+        snd_soc_update_bits(codec, WM8904_AUDIO_INTERFACE_3,
+                            WM8904_LRCLK_DIR, aif3);
+
+        return 0;
+}
+
+
+static int wm8904_set_tdm_slot(struct snd_soc_dai *dai, unsigned int tx_mask,
+                               unsigned int rx_mask, int slots, int slot_width)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        struct wm8904_priv *wm8904 = codec->private_data;
+        int aif1 = 0;
+
+        /* Don't need to validate anything if we're turning off TDM */
+        if (slots == 0)
+                goto out;
+
+        /* Note that we allow configurations we can't handle ourselves - 
+         * for example, we can generate clocks for slots 2 and up even if
+         * we can't use those slots ourselves.
+         */
+        aif1 |= WM8904_AIFADC_TDM | WM8904_AIFDAC_TDM;
+
+        switch (rx_mask) {
+        case 3:
+                break;
+        case 0xc:
+                aif1 |= WM8904_AIFADC_TDM_CHAN;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+
+        switch (tx_mask) {
+        case 3:
+                break;
+        case 0xc:
+                aif1 |= WM8904_AIFDAC_TDM_CHAN;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+out:
+        wm8904->tdm_width = slot_width;
+        wm8904->tdm_slots = slots / 2;
+
+        snd_soc_update_bits(codec, WM8904_AUDIO_INTERFACE_1,
+                            WM8904_AIFADC_TDM | WM8904_AIFADC_TDM_CHAN |
+                            WM8904_AIFDAC_TDM | WM8904_AIFDAC_TDM_CHAN, aif1);
+
+        return 0;
+}
+
+struct _fll_div {
+        u16 fll_fratio;
+        u16 fll_outdiv;
+        u16 fll_clk_ref_div;
+        u16 n;
+        u16 k;
+};
+
+/* The size in bits of the FLL divide multiplied by 10
+ * to allow rounding later */
+#define FIXED_FLL_SIZE ((1 << 16) * 10)
+
+static struct {
+        unsigned int min;
+        unsigned int max;
+        u16 fll_fratio;
+        int ratio;
+} fll_fratios[] = {
+        {       0,    64000, 4, 16 },
+        {   64000,   128000, 3,  8 },
+        {  128000,   256000, 2,  4 },
+        {  256000,  1000000, 1,  2 },
+        { 1000000, 13500000, 0,  1 },
+};
+
+static int fll_factors(struct _fll_div *fll_div, unsigned int Fref,
+                       unsigned int Fout)
+{
+        u64 Kpart;
+        unsigned int K, Ndiv, Nmod, target;
+        unsigned int div;
+        int i;
+
+        /* Fref must be <=13.5MHz */
+        div = 1;
+        fll_div->fll_clk_ref_div = 0;
+        while ((Fref / div) > 13500000) {
+                div *= 2;
+                fll_div->fll_clk_ref_div++;
+
+                if (div > 8) {
+                        pr_err("Can't scale %dMHz input down to <=13.5MHz\n",
+                               Fref);
+                        return -EINVAL;
+                }
+        }
+
+        pr_debug("Fref=%u Fout=%u\n", Fref, Fout);
+
+        /* Apply the division for our remaining calculations */
+        Fref /= div;
+
+        /* Fvco should be 90-100MHz; don't check the upper bound */
+        div = 4;
+        while (Fout * div < 90000000) {
+                div++;
+                if (div > 64) {
+                        pr_err("Unable to find FLL_OUTDIV for Fout=%uHz\n",
+                               Fout);
+                        return -EINVAL;
+                }
+        }
+        target = Fout * div;
+        fll_div->fll_outdiv = div - 1;
+
+        pr_debug("Fvco=%dHz\n", target);
+
+        /* Find an appropraite FLL_FRATIO and factor it out of the target */
+        for (i = 0; i < ARRAY_SIZE(fll_fratios); i++) {
+                if (fll_fratios[i].min <= Fref && Fref <= fll_fratios[i].max) {
+                        fll_div->fll_fratio = fll_fratios[i].fll_fratio;
+                        target /= fll_fratios[i].ratio;
+                        break;
+                }
+        }
+        if (i == ARRAY_SIZE(fll_fratios)) {
+                pr_err("Unable to find FLL_FRATIO for Fref=%uHz\n", Fref);
+                return -EINVAL;
+        }
+
+        /* Now, calculate N.K */
+        Ndiv = target / Fref;
+
+        fll_div->n = Ndiv;
+        Nmod = target % Fref;
+        pr_debug("Nmod=%d\n", Nmod);
+
+        /* Calculate fractional part - scale up so we can round. */
+        Kpart = FIXED_FLL_SIZE * (long long)Nmod;
+
+        do_div(Kpart, Fref);
+
+        K = Kpart & 0xFFFFFFFF;
+
+        if ((K % 10) >= 5)
+                K += 5;
+
+        /* Move down to proper range now rounding is done */
+        fll_div->k = K / 10;
+
+        pr_debug("N=%x K=%x FLL_FRATIO=%x FLL_OUTDIV=%x FLL_CLK_REF_DIV=%x\n",
+                 fll_div->n, fll_div->k,
+                 fll_div->fll_fratio, fll_div->fll_outdiv,
+                 fll_div->fll_clk_ref_div);
+
+        return 0;
+}
+
+static int wm8904_set_fll(struct snd_soc_dai *dai, int fll_id, int source,
+                          unsigned int Fref, unsigned int Fout)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        struct wm8904_priv *wm8904 = codec->private_data;
+        struct _fll_div fll_div;
+        int ret, val;
+        int clock2, fll1;
+
+        /* Any change? */
+        if (source == wm8904->fll_src && Fref == wm8904->fll_fref &&
+            Fout == wm8904->fll_fout)
+                return 0;
+
+        clock2 = snd_soc_read(codec, WM8904_CLOCK_RATES_2);
+
+        if (Fout == 0) {
+                dev_dbg(codec->dev, "FLL disabled\n");
+
+                wm8904->fll_fref = 0;
+                wm8904->fll_fout = 0;
+
+                /* Gate SYSCLK to avoid glitches */
+                snd_soc_update_bits(codec, WM8904_CLOCK_RATES_2,
+                                    WM8904_CLK_SYS_ENA, 0);
+
+                snd_soc_update_bits(codec, WM8904_FLL_CONTROL_1,
+                                    WM8904_FLL_OSC_ENA | WM8904_FLL_ENA, 0);
+
+                goto out;
+        }
+
+        /* Validate the FLL ID */
+        switch (source) {
+        case WM8904_FLL_MCLK:
+        case WM8904_FLL_LRCLK:
+        case WM8904_FLL_BCLK:
+                ret = fll_factors(&fll_div, Fref, Fout);
+                if (ret != 0)
+                        return ret;
+                break;
+
+        case WM8904_FLL_FREE_RUNNING:
+                dev_dbg(codec->dev, "Using free running FLL\n");
+                /* Force 12MHz and output/4 for now */
+                Fout = 12000000;
+                Fref = 12000000;
+
+                memset(&fll_div, 0, sizeof(fll_div));
+                fll_div.fll_outdiv = 3;
+                break;
+
+        default:
+                dev_err(codec->dev, "Unknown FLL ID %d\n", fll_id);
+                return -EINVAL;
+        }
+
+        /* Save current state then disable the FLL and SYSCLK to avoid
+         * misclocking */
+        fll1 = snd_soc_read(codec, WM8904_FLL_CONTROL_1);
+        snd_soc_update_bits(codec, WM8904_CLOCK_RATES_2,
+                            WM8904_CLK_SYS_ENA, 0);
+        snd_soc_update_bits(codec, WM8904_FLL_CONTROL_1,
+                            WM8904_FLL_OSC_ENA | WM8904_FLL_ENA, 0);
+
+        /* Unlock forced oscilator control to switch it on/off */
+        snd_soc_update_bits(codec, WM8904_CONTROL_INTERFACE_TEST_1,
+                            WM8904_USER_KEY, WM8904_USER_KEY);
+
+        if (fll_id == WM8904_FLL_FREE_RUNNING) {
+                val = WM8904_FLL_FRC_NCO;
+        } else {
+                val = 0;
+        }
+
+        snd_soc_update_bits(codec, WM8904_FLL_NCO_TEST_1, WM8904_FLL_FRC_NCO,
+                            val);
+        snd_soc_update_bits(codec, WM8904_CONTROL_INTERFACE_TEST_1,
+                            WM8904_USER_KEY, 0);
+
+        switch (fll_id) {
+        case WM8904_FLL_MCLK:
+                snd_soc_update_bits(codec, WM8904_FLL_CONTROL_5,
+                                    WM8904_FLL_CLK_REF_SRC_MASK, 0);
+                break;
+
+        case WM8904_FLL_LRCLK:
+                snd_soc_update_bits(codec, WM8904_FLL_CONTROL_5,
+                                    WM8904_FLL_CLK_REF_SRC_MASK, 1);
+                break;
+
+        case WM8904_FLL_BCLK:
+                snd_soc_update_bits(codec, WM8904_FLL_CONTROL_5,
+                                    WM8904_FLL_CLK_REF_SRC_MASK, 2);
+                break;
+        }
+
+        if (fll_div.k)
+                val = WM8904_FLL_FRACN_ENA;
+        else
+                val = 0;
+        snd_soc_update_bits(codec, WM8904_FLL_CONTROL_1,
+                            WM8904_FLL_FRACN_ENA, val);
+
+        snd_soc_update_bits(codec, WM8904_FLL_CONTROL_2,
+                            WM8904_FLL_OUTDIV_MASK | WM8904_FLL_FRATIO_MASK,
+                            (fll_div.fll_outdiv << WM8904_FLL_OUTDIV_SHIFT) |
+                            (fll_div.fll_fratio << WM8904_FLL_FRATIO_SHIFT));
+
+        snd_soc_write(codec, WM8904_FLL_CONTROL_3, fll_div.k);
+
+        snd_soc_update_bits(codec, WM8904_FLL_CONTROL_4, WM8904_FLL_N_MASK,
+                            fll_div.n << WM8904_FLL_N_SHIFT);
+
+        snd_soc_update_bits(codec, WM8904_FLL_CONTROL_5,
+                            WM8904_FLL_CLK_REF_DIV_MASK,
+                            fll_div.fll_clk_ref_div 
+                            << WM8904_FLL_CLK_REF_DIV_SHIFT);
+
+        dev_dbg(codec->dev, "FLL configured for %dHz->%dHz\n", Fref, Fout);
+
+        wm8904->fll_fref = Fref;
+        wm8904->fll_fout = Fout;
+        wm8904->fll_src = source;
+
+        /* Enable the FLL if it was previously active */
+        snd_soc_update_bits(codec, WM8904_FLL_CONTROL_1,
+                            WM8904_FLL_OSC_ENA, fll1);
+        snd_soc_update_bits(codec, WM8904_FLL_CONTROL_1,
+                            WM8904_FLL_ENA, fll1);
+
+out:
+        /* Reenable SYSCLK if it was previously active */
+        snd_soc_update_bits(codec, WM8904_CLOCK_RATES_2,
+                            WM8904_CLK_SYS_ENA, clock2);
+
+        return 0;
+}
+
+static int wm8904_digital_mute(struct snd_soc_dai *codec_dai, int mute)
+{
+        struct snd_soc_codec *codec = codec_dai->codec;
+        int val;
+
+        if (mute)
+                val = WM8904_DAC_MUTE;
+        else
+                val = 0;
+
+        snd_soc_update_bits(codec, WM8904_DAC_DIGITAL_1, WM8904_DAC_MUTE, val);
+
+        return 0;
+}
+
+static void wm8904_sync_cache(struct snd_soc_codec *codec)
+{
+        struct wm8904_priv *wm8904 = codec->private_data;
+        int i;
+
+        if (!codec->cache_sync)
+                return;
+
+        codec->cache_only = 0;
+
+        /* Sync back cached values if they're different from the
+         * hardware default.
+         */
+        for (i = 1; i < ARRAY_SIZE(wm8904->reg_cache); i++) {
+                if (!wm8904_access[i].writable)
+                        continue;
+
+                if (wm8904->reg_cache[i] == wm8904_reg[i])
+                        continue;
+
+                snd_soc_write(codec, i, wm8904->reg_cache[i]);
+        }
+
+        codec->cache_sync = 0;
+}
+
+static int wm8904_set_bias_level(struct snd_soc_codec *codec,
+                                 enum snd_soc_bias_level level)
+{
+        struct wm8904_priv *wm8904 = codec->private_data;
+        int ret;
+
+        switch (level) {
+        case SND_SOC_BIAS_ON:
+                break;
+
+        case SND_SOC_BIAS_PREPARE:
+                /* VMID resistance 2*50k */
+                snd_soc_update_bits(codec, WM8904_VMID_CONTROL_0,
+                                    WM8904_VMID_RES_MASK,
+                                    0x1 << WM8904_VMID_RES_SHIFT);
+
+                /* Normal bias current */
+                snd_soc_update_bits(codec, WM8904_BIAS_CONTROL_0,
+                                    WM8904_ISEL_MASK, 2 << WM8904_ISEL_SHIFT);
+                break;
+
+        case SND_SOC_BIAS_STANDBY:
+                if (codec->bias_level == SND_SOC_BIAS_OFF) {
+                        ret = regulator_bulk_enable(ARRAY_SIZE(wm8904->supplies),
+                                                    wm8904->supplies);
+                        if (ret != 0) {
+                                dev_err(codec->dev,
+                                        "Failed to enable supplies: %d\n",
+                                        ret);
+                                return ret;
+                        }
+
+                        wm8904_sync_cache(codec);
+
+                        /* Enable bias */
+                        snd_soc_update_bits(codec, WM8904_BIAS_CONTROL_0,
+                                            WM8904_BIAS_ENA, WM8904_BIAS_ENA);
+
+                        /* Enable VMID, VMID buffering, 2*5k resistance */
+                        snd_soc_update_bits(codec, WM8904_VMID_CONTROL_0,
+                                            WM8904_VMID_ENA |
+                                            WM8904_VMID_RES_MASK,
+                                            WM8904_VMID_ENA |
+                                            0x3 << WM8904_VMID_RES_SHIFT);
+
+                        /* Let VMID ramp */
+                        msleep(1);
+                }
+
+                /* Maintain VMID with 2*250k */
+                snd_soc_update_bits(codec, WM8904_VMID_CONTROL_0,
+                                    WM8904_VMID_RES_MASK,
+                                    0x2 << WM8904_VMID_RES_SHIFT);
+
+                /* Bias current *0.5 */
+                snd_soc_update_bits(codec, WM8904_BIAS_CONTROL_0,
+                                    WM8904_ISEL_MASK, 0);
+                break;
+
+        case SND_SOC_BIAS_OFF:
+                /* Turn off VMID */
+                snd_soc_update_bits(codec, WM8904_VMID_CONTROL_0,
+                                    WM8904_VMID_RES_MASK | WM8904_VMID_ENA, 0);
+
+                /* Stop bias generation */
+                snd_soc_update_bits(codec, WM8904_BIAS_CONTROL_0,
+                                    WM8904_BIAS_ENA, 0);
+
+#ifdef CONFIG_REGULATOR
+                /* Post 2.6.34 we will be able to get a callback when
+                 * the regulators are disabled which we can use but
+                 * for now just assume that the power will be cut if
+                 * the regulator API is in use.
+                 */
+                codec->cache_sync = 1;
+#endif
+
+                regulator_bulk_disable(ARRAY_SIZE(wm8904->supplies),
+                                       wm8904->supplies);
+                break;
+        }
+        codec->bias_level = level;
+        return 0;
+}
+
+#define WM8904_RATES SNDRV_PCM_RATE_8000_96000
+
+#define WM8904_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
+                        SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32_LE)
+
+static struct snd_soc_dai_ops wm8904_dai_ops = {
+        .set_sysclk = wm8904_set_sysclk,
+        .set_fmt = wm8904_set_fmt,
+        .set_tdm_slot = wm8904_set_tdm_slot,
+        .set_pll = wm8904_set_fll,
+        .hw_params = wm8904_hw_params,
+        .digital_mute = wm8904_digital_mute,
+};
+
+struct snd_soc_dai wm8904_dai = {
+        .name = "WM8904",
+        .playback = {
+                .stream_name = "Playback",
+                .channels_min = 2,
+                .channels_max = 2,
+                .rates = WM8904_RATES,
+                .formats = WM8904_FORMATS,
+        },
+        .capture = {
+                .stream_name = "Capture",
+                .channels_min = 2,
+                .channels_max = 2,
+                .rates = WM8904_RATES,
+                .formats = WM8904_FORMATS,
+        },
+        .ops = &wm8904_dai_ops,
+        .symmetric_rates = 1,
+};
+EXPORT_SYMBOL_GPL(wm8904_dai);
+
+#ifdef CONFIG_PM
+static int wm8904_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec = socdev->card->codec;
+
+        wm8904_set_bias_level(codec, SND_SOC_BIAS_OFF);
+
+        return 0;
+}
+
+static int wm8904_resume(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec = socdev->card->codec;
+
+        wm8904_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+
+        return 0;
+}
+#else
+#define wm8904_suspend NULL
+#define wm8904_resume NULL
+#endif
+
+static void wm8904_handle_retune_mobile_pdata(struct wm8904_priv *wm8904)
+{
+        struct snd_soc_codec *codec = &wm8904->codec;
+        struct wm8904_pdata *pdata = wm8904->pdata;
+        struct snd_kcontrol_new control =
+                SOC_ENUM_EXT("EQ Mode",
+                             wm8904->retune_mobile_enum,
+                             wm8904_get_retune_mobile_enum,
+                             wm8904_put_retune_mobile_enum);
+        int ret, i, j;
+        const char **t;
+
+        /* We need an array of texts for the enum API but the number
+         * of texts is likely to be less than the number of
+         * configurations due to the sample rate dependency of the
+         * configurations. */
+        wm8904->num_retune_mobile_texts = 0;
+        wm8904->retune_mobile_texts = NULL;
+        for (i = 0; i < pdata->num_retune_mobile_cfgs; i++) {
+                for (j = 0; j < wm8904->num_retune_mobile_texts; j++) {
+                        if (strcmp(pdata->retune_mobile_cfgs[i].name,
+                                   wm8904->retune_mobile_texts[j]) == 0)
+                                break;
+                }
+
+                if (j != wm8904->num_retune_mobile_texts)
+                        continue;
+
+                /* Expand the array... */
+                t = krealloc(wm8904->retune_mobile_texts,
+                             sizeof(char *) * 
+                             (wm8904->num_retune_mobile_texts + 1),
+                             GFP_KERNEL);
+                if (t == NULL)
+                        continue;
+
+                /* ...store the new entry... */
+                t[wm8904->num_retune_mobile_texts] = 
+                        pdata->retune_mobile_cfgs[i].name;
+
+                /* ...and remember the new version. */
+                wm8904->num_retune_mobile_texts++;
+                wm8904->retune_mobile_texts = t;
+        }
+
+        dev_dbg(codec->dev, "Allocated %d unique ReTune Mobile names\n",
+                wm8904->num_retune_mobile_texts);
+
+        wm8904->retune_mobile_enum.max = wm8904->num_retune_mobile_texts;
+        wm8904->retune_mobile_enum.texts = wm8904->retune_mobile_texts;
+
+        ret = snd_soc_add_controls(&wm8904->codec, &control, 1);
+        if (ret != 0)
+                dev_err(wm8904->codec.dev,
+                        "Failed to add ReTune Mobile control: %d\n", ret);
+}
+
+static void wm8904_handle_pdata(struct wm8904_priv *wm8904)
+{
+        struct snd_soc_codec *codec = &wm8904->codec;
+        struct wm8904_pdata *pdata = wm8904->pdata;
+        int ret, i;
+
+        if (!pdata) {
+                snd_soc_add_controls(&wm8904->codec, wm8904_eq_controls,
+                                     ARRAY_SIZE(wm8904_eq_controls));
+                return;
+        }
+
+        dev_dbg(codec->dev, "%d DRC configurations\n", pdata->num_drc_cfgs);
+
+        if (pdata->num_drc_cfgs) {
+                struct snd_kcontrol_new control =
+                        SOC_ENUM_EXT("DRC Mode", wm8904->drc_enum,
+                                     wm8904_get_drc_enum, wm8904_put_drc_enum);
+
+                /* We need an array of texts for the enum API */
+                wm8904->drc_texts = kmalloc(sizeof(char *)
+                                            * pdata->num_drc_cfgs, GFP_KERNEL);
+                if (!wm8904->drc_texts) {
+                        dev_err(wm8904->codec.dev,
+                                "Failed to allocate %d DRC config texts\n",
+                                pdata->num_drc_cfgs);
+                        return;
+                }
+
+                for (i = 0; i < pdata->num_drc_cfgs; i++)
+                        wm8904->drc_texts[i] = pdata->drc_cfgs[i].name;
+
+                wm8904->drc_enum.max = pdata->num_drc_cfgs;
+                wm8904->drc_enum.texts = wm8904->drc_texts;
+
+                ret = snd_soc_add_controls(&wm8904->codec, &control, 1);
+                if (ret != 0)
+                        dev_err(wm8904->codec.dev,
+                                "Failed to add DRC mode control: %d\n", ret);
+
+                wm8904_set_drc(codec);
+        }
+
+        dev_dbg(codec->dev, "%d ReTune Mobile configurations\n",
+                pdata->num_retune_mobile_cfgs);
+
+        if (pdata->num_retune_mobile_cfgs)
+                wm8904_handle_retune_mobile_pdata(wm8904);
+        else
+                snd_soc_add_controls(&wm8904->codec, wm8904_eq_controls,
+                                     ARRAY_SIZE(wm8904_eq_controls));
+}
+
+static int wm8904_probe(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec;
+        int ret = 0;
+
+        if (wm8904_codec == NULL) {
+                dev_err(&pdev->dev, "Codec device not registered\n");
+                return -ENODEV;
+        }
+
+        socdev->card->codec = wm8904_codec;
+        codec = wm8904_codec;
+
+        /* register pcms */
+        ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
+        if (ret < 0) {
+                dev_err(codec->dev, "failed to create pcms: %d\n", ret);
+                goto pcm_err;
+        }
+
+        wm8904_handle_pdata(codec->private_data);
+
+        wm8904_add_widgets(codec);
+
+        return ret;
+
+pcm_err:
+        return ret;
+}
+
+static int wm8904_remove(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+
+        snd_soc_free_pcms(socdev);
+        snd_soc_dapm_free(socdev);
+
+        return 0;
+}
+
+struct snd_soc_codec_device soc_codec_dev_wm8904 = {
+        .probe =        wm8904_probe,
+        .remove =       wm8904_remove,
+        .suspend =      wm8904_suspend,
+        .resume =       wm8904_resume,
+};
+EXPORT_SYMBOL_GPL(soc_codec_dev_wm8904);
+
+static int wm8904_register(struct wm8904_priv *wm8904,
+                           enum snd_soc_control_type control)
+{
+        int ret;
+        struct snd_soc_codec *codec = &wm8904->codec;
+        int i;
+
+        if (wm8904_codec) {
+                dev_err(codec->dev, "Another WM8904 is registered\n");
+                return -EINVAL;
+        }
+
+        mutex_init(&codec->mutex);
+        INIT_LIST_HEAD(&codec->dapm_widgets);
+        INIT_LIST_HEAD(&codec->dapm_paths);
+
+        codec->private_data = wm8904;
+        codec->name = "WM8904";
+        codec->owner = THIS_MODULE;
+        codec->bias_level = SND_SOC_BIAS_OFF;
+        codec->set_bias_level = wm8904_set_bias_level;
+        codec->dai = &wm8904_dai;
+        codec->num_dai = 1;
+        codec->reg_cache_size = WM8904_MAX_REGISTER;
+        codec->reg_cache = &wm8904->reg_cache;
+        codec->volatile_register = wm8904_volatile_register;
+        codec->cache_sync = 1;
+        codec->idle_bias_off = 1;
+
+        switch (wm8904->devtype) {
+        case WM8904:
+                break;
+        case WM8912:
+                memset(&wm8904_dai.capture, 0, sizeof(wm8904_dai.capture));
+                break;
+        default:
+                dev_err(codec->dev, "Unknown device type %d\n",
+                        wm8904->devtype);
+                return -EINVAL;
+        }
+
+        memcpy(codec->reg_cache, wm8904_reg, sizeof(wm8904_reg));
+
+        ret = snd_soc_codec_set_cache_io(codec, 8, 16, control);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
+                goto err;
+        }
+
+        for (i = 0; i < ARRAY_SIZE(wm8904->supplies); i++)
+                wm8904->supplies[i].supply = wm8904_supply_names[i];
+
+        ret = regulator_bulk_get(codec->dev, ARRAY_SIZE(wm8904->supplies),
+                                 wm8904->supplies);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to request supplies: %d\n", ret);
+                goto err;
+        }
+
+        ret = regulator_bulk_enable(ARRAY_SIZE(wm8904->supplies),
+                                    wm8904->supplies);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to enable supplies: %d\n", ret);
+                goto err_get;
+        }
+
+        ret = snd_soc_read(codec, WM8904_SW_RESET_AND_ID);
+        if (ret < 0) {
+                dev_err(codec->dev, "Failed to read ID register\n");
+                goto err_enable;
+        }
+        if (ret != wm8904_reg[WM8904_SW_RESET_AND_ID]) {
+                dev_err(codec->dev, "Device is not a WM8904, ID is %x\n", ret);
+                ret = -EINVAL;
+                goto err_enable;
+        }
+
+        ret = snd_soc_read(codec, WM8904_REVISION);
+        if (ret < 0) {
+                dev_err(codec->dev, "Failed to read device revision: %d\n",
+                        ret);
+                goto err_enable;
+        }
+        dev_info(codec->dev, "revision %c\n", ret + 'A');
+
+        ret = wm8904_reset(codec);
+        if (ret < 0) {
+                dev_err(codec->dev, "Failed to issue reset\n");
+                goto err_enable;
+        }
+
+        wm8904_dai.dev = codec->dev;
+
+        /* Change some default settings - latch VU and enable ZC */
+        wm8904->reg_cache[WM8904_ADC_DIGITAL_VOLUME_LEFT] |= WM8904_ADC_VU;
+        wm8904->reg_cache[WM8904_ADC_DIGITAL_VOLUME_RIGHT] |= WM8904_ADC_VU;
+        wm8904->reg_cache[WM8904_DAC_DIGITAL_VOLUME_LEFT] |= WM8904_DAC_VU;
+        wm8904->reg_cache[WM8904_DAC_DIGITAL_VOLUME_RIGHT] |= WM8904_DAC_VU;
+        wm8904->reg_cache[WM8904_ANALOGUE_OUT1_LEFT] |= WM8904_HPOUT_VU |
+                WM8904_HPOUTLZC;
+        wm8904->reg_cache[WM8904_ANALOGUE_OUT1_RIGHT] |= WM8904_HPOUT_VU |
+                WM8904_HPOUTRZC;
+        wm8904->reg_cache[WM8904_ANALOGUE_OUT2_LEFT] |= WM8904_LINEOUT_VU |
+                WM8904_LINEOUTLZC;
+        wm8904->reg_cache[WM8904_ANALOGUE_OUT2_RIGHT] |= WM8904_LINEOUT_VU |
+                WM8904_LINEOUTRZC;
+        wm8904->reg_cache[WM8904_CLOCK_RATES_0] &= ~WM8904_SR_MODE;
+
+        /* Set Class W by default - this will be managed by the Class
+         * G widget at runtime where bypass paths are available.
+         */
+        wm8904->reg_cache[WM8904_CLASS_W_0] |= WM8904_CP_DYN_PWR;
+
+        /* Use normal bias source */
+        wm8904->reg_cache[WM8904_BIAS_CONTROL_0] &= ~WM8904_POBCTRL;
+
+        wm8904_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+
+        /* Bias level configuration will have done an extra enable */
+        regulator_bulk_disable(ARRAY_SIZE(wm8904->supplies), wm8904->supplies);
+
+        wm8904_codec = codec;
+
+        ret = snd_soc_register_codec(codec);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to register codec: %d\n", ret);
+                return ret;
+        }
+
+        ret = snd_soc_register_dai(&wm8904_dai);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to register DAI: %d\n", ret);
+                snd_soc_unregister_codec(codec);
+                return ret;
+        }
+
+        return 0;
+
+err_enable:
+        regulator_bulk_disable(ARRAY_SIZE(wm8904->supplies), wm8904->supplies);
+err_get:
+        regulator_bulk_free(ARRAY_SIZE(wm8904->supplies), wm8904->supplies);
+err:
+        kfree(wm8904);
+        return ret;
+}
+
+static void wm8904_unregister(struct wm8904_priv *wm8904)
+{
+        wm8904_set_bias_level(&wm8904->codec, SND_SOC_BIAS_OFF);
+        regulator_bulk_free(ARRAY_SIZE(wm8904->supplies), wm8904->supplies);
+        snd_soc_unregister_dai(&wm8904_dai);
+        snd_soc_unregister_codec(&wm8904->codec);
+        kfree(wm8904);
+        wm8904_codec = NULL;
+}
+
+#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+static __devinit int wm8904_i2c_probe(struct i2c_client *i2c,
+                                      const struct i2c_device_id *id)
+{
+        struct wm8904_priv *wm8904;
+        struct snd_soc_codec *codec;
+
+        wm8904 = kzalloc(sizeof(struct wm8904_priv), GFP_KERNEL);
+        if (wm8904 == NULL)
+                return -ENOMEM;
+
+        codec = &wm8904->codec;
+        codec->hw_write = (hw_write_t)i2c_master_send;
+
+        wm8904->devtype = id->driver_data;
+
+        i2c_set_clientdata(i2c, wm8904);
+        codec->control_data = i2c;
+        wm8904->pdata = i2c->dev.platform_data;
+
+        codec->dev = &i2c->dev;
+
+        return wm8904_register(wm8904, SND_SOC_I2C);
+}
+
+static __devexit int wm8904_i2c_remove(struct i2c_client *client)
+{
+        struct wm8904_priv *wm8904 = i2c_get_clientdata(client);
+        wm8904_unregister(wm8904);
+        return 0;
+}
+
+static const struct i2c_device_id wm8904_i2c_id[] = {
+        { "wm8904", WM8904 },
+        { "wm8912", WM8912 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, wm8904_i2c_id);
+
+static struct i2c_driver wm8904_i2c_driver = {
+        .driver = {
+                .name = "WM8904",
+                .owner = THIS_MODULE,
+        },
+        .probe =    wm8904_i2c_probe,
+        .remove =   __devexit_p(wm8904_i2c_remove),
+        .id_table = wm8904_i2c_id,
+};
+#endif
+
+static int __init wm8904_modinit(void)
+{
+        int ret;
+#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+        ret = i2c_add_driver(&wm8904_i2c_driver);
+        if (ret != 0) {
+                printk(KERN_ERR "Failed to register WM8904 I2C driver: %d\n",
+                       ret);
+        }
+#endif
+        return 0;
+}
+module_init(wm8904_modinit);
+
+static void __exit wm8904_exit(void)
+{
+#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+        i2c_del_driver(&wm8904_i2c_driver);
+#endif
+}
+module_exit(wm8904_exit);
+
+MODULE_DESCRIPTION("ASoC WM8904 driver");
+MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/codecs/wm8904.h b/sound/soc/codecs/wm8904.h
new file mode 100644
index 000000000000..b68886df34e4
--- /dev/null
+++ b/sound/soc/codecs/wm8904.h
@@ -0,0 +1,1681 @@
+/*
+ * wm8904.h  --  WM8904 ASoC driver
+ *
+ * Copyright 2009 Wolfson Microelectronics, plc
+ *
+ * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef _WM8904_H
+#define _WM8904_H
+
+#define WM8904_CLK_MCLK 1
+#define WM8904_CLK_FLL  2
+
+#define WM8904_FLL_MCLK          1
+#define WM8904_FLL_BCLK          2
+#define WM8904_FLL_LRCLK         3
+#define WM8904_FLL_FREE_RUNNING  4
+
+extern struct snd_soc_dai wm8904_dai;
+extern struct snd_soc_codec_device soc_codec_dev_wm8904;
+
+/*
+ * Register values.
+ */
+#define WM8904_SW_RESET_AND_ID                  0x00
+#define WM8904_REVISION                         0x01
+#define WM8904_BIAS_CONTROL_0                   0x04
+#define WM8904_VMID_CONTROL_0                   0x05
+#define WM8904_MIC_BIAS_CONTROL_0               0x06
+#define WM8904_MIC_BIAS_CONTROL_1               0x07
+#define WM8904_ANALOGUE_DAC_0                   0x08
+#define WM8904_MIC_FILTER_CONTROL               0x09
+#define WM8904_ANALOGUE_ADC_0                   0x0A
+#define WM8904_POWER_MANAGEMENT_0               0x0C
+#define WM8904_POWER_MANAGEMENT_2               0x0E
+#define WM8904_POWER_MANAGEMENT_3               0x0F
+#define WM8904_POWER_MANAGEMENT_6               0x12
+#define WM8904_CLOCK_RATES_0                    0x14
+#define WM8904_CLOCK_RATES_1                    0x15
+#define WM8904_CLOCK_RATES_2                    0x16
+#define WM8904_AUDIO_INTERFACE_0                0x18
+#define WM8904_AUDIO_INTERFACE_1                0x19
+#define WM8904_AUDIO_INTERFACE_2                0x1A
+#define WM8904_AUDIO_INTERFACE_3                0x1B
+#define WM8904_DAC_DIGITAL_VOLUME_LEFT          0x1E
+#define WM8904_DAC_DIGITAL_VOLUME_RIGHT         0x1F
+#define WM8904_DAC_DIGITAL_0                    0x20
+#define WM8904_DAC_DIGITAL_1                    0x21
+#define WM8904_ADC_DIGITAL_VOLUME_LEFT          0x24
+#define WM8904_ADC_DIGITAL_VOLUME_RIGHT         0x25
+#define WM8904_ADC_DIGITAL_0                    0x26
+#define WM8904_DIGITAL_MICROPHONE_0             0x27
+#define WM8904_DRC_0                            0x28
+#define WM8904_DRC_1                            0x29
+#define WM8904_DRC_2                            0x2A
+#define WM8904_DRC_3                            0x2B
+#define WM8904_ANALOGUE_LEFT_INPUT_0            0x2C
+#define WM8904_ANALOGUE_RIGHT_INPUT_0           0x2D
+#define WM8904_ANALOGUE_LEFT_INPUT_1            0x2E
+#define WM8904_ANALOGUE_RIGHT_INPUT_1           0x2F
+#define WM8904_ANALOGUE_OUT1_LEFT               0x39
+#define WM8904_ANALOGUE_OUT1_RIGHT              0x3A
+#define WM8904_ANALOGUE_OUT2_LEFT               0x3B
+#define WM8904_ANALOGUE_OUT2_RIGHT              0x3C
+#define WM8904_ANALOGUE_OUT12_ZC                0x3D
+#define WM8904_DC_SERVO_0                       0x43
+#define WM8904_DC_SERVO_1                       0x44
+#define WM8904_DC_SERVO_2                       0x45
+#define WM8904_DC_SERVO_4                       0x47
+#define WM8904_DC_SERVO_5                       0x48
+#define WM8904_DC_SERVO_6                       0x49
+#define WM8904_DC_SERVO_7                       0x4A
+#define WM8904_DC_SERVO_8                       0x4B
+#define WM8904_DC_SERVO_9                       0x4C
+#define WM8904_DC_SERVO_READBACK_0              0x4D
+#define WM8904_ANALOGUE_HP_0                    0x5A
+#define WM8904_ANALOGUE_LINEOUT_0               0x5E
+#define WM8904_CHARGE_PUMP_0                    0x62
+#define WM8904_CLASS_W_0                        0x68
+#define WM8904_WRITE_SEQUENCER_0                0x6C
+#define WM8904_WRITE_SEQUENCER_1                0x6D
+#define WM8904_WRITE_SEQUENCER_2                0x6E
+#define WM8904_WRITE_SEQUENCER_3                0x6F
+#define WM8904_WRITE_SEQUENCER_4                0x70
+#define WM8904_FLL_CONTROL_1                    0x74
+#define WM8904_FLL_CONTROL_2                    0x75
+#define WM8904_FLL_CONTROL_3                    0x76
+#define WM8904_FLL_CONTROL_4                    0x77
+#define WM8904_FLL_CONTROL_5                    0x78
+#define WM8904_GPIO_CONTROL_1                   0x79
+#define WM8904_GPIO_CONTROL_2                   0x7A
+#define WM8904_GPIO_CONTROL_3                   0x7B
+#define WM8904_GPIO_CONTROL_4                   0x7C
+#define WM8904_DIGITAL_PULLS                    0x7E
+#define WM8904_INTERRUPT_STATUS                 0x7F
+#define WM8904_INTERRUPT_STATUS_MASK            0x80
+#define WM8904_INTERRUPT_POLARITY               0x81
+#define WM8904_INTERRUPT_DEBOUNCE               0x82
+#define WM8904_EQ1                              0x86
+#define WM8904_EQ2                              0x87
+#define WM8904_EQ3                              0x88
+#define WM8904_EQ4                              0x89
+#define WM8904_EQ5                              0x8A
+#define WM8904_EQ6                              0x8B
+#define WM8904_EQ7                              0x8C
+#define WM8904_EQ8                              0x8D
+#define WM8904_EQ9                              0x8E
+#define WM8904_EQ10                             0x8F
+#define WM8904_EQ11                             0x90
+#define WM8904_EQ12                             0x91
+#define WM8904_EQ13                             0x92
+#define WM8904_EQ14                             0x93
+#define WM8904_EQ15                             0x94
+#define WM8904_EQ16                             0x95
+#define WM8904_EQ17                             0x96
+#define WM8904_EQ18                             0x97
+#define WM8904_EQ19                             0x98
+#define WM8904_EQ20                             0x99
+#define WM8904_EQ21                             0x9A
+#define WM8904_EQ22                             0x9B
+#define WM8904_EQ23                             0x9C
+#define WM8904_EQ24                             0x9D
+#define WM8904_CONTROL_INTERFACE_TEST_1         0xA1
+#define WM8904_ANALOGUE_OUTPUT_BIAS_0           0xCC
+#define WM8904_FLL_NCO_TEST_0                   0xF7
+#define WM8904_FLL_NCO_TEST_1                   0xF8
+
+#define WM8904_REGISTER_COUNT                   101
+#define WM8904_MAX_REGISTER                     0xF8
+
+/*
+ * Field Definitions.
+ */
+
+/*
+ * R0 (0x00) - SW Reset and ID
+ */
+#define WM8904_SW_RST_DEV_ID1_MASK              0xFFFF  /* SW_RST_DEV_ID1 - [15:0] */
+#define WM8904_SW_RST_DEV_ID1_SHIFT                  0  /* SW_RST_DEV_ID1 - [15:0] */
+#define WM8904_SW_RST_DEV_ID1_WIDTH                 16  /* SW_RST_DEV_ID1 - [15:0] */
+
+/*
+ * R1 (0x01) - Revision
+ */
+#define WM8904_REVISION_MASK                    0x000F  /* REVISION - [3:0] */
+#define WM8904_REVISION_SHIFT                        0  /* REVISION - [3:0] */
+#define WM8904_REVISION_WIDTH                       16  /* REVISION - [3:0] */
+
+/*
+ * R4 (0x04) - Bias Control 0
+ */
+#define WM8904_POBCTRL                          0x0010  /* POBCTRL */
+#define WM8904_POBCTRL_MASK                     0x0010  /* POBCTRL */
+#define WM8904_POBCTRL_SHIFT                         4  /* POBCTRL */
+#define WM8904_POBCTRL_WIDTH                         1  /* POBCTRL */
+#define WM8904_ISEL_MASK                        0x000C  /* ISEL - [3:2] */
+#define WM8904_ISEL_SHIFT                            2  /* ISEL - [3:2] */
+#define WM8904_ISEL_WIDTH                            2  /* ISEL - [3:2] */
+#define WM8904_STARTUP_BIAS_ENA                 0x0002  /* STARTUP_BIAS_ENA */
+#define WM8904_STARTUP_BIAS_ENA_MASK            0x0002  /* STARTUP_BIAS_ENA */
+#define WM8904_STARTUP_BIAS_ENA_SHIFT                1  /* STARTUP_BIAS_ENA */
+#define WM8904_STARTUP_BIAS_ENA_WIDTH                1  /* STARTUP_BIAS_ENA */
+#define WM8904_BIAS_ENA                         0x0001  /* BIAS_ENA */
+#define WM8904_BIAS_ENA_MASK                    0x0001  /* BIAS_ENA */
+#define WM8904_BIAS_ENA_SHIFT                        0  /* BIAS_ENA */
+#define WM8904_BIAS_ENA_WIDTH                        1  /* BIAS_ENA */
+
+/*
+ * R5 (0x05) - VMID Control 0
+ */
+#define WM8904_VMID_BUF_ENA                     0x0040  /* VMID_BUF_ENA */
+#define WM8904_VMID_BUF_ENA_MASK                0x0040  /* VMID_BUF_ENA */
+#define WM8904_VMID_BUF_ENA_SHIFT                    6  /* VMID_BUF_ENA */
+#define WM8904_VMID_BUF_ENA_WIDTH                    1  /* VMID_BUF_ENA */
+#define WM8904_VMID_RES_MASK                    0x0006  /* VMID_RES - [2:1] */
+#define WM8904_VMID_RES_SHIFT                        1  /* VMID_RES - [2:1] */
+#define WM8904_VMID_RES_WIDTH                        2  /* VMID_RES - [2:1] */
+#define WM8904_VMID_ENA                         0x0001  /* VMID_ENA */
+#define WM8904_VMID_ENA_MASK                    0x0001  /* VMID_ENA */
+#define WM8904_VMID_ENA_SHIFT                        0  /* VMID_ENA */
+#define WM8904_VMID_ENA_WIDTH                        1  /* VMID_ENA */
+
+/*
+ * R6 (0x06) - Mic Bias Control 0
+ */
+#define WM8904_MICDET_THR_MASK                  0x0070  /* MICDET_THR - [6:4] */
+#define WM8904_MICDET_THR_SHIFT                      4  /* MICDET_THR - [6:4] */
+#define WM8904_MICDET_THR_WIDTH                      3  /* MICDET_THR - [6:4] */
+#define WM8904_MICSHORT_THR_MASK                0x000C  /* MICSHORT_THR - [3:2] */
+#define WM8904_MICSHORT_THR_SHIFT                    2  /* MICSHORT_THR - [3:2] */
+#define WM8904_MICSHORT_THR_WIDTH                    2  /* MICSHORT_THR - [3:2] */
+#define WM8904_MICDET_ENA                       0x0002  /* MICDET_ENA */
+#define WM8904_MICDET_ENA_MASK                  0x0002  /* MICDET_ENA */
+#define WM8904_MICDET_ENA_SHIFT                      1  /* MICDET_ENA */
+#define WM8904_MICDET_ENA_WIDTH                      1  /* MICDET_ENA */
+#define WM8904_MICBIAS_ENA                      0x0001  /* MICBIAS_ENA */
+#define WM8904_MICBIAS_ENA_MASK                 0x0001  /* MICBIAS_ENA */
+#define WM8904_MICBIAS_ENA_SHIFT                     0  /* MICBIAS_ENA */
+#define WM8904_MICBIAS_ENA_WIDTH                     1  /* MICBIAS_ENA */
+
+/*
+ * R7 (0x07) - Mic Bias Control 1
+ */
+#define WM8904_MIC_DET_FILTER_ENA               0x8000  /* MIC_DET_FILTER_ENA */
+#define WM8904_MIC_DET_FILTER_ENA_MASK          0x8000  /* MIC_DET_FILTER_ENA */
+#define WM8904_MIC_DET_FILTER_ENA_SHIFT             15  /* MIC_DET_FILTER_ENA */
+#define WM8904_MIC_DET_FILTER_ENA_WIDTH              1  /* MIC_DET_FILTER_ENA */
+#define WM8904_MIC_SHORT_FILTER_ENA             0x4000  /* MIC_SHORT_FILTER_ENA */
+#define WM8904_MIC_SHORT_FILTER_ENA_MASK        0x4000  /* MIC_SHORT_FILTER_ENA */
+#define WM8904_MIC_SHORT_FILTER_ENA_SHIFT           14  /* MIC_SHORT_FILTER_ENA */
+#define WM8904_MIC_SHORT_FILTER_ENA_WIDTH            1  /* MIC_SHORT_FILTER_ENA */
+#define WM8904_MICBIAS_SEL_MASK                 0x0007  /* MICBIAS_SEL - [2:0] */
+#define WM8904_MICBIAS_SEL_SHIFT                     0  /* MICBIAS_SEL - [2:0] */
+#define WM8904_MICBIAS_SEL_WIDTH                     3  /* MICBIAS_SEL - [2:0] */
+
+/*
+ * R8 (0x08) - Analogue DAC 0
+ */
+#define WM8904_DAC_BIAS_SEL_MASK                0x0018  /* DAC_BIAS_SEL - [4:3] */
+#define WM8904_DAC_BIAS_SEL_SHIFT                    3  /* DAC_BIAS_SEL - [4:3] */
+#define WM8904_DAC_BIAS_SEL_WIDTH                    2  /* DAC_BIAS_SEL - [4:3] */
+#define WM8904_DAC_VMID_BIAS_SEL_MASK           0x0006  /* DAC_VMID_BIAS_SEL - [2:1] */
+#define WM8904_DAC_VMID_BIAS_SEL_SHIFT               1  /* DAC_VMID_BIAS_SEL - [2:1] */
+#define WM8904_DAC_VMID_BIAS_SEL_WIDTH               2  /* DAC_VMID_BIAS_SEL - [2:1] */
+
+/*
+ * R9 (0x09) - mic Filter Control
+ */
+#define WM8904_MIC_DET_SET_THRESHOLD_MASK       0xF000  /* MIC_DET_SET_THRESHOLD - [15:12] */
+#define WM8904_MIC_DET_SET_THRESHOLD_SHIFT          12  /* MIC_DET_SET_THRESHOLD - [15:12] */
+#define WM8904_MIC_DET_SET_THRESHOLD_WIDTH           4  /* MIC_DET_SET_THRESHOLD - [15:12] */
+#define WM8904_MIC_DET_RESET_THRESHOLD_MASK     0x0F00  /* MIC_DET_RESET_THRESHOLD - [11:8] */
+#define WM8904_MIC_DET_RESET_THRESHOLD_SHIFT         8  /* MIC_DET_RESET_THRESHOLD - [11:8] */
+#define WM8904_MIC_DET_RESET_THRESHOLD_WIDTH         4  /* MIC_DET_RESET_THRESHOLD - [11:8] */
+#define WM8904_MIC_SHORT_SET_THRESHOLD_MASK     0x00F0  /* MIC_SHORT_SET_THRESHOLD - [7:4] */
+#define WM8904_MIC_SHORT_SET_THRESHOLD_SHIFT         4  /* MIC_SHORT_SET_THRESHOLD - [7:4] */
+#define WM8904_MIC_SHORT_SET_THRESHOLD_WIDTH         4  /* MIC_SHORT_SET_THRESHOLD - [7:4] */
+#define WM8904_MIC_SHORT_RESET_THRESHOLD_MASK   0x000F  /* MIC_SHORT_RESET_THRESHOLD - [3:0] */
+#define WM8904_MIC_SHORT_RESET_THRESHOLD_SHIFT       0  /* MIC_SHORT_RESET_THRESHOLD - [3:0] */
+#define WM8904_MIC_SHORT_RESET_THRESHOLD_WIDTH       4  /* MIC_SHORT_RESET_THRESHOLD - [3:0] */
+
+/*
+ * R10 (0x0A) - Analogue ADC 0
+ */
+#define WM8904_ADC_OSR128                       0x0001  /* ADC_OSR128 */
+#define WM8904_ADC_OSR128_MASK                  0x0001  /* ADC_OSR128 */
+#define WM8904_ADC_OSR128_SHIFT                      0  /* ADC_OSR128 */
+#define WM8904_ADC_OSR128_WIDTH                      1  /* ADC_OSR128 */
+
+/*
+ * R12 (0x0C) - Power Management 0
+ */
+#define WM8904_INL_ENA                          0x0002  /* INL_ENA */
+#define WM8904_INL_ENA_MASK                     0x0002  /* INL_ENA */
+#define WM8904_INL_ENA_SHIFT                         1  /* INL_ENA */
+#define WM8904_INL_ENA_WIDTH                         1  /* INL_ENA */
+#define WM8904_INR_ENA                          0x0001  /* INR_ENA */
+#define WM8904_INR_ENA_MASK                     0x0001  /* INR_ENA */
+#define WM8904_INR_ENA_SHIFT                         0  /* INR_ENA */
+#define WM8904_INR_ENA_WIDTH                         1  /* INR_ENA */
+
+/*
+ * R14 (0x0E) - Power Management 2
+ */
+#define WM8904_HPL_PGA_ENA                      0x0002  /* HPL_PGA_ENA */
+#define WM8904_HPL_PGA_ENA_MASK                 0x0002  /* HPL_PGA_ENA */
+#define WM8904_HPL_PGA_ENA_SHIFT                     1  /* HPL_PGA_ENA */
+#define WM8904_HPL_PGA_ENA_WIDTH                     1  /* HPL_PGA_ENA */
+#define WM8904_HPR_PGA_ENA                      0x0001  /* HPR_PGA_ENA */
+#define WM8904_HPR_PGA_ENA_MASK                 0x0001  /* HPR_PGA_ENA */
+#define WM8904_HPR_PGA_ENA_SHIFT                     0  /* HPR_PGA_ENA */
+#define WM8904_HPR_PGA_ENA_WIDTH                     1  /* HPR_PGA_ENA */
+
+/*
+ * R15 (0x0F) - Power Management 3
+ */
+#define WM8904_LINEOUTL_PGA_ENA                 0x0002  /* LINEOUTL_PGA_ENA */
+#define WM8904_LINEOUTL_PGA_ENA_MASK            0x0002  /* LINEOUTL_PGA_ENA */
+#define WM8904_LINEOUTL_PGA_ENA_SHIFT                1  /* LINEOUTL_PGA_ENA */
+#define WM8904_LINEOUTL_PGA_ENA_WIDTH                1  /* LINEOUTL_PGA_ENA */
+#define WM8904_LINEOUTR_PGA_ENA                 0x0001  /* LINEOUTR_PGA_ENA */
+#define WM8904_LINEOUTR_PGA_ENA_MASK            0x0001  /* LINEOUTR_PGA_ENA */
+#define WM8904_LINEOUTR_PGA_ENA_SHIFT                0  /* LINEOUTR_PGA_ENA */
+#define WM8904_LINEOUTR_PGA_ENA_WIDTH                1  /* LINEOUTR_PGA_ENA */
+
+/*
+ * R18 (0x12) - Power Management 6
+ */
+#define WM8904_DACL_ENA                         0x0008  /* DACL_ENA */
+#define WM8904_DACL_ENA_MASK                    0x0008  /* DACL_ENA */
+#define WM8904_DACL_ENA_SHIFT                        3  /* DACL_ENA */
+#define WM8904_DACL_ENA_WIDTH                        1  /* DACL_ENA */
+#define WM8904_DACR_ENA                         0x0004  /* DACR_ENA */
+#define WM8904_DACR_ENA_MASK                    0x0004  /* DACR_ENA */
+#define WM8904_DACR_ENA_SHIFT                        2  /* DACR_ENA */
+#define WM8904_DACR_ENA_WIDTH                        1  /* DACR_ENA */
+#define WM8904_ADCL_ENA                         0x0002  /* ADCL_ENA */
+#define WM8904_ADCL_ENA_MASK                    0x0002  /* ADCL_ENA */
+#define WM8904_ADCL_ENA_SHIFT                        1  /* ADCL_ENA */
+#define WM8904_ADCL_ENA_WIDTH                        1  /* ADCL_ENA */
+#define WM8904_ADCR_ENA                         0x0001  /* ADCR_ENA */
+#define WM8904_ADCR_ENA_MASK                    0x0001  /* ADCR_ENA */
+#define WM8904_ADCR_ENA_SHIFT                        0  /* ADCR_ENA */
+#define WM8904_ADCR_ENA_WIDTH                        1  /* ADCR_ENA */
+
+/*
+ * R20 (0x14) - Clock Rates 0
+ */
+#define WM8904_TOCLK_RATE_DIV16                 0x4000  /* TOCLK_RATE_DIV16 */
+#define WM8904_TOCLK_RATE_DIV16_MASK            0x4000  /* TOCLK_RATE_DIV16 */
+#define WM8904_TOCLK_RATE_DIV16_SHIFT               14  /* TOCLK_RATE_DIV16 */
+#define WM8904_TOCLK_RATE_DIV16_WIDTH                1  /* TOCLK_RATE_DIV16 */
+#define WM8904_TOCLK_RATE_X4                    0x2000  /* TOCLK_RATE_X4 */
+#define WM8904_TOCLK_RATE_X4_MASK               0x2000  /* TOCLK_RATE_X4 */
+#define WM8904_TOCLK_RATE_X4_SHIFT                  13  /* TOCLK_RATE_X4 */
+#define WM8904_TOCLK_RATE_X4_WIDTH                   1  /* TOCLK_RATE_X4 */
+#define WM8904_SR_MODE                          0x1000  /* SR_MODE */
+#define WM8904_SR_MODE_MASK                     0x1000  /* SR_MODE */
+#define WM8904_SR_MODE_SHIFT                        12  /* SR_MODE */
+#define WM8904_SR_MODE_WIDTH                         1  /* SR_MODE */
+#define WM8904_MCLK_DIV                         0x0001  /* MCLK_DIV */
+#define WM8904_MCLK_DIV_MASK                    0x0001  /* MCLK_DIV */
+#define WM8904_MCLK_DIV_SHIFT                        0  /* MCLK_DIV */
+#define WM8904_MCLK_DIV_WIDTH                        1  /* MCLK_DIV */
+
+/*
+ * R21 (0x15) - Clock Rates 1
+ */
+#define WM8904_CLK_SYS_RATE_MASK                0x3C00  /* CLK_SYS_RATE - [13:10] */
+#define WM8904_CLK_SYS_RATE_SHIFT                   10  /* CLK_SYS_RATE - [13:10] */
+#define WM8904_CLK_SYS_RATE_WIDTH                    4  /* CLK_SYS_RATE - [13:10] */
+#define WM8904_SAMPLE_RATE_MASK                 0x0007  /* SAMPLE_RATE - [2:0] */
+#define WM8904_SAMPLE_RATE_SHIFT                     0  /* SAMPLE_RATE - [2:0] */
+#define WM8904_SAMPLE_RATE_WIDTH                     3  /* SAMPLE_RATE - [2:0] */
+
+/*
+ * R22 (0x16) - Clock Rates 2
+ */
+#define WM8904_MCLK_INV                         0x8000  /* MCLK_INV */
+#define WM8904_MCLK_INV_MASK                    0x8000  /* MCLK_INV */
+#define WM8904_MCLK_INV_SHIFT                       15  /* MCLK_INV */
+#define WM8904_MCLK_INV_WIDTH                        1  /* MCLK_INV */
+#define WM8904_SYSCLK_SRC                       0x4000  /* SYSCLK_SRC */
+#define WM8904_SYSCLK_SRC_MASK                  0x4000  /* SYSCLK_SRC */
+#define WM8904_SYSCLK_SRC_SHIFT                     14  /* SYSCLK_SRC */
+#define WM8904_SYSCLK_SRC_WIDTH                      1  /* SYSCLK_SRC */
+#define WM8904_TOCLK_RATE                       0x1000  /* TOCLK_RATE */
+#define WM8904_TOCLK_RATE_MASK                  0x1000  /* TOCLK_RATE */
+#define WM8904_TOCLK_RATE_SHIFT                     12  /* TOCLK_RATE */
+#define WM8904_TOCLK_RATE_WIDTH                      1  /* TOCLK_RATE */
+#define WM8904_OPCLK_ENA                        0x0008  /* OPCLK_ENA */
+#define WM8904_OPCLK_ENA_MASK                   0x0008  /* OPCLK_ENA */
+#define WM8904_OPCLK_ENA_SHIFT                       3  /* OPCLK_ENA */
+#define WM8904_OPCLK_ENA_WIDTH                       1  /* OPCLK_ENA */
+#define WM8904_CLK_SYS_ENA                      0x0004  /* CLK_SYS_ENA */
+#define WM8904_CLK_SYS_ENA_MASK                 0x0004  /* CLK_SYS_ENA */
+#define WM8904_CLK_SYS_ENA_SHIFT                     2  /* CLK_SYS_ENA */
+#define WM8904_CLK_SYS_ENA_WIDTH                     1  /* CLK_SYS_ENA */
+#define WM8904_CLK_DSP_ENA                      0x0002  /* CLK_DSP_ENA */
+#define WM8904_CLK_DSP_ENA_MASK                 0x0002  /* CLK_DSP_ENA */
+#define WM8904_CLK_DSP_ENA_SHIFT                     1  /* CLK_DSP_ENA */
+#define WM8904_CLK_DSP_ENA_WIDTH                     1  /* CLK_DSP_ENA */
+#define WM8904_TOCLK_ENA                        0x0001  /* TOCLK_ENA */
+#define WM8904_TOCLK_ENA_MASK                   0x0001  /* TOCLK_ENA */
+#define WM8904_TOCLK_ENA_SHIFT                       0  /* TOCLK_ENA */
+#define WM8904_TOCLK_ENA_WIDTH                       1  /* TOCLK_ENA */
+
+/*
+ * R24 (0x18) - Audio Interface 0
+ */
+#define WM8904_DACL_DATINV                      0x1000  /* DACL_DATINV */
+#define WM8904_DACL_DATINV_MASK                 0x1000  /* DACL_DATINV */
+#define WM8904_DACL_DATINV_SHIFT                    12  /* DACL_DATINV */
+#define WM8904_DACL_DATINV_WIDTH                     1  /* DACL_DATINV */
+#define WM8904_DACR_DATINV                      0x0800  /* DACR_DATINV */
+#define WM8904_DACR_DATINV_MASK                 0x0800  /* DACR_DATINV */
+#define WM8904_DACR_DATINV_SHIFT                    11  /* DACR_DATINV */
+#define WM8904_DACR_DATINV_WIDTH                     1  /* DACR_DATINV */
+#define WM8904_DAC_BOOST_MASK                   0x0600  /* DAC_BOOST - [10:9] */
+#define WM8904_DAC_BOOST_SHIFT                       9  /* DAC_BOOST - [10:9] */
+#define WM8904_DAC_BOOST_WIDTH                       2  /* DAC_BOOST - [10:9] */
+#define WM8904_LOOPBACK                         0x0100  /* LOOPBACK */
+#define WM8904_LOOPBACK_MASK                    0x0100  /* LOOPBACK */
+#define WM8904_LOOPBACK_SHIFT                        8  /* LOOPBACK */
+#define WM8904_LOOPBACK_WIDTH                        1  /* LOOPBACK */
+#define WM8904_AIFADCL_SRC                      0x0080  /* AIFADCL_SRC */
+#define WM8904_AIFADCL_SRC_MASK                 0x0080  /* AIFADCL_SRC */
+#define WM8904_AIFADCL_SRC_SHIFT                     7  /* AIFADCL_SRC */
+#define WM8904_AIFADCL_SRC_WIDTH                     1  /* AIFADCL_SRC */
+#define WM8904_AIFADCR_SRC                      0x0040  /* AIFADCR_SRC */
+#define WM8904_AIFADCR_SRC_MASK                 0x0040  /* AIFADCR_SRC */
+#define WM8904_AIFADCR_SRC_SHIFT                     6  /* AIFADCR_SRC */
+#define WM8904_AIFADCR_SRC_WIDTH                     1  /* AIFADCR_SRC */
+#define WM8904_AIFDACL_SRC                      0x0020  /* AIFDACL_SRC */
+#define WM8904_AIFDACL_SRC_MASK                 0x0020  /* AIFDACL_SRC */
+#define WM8904_AIFDACL_SRC_SHIFT                     5  /* AIFDACL_SRC */
+#define WM8904_AIFDACL_SRC_WIDTH                     1  /* AIFDACL_SRC */
+#define WM8904_AIFDACR_SRC                      0x0010  /* AIFDACR_SRC */
+#define WM8904_AIFDACR_SRC_MASK                 0x0010  /* AIFDACR_SRC */
+#define WM8904_AIFDACR_SRC_SHIFT                     4  /* AIFDACR_SRC */
+#define WM8904_AIFDACR_SRC_WIDTH                     1  /* AIFDACR_SRC */
+#define WM8904_ADC_COMP                         0x0008  /* ADC_COMP */
+#define WM8904_ADC_COMP_MASK                    0x0008  /* ADC_COMP */
+#define WM8904_ADC_COMP_SHIFT                        3  /* ADC_COMP */
+#define WM8904_ADC_COMP_WIDTH                        1  /* ADC_COMP */
+#define WM8904_ADC_COMPMODE                     0x0004  /* ADC_COMPMODE */
+#define WM8904_ADC_COMPMODE_MASK                0x0004  /* ADC_COMPMODE */
+#define WM8904_ADC_COMPMODE_SHIFT                    2  /* ADC_COMPMODE */
+#define WM8904_ADC_COMPMODE_WIDTH                    1  /* ADC_COMPMODE */
+#define WM8904_DAC_COMP                         0x0002  /* DAC_COMP */
+#define WM8904_DAC_COMP_MASK                    0x0002  /* DAC_COMP */
+#define WM8904_DAC_COMP_SHIFT                        1  /* DAC_COMP */
+#define WM8904_DAC_COMP_WIDTH                        1  /* DAC_COMP */
+#define WM8904_DAC_COMPMODE                     0x0001  /* DAC_COMPMODE */
+#define WM8904_DAC_COMPMODE_MASK                0x0001  /* DAC_COMPMODE */
+#define WM8904_DAC_COMPMODE_SHIFT                    0  /* DAC_COMPMODE */
+#define WM8904_DAC_COMPMODE_WIDTH                    1  /* DAC_COMPMODE */
+
+/*
+ * R25 (0x19) - Audio Interface 1
+ */
+#define WM8904_AIFDAC_TDM                       0x2000  /* AIFDAC_TDM */
+#define WM8904_AIFDAC_TDM_MASK                  0x2000  /* AIFDAC_TDM */
+#define WM8904_AIFDAC_TDM_SHIFT                     13  /* AIFDAC_TDM */
+#define WM8904_AIFDAC_TDM_WIDTH                      1  /* AIFDAC_TDM */
+#define WM8904_AIFDAC_TDM_CHAN                  0x1000  /* AIFDAC_TDM_CHAN */
+#define WM8904_AIFDAC_TDM_CHAN_MASK             0x1000  /* AIFDAC_TDM_CHAN */
+#define WM8904_AIFDAC_TDM_CHAN_SHIFT                12  /* AIFDAC_TDM_CHAN */
+#define WM8904_AIFDAC_TDM_CHAN_WIDTH                 1  /* AIFDAC_TDM_CHAN */
+#define WM8904_AIFADC_TDM                       0x0800  /* AIFADC_TDM */
+#define WM8904_AIFADC_TDM_MASK                  0x0800  /* AIFADC_TDM */
+#define WM8904_AIFADC_TDM_SHIFT                     11  /* AIFADC_TDM */
+#define WM8904_AIFADC_TDM_WIDTH                      1  /* AIFADC_TDM */
+#define WM8904_AIFADC_TDM_CHAN                  0x0400  /* AIFADC_TDM_CHAN */
+#define WM8904_AIFADC_TDM_CHAN_MASK             0x0400  /* AIFADC_TDM_CHAN */
+#define WM8904_AIFADC_TDM_CHAN_SHIFT                10  /* AIFADC_TDM_CHAN */
+#define WM8904_AIFADC_TDM_CHAN_WIDTH                 1  /* AIFADC_TDM_CHAN */
+#define WM8904_AIF_TRIS                         0x0100  /* AIF_TRIS */
+#define WM8904_AIF_TRIS_MASK                    0x0100  /* AIF_TRIS */
+#define WM8904_AIF_TRIS_SHIFT                        8  /* AIF_TRIS */
+#define WM8904_AIF_TRIS_WIDTH                        1  /* AIF_TRIS */
+#define WM8904_AIF_BCLK_INV                     0x0080  /* AIF_BCLK_INV */
+#define WM8904_AIF_BCLK_INV_MASK                0x0080  /* AIF_BCLK_INV */
+#define WM8904_AIF_BCLK_INV_SHIFT                    7  /* AIF_BCLK_INV */
+#define WM8904_AIF_BCLK_INV_WIDTH                    1  /* AIF_BCLK_INV */
+#define WM8904_BCLK_DIR                         0x0040  /* BCLK_DIR */
+#define WM8904_BCLK_DIR_MASK                    0x0040  /* BCLK_DIR */
+#define WM8904_BCLK_DIR_SHIFT                        6  /* BCLK_DIR */
+#define WM8904_BCLK_DIR_WIDTH                        1  /* BCLK_DIR */
+#define WM8904_AIF_LRCLK_INV                    0x0010  /* AIF_LRCLK_INV */
+#define WM8904_AIF_LRCLK_INV_MASK               0x0010  /* AIF_LRCLK_INV */
+#define WM8904_AIF_LRCLK_INV_SHIFT                   4  /* AIF_LRCLK_INV */
+#define WM8904_AIF_LRCLK_INV_WIDTH                   1  /* AIF_LRCLK_INV */
+#define WM8904_AIF_WL_MASK                      0x000C  /* AIF_WL - [3:2] */
+#define WM8904_AIF_WL_SHIFT                          2  /* AIF_WL - [3:2] */
+#define WM8904_AIF_WL_WIDTH                          2  /* AIF_WL - [3:2] */
+#define WM8904_AIF_FMT_MASK                     0x0003  /* AIF_FMT - [1:0] */
+#define WM8904_AIF_FMT_SHIFT                         0  /* AIF_FMT - [1:0] */
+#define WM8904_AIF_FMT_WIDTH                         2  /* AIF_FMT - [1:0] */
+
+/*
+ * R26 (0x1A) - Audio Interface 2
+ */
+#define WM8904_OPCLK_DIV_MASK                   0x0F00  /* OPCLK_DIV - [11:8] */
+#define WM8904_OPCLK_DIV_SHIFT                       8  /* OPCLK_DIV - [11:8] */
+#define WM8904_OPCLK_DIV_WIDTH                       4  /* OPCLK_DIV - [11:8] */
+#define WM8904_BCLK_DIV_MASK                    0x001F  /* BCLK_DIV - [4:0] */
+#define WM8904_BCLK_DIV_SHIFT                        0  /* BCLK_DIV - [4:0] */
+#define WM8904_BCLK_DIV_WIDTH                        5  /* BCLK_DIV - [4:0] */
+
+/*
+ * R27 (0x1B) - Audio Interface 3
+ */
+#define WM8904_LRCLK_DIR                        0x0800  /* LRCLK_DIR */
+#define WM8904_LRCLK_DIR_MASK                   0x0800  /* LRCLK_DIR */
+#define WM8904_LRCLK_DIR_SHIFT                      11  /* LRCLK_DIR */
+#define WM8904_LRCLK_DIR_WIDTH                       1  /* LRCLK_DIR */
+#define WM8904_LRCLK_RATE_MASK                  0x07FF  /* LRCLK_RATE - [10:0] */
+#define WM8904_LRCLK_RATE_SHIFT                      0  /* LRCLK_RATE - [10:0] */
+#define WM8904_LRCLK_RATE_WIDTH                     11  /* LRCLK_RATE - [10:0] */
+
+/*
+ * R30 (0x1E) - DAC Digital Volume Left
+ */
+#define WM8904_DAC_VU                           0x0100  /* DAC_VU */
+#define WM8904_DAC_VU_MASK                      0x0100  /* DAC_VU */
+#define WM8904_DAC_VU_SHIFT                          8  /* DAC_VU */
+#define WM8904_DAC_VU_WIDTH                          1  /* DAC_VU */
+#define WM8904_DACL_VOL_MASK                    0x00FF  /* DACL_VOL - [7:0] */
+#define WM8904_DACL_VOL_SHIFT                        0  /* DACL_VOL - [7:0] */
+#define WM8904_DACL_VOL_WIDTH                        8  /* DACL_VOL - [7:0] */
+
+/*
+ * R31 (0x1F) - DAC Digital Volume Right
+ */
+#define WM8904_DAC_VU                           0x0100  /* DAC_VU */
+#define WM8904_DAC_VU_MASK                      0x0100  /* DAC_VU */
+#define WM8904_DAC_VU_SHIFT                          8  /* DAC_VU */
+#define WM8904_DAC_VU_WIDTH                          1  /* DAC_VU */
+#define WM8904_DACR_VOL_MASK                    0x00FF  /* DACR_VOL - [7:0] */
+#define WM8904_DACR_VOL_SHIFT                        0  /* DACR_VOL - [7:0] */
+#define WM8904_DACR_VOL_WIDTH                        8  /* DACR_VOL - [7:0] */
+
+/*
+ * R32 (0x20) - DAC Digital 0
+ */
+#define WM8904_ADCL_DAC_SVOL_MASK               0x0F00  /* ADCL_DAC_SVOL - [11:8] */
+#define WM8904_ADCL_DAC_SVOL_SHIFT                   8  /* ADCL_DAC_SVOL - [11:8] */
+#define WM8904_ADCL_DAC_SVOL_WIDTH                   4  /* ADCL_DAC_SVOL - [11:8] */
+#define WM8904_ADCR_DAC_SVOL_MASK               0x00F0  /* ADCR_DAC_SVOL - [7:4] */
+#define WM8904_ADCR_DAC_SVOL_SHIFT                   4  /* ADCR_DAC_SVOL - [7:4] */
+#define WM8904_ADCR_DAC_SVOL_WIDTH                   4  /* ADCR_DAC_SVOL - [7:4] */
+#define WM8904_ADC_TO_DACL_MASK                 0x000C  /* ADC_TO_DACL - [3:2] */
+#define WM8904_ADC_TO_DACL_SHIFT                     2  /* ADC_TO_DACL - [3:2] */
+#define WM8904_ADC_TO_DACL_WIDTH                     2  /* ADC_TO_DACL - [3:2] */
+#define WM8904_ADC_TO_DACR_MASK                 0x0003  /* ADC_TO_DACR - [1:0] */
+#define WM8904_ADC_TO_DACR_SHIFT                     0  /* ADC_TO_DACR - [1:0] */
+#define WM8904_ADC_TO_DACR_WIDTH                     2  /* ADC_TO_DACR - [1:0] */
+
+/*
+ * R33 (0x21) - DAC Digital 1
+ */
+#define WM8904_DAC_MONO                         0x1000  /* DAC_MONO */
+#define WM8904_DAC_MONO_MASK                    0x1000  /* DAC_MONO */
+#define WM8904_DAC_MONO_SHIFT                       12  /* DAC_MONO */
+#define WM8904_DAC_MONO_WIDTH                        1  /* DAC_MONO */
+#define WM8904_DAC_SB_FILT                      0x0800  /* DAC_SB_FILT */
+#define WM8904_DAC_SB_FILT_MASK                 0x0800  /* DAC_SB_FILT */
+#define WM8904_DAC_SB_FILT_SHIFT                    11  /* DAC_SB_FILT */
+#define WM8904_DAC_SB_FILT_WIDTH                     1  /* DAC_SB_FILT */
+#define WM8904_DAC_MUTERATE                     0x0400  /* DAC_MUTERATE */
+#define WM8904_DAC_MUTERATE_MASK                0x0400  /* DAC_MUTERATE */
+#define WM8904_DAC_MUTERATE_SHIFT                   10  /* DAC_MUTERATE */
+#define WM8904_DAC_MUTERATE_WIDTH                    1  /* DAC_MUTERATE */
+#define WM8904_DAC_UNMUTE_RAMP                  0x0200  /* DAC_UNMUTE_RAMP */
+#define WM8904_DAC_UNMUTE_RAMP_MASK             0x0200  /* DAC_UNMUTE_RAMP */
+#define WM8904_DAC_UNMUTE_RAMP_SHIFT                 9  /* DAC_UNMUTE_RAMP */
+#define WM8904_DAC_UNMUTE_RAMP_WIDTH                 1  /* DAC_UNMUTE_RAMP */
+#define WM8904_DAC_OSR128                       0x0040  /* DAC_OSR128 */
+#define WM8904_DAC_OSR128_MASK                  0x0040  /* DAC_OSR128 */
+#define WM8904_DAC_OSR128_SHIFT                      6  /* DAC_OSR128 */
+#define WM8904_DAC_OSR128_WIDTH                      1  /* DAC_OSR128 */
+#define WM8904_DAC_MUTE                         0x0008  /* DAC_MUTE */
+#define WM8904_DAC_MUTE_MASK                    0x0008  /* DAC_MUTE */
+#define WM8904_DAC_MUTE_SHIFT                        3  /* DAC_MUTE */
+#define WM8904_DAC_MUTE_WIDTH                        1  /* DAC_MUTE */
+#define WM8904_DEEMPH_MASK                      0x0006  /* DEEMPH - [2:1] */
+#define WM8904_DEEMPH_SHIFT                          1  /* DEEMPH - [2:1] */
+#define WM8904_DEEMPH_WIDTH                          2  /* DEEMPH - [2:1] */
+
+/*
+ * R36 (0x24) - ADC Digital Volume Left
+ */
+#define WM8904_ADC_VU                           0x0100  /* ADC_VU */
+#define WM8904_ADC_VU_MASK                      0x0100  /* ADC_VU */
+#define WM8904_ADC_VU_SHIFT                          8  /* ADC_VU */
+#define WM8904_ADC_VU_WIDTH                          1  /* ADC_VU */
+#define WM8904_ADCL_VOL_MASK                    0x00FF  /* ADCL_VOL - [7:0] */
+#define WM8904_ADCL_VOL_SHIFT                        0  /* ADCL_VOL - [7:0] */
+#define WM8904_ADCL_VOL_WIDTH                        8  /* ADCL_VOL - [7:0] */
+
+/*
+ * R37 (0x25) - ADC Digital Volume Right
+ */
+#define WM8904_ADC_VU                           0x0100  /* ADC_VU */
+#define WM8904_ADC_VU_MASK                      0x0100  /* ADC_VU */
+#define WM8904_ADC_VU_SHIFT                          8  /* ADC_VU */
+#define WM8904_ADC_VU_WIDTH                          1  /* ADC_VU */
+#define WM8904_ADCR_VOL_MASK                    0x00FF  /* ADCR_VOL - [7:0] */
+#define WM8904_ADCR_VOL_SHIFT                        0  /* ADCR_VOL - [7:0] */
+#define WM8904_ADCR_VOL_WIDTH                        8  /* ADCR_VOL - [7:0] */
+
+/*
+ * R38 (0x26) - ADC Digital 0
+ */
+#define WM8904_ADC_HPF_CUT_MASK                 0x0060  /* ADC_HPF_CUT - [6:5] */
+#define WM8904_ADC_HPF_CUT_SHIFT                     5  /* ADC_HPF_CUT - [6:5] */
+#define WM8904_ADC_HPF_CUT_WIDTH                     2  /* ADC_HPF_CUT - [6:5] */
+#define WM8904_ADC_HPF                          0x0010  /* ADC_HPF */
+#define WM8904_ADC_HPF_MASK                     0x0010  /* ADC_HPF */
+#define WM8904_ADC_HPF_SHIFT                         4  /* ADC_HPF */
+#define WM8904_ADC_HPF_WIDTH                         1  /* ADC_HPF */
+#define WM8904_ADCL_DATINV                      0x0002  /* ADCL_DATINV */
+#define WM8904_ADCL_DATINV_MASK                 0x0002  /* ADCL_DATINV */
+#define WM8904_ADCL_DATINV_SHIFT                     1  /* ADCL_DATINV */
+#define WM8904_ADCL_DATINV_WIDTH                     1  /* ADCL_DATINV */
+#define WM8904_ADCR_DATINV                      0x0001  /* ADCR_DATINV */
+#define WM8904_ADCR_DATINV_MASK                 0x0001  /* ADCR_DATINV */
+#define WM8904_ADCR_DATINV_SHIFT                     0  /* ADCR_DATINV */
+#define WM8904_ADCR_DATINV_WIDTH                     1  /* ADCR_DATINV */
+
+/*
+ * R39 (0x27) - Digital Microphone 0
+ */
+#define WM8904_DMIC_ENA                         0x1000  /* DMIC_ENA */
+#define WM8904_DMIC_ENA_MASK                    0x1000  /* DMIC_ENA */
+#define WM8904_DMIC_ENA_SHIFT                       12  /* DMIC_ENA */
+#define WM8904_DMIC_ENA_WIDTH                        1  /* DMIC_ENA */
+#define WM8904_DMIC_SRC                         0x0800  /* DMIC_SRC */
+#define WM8904_DMIC_SRC_MASK                    0x0800  /* DMIC_SRC */
+#define WM8904_DMIC_SRC_SHIFT                       11  /* DMIC_SRC */
+#define WM8904_DMIC_SRC_WIDTH                        1  /* DMIC_SRC */
+
+/*
+ * R40 (0x28) - DRC 0
+ */
+#define WM8904_DRC_ENA                          0x8000  /* DRC_ENA */
+#define WM8904_DRC_ENA_MASK                     0x8000  /* DRC_ENA */
+#define WM8904_DRC_ENA_SHIFT                        15  /* DRC_ENA */
+#define WM8904_DRC_ENA_WIDTH                         1  /* DRC_ENA */
+#define WM8904_DRC_DAC_PATH                     0x4000  /* DRC_DAC_PATH */
+#define WM8904_DRC_DAC_PATH_MASK                0x4000  /* DRC_DAC_PATH */
+#define WM8904_DRC_DAC_PATH_SHIFT                   14  /* DRC_DAC_PATH */
+#define WM8904_DRC_DAC_PATH_WIDTH                    1  /* DRC_DAC_PATH */
+#define WM8904_DRC_GS_HYST_LVL_MASK             0x1800  /* DRC_GS_HYST_LVL - [12:11] */
+#define WM8904_DRC_GS_HYST_LVL_SHIFT                11  /* DRC_GS_HYST_LVL - [12:11] */
+#define WM8904_DRC_GS_HYST_LVL_WIDTH                 2  /* DRC_GS_HYST_LVL - [12:11] */
+#define WM8904_DRC_STARTUP_GAIN_MASK            0x07C0  /* DRC_STARTUP_GAIN - [10:6] */
+#define WM8904_DRC_STARTUP_GAIN_SHIFT                6  /* DRC_STARTUP_GAIN - [10:6] */
+#define WM8904_DRC_STARTUP_GAIN_WIDTH                5  /* DRC_STARTUP_GAIN - [10:6] */
+#define WM8904_DRC_FF_DELAY                     0x0020  /* DRC_FF_DELAY */
+#define WM8904_DRC_FF_DELAY_MASK                0x0020  /* DRC_FF_DELAY */
+#define WM8904_DRC_FF_DELAY_SHIFT                    5  /* DRC_FF_DELAY */
+#define WM8904_DRC_FF_DELAY_WIDTH                    1  /* DRC_FF_DELAY */
+#define WM8904_DRC_GS_ENA                       0x0008  /* DRC_GS_ENA */
+#define WM8904_DRC_GS_ENA_MASK                  0x0008  /* DRC_GS_ENA */
+#define WM8904_DRC_GS_ENA_SHIFT                      3  /* DRC_GS_ENA */
+#define WM8904_DRC_GS_ENA_WIDTH                      1  /* DRC_GS_ENA */
+#define WM8904_DRC_QR                           0x0004  /* DRC_QR */
+#define WM8904_DRC_QR_MASK                      0x0004  /* DRC_QR */
+#define WM8904_DRC_QR_SHIFT                          2  /* DRC_QR */
+#define WM8904_DRC_QR_WIDTH                          1  /* DRC_QR */
+#define WM8904_DRC_ANTICLIP                     0x0002  /* DRC_ANTICLIP */
+#define WM8904_DRC_ANTICLIP_MASK                0x0002  /* DRC_ANTICLIP */
+#define WM8904_DRC_ANTICLIP_SHIFT                    1  /* DRC_ANTICLIP */
+#define WM8904_DRC_ANTICLIP_WIDTH                    1  /* DRC_ANTICLIP */
+#define WM8904_DRC_GS_HYST                      0x0001  /* DRC_GS_HYST */
+#define WM8904_DRC_GS_HYST_MASK                 0x0001  /* DRC_GS_HYST */
+#define WM8904_DRC_GS_HYST_SHIFT                     0  /* DRC_GS_HYST */
+#define WM8904_DRC_GS_HYST_WIDTH                     1  /* DRC_GS_HYST */
+
+/*
+ * R41 (0x29) - DRC 1
+ */
+#define WM8904_DRC_ATK_MASK                     0xF000  /* DRC_ATK - [15:12] */
+#define WM8904_DRC_ATK_SHIFT                        12  /* DRC_ATK - [15:12] */
+#define WM8904_DRC_ATK_WIDTH                         4  /* DRC_ATK - [15:12] */
+#define WM8904_DRC_DCY_MASK                     0x0F00  /* DRC_DCY - [11:8] */
+#define WM8904_DRC_DCY_SHIFT                         8  /* DRC_DCY - [11:8] */
+#define WM8904_DRC_DCY_WIDTH                         4  /* DRC_DCY - [11:8] */
+#define WM8904_DRC_QR_THR_MASK                  0x00C0  /* DRC_QR_THR - [7:6] */
+#define WM8904_DRC_QR_THR_SHIFT                      6  /* DRC_QR_THR - [7:6] */
+#define WM8904_DRC_QR_THR_WIDTH                      2  /* DRC_QR_THR - [7:6] */
+#define WM8904_DRC_QR_DCY_MASK                  0x0030  /* DRC_QR_DCY - [5:4] */
+#define WM8904_DRC_QR_DCY_SHIFT                      4  /* DRC_QR_DCY - [5:4] */
+#define WM8904_DRC_QR_DCY_WIDTH                      2  /* DRC_QR_DCY - [5:4] */
+#define WM8904_DRC_MINGAIN_MASK                 0x000C  /* DRC_MINGAIN - [3:2] */
+#define WM8904_DRC_MINGAIN_SHIFT                     2  /* DRC_MINGAIN - [3:2] */
+#define WM8904_DRC_MINGAIN_WIDTH                     2  /* DRC_MINGAIN - [3:2] */
+#define WM8904_DRC_MAXGAIN_MASK                 0x0003  /* DRC_MAXGAIN - [1:0] */
+#define WM8904_DRC_MAXGAIN_SHIFT                     0  /* DRC_MAXGAIN - [1:0] */
+#define WM8904_DRC_MAXGAIN_WIDTH                     2  /* DRC_MAXGAIN - [1:0] */
+
+/*
+ * R42 (0x2A) - DRC 2
+ */
+#define WM8904_DRC_HI_COMP_MASK                 0x0038  /* DRC_HI_COMP - [5:3] */
+#define WM8904_DRC_HI_COMP_SHIFT                     3  /* DRC_HI_COMP - [5:3] */
+#define WM8904_DRC_HI_COMP_WIDTH                     3  /* DRC_HI_COMP - [5:3] */
+#define WM8904_DRC_LO_COMP_MASK                 0x0007  /* DRC_LO_COMP - [2:0] */
+#define WM8904_DRC_LO_COMP_SHIFT                     0  /* DRC_LO_COMP - [2:0] */
+#define WM8904_DRC_LO_COMP_WIDTH                     3  /* DRC_LO_COMP - [2:0] */
+
+/*
+ * R43 (0x2B) - DRC 3
+ */
+#define WM8904_DRC_KNEE_IP_MASK                 0x07E0  /* DRC_KNEE_IP - [10:5] */
+#define WM8904_DRC_KNEE_IP_SHIFT                     5  /* DRC_KNEE_IP - [10:5] */
+#define WM8904_DRC_KNEE_IP_WIDTH                     6  /* DRC_KNEE_IP - [10:5] */
+#define WM8904_DRC_KNEE_OP_MASK                 0x001F  /* DRC_KNEE_OP - [4:0] */
+#define WM8904_DRC_KNEE_OP_SHIFT                     0  /* DRC_KNEE_OP - [4:0] */
+#define WM8904_DRC_KNEE_OP_WIDTH                     5  /* DRC_KNEE_OP - [4:0] */
+
+/*
+ * R44 (0x2C) - Analogue Left Input 0
+ */
+#define WM8904_LINMUTE                          0x0080  /* LINMUTE */
+#define WM8904_LINMUTE_MASK                     0x0080  /* LINMUTE */
+#define WM8904_LINMUTE_SHIFT                         7  /* LINMUTE */
+#define WM8904_LINMUTE_WIDTH                         1  /* LINMUTE */
+#define WM8904_LIN_VOL_MASK                     0x001F  /* LIN_VOL - [4:0] */
+#define WM8904_LIN_VOL_SHIFT                         0  /* LIN_VOL - [4:0] */
+#define WM8904_LIN_VOL_WIDTH                         5  /* LIN_VOL - [4:0] */
+
+/*
+ * R45 (0x2D) - Analogue Right Input 0
+ */
+#define WM8904_RINMUTE                          0x0080  /* RINMUTE */
+#define WM8904_RINMUTE_MASK                     0x0080  /* RINMUTE */
+#define WM8904_RINMUTE_SHIFT                         7  /* RINMUTE */
+#define WM8904_RINMUTE_WIDTH                         1  /* RINMUTE */
+#define WM8904_RIN_VOL_MASK                     0x001F  /* RIN_VOL - [4:0] */
+#define WM8904_RIN_VOL_SHIFT                         0  /* RIN_VOL - [4:0] */
+#define WM8904_RIN_VOL_WIDTH                         5  /* RIN_VOL - [4:0] */
+
+/*
+ * R46 (0x2E) - Analogue Left Input 1
+ */
+#define WM8904_INL_CM_ENA                       0x0040  /* INL_CM_ENA */
+#define WM8904_INL_CM_ENA_MASK                  0x0040  /* INL_CM_ENA */
+#define WM8904_INL_CM_ENA_SHIFT                      6  /* INL_CM_ENA */
+#define WM8904_INL_CM_ENA_WIDTH                      1  /* INL_CM_ENA */
+#define WM8904_L_IP_SEL_N_MASK                  0x0030  /* L_IP_SEL_N - [5:4] */
+#define WM8904_L_IP_SEL_N_SHIFT                      4  /* L_IP_SEL_N - [5:4] */
+#define WM8904_L_IP_SEL_N_WIDTH                      2  /* L_IP_SEL_N - [5:4] */
+#define WM8904_L_IP_SEL_P_MASK                  0x000C  /* L_IP_SEL_P - [3:2] */
+#define WM8904_L_IP_SEL_P_SHIFT                      2  /* L_IP_SEL_P - [3:2] */
+#define WM8904_L_IP_SEL_P_WIDTH                      2  /* L_IP_SEL_P - [3:2] */
+#define WM8904_L_MODE_MASK                      0x0003  /* L_MODE - [1:0] */
+#define WM8904_L_MODE_SHIFT                          0  /* L_MODE - [1:0] */
+#define WM8904_L_MODE_WIDTH                          2  /* L_MODE - [1:0] */
+
+/*
+ * R47 (0x2F) - Analogue Right Input 1
+ */
+#define WM8904_INR_CM_ENA                       0x0040  /* INR_CM_ENA */
+#define WM8904_INR_CM_ENA_MASK                  0x0040  /* INR_CM_ENA */
+#define WM8904_INR_CM_ENA_SHIFT                      6  /* INR_CM_ENA */
+#define WM8904_INR_CM_ENA_WIDTH                      1  /* INR_CM_ENA */
+#define WM8904_R_IP_SEL_N_MASK                  0x0030  /* R_IP_SEL_N - [5:4] */
+#define WM8904_R_IP_SEL_N_SHIFT                      4  /* R_IP_SEL_N - [5:4] */
+#define WM8904_R_IP_SEL_N_WIDTH                      2  /* R_IP_SEL_N - [5:4] */
+#define WM8904_R_IP_SEL_P_MASK                  0x000C  /* R_IP_SEL_P - [3:2] */
+#define WM8904_R_IP_SEL_P_SHIFT                      2  /* R_IP_SEL_P - [3:2] */
+#define WM8904_R_IP_SEL_P_WIDTH                      2  /* R_IP_SEL_P - [3:2] */
+#define WM8904_R_MODE_MASK                      0x0003  /* R_MODE - [1:0] */
+#define WM8904_R_MODE_SHIFT                          0  /* R_MODE - [1:0] */
+#define WM8904_R_MODE_WIDTH                          2  /* R_MODE - [1:0] */
+
+/*
+ * R57 (0x39) - Analogue OUT1 Left
+ */
+#define WM8904_HPOUTL_MUTE                      0x0100  /* HPOUTL_MUTE */
+#define WM8904_HPOUTL_MUTE_MASK                 0x0100  /* HPOUTL_MUTE */
+#define WM8904_HPOUTL_MUTE_SHIFT                     8  /* HPOUTL_MUTE */
+#define WM8904_HPOUTL_MUTE_WIDTH                     1  /* HPOUTL_MUTE */
+#define WM8904_HPOUT_VU                         0x0080  /* HPOUT_VU */
+#define WM8904_HPOUT_VU_MASK                    0x0080  /* HPOUT_VU */
+#define WM8904_HPOUT_VU_SHIFT                        7  /* HPOUT_VU */
+#define WM8904_HPOUT_VU_WIDTH                        1  /* HPOUT_VU */
+#define WM8904_HPOUTLZC                         0x0040  /* HPOUTLZC */
+#define WM8904_HPOUTLZC_MASK                    0x0040  /* HPOUTLZC */
+#define WM8904_HPOUTLZC_SHIFT                        6  /* HPOUTLZC */
+#define WM8904_HPOUTLZC_WIDTH                        1  /* HPOUTLZC */
+#define WM8904_HPOUTL_VOL_MASK                  0x003F  /* HPOUTL_VOL - [5:0] */
+#define WM8904_HPOUTL_VOL_SHIFT                      0  /* HPOUTL_VOL - [5:0] */
+#define WM8904_HPOUTL_VOL_WIDTH                      6  /* HPOUTL_VOL - [5:0] */
+
+/*
+ * R58 (0x3A) - Analogue OUT1 Right
+ */
+#define WM8904_HPOUTR_MUTE                      0x0100  /* HPOUTR_MUTE */
+#define WM8904_HPOUTR_MUTE_MASK                 0x0100  /* HPOUTR_MUTE */
+#define WM8904_HPOUTR_MUTE_SHIFT                     8  /* HPOUTR_MUTE */
+#define WM8904_HPOUTR_MUTE_WIDTH                     1  /* HPOUTR_MUTE */
+#define WM8904_HPOUT_VU                         0x0080  /* HPOUT_VU */
+#define WM8904_HPOUT_VU_MASK                    0x0080  /* HPOUT_VU */
+#define WM8904_HPOUT_VU_SHIFT                        7  /* HPOUT_VU */
+#define WM8904_HPOUT_VU_WIDTH                        1  /* HPOUT_VU */
+#define WM8904_HPOUTRZC                         0x0040  /* HPOUTRZC */
+#define WM8904_HPOUTRZC_MASK                    0x0040  /* HPOUTRZC */
+#define WM8904_HPOUTRZC_SHIFT                        6  /* HPOUTRZC */
+#define WM8904_HPOUTRZC_WIDTH                        1  /* HPOUTRZC */
+#define WM8904_HPOUTR_VOL_MASK                  0x003F  /* HPOUTR_VOL - [5:0] */
+#define WM8904_HPOUTR_VOL_SHIFT                      0  /* HPOUTR_VOL - [5:0] */
+#define WM8904_HPOUTR_VOL_WIDTH                      6  /* HPOUTR_VOL - [5:0] */
+
+/*
+ * R59 (0x3B) - Analogue OUT2 Left
+ */
+#define WM8904_LINEOUTL_MUTE                    0x0100  /* LINEOUTL_MUTE */
+#define WM8904_LINEOUTL_MUTE_MASK               0x0100  /* LINEOUTL_MUTE */
+#define WM8904_LINEOUTL_MUTE_SHIFT                   8  /* LINEOUTL_MUTE */
+#define WM8904_LINEOUTL_MUTE_WIDTH                   1  /* LINEOUTL_MUTE */
+#define WM8904_LINEOUT_VU                       0x0080  /* LINEOUT_VU */
+#define WM8904_LINEOUT_VU_MASK                  0x0080  /* LINEOUT_VU */
+#define WM8904_LINEOUT_VU_SHIFT                      7  /* LINEOUT_VU */
+#define WM8904_LINEOUT_VU_WIDTH                      1  /* LINEOUT_VU */
+#define WM8904_LINEOUTLZC                       0x0040  /* LINEOUTLZC */
+#define WM8904_LINEOUTLZC_MASK                  0x0040  /* LINEOUTLZC */
+#define WM8904_LINEOUTLZC_SHIFT                      6  /* LINEOUTLZC */
+#define WM8904_LINEOUTLZC_WIDTH                      1  /* LINEOUTLZC */
+#define WM8904_LINEOUTL_VOL_MASK                0x003F  /* LINEOUTL_VOL - [5:0] */
+#define WM8904_LINEOUTL_VOL_SHIFT                    0  /* LINEOUTL_VOL - [5:0] */
+#define WM8904_LINEOUTL_VOL_WIDTH                    6  /* LINEOUTL_VOL - [5:0] */
+
+/*
+ * R60 (0x3C) - Analogue OUT2 Right
+ */
+#define WM8904_LINEOUTR_MUTE                    0x0100  /* LINEOUTR_MUTE */
+#define WM8904_LINEOUTR_MUTE_MASK               0x0100  /* LINEOUTR_MUTE */
+#define WM8904_LINEOUTR_MUTE_SHIFT                   8  /* LINEOUTR_MUTE */
+#define WM8904_LINEOUTR_MUTE_WIDTH                   1  /* LINEOUTR_MUTE */
+#define WM8904_LINEOUT_VU                       0x0080  /* LINEOUT_VU */
+#define WM8904_LINEOUT_VU_MASK                  0x0080  /* LINEOUT_VU */
+#define WM8904_LINEOUT_VU_SHIFT                      7  /* LINEOUT_VU */
+#define WM8904_LINEOUT_VU_WIDTH                      1  /* LINEOUT_VU */
+#define WM8904_LINEOUTRZC                       0x0040  /* LINEOUTRZC */
+#define WM8904_LINEOUTRZC_MASK                  0x0040  /* LINEOUTRZC */
+#define WM8904_LINEOUTRZC_SHIFT                      6  /* LINEOUTRZC */
+#define WM8904_LINEOUTRZC_WIDTH                      1  /* LINEOUTRZC */
+#define WM8904_LINEOUTR_VOL_MASK                0x003F  /* LINEOUTR_VOL - [5:0] */
+#define WM8904_LINEOUTR_VOL_SHIFT                    0  /* LINEOUTR_VOL - [5:0] */
+#define WM8904_LINEOUTR_VOL_WIDTH                    6  /* LINEOUTR_VOL - [5:0] */
+
+/*
+ * R61 (0x3D) - Analogue OUT12 ZC
+ */
+#define WM8904_HPL_BYP_ENA                      0x0008  /* HPL_BYP_ENA */
+#define WM8904_HPL_BYP_ENA_MASK                 0x0008  /* HPL_BYP_ENA */
+#define WM8904_HPL_BYP_ENA_SHIFT                     3  /* HPL_BYP_ENA */
+#define WM8904_HPL_BYP_ENA_WIDTH                     1  /* HPL_BYP_ENA */
+#define WM8904_HPR_BYP_ENA                      0x0004  /* HPR_BYP_ENA */
+#define WM8904_HPR_BYP_ENA_MASK                 0x0004  /* HPR_BYP_ENA */
+#define WM8904_HPR_BYP_ENA_SHIFT                     2  /* HPR_BYP_ENA */
+#define WM8904_HPR_BYP_ENA_WIDTH                     1  /* HPR_BYP_ENA */
+#define WM8904_LINEOUTL_BYP_ENA                 0x0002  /* LINEOUTL_BYP_ENA */
+#define WM8904_LINEOUTL_BYP_ENA_MASK            0x0002  /* LINEOUTL_BYP_ENA */
+#define WM8904_LINEOUTL_BYP_ENA_SHIFT                1  /* LINEOUTL_BYP_ENA */
+#define WM8904_LINEOUTL_BYP_ENA_WIDTH                1  /* LINEOUTL_BYP_ENA */
+#define WM8904_LINEOUTR_BYP_ENA                 0x0001  /* LINEOUTR_BYP_ENA */
+#define WM8904_LINEOUTR_BYP_ENA_MASK            0x0001  /* LINEOUTR_BYP_ENA */
+#define WM8904_LINEOUTR_BYP_ENA_SHIFT                0  /* LINEOUTR_BYP_ENA */
+#define WM8904_LINEOUTR_BYP_ENA_WIDTH                1  /* LINEOUTR_BYP_ENA */
+
+/*
+ * R67 (0x43) - DC Servo 0
+ */
+#define WM8904_DCS_ENA_CHAN_3                   0x0008  /* DCS_ENA_CHAN_3 */
+#define WM8904_DCS_ENA_CHAN_3_MASK              0x0008  /* DCS_ENA_CHAN_3 */
+#define WM8904_DCS_ENA_CHAN_3_SHIFT                  3  /* DCS_ENA_CHAN_3 */
+#define WM8904_DCS_ENA_CHAN_3_WIDTH                  1  /* DCS_ENA_CHAN_3 */
+#define WM8904_DCS_ENA_CHAN_2                   0x0004  /* DCS_ENA_CHAN_2 */
+#define WM8904_DCS_ENA_CHAN_2_MASK              0x0004  /* DCS_ENA_CHAN_2 */
+#define WM8904_DCS_ENA_CHAN_2_SHIFT                  2  /* DCS_ENA_CHAN_2 */
+#define WM8904_DCS_ENA_CHAN_2_WIDTH                  1  /* DCS_ENA_CHAN_2 */
+#define WM8904_DCS_ENA_CHAN_1                   0x0002  /* DCS_ENA_CHAN_1 */
+#define WM8904_DCS_ENA_CHAN_1_MASK              0x0002  /* DCS_ENA_CHAN_1 */
+#define WM8904_DCS_ENA_CHAN_1_SHIFT                  1  /* DCS_ENA_CHAN_1 */
+#define WM8904_DCS_ENA_CHAN_1_WIDTH                  1  /* DCS_ENA_CHAN_1 */
+#define WM8904_DCS_ENA_CHAN_0                   0x0001  /* DCS_ENA_CHAN_0 */
+#define WM8904_DCS_ENA_CHAN_0_MASK              0x0001  /* DCS_ENA_CHAN_0 */
+#define WM8904_DCS_ENA_CHAN_0_SHIFT                  0  /* DCS_ENA_CHAN_0 */
+#define WM8904_DCS_ENA_CHAN_0_WIDTH                  1  /* DCS_ENA_CHAN_0 */
+
+/*
+ * R68 (0x44) - DC Servo 1
+ */
+#define WM8904_DCS_TRIG_SINGLE_3                0x8000  /* DCS_TRIG_SINGLE_3 */
+#define WM8904_DCS_TRIG_SINGLE_3_MASK           0x8000  /* DCS_TRIG_SINGLE_3 */
+#define WM8904_DCS_TRIG_SINGLE_3_SHIFT              15  /* DCS_TRIG_SINGLE_3 */
+#define WM8904_DCS_TRIG_SINGLE_3_WIDTH               1  /* DCS_TRIG_SINGLE_3 */
+#define WM8904_DCS_TRIG_SINGLE_2                0x4000  /* DCS_TRIG_SINGLE_2 */
+#define WM8904_DCS_TRIG_SINGLE_2_MASK           0x4000  /* DCS_TRIG_SINGLE_2 */
+#define WM8904_DCS_TRIG_SINGLE_2_SHIFT              14  /* DCS_TRIG_SINGLE_2 */
+#define WM8904_DCS_TRIG_SINGLE_2_WIDTH               1  /* DCS_TRIG_SINGLE_2 */
+#define WM8904_DCS_TRIG_SINGLE_1                0x2000  /* DCS_TRIG_SINGLE_1 */
+#define WM8904_DCS_TRIG_SINGLE_1_MASK           0x2000  /* DCS_TRIG_SINGLE_1 */
+#define WM8904_DCS_TRIG_SINGLE_1_SHIFT              13  /* DCS_TRIG_SINGLE_1 */
+#define WM8904_DCS_TRIG_SINGLE_1_WIDTH               1  /* DCS_TRIG_SINGLE_1 */
+#define WM8904_DCS_TRIG_SINGLE_0                0x1000  /* DCS_TRIG_SINGLE_0 */
+#define WM8904_DCS_TRIG_SINGLE_0_MASK           0x1000  /* DCS_TRIG_SINGLE_0 */
+#define WM8904_DCS_TRIG_SINGLE_0_SHIFT              12  /* DCS_TRIG_SINGLE_0 */
+#define WM8904_DCS_TRIG_SINGLE_0_WIDTH               1  /* DCS_TRIG_SINGLE_0 */
+#define WM8904_DCS_TRIG_SERIES_3                0x0800  /* DCS_TRIG_SERIES_3 */
+#define WM8904_DCS_TRIG_SERIES_3_MASK           0x0800  /* DCS_TRIG_SERIES_3 */
+#define WM8904_DCS_TRIG_SERIES_3_SHIFT              11  /* DCS_TRIG_SERIES_3 */
+#define WM8904_DCS_TRIG_SERIES_3_WIDTH               1  /* DCS_TRIG_SERIES_3 */
+#define WM8904_DCS_TRIG_SERIES_2                0x0400  /* DCS_TRIG_SERIES_2 */
+#define WM8904_DCS_TRIG_SERIES_2_MASK           0x0400  /* DCS_TRIG_SERIES_2 */
+#define WM8904_DCS_TRIG_SERIES_2_SHIFT              10  /* DCS_TRIG_SERIES_2 */
+#define WM8904_DCS_TRIG_SERIES_2_WIDTH               1  /* DCS_TRIG_SERIES_2 */
+#define WM8904_DCS_TRIG_SERIES_1                0x0200  /* DCS_TRIG_SERIES_1 */
+#define WM8904_DCS_TRIG_SERIES_1_MASK           0x0200  /* DCS_TRIG_SERIES_1 */
+#define WM8904_DCS_TRIG_SERIES_1_SHIFT               9  /* DCS_TRIG_SERIES_1 */
+#define WM8904_DCS_TRIG_SERIES_1_WIDTH               1  /* DCS_TRIG_SERIES_1 */
+#define WM8904_DCS_TRIG_SERIES_0                0x0100  /* DCS_TRIG_SERIES_0 */
+#define WM8904_DCS_TRIG_SERIES_0_MASK           0x0100  /* DCS_TRIG_SERIES_0 */
+#define WM8904_DCS_TRIG_SERIES_0_SHIFT               8  /* DCS_TRIG_SERIES_0 */
+#define WM8904_DCS_TRIG_SERIES_0_WIDTH               1  /* DCS_TRIG_SERIES_0 */
+#define WM8904_DCS_TRIG_STARTUP_3               0x0080  /* DCS_TRIG_STARTUP_3 */
+#define WM8904_DCS_TRIG_STARTUP_3_MASK          0x0080  /* DCS_TRIG_STARTUP_3 */
+#define WM8904_DCS_TRIG_STARTUP_3_SHIFT              7  /* DCS_TRIG_STARTUP_3 */
+#define WM8904_DCS_TRIG_STARTUP_3_WIDTH              1  /* DCS_TRIG_STARTUP_3 */
+#define WM8904_DCS_TRIG_STARTUP_2               0x0040  /* DCS_TRIG_STARTUP_2 */
+#define WM8904_DCS_TRIG_STARTUP_2_MASK          0x0040  /* DCS_TRIG_STARTUP_2 */
+#define WM8904_DCS_TRIG_STARTUP_2_SHIFT              6  /* DCS_TRIG_STARTUP_2 */
+#define WM8904_DCS_TRIG_STARTUP_2_WIDTH              1  /* DCS_TRIG_STARTUP_2 */
+#define WM8904_DCS_TRIG_STARTUP_1               0x0020  /* DCS_TRIG_STARTUP_1 */
+#define WM8904_DCS_TRIG_STARTUP_1_MASK          0x0020  /* DCS_TRIG_STARTUP_1 */
+#define WM8904_DCS_TRIG_STARTUP_1_SHIFT              5  /* DCS_TRIG_STARTUP_1 */
+#define WM8904_DCS_TRIG_STARTUP_1_WIDTH              1  /* DCS_TRIG_STARTUP_1 */
+#define WM8904_DCS_TRIG_STARTUP_0               0x0010  /* DCS_TRIG_STARTUP_0 */
+#define WM8904_DCS_TRIG_STARTUP_0_MASK          0x0010  /* DCS_TRIG_STARTUP_0 */
+#define WM8904_DCS_TRIG_STARTUP_0_SHIFT              4  /* DCS_TRIG_STARTUP_0 */
+#define WM8904_DCS_TRIG_STARTUP_0_WIDTH              1  /* DCS_TRIG_STARTUP_0 */
+#define WM8904_DCS_TRIG_DAC_WR_3                0x0008  /* DCS_TRIG_DAC_WR_3 */
+#define WM8904_DCS_TRIG_DAC_WR_3_MASK           0x0008  /* DCS_TRIG_DAC_WR_3 */
+#define WM8904_DCS_TRIG_DAC_WR_3_SHIFT               3  /* DCS_TRIG_DAC_WR_3 */
+#define WM8904_DCS_TRIG_DAC_WR_3_WIDTH               1  /* DCS_TRIG_DAC_WR_3 */
+#define WM8904_DCS_TRIG_DAC_WR_2                0x0004  /* DCS_TRIG_DAC_WR_2 */
+#define WM8904_DCS_TRIG_DAC_WR_2_MASK           0x0004  /* DCS_TRIG_DAC_WR_2 */
+#define WM8904_DCS_TRIG_DAC_WR_2_SHIFT               2  /* DCS_TRIG_DAC_WR_2 */
+#define WM8904_DCS_TRIG_DAC_WR_2_WIDTH               1  /* DCS_TRIG_DAC_WR_2 */
+#define WM8904_DCS_TRIG_DAC_WR_1                0x0002  /* DCS_TRIG_DAC_WR_1 */
+#define WM8904_DCS_TRIG_DAC_WR_1_MASK           0x0002  /* DCS_TRIG_DAC_WR_1 */
+#define WM8904_DCS_TRIG_DAC_WR_1_SHIFT               1  /* DCS_TRIG_DAC_WR_1 */
+#define WM8904_DCS_TRIG_DAC_WR_1_WIDTH               1  /* DCS_TRIG_DAC_WR_1 */
+#define WM8904_DCS_TRIG_DAC_WR_0                0x0001  /* DCS_TRIG_DAC_WR_0 */
+#define WM8904_DCS_TRIG_DAC_WR_0_MASK           0x0001  /* DCS_TRIG_DAC_WR_0 */
+#define WM8904_DCS_TRIG_DAC_WR_0_SHIFT               0  /* DCS_TRIG_DAC_WR_0 */
+#define WM8904_DCS_TRIG_DAC_WR_0_WIDTH               1  /* DCS_TRIG_DAC_WR_0 */
+
+/*
+ * R69 (0x45) - DC Servo 2
+ */
+#define WM8904_DCS_TIMER_PERIOD_23_MASK         0x0F00  /* DCS_TIMER_PERIOD_23 - [11:8] */
+#define WM8904_DCS_TIMER_PERIOD_23_SHIFT             8  /* DCS_TIMER_PERIOD_23 - [11:8] */
+#define WM8904_DCS_TIMER_PERIOD_23_WIDTH             4  /* DCS_TIMER_PERIOD_23 - [11:8] */
+#define WM8904_DCS_TIMER_PERIOD_01_MASK         0x000F  /* DCS_TIMER_PERIOD_01 - [3:0] */
+#define WM8904_DCS_TIMER_PERIOD_01_SHIFT             0  /* DCS_TIMER_PERIOD_01 - [3:0] */
+#define WM8904_DCS_TIMER_PERIOD_01_WIDTH             4  /* DCS_TIMER_PERIOD_01 - [3:0] */
+
+/*
+ * R71 (0x47) - DC Servo 4
+ */
+#define WM8904_DCS_SERIES_NO_23_MASK            0x007F  /* DCS_SERIES_NO_23 - [6:0] */
+#define WM8904_DCS_SERIES_NO_23_SHIFT                0  /* DCS_SERIES_NO_23 - [6:0] */
+#define WM8904_DCS_SERIES_NO_23_WIDTH                7  /* DCS_SERIES_NO_23 - [6:0] */
+
+/*
+ * R72 (0x48) - DC Servo 5
+ */
+#define WM8904_DCS_SERIES_NO_01_MASK            0x007F  /* DCS_SERIES_NO_01 - [6:0] */
+#define WM8904_DCS_SERIES_NO_01_SHIFT                0  /* DCS_SERIES_NO_01 - [6:0] */
+#define WM8904_DCS_SERIES_NO_01_WIDTH                7  /* DCS_SERIES_NO_01 - [6:0] */
+
+/*
+ * R73 (0x49) - DC Servo 6
+ */
+#define WM8904_DCS_DAC_WR_VAL_3_MASK            0x00FF  /* DCS_DAC_WR_VAL_3 - [7:0] */
+#define WM8904_DCS_DAC_WR_VAL_3_SHIFT                0  /* DCS_DAC_WR_VAL_3 - [7:0] */
+#define WM8904_DCS_DAC_WR_VAL_3_WIDTH                8  /* DCS_DAC_WR_VAL_3 - [7:0] */
+
+/*
+ * R74 (0x4A) - DC Servo 7
+ */
+#define WM8904_DCS_DAC_WR_VAL_2_MASK            0x00FF  /* DCS_DAC_WR_VAL_2 - [7:0] */
+#define WM8904_DCS_DAC_WR_VAL_2_SHIFT                0  /* DCS_DAC_WR_VAL_2 - [7:0] */
+#define WM8904_DCS_DAC_WR_VAL_2_WIDTH                8  /* DCS_DAC_WR_VAL_2 - [7:0] */
+
+/*
+ * R75 (0x4B) - DC Servo 8
+ */
+#define WM8904_DCS_DAC_WR_VAL_1_MASK            0x00FF  /* DCS_DAC_WR_VAL_1 - [7:0] */
+#define WM8904_DCS_DAC_WR_VAL_1_SHIFT                0  /* DCS_DAC_WR_VAL_1 - [7:0] */
+#define WM8904_DCS_DAC_WR_VAL_1_WIDTH                8  /* DCS_DAC_WR_VAL_1 - [7:0] */
+
+/*
+ * R76 (0x4C) - DC Servo 9
+ */
+#define WM8904_DCS_DAC_WR_VAL_0_MASK            0x00FF  /* DCS_DAC_WR_VAL_0 - [7:0] */
+#define WM8904_DCS_DAC_WR_VAL_0_SHIFT                0  /* DCS_DAC_WR_VAL_0 - [7:0] */
+#define WM8904_DCS_DAC_WR_VAL_0_WIDTH                8  /* DCS_DAC_WR_VAL_0 - [7:0] */
+
+/*
+ * R77 (0x4D) - DC Servo Readback 0
+ */
+#define WM8904_DCS_CAL_COMPLETE_MASK            0x0F00  /* DCS_CAL_COMPLETE - [11:8] */
+#define WM8904_DCS_CAL_COMPLETE_SHIFT                8  /* DCS_CAL_COMPLETE - [11:8] */
+#define WM8904_DCS_CAL_COMPLETE_WIDTH                4  /* DCS_CAL_COMPLETE - [11:8] */
+#define WM8904_DCS_DAC_WR_COMPLETE_MASK         0x00F0  /* DCS_DAC_WR_COMPLETE - [7:4] */
+#define WM8904_DCS_DAC_WR_COMPLETE_SHIFT             4  /* DCS_DAC_WR_COMPLETE - [7:4] */
+#define WM8904_DCS_DAC_WR_COMPLETE_WIDTH             4  /* DCS_DAC_WR_COMPLETE - [7:4] */
+#define WM8904_DCS_STARTUP_COMPLETE_MASK        0x000F  /* DCS_STARTUP_COMPLETE - [3:0] */
+#define WM8904_DCS_STARTUP_COMPLETE_SHIFT            0  /* DCS_STARTUP_COMPLETE - [3:0] */
+#define WM8904_DCS_STARTUP_COMPLETE_WIDTH            4  /* DCS_STARTUP_COMPLETE - [3:0] */
+
+/*
+ * R90 (0x5A) - Analogue HP 0
+ */
+#define WM8904_HPL_RMV_SHORT                    0x0080  /* HPL_RMV_SHORT */
+#define WM8904_HPL_RMV_SHORT_MASK               0x0080  /* HPL_RMV_SHORT */
+#define WM8904_HPL_RMV_SHORT_SHIFT                   7  /* HPL_RMV_SHORT */
+#define WM8904_HPL_RMV_SHORT_WIDTH                   1  /* HPL_RMV_SHORT */
+#define WM8904_HPL_ENA_OUTP                     0x0040  /* HPL_ENA_OUTP */
+#define WM8904_HPL_ENA_OUTP_MASK                0x0040  /* HPL_ENA_OUTP */
+#define WM8904_HPL_ENA_OUTP_SHIFT                    6  /* HPL_ENA_OUTP */
+#define WM8904_HPL_ENA_OUTP_WIDTH                    1  /* HPL_ENA_OUTP */
+#define WM8904_HPL_ENA_DLY                      0x0020  /* HPL_ENA_DLY */
+#define WM8904_HPL_ENA_DLY_MASK                 0x0020  /* HPL_ENA_DLY */
+#define WM8904_HPL_ENA_DLY_SHIFT                     5  /* HPL_ENA_DLY */
+#define WM8904_HPL_ENA_DLY_WIDTH                     1  /* HPL_ENA_DLY */
+#define WM8904_HPL_ENA                          0x0010  /* HPL_ENA */
+#define WM8904_HPL_ENA_MASK                     0x0010  /* HPL_ENA */
+#define WM8904_HPL_ENA_SHIFT                         4  /* HPL_ENA */
+#define WM8904_HPL_ENA_WIDTH                         1  /* HPL_ENA */
+#define WM8904_HPR_RMV_SHORT                    0x0008  /* HPR_RMV_SHORT */
+#define WM8904_HPR_RMV_SHORT_MASK               0x0008  /* HPR_RMV_SHORT */
+#define WM8904_HPR_RMV_SHORT_SHIFT                   3  /* HPR_RMV_SHORT */
+#define WM8904_HPR_RMV_SHORT_WIDTH                   1  /* HPR_RMV_SHORT */
+#define WM8904_HPR_ENA_OUTP                     0x0004  /* HPR_ENA_OUTP */
+#define WM8904_HPR_ENA_OUTP_MASK                0x0004  /* HPR_ENA_OUTP */
+#define WM8904_HPR_ENA_OUTP_SHIFT                    2  /* HPR_ENA_OUTP */
+#define WM8904_HPR_ENA_OUTP_WIDTH                    1  /* HPR_ENA_OUTP */
+#define WM8904_HPR_ENA_DLY                      0x0002  /* HPR_ENA_DLY */
+#define WM8904_HPR_ENA_DLY_MASK                 0x0002  /* HPR_ENA_DLY */
+#define WM8904_HPR_ENA_DLY_SHIFT                     1  /* HPR_ENA_DLY */
+#define WM8904_HPR_ENA_DLY_WIDTH                     1  /* HPR_ENA_DLY */
+#define WM8904_HPR_ENA                          0x0001  /* HPR_ENA */
+#define WM8904_HPR_ENA_MASK                     0x0001  /* HPR_ENA */
+#define WM8904_HPR_ENA_SHIFT                         0  /* HPR_ENA */
+#define WM8904_HPR_ENA_WIDTH                         1  /* HPR_ENA */
+
+/*
+ * R94 (0x5E) - Analogue Lineout 0
+ */
+#define WM8904_LINEOUTL_RMV_SHORT               0x0080  /* LINEOUTL_RMV_SHORT */
+#define WM8904_LINEOUTL_RMV_SHORT_MASK          0x0080  /* LINEOUTL_RMV_SHORT */
+#define WM8904_LINEOUTL_RMV_SHORT_SHIFT              7  /* LINEOUTL_RMV_SHORT */
+#define WM8904_LINEOUTL_RMV_SHORT_WIDTH              1  /* LINEOUTL_RMV_SHORT */
+#define WM8904_LINEOUTL_ENA_OUTP                0x0040  /* LINEOUTL_ENA_OUTP */
+#define WM8904_LINEOUTL_ENA_OUTP_MASK           0x0040  /* LINEOUTL_ENA_OUTP */
+#define WM8904_LINEOUTL_ENA_OUTP_SHIFT               6  /* LINEOUTL_ENA_OUTP */
+#define WM8904_LINEOUTL_ENA_OUTP_WIDTH               1  /* LINEOUTL_ENA_OUTP */
+#define WM8904_LINEOUTL_ENA_DLY                 0x0020  /* LINEOUTL_ENA_DLY */
+#define WM8904_LINEOUTL_ENA_DLY_MASK            0x0020  /* LINEOUTL_ENA_DLY */
+#define WM8904_LINEOUTL_ENA_DLY_SHIFT                5  /* LINEOUTL_ENA_DLY */
+#define WM8904_LINEOUTL_ENA_DLY_WIDTH                1  /* LINEOUTL_ENA_DLY */
+#define WM8904_LINEOUTL_ENA                     0x0010  /* LINEOUTL_ENA */
+#define WM8904_LINEOUTL_ENA_MASK                0x0010  /* LINEOUTL_ENA */
+#define WM8904_LINEOUTL_ENA_SHIFT                    4  /* LINEOUTL_ENA */
+#define WM8904_LINEOUTL_ENA_WIDTH                    1  /* LINEOUTL_ENA */
+#define WM8904_LINEOUTR_RMV_SHORT               0x0008  /* LINEOUTR_RMV_SHORT */
+#define WM8904_LINEOUTR_RMV_SHORT_MASK          0x0008  /* LINEOUTR_RMV_SHORT */
+#define WM8904_LINEOUTR_RMV_SHORT_SHIFT              3  /* LINEOUTR_RMV_SHORT */
+#define WM8904_LINEOUTR_RMV_SHORT_WIDTH              1  /* LINEOUTR_RMV_SHORT */
+#define WM8904_LINEOUTR_ENA_OUTP                0x0004  /* LINEOUTR_ENA_OUTP */
+#define WM8904_LINEOUTR_ENA_OUTP_MASK           0x0004  /* LINEOUTR_ENA_OUTP */
+#define WM8904_LINEOUTR_ENA_OUTP_SHIFT               2  /* LINEOUTR_ENA_OUTP */
+#define WM8904_LINEOUTR_ENA_OUTP_WIDTH               1  /* LINEOUTR_ENA_OUTP */
+#define WM8904_LINEOUTR_ENA_DLY                 0x0002  /* LINEOUTR_ENA_DLY */
+#define WM8904_LINEOUTR_ENA_DLY_MASK            0x0002  /* LINEOUTR_ENA_DLY */
+#define WM8904_LINEOUTR_ENA_DLY_SHIFT                1  /* LINEOUTR_ENA_DLY */
+#define WM8904_LINEOUTR_ENA_DLY_WIDTH                1  /* LINEOUTR_ENA_DLY */
+#define WM8904_LINEOUTR_ENA                     0x0001  /* LINEOUTR_ENA */
+#define WM8904_LINEOUTR_ENA_MASK                0x0001  /* LINEOUTR_ENA */
+#define WM8904_LINEOUTR_ENA_SHIFT                    0  /* LINEOUTR_ENA */
+#define WM8904_LINEOUTR_ENA_WIDTH                    1  /* LINEOUTR_ENA */
+
+/*
+ * R98 (0x62) - Charge Pump 0
+ */
+#define WM8904_CP_ENA                           0x0001  /* CP_ENA */
+#define WM8904_CP_ENA_MASK                      0x0001  /* CP_ENA */
+#define WM8904_CP_ENA_SHIFT                          0  /* CP_ENA */
+#define WM8904_CP_ENA_WIDTH                          1  /* CP_ENA */
+
+/*
+ * R104 (0x68) - Class W 0
+ */
+#define WM8904_CP_DYN_PWR                       0x0001  /* CP_DYN_PWR */
+#define WM8904_CP_DYN_PWR_MASK                  0x0001  /* CP_DYN_PWR */
+#define WM8904_CP_DYN_PWR_SHIFT                      0  /* CP_DYN_PWR */
+#define WM8904_CP_DYN_PWR_WIDTH                      1  /* CP_DYN_PWR */
+
+/*
+ * R108 (0x6C) - Write Sequencer 0
+ */
+#define WM8904_WSEQ_ENA                         0x0100  /* WSEQ_ENA */
+#define WM8904_WSEQ_ENA_MASK                    0x0100  /* WSEQ_ENA */
+#define WM8904_WSEQ_ENA_SHIFT                        8  /* WSEQ_ENA */
+#define WM8904_WSEQ_ENA_WIDTH                        1  /* WSEQ_ENA */
+#define WM8904_WSEQ_WRITE_INDEX_MASK            0x001F  /* WSEQ_WRITE_INDEX - [4:0] */
+#define WM8904_WSEQ_WRITE_INDEX_SHIFT                0  /* WSEQ_WRITE_INDEX - [4:0] */
+#define WM8904_WSEQ_WRITE_INDEX_WIDTH                5  /* WSEQ_WRITE_INDEX - [4:0] */
+
+/*
+ * R109 (0x6D) - Write Sequencer 1
+ */
+#define WM8904_WSEQ_DATA_WIDTH_MASK             0x7000  /* WSEQ_DATA_WIDTH - [14:12] */
+#define WM8904_WSEQ_DATA_WIDTH_SHIFT                12  /* WSEQ_DATA_WIDTH - [14:12] */
+#define WM8904_WSEQ_DATA_WIDTH_WIDTH                 3  /* WSEQ_DATA_WIDTH - [14:12] */
+#define WM8904_WSEQ_DATA_START_MASK             0x0F00  /* WSEQ_DATA_START - [11:8] */
+#define WM8904_WSEQ_DATA_START_SHIFT                 8  /* WSEQ_DATA_START - [11:8] */
+#define WM8904_WSEQ_DATA_START_WIDTH                 4  /* WSEQ_DATA_START - [11:8] */
+#define WM8904_WSEQ_ADDR_MASK                   0x00FF  /* WSEQ_ADDR - [7:0] */
+#define WM8904_WSEQ_ADDR_SHIFT                       0  /* WSEQ_ADDR - [7:0] */
+#define WM8904_WSEQ_ADDR_WIDTH                       8  /* WSEQ_ADDR - [7:0] */
+
+/*
+ * R110 (0x6E) - Write Sequencer 2
+ */
+#define WM8904_WSEQ_EOS                         0x4000  /* WSEQ_EOS */
+#define WM8904_WSEQ_EOS_MASK                    0x4000  /* WSEQ_EOS */
+#define WM8904_WSEQ_EOS_SHIFT                       14  /* WSEQ_EOS */
+#define WM8904_WSEQ_EOS_WIDTH                        1  /* WSEQ_EOS */
+#define WM8904_WSEQ_DELAY_MASK                  0x0F00  /* WSEQ_DELAY - [11:8] */
+#define WM8904_WSEQ_DELAY_SHIFT                      8  /* WSEQ_DELAY - [11:8] */
+#define WM8904_WSEQ_DELAY_WIDTH                      4  /* WSEQ_DELAY - [11:8] */
+#define WM8904_WSEQ_DATA_MASK                   0x00FF  /* WSEQ_DATA - [7:0] */
+#define WM8904_WSEQ_DATA_SHIFT                       0  /* WSEQ_DATA - [7:0] */
+#define WM8904_WSEQ_DATA_WIDTH                       8  /* WSEQ_DATA - [7:0] */
+
+/*
+ * R111 (0x6F) - Write Sequencer 3
+ */
+#define WM8904_WSEQ_ABORT                       0x0200  /* WSEQ_ABORT */
+#define WM8904_WSEQ_ABORT_MASK                  0x0200  /* WSEQ_ABORT */
+#define WM8904_WSEQ_ABORT_SHIFT                      9  /* WSEQ_ABORT */
+#define WM8904_WSEQ_ABORT_WIDTH                      1  /* WSEQ_ABORT */
+#define WM8904_WSEQ_START                       0x0100  /* WSEQ_START */
+#define WM8904_WSEQ_START_MASK                  0x0100  /* WSEQ_START */
+#define WM8904_WSEQ_START_SHIFT                      8  /* WSEQ_START */
+#define WM8904_WSEQ_START_WIDTH                      1  /* WSEQ_START */
+#define WM8904_WSEQ_START_INDEX_MASK            0x003F  /* WSEQ_START_INDEX - [5:0] */
+#define WM8904_WSEQ_START_INDEX_SHIFT                0  /* WSEQ_START_INDEX - [5:0] */
+#define WM8904_WSEQ_START_INDEX_WIDTH                6  /* WSEQ_START_INDEX - [5:0] */
+
+/*
+ * R112 (0x70) - Write Sequencer 4
+ */
+#define WM8904_WSEQ_CURRENT_INDEX_MASK          0x03F0  /* WSEQ_CURRENT_INDEX - [9:4] */
+#define WM8904_WSEQ_CURRENT_INDEX_SHIFT              4  /* WSEQ_CURRENT_INDEX - [9:4] */
+#define WM8904_WSEQ_CURRENT_INDEX_WIDTH              6  /* WSEQ_CURRENT_INDEX - [9:4] */
+#define WM8904_WSEQ_BUSY                        0x0001  /* WSEQ_BUSY */
+#define WM8904_WSEQ_BUSY_MASK                   0x0001  /* WSEQ_BUSY */
+#define WM8904_WSEQ_BUSY_SHIFT                       0  /* WSEQ_BUSY */
+#define WM8904_WSEQ_BUSY_WIDTH                       1  /* WSEQ_BUSY */
+
+/*
+ * R116 (0x74) - FLL Control 1
+ */
+#define WM8904_FLL_FRACN_ENA                    0x0004  /* FLL_FRACN_ENA */
+#define WM8904_FLL_FRACN_ENA_MASK               0x0004  /* FLL_FRACN_ENA */
+#define WM8904_FLL_FRACN_ENA_SHIFT                   2  /* FLL_FRACN_ENA */
+#define WM8904_FLL_FRACN_ENA_WIDTH                   1  /* FLL_FRACN_ENA */
+#define WM8904_FLL_OSC_ENA                      0x0002  /* FLL_OSC_ENA */
+#define WM8904_FLL_OSC_ENA_MASK                 0x0002  /* FLL_OSC_ENA */
+#define WM8904_FLL_OSC_ENA_SHIFT                     1  /* FLL_OSC_ENA */
+#define WM8904_FLL_OSC_ENA_WIDTH                     1  /* FLL_OSC_ENA */
+#define WM8904_FLL_ENA                          0x0001  /* FLL_ENA */
+#define WM8904_FLL_ENA_MASK                     0x0001  /* FLL_ENA */
+#define WM8904_FLL_ENA_SHIFT                         0  /* FLL_ENA */
+#define WM8904_FLL_ENA_WIDTH                         1  /* FLL_ENA */
+
+/*
+ * R117 (0x75) - FLL Control 2
+ */
+#define WM8904_FLL_OUTDIV_MASK                  0x3F00  /* FLL_OUTDIV - [13:8] */
+#define WM8904_FLL_OUTDIV_SHIFT                      8  /* FLL_OUTDIV - [13:8] */
+#define WM8904_FLL_OUTDIV_WIDTH                      6  /* FLL_OUTDIV - [13:8] */
+#define WM8904_FLL_CTRL_RATE_MASK               0x0070  /* FLL_CTRL_RATE - [6:4] */
+#define WM8904_FLL_CTRL_RATE_SHIFT                   4  /* FLL_CTRL_RATE - [6:4] */
+#define WM8904_FLL_CTRL_RATE_WIDTH                   3  /* FLL_CTRL_RATE - [6:4] */
+#define WM8904_FLL_FRATIO_MASK                  0x0007  /* FLL_FRATIO - [2:0] */
+#define WM8904_FLL_FRATIO_SHIFT                      0  /* FLL_FRATIO - [2:0] */
+#define WM8904_FLL_FRATIO_WIDTH                      3  /* FLL_FRATIO - [2:0] */
+
+/*
+ * R118 (0x76) - FLL Control 3
+ */
+#define WM8904_FLL_K_MASK                       0xFFFF  /* FLL_K - [15:0] */
+#define WM8904_FLL_K_SHIFT                           0  /* FLL_K - [15:0] */
+#define WM8904_FLL_K_WIDTH                          16  /* FLL_K - [15:0] */
+
+/*
+ * R119 (0x77) - FLL Control 4
+ */
+#define WM8904_FLL_N_MASK                       0x7FE0  /* FLL_N - [14:5] */
+#define WM8904_FLL_N_SHIFT                           5  /* FLL_N - [14:5] */
+#define WM8904_FLL_N_WIDTH                          10  /* FLL_N - [14:5] */
+#define WM8904_FLL_GAIN_MASK                    0x000F  /* FLL_GAIN - [3:0] */
+#define WM8904_FLL_GAIN_SHIFT                        0  /* FLL_GAIN - [3:0] */
+#define WM8904_FLL_GAIN_WIDTH                        4  /* FLL_GAIN - [3:0] */
+
+/*
+ * R120 (0x78) - FLL Control 5
+ */
+#define WM8904_FLL_CLK_REF_DIV_MASK             0x0018  /* FLL_CLK_REF_DIV - [4:3] */
+#define WM8904_FLL_CLK_REF_DIV_SHIFT                 3  /* FLL_CLK_REF_DIV - [4:3] */
+#define WM8904_FLL_CLK_REF_DIV_WIDTH                 2  /* FLL_CLK_REF_DIV - [4:3] */
+#define WM8904_FLL_CLK_REF_SRC_MASK             0x0003  /* FLL_CLK_REF_SRC - [1:0] */
+#define WM8904_FLL_CLK_REF_SRC_SHIFT                 0  /* FLL_CLK_REF_SRC - [1:0] */
+#define WM8904_FLL_CLK_REF_SRC_WIDTH                 2  /* FLL_CLK_REF_SRC - [1:0] */
+
+/*
+ * R121 (0x79) - GPIO Control 1
+ */
+#define WM8904_GPIO1_PU                         0x0020  /* GPIO1_PU */
+#define WM8904_GPIO1_PU_MASK                    0x0020  /* GPIO1_PU */
+#define WM8904_GPIO1_PU_SHIFT                        5  /* GPIO1_PU */
+#define WM8904_GPIO1_PU_WIDTH                        1  /* GPIO1_PU */
+#define WM8904_GPIO1_PD                         0x0010  /* GPIO1_PD */
+#define WM8904_GPIO1_PD_MASK                    0x0010  /* GPIO1_PD */
+#define WM8904_GPIO1_PD_SHIFT                        4  /* GPIO1_PD */
+#define WM8904_GPIO1_PD_WIDTH                        1  /* GPIO1_PD */
+#define WM8904_GPIO1_SEL_MASK                   0x000F  /* GPIO1_SEL - [3:0] */
+#define WM8904_GPIO1_SEL_SHIFT                       0  /* GPIO1_SEL - [3:0] */
+#define WM8904_GPIO1_SEL_WIDTH                       4  /* GPIO1_SEL - [3:0] */
+
+/*
+ * R122 (0x7A) - GPIO Control 2
+ */
+#define WM8904_GPIO2_PU                         0x0020  /* GPIO2_PU */
+#define WM8904_GPIO2_PU_MASK                    0x0020  /* GPIO2_PU */
+#define WM8904_GPIO2_PU_SHIFT                        5  /* GPIO2_PU */
+#define WM8904_GPIO2_PU_WIDTH                        1  /* GPIO2_PU */
+#define WM8904_GPIO2_PD                         0x0010  /* GPIO2_PD */
+#define WM8904_GPIO2_PD_MASK                    0x0010  /* GPIO2_PD */
+#define WM8904_GPIO2_PD_SHIFT                        4  /* GPIO2_PD */
+#define WM8904_GPIO2_PD_WIDTH                        1  /* GPIO2_PD */
+#define WM8904_GPIO2_SEL_MASK                   0x000F  /* GPIO2_SEL - [3:0] */
+#define WM8904_GPIO2_SEL_SHIFT                       0  /* GPIO2_SEL - [3:0] */
+#define WM8904_GPIO2_SEL_WIDTH                       4  /* GPIO2_SEL - [3:0] */
+
+/*
+ * R123 (0x7B) - GPIO Control 3
+ */
+#define WM8904_GPIO3_PU                         0x0020  /* GPIO3_PU */
+#define WM8904_GPIO3_PU_MASK                    0x0020  /* GPIO3_PU */
+#define WM8904_GPIO3_PU_SHIFT                        5  /* GPIO3_PU */
+#define WM8904_GPIO3_PU_WIDTH                        1  /* GPIO3_PU */
+#define WM8904_GPIO3_PD                         0x0010  /* GPIO3_PD */
+#define WM8904_GPIO3_PD_MASK                    0x0010  /* GPIO3_PD */
+#define WM8904_GPIO3_PD_SHIFT                        4  /* GPIO3_PD */
+#define WM8904_GPIO3_PD_WIDTH                        1  /* GPIO3_PD */
+#define WM8904_GPIO3_SEL_MASK                   0x000F  /* GPIO3_SEL - [3:0] */
+#define WM8904_GPIO3_SEL_SHIFT                       0  /* GPIO3_SEL - [3:0] */
+#define WM8904_GPIO3_SEL_WIDTH                       4  /* GPIO3_SEL - [3:0] */
+
+/*
+ * R124 (0x7C) - GPIO Control 4
+ */
+#define WM8904_GPI7_ENA                         0x0200  /* GPI7_ENA */
+#define WM8904_GPI7_ENA_MASK                    0x0200  /* GPI7_ENA */
+#define WM8904_GPI7_ENA_SHIFT                        9  /* GPI7_ENA */
+#define WM8904_GPI7_ENA_WIDTH                        1  /* GPI7_ENA */
+#define WM8904_GPI8_ENA                         0x0100  /* GPI8_ENA */
+#define WM8904_GPI8_ENA_MASK                    0x0100  /* GPI8_ENA */
+#define WM8904_GPI8_ENA_SHIFT                        8  /* GPI8_ENA */
+#define WM8904_GPI8_ENA_WIDTH                        1  /* GPI8_ENA */
+#define WM8904_GPIO_BCLK_MODE_ENA               0x0080  /* GPIO_BCLK_MODE_ENA */
+#define WM8904_GPIO_BCLK_MODE_ENA_MASK          0x0080  /* GPIO_BCLK_MODE_ENA */
+#define WM8904_GPIO_BCLK_MODE_ENA_SHIFT              7  /* GPIO_BCLK_MODE_ENA */
+#define WM8904_GPIO_BCLK_MODE_ENA_WIDTH              1  /* GPIO_BCLK_MODE_ENA */
+#define WM8904_GPIO_BCLK_SEL_MASK               0x000F  /* GPIO_BCLK_SEL - [3:0] */
+#define WM8904_GPIO_BCLK_SEL_SHIFT                   0  /* GPIO_BCLK_SEL - [3:0] */
+#define WM8904_GPIO_BCLK_SEL_WIDTH                   4  /* GPIO_BCLK_SEL - [3:0] */
+
+/*
+ * R126 (0x7E) - Digital Pulls
+ */
+#define WM8904_MCLK_PU                          0x0080  /* MCLK_PU */
+#define WM8904_MCLK_PU_MASK                     0x0080  /* MCLK_PU */
+#define WM8904_MCLK_PU_SHIFT                         7  /* MCLK_PU */
+#define WM8904_MCLK_PU_WIDTH                         1  /* MCLK_PU */
+#define WM8904_MCLK_PD                          0x0040  /* MCLK_PD */
+#define WM8904_MCLK_PD_MASK                     0x0040  /* MCLK_PD */
+#define WM8904_MCLK_PD_SHIFT                         6  /* MCLK_PD */
+#define WM8904_MCLK_PD_WIDTH                         1  /* MCLK_PD */
+#define WM8904_DACDAT_PU                        0x0020  /* DACDAT_PU */
+#define WM8904_DACDAT_PU_MASK                   0x0020  /* DACDAT_PU */
+#define WM8904_DACDAT_PU_SHIFT                       5  /* DACDAT_PU */
+#define WM8904_DACDAT_PU_WIDTH                       1  /* DACDAT_PU */
+#define WM8904_DACDAT_PD                        0x0010  /* DACDAT_PD */
+#define WM8904_DACDAT_PD_MASK                   0x0010  /* DACDAT_PD */
+#define WM8904_DACDAT_PD_SHIFT                       4  /* DACDAT_PD */
+#define WM8904_DACDAT_PD_WIDTH                       1  /* DACDAT_PD */
+#define WM8904_LRCLK_PU                         0x0008  /* LRCLK_PU */
+#define WM8904_LRCLK_PU_MASK                    0x0008  /* LRCLK_PU */
+#define WM8904_LRCLK_PU_SHIFT                        3  /* LRCLK_PU */
+#define WM8904_LRCLK_PU_WIDTH                        1  /* LRCLK_PU */
+#define WM8904_LRCLK_PD                         0x0004  /* LRCLK_PD */
+#define WM8904_LRCLK_PD_MASK                    0x0004  /* LRCLK_PD */
+#define WM8904_LRCLK_PD_SHIFT                        2  /* LRCLK_PD */
+#define WM8904_LRCLK_PD_WIDTH                        1  /* LRCLK_PD */
+#define WM8904_BCLK_PU                          0x0002  /* BCLK_PU */
+#define WM8904_BCLK_PU_MASK                     0x0002  /* BCLK_PU */
+#define WM8904_BCLK_PU_SHIFT                         1  /* BCLK_PU */
+#define WM8904_BCLK_PU_WIDTH                         1  /* BCLK_PU */
+#define WM8904_BCLK_PD                          0x0001  /* BCLK_PD */
+#define WM8904_BCLK_PD_MASK                     0x0001  /* BCLK_PD */
+#define WM8904_BCLK_PD_SHIFT                         0  /* BCLK_PD */
+#define WM8904_BCLK_PD_WIDTH                         1  /* BCLK_PD */
+
+/*
+ * R127 (0x7F) - Interrupt Status
+ */
+#define WM8904_IRQ                              0x0400  /* IRQ */
+#define WM8904_IRQ_MASK                         0x0400  /* IRQ */
+#define WM8904_IRQ_SHIFT                            10  /* IRQ */
+#define WM8904_IRQ_WIDTH                             1  /* IRQ */
+#define WM8904_GPIO_BCLK_EINT                   0x0200  /* GPIO_BCLK_EINT */
+#define WM8904_GPIO_BCLK_EINT_MASK              0x0200  /* GPIO_BCLK_EINT */
+#define WM8904_GPIO_BCLK_EINT_SHIFT                  9  /* GPIO_BCLK_EINT */
+#define WM8904_GPIO_BCLK_EINT_WIDTH                  1  /* GPIO_BCLK_EINT */
+#define WM8904_WSEQ_EINT                        0x0100  /* WSEQ_EINT */
+#define WM8904_WSEQ_EINT_MASK                   0x0100  /* WSEQ_EINT */
+#define WM8904_WSEQ_EINT_SHIFT                       8  /* WSEQ_EINT */
+#define WM8904_WSEQ_EINT_WIDTH                       1  /* WSEQ_EINT */
+#define WM8904_GPIO3_EINT                       0x0080  /* GPIO3_EINT */
+#define WM8904_GPIO3_EINT_MASK                  0x0080  /* GPIO3_EINT */
+#define WM8904_GPIO3_EINT_SHIFT                      7  /* GPIO3_EINT */
+#define WM8904_GPIO3_EINT_WIDTH                      1  /* GPIO3_EINT */
+#define WM8904_GPIO2_EINT                       0x0040  /* GPIO2_EINT */
+#define WM8904_GPIO2_EINT_MASK                  0x0040  /* GPIO2_EINT */
+#define WM8904_GPIO2_EINT_SHIFT                      6  /* GPIO2_EINT */
+#define WM8904_GPIO2_EINT_WIDTH                      1  /* GPIO2_EINT */
+#define WM8904_GPIO1_EINT                       0x0020  /* GPIO1_EINT */
+#define WM8904_GPIO1_EINT_MASK                  0x0020  /* GPIO1_EINT */
+#define WM8904_GPIO1_EINT_SHIFT                      5  /* GPIO1_EINT */
+#define WM8904_GPIO1_EINT_WIDTH                      1  /* GPIO1_EINT */
+#define WM8904_GPI8_EINT                        0x0010  /* GPI8_EINT */
+#define WM8904_GPI8_EINT_MASK                   0x0010  /* GPI8_EINT */
+#define WM8904_GPI8_EINT_SHIFT                       4  /* GPI8_EINT */
+#define WM8904_GPI8_EINT_WIDTH                       1  /* GPI8_EINT */
+#define WM8904_GPI7_EINT                        0x0008  /* GPI7_EINT */
+#define WM8904_GPI7_EINT_MASK                   0x0008  /* GPI7_EINT */
+#define WM8904_GPI7_EINT_SHIFT                       3  /* GPI7_EINT */
+#define WM8904_GPI7_EINT_WIDTH                       1  /* GPI7_EINT */
+#define WM8904_FLL_LOCK_EINT                    0x0004  /* FLL_LOCK_EINT */
+#define WM8904_FLL_LOCK_EINT_MASK               0x0004  /* FLL_LOCK_EINT */
+#define WM8904_FLL_LOCK_EINT_SHIFT                   2  /* FLL_LOCK_EINT */
+#define WM8904_FLL_LOCK_EINT_WIDTH                   1  /* FLL_LOCK_EINT */
+#define WM8904_MIC_SHRT_EINT                    0x0002  /* MIC_SHRT_EINT */
+#define WM8904_MIC_SHRT_EINT_MASK               0x0002  /* MIC_SHRT_EINT */
+#define WM8904_MIC_SHRT_EINT_SHIFT                   1  /* MIC_SHRT_EINT */
+#define WM8904_MIC_SHRT_EINT_WIDTH                   1  /* MIC_SHRT_EINT */
+#define WM8904_MIC_DET_EINT                     0x0001  /* MIC_DET_EINT */
+#define WM8904_MIC_DET_EINT_MASK                0x0001  /* MIC_DET_EINT */
+#define WM8904_MIC_DET_EINT_SHIFT                    0  /* MIC_DET_EINT */
+#define WM8904_MIC_DET_EINT_WIDTH                    1  /* MIC_DET_EINT */
+
+/*
+ * R128 (0x80) - Interrupt Status Mask
+ */
+#define WM8904_IM_GPIO_BCLK_EINT                0x0200  /* IM_GPIO_BCLK_EINT */
+#define WM8904_IM_GPIO_BCLK_EINT_MASK           0x0200  /* IM_GPIO_BCLK_EINT */
+#define WM8904_IM_GPIO_BCLK_EINT_SHIFT               9  /* IM_GPIO_BCLK_EINT */
+#define WM8904_IM_GPIO_BCLK_EINT_WIDTH               1  /* IM_GPIO_BCLK_EINT */
+#define WM8904_IM_WSEQ_EINT                     0x0100  /* IM_WSEQ_EINT */
+#define WM8904_IM_WSEQ_EINT_MASK                0x0100  /* IM_WSEQ_EINT */
+#define WM8904_IM_WSEQ_EINT_SHIFT                    8  /* IM_WSEQ_EINT */
+#define WM8904_IM_WSEQ_EINT_WIDTH                    1  /* IM_WSEQ_EINT */
+#define WM8904_IM_GPIO3_EINT                    0x0080  /* IM_GPIO3_EINT */
+#define WM8904_IM_GPIO3_EINT_MASK               0x0080  /* IM_GPIO3_EINT */
+#define WM8904_IM_GPIO3_EINT_SHIFT                   7  /* IM_GPIO3_EINT */
+#define WM8904_IM_GPIO3_EINT_WIDTH                   1  /* IM_GPIO3_EINT */
+#define WM8904_IM_GPIO2_EINT                    0x0040  /* IM_GPIO2_EINT */
+#define WM8904_IM_GPIO2_EINT_MASK               0x0040  /* IM_GPIO2_EINT */
+#define WM8904_IM_GPIO2_EINT_SHIFT                   6  /* IM_GPIO2_EINT */
+#define WM8904_IM_GPIO2_EINT_WIDTH                   1  /* IM_GPIO2_EINT */
+#define WM8904_IM_GPIO1_EINT                    0x0020  /* IM_GPIO1_EINT */
+#define WM8904_IM_GPIO1_EINT_MASK               0x0020  /* IM_GPIO1_EINT */
+#define WM8904_IM_GPIO1_EINT_SHIFT                   5  /* IM_GPIO1_EINT */
+#define WM8904_IM_GPIO1_EINT_WIDTH                   1  /* IM_GPIO1_EINT */
+#define WM8904_IM_GPI8_EINT                     0x0010  /* IM_GPI8_EINT */
+#define WM8904_IM_GPI8_EINT_MASK                0x0010  /* IM_GPI8_EINT */
+#define WM8904_IM_GPI8_EINT_SHIFT                    4  /* IM_GPI8_EINT */
+#define WM8904_IM_GPI8_EINT_WIDTH                    1  /* IM_GPI8_EINT */
+#define WM8904_IM_GPI7_EINT                     0x0008  /* IM_GPI7_EINT */
+#define WM8904_IM_GPI7_EINT_MASK                0x0008  /* IM_GPI7_EINT */
+#define WM8904_IM_GPI7_EINT_SHIFT                    3  /* IM_GPI7_EINT */
+#define WM8904_IM_GPI7_EINT_WIDTH                    1  /* IM_GPI7_EINT */
+#define WM8904_IM_FLL_LOCK_EINT                 0x0004  /* IM_FLL_LOCK_EINT */
+#define WM8904_IM_FLL_LOCK_EINT_MASK            0x0004  /* IM_FLL_LOCK_EINT */
+#define WM8904_IM_FLL_LOCK_EINT_SHIFT                2  /* IM_FLL_LOCK_EINT */
+#define WM8904_IM_FLL_LOCK_EINT_WIDTH                1  /* IM_FLL_LOCK_EINT */
+#define WM8904_IM_MIC_SHRT_EINT                 0x0002  /* IM_MIC_SHRT_EINT */
+#define WM8904_IM_MIC_SHRT_EINT_MASK            0x0002  /* IM_MIC_SHRT_EINT */
+#define WM8904_IM_MIC_SHRT_EINT_SHIFT                1  /* IM_MIC_SHRT_EINT */
+#define WM8904_IM_MIC_SHRT_EINT_WIDTH                1  /* IM_MIC_SHRT_EINT */
+#define WM8904_IM_MIC_DET_EINT                  0x0001  /* IM_MIC_DET_EINT */
+#define WM8904_IM_MIC_DET_EINT_MASK             0x0001  /* IM_MIC_DET_EINT */
+#define WM8904_IM_MIC_DET_EINT_SHIFT                 0  /* IM_MIC_DET_EINT */
+#define WM8904_IM_MIC_DET_EINT_WIDTH                 1  /* IM_MIC_DET_EINT */
+
+/*
+ * R129 (0x81) - Interrupt Polarity
+ */
+#define WM8904_GPIO_BCLK_EINT_POL               0x0200  /* GPIO_BCLK_EINT_POL */
+#define WM8904_GPIO_BCLK_EINT_POL_MASK          0x0200  /* GPIO_BCLK_EINT_POL */
+#define WM8904_GPIO_BCLK_EINT_POL_SHIFT              9  /* GPIO_BCLK_EINT_POL */
+#define WM8904_GPIO_BCLK_EINT_POL_WIDTH              1  /* GPIO_BCLK_EINT_POL */
+#define WM8904_WSEQ_EINT_POL                    0x0100  /* WSEQ_EINT_POL */
+#define WM8904_WSEQ_EINT_POL_MASK               0x0100  /* WSEQ_EINT_POL */
+#define WM8904_WSEQ_EINT_POL_SHIFT                   8  /* WSEQ_EINT_POL */
+#define WM8904_WSEQ_EINT_POL_WIDTH                   1  /* WSEQ_EINT_POL */
+#define WM8904_GPIO3_EINT_POL                   0x0080  /* GPIO3_EINT_POL */
+#define WM8904_GPIO3_EINT_POL_MASK              0x0080  /* GPIO3_EINT_POL */
+#define WM8904_GPIO3_EINT_POL_SHIFT                  7  /* GPIO3_EINT_POL */
+#define WM8904_GPIO3_EINT_POL_WIDTH                  1  /* GPIO3_EINT_POL */
+#define WM8904_GPIO2_EINT_POL                   0x0040  /* GPIO2_EINT_POL */
+#define WM8904_GPIO2_EINT_POL_MASK              0x0040  /* GPIO2_EINT_POL */
+#define WM8904_GPIO2_EINT_POL_SHIFT                  6  /* GPIO2_EINT_POL */
+#define WM8904_GPIO2_EINT_POL_WIDTH                  1  /* GPIO2_EINT_POL */
+#define WM8904_GPIO1_EINT_POL                   0x0020  /* GPIO1_EINT_POL */
+#define WM8904_GPIO1_EINT_POL_MASK              0x0020  /* GPIO1_EINT_POL */
+#define WM8904_GPIO1_EINT_POL_SHIFT                  5  /* GPIO1_EINT_POL */
+#define WM8904_GPIO1_EINT_POL_WIDTH                  1  /* GPIO1_EINT_POL */
+#define WM8904_GPI8_EINT_POL                    0x0010  /* GPI8_EINT_POL */
+#define WM8904_GPI8_EINT_POL_MASK               0x0010  /* GPI8_EINT_POL */
+#define WM8904_GPI8_EINT_POL_SHIFT                   4  /* GPI8_EINT_POL */
+#define WM8904_GPI8_EINT_POL_WIDTH                   1  /* GPI8_EINT_POL */
+#define WM8904_GPI7_EINT_POL                    0x0008  /* GPI7_EINT_POL */
+#define WM8904_GPI7_EINT_POL_MASK               0x0008  /* GPI7_EINT_POL */
+#define WM8904_GPI7_EINT_POL_SHIFT                   3  /* GPI7_EINT_POL */
+#define WM8904_GPI7_EINT_POL_WIDTH                   1  /* GPI7_EINT_POL */
+#define WM8904_FLL_LOCK_EINT_POL                0x0004  /* FLL_LOCK_EINT_POL */
+#define WM8904_FLL_LOCK_EINT_POL_MASK           0x0004  /* FLL_LOCK_EINT_POL */
+#define WM8904_FLL_LOCK_EINT_POL_SHIFT               2  /* FLL_LOCK_EINT_POL */
+#define WM8904_FLL_LOCK_EINT_POL_WIDTH               1  /* FLL_LOCK_EINT_POL */
+#define WM8904_MIC_SHRT_EINT_POL                0x0002  /* MIC_SHRT_EINT_POL */
+#define WM8904_MIC_SHRT_EINT_POL_MASK           0x0002  /* MIC_SHRT_EINT_POL */
+#define WM8904_MIC_SHRT_EINT_POL_SHIFT               1  /* MIC_SHRT_EINT_POL */
+#define WM8904_MIC_SHRT_EINT_POL_WIDTH               1  /* MIC_SHRT_EINT_POL */
+#define WM8904_MIC_DET_EINT_POL                 0x0001  /* MIC_DET_EINT_POL */
+#define WM8904_MIC_DET_EINT_POL_MASK            0x0001  /* MIC_DET_EINT_POL */
+#define WM8904_MIC_DET_EINT_POL_SHIFT                0  /* MIC_DET_EINT_POL */
+#define WM8904_MIC_DET_EINT_POL_WIDTH                1  /* MIC_DET_EINT_POL */
+
+/*
+ * R130 (0x82) - Interrupt Debounce
+ */
+#define WM8904_GPIO_BCLK_EINT_DB                0x0200  /* GPIO_BCLK_EINT_DB */
+#define WM8904_GPIO_BCLK_EINT_DB_MASK           0x0200  /* GPIO_BCLK_EINT_DB */
+#define WM8904_GPIO_BCLK_EINT_DB_SHIFT               9  /* GPIO_BCLK_EINT_DB */
+#define WM8904_GPIO_BCLK_EINT_DB_WIDTH               1  /* GPIO_BCLK_EINT_DB */
+#define WM8904_WSEQ_EINT_DB                     0x0100  /* WSEQ_EINT_DB */
+#define WM8904_WSEQ_EINT_DB_MASK                0x0100  /* WSEQ_EINT_DB */
+#define WM8904_WSEQ_EINT_DB_SHIFT                    8  /* WSEQ_EINT_DB */
+#define WM8904_WSEQ_EINT_DB_WIDTH                    1  /* WSEQ_EINT_DB */
+#define WM8904_GPIO3_EINT_DB                    0x0080  /* GPIO3_EINT_DB */
+#define WM8904_GPIO3_EINT_DB_MASK               0x0080  /* GPIO3_EINT_DB */
+#define WM8904_GPIO3_EINT_DB_SHIFT                   7  /* GPIO3_EINT_DB */
+#define WM8904_GPIO3_EINT_DB_WIDTH                   1  /* GPIO3_EINT_DB */
+#define WM8904_GPIO2_EINT_DB                    0x0040  /* GPIO2_EINT_DB */
+#define WM8904_GPIO2_EINT_DB_MASK               0x0040  /* GPIO2_EINT_DB */
+#define WM8904_GPIO2_EINT_DB_SHIFT                   6  /* GPIO2_EINT_DB */
+#define WM8904_GPIO2_EINT_DB_WIDTH                   1  /* GPIO2_EINT_DB */
+#define WM8904_GPIO1_EINT_DB                    0x0020  /* GPIO1_EINT_DB */
+#define WM8904_GPIO1_EINT_DB_MASK               0x0020  /* GPIO1_EINT_DB */
+#define WM8904_GPIO1_EINT_DB_SHIFT                   5  /* GPIO1_EINT_DB */
+#define WM8904_GPIO1_EINT_DB_WIDTH                   1  /* GPIO1_EINT_DB */
+#define WM8904_GPI8_EINT_DB                     0x0010  /* GPI8_EINT_DB */
+#define WM8904_GPI8_EINT_DB_MASK                0x0010  /* GPI8_EINT_DB */
+#define WM8904_GPI8_EINT_DB_SHIFT                    4  /* GPI8_EINT_DB */
+#define WM8904_GPI8_EINT_DB_WIDTH                    1  /* GPI8_EINT_DB */
+#define WM8904_GPI7_EINT_DB                     0x0008  /* GPI7_EINT_DB */
+#define WM8904_GPI7_EINT_DB_MASK                0x0008  /* GPI7_EINT_DB */
+#define WM8904_GPI7_EINT_DB_SHIFT                    3  /* GPI7_EINT_DB */
+#define WM8904_GPI7_EINT_DB_WIDTH                    1  /* GPI7_EINT_DB */
+#define WM8904_FLL_LOCK_EINT_DB                 0x0004  /* FLL_LOCK_EINT_DB */
+#define WM8904_FLL_LOCK_EINT_DB_MASK            0x0004  /* FLL_LOCK_EINT_DB */
+#define WM8904_FLL_LOCK_EINT_DB_SHIFT                2  /* FLL_LOCK_EINT_DB */
+#define WM8904_FLL_LOCK_EINT_DB_WIDTH                1  /* FLL_LOCK_EINT_DB */
+#define WM8904_MIC_SHRT_EINT_DB                 0x0002  /* MIC_SHRT_EINT_DB */
+#define WM8904_MIC_SHRT_EINT_DB_MASK            0x0002  /* MIC_SHRT_EINT_DB */
+#define WM8904_MIC_SHRT_EINT_DB_SHIFT                1  /* MIC_SHRT_EINT_DB */
+#define WM8904_MIC_SHRT_EINT_DB_WIDTH                1  /* MIC_SHRT_EINT_DB */
+#define WM8904_MIC_DET_EINT_DB                  0x0001  /* MIC_DET_EINT_DB */
+#define WM8904_MIC_DET_EINT_DB_MASK             0x0001  /* MIC_DET_EINT_DB */
+#define WM8904_MIC_DET_EINT_DB_SHIFT                 0  /* MIC_DET_EINT_DB */
+#define WM8904_MIC_DET_EINT_DB_WIDTH                 1  /* MIC_DET_EINT_DB */
+
+/*
+ * R134 (0x86) - EQ1
+ */
+#define WM8904_EQ_ENA                           0x0001  /* EQ_ENA */
+#define WM8904_EQ_ENA_MASK                      0x0001  /* EQ_ENA */
+#define WM8904_EQ_ENA_SHIFT                          0  /* EQ_ENA */
+#define WM8904_EQ_ENA_WIDTH                          1  /* EQ_ENA */
+
+/*
+ * R135 (0x87) - EQ2
+ */
+#define WM8904_EQ_B1_GAIN_MASK                  0x001F  /* EQ_B1_GAIN - [4:0] */
+#define WM8904_EQ_B1_GAIN_SHIFT                      0  /* EQ_B1_GAIN - [4:0] */
+#define WM8904_EQ_B1_GAIN_WIDTH                      5  /* EQ_B1_GAIN - [4:0] */
+
+/*
+ * R136 (0x88) - EQ3
+ */
+#define WM8904_EQ_B2_GAIN_MASK                  0x001F  /* EQ_B2_GAIN - [4:0] */
+#define WM8904_EQ_B2_GAIN_SHIFT                      0  /* EQ_B2_GAIN - [4:0] */
+#define WM8904_EQ_B2_GAIN_WIDTH                      5  /* EQ_B2_GAIN - [4:0] */
+
+/*
+ * R137 (0x89) - EQ4
+ */
+#define WM8904_EQ_B3_GAIN_MASK                  0x001F  /* EQ_B3_GAIN - [4:0] */
+#define WM8904_EQ_B3_GAIN_SHIFT                      0  /* EQ_B3_GAIN - [4:0] */
+#define WM8904_EQ_B3_GAIN_WIDTH                      5  /* EQ_B3_GAIN - [4:0] */
+
+/*
+ * R138 (0x8A) - EQ5
+ */
+#define WM8904_EQ_B4_GAIN_MASK                  0x001F  /* EQ_B4_GAIN - [4:0] */
+#define WM8904_EQ_B4_GAIN_SHIFT                      0  /* EQ_B4_GAIN - [4:0] */
+#define WM8904_EQ_B4_GAIN_WIDTH                      5  /* EQ_B4_GAIN - [4:0] */
+
+/*
+ * R139 (0x8B) - EQ6
+ */
+#define WM8904_EQ_B5_GAIN_MASK                  0x001F  /* EQ_B5_GAIN - [4:0] */
+#define WM8904_EQ_B5_GAIN_SHIFT                      0  /* EQ_B5_GAIN - [4:0] */
+#define WM8904_EQ_B5_GAIN_WIDTH                      5  /* EQ_B5_GAIN - [4:0] */
+
+/*
+ * R140 (0x8C) - EQ7
+ */
+#define WM8904_EQ_B1_A_MASK                     0xFFFF  /* EQ_B1_A - [15:0] */
+#define WM8904_EQ_B1_A_SHIFT                         0  /* EQ_B1_A - [15:0] */
+#define WM8904_EQ_B1_A_WIDTH                        16  /* EQ_B1_A - [15:0] */
+
+/*
+ * R141 (0x8D) - EQ8
+ */
+#define WM8904_EQ_B1_B_MASK                     0xFFFF  /* EQ_B1_B - [15:0] */
+#define WM8904_EQ_B1_B_SHIFT                         0  /* EQ_B1_B - [15:0] */
+#define WM8904_EQ_B1_B_WIDTH                        16  /* EQ_B1_B - [15:0] */
+
+/*
+ * R142 (0x8E) - EQ9
+ */
+#define WM8904_EQ_B1_PG_MASK                    0xFFFF  /* EQ_B1_PG - [15:0] */
+#define WM8904_EQ_B1_PG_SHIFT                        0  /* EQ_B1_PG - [15:0] */
+#define WM8904_EQ_B1_PG_WIDTH                       16  /* EQ_B1_PG - [15:0] */
+
+/*
+ * R143 (0x8F) - EQ10
+ */
+#define WM8904_EQ_B2_A_MASK                     0xFFFF  /* EQ_B2_A - [15:0] */
+#define WM8904_EQ_B2_A_SHIFT                         0  /* EQ_B2_A - [15:0] */
+#define WM8904_EQ_B2_A_WIDTH                        16  /* EQ_B2_A - [15:0] */
+
+/*
+ * R144 (0x90) - EQ11
+ */
+#define WM8904_EQ_B2_B_MASK                     0xFFFF  /* EQ_B2_B - [15:0] */
+#define WM8904_EQ_B2_B_SHIFT                         0  /* EQ_B2_B - [15:0] */
+#define WM8904_EQ_B2_B_WIDTH                        16  /* EQ_B2_B - [15:0] */
+
+/*
+ * R145 (0x91) - EQ12
+ */
+#define WM8904_EQ_B2_C_MASK                     0xFFFF  /* EQ_B2_C - [15:0] */
+#define WM8904_EQ_B2_C_SHIFT                         0  /* EQ_B2_C - [15:0] */
+#define WM8904_EQ_B2_C_WIDTH                        16  /* EQ_B2_C - [15:0] */
+
+/*
+ * R146 (0x92) - EQ13
+ */
+#define WM8904_EQ_B2_PG_MASK                    0xFFFF  /* EQ_B2_PG - [15:0] */
+#define WM8904_EQ_B2_PG_SHIFT                        0  /* EQ_B2_PG - [15:0] */
+#define WM8904_EQ_B2_PG_WIDTH                       16  /* EQ_B2_PG - [15:0] */
+
+/*
+ * R147 (0x93) - EQ14
+ */
+#define WM8904_EQ_B3_A_MASK                     0xFFFF  /* EQ_B3_A - [15:0] */
+#define WM8904_EQ_B3_A_SHIFT                         0  /* EQ_B3_A - [15:0] */
+#define WM8904_EQ_B3_A_WIDTH                        16  /* EQ_B3_A - [15:0] */
+
+/*
+ * R148 (0x94) - EQ15
+ */
+#define WM8904_EQ_B3_B_MASK                     0xFFFF  /* EQ_B3_B - [15:0] */
+#define WM8904_EQ_B3_B_SHIFT                         0  /* EQ_B3_B - [15:0] */
+#define WM8904_EQ_B3_B_WIDTH                        16  /* EQ_B3_B - [15:0] */
+
+/*
+ * R149 (0x95) - EQ16
+ */
+#define WM8904_EQ_B3_C_MASK                     0xFFFF  /* EQ_B3_C - [15:0] */
+#define WM8904_EQ_B3_C_SHIFT                         0  /* EQ_B3_C - [15:0] */
+#define WM8904_EQ_B3_C_WIDTH                        16  /* EQ_B3_C - [15:0] */
+
+/*
+ * R150 (0x96) - EQ17
+ */
+#define WM8904_EQ_B3_PG_MASK                    0xFFFF  /* EQ_B3_PG - [15:0] */
+#define WM8904_EQ_B3_PG_SHIFT                        0  /* EQ_B3_PG - [15:0] */
+#define WM8904_EQ_B3_PG_WIDTH                       16  /* EQ_B3_PG - [15:0] */
+
+/*
+ * R151 (0x97) - EQ18
+ */
+#define WM8904_EQ_B4_A_MASK                     0xFFFF  /* EQ_B4_A - [15:0] */
+#define WM8904_EQ_B4_A_SHIFT                         0  /* EQ_B4_A - [15:0] */
+#define WM8904_EQ_B4_A_WIDTH                        16  /* EQ_B4_A - [15:0] */
+
+/*
+ * R152 (0x98) - EQ19
+ */
+#define WM8904_EQ_B4_B_MASK                     0xFFFF  /* EQ_B4_B - [15:0] */
+#define WM8904_EQ_B4_B_SHIFT                         0  /* EQ_B4_B - [15:0] */
+#define WM8904_EQ_B4_B_WIDTH                        16  /* EQ_B4_B - [15:0] */
+
+/*
+ * R153 (0x99) - EQ20
+ */
+#define WM8904_EQ_B4_C_MASK                     0xFFFF  /* EQ_B4_C - [15:0] */
+#define WM8904_EQ_B4_C_SHIFT                         0  /* EQ_B4_C - [15:0] */
+#define WM8904_EQ_B4_C_WIDTH                        16  /* EQ_B4_C - [15:0] */
+
+/*
+ * R154 (0x9A) - EQ21
+ */
+#define WM8904_EQ_B4_PG_MASK                    0xFFFF  /* EQ_B4_PG - [15:0] */
+#define WM8904_EQ_B4_PG_SHIFT                        0  /* EQ_B4_PG - [15:0] */
+#define WM8904_EQ_B4_PG_WIDTH                       16  /* EQ_B4_PG - [15:0] */
+
+/*
+ * R155 (0x9B) - EQ22
+ */
+#define WM8904_EQ_B5_A_MASK                     0xFFFF  /* EQ_B5_A - [15:0] */
+#define WM8904_EQ_B5_A_SHIFT                         0  /* EQ_B5_A - [15:0] */
+#define WM8904_EQ_B5_A_WIDTH                        16  /* EQ_B5_A - [15:0] */
+
+/*
+ * R156 (0x9C) - EQ23
+ */
+#define WM8904_EQ_B5_B_MASK                     0xFFFF  /* EQ_B5_B - [15:0] */
+#define WM8904_EQ_B5_B_SHIFT                         0  /* EQ_B5_B - [15:0] */
+#define WM8904_EQ_B5_B_WIDTH                        16  /* EQ_B5_B - [15:0] */
+
+/*
+ * R157 (0x9D) - EQ24
+ */
+#define WM8904_EQ_B5_PG_MASK                    0xFFFF  /* EQ_B5_PG - [15:0] */
+#define WM8904_EQ_B5_PG_SHIFT                        0  /* EQ_B5_PG - [15:0] */
+#define WM8904_EQ_B5_PG_WIDTH                       16  /* EQ_B5_PG - [15:0] */
+
+/*
+ * R161 (0xA1) - Control Interface Test 1
+ */
+#define WM8904_USER_KEY                         0x0002  /* USER_KEY */
+#define WM8904_USER_KEY_MASK                    0x0002  /* USER_KEY */
+#define WM8904_USER_KEY_SHIFT                        1  /* USER_KEY */
+#define WM8904_USER_KEY_WIDTH                        1  /* USER_KEY */
+
+/*
+ * R204 (0xCC) - Analogue Output Bias 0
+ */
+#define WM8904_PGA_BIAS_MASK                    0x0070  /* PGA_BIAS - [6:4] */
+#define WM8904_PGA_BIAS_SHIFT                        4  /* PGA_BIAS - [6:4] */
+#define WM8904_PGA_BIAS_WIDTH                        3  /* PGA_BIAS - [6:4] */
+
+/*
+ * R247 (0xF7) - FLL NCO Test 0
+ */
+#define WM8904_FLL_FRC_NCO                      0x0001  /* FLL_FRC_NCO */
+#define WM8904_FLL_FRC_NCO_MASK                 0x0001  /* FLL_FRC_NCO */
+#define WM8904_FLL_FRC_NCO_SHIFT                     0  /* FLL_FRC_NCO */
+#define WM8904_FLL_FRC_NCO_WIDTH                     1  /* FLL_FRC_NCO */
+
+/*
+ * R248 (0xF8) - FLL NCO Test 1
+ */
+#define WM8904_FLL_FRC_NCO_VAL_MASK             0x003F  /* FLL_FRC_NCO_VAL - [5:0] */
+#define WM8904_FLL_FRC_NCO_VAL_SHIFT                 0  /* FLL_FRC_NCO_VAL - [5:0] */
+#define WM8904_FLL_FRC_NCO_VAL_WIDTH                 6  /* FLL_FRC_NCO_VAL - [5:0] */
+
+#endif
diff --git a/sound/soc/codecs/wm8940.c b/sound/soc/codecs/wm8940.c
index 1ef2454c5205..0c04b476487f 100644
--- a/sound/soc/codecs/wm8940.c
+++ b/sound/soc/codecs/wm8940.c
@@ -30,6 +30,7 @@
 #include <linux/i2c.h>
 #include <linux/platform_device.h>
 #include <linux/spi/spi.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
@@ -298,7 +299,6 @@ static int wm8940_add_widgets(struct snd_soc_codec *codec)
         ret = snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
         if (ret)
                 goto error_ret;
-        ret = snd_soc_dapm_new_widgets(codec);
 
 error_ret:
         return ret;
@@ -379,23 +379,23 @@ static int wm8940_i2s_hw_params(struct snd_pcm_substream *substream,
                 iface |= (1 << 9);
 
         switch (params_rate(params)) {
-        case SNDRV_PCM_RATE_8000:
+        case 8000:
                 addcntrl |= (0x5 << 1);
                 break;
-        case SNDRV_PCM_RATE_11025:
+        case 11025:
                 addcntrl |= (0x4 << 1);
                 break;
-        case SNDRV_PCM_RATE_16000:
+        case 16000:
                 addcntrl |= (0x3 << 1);
                 break;
-        case SNDRV_PCM_RATE_22050:
+        case 22050:
                 addcntrl |= (0x2 << 1);
                 break;
-        case SNDRV_PCM_RATE_32000:
+        case 32000:
                 addcntrl |= (0x1 << 1);
                 break;
-        case SNDRV_PCM_RATE_44100:
-        case SNDRV_PCM_RATE_48000:
+        case 44100:
+        case 48000:
                 break;
         }
         ret = snd_soc_write(codec, WM8940_ADDCNTRL, addcntrl);
@@ -536,8 +536,8 @@ static void pll_factors(unsigned int target, unsigned int source)
 }
 
 /* Untested at the moment */
-static int wm8940_set_dai_pll(struct snd_soc_dai *codec_dai,
-                int pll_id, unsigned int freq_in, unsigned int freq_out)
+static int wm8940_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id,
+                int source, unsigned int freq_in, unsigned int freq_out)
 {
         struct snd_soc_codec *codec = codec_dai->codec;
         u16 reg;
@@ -731,12 +731,6 @@ static int wm8940_probe(struct platform_device *pdev)
         if (ret)
                 goto error_free_pcms;
 
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                dev_err(codec->dev, "failed to register card: %d\n", ret);
-                goto error_free_pcms;
-        }
-
         return ret;
 
 error_free_pcms:
@@ -877,21 +871,6 @@ static int __devexit wm8940_i2c_remove(struct i2c_client *client)
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int wm8940_i2c_suspend(struct i2c_client *client, pm_message_t msg)
-{
-        return snd_soc_suspend_device(&client->dev);
-}
-
-static int wm8940_i2c_resume(struct i2c_client *client)
-{
-        return snd_soc_resume_device(&client->dev);
-}
-#else
-#define wm8940_i2c_suspend NULL
-#define wm8940_i2c_resume NULL
-#endif
-
 static const struct i2c_device_id wm8940_i2c_id[] = {
         { "wm8940", 0 },
         { }
@@ -905,8 +884,6 @@ static struct i2c_driver wm8940_i2c_driver = {
         },
         .probe = wm8940_i2c_probe,
         .remove = __devexit_p(wm8940_i2c_remove),
-        .suspend = wm8940_i2c_suspend,
-        .resume = wm8940_i2c_resume,
         .id_table = wm8940_i2c_id,
 };
 
diff --git a/sound/soc/codecs/wm8955.c b/sound/soc/codecs/wm8955.c
new file mode 100644
index 000000000000..c8d7a809af4d
--- /dev/null
+++ b/sound/soc/codecs/wm8955.c
@@ -0,0 +1,1152 @@
+/*
+ * wm8955.c  --  WM8955 ALSA SoC Audio driver
+ *
+ * Copyright 2009 Wolfson Microelectronics plc
+ *
+ * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/pm.h>
+#include <linux/i2c.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/consumer.h>
+#include <linux/slab.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+#include <sound/initval.h>
+#include <sound/tlv.h>
+#include <sound/wm8955.h>
+
+#include "wm8955.h"
+
+static struct snd_soc_codec *wm8955_codec;
+struct snd_soc_codec_device soc_codec_dev_wm8955;
+
+#define WM8955_NUM_SUPPLIES 4
+static const char *wm8955_supply_names[WM8955_NUM_SUPPLIES] = {
+        "DCVDD",
+        "DBVDD",
+        "HPVDD",
+        "AVDD",
+};
+
+/* codec private data */
+struct wm8955_priv {
+        struct snd_soc_codec codec;
+        u16 reg_cache[WM8955_MAX_REGISTER + 1];
+
+        unsigned int mclk_rate;
+
+        int deemph;
+        int fs;
+
+        struct regulator_bulk_data supplies[WM8955_NUM_SUPPLIES];
+
+        struct wm8955_pdata *pdata;
+};
+
+static const u16 wm8955_reg[WM8955_MAX_REGISTER + 1] = {
+        0x0000,     /* R0 */
+        0x0000,     /* R1 */
+        0x0079,     /* R2  - LOUT1 volume */
+        0x0079,     /* R3  - ROUT1 volume */
+        0x0000,     /* R4 */
+        0x0008,     /* R5  - DAC Control */
+        0x0000,     /* R6 */
+        0x000A,     /* R7  - Audio Interface */
+        0x0000,     /* R8  - Sample Rate */
+        0x0000,     /* R9 */
+        0x00FF,     /* R10 - Left DAC volume */
+        0x00FF,     /* R11 - Right DAC volume */
+        0x000F,     /* R12 - Bass control */
+        0x000F,     /* R13 - Treble control */
+        0x0000,     /* R14 */
+        0x0000,     /* R15 - Reset */
+        0x0000,     /* R16 */
+        0x0000,     /* R17 */
+        0x0000,     /* R18 */
+        0x0000,     /* R19 */
+        0x0000,     /* R20 */
+        0x0000,     /* R21 */
+        0x0000,     /* R22 */
+        0x00C1,     /* R23 - Additional control (1) */
+        0x0000,     /* R24 - Additional control (2) */
+        0x0000,     /* R25 - Power Management (1) */
+        0x0000,     /* R26 - Power Management (2) */
+        0x0000,     /* R27 - Additional Control (3) */
+        0x0000,     /* R28 */
+        0x0000,     /* R29 */
+        0x0000,     /* R30 */
+        0x0000,     /* R31 */
+        0x0000,     /* R32 */
+        0x0000,     /* R33 */
+        0x0050,     /* R34 - Left out Mix (1) */
+        0x0050,     /* R35 - Left out Mix (2) */
+        0x0050,     /* R36 - Right out Mix (1) */
+        0x0050,     /* R37 - Right Out Mix (2) */
+        0x0050,     /* R38 - Mono out Mix (1) */
+        0x0050,     /* R39 - Mono out Mix (2) */
+        0x0079,     /* R40 - LOUT2 volume */
+        0x0079,     /* R41 - ROUT2 volume */
+        0x0079,     /* R42 - MONOOUT volume */
+        0x0000,     /* R43 - Clocking / PLL */
+        0x0103,     /* R44 - PLL Control 1 */
+        0x0024,     /* R45 - PLL Control 2 */
+        0x01BA,     /* R46 - PLL Control 3 */
+        0x0000,     /* R47 */
+        0x0000,     /* R48 */
+        0x0000,     /* R49 */
+        0x0000,     /* R50 */
+        0x0000,     /* R51 */
+        0x0000,     /* R52 */
+        0x0000,     /* R53 */
+        0x0000,     /* R54 */
+        0x0000,     /* R55 */
+        0x0000,     /* R56 */
+        0x0000,     /* R57 */
+        0x0000,     /* R58 */
+        0x0000,     /* R59 - PLL Control 4 */
+};
+
+static int wm8955_reset(struct snd_soc_codec *codec)
+{
+        return snd_soc_write(codec, WM8955_RESET, 0);
+}
+
+struct pll_factors {
+        int n;
+        int k;
+        int outdiv;
+};
+
+/* The size in bits of the FLL divide multiplied by 10
+ * to allow rounding later */
+#define FIXED_FLL_SIZE ((1 << 22) * 10)
+
+static int wm8995_pll_factors(struct device *dev,
+                              int Fref, int Fout, struct pll_factors *pll)
+{
+        u64 Kpart;
+        unsigned int K, Ndiv, Nmod, target;
+
+        dev_dbg(dev, "Fref=%u Fout=%u\n", Fref, Fout);
+
+        /* The oscilator should run at should be 90-100MHz, and
+         * there's a divide by 4 plus an optional divide by 2 in the
+         * output path to generate the system clock.  The clock table
+         * is sortd so we should always generate a suitable target. */
+        target = Fout * 4;
+        if (target < 90000000) {
+                pll->outdiv = 1;
+                target *= 2;
+        } else {
+                pll->outdiv = 0;
+        }
+
+        WARN_ON(target < 90000000 || target > 100000000);
+
+        dev_dbg(dev, "Fvco=%dHz\n", target);
+
+        /* Now, calculate N.K */
+        Ndiv = target / Fref;
+
+        pll->n = Ndiv;
+        Nmod = target % Fref;
+        dev_dbg(dev, "Nmod=%d\n", Nmod);
+
+        /* Calculate fractional part - scale up so we can round. */
+        Kpart = FIXED_FLL_SIZE * (long long)Nmod;
+
+        do_div(Kpart, Fref);
+
+        K = Kpart & 0xFFFFFFFF;
+
+        if ((K % 10) >= 5)
+                K += 5;
+
+        /* Move down to proper range now rounding is done */
+        pll->k = K / 10;
+
+        dev_dbg(dev, "N=%x K=%x OUTDIV=%x\n", pll->n, pll->k, pll->outdiv);
+
+        return 0;
+}
+
+/* Lookup table specifiying SRATE (table 25 in datasheet); some of the
+ * output frequencies have been rounded to the standard frequencies
+ * they are intended to match where the error is slight. */
+static struct {
+        int mclk;
+        int fs;
+        int usb;
+        int sr;
+} clock_cfgs[] = {
+        { 18432000,  8000, 0,  3, },
+        { 18432000, 12000, 0,  9, },
+        { 18432000, 16000, 0, 11, },
+        { 18432000, 24000, 0, 29, },
+        { 18432000, 32000, 0, 13, },
+        { 18432000, 48000, 0,  1, },
+        { 18432000, 96000, 0, 15, },
+
+        { 16934400,  8018, 0, 19, },
+        { 16934400, 11025, 0, 25, },
+        { 16934400, 22050, 0, 27, },
+        { 16934400, 44100, 0, 17, },
+        { 16934400, 88200, 0, 31, },
+
+        { 12000000,  8000, 1,  2, },
+        { 12000000, 11025, 1, 25, },
+        { 12000000, 12000, 1,  8, },
+        { 12000000, 16000, 1, 10, },
+        { 12000000, 22050, 1, 27, },
+        { 12000000, 24000, 1, 28, },
+        { 12000000, 32000, 1, 12, },
+        { 12000000, 44100, 1, 17, },
+        { 12000000, 48000, 1,  0, },
+        { 12000000, 88200, 1, 31, },
+        { 12000000, 96000, 1, 14, },
+
+        { 12288000,  8000, 0,  2, },
+        { 12288000, 12000, 0,  8, },
+        { 12288000, 16000, 0, 10, },
+        { 12288000, 24000, 0, 28, },
+        { 12288000, 32000, 0, 12, },
+        { 12288000, 48000, 0,  0, },
+        { 12288000, 96000, 0, 14, },
+
+        { 12289600,  8018, 0, 18, },
+        { 12289600, 11025, 0, 24, },
+        { 12289600, 22050, 0, 26, },
+        { 11289600, 44100, 0, 16, },
+        { 11289600, 88200, 0, 31, },
+};
+
+static int wm8955_configure_clocking(struct snd_soc_codec *codec)
+{
+        struct wm8955_priv *wm8955 = codec->private_data;
+        int i, ret, val;
+        int clocking = 0;
+        int srate = 0;
+        int sr = -1;
+        struct pll_factors pll;
+
+        /* If we're not running a sample rate currently just pick one */
+        if (wm8955->fs == 0)
+                wm8955->fs = 8000;
+
+        /* Can we generate an exact output? */
+        for (i = 0; i < ARRAY_SIZE(clock_cfgs); i++) {
+                if (wm8955->fs != clock_cfgs[i].fs)
+                        continue;
+                sr = i;
+
+                if (wm8955->mclk_rate == clock_cfgs[i].mclk)
+                        break;
+        }
+
+        /* We should never get here with an unsupported sample rate */
+        if (sr == -1) {
+                dev_err(codec->dev, "Sample rate %dHz unsupported\n",
+                        wm8955->fs);
+                WARN_ON(sr == -1);
+                return -EINVAL;
+        }
+
+        if (i == ARRAY_SIZE(clock_cfgs)) {
+                /* If we can't generate the right clock from MCLK then
+                 * we should configure the PLL to supply us with an
+                 * appropriate clock.
+                 */
+                clocking |= WM8955_MCLKSEL;
+
+                /* Use the last divider configuration we saw for the
+                 * sample rate. */
+                ret = wm8995_pll_factors(codec->dev, wm8955->mclk_rate,
+                                         clock_cfgs[sr].mclk, &pll);
+                if (ret != 0) {
+                        dev_err(codec->dev,
+                                "Unable to generate %dHz from %dHz MCLK\n",
+                                wm8955->fs, wm8955->mclk_rate);
+                        return -EINVAL;
+                }
+
+                snd_soc_update_bits(codec, WM8955_PLL_CONTROL_1,
+                                    WM8955_N_MASK | WM8955_K_21_18_MASK,
+                                    (pll.n << WM8955_N_SHIFT) |
+                                    pll.k >> 18);
+                snd_soc_update_bits(codec, WM8955_PLL_CONTROL_2,
+                                    WM8955_K_17_9_MASK,
+                                    (pll.k >> 9) & WM8955_K_17_9_MASK);
+                snd_soc_update_bits(codec, WM8955_PLL_CONTROL_2,
+                                    WM8955_K_8_0_MASK,
+                                    pll.k & WM8955_K_8_0_MASK);
+                if (pll.k)
+                        snd_soc_update_bits(codec, WM8955_PLL_CONTROL_4,
+                                            WM8955_KEN, WM8955_KEN);
+                else
+                        snd_soc_update_bits(codec, WM8955_PLL_CONTROL_4,
+                                            WM8955_KEN, 0);
+
+                if (pll.outdiv)
+                        val = WM8955_PLL_RB | WM8955_PLLOUTDIV2;
+                else
+                        val = WM8955_PLL_RB;
+
+                /* Now start the PLL running */
+                snd_soc_update_bits(codec, WM8955_CLOCKING_PLL,
+                                    WM8955_PLL_RB | WM8955_PLLOUTDIV2, val);
+                snd_soc_update_bits(codec, WM8955_CLOCKING_PLL,
+                                    WM8955_PLLEN, WM8955_PLLEN);
+        }
+
+        srate = clock_cfgs[sr].usb | (clock_cfgs[sr].sr << WM8955_SR_SHIFT);
+
+        snd_soc_update_bits(codec, WM8955_SAMPLE_RATE,
+                            WM8955_USB | WM8955_SR_MASK, srate);
+        snd_soc_update_bits(codec, WM8955_CLOCKING_PLL,
+                            WM8955_MCLKSEL, clocking);
+
+        return 0;
+}
+
+static int wm8955_sysclk(struct snd_soc_dapm_widget *w,
+                         struct snd_kcontrol *kcontrol, int event)
+{
+        struct snd_soc_codec *codec = w->codec;
+        int ret = 0;
+
+        /* Always disable the clocks - if we're doing reconfiguration this
+         * avoids misclocking.
+         */
+        snd_soc_update_bits(codec, WM8955_POWER_MANAGEMENT_1,
+                            WM8955_DIGENB, 0);
+        snd_soc_update_bits(codec, WM8955_CLOCKING_PLL,
+                            WM8955_PLL_RB | WM8955_PLLEN, 0);
+
+        switch (event) {
+        case SND_SOC_DAPM_POST_PMD:
+                break;
+        case SND_SOC_DAPM_PRE_PMU:
+                ret = wm8955_configure_clocking(codec);
+                break;
+        default:
+                ret = -EINVAL;
+                break;
+        }
+
+        return ret;
+}
+
+static int deemph_settings[] = { 0, 32000, 44100, 48000 };
+
+static int wm8955_set_deemph(struct snd_soc_codec *codec)
+{
+        struct wm8955_priv *wm8955 = codec->private_data;
+        int val, i, best;
+
+        /* If we're using deemphasis select the nearest available sample
+         * rate.
+         */
+        if (wm8955->deemph) {
+                best = 1;
+                for (i = 2; i < ARRAY_SIZE(deemph_settings); i++) {
+                        if (abs(deemph_settings[i] - wm8955->fs) <
+                            abs(deemph_settings[best] - wm8955->fs))
+                                best = i;
+                }
+
+                val = best << WM8955_DEEMPH_SHIFT;
+        } else {
+                val = 0;
+        }
+
+        dev_dbg(codec->dev, "Set deemphasis %d\n", val);
+
+        return snd_soc_update_bits(codec, WM8955_DAC_CONTROL,
+                                   WM8955_DEEMPH_MASK, val);
+}
+
+static int wm8955_get_deemph(struct snd_kcontrol *kcontrol,
+                             struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct wm8955_priv *wm8955 = codec->private_data;
+
+        return wm8955->deemph;
+}
+
+static int wm8955_put_deemph(struct snd_kcontrol *kcontrol,
+                             struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct wm8955_priv *wm8955 = codec->private_data;
+        int deemph = ucontrol->value.enumerated.item[0];
+
+        if (deemph > 1)
+                return -EINVAL;
+
+        wm8955->deemph = deemph;
+
+        return wm8955_set_deemph(codec);
+}
+
+static const char *bass_mode_text[] = {
+        "Linear", "Adaptive",
+};
+
+static const struct soc_enum bass_mode =
+        SOC_ENUM_SINGLE(WM8955_BASS_CONTROL, 7, 2, bass_mode_text);
+
+static const char *bass_cutoff_text[] = {
+        "Low", "High"
+};
+
+static const struct soc_enum bass_cutoff =
+        SOC_ENUM_SINGLE(WM8955_BASS_CONTROL, 6, 2, bass_cutoff_text);
+
+static const char *treble_cutoff_text[] = {
+        "High", "Low"
+};
+
+static const struct soc_enum treble_cutoff =
+        SOC_ENUM_SINGLE(WM8955_TREBLE_CONTROL, 6, 2, treble_cutoff_text);
+
+static const DECLARE_TLV_DB_SCALE(digital_tlv, -12750, 50, 1);
+static const DECLARE_TLV_DB_SCALE(atten_tlv, -600, 600, 0);
+static const DECLARE_TLV_DB_SCALE(bypass_tlv, -1500, 300, 0);
+static const DECLARE_TLV_DB_SCALE(mono_tlv, -2100, 300, 0);
+static const DECLARE_TLV_DB_SCALE(out_tlv, -12100, 100, 1);
+static const DECLARE_TLV_DB_SCALE(treble_tlv, -1200, 150, 1);
+
+static const struct snd_kcontrol_new wm8955_snd_controls[] = {
+SOC_DOUBLE_R_TLV("Digital Playback Volume", WM8955_LEFT_DAC_VOLUME,
+                 WM8955_RIGHT_DAC_VOLUME, 0, 255, 0, digital_tlv),
+SOC_SINGLE_TLV("Playback Attenuation Volume", WM8955_DAC_CONTROL, 7, 1, 1,
+               atten_tlv),
+SOC_SINGLE_BOOL_EXT("DAC Deemphasis Switch", 0,
+                    wm8955_get_deemph, wm8955_put_deemph),
+
+SOC_ENUM("Bass Mode", bass_mode),
+SOC_ENUM("Bass Cutoff", bass_cutoff),
+SOC_SINGLE("Bass Volume", WM8955_BASS_CONTROL, 0, 15, 1),
+
+SOC_ENUM("Treble Cutoff", treble_cutoff),
+SOC_SINGLE_TLV("Treble Volume", WM8955_TREBLE_CONTROL, 0, 14, 1, treble_tlv),
+
+SOC_SINGLE_TLV("Left Bypass Volume", WM8955_LEFT_OUT_MIX_1, 4, 7, 1,
+               bypass_tlv),
+SOC_SINGLE_TLV("Left Mono Volume", WM8955_LEFT_OUT_MIX_2, 4, 7, 1,
+               bypass_tlv),
+
+SOC_SINGLE_TLV("Right Mono Volume", WM8955_RIGHT_OUT_MIX_1, 4, 7, 1,
+               bypass_tlv),
+SOC_SINGLE_TLV("Right Bypass Volume", WM8955_RIGHT_OUT_MIX_2, 4, 7, 1,
+               bypass_tlv),
+
+/* Not a stereo pair so they line up with the DAPM switches */
+SOC_SINGLE_TLV("Mono Left Bypass Volume", WM8955_MONO_OUT_MIX_1, 4, 7, 1,
+               mono_tlv),
+SOC_SINGLE_TLV("Mono Right Bypass Volume", WM8955_MONO_OUT_MIX_2, 4, 7, 1,
+               mono_tlv),
+
+SOC_DOUBLE_R_TLV("Headphone Volume", WM8955_LOUT1_VOLUME,
+                 WM8955_ROUT1_VOLUME, 0, 127, 0, out_tlv),
+SOC_DOUBLE_R("Headphone ZC Switch", WM8955_LOUT1_VOLUME,
+             WM8955_ROUT1_VOLUME, 7, 1, 0),
+
+SOC_DOUBLE_R_TLV("Speaker Volume", WM8955_LOUT2_VOLUME,
+                 WM8955_ROUT2_VOLUME, 0, 127, 0, out_tlv),
+SOC_DOUBLE_R("Speaker ZC Switch", WM8955_LOUT2_VOLUME,
+             WM8955_ROUT2_VOLUME, 7, 1, 0),
+
+SOC_SINGLE_TLV("Mono Volume", WM8955_MONOOUT_VOLUME, 0, 127, 0, out_tlv),
+SOC_SINGLE("Mono ZC Switch", WM8955_MONOOUT_VOLUME, 7, 1, 0),
+};
+
+static const struct snd_kcontrol_new lmixer[] = {
+SOC_DAPM_SINGLE("Playback Switch", WM8955_LEFT_OUT_MIX_1, 8, 1, 0),
+SOC_DAPM_SINGLE("Bypass Switch", WM8955_LEFT_OUT_MIX_1, 7, 1, 0),
+SOC_DAPM_SINGLE("Right Playback Switch", WM8955_LEFT_OUT_MIX_2, 8, 1, 0),
+SOC_DAPM_SINGLE("Mono Switch", WM8955_LEFT_OUT_MIX_2, 7, 1, 0),
+};
+
+static const struct snd_kcontrol_new rmixer[] = {
+SOC_DAPM_SINGLE("Left Playback Switch", WM8955_RIGHT_OUT_MIX_1, 8, 1, 0),
+SOC_DAPM_SINGLE("Mono Switch", WM8955_RIGHT_OUT_MIX_1, 7, 1, 0),
+SOC_DAPM_SINGLE("Playback Switch", WM8955_RIGHT_OUT_MIX_2, 8, 1, 0),
+SOC_DAPM_SINGLE("Bypass Switch", WM8955_RIGHT_OUT_MIX_2, 7, 1, 0),
+};
+
+static const struct snd_kcontrol_new mmixer[] = {
+SOC_DAPM_SINGLE("Left Playback Switch", WM8955_MONO_OUT_MIX_1, 8, 1, 0),
+SOC_DAPM_SINGLE("Left Bypass Switch", WM8955_MONO_OUT_MIX_1, 7, 1, 0),
+SOC_DAPM_SINGLE("Right Playback Switch", WM8955_MONO_OUT_MIX_2, 8, 1, 0),
+SOC_DAPM_SINGLE("Right Bypass Switch", WM8955_MONO_OUT_MIX_2, 7, 1, 0),
+};
+
+static const struct snd_soc_dapm_widget wm8955_dapm_widgets[] = {
+SND_SOC_DAPM_INPUT("MONOIN-"),
+SND_SOC_DAPM_INPUT("MONOIN+"),
+SND_SOC_DAPM_INPUT("LINEINR"),
+SND_SOC_DAPM_INPUT("LINEINL"),
+
+SND_SOC_DAPM_PGA("Mono Input", SND_SOC_NOPM, 0, 0, NULL, 0),
+
+SND_SOC_DAPM_SUPPLY("SYSCLK", WM8955_POWER_MANAGEMENT_1, 0, 1, wm8955_sysclk,
+                    SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
+SND_SOC_DAPM_SUPPLY("TSDEN", WM8955_ADDITIONAL_CONTROL_1, 8, 0, NULL, 0),
+
+SND_SOC_DAPM_DAC("DACL", "Playback", WM8955_POWER_MANAGEMENT_2, 8, 0),
+SND_SOC_DAPM_DAC("DACR", "Playback", WM8955_POWER_MANAGEMENT_2, 7, 0),
+
+SND_SOC_DAPM_PGA("LOUT1 PGA", WM8955_POWER_MANAGEMENT_2, 6, 0, NULL, 0),
+SND_SOC_DAPM_PGA("ROUT1 PGA", WM8955_POWER_MANAGEMENT_2, 5, 0, NULL, 0),
+SND_SOC_DAPM_PGA("LOUT2 PGA", WM8955_POWER_MANAGEMENT_2, 4, 0, NULL, 0),
+SND_SOC_DAPM_PGA("ROUT2 PGA", WM8955_POWER_MANAGEMENT_2, 3, 0, NULL, 0),
+SND_SOC_DAPM_PGA("MOUT PGA", WM8955_POWER_MANAGEMENT_2, 2, 0, NULL, 0),
+SND_SOC_DAPM_PGA("OUT3 PGA", WM8955_POWER_MANAGEMENT_2, 1, 0, NULL, 0),
+
+/* The names are chosen to make the control names nice */
+SND_SOC_DAPM_MIXER("Left", SND_SOC_NOPM, 0, 0,
+                   lmixer, ARRAY_SIZE(lmixer)),
+SND_SOC_DAPM_MIXER("Right", SND_SOC_NOPM, 0, 0,
+                   rmixer, ARRAY_SIZE(rmixer)),
+SND_SOC_DAPM_MIXER("Mono", SND_SOC_NOPM, 0, 0,
+                   mmixer, ARRAY_SIZE(mmixer)),
+
+SND_SOC_DAPM_OUTPUT("LOUT1"),
+SND_SOC_DAPM_OUTPUT("ROUT1"),
+SND_SOC_DAPM_OUTPUT("LOUT2"),
+SND_SOC_DAPM_OUTPUT("ROUT2"),
+SND_SOC_DAPM_OUTPUT("MONOOUT"),
+SND_SOC_DAPM_OUTPUT("OUT3"),
+};
+
+static const struct snd_soc_dapm_route wm8955_intercon[] = {
+        { "DACL", NULL, "SYSCLK" },
+        { "DACR", NULL, "SYSCLK" },
+
+        { "Mono Input", NULL, "MONOIN-" },
+        { "Mono Input", NULL, "MONOIN+" },
+
+        { "Left", "Playback Switch", "DACL" },
+        { "Left", "Right Playback Switch", "DACR" },
+        { "Left", "Bypass Switch", "LINEINL" },
+        { "Left", "Mono Switch", "Mono Input" },
+
+        { "Right", "Playback Switch", "DACR" },
+        { "Right", "Left Playback Switch", "DACL" },
+        { "Right", "Bypass Switch", "LINEINR" },
+        { "Right", "Mono Switch", "Mono Input" },
+
+        { "Mono", "Left Playback Switch", "DACL" },
+        { "Mono", "Right Playback Switch", "DACR" },
+        { "Mono", "Left Bypass Switch", "LINEINL" },
+        { "Mono", "Right Bypass Switch", "LINEINR" },
+
+        { "LOUT1 PGA", NULL, "Left" },
+        { "LOUT1", NULL, "TSDEN" },
+        { "LOUT1", NULL, "LOUT1 PGA" },
+
+        { "ROUT1 PGA", NULL, "Right" },
+        { "ROUT1", NULL, "TSDEN" },
+        { "ROUT1", NULL, "ROUT1 PGA" },
+
+        { "LOUT2 PGA", NULL, "Left" },
+        { "LOUT2", NULL, "TSDEN" },
+        { "LOUT2", NULL, "LOUT2 PGA" },
+
+        { "ROUT2 PGA", NULL, "Right" },
+        { "ROUT2", NULL, "TSDEN" },
+        { "ROUT2", NULL, "ROUT2 PGA" },
+
+        { "MOUT PGA", NULL, "Mono" },
+        { "MONOOUT", NULL, "MOUT PGA" },
+
+        /* OUT3 not currently implemented */
+        { "OUT3", NULL, "OUT3 PGA" },
+};
+
+static int wm8955_add_widgets(struct snd_soc_codec *codec)
+{
+        snd_soc_add_controls(codec, wm8955_snd_controls,
+                             ARRAY_SIZE(wm8955_snd_controls));
+
+        snd_soc_dapm_new_controls(codec, wm8955_dapm_widgets,
+                                  ARRAY_SIZE(wm8955_dapm_widgets));
+
+        snd_soc_dapm_add_routes(codec, wm8955_intercon,
+                                ARRAY_SIZE(wm8955_intercon));
+
+        return 0;
+}
+
+static int wm8955_hw_params(struct snd_pcm_substream *substream,
+                            struct snd_pcm_hw_params *params,
+                            struct snd_soc_dai *dai)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        struct wm8955_priv *wm8955 = codec->private_data;
+        int ret;
+        int wl;
+
+        switch (params_format(params)) {
+        case SNDRV_PCM_FORMAT_S16_LE:
+                wl = 0;
+                break;
+        case SNDRV_PCM_FORMAT_S20_3LE:
+                wl = 0x4;
+                break;
+        case SNDRV_PCM_FORMAT_S24_LE:
+                wl = 0x8;
+                break;
+        case SNDRV_PCM_FORMAT_S32_LE:
+                wl = 0xc;
+                break;
+        default:
+                return -EINVAL;
+        }
+        snd_soc_update_bits(codec, WM8955_AUDIO_INTERFACE,
+                            WM8955_WL_MASK, wl);
+
+        wm8955->fs = params_rate(params);
+        wm8955_set_deemph(codec);
+
+        /* If the chip is clocked then disable the clocks and force a
+         * reconfiguration, otherwise DAPM will power up the
+         * clocks for us later. */
+        ret = snd_soc_read(codec, WM8955_POWER_MANAGEMENT_1);
+        if (ret < 0)
+                return ret;
+        if (ret & WM8955_DIGENB) {
+                snd_soc_update_bits(codec, WM8955_POWER_MANAGEMENT_1,
+                                    WM8955_DIGENB, 0);
+                snd_soc_update_bits(codec, WM8955_CLOCKING_PLL,
+                                    WM8955_PLL_RB | WM8955_PLLEN, 0);
+
+                wm8955_configure_clocking(codec);
+        }
+
+        return 0;
+}
+
+
+static int wm8955_set_sysclk(struct snd_soc_dai *dai, int clk_id,
+                             unsigned int freq, int dir)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        struct wm8955_priv *priv = codec->private_data;
+        int div;
+
+        switch (clk_id) {
+        case WM8955_CLK_MCLK:
+                if (freq > 15000000) {
+                        priv->mclk_rate = freq /= 2;
+                        div = WM8955_MCLKDIV2;
+                } else {
+                        priv->mclk_rate = freq;
+                        div = 0;
+                }
+
+                snd_soc_update_bits(codec, WM8955_SAMPLE_RATE,
+                                    WM8955_MCLKDIV2, div);
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        dev_dbg(dai->dev, "Clock source is %d at %uHz\n", clk_id, freq);
+
+        return 0;
+}
+
+static int wm8955_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        u16 aif = 0;
+
+        switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
+        case SND_SOC_DAIFMT_CBS_CFS:
+                break;
+        case SND_SOC_DAIFMT_CBM_CFM:
+                aif |= WM8955_MS;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
+        case SND_SOC_DAIFMT_DSP_B:
+                aif |= WM8955_LRP;
+        case SND_SOC_DAIFMT_DSP_A:
+                aif |= 0x3;
+                break;
+        case SND_SOC_DAIFMT_I2S:
+                aif |= 0x2;
+                break;
+        case SND_SOC_DAIFMT_RIGHT_J:
+                break;
+        case SND_SOC_DAIFMT_LEFT_J:
+                aif |= 0x1;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
+        case SND_SOC_DAIFMT_DSP_A:
+        case SND_SOC_DAIFMT_DSP_B:
+                /* frame inversion not valid for DSP modes */
+                switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
+                case SND_SOC_DAIFMT_NB_NF:
+                        break;
+                case SND_SOC_DAIFMT_IB_NF:
+                        aif |= WM8955_BCLKINV;
+                        break;
+                default:
+                        return -EINVAL;
+                }
+                break;
+
+        case SND_SOC_DAIFMT_I2S:
+        case SND_SOC_DAIFMT_RIGHT_J:
+        case SND_SOC_DAIFMT_LEFT_J:
+                switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
+                case SND_SOC_DAIFMT_NB_NF:
+                        break;
+                case SND_SOC_DAIFMT_IB_IF:
+                        aif |= WM8955_BCLKINV | WM8955_LRP;
+                        break;
+                case SND_SOC_DAIFMT_IB_NF:
+                        aif |= WM8955_BCLKINV;
+                        break;
+                case SND_SOC_DAIFMT_NB_IF:
+                        aif |= WM8955_LRP;
+                        break;
+                default:
+                        return -EINVAL;
+                }
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        snd_soc_update_bits(codec, WM8955_AUDIO_INTERFACE,
+                            WM8955_MS | WM8955_FORMAT_MASK | WM8955_BCLKINV |
+                            WM8955_LRP, aif);
+
+        return 0;
+}
+
+
+static int wm8955_digital_mute(struct snd_soc_dai *codec_dai, int mute)
+{
+        struct snd_soc_codec *codec = codec_dai->codec;
+        int val;
+
+        if (mute)
+                val = WM8955_DACMU;
+        else
+                val = 0;
+
+        snd_soc_update_bits(codec, WM8955_DAC_CONTROL, WM8955_DACMU, val);
+
+        return 0;
+}
+
+static int wm8955_set_bias_level(struct snd_soc_codec *codec,
+                                 enum snd_soc_bias_level level)
+{
+        struct wm8955_priv *wm8955 = codec->private_data;
+        int ret, i;
+
+        switch (level) {
+        case SND_SOC_BIAS_ON:
+                break;
+
+        case SND_SOC_BIAS_PREPARE:
+                /* VMID resistance 2*50k */
+                snd_soc_update_bits(codec, WM8955_POWER_MANAGEMENT_1,
+                                    WM8955_VMIDSEL_MASK,
+                                    0x1 << WM8955_VMIDSEL_SHIFT);
+
+                /* Default bias current */
+                snd_soc_update_bits(codec, WM8955_ADDITIONAL_CONTROL_1,
+                                    WM8955_VSEL_MASK,
+                                    0x2 << WM8955_VSEL_SHIFT);
+                break;
+
+        case SND_SOC_BIAS_STANDBY:
+                if (codec->bias_level == SND_SOC_BIAS_OFF) {
+                        ret = regulator_bulk_enable(ARRAY_SIZE(wm8955->supplies),
+                                                    wm8955->supplies);
+                        if (ret != 0) {
+                                dev_err(codec->dev,
+                                        "Failed to enable supplies: %d\n",
+                                        ret);
+                                return ret;
+                        }
+
+                        /* Sync back cached values if they're
+                         * different from the hardware default.
+                         */
+                        for (i = 0; i < ARRAY_SIZE(wm8955->reg_cache); i++) {
+                                if (i == WM8955_RESET)
+                                        continue;
+
+                                if (wm8955->reg_cache[i] == wm8955_reg[i])
+                                        continue;
+
+                                snd_soc_write(codec, i, wm8955->reg_cache[i]);
+                        }
+
+                        /* Enable VREF and VMID */
+                        snd_soc_update_bits(codec, WM8955_POWER_MANAGEMENT_1,
+                                            WM8955_VREF |
+                                            WM8955_VMIDSEL_MASK,
+                                            WM8955_VREF |
+                                            0x3 << WM8955_VREF_SHIFT);
+
+                        /* Let VMID ramp */
+                        msleep(500);
+
+                        /* High resistance VROI to maintain outputs */
+                        snd_soc_update_bits(codec,
+                                            WM8955_ADDITIONAL_CONTROL_3,
+                                            WM8955_VROI, WM8955_VROI);
+                }
+
+                /* Maintain VMID with 2*250k */
+                snd_soc_update_bits(codec, WM8955_POWER_MANAGEMENT_1,
+                                    WM8955_VMIDSEL_MASK,
+                                    0x2 << WM8955_VMIDSEL_SHIFT);
+
+                /* Minimum bias current */
+                snd_soc_update_bits(codec, WM8955_ADDITIONAL_CONTROL_1,
+                                    WM8955_VSEL_MASK, 0);
+                break;
+
+        case SND_SOC_BIAS_OFF:
+                /* Low resistance VROI to help discharge */
+                snd_soc_update_bits(codec,
+                                    WM8955_ADDITIONAL_CONTROL_3,
+                                    WM8955_VROI, 0);
+
+                /* Turn off VMID and VREF */
+                snd_soc_update_bits(codec, WM8955_POWER_MANAGEMENT_1,
+                                    WM8955_VREF |
+                                    WM8955_VMIDSEL_MASK, 0);
+
+                regulator_bulk_disable(ARRAY_SIZE(wm8955->supplies),
+                                       wm8955->supplies);
+                break;
+        }
+        codec->bias_level = level;
+        return 0;
+}
+
+#define WM8955_RATES SNDRV_PCM_RATE_8000_96000
+
+#define WM8955_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
+                        SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32_LE)
+
+static struct snd_soc_dai_ops wm8955_dai_ops = {
+        .set_sysclk = wm8955_set_sysclk,
+        .set_fmt = wm8955_set_fmt,
+        .hw_params = wm8955_hw_params,
+        .digital_mute = wm8955_digital_mute,
+};
+
+struct snd_soc_dai wm8955_dai = {
+        .name = "WM8955",
+        .playback = {
+                .stream_name = "Playback",
+                .channels_min = 2,
+                .channels_max = 2,
+                .rates = WM8955_RATES,
+                .formats = WM8955_FORMATS,
+        },
+        .ops = &wm8955_dai_ops,
+};
+EXPORT_SYMBOL_GPL(wm8955_dai);
+
+#ifdef CONFIG_PM
+static int wm8955_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec = socdev->card->codec;
+
+        wm8955_set_bias_level(codec, SND_SOC_BIAS_OFF);
+
+        return 0;
+}
+
+static int wm8955_resume(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec = socdev->card->codec;
+
+        wm8955_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+
+        return 0;
+}
+#else
+#define wm8955_suspend NULL
+#define wm8955_resume NULL
+#endif
+
+static int wm8955_probe(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec;
+        int ret = 0;
+
+        if (wm8955_codec == NULL) {
+                dev_err(&pdev->dev, "Codec device not registered\n");
+                return -ENODEV;
+        }
+
+        socdev->card->codec = wm8955_codec;
+        codec = wm8955_codec;
+
+        /* register pcms */
+        ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
+        if (ret < 0) {
+                dev_err(codec->dev, "failed to create pcms: %d\n", ret);
+                goto pcm_err;
+        }
+
+        wm8955_add_widgets(codec);
+
+        return ret;
+
+pcm_err:
+        return ret;
+}
+
+static int wm8955_remove(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+
+        snd_soc_free_pcms(socdev);
+        snd_soc_dapm_free(socdev);
+
+        return 0;
+}
+
+struct snd_soc_codec_device soc_codec_dev_wm8955 = {
+        .probe =        wm8955_probe,
+        .remove =       wm8955_remove,
+        .suspend =      wm8955_suspend,
+        .resume =       wm8955_resume,
+};
+EXPORT_SYMBOL_GPL(soc_codec_dev_wm8955);
+
+static int wm8955_register(struct wm8955_priv *wm8955,
+                           enum snd_soc_control_type control)
+{
+        int ret;
+        struct snd_soc_codec *codec = &wm8955->codec;
+        int i;
+
+        if (wm8955_codec) {
+                dev_err(codec->dev, "Another WM8955 is registered\n");
+                return -EINVAL;
+        }
+
+        mutex_init(&codec->mutex);
+        INIT_LIST_HEAD(&codec->dapm_widgets);
+        INIT_LIST_HEAD(&codec->dapm_paths);
+
+        codec->private_data = wm8955;
+        codec->name = "WM8955";
+        codec->owner = THIS_MODULE;
+        codec->bias_level = SND_SOC_BIAS_OFF;
+        codec->set_bias_level = wm8955_set_bias_level;
+        codec->dai = &wm8955_dai;
+        codec->num_dai = 1;
+        codec->reg_cache_size = WM8955_MAX_REGISTER;
+        codec->reg_cache = &wm8955->reg_cache;
+
+        memcpy(codec->reg_cache, wm8955_reg, sizeof(wm8955_reg));
+
+        ret = snd_soc_codec_set_cache_io(codec, 7, 9, control);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
+                goto err;
+        }
+
+        for (i = 0; i < ARRAY_SIZE(wm8955->supplies); i++)
+                wm8955->supplies[i].supply = wm8955_supply_names[i];
+
+        ret = regulator_bulk_get(codec->dev, ARRAY_SIZE(wm8955->supplies),
+                                 wm8955->supplies);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to request supplies: %d\n", ret);
+                goto err;
+        }
+
+        ret = regulator_bulk_enable(ARRAY_SIZE(wm8955->supplies),
+                                    wm8955->supplies);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to enable supplies: %d\n", ret);
+                goto err_get;
+        }
+
+        ret = wm8955_reset(codec);
+        if (ret < 0) {
+                dev_err(codec->dev, "Failed to issue reset: %d\n", ret);
+                goto err_enable;
+        }
+
+        wm8955_dai.dev = codec->dev;
+
+        /* Change some default settings - latch VU and enable ZC */
+        wm8955->reg_cache[WM8955_LEFT_DAC_VOLUME] |= WM8955_LDVU;
+        wm8955->reg_cache[WM8955_RIGHT_DAC_VOLUME] |= WM8955_RDVU;
+        wm8955->reg_cache[WM8955_LOUT1_VOLUME] |= WM8955_LO1VU | WM8955_LO1ZC;
+        wm8955->reg_cache[WM8955_ROUT1_VOLUME] |= WM8955_RO1VU | WM8955_RO1ZC;
+        wm8955->reg_cache[WM8955_LOUT2_VOLUME] |= WM8955_LO2VU | WM8955_LO2ZC;
+        wm8955->reg_cache[WM8955_ROUT2_VOLUME] |= WM8955_RO2VU | WM8955_RO2ZC;
+        wm8955->reg_cache[WM8955_MONOOUT_VOLUME] |= WM8955_MOZC;
+
+        /* Also enable adaptive bass boost by default */
+        wm8955->reg_cache[WM8955_BASS_CONTROL] |= WM8955_BB;
+
+        /* Set platform data values */
+        if (wm8955->pdata) {
+                if (wm8955->pdata->out2_speaker)
+                        wm8955->reg_cache[WM8955_ADDITIONAL_CONTROL_2]
+                                |= WM8955_ROUT2INV;
+
+                if (wm8955->pdata->monoin_diff)
+                        wm8955->reg_cache[WM8955_MONO_OUT_MIX_1]
+                                |= WM8955_DMEN;
+        }
+
+        wm8955_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+
+        /* Bias level configuration will have done an extra enable */
+        regulator_bulk_disable(ARRAY_SIZE(wm8955->supplies), wm8955->supplies);
+
+        wm8955_codec = codec;
+
+        ret = snd_soc_register_codec(codec);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to register codec: %d\n", ret);
+                return ret;
+        }
+
+        ret = snd_soc_register_dai(&wm8955_dai);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to register DAI: %d\n", ret);
+                snd_soc_unregister_codec(codec);
+                return ret;
+        }
+
+        return 0;
+
+err_enable:
+        regulator_bulk_disable(ARRAY_SIZE(wm8955->supplies), wm8955->supplies);
+err_get:
+        regulator_bulk_free(ARRAY_SIZE(wm8955->supplies), wm8955->supplies);
+err:
+        kfree(wm8955);
+        return ret;
+}
+
+static void wm8955_unregister(struct wm8955_priv *wm8955)
+{
+        wm8955_set_bias_level(&wm8955->codec, SND_SOC_BIAS_OFF);
+        regulator_bulk_free(ARRAY_SIZE(wm8955->supplies), wm8955->supplies);
+        snd_soc_unregister_dai(&wm8955_dai);
+        snd_soc_unregister_codec(&wm8955->codec);
+        kfree(wm8955);
+        wm8955_codec = NULL;
+}
+
+#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+static __devinit int wm8955_i2c_probe(struct i2c_client *i2c,
+                                      const struct i2c_device_id *id)
+{
+        struct wm8955_priv *wm8955;
+        struct snd_soc_codec *codec;
+
+        wm8955 = kzalloc(sizeof(struct wm8955_priv), GFP_KERNEL);
+        if (wm8955 == NULL)
+                return -ENOMEM;
+
+        codec = &wm8955->codec;
+        codec->hw_write = (hw_write_t)i2c_master_send;
+
+        i2c_set_clientdata(i2c, wm8955);
+        codec->control_data = i2c;
+        wm8955->pdata = i2c->dev.platform_data;
+
+        codec->dev = &i2c->dev;
+
+        return wm8955_register(wm8955, SND_SOC_I2C);
+}
+
+static __devexit int wm8955_i2c_remove(struct i2c_client *client)
+{
+        struct wm8955_priv *wm8955 = i2c_get_clientdata(client);
+        wm8955_unregister(wm8955);
+        return 0;
+}
+
+static const struct i2c_device_id wm8955_i2c_id[] = {
+        { "wm8955", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, wm8955_i2c_id);
+
+static struct i2c_driver wm8955_i2c_driver = {
+        .driver = {
+                .name = "wm8955",
+                .owner = THIS_MODULE,
+        },
+        .probe =    wm8955_i2c_probe,
+        .remove =   __devexit_p(wm8955_i2c_remove),
+        .id_table = wm8955_i2c_id,
+};
+#endif
+
+static int __init wm8955_modinit(void)
+{
+        int ret;
+#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+        ret = i2c_add_driver(&wm8955_i2c_driver);
+        if (ret != 0) {
+                printk(KERN_ERR "Failed to register WM8955 I2C driver: %d\n",
+                       ret);
+        }
+#endif
+        return 0;
+}
+module_init(wm8955_modinit);
+
+static void __exit wm8955_exit(void)
+{
+#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+        i2c_del_driver(&wm8955_i2c_driver);
+#endif
+}
+module_exit(wm8955_exit);
+
+MODULE_DESCRIPTION("ASoC WM8955 driver");
+MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/codecs/wm8955.h b/sound/soc/codecs/wm8955.h
new file mode 100644
index 000000000000..ae349c8531f6
--- /dev/null
+++ b/sound/soc/codecs/wm8955.h
@@ -0,0 +1,489 @@
+/*
+ * wm8955.h  --  WM8904 ASoC driver
+ *
+ * Copyright 2009 Wolfson Microelectronics, plc
+ *
+ * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef _WM8955_H
+#define _WM8955_H
+
+#define WM8955_CLK_MCLK 1
+
+extern struct snd_soc_dai wm8955_dai;
+extern struct snd_soc_codec_device soc_codec_dev_wm8955;
+
+/*
+ * Register values.
+ */
+#define WM8955_LOUT1_VOLUME                     0x02
+#define WM8955_ROUT1_VOLUME                     0x03
+#define WM8955_DAC_CONTROL                      0x05
+#define WM8955_AUDIO_INTERFACE                  0x07
+#define WM8955_SAMPLE_RATE                      0x08
+#define WM8955_LEFT_DAC_VOLUME                  0x0A
+#define WM8955_RIGHT_DAC_VOLUME                 0x0B
+#define WM8955_BASS_CONTROL                     0x0C
+#define WM8955_TREBLE_CONTROL                   0x0D
+#define WM8955_RESET                            0x0F
+#define WM8955_ADDITIONAL_CONTROL_1             0x17
+#define WM8955_ADDITIONAL_CONTROL_2             0x18
+#define WM8955_POWER_MANAGEMENT_1               0x19
+#define WM8955_POWER_MANAGEMENT_2               0x1A
+#define WM8955_ADDITIONAL_CONTROL_3             0x1B
+#define WM8955_LEFT_OUT_MIX_1                   0x22
+#define WM8955_LEFT_OUT_MIX_2                   0x23
+#define WM8955_RIGHT_OUT_MIX_1                  0x24
+#define WM8955_RIGHT_OUT_MIX_2                  0x25
+#define WM8955_MONO_OUT_MIX_1                   0x26
+#define WM8955_MONO_OUT_MIX_2                   0x27
+#define WM8955_LOUT2_VOLUME                     0x28
+#define WM8955_ROUT2_VOLUME                     0x29
+#define WM8955_MONOOUT_VOLUME                   0x2A
+#define WM8955_CLOCKING_PLL                     0x2B
+#define WM8955_PLL_CONTROL_1                    0x2C
+#define WM8955_PLL_CONTROL_2                    0x2D
+#define WM8955_PLL_CONTROL_3                    0x2E
+#define WM8955_PLL_CONTROL_4                    0x3B
+
+#define WM8955_REGISTER_COUNT                   29
+#define WM8955_MAX_REGISTER                     0x3B
+
+/*
+ * Field Definitions.
+ */
+
+/*
+ * R2 (0x02) - LOUT1 volume
+ */
+#define WM8955_LO1VU                            0x0100  /* LO1VU */
+#define WM8955_LO1VU_MASK                       0x0100  /* LO1VU */
+#define WM8955_LO1VU_SHIFT                           8  /* LO1VU */
+#define WM8955_LO1VU_WIDTH                           1  /* LO1VU */
+#define WM8955_LO1ZC                            0x0080  /* LO1ZC */
+#define WM8955_LO1ZC_MASK                       0x0080  /* LO1ZC */
+#define WM8955_LO1ZC_SHIFT                           7  /* LO1ZC */
+#define WM8955_LO1ZC_WIDTH                           1  /* LO1ZC */
+#define WM8955_LOUTVOL_MASK                     0x007F  /* LOUTVOL - [6:0] */
+#define WM8955_LOUTVOL_SHIFT                         0  /* LOUTVOL - [6:0] */
+#define WM8955_LOUTVOL_WIDTH                         7  /* LOUTVOL - [6:0] */
+
+/*
+ * R3 (0x03) - ROUT1 volume
+ */
+#define WM8955_RO1VU                            0x0100  /* RO1VU */
+#define WM8955_RO1VU_MASK                       0x0100  /* RO1VU */
+#define WM8955_RO1VU_SHIFT                           8  /* RO1VU */
+#define WM8955_RO1VU_WIDTH                           1  /* RO1VU */
+#define WM8955_RO1ZC                            0x0080  /* RO1ZC */
+#define WM8955_RO1ZC_MASK                       0x0080  /* RO1ZC */
+#define WM8955_RO1ZC_SHIFT                           7  /* RO1ZC */
+#define WM8955_RO1ZC_WIDTH                           1  /* RO1ZC */
+#define WM8955_ROUTVOL_MASK                     0x007F  /* ROUTVOL - [6:0] */
+#define WM8955_ROUTVOL_SHIFT                         0  /* ROUTVOL - [6:0] */
+#define WM8955_ROUTVOL_WIDTH                         7  /* ROUTVOL - [6:0] */
+
+/*
+ * R5 (0x05) - DAC Control
+ */
+#define WM8955_DAT                              0x0080  /* DAT */
+#define WM8955_DAT_MASK                         0x0080  /* DAT */
+#define WM8955_DAT_SHIFT                             7  /* DAT */
+#define WM8955_DAT_WIDTH                             1  /* DAT */
+#define WM8955_DACMU                            0x0008  /* DACMU */
+#define WM8955_DACMU_MASK                       0x0008  /* DACMU */
+#define WM8955_DACMU_SHIFT                           3  /* DACMU */
+#define WM8955_DACMU_WIDTH                           1  /* DACMU */
+#define WM8955_DEEMPH_MASK                      0x0006  /* DEEMPH - [2:1] */
+#define WM8955_DEEMPH_SHIFT                          1  /* DEEMPH - [2:1] */
+#define WM8955_DEEMPH_WIDTH                          2  /* DEEMPH - [2:1] */
+
+/*
+ * R7 (0x07) - Audio Interface
+ */
+#define WM8955_BCLKINV                          0x0080  /* BCLKINV */
+#define WM8955_BCLKINV_MASK                     0x0080  /* BCLKINV */
+#define WM8955_BCLKINV_SHIFT                         7  /* BCLKINV */
+#define WM8955_BCLKINV_WIDTH                         1  /* BCLKINV */
+#define WM8955_MS                               0x0040  /* MS */
+#define WM8955_MS_MASK                          0x0040  /* MS */
+#define WM8955_MS_SHIFT                              6  /* MS */
+#define WM8955_MS_WIDTH                              1  /* MS */
+#define WM8955_LRSWAP                           0x0020  /* LRSWAP */
+#define WM8955_LRSWAP_MASK                      0x0020  /* LRSWAP */
+#define WM8955_LRSWAP_SHIFT                          5  /* LRSWAP */
+#define WM8955_LRSWAP_WIDTH                          1  /* LRSWAP */
+#define WM8955_LRP                              0x0010  /* LRP */
+#define WM8955_LRP_MASK                         0x0010  /* LRP */
+#define WM8955_LRP_SHIFT                             4  /* LRP */
+#define WM8955_LRP_WIDTH                             1  /* LRP */
+#define WM8955_WL_MASK                          0x000C  /* WL - [3:2] */
+#define WM8955_WL_SHIFT                              2  /* WL - [3:2] */
+#define WM8955_WL_WIDTH                              2  /* WL - [3:2] */
+#define WM8955_FORMAT_MASK                      0x0003  /* FORMAT - [1:0] */
+#define WM8955_FORMAT_SHIFT                          0  /* FORMAT - [1:0] */
+#define WM8955_FORMAT_WIDTH                          2  /* FORMAT - [1:0] */
+
+/*
+ * R8 (0x08) - Sample Rate
+ */
+#define WM8955_BCLKDIV2                         0x0080  /* BCLKDIV2 */
+#define WM8955_BCLKDIV2_MASK                    0x0080  /* BCLKDIV2 */
+#define WM8955_BCLKDIV2_SHIFT                        7  /* BCLKDIV2 */
+#define WM8955_BCLKDIV2_WIDTH                        1  /* BCLKDIV2 */
+#define WM8955_MCLKDIV2                         0x0040  /* MCLKDIV2 */
+#define WM8955_MCLKDIV2_MASK                    0x0040  /* MCLKDIV2 */
+#define WM8955_MCLKDIV2_SHIFT                        6  /* MCLKDIV2 */
+#define WM8955_MCLKDIV2_WIDTH                        1  /* MCLKDIV2 */
+#define WM8955_SR_MASK                          0x003E  /* SR - [5:1] */
+#define WM8955_SR_SHIFT                              1  /* SR - [5:1] */
+#define WM8955_SR_WIDTH                              5  /* SR - [5:1] */
+#define WM8955_USB                              0x0001  /* USB */
+#define WM8955_USB_MASK                         0x0001  /* USB */
+#define WM8955_USB_SHIFT                             0  /* USB */
+#define WM8955_USB_WIDTH                             1  /* USB */
+
+/*
+ * R10 (0x0A) - Left DAC volume
+ */
+#define WM8955_LDVU                             0x0100  /* LDVU */
+#define WM8955_LDVU_MASK                        0x0100  /* LDVU */
+#define WM8955_LDVU_SHIFT                            8  /* LDVU */
+#define WM8955_LDVU_WIDTH                            1  /* LDVU */
+#define WM8955_LDACVOL_MASK                     0x00FF  /* LDACVOL - [7:0] */
+#define WM8955_LDACVOL_SHIFT                         0  /* LDACVOL - [7:0] */
+#define WM8955_LDACVOL_WIDTH                         8  /* LDACVOL - [7:0] */
+
+/*
+ * R11 (0x0B) - Right DAC volume
+ */
+#define WM8955_RDVU                             0x0100  /* RDVU */
+#define WM8955_RDVU_MASK                        0x0100  /* RDVU */
+#define WM8955_RDVU_SHIFT                            8  /* RDVU */
+#define WM8955_RDVU_WIDTH                            1  /* RDVU */
+#define WM8955_RDACVOL_MASK                     0x00FF  /* RDACVOL - [7:0] */
+#define WM8955_RDACVOL_SHIFT                         0  /* RDACVOL - [7:0] */
+#define WM8955_RDACVOL_WIDTH                         8  /* RDACVOL - [7:0] */
+
+/*
+ * R12 (0x0C) - Bass control
+ */
+#define WM8955_BB                               0x0080  /* BB */
+#define WM8955_BB_MASK                          0x0080  /* BB */
+#define WM8955_BB_SHIFT                              7  /* BB */
+#define WM8955_BB_WIDTH                              1  /* BB */
+#define WM8955_BC                               0x0040  /* BC */
+#define WM8955_BC_MASK                          0x0040  /* BC */
+#define WM8955_BC_SHIFT                              6  /* BC */
+#define WM8955_BC_WIDTH                              1  /* BC */
+#define WM8955_BASS_MASK                        0x000F  /* BASS - [3:0] */
+#define WM8955_BASS_SHIFT                            0  /* BASS - [3:0] */
+#define WM8955_BASS_WIDTH                            4  /* BASS - [3:0] */
+
+/*
+ * R13 (0x0D) - Treble control
+ */
+#define WM8955_TC                               0x0040  /* TC */
+#define WM8955_TC_MASK                          0x0040  /* TC */
+#define WM8955_TC_SHIFT                              6  /* TC */
+#define WM8955_TC_WIDTH                              1  /* TC */
+#define WM8955_TRBL_MASK                        0x000F  /* TRBL - [3:0] */
+#define WM8955_TRBL_SHIFT                            0  /* TRBL - [3:0] */
+#define WM8955_TRBL_WIDTH                            4  /* TRBL - [3:0] */
+
+/*
+ * R15 (0x0F) - Reset
+ */
+#define WM8955_RESET_MASK                       0x01FF  /* RESET - [8:0] */
+#define WM8955_RESET_SHIFT                           0  /* RESET - [8:0] */
+#define WM8955_RESET_WIDTH                           9  /* RESET - [8:0] */
+
+/*
+ * R23 (0x17) - Additional control (1)
+ */
+#define WM8955_TSDEN                            0x0100  /* TSDEN */
+#define WM8955_TSDEN_MASK                       0x0100  /* TSDEN */
+#define WM8955_TSDEN_SHIFT                           8  /* TSDEN */
+#define WM8955_TSDEN_WIDTH                           1  /* TSDEN */
+#define WM8955_VSEL_MASK                        0x00C0  /* VSEL - [7:6] */
+#define WM8955_VSEL_SHIFT                            6  /* VSEL - [7:6] */
+#define WM8955_VSEL_WIDTH                            2  /* VSEL - [7:6] */
+#define WM8955_DMONOMIX_MASK                    0x0030  /* DMONOMIX - [5:4] */
+#define WM8955_DMONOMIX_SHIFT                        4  /* DMONOMIX - [5:4] */
+#define WM8955_DMONOMIX_WIDTH                        2  /* DMONOMIX - [5:4] */
+#define WM8955_DACINV                           0x0002  /* DACINV */
+#define WM8955_DACINV_MASK                      0x0002  /* DACINV */
+#define WM8955_DACINV_SHIFT                          1  /* DACINV */
+#define WM8955_DACINV_WIDTH                          1  /* DACINV */
+#define WM8955_TOEN                             0x0001  /* TOEN */
+#define WM8955_TOEN_MASK                        0x0001  /* TOEN */
+#define WM8955_TOEN_SHIFT                            0  /* TOEN */
+#define WM8955_TOEN_WIDTH                            1  /* TOEN */
+
+/*
+ * R24 (0x18) - Additional control (2)
+ */
+#define WM8955_OUT3SW_MASK                      0x0180  /* OUT3SW - [8:7] */
+#define WM8955_OUT3SW_SHIFT                          7  /* OUT3SW - [8:7] */
+#define WM8955_OUT3SW_WIDTH                          2  /* OUT3SW - [8:7] */
+#define WM8955_ROUT2INV                         0x0010  /* ROUT2INV */
+#define WM8955_ROUT2INV_MASK                    0x0010  /* ROUT2INV */
+#define WM8955_ROUT2INV_SHIFT                        4  /* ROUT2INV */
+#define WM8955_ROUT2INV_WIDTH                        1  /* ROUT2INV */
+#define WM8955_DACOSR                           0x0001  /* DACOSR */
+#define WM8955_DACOSR_MASK                      0x0001  /* DACOSR */
+#define WM8955_DACOSR_SHIFT                          0  /* DACOSR */
+#define WM8955_DACOSR_WIDTH                          1  /* DACOSR */
+
+/*
+ * R25 (0x19) - Power Management (1)
+ */
+#define WM8955_VMIDSEL_MASK                     0x0180  /* VMIDSEL - [8:7] */
+#define WM8955_VMIDSEL_SHIFT                         7  /* VMIDSEL - [8:7] */
+#define WM8955_VMIDSEL_WIDTH                         2  /* VMIDSEL - [8:7] */
+#define WM8955_VREF                             0x0040  /* VREF */
+#define WM8955_VREF_MASK                        0x0040  /* VREF */
+#define WM8955_VREF_SHIFT                            6  /* VREF */
+#define WM8955_VREF_WIDTH                            1  /* VREF */
+#define WM8955_DIGENB                           0x0001  /* DIGENB */
+#define WM8955_DIGENB_MASK                      0x0001  /* DIGENB */
+#define WM8955_DIGENB_SHIFT                          0  /* DIGENB */
+#define WM8955_DIGENB_WIDTH                          1  /* DIGENB */
+
+/*
+ * R26 (0x1A) - Power Management (2)
+ */
+#define WM8955_DACL                             0x0100  /* DACL */
+#define WM8955_DACL_MASK                        0x0100  /* DACL */
+#define WM8955_DACL_SHIFT                            8  /* DACL */
+#define WM8955_DACL_WIDTH                            1  /* DACL */
+#define WM8955_DACR                             0x0080  /* DACR */
+#define WM8955_DACR_MASK                        0x0080  /* DACR */
+#define WM8955_DACR_SHIFT                            7  /* DACR */
+#define WM8955_DACR_WIDTH                            1  /* DACR */
+#define WM8955_LOUT1                            0x0040  /* LOUT1 */
+#define WM8955_LOUT1_MASK                       0x0040  /* LOUT1 */
+#define WM8955_LOUT1_SHIFT                           6  /* LOUT1 */
+#define WM8955_LOUT1_WIDTH                           1  /* LOUT1 */
+#define WM8955_ROUT1                            0x0020  /* ROUT1 */
+#define WM8955_ROUT1_MASK                       0x0020  /* ROUT1 */
+#define WM8955_ROUT1_SHIFT                           5  /* ROUT1 */
+#define WM8955_ROUT1_WIDTH                           1  /* ROUT1 */
+#define WM8955_LOUT2                            0x0010  /* LOUT2 */
+#define WM8955_LOUT2_MASK                       0x0010  /* LOUT2 */
+#define WM8955_LOUT2_SHIFT                           4  /* LOUT2 */
+#define WM8955_LOUT2_WIDTH                           1  /* LOUT2 */
+#define WM8955_ROUT2                            0x0008  /* ROUT2 */
+#define WM8955_ROUT2_MASK                       0x0008  /* ROUT2 */
+#define WM8955_ROUT2_SHIFT                           3  /* ROUT2 */
+#define WM8955_ROUT2_WIDTH                           1  /* ROUT2 */
+#define WM8955_MONO                             0x0004  /* MONO */
+#define WM8955_MONO_MASK                        0x0004  /* MONO */
+#define WM8955_MONO_SHIFT                            2  /* MONO */
+#define WM8955_MONO_WIDTH                            1  /* MONO */
+#define WM8955_OUT3                             0x0002  /* OUT3 */
+#define WM8955_OUT3_MASK                        0x0002  /* OUT3 */
+#define WM8955_OUT3_SHIFT                            1  /* OUT3 */
+#define WM8955_OUT3_WIDTH                            1  /* OUT3 */
+
+/*
+ * R27 (0x1B) - Additional Control (3)
+ */
+#define WM8955_VROI                             0x0040  /* VROI */
+#define WM8955_VROI_MASK                        0x0040  /* VROI */
+#define WM8955_VROI_SHIFT                            6  /* VROI */
+#define WM8955_VROI_WIDTH                            1  /* VROI */
+
+/*
+ * R34 (0x22) - Left out Mix (1)
+ */
+#define WM8955_LD2LO                            0x0100  /* LD2LO */
+#define WM8955_LD2LO_MASK                       0x0100  /* LD2LO */
+#define WM8955_LD2LO_SHIFT                           8  /* LD2LO */
+#define WM8955_LD2LO_WIDTH                           1  /* LD2LO */
+#define WM8955_LI2LO                            0x0080  /* LI2LO */
+#define WM8955_LI2LO_MASK                       0x0080  /* LI2LO */
+#define WM8955_LI2LO_SHIFT                           7  /* LI2LO */
+#define WM8955_LI2LO_WIDTH                           1  /* LI2LO */
+#define WM8955_LI2LOVOL_MASK                    0x0070  /* LI2LOVOL - [6:4] */
+#define WM8955_LI2LOVOL_SHIFT                        4  /* LI2LOVOL - [6:4] */
+#define WM8955_LI2LOVOL_WIDTH                        3  /* LI2LOVOL - [6:4] */
+
+/*
+ * R35 (0x23) - Left out Mix (2)
+ */
+#define WM8955_RD2LO                            0x0100  /* RD2LO */
+#define WM8955_RD2LO_MASK                       0x0100  /* RD2LO */
+#define WM8955_RD2LO_SHIFT                           8  /* RD2LO */
+#define WM8955_RD2LO_WIDTH                           1  /* RD2LO */
+#define WM8955_RI2LO                            0x0080  /* RI2LO */
+#define WM8955_RI2LO_MASK                       0x0080  /* RI2LO */
+#define WM8955_RI2LO_SHIFT                           7  /* RI2LO */
+#define WM8955_RI2LO_WIDTH                           1  /* RI2LO */
+#define WM8955_RI2LOVOL_MASK                    0x0070  /* RI2LOVOL - [6:4] */
+#define WM8955_RI2LOVOL_SHIFT                        4  /* RI2LOVOL - [6:4] */
+#define WM8955_RI2LOVOL_WIDTH                        3  /* RI2LOVOL - [6:4] */
+
+/*
+ * R36 (0x24) - Right out Mix (1)
+ */
+#define WM8955_LD2RO                            0x0100  /* LD2RO */
+#define WM8955_LD2RO_MASK                       0x0100  /* LD2RO */
+#define WM8955_LD2RO_SHIFT                           8  /* LD2RO */
+#define WM8955_LD2RO_WIDTH                           1  /* LD2RO */
+#define WM8955_LI2RO                            0x0080  /* LI2RO */
+#define WM8955_LI2RO_MASK                       0x0080  /* LI2RO */
+#define WM8955_LI2RO_SHIFT                           7  /* LI2RO */
+#define WM8955_LI2RO_WIDTH                           1  /* LI2RO */
+#define WM8955_LI2ROVOL_MASK                    0x0070  /* LI2ROVOL - [6:4] */
+#define WM8955_LI2ROVOL_SHIFT                        4  /* LI2ROVOL - [6:4] */
+#define WM8955_LI2ROVOL_WIDTH                        3  /* LI2ROVOL - [6:4] */
+
+/*
+ * R37 (0x25) - Right Out Mix (2)
+ */
+#define WM8955_RD2RO                            0x0100  /* RD2RO */
+#define WM8955_RD2RO_MASK                       0x0100  /* RD2RO */
+#define WM8955_RD2RO_SHIFT                           8  /* RD2RO */
+#define WM8955_RD2RO_WIDTH                           1  /* RD2RO */
+#define WM8955_RI2RO                            0x0080  /* RI2RO */
+#define WM8955_RI2RO_MASK                       0x0080  /* RI2RO */
+#define WM8955_RI2RO_SHIFT                           7  /* RI2RO */
+#define WM8955_RI2RO_WIDTH                           1  /* RI2RO */
+#define WM8955_RI2ROVOL_MASK                    0x0070  /* RI2ROVOL - [6:4] */
+#define WM8955_RI2ROVOL_SHIFT                        4  /* RI2ROVOL - [6:4] */
+#define WM8955_RI2ROVOL_WIDTH                        3  /* RI2ROVOL - [6:4] */
+
+/*
+ * R38 (0x26) - Mono out Mix (1)
+ */
+#define WM8955_LD2MO                            0x0100  /* LD2MO */
+#define WM8955_LD2MO_MASK                       0x0100  /* LD2MO */
+#define WM8955_LD2MO_SHIFT                           8  /* LD2MO */
+#define WM8955_LD2MO_WIDTH                           1  /* LD2MO */
+#define WM8955_LI2MO                            0x0080  /* LI2MO */
+#define WM8955_LI2MO_MASK                       0x0080  /* LI2MO */
+#define WM8955_LI2MO_SHIFT                           7  /* LI2MO */
+#define WM8955_LI2MO_WIDTH                           1  /* LI2MO */
+#define WM8955_LI2MOVOL_MASK                    0x0070  /* LI2MOVOL - [6:4] */
+#define WM8955_LI2MOVOL_SHIFT                        4  /* LI2MOVOL - [6:4] */
+#define WM8955_LI2MOVOL_WIDTH                        3  /* LI2MOVOL - [6:4] */
+#define WM8955_DMEN                             0x0001  /* DMEN */
+#define WM8955_DMEN_MASK                        0x0001  /* DMEN */
+#define WM8955_DMEN_SHIFT                            0  /* DMEN */
+#define WM8955_DMEN_WIDTH                            1  /* DMEN */
+
+/*
+ * R39 (0x27) - Mono out Mix (2)
+ */
+#define WM8955_RD2MO                            0x0100  /* RD2MO */
+#define WM8955_RD2MO_MASK                       0x0100  /* RD2MO */
+#define WM8955_RD2MO_SHIFT                           8  /* RD2MO */
+#define WM8955_RD2MO_WIDTH                           1  /* RD2MO */
+#define WM8955_RI2MO                            0x0080  /* RI2MO */
+#define WM8955_RI2MO_MASK                       0x0080  /* RI2MO */
+#define WM8955_RI2MO_SHIFT                           7  /* RI2MO */
+#define WM8955_RI2MO_WIDTH                           1  /* RI2MO */
+#define WM8955_RI2MOVOL_MASK                    0x0070  /* RI2MOVOL - [6:4] */
+#define WM8955_RI2MOVOL_SHIFT                        4  /* RI2MOVOL - [6:4] */
+#define WM8955_RI2MOVOL_WIDTH                        3  /* RI2MOVOL - [6:4] */
+
+/*
+ * R40 (0x28) - LOUT2 volume
+ */
+#define WM8955_LO2VU                            0x0100  /* LO2VU */
+#define WM8955_LO2VU_MASK                       0x0100  /* LO2VU */
+#define WM8955_LO2VU_SHIFT                           8  /* LO2VU */
+#define WM8955_LO2VU_WIDTH                           1  /* LO2VU */
+#define WM8955_LO2ZC                            0x0080  /* LO2ZC */
+#define WM8955_LO2ZC_MASK                       0x0080  /* LO2ZC */
+#define WM8955_LO2ZC_SHIFT                           7  /* LO2ZC */
+#define WM8955_LO2ZC_WIDTH                           1  /* LO2ZC */
+#define WM8955_LOUT2VOL_MASK                    0x007F  /* LOUT2VOL - [6:0] */
+#define WM8955_LOUT2VOL_SHIFT                        0  /* LOUT2VOL - [6:0] */
+#define WM8955_LOUT2VOL_WIDTH                        7  /* LOUT2VOL - [6:0] */
+
+/*
+ * R41 (0x29) - ROUT2 volume
+ */
+#define WM8955_RO2VU                            0x0100  /* RO2VU */
+#define WM8955_RO2VU_MASK                       0x0100  /* RO2VU */
+#define WM8955_RO2VU_SHIFT                           8  /* RO2VU */
+#define WM8955_RO2VU_WIDTH                           1  /* RO2VU */
+#define WM8955_RO2ZC                            0x0080  /* RO2ZC */
+#define WM8955_RO2ZC_MASK                       0x0080  /* RO2ZC */
+#define WM8955_RO2ZC_SHIFT                           7  /* RO2ZC */
+#define WM8955_RO2ZC_WIDTH                           1  /* RO2ZC */
+#define WM8955_ROUT2VOL_MASK                    0x007F  /* ROUT2VOL - [6:0] */
+#define WM8955_ROUT2VOL_SHIFT                        0  /* ROUT2VOL - [6:0] */
+#define WM8955_ROUT2VOL_WIDTH                        7  /* ROUT2VOL - [6:0] */
+
+/*
+ * R42 (0x2A) - MONOOUT volume
+ */
+#define WM8955_MOZC                             0x0080  /* MOZC */
+#define WM8955_MOZC_MASK                        0x0080  /* MOZC */
+#define WM8955_MOZC_SHIFT                            7  /* MOZC */
+#define WM8955_MOZC_WIDTH                            1  /* MOZC */
+#define WM8955_MOUTVOL_MASK                     0x007F  /* MOUTVOL - [6:0] */
+#define WM8955_MOUTVOL_SHIFT                         0  /* MOUTVOL - [6:0] */
+#define WM8955_MOUTVOL_WIDTH                         7  /* MOUTVOL - [6:0] */
+
+/*
+ * R43 (0x2B) - Clocking / PLL
+ */
+#define WM8955_MCLKSEL                          0x0100  /* MCLKSEL */
+#define WM8955_MCLKSEL_MASK                     0x0100  /* MCLKSEL */
+#define WM8955_MCLKSEL_SHIFT                         8  /* MCLKSEL */
+#define WM8955_MCLKSEL_WIDTH                         1  /* MCLKSEL */
+#define WM8955_PLLOUTDIV2                       0x0020  /* PLLOUTDIV2 */
+#define WM8955_PLLOUTDIV2_MASK                  0x0020  /* PLLOUTDIV2 */
+#define WM8955_PLLOUTDIV2_SHIFT                      5  /* PLLOUTDIV2 */
+#define WM8955_PLLOUTDIV2_WIDTH                      1  /* PLLOUTDIV2 */
+#define WM8955_PLL_RB                           0x0010  /* PLL_RB */
+#define WM8955_PLL_RB_MASK                      0x0010  /* PLL_RB */
+#define WM8955_PLL_RB_SHIFT                          4  /* PLL_RB */
+#define WM8955_PLL_RB_WIDTH                          1  /* PLL_RB */
+#define WM8955_PLLEN                            0x0008  /* PLLEN */
+#define WM8955_PLLEN_MASK                       0x0008  /* PLLEN */
+#define WM8955_PLLEN_SHIFT                           3  /* PLLEN */
+#define WM8955_PLLEN_WIDTH                           1  /* PLLEN */
+
+/*
+ * R44 (0x2C) - PLL Control 1
+ */
+#define WM8955_N_MASK                           0x01E0  /* N - [8:5] */
+#define WM8955_N_SHIFT                               5  /* N - [8:5] */
+#define WM8955_N_WIDTH                               4  /* N - [8:5] */
+#define WM8955_K_21_18_MASK                     0x000F  /* K(21:18) - [3:0] */
+#define WM8955_K_21_18_SHIFT                         0  /* K(21:18) - [3:0] */
+#define WM8955_K_21_18_WIDTH                         4  /* K(21:18) - [3:0] */
+
+/*
+ * R45 (0x2D) - PLL Control 2
+ */
+#define WM8955_K_17_9_MASK                      0x01FF  /* K(17:9) - [8:0] */
+#define WM8955_K_17_9_SHIFT                          0  /* K(17:9) - [8:0] */
+#define WM8955_K_17_9_WIDTH                          9  /* K(17:9) - [8:0] */
+
+/*
+ * R46 (0x2E) - PLL Control 3
+ */
+#define WM8955_K_8_0_MASK                       0x01FF  /* K(8:0) - [8:0] */
+#define WM8955_K_8_0_SHIFT                           0  /* K(8:0) - [8:0] */
+#define WM8955_K_8_0_WIDTH                           9  /* K(8:0) - [8:0] */
+
+/*
+ * R59 (0x3B) - PLL Control 4
+ */
+#define WM8955_KEN                              0x0080  /* KEN */
+#define WM8955_KEN_MASK                         0x0080  /* KEN */
+#define WM8955_KEN_SHIFT                             7  /* KEN */
+#define WM8955_KEN_WIDTH                             1  /* KEN */
+
+#endif
diff --git a/sound/soc/codecs/wm8960.c b/sound/soc/codecs/wm8960.c
index f59703be61c8..f1e63e01b04d 100644
--- a/sound/soc/codecs/wm8960.c
+++ b/sound/soc/codecs/wm8960.c
@@ -15,6 +15,7 @@
 #include <linux/pm.h>
 #include <linux/i2c.h>
 #include <linux/platform_device.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
@@ -307,7 +308,6 @@ static int wm8960_add_widgets(struct snd_soc_codec *codec)
 
         snd_soc_dapm_add_routes(codec, audio_paths, ARRAY_SIZE(audio_paths));
 
-        snd_soc_dapm_new_widgets(codec);
         return 0;
 }
 
@@ -540,8 +540,8 @@ static int pll_factors(unsigned int source, unsigned int target,
         return 0;
 }
 
-static int wm8960_set_dai_pll(struct snd_soc_dai *codec_dai,
-                int pll_id, unsigned int freq_in, unsigned int freq_out)
+static int wm8960_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id,
+                int source, unsigned int freq_in, unsigned int freq_out)
 {
         struct snd_soc_codec *codec = codec_dai->codec;
         u16 reg;
@@ -713,17 +713,9 @@ static int wm8960_probe(struct platform_device *pdev)
         snd_soc_add_controls(codec, wm8960_snd_controls,
                              ARRAY_SIZE(wm8960_snd_controls));
         wm8960_add_widgets(codec);
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                dev_err(codec->dev, "failed to register card: %d\n", ret);
-                goto card_err;
-        }
 
         return ret;
 
-card_err:
-        snd_soc_free_pcms(socdev);
-        snd_soc_dapm_free(socdev);
 pcm_err:
         return ret;
 }
@@ -883,21 +875,6 @@ static __devexit int wm8960_i2c_remove(struct i2c_client *client)
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int wm8960_i2c_suspend(struct i2c_client *client, pm_message_t msg)
-{
-        return snd_soc_suspend_device(&client->dev);
-}
-
-static int wm8960_i2c_resume(struct i2c_client *client)
-{
-        return snd_soc_resume_device(&client->dev);
-}
-#else
-#define wm8960_i2c_suspend NULL
-#define wm8960_i2c_resume NULL
-#endif
-
 static const struct i2c_device_id wm8960_i2c_id[] = {
         { "wm8960", 0 },
         { }
@@ -911,8 +888,6 @@ static struct i2c_driver wm8960_i2c_driver = {
         },
         .probe =    wm8960_i2c_probe,
         .remove =   __devexit_p(wm8960_i2c_remove),
-        .suspend =  wm8960_i2c_suspend,
-        .resume =   wm8960_i2c_resume,
         .id_table = wm8960_i2c_id,
 };
 
diff --git a/sound/soc/codecs/wm8961.c b/sound/soc/codecs/wm8961.c
index 503032085899..50634ab76a5c 100644
--- a/sound/soc/codecs/wm8961.c
+++ b/sound/soc/codecs/wm8961.c
@@ -18,6 +18,7 @@
 #include <linux/pm.h>
 #include <linux/i2c.h>
 #include <linux/platform_device.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
@@ -986,19 +987,9 @@ static int wm8961_probe(struct platform_device *pdev)
         snd_soc_dapm_new_controls(codec, wm8961_dapm_widgets,
                                   ARRAY_SIZE(wm8961_dapm_widgets));
         snd_soc_dapm_add_routes(codec, audio_paths, ARRAY_SIZE(audio_paths));
-        snd_soc_dapm_new_widgets(codec);
-
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                dev_err(codec->dev, "failed to register card: %d\n", ret);
-                goto card_err;
-        }
 
         return ret;
 
-card_err:
-        snd_soc_free_pcms(socdev);
-        snd_soc_dapm_free(socdev);
 pcm_err:
         return ret;
 }
@@ -1032,6 +1023,9 @@ static int wm8961_resume(struct platform_device *pdev)
         int i;
 
         for (i = 0; i < codec->reg_cache_size; i++) {
+                if (reg_cache[i] == wm8961_reg_defaults[i])
+                        continue;
+
                 if (i == WM8961_SOFTWARE_RESET)
                         continue;
 
@@ -1206,21 +1200,6 @@ static __devexit int wm8961_i2c_remove(struct i2c_client *client)
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int wm8961_i2c_suspend(struct i2c_client *client, pm_message_t state)
-{
-        return snd_soc_suspend_device(&client->dev);
-}
-
-static int wm8961_i2c_resume(struct i2c_client *client)
-{
-        return snd_soc_resume_device(&client->dev);
-}
-#else
-#define wm8961_i2c_suspend NULL
-#define wm8961_i2c_resume NULL
-#endif
-
 static const struct i2c_device_id wm8961_i2c_id[] = {
         { "wm8961", 0 },
         { }
@@ -1234,8 +1213,6 @@ static struct i2c_driver wm8961_i2c_driver = {
         },
         .probe =    wm8961_i2c_probe,
         .remove =   __devexit_p(wm8961_i2c_remove),
-        .suspend =  wm8961_i2c_suspend,
-        .resume =   wm8961_i2c_resume,
         .id_table = wm8961_i2c_id,
 };
 
diff --git a/sound/soc/codecs/wm8971.c b/sound/soc/codecs/wm8971.c
index d66efb0546ea..a65b781af512 100644
--- a/sound/soc/codecs/wm8971.c
+++ b/sound/soc/codecs/wm8971.c
@@ -20,6 +20,7 @@
 #include <linux/pm.h>
 #include <linux/i2c.h>
 #include <linux/platform_device.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
@@ -338,8 +339,6 @@ static int wm8971_add_widgets(struct snd_soc_codec *codec)
 
         snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
 
-        snd_soc_dapm_new_widgets(codec);
-
         return 0;
 }
 
@@ -703,16 +702,9 @@ static int wm8971_init(struct snd_soc_device *socdev,
         snd_soc_add_controls(codec, wm8971_snd_controls,
                                 ARRAY_SIZE(wm8971_snd_controls));
         wm8971_add_widgets(codec);
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                printk(KERN_ERR "wm8971: failed to register card\n");
-                goto card_err;
-        }
+
         return ret;
 
-card_err:
-        snd_soc_free_pcms(socdev);
-        snd_soc_dapm_free(socdev);
 err:
         kfree(codec->reg_cache);
         return ret;
diff --git a/sound/soc/codecs/wm8974.c b/sound/soc/codecs/wm8974.c
index 98d663afc97d..69708c4cc004 100644
--- a/sound/soc/codecs/wm8974.c
+++ b/sound/soc/codecs/wm8974.c
@@ -18,6 +18,7 @@
 #include <linux/pm.h>
 #include <linux/i2c.h>
 #include <linux/platform_device.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
@@ -47,7 +48,7 @@ static const u16 wm8974_reg[WM8974_CACHEREGNUM] = {
 };
 
 #define WM8974_POWER1_BIASEN  0x08
-#define WM8974_POWER1_BUFIOEN 0x10
+#define WM8974_POWER1_BUFIOEN 0x04
 
 struct wm8974_priv {
         struct snd_soc_codec codec;
@@ -170,6 +171,10 @@ SOC_ENUM("Aux Mode", wm8974_auxmode),
 
 SOC_SINGLE("Capture Boost(+20dB)", WM8974_ADCBOOST,  8, 1, 0),
 SOC_SINGLE("Mono Playback Switch", WM8974_MONOMIX, 6, 1, 1),
+
+/* DAC / ADC oversampling */
+SOC_SINGLE("DAC 128x Oversampling Switch", WM8974_DAC, 8, 1, 0),
+SOC_SINGLE("ADC 128x Oversampling Switch", WM8974_ADC, 8, 1, 0),
 };
 
 /* Speaker Output Mixer */
@@ -276,41 +281,42 @@ static int wm8974_add_widgets(struct snd_soc_codec *codec)
 
         snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
 
-        snd_soc_dapm_new_widgets(codec);
         return 0;
 }
 
 struct pll_ {
-        unsigned int pre_div:4; /* prescale - 1 */
+        unsigned int pre_div:1;
         unsigned int n:4;
         unsigned int k;
 };
 
-static struct pll_ pll_div;
-
 /* The size in bits of the pll divide multiplied by 10
  * to allow rounding later */
 #define FIXED_PLL_SIZE ((1 << 24) * 10)
 
-static void pll_factors(unsigned int target, unsigned int source)
+static void pll_factors(struct pll_ *pll_div,
+                        unsigned int target, unsigned int source)
 {
         unsigned long long Kpart;
         unsigned int K, Ndiv, Nmod;
 
+        /* There is a fixed divide by 4 in the output path */
+        target *= 4;
+
         Ndiv = target / source;
         if (Ndiv < 6) {
-                source >>= 1;
-                pll_div.pre_div = 1;
+                source /= 2;
+                pll_div->pre_div = 1;
                 Ndiv = target / source;
         } else
-                pll_div.pre_div = 0;
+                pll_div->pre_div = 0;
 
         if ((Ndiv < 6) || (Ndiv > 12))
                 printk(KERN_WARNING
                         "WM8974 N value %u outwith recommended range!\n",
                         Ndiv);
 
-        pll_div.n = Ndiv;
+        pll_div->n = Ndiv;
         Nmod = target % source;
         Kpart = FIXED_PLL_SIZE * (long long)Nmod;
 
@@ -325,13 +331,14 @@ static void pll_factors(unsigned int target, unsigned int source)
         /* Move down to proper range now rounding is done */
         K /= 10;
 
-        pll_div.k = K;
+        pll_div->k = K;
 }
 
-static int wm8974_set_dai_pll(struct snd_soc_dai *codec_dai,
-                int pll_id, unsigned int freq_in, unsigned int freq_out)
+static int wm8974_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id,
+                int source, unsigned int freq_in, unsigned int freq_out)
 {
         struct snd_soc_codec *codec = codec_dai->codec;
+        struct pll_ pll_div;
         u16 reg;
 
         if (freq_in == 0 || freq_out == 0) {
@@ -345,7 +352,7 @@ static int wm8974_set_dai_pll(struct snd_soc_dai *codec_dai,
                 return 0;
         }
 
-        pll_factors(freq_out*4, freq_in);
+        pll_factors(&pll_div, freq_out, freq_in);
 
         snd_soc_write(codec, WM8974_PLLN, (pll_div.pre_div << 4) | pll_div.n);
         snd_soc_write(codec, WM8974_PLLK1, pll_div.k >> 18);
@@ -379,14 +386,6 @@ static int wm8974_set_dai_clkdiv(struct snd_soc_dai *codec_dai,
                 reg = snd_soc_read(codec, WM8974_CLOCK) & 0x11f;
                 snd_soc_write(codec, WM8974_CLOCK, reg | div);
                 break;
-        case WM8974_ADCCLK:
-                reg = snd_soc_read(codec, WM8974_ADC) & 0x1f7;
-                snd_soc_write(codec, WM8974_ADC, reg | div);
-                break;
-        case WM8974_DACCLK:
-                reg = snd_soc_read(codec, WM8974_DAC) & 0x1f7;
-                snd_soc_write(codec, WM8974_DAC, reg | div);
-                break;
         case WM8974_BCLKDIV:
                 reg = snd_soc_read(codec, WM8974_CLOCK) & 0x1e3;
                 snd_soc_write(codec, WM8974_CLOCK, reg | div);
@@ -480,23 +479,23 @@ static int wm8974_pcm_hw_params(struct snd_pcm_substream *substream,
 
         /* filter coefficient */
         switch (params_rate(params)) {
-        case SNDRV_PCM_RATE_8000:
+        case 8000:
                 adn |= 0x5 << 1;
                 break;
-        case SNDRV_PCM_RATE_11025:
+        case 11025:
                 adn |= 0x4 << 1;
                 break;
-        case SNDRV_PCM_RATE_16000:
+        case 16000:
                 adn |= 0x3 << 1;
                 break;
-        case SNDRV_PCM_RATE_22050:
+        case 22050:
                 adn |= 0x2 << 1;
                 break;
-        case SNDRV_PCM_RATE_32000:
+        case 32000:
                 adn |= 0x1 << 1;
                 break;
-        case SNDRV_PCM_RATE_44100:
-        case SNDRV_PCM_RATE_48000:
+        case 44100:
+        case 48000:
                 break;
         }
 
@@ -638,17 +637,9 @@ static int wm8974_probe(struct platform_device *pdev)
         snd_soc_add_controls(codec, wm8974_snd_controls,
                              ARRAY_SIZE(wm8974_snd_controls));
         wm8974_add_widgets(codec);
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                dev_err(codec->dev, "failed to register card: %d\n", ret);
-                goto card_err;
-        }
 
         return ret;
 
-card_err:
-        snd_soc_free_pcms(socdev);
-        snd_soc_dapm_free(socdev);
 pcm_err:
         return ret;
 }
diff --git a/sound/soc/codecs/wm8974.h b/sound/soc/codecs/wm8974.h
index 98de9562d4d2..896a7f0f3fc4 100644
--- a/sound/soc/codecs/wm8974.h
+++ b/sound/soc/codecs/wm8974.h
@@ -57,17 +57,7 @@
 /* Clock divider Id's */
 #define WM8974_OPCLKDIV         0
 #define WM8974_MCLKDIV          1
-#define WM8974_ADCCLK           2
-#define WM8974_DACCLK           3
-#define WM8974_BCLKDIV          4
-
-/* DAC clock dividers */
-#define WM8974_DACCLK_F2        (1 << 3)
-#define WM8974_DACCLK_F4        (0 << 3)
-
-/* ADC clock dividers */
-#define WM8974_ADCCLK_F2        (1 << 3)
-#define WM8974_ADCCLK_F4        (0 << 3)
+#define WM8974_BCLKDIV          2
 
 /* PLL Out dividers */
 #define WM8974_OPCLKDIV_1       (0 << 4)
diff --git a/sound/soc/codecs/wm8978.c b/sound/soc/codecs/wm8978.c
new file mode 100644
index 000000000000..526f56b09066
--- /dev/null
+++ b/sound/soc/codecs/wm8978.c
@@ -0,0 +1,1150 @@
+/*
+ * wm8978.c  --  WM8978 ALSA SoC Audio Codec driver
+ *
+ * Copyright (C) 2009-2010 Guennadi Liakhovetski <g.liakhovetski@gmx.de>
+ * Copyright (C) 2007 Carlos Munoz <carlos@kenati.com>
+ * Copyright 2006-2009 Wolfson Microelectronics PLC.
+ * Based on wm8974 and wm8990 by Liam Girdwood <lrg@slimlogic.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/pm.h>
+#include <linux/i2c.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+#include <sound/initval.h>
+#include <sound/tlv.h>
+#include <asm/div64.h>
+
+#include "wm8978.h"
+
+static struct snd_soc_codec *wm8978_codec;
+
+/* wm8978 register cache. Note that register 0 is not included in the cache. */
+static const u16 wm8978_reg[WM8978_CACHEREGNUM] = {
+        0x0000, 0x0000, 0x0000, 0x0000, /* 0x00...0x03 */
+        0x0050, 0x0000, 0x0140, 0x0000, /* 0x04...0x07 */
+        0x0000, 0x0000, 0x0000, 0x00ff, /* 0x08...0x0b */
+        0x00ff, 0x0000, 0x0100, 0x00ff, /* 0x0c...0x0f */
+        0x00ff, 0x0000, 0x012c, 0x002c, /* 0x10...0x13 */
+        0x002c, 0x002c, 0x002c, 0x0000, /* 0x14...0x17 */
+        0x0032, 0x0000, 0x0000, 0x0000, /* 0x18...0x1b */
+        0x0000, 0x0000, 0x0000, 0x0000, /* 0x1c...0x1f */
+        0x0038, 0x000b, 0x0032, 0x0000, /* 0x20...0x23 */
+        0x0008, 0x000c, 0x0093, 0x00e9, /* 0x24...0x27 */
+        0x0000, 0x0000, 0x0000, 0x0000, /* 0x28...0x2b */
+        0x0033, 0x0010, 0x0010, 0x0100, /* 0x2c...0x2f */
+        0x0100, 0x0002, 0x0001, 0x0001, /* 0x30...0x33 */
+        0x0039, 0x0039, 0x0039, 0x0039, /* 0x34...0x37 */
+        0x0001, 0x0001,                 /* 0x38...0x3b */
+};
+
+/* codec private data */
+struct wm8978_priv {
+        struct snd_soc_codec codec;
+        unsigned int f_pllout;
+        unsigned int f_mclk;
+        unsigned int f_256fs;
+        unsigned int f_opclk;
+        int mclk_idx;
+        enum wm8978_sysclk_src sysclk;
+        u16 reg_cache[WM8978_CACHEREGNUM];
+};
+
+static const char *wm8978_companding[] = {"Off", "NC", "u-law", "A-law"};
+static const char *wm8978_eqmode[] = {"Capture", "Playback"};
+static const char *wm8978_bw[] = {"Narrow", "Wide"};
+static const char *wm8978_eq1[] = {"80Hz", "105Hz", "135Hz", "175Hz"};
+static const char *wm8978_eq2[] = {"230Hz", "300Hz", "385Hz", "500Hz"};
+static const char *wm8978_eq3[] = {"650Hz", "850Hz", "1.1kHz", "1.4kHz"};
+static const char *wm8978_eq4[] = {"1.8kHz", "2.4kHz", "3.2kHz", "4.1kHz"};
+static const char *wm8978_eq5[] = {"5.3kHz", "6.9kHz", "9kHz", "11.7kHz"};
+static const char *wm8978_alc3[] = {"ALC", "Limiter"};
+static const char *wm8978_alc1[] = {"Off", "Right", "Left", "Both"};
+
+static const SOC_ENUM_SINGLE_DECL(adc_compand, WM8978_COMPANDING_CONTROL, 1,
+                                  wm8978_companding);
+static const SOC_ENUM_SINGLE_DECL(dac_compand, WM8978_COMPANDING_CONTROL, 3,
+                                  wm8978_companding);
+static const SOC_ENUM_SINGLE_DECL(eqmode, WM8978_EQ1, 8, wm8978_eqmode);
+static const SOC_ENUM_SINGLE_DECL(eq1, WM8978_EQ1, 5, wm8978_eq1);
+static const SOC_ENUM_SINGLE_DECL(eq2bw, WM8978_EQ2, 8, wm8978_bw);
+static const SOC_ENUM_SINGLE_DECL(eq2, WM8978_EQ2, 5, wm8978_eq2);
+static const SOC_ENUM_SINGLE_DECL(eq3bw, WM8978_EQ3, 8, wm8978_bw);
+static const SOC_ENUM_SINGLE_DECL(eq3, WM8978_EQ3, 5, wm8978_eq3);
+static const SOC_ENUM_SINGLE_DECL(eq4bw, WM8978_EQ4, 8, wm8978_bw);
+static const SOC_ENUM_SINGLE_DECL(eq4, WM8978_EQ4, 5, wm8978_eq4);
+static const SOC_ENUM_SINGLE_DECL(eq5, WM8978_EQ5, 5, wm8978_eq5);
+static const SOC_ENUM_SINGLE_DECL(alc3, WM8978_ALC_CONTROL_3, 8, wm8978_alc3);
+static const SOC_ENUM_SINGLE_DECL(alc1, WM8978_ALC_CONTROL_1, 7, wm8978_alc1);
+
+static const DECLARE_TLV_DB_SCALE(digital_tlv, -12750, 50, 1);
+static const DECLARE_TLV_DB_SCALE(eq_tlv, -1200, 100, 0);
+static const DECLARE_TLV_DB_SCALE(inpga_tlv, -1200, 75, 0);
+static const DECLARE_TLV_DB_SCALE(spk_tlv, -5700, 100, 0);
+static const DECLARE_TLV_DB_SCALE(boost_tlv, -1500, 300, 1);
+
+static const struct snd_kcontrol_new wm8978_snd_controls[] = {
+
+        SOC_SINGLE("Digital Loopback Switch",
+                WM8978_COMPANDING_CONTROL, 0, 1, 0),
+
+        SOC_ENUM("ADC Companding", adc_compand),
+        SOC_ENUM("DAC Companding", dac_compand),
+
+        SOC_DOUBLE("DAC Inversion Switch", WM8978_DAC_CONTROL, 0, 1, 1, 0),
+
+        SOC_DOUBLE_R_TLV("PCM Volume",
+                WM8978_LEFT_DAC_DIGITAL_VOLUME, WM8978_RIGHT_DAC_DIGITAL_VOLUME,
+                0, 255, 0, digital_tlv),
+
+        SOC_SINGLE("High Pass Filter Switch", WM8978_ADC_CONTROL, 8, 1, 0),
+        SOC_SINGLE("High Pass Cut Off", WM8978_ADC_CONTROL, 4, 7, 0),
+        SOC_DOUBLE("ADC Inversion Switch", WM8978_ADC_CONTROL, 0, 1, 1, 0),
+
+        SOC_DOUBLE_R_TLV("ADC Volume",
+                WM8978_LEFT_ADC_DIGITAL_VOLUME, WM8978_RIGHT_ADC_DIGITAL_VOLUME,
+                0, 255, 0, digital_tlv),
+
+        SOC_ENUM("Equaliser Function", eqmode),
+        SOC_ENUM("EQ1 Cut Off", eq1),
+        SOC_SINGLE_TLV("EQ1 Volume", WM8978_EQ1,  0, 24, 1, eq_tlv),
+
+        SOC_ENUM("Equaliser EQ2 Bandwith", eq2bw),
+        SOC_ENUM("EQ2 Cut Off", eq2),
+        SOC_SINGLE_TLV("EQ2 Volume", WM8978_EQ2,  0, 24, 1, eq_tlv),
+
+        SOC_ENUM("Equaliser EQ3 Bandwith", eq3bw),
+        SOC_ENUM("EQ3 Cut Off", eq3),
+        SOC_SINGLE_TLV("EQ3 Volume", WM8978_EQ3,  0, 24, 1, eq_tlv),
+
+        SOC_ENUM("Equaliser EQ4 Bandwith", eq4bw),
+        SOC_ENUM("EQ4 Cut Off", eq4),
+        SOC_SINGLE_TLV("EQ4 Volume", WM8978_EQ4,  0, 24, 1, eq_tlv),
+
+        SOC_ENUM("EQ5 Cut Off", eq5),
+        SOC_SINGLE_TLV("EQ5 Volume", WM8978_EQ5, 0, 24, 1, eq_tlv),
+
+        SOC_SINGLE("DAC Playback Limiter Switch",
+                WM8978_DAC_LIMITER_1, 8, 1, 0),
+        SOC_SINGLE("DAC Playback Limiter Decay",
+                WM8978_DAC_LIMITER_1, 4, 15, 0),
+        SOC_SINGLE("DAC Playback Limiter Attack",
+                WM8978_DAC_LIMITER_1, 0, 15, 0),
+
+        SOC_SINGLE("DAC Playback Limiter Threshold",
+                WM8978_DAC_LIMITER_2, 4, 7, 0),
+        SOC_SINGLE("DAC Playback Limiter Boost",
+                WM8978_DAC_LIMITER_2, 0, 15, 0),
+
+        SOC_ENUM("ALC Enable Switch", alc1),
+        SOC_SINGLE("ALC Capture Min Gain", WM8978_ALC_CONTROL_1, 0, 7, 0),
+        SOC_SINGLE("ALC Capture Max Gain", WM8978_ALC_CONTROL_1, 3, 7, 0),
+
+        SOC_SINGLE("ALC Capture Hold", WM8978_ALC_CONTROL_2, 4, 7, 0),
+        SOC_SINGLE("ALC Capture Target", WM8978_ALC_CONTROL_2, 0, 15, 0),
+
+        SOC_ENUM("ALC Capture Mode", alc3),
+        SOC_SINGLE("ALC Capture Decay", WM8978_ALC_CONTROL_3, 4, 15, 0),
+        SOC_SINGLE("ALC Capture Attack", WM8978_ALC_CONTROL_3, 0, 15, 0),
+
+        SOC_SINGLE("ALC Capture Noise Gate Switch", WM8978_NOISE_GATE, 3, 1, 0),
+        SOC_SINGLE("ALC Capture Noise Gate Threshold",
+                WM8978_NOISE_GATE, 0, 7, 0),
+
+        SOC_DOUBLE_R("Capture PGA ZC Switch",
+                WM8978_LEFT_INP_PGA_CONTROL, WM8978_RIGHT_INP_PGA_CONTROL,
+                7, 1, 0),
+
+        /* OUT1 - Headphones */
+        SOC_DOUBLE_R("Headphone Playback ZC Switch",
+                WM8978_LOUT1_HP_CONTROL, WM8978_ROUT1_HP_CONTROL, 7, 1, 0),
+
+        SOC_DOUBLE_R_TLV("Headphone Playback Volume",
+                WM8978_LOUT1_HP_CONTROL, WM8978_ROUT1_HP_CONTROL,
+                0, 63, 0, spk_tlv),
+
+        /* OUT2 - Speakers */
+        SOC_DOUBLE_R("Speaker Playback ZC Switch",
+                WM8978_LOUT2_SPK_CONTROL, WM8978_ROUT2_SPK_CONTROL, 7, 1, 0),
+
+        SOC_DOUBLE_R_TLV("Speaker Playback Volume",
+                WM8978_LOUT2_SPK_CONTROL, WM8978_ROUT2_SPK_CONTROL,
+                0, 63, 0, spk_tlv),
+
+        /* OUT3/4 - Line Output */
+        SOC_DOUBLE_R("Line Playback Switch",
+                WM8978_OUT3_MIXER_CONTROL, WM8978_OUT4_MIXER_CONTROL, 6, 1, 1),
+
+        /* Mixer #3: Boost (Input) mixer */
+        SOC_DOUBLE_R("PGA Boost (+20dB)",
+                WM8978_LEFT_ADC_BOOST_CONTROL, WM8978_RIGHT_ADC_BOOST_CONTROL,
+                8, 1, 0),
+        SOC_DOUBLE_R_TLV("L2/R2 Boost Volume",
+                WM8978_LEFT_ADC_BOOST_CONTROL, WM8978_RIGHT_ADC_BOOST_CONTROL,
+                4, 7, 0, boost_tlv),
+        SOC_DOUBLE_R_TLV("Aux Boost Volume",
+                WM8978_LEFT_ADC_BOOST_CONTROL, WM8978_RIGHT_ADC_BOOST_CONTROL,
+                0, 7, 0, boost_tlv),
+
+        /* Input PGA volume */
+        SOC_DOUBLE_R_TLV("Input PGA Volume",
+                WM8978_LEFT_INP_PGA_CONTROL, WM8978_RIGHT_INP_PGA_CONTROL,
+                0, 63, 0, inpga_tlv),
+
+        /* Headphone */
+        SOC_DOUBLE_R("Headphone Switch",
+                WM8978_LOUT1_HP_CONTROL, WM8978_ROUT1_HP_CONTROL, 6, 1, 1),
+
+        /* Speaker */
+        SOC_DOUBLE_R("Speaker Switch",
+                WM8978_LOUT2_SPK_CONTROL, WM8978_ROUT2_SPK_CONTROL, 6, 1, 1),
+
+        /* DAC / ADC oversampling */
+        SOC_SINGLE("DAC 128x Oversampling Switch", WM8978_DAC_CONTROL, 8, 1, 0),
+        SOC_SINGLE("ADC 128x Oversampling Switch", WM8978_ADC_CONTROL, 8, 1, 0),
+};
+
+/* Mixer #1: Output (OUT1, OUT2) Mixer: mix AUX, Input mixer output and DAC */
+static const struct snd_kcontrol_new wm8978_left_out_mixer[] = {
+        SOC_DAPM_SINGLE("Line Bypass Switch", WM8978_LEFT_MIXER_CONTROL, 1, 1, 0),
+        SOC_DAPM_SINGLE("Aux Playback Switch", WM8978_LEFT_MIXER_CONTROL, 5, 1, 0),
+        SOC_DAPM_SINGLE("PCM Playback Switch", WM8978_LEFT_MIXER_CONTROL, 0, 1, 0),
+};
+
+static const struct snd_kcontrol_new wm8978_right_out_mixer[] = {
+        SOC_DAPM_SINGLE("Line Bypass Switch", WM8978_RIGHT_MIXER_CONTROL, 1, 1, 0),
+        SOC_DAPM_SINGLE("Aux Playback Switch", WM8978_RIGHT_MIXER_CONTROL, 5, 1, 0),
+        SOC_DAPM_SINGLE("PCM Playback Switch", WM8978_RIGHT_MIXER_CONTROL, 0, 1, 0),
+};
+
+/* OUT3/OUT4 Mixer not implemented */
+
+/* Mixer #2: Input PGA Mute */
+static const struct snd_kcontrol_new wm8978_left_input_mixer[] = {
+        SOC_DAPM_SINGLE("L2 Switch", WM8978_INPUT_CONTROL, 2, 1, 0),
+        SOC_DAPM_SINGLE("MicN Switch", WM8978_INPUT_CONTROL, 1, 1, 0),
+        SOC_DAPM_SINGLE("MicP Switch", WM8978_INPUT_CONTROL, 0, 1, 0),
+};
+static const struct snd_kcontrol_new wm8978_right_input_mixer[] = {
+        SOC_DAPM_SINGLE("R2 Switch", WM8978_INPUT_CONTROL, 6, 1, 0),
+        SOC_DAPM_SINGLE("MicN Switch", WM8978_INPUT_CONTROL, 5, 1, 0),
+        SOC_DAPM_SINGLE("MicP Switch", WM8978_INPUT_CONTROL, 4, 1, 0),
+};
+
+static const struct snd_soc_dapm_widget wm8978_dapm_widgets[] = {
+        SND_SOC_DAPM_DAC("Left DAC", "Left HiFi Playback",
+                         WM8978_POWER_MANAGEMENT_3, 0, 0),
+        SND_SOC_DAPM_DAC("Right DAC", "Right HiFi Playback",
+                         WM8978_POWER_MANAGEMENT_3, 1, 0),
+        SND_SOC_DAPM_ADC("Left ADC", "Left HiFi Capture",
+                         WM8978_POWER_MANAGEMENT_2, 0, 0),
+        SND_SOC_DAPM_ADC("Right ADC", "Right HiFi Capture",
+                         WM8978_POWER_MANAGEMENT_2, 1, 0),
+
+        /* Mixer #1: OUT1,2 */
+        SOC_MIXER_ARRAY("Left Output Mixer", WM8978_POWER_MANAGEMENT_3,
+                        2, 0, wm8978_left_out_mixer),
+        SOC_MIXER_ARRAY("Right Output Mixer", WM8978_POWER_MANAGEMENT_3,
+                        3, 0, wm8978_right_out_mixer),
+
+        SOC_MIXER_ARRAY("Left Input Mixer", WM8978_POWER_MANAGEMENT_2,
+                        2, 0, wm8978_left_input_mixer),
+        SOC_MIXER_ARRAY("Right Input Mixer", WM8978_POWER_MANAGEMENT_2,
+                        3, 0, wm8978_right_input_mixer),
+
+        SND_SOC_DAPM_PGA("Left Boost Mixer", WM8978_POWER_MANAGEMENT_2,
+                         4, 0, NULL, 0),
+        SND_SOC_DAPM_PGA("Right Boost Mixer", WM8978_POWER_MANAGEMENT_2,
+                         5, 0, NULL, 0),
+
+        SND_SOC_DAPM_PGA("Left Capture PGA", WM8978_LEFT_INP_PGA_CONTROL,
+                         6, 1, NULL, 0),
+        SND_SOC_DAPM_PGA("Right Capture PGA", WM8978_RIGHT_INP_PGA_CONTROL,
+                         6, 1, NULL, 0),
+
+        SND_SOC_DAPM_PGA("Left Headphone Out", WM8978_POWER_MANAGEMENT_2,
+                         7, 0, NULL, 0),
+        SND_SOC_DAPM_PGA("Right Headphone Out", WM8978_POWER_MANAGEMENT_2,
+                         8, 0, NULL, 0),
+
+        SND_SOC_DAPM_PGA("Left Speaker Out", WM8978_POWER_MANAGEMENT_3,
+                         6, 0, NULL, 0),
+        SND_SOC_DAPM_PGA("Right Speaker Out", WM8978_POWER_MANAGEMENT_3,
+                         5, 0, NULL, 0),
+
+        SND_SOC_DAPM_MIXER("OUT4 VMID", WM8978_POWER_MANAGEMENT_3,
+                           8, 0, NULL, 0),
+
+        SND_SOC_DAPM_MICBIAS("Mic Bias", WM8978_POWER_MANAGEMENT_1, 4, 0),
+
+        SND_SOC_DAPM_INPUT("LMICN"),
+        SND_SOC_DAPM_INPUT("LMICP"),
+        SND_SOC_DAPM_INPUT("RMICN"),
+        SND_SOC_DAPM_INPUT("RMICP"),
+        SND_SOC_DAPM_INPUT("LAUX"),
+        SND_SOC_DAPM_INPUT("RAUX"),
+        SND_SOC_DAPM_INPUT("L2"),
+        SND_SOC_DAPM_INPUT("R2"),
+        SND_SOC_DAPM_OUTPUT("LHP"),
+        SND_SOC_DAPM_OUTPUT("RHP"),
+        SND_SOC_DAPM_OUTPUT("LSPK"),
+        SND_SOC_DAPM_OUTPUT("RSPK"),
+};
+
+static const struct snd_soc_dapm_route audio_map[] = {
+        /* Output mixer */
+        {"Right Output Mixer", "PCM Playback Switch", "Right DAC"},
+        {"Right Output Mixer", "Aux Playback Switch", "RAUX"},
+        {"Right Output Mixer", "Line Bypass Switch", "Right Boost Mixer"},
+
+        {"Left Output Mixer", "PCM Playback Switch", "Left DAC"},
+        {"Left Output Mixer", "Aux Playback Switch", "LAUX"},
+        {"Left Output Mixer", "Line Bypass Switch", "Left Boost Mixer"},
+
+        /* Outputs */
+        {"Right Headphone Out", NULL, "Right Output Mixer"},
+        {"RHP", NULL, "Right Headphone Out"},
+
+        {"Left Headphone Out", NULL, "Left Output Mixer"},
+        {"LHP", NULL, "Left Headphone Out"},
+
+        {"Right Speaker Out", NULL, "Right Output Mixer"},
+        {"RSPK", NULL, "Right Speaker Out"},
+
+        {"Left Speaker Out", NULL, "Left Output Mixer"},
+        {"LSPK", NULL, "Left Speaker Out"},
+
+        /* Boost Mixer */
+        {"Right ADC", NULL, "Right Boost Mixer"},
+
+        {"Right Boost Mixer", NULL, "RAUX"},
+        {"Right Boost Mixer", NULL, "Right Capture PGA"},
+        {"Right Boost Mixer", NULL, "R2"},
+
+        {"Left ADC", NULL, "Left Boost Mixer"},
+
+        {"Left Boost Mixer", NULL, "LAUX"},
+        {"Left Boost Mixer", NULL, "Left Capture PGA"},
+        {"Left Boost Mixer", NULL, "L2"},
+
+        /* Input PGA */
+        {"Right Capture PGA", NULL, "Right Input Mixer"},
+        {"Left Capture PGA", NULL, "Left Input Mixer"},
+
+        {"Right Input Mixer", "R2 Switch", "R2"},
+        {"Right Input Mixer", "MicN Switch", "RMICN"},
+        {"Right Input Mixer", "MicP Switch", "RMICP"},
+
+        {"Left Input Mixer", "L2 Switch", "L2"},
+        {"Left Input Mixer", "MicN Switch", "LMICN"},
+        {"Left Input Mixer", "MicP Switch", "LMICP"},
+};
+
+static int wm8978_add_widgets(struct snd_soc_codec *codec)
+{
+        snd_soc_dapm_new_controls(codec, wm8978_dapm_widgets,
+                                  ARRAY_SIZE(wm8978_dapm_widgets));
+
+        /* set up the WM8978 audio map */
+        snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
+
+        return 0;
+}
+
+/* PLL divisors */
+struct wm8978_pll_div {
+        u32 k;
+        u8 n;
+        u8 div2;
+};
+
+#define FIXED_PLL_SIZE (1 << 24)
+
+static void pll_factors(struct wm8978_pll_div *pll_div, unsigned int target,
+                        unsigned int source)
+{
+        u64 k_part;
+        unsigned int k, n_div, n_mod;
+
+        n_div = target / source;
+        if (n_div < 6) {
+                source >>= 1;
+                pll_div->div2 = 1;
+                n_div = target / source;
+        } else {
+                pll_div->div2 = 0;
+        }
+
+        if (n_div < 6 || n_div > 12)
+                dev_warn(wm8978_codec->dev,
+                         "WM8978 N value exceeds recommended range! N = %u\n",
+                         n_div);
+
+        pll_div->n = n_div;
+        n_mod = target - source * n_div;
+        k_part = FIXED_PLL_SIZE * (long long)n_mod + source / 2;
+
+        do_div(k_part, source);
+
+        k = k_part & 0xFFFFFFFF;
+
+        pll_div->k = k;
+}
+
+/* MCLK dividers */
+static const int mclk_numerator[]       = {1, 3, 2, 3, 4, 6, 8, 12};
+static const int mclk_denominator[]     = {1, 2, 1, 1, 1, 1, 1, 1};
+
+/*
+ * find index >= idx, such that, for a given f_out,
+ * 3 * f_mclk / 4 <= f_PLLOUT < 13 * f_mclk / 4
+ * f_out can be f_256fs or f_opclk, currently only used for f_256fs. Can be
+ * generalised for f_opclk with suitable coefficient arrays, but currently
+ * the OPCLK divisor is calculated directly, not iteratively.
+ */
+static int wm8978_enum_mclk(unsigned int f_out, unsigned int f_mclk,
+                            unsigned int *f_pllout)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(mclk_numerator); i++) {
+                unsigned int f_pllout_x4 = 4 * f_out * mclk_numerator[i] /
+                        mclk_denominator[i];
+                if (3 * f_mclk <= f_pllout_x4 && f_pllout_x4 < 13 * f_mclk) {
+                        *f_pllout = f_pllout_x4 / 4;
+                        return i;
+                }
+        }
+
+        return -EINVAL;
+}
+
+/*
+ * Calculate internal frequencies and dividers, according to Figure 40
+ * "PLL and Clock Select Circuit" in WM8978 datasheet Rev. 2.6
+ */
+static int wm8978_configure_pll(struct snd_soc_codec *codec)
+{
+        struct wm8978_priv *wm8978 = codec->private_data;
+        struct wm8978_pll_div pll_div;
+        unsigned int f_opclk = wm8978->f_opclk, f_mclk = wm8978->f_mclk,
+                f_256fs = wm8978->f_256fs;
+        unsigned int f2;
+
+        if (!f_mclk)
+                return -EINVAL;
+
+        if (f_opclk) {
+                unsigned int opclk_div;
+                /* Cannot set up MCLK divider now, do later */
+                wm8978->mclk_idx = -1;
+
+                /*
+                 * The user needs OPCLK. Choose OPCLKDIV to put
+                 * 6 <= R = f2 / f1 < 13, 1 <= OPCLKDIV <= 4.
+                 * f_opclk = f_mclk * prescale * R / 4 / OPCLKDIV, where
+                 * prescale = 1, or prescale = 2. Prescale is calculated inside
+                 * pll_factors(). We have to select f_PLLOUT, such that
+                 * f_mclk * 3 / 4 <= f_PLLOUT < f_mclk * 13 / 4. Must be
+                 * f_mclk * 3 / 16 <= f_opclk < f_mclk * 13 / 4.
+                 */
+                if (16 * f_opclk < 3 * f_mclk || 4 * f_opclk >= 13 * f_mclk)
+                        return -EINVAL;
+
+                if (4 * f_opclk < 3 * f_mclk)
+                        /* Have to use OPCLKDIV */
+                        opclk_div = (3 * f_mclk / 4 + f_opclk - 1) / f_opclk;
+                else
+                        opclk_div = 1;
+
+                dev_dbg(codec->dev, "%s: OPCLKDIV=%d\n", __func__, opclk_div);
+
+                snd_soc_update_bits(codec, WM8978_GPIO_CONTROL, 0x30,
+                                    (opclk_div - 1) << 4);
+
+                wm8978->f_pllout = f_opclk * opclk_div;
+        } else if (f_256fs) {
+                /*
+                 * Not using OPCLK, but PLL is used for the codec, choose R:
+                 * 6 <= R = f2 / f1 < 13, to put 1 <= MCLKDIV <= 12.
+                 * f_256fs = f_mclk * prescale * R / 4 / MCLKDIV, where
+                 * prescale = 1, or prescale = 2. Prescale is calculated inside
+                 * pll_factors(). We have to select f_PLLOUT, such that
+                 * f_mclk * 3 / 4 <= f_PLLOUT < f_mclk * 13 / 4. Must be
+                 * f_mclk * 3 / 48 <= f_256fs < f_mclk * 13 / 4. This means MCLK
+                 * must be 3.781MHz <= f_MCLK <= 32.768MHz
+                 */
+                int idx = wm8978_enum_mclk(f_256fs, f_mclk, &wm8978->f_pllout);
+                if (idx < 0)
+                        return idx;
+
+                wm8978->mclk_idx = idx;
+
+                /* GPIO1 into default mode as input - before configuring PLL */
+                snd_soc_update_bits(codec, WM8978_GPIO_CONTROL, 7, 0);
+        } else {
+                return -EINVAL;
+        }
+
+        f2 = wm8978->f_pllout * 4;
+
+        dev_dbg(codec->dev, "%s: f_MCLK=%uHz, f_PLLOUT=%uHz\n", __func__,
+                wm8978->f_mclk, wm8978->f_pllout);
+
+        pll_factors(&pll_div, f2, wm8978->f_mclk);
+
+        dev_dbg(codec->dev, "%s: calculated PLL N=0x%x, K=0x%x, div2=%d\n",
+                __func__, pll_div.n, pll_div.k, pll_div.div2);
+
+        /* Turn PLL off for configuration... */
+        snd_soc_update_bits(codec, WM8978_POWER_MANAGEMENT_1, 0x20, 0);
+
+        snd_soc_write(codec, WM8978_PLL_N, (pll_div.div2 << 4) | pll_div.n);
+        snd_soc_write(codec, WM8978_PLL_K1, pll_div.k >> 18);
+        snd_soc_write(codec, WM8978_PLL_K2, (pll_div.k >> 9) & 0x1ff);
+        snd_soc_write(codec, WM8978_PLL_K3, pll_div.k & 0x1ff);
+
+        /* ...and on again */
+        snd_soc_update_bits(codec, WM8978_POWER_MANAGEMENT_1, 0x20, 0x20);
+
+        if (f_opclk)
+                /* Output PLL (OPCLK) to GPIO1 */
+                snd_soc_update_bits(codec, WM8978_GPIO_CONTROL, 7, 4);
+
+        return 0;
+}
+
+/*
+ * Configure WM8978 clock dividers.
+ */
+static int wm8978_set_dai_clkdiv(struct snd_soc_dai *codec_dai,
+                                 int div_id, int div)
+{
+        struct snd_soc_codec *codec = codec_dai->codec;
+        struct wm8978_priv *wm8978 = codec->private_data;
+        int ret = 0;
+
+        switch (div_id) {
+        case WM8978_OPCLKRATE:
+                wm8978->f_opclk = div;
+
+                if (wm8978->f_mclk)
+                        /*
+                         * We know the MCLK frequency, the user has requested
+                         * OPCLK, configure the PLL based on that and start it
+                         * and OPCLK immediately. We will configure PLL to match
+                         * user-requested OPCLK frquency as good as possible.
+                         * In fact, it is likely, that matching the sampling
+                         * rate, when it becomes known, is more important, and
+                         * we will not be reconfiguring PLL then, because we
+                         * must not interrupt OPCLK. But it should be fine,
+                         * because typically the user will request OPCLK to run
+                         * at 256fs or 512fs, and for these cases we will also
+                         * find an exact MCLK divider configuration - it will
+                         * be equal to or double the OPCLK divisor.
+                         */
+                        ret = wm8978_configure_pll(codec);
+                break;
+        case WM8978_BCLKDIV:
+                if (div & ~0x1c)
+                        return -EINVAL;
+                snd_soc_update_bits(codec, WM8978_CLOCKING, 0x1c, div);
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        dev_dbg(codec->dev, "%s: ID %d, value %u\n", __func__, div_id, div);
+
+        return ret;
+}
+
+/*
+ * @freq:       when .set_pll() us not used, freq is codec MCLK input frequency
+ */
+static int wm8978_set_dai_sysclk(struct snd_soc_dai *codec_dai, int clk_id,
+                                 unsigned int freq, int dir)
+{
+        struct snd_soc_codec *codec = codec_dai->codec;
+        struct wm8978_priv *wm8978 = codec->private_data;
+        int ret = 0;
+
+        dev_dbg(codec->dev, "%s: ID %d, freq %u\n", __func__, clk_id, freq);
+
+        if (freq) {
+                wm8978->f_mclk = freq;
+
+                /* Even if MCLK is used for system clock, might have to drive OPCLK */
+                if (wm8978->f_opclk)
+                        ret = wm8978_configure_pll(codec);
+
+                /* Our sysclk is fixed to 256 * fs, will configure in .hw_params()  */
+
+                if (!ret)
+                        wm8978->sysclk = clk_id;
+        }
+
+        if (wm8978->sysclk == WM8978_PLL && (!freq || clk_id == WM8978_MCLK)) {
+                /* Clock CODEC directly from MCLK */
+                snd_soc_update_bits(codec, WM8978_CLOCKING, 0x100, 0);
+
+                /* GPIO1 into default mode as input - before configuring PLL */
+                snd_soc_update_bits(codec, WM8978_GPIO_CONTROL, 7, 0);
+
+                /* Turn off PLL */
+                snd_soc_update_bits(codec, WM8978_POWER_MANAGEMENT_1, 0x20, 0);
+                wm8978->sysclk = WM8978_MCLK;
+                wm8978->f_pllout = 0;
+                wm8978->f_opclk = 0;
+        }
+
+        return ret;
+}
+
+/*
+ * Set ADC and Voice DAC format.
+ */
+static int wm8978_set_dai_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt)
+{
+        struct snd_soc_codec *codec = codec_dai->codec;
+        /*
+         * BCLK polarity mask = 0x100, LRC clock polarity mask = 0x80,
+         * Data Format mask = 0x18: all will be calculated anew
+         */
+        u16 iface = snd_soc_read(codec, WM8978_AUDIO_INTERFACE) & ~0x198;
+        u16 clk = snd_soc_read(codec, WM8978_CLOCKING);
+
+        dev_dbg(codec->dev, "%s\n", __func__);
+
+        /* set master/slave audio interface */
+        switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
+        case SND_SOC_DAIFMT_CBM_CFM:
+                clk |= 1;
+                break;
+        case SND_SOC_DAIFMT_CBS_CFS:
+                clk &= ~1;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        /* interface format */
+        switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
+        case SND_SOC_DAIFMT_I2S:
+                iface |= 0x10;
+                break;
+        case SND_SOC_DAIFMT_RIGHT_J:
+                break;
+        case SND_SOC_DAIFMT_LEFT_J:
+                iface |= 0x8;
+                break;
+        case SND_SOC_DAIFMT_DSP_A:
+                iface |= 0x18;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        /* clock inversion */
+        switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
+        case SND_SOC_DAIFMT_NB_NF:
+                break;
+        case SND_SOC_DAIFMT_IB_IF:
+                iface |= 0x180;
+                break;
+        case SND_SOC_DAIFMT_IB_NF:
+                iface |= 0x100;
+                break;
+        case SND_SOC_DAIFMT_NB_IF:
+                iface |= 0x80;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        snd_soc_write(codec, WM8978_AUDIO_INTERFACE, iface);
+        snd_soc_write(codec, WM8978_CLOCKING, clk);
+
+        return 0;
+}
+
+/*
+ * Set PCM DAI bit size and sample rate.
+ */
+static int wm8978_hw_params(struct snd_pcm_substream *substream,
+                            struct snd_pcm_hw_params *params,
+                            struct snd_soc_dai *dai)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_device *socdev = rtd->socdev;
+        struct snd_soc_codec *codec = socdev->card->codec;
+        struct wm8978_priv *wm8978 = codec->private_data;
+        /* Word length mask = 0x60 */
+        u16 iface_ctl = snd_soc_read(codec, WM8978_AUDIO_INTERFACE) & ~0x60;
+        /* Sampling rate mask = 0xe (for filters) */
+        u16 add_ctl = snd_soc_read(codec, WM8978_ADDITIONAL_CONTROL) & ~0xe;
+        u16 clking = snd_soc_read(codec, WM8978_CLOCKING);
+        enum wm8978_sysclk_src current_clk_id = clking & 0x100 ?
+                WM8978_PLL : WM8978_MCLK;
+        unsigned int f_sel, diff, diff_best = INT_MAX;
+        int i, best = 0;
+
+        if (!wm8978->f_mclk)
+                return -EINVAL;
+
+        /* bit size */
+        switch (params_format(params)) {
+        case SNDRV_PCM_FORMAT_S16_LE:
+                break;
+        case SNDRV_PCM_FORMAT_S20_3LE:
+                iface_ctl |= 0x20;
+                break;
+        case SNDRV_PCM_FORMAT_S24_LE:
+                iface_ctl |= 0x40;
+                break;
+        case SNDRV_PCM_FORMAT_S32_LE:
+                iface_ctl |= 0x60;
+                break;
+        }
+
+        /* filter coefficient */
+        switch (params_rate(params)) {
+        case 8000:
+                add_ctl |= 0x5 << 1;
+                break;
+        case 11025:
+                add_ctl |= 0x4 << 1;
+                break;
+        case 16000:
+                add_ctl |= 0x3 << 1;
+                break;
+        case 22050:
+                add_ctl |= 0x2 << 1;
+                break;
+        case 32000:
+                add_ctl |= 0x1 << 1;
+                break;
+        case 44100:
+        case 48000:
+                break;
+        }
+
+        /* Sampling rate is known now, can configure the MCLK divider */
+        wm8978->f_256fs = params_rate(params) * 256;
+
+        if (wm8978->sysclk == WM8978_MCLK) {
+                wm8978->mclk_idx = -1;
+                f_sel = wm8978->f_mclk;
+        } else {
+                if (!wm8978->f_pllout) {
+                        /* We only enter here, if OPCLK is not used */
+                        int ret = wm8978_configure_pll(codec);
+                        if (ret < 0)
+                                return ret;
+                }
+                f_sel = wm8978->f_pllout;
+        }
+
+        if (wm8978->mclk_idx < 0) {
+                /* Either MCLK is used directly, or OPCLK is used */
+                if (f_sel < wm8978->f_256fs || f_sel > 12 * wm8978->f_256fs)
+                        return -EINVAL;
+
+                for (i = 0; i < ARRAY_SIZE(mclk_numerator); i++) {
+                        diff = abs(wm8978->f_256fs * 3 -
+                                   f_sel * 3 * mclk_denominator[i] / mclk_numerator[i]);
+
+                        if (diff < diff_best) {
+                                diff_best = diff;
+                                best = i;
+                        }
+
+                        if (!diff)
+                                break;
+                }
+        } else {
+                /* OPCLK not used, codec driven by PLL */
+                best = wm8978->mclk_idx;
+                diff = 0;
+        }
+
+        if (diff)
+                dev_warn(codec->dev, "Imprecise sampling rate: %uHz%s\n",
+                        f_sel * mclk_denominator[best] / mclk_numerator[best] / 256,
+                        wm8978->sysclk == WM8978_MCLK ?
+                        ", consider using PLL" : "");
+
+        dev_dbg(codec->dev, "%s: fmt %d, rate %u, MCLK divisor #%d\n", __func__,
+                params_format(params), params_rate(params), best);
+
+        /* MCLK divisor mask = 0xe0 */
+        snd_soc_update_bits(codec, WM8978_CLOCKING, 0xe0, best << 5);
+
+        snd_soc_write(codec, WM8978_AUDIO_INTERFACE, iface_ctl);
+        snd_soc_write(codec, WM8978_ADDITIONAL_CONTROL, add_ctl);
+
+        if (wm8978->sysclk != current_clk_id) {
+                if (wm8978->sysclk == WM8978_PLL)
+                        /* Run CODEC from PLL instead of MCLK */
+                        snd_soc_update_bits(codec, WM8978_CLOCKING,
+                                            0x100, 0x100);
+                else
+                        /* Clock CODEC directly from MCLK */
+                        snd_soc_update_bits(codec, WM8978_CLOCKING, 0x100, 0);
+        }
+
+        return 0;
+}
+
+static int wm8978_mute(struct snd_soc_dai *dai, int mute)
+{
+        struct snd_soc_codec *codec = dai->codec;
+
+        dev_dbg(codec->dev, "%s: %d\n", __func__, mute);
+
+        if (mute)
+                snd_soc_update_bits(codec, WM8978_DAC_CONTROL, 0x40, 0x40);
+        else
+                snd_soc_update_bits(codec, WM8978_DAC_CONTROL, 0x40, 0);
+
+        return 0;
+}
+
+static int wm8978_set_bias_level(struct snd_soc_codec *codec,
+                                 enum snd_soc_bias_level level)
+{
+        u16 power1 = snd_soc_read(codec, WM8978_POWER_MANAGEMENT_1) & ~3;
+
+        switch (level) {
+        case SND_SOC_BIAS_ON:
+        case SND_SOC_BIAS_PREPARE:
+                power1 |= 1;  /* VMID 75k */
+                snd_soc_write(codec, WM8978_POWER_MANAGEMENT_1, power1);
+                break;
+        case SND_SOC_BIAS_STANDBY:
+                /* bit 3: enable bias, bit 2: enable I/O tie off buffer */
+                power1 |= 0xc;
+
+                if (codec->bias_level == SND_SOC_BIAS_OFF) {
+                        /* Initial cap charge at VMID 5k */
+                        snd_soc_write(codec, WM8978_POWER_MANAGEMENT_1,
+                                      power1 | 0x3);
+                        mdelay(100);
+                }
+
+                power1 |= 0x2;  /* VMID 500k */
+                snd_soc_write(codec, WM8978_POWER_MANAGEMENT_1, power1);
+                break;
+        case SND_SOC_BIAS_OFF:
+                /* Preserve PLL - OPCLK may be used by someone */
+                snd_soc_update_bits(codec, WM8978_POWER_MANAGEMENT_1, ~0x20, 0);
+                snd_soc_write(codec, WM8978_POWER_MANAGEMENT_2, 0);
+                snd_soc_write(codec, WM8978_POWER_MANAGEMENT_3, 0);
+                break;
+        }
+
+        dev_dbg(codec->dev, "%s: %d, %x\n", __func__, level, power1);
+
+        codec->bias_level = level;
+        return 0;
+}
+
+#define WM8978_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE | \
+        SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32_LE)
+
+static struct snd_soc_dai_ops wm8978_dai_ops = {
+        .hw_params      = wm8978_hw_params,
+        .digital_mute   = wm8978_mute,
+        .set_fmt        = wm8978_set_dai_fmt,
+        .set_clkdiv     = wm8978_set_dai_clkdiv,
+        .set_sysclk     = wm8978_set_dai_sysclk,
+};
+
+/* Also supports 12kHz */
+struct snd_soc_dai wm8978_dai = {
+        .name = "WM8978 HiFi",
+        .id = 1,
+        .playback = {
+                .stream_name = "Playback",
+                .channels_min = 1,
+                .channels_max = 2,
+                .rates = SNDRV_PCM_RATE_8000_48000,
+                .formats = WM8978_FORMATS,
+        },
+        .capture = {
+                .stream_name = "Capture",
+                .channels_min = 1,
+                .channels_max = 2,
+                .rates = SNDRV_PCM_RATE_8000_48000,
+                .formats = WM8978_FORMATS,
+        },
+        .ops = &wm8978_dai_ops,
+};
+EXPORT_SYMBOL_GPL(wm8978_dai);
+
+static int wm8978_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec = socdev->card->codec;
+
+        wm8978_set_bias_level(codec, SND_SOC_BIAS_OFF);
+        /* Also switch PLL off */
+        snd_soc_write(codec, WM8978_POWER_MANAGEMENT_1, 0);
+
+        return 0;
+}
+
+static int wm8978_resume(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec = socdev->card->codec;
+        struct wm8978_priv *wm8978 = codec->private_data;
+        int i;
+        u16 *cache = codec->reg_cache;
+
+        /* Sync reg_cache with the hardware */
+        for (i = 0; i < ARRAY_SIZE(wm8978_reg); i++) {
+                if (i == WM8978_RESET)
+                        continue;
+                if (cache[i] != wm8978_reg[i])
+                        snd_soc_write(codec, i, cache[i]);
+        }
+
+        wm8978_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+
+        if (wm8978->f_pllout)
+                /* Switch PLL on */
+                snd_soc_update_bits(codec, WM8978_POWER_MANAGEMENT_1, 0x20, 0x20);
+
+        return 0;
+}
+
+static int wm8978_probe(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec;
+        int ret = 0;
+
+        if (wm8978_codec == NULL) {
+                dev_err(&pdev->dev, "Codec device not registered\n");
+                return -ENODEV;
+        }
+
+        socdev->card->codec = wm8978_codec;
+        codec = wm8978_codec;
+
+        /* register pcms */
+        ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
+        if (ret < 0) {
+                dev_err(codec->dev, "failed to create pcms: %d\n", ret);
+                goto pcm_err;
+        }
+
+        snd_soc_add_controls(codec, wm8978_snd_controls,
+                             ARRAY_SIZE(wm8978_snd_controls));
+        wm8978_add_widgets(codec);
+
+pcm_err:
+        return ret;
+}
+
+/* power down chip */
+static int wm8978_remove(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+
+        snd_soc_free_pcms(socdev);
+        snd_soc_dapm_free(socdev);
+
+        return 0;
+}
+
+struct snd_soc_codec_device soc_codec_dev_wm8978 = {
+        .probe          = wm8978_probe,
+        .remove         = wm8978_remove,
+        .suspend        = wm8978_suspend,
+        .resume         = wm8978_resume,
+};
+EXPORT_SYMBOL_GPL(soc_codec_dev_wm8978);
+
+/*
+ * These registers contain an "update" bit - bit 8. This means, for example,
+ * that one can write new DAC digital volume for both channels, but only when
+ * the update bit is set, will also the volume be updated - simultaneously for
+ * both channels.
+ */
+static const int update_reg[] = {
+        WM8978_LEFT_DAC_DIGITAL_VOLUME,
+        WM8978_RIGHT_DAC_DIGITAL_VOLUME,
+        WM8978_LEFT_ADC_DIGITAL_VOLUME,
+        WM8978_RIGHT_ADC_DIGITAL_VOLUME,
+        WM8978_LEFT_INP_PGA_CONTROL,
+        WM8978_RIGHT_INP_PGA_CONTROL,
+        WM8978_LOUT1_HP_CONTROL,
+        WM8978_ROUT1_HP_CONTROL,
+        WM8978_LOUT2_SPK_CONTROL,
+        WM8978_ROUT2_SPK_CONTROL,
+};
+
+static __devinit int wm8978_register(struct wm8978_priv *wm8978)
+{
+        int ret, i;
+        struct snd_soc_codec *codec = &wm8978->codec;
+
+        if (wm8978_codec) {
+                dev_err(codec->dev, "Another WM8978 is registered\n");
+                return -EINVAL;
+        }
+
+        /*
+         * Set default system clock to PLL, it is more precise, this is also the
+         * default hardware setting
+         */
+        wm8978->sysclk = WM8978_PLL;
+
+        mutex_init(&codec->mutex);
+        INIT_LIST_HEAD(&codec->dapm_widgets);
+        INIT_LIST_HEAD(&codec->dapm_paths);
+
+        codec->private_data = wm8978;
+        codec->name = "WM8978";
+        codec->owner = THIS_MODULE;
+        codec->bias_level = SND_SOC_BIAS_OFF;
+        codec->set_bias_level = wm8978_set_bias_level;
+        codec->dai = &wm8978_dai;
+        codec->num_dai = 1;
+        codec->reg_cache_size = WM8978_CACHEREGNUM;
+        codec->reg_cache = &wm8978->reg_cache;
+
+        ret = snd_soc_codec_set_cache_io(codec, 7, 9, SND_SOC_I2C);
+        if (ret < 0) {
+                dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
+                goto err;
+        }
+
+        memcpy(codec->reg_cache, wm8978_reg, sizeof(wm8978_reg));
+
+        /*
+         * Set the update bit in all registers, that have one. This way all
+         * writes to those registers will also cause the update bit to be
+         * written.
+         */
+        for (i = 0; i < ARRAY_SIZE(update_reg); i++)
+                ((u16 *)codec->reg_cache)[update_reg[i]] |= 0x100;
+
+        /* Reset the codec */
+        ret = snd_soc_write(codec, WM8978_RESET, 0);
+        if (ret < 0) {
+                dev_err(codec->dev, "Failed to issue reset\n");
+                goto err;
+        }
+
+        wm8978_dai.dev = codec->dev;
+
+        wm8978_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+
+        wm8978_codec = codec;
+
+        ret = snd_soc_register_codec(codec);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to register codec: %d\n", ret);
+                goto err;
+        }
+
+        ret = snd_soc_register_dai(&wm8978_dai);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to register DAI: %d\n", ret);
+                goto err_codec;
+        }
+
+        return 0;
+
+err_codec:
+        snd_soc_unregister_codec(codec);
+err:
+        kfree(wm8978);
+        return ret;
+}
+
+static __devexit void wm8978_unregister(struct wm8978_priv *wm8978)
+{
+        wm8978_set_bias_level(&wm8978->codec, SND_SOC_BIAS_OFF);
+        snd_soc_unregister_dai(&wm8978_dai);
+        snd_soc_unregister_codec(&wm8978->codec);
+        kfree(wm8978);
+        wm8978_codec = NULL;
+}
+
+static __devinit int wm8978_i2c_probe(struct i2c_client *i2c,
+                                      const struct i2c_device_id *id)
+{
+        struct wm8978_priv *wm8978;
+        struct snd_soc_codec *codec;
+
+        wm8978 = kzalloc(sizeof(struct wm8978_priv), GFP_KERNEL);
+        if (wm8978 == NULL)
+                return -ENOMEM;
+
+        codec = &wm8978->codec;
+        codec->hw_write = (hw_write_t)i2c_master_send;
+
+        i2c_set_clientdata(i2c, wm8978);
+        codec->control_data = i2c;
+
+        codec->dev = &i2c->dev;
+
+        return wm8978_register(wm8978);
+}
+
+static __devexit int wm8978_i2c_remove(struct i2c_client *client)
+{
+        struct wm8978_priv *wm8978 = i2c_get_clientdata(client);
+        wm8978_unregister(wm8978);
+        return 0;
+}
+
+static const struct i2c_device_id wm8978_i2c_id[] = {
+        { "wm8978", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, wm8978_i2c_id);
+
+static struct i2c_driver wm8978_i2c_driver = {
+        .driver = {
+                .name = "WM8978",
+                .owner = THIS_MODULE,
+        },
+        .probe =    wm8978_i2c_probe,
+        .remove =   __devexit_p(wm8978_i2c_remove),
+        .id_table = wm8978_i2c_id,
+};
+
+static int __init wm8978_modinit(void)
+{
+        return i2c_add_driver(&wm8978_i2c_driver);
+}
+module_init(wm8978_modinit);
+
+static void __exit wm8978_exit(void)
+{
+        i2c_del_driver(&wm8978_i2c_driver);
+}
+module_exit(wm8978_exit);
+
+MODULE_DESCRIPTION("ASoC WM8978 codec driver");
+MODULE_AUTHOR("Guennadi Liakhovetski <g.liakhovetski@gmx.de>");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/codecs/wm8978.h b/sound/soc/codecs/wm8978.h
new file mode 100644
index 000000000000..56ec83270917
--- /dev/null
+++ b/sound/soc/codecs/wm8978.h
@@ -0,0 +1,86 @@
+/*
+ * wm8978.h             --  codec driver for WM8978
+ *
+ * Copyright 2009 Guennadi Liakhovetski <g.liakhovetski@gmx.de>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef __WM8978_H__
+#define __WM8978_H__
+
+/*
+ * Register values.
+ */
+#define WM8978_RESET                            0x00
+#define WM8978_POWER_MANAGEMENT_1               0x01
+#define WM8978_POWER_MANAGEMENT_2               0x02
+#define WM8978_POWER_MANAGEMENT_3               0x03
+#define WM8978_AUDIO_INTERFACE                  0x04
+#define WM8978_COMPANDING_CONTROL               0x05
+#define WM8978_CLOCKING                         0x06
+#define WM8978_ADDITIONAL_CONTROL               0x07
+#define WM8978_GPIO_CONTROL                     0x08
+#define WM8978_JACK_DETECT_CONTROL_1            0x09
+#define WM8978_DAC_CONTROL                      0x0A
+#define WM8978_LEFT_DAC_DIGITAL_VOLUME          0x0B
+#define WM8978_RIGHT_DAC_DIGITAL_VOLUME         0x0C
+#define WM8978_JACK_DETECT_CONTROL_2            0x0D
+#define WM8978_ADC_CONTROL                      0x0E
+#define WM8978_LEFT_ADC_DIGITAL_VOLUME          0x0F
+#define WM8978_RIGHT_ADC_DIGITAL_VOLUME         0x10
+#define WM8978_EQ1                              0x12
+#define WM8978_EQ2                              0x13
+#define WM8978_EQ3                              0x14
+#define WM8978_EQ4                              0x15
+#define WM8978_EQ5                              0x16
+#define WM8978_DAC_LIMITER_1                    0x18
+#define WM8978_DAC_LIMITER_2                    0x19
+#define WM8978_NOTCH_FILTER_1                   0x1b
+#define WM8978_NOTCH_FILTER_2                   0x1c
+#define WM8978_NOTCH_FILTER_3                   0x1d
+#define WM8978_NOTCH_FILTER_4                   0x1e
+#define WM8978_ALC_CONTROL_1                    0x20
+#define WM8978_ALC_CONTROL_2                    0x21
+#define WM8978_ALC_CONTROL_3                    0x22
+#define WM8978_NOISE_GATE                       0x23
+#define WM8978_PLL_N                            0x24
+#define WM8978_PLL_K1                           0x25
+#define WM8978_PLL_K2                           0x26
+#define WM8978_PLL_K3                           0x27
+#define WM8978_3D_CONTROL                       0x29
+#define WM8978_BEEP_CONTROL                     0x2b
+#define WM8978_INPUT_CONTROL                    0x2c
+#define WM8978_LEFT_INP_PGA_CONTROL             0x2d
+#define WM8978_RIGHT_INP_PGA_CONTROL            0x2e
+#define WM8978_LEFT_ADC_BOOST_CONTROL           0x2f
+#define WM8978_RIGHT_ADC_BOOST_CONTROL          0x30
+#define WM8978_OUTPUT_CONTROL                   0x31
+#define WM8978_LEFT_MIXER_CONTROL               0x32
+#define WM8978_RIGHT_MIXER_CONTROL              0x33
+#define WM8978_LOUT1_HP_CONTROL                 0x34
+#define WM8978_ROUT1_HP_CONTROL                 0x35
+#define WM8978_LOUT2_SPK_CONTROL                0x36
+#define WM8978_ROUT2_SPK_CONTROL                0x37
+#define WM8978_OUT3_MIXER_CONTROL               0x38
+#define WM8978_OUT4_MIXER_CONTROL               0x39
+
+#define WM8978_CACHEREGNUM                      58
+
+/* Clock divider Id's */
+enum wm8978_clk_id {
+        WM8978_OPCLKRATE,
+        WM8978_BCLKDIV,
+};
+
+enum wm8978_sysclk_src {
+        WM8978_PLL,
+        WM8978_MCLK
+};
+
+extern struct snd_soc_dai wm8978_dai;
+extern struct snd_soc_codec_device soc_codec_dev_wm8978;
+
+#endif  /* __WM8978_H__ */
diff --git a/sound/soc/codecs/wm8988.c b/sound/soc/codecs/wm8988.c
index 3f530f8a972a..bb18c3ecfeb9 100644
--- a/sound/soc/codecs/wm8988.c
+++ b/sound/soc/codecs/wm8988.c
@@ -19,6 +19,7 @@
 #include <linux/i2c.h>
 #include <linux/spi/spi.h>
 #include <linux/platform_device.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
@@ -790,19 +791,9 @@ static int wm8988_probe(struct platform_device *pdev)
         snd_soc_dapm_new_controls(codec, wm8988_dapm_widgets,
                                   ARRAY_SIZE(wm8988_dapm_widgets));
         snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
-        snd_soc_dapm_new_widgets(codec);
-
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                dev_err(codec->dev, "failed to register card: %d\n", ret);
-                goto card_err;
-        }
 
         return ret;
 
-card_err:
-        snd_soc_free_pcms(socdev);
-        snd_soc_dapm_free(socdev);
 pcm_err:
         return ret;
 }
@@ -944,21 +935,6 @@ static int wm8988_i2c_remove(struct i2c_client *client)
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int wm8988_i2c_suspend(struct i2c_client *client, pm_message_t msg)
-{
-        return snd_soc_suspend_device(&client->dev);
-}
-
-static int wm8988_i2c_resume(struct i2c_client *client)
-{
-        return snd_soc_resume_device(&client->dev);
-}
-#else
-#define wm8988_i2c_suspend NULL
-#define wm8988_i2c_resume NULL
-#endif
-
 static const struct i2c_device_id wm8988_i2c_id[] = {
         { "wm8988", 0 },
         { }
@@ -972,8 +948,6 @@ static struct i2c_driver wm8988_i2c_driver = {
         },
         .probe = wm8988_i2c_probe,
         .remove = wm8988_i2c_remove,
-        .suspend = wm8988_i2c_suspend,
-        .resume = wm8988_i2c_resume,
         .id_table = wm8988_i2c_id,
 };
 #endif
@@ -1006,21 +980,6 @@ static int __devexit wm8988_spi_remove(struct spi_device *spi)
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int wm8988_spi_suspend(struct spi_device *spi, pm_message_t msg)
-{
-        return snd_soc_suspend_device(&spi->dev);
-}
-
-static int wm8988_spi_resume(struct spi_device *spi)
-{
-        return snd_soc_resume_device(&spi->dev);
-}
-#else
-#define wm8988_spi_suspend NULL
-#define wm8988_spi_resume NULL
-#endif
-
 static struct spi_driver wm8988_spi_driver = {
         .driver = {
                 .name   = "wm8988",
@@ -1029,8 +988,6 @@ static struct spi_driver wm8988_spi_driver = {
         },
         .probe          = wm8988_spi_probe,
         .remove         = __devexit_p(wm8988_spi_remove),
-        .suspend        = wm8988_spi_suspend,
-        .resume         = wm8988_spi_resume,
 };
 #endif
 
diff --git a/sound/soc/codecs/wm8990.c b/sound/soc/codecs/wm8990.c
index 2d702db4131d..831f4730bfd5 100644
--- a/sound/soc/codecs/wm8990.c
+++ b/sound/soc/codecs/wm8990.c
@@ -18,6 +18,7 @@
 #include <linux/pm.h>
 #include <linux/i2c.h>
 #include <linux/platform_device.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
@@ -920,7 +921,6 @@ static int wm8990_add_widgets(struct snd_soc_codec *codec)
         /* set up the WM8990 audio map */
         snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
 
-        snd_soc_dapm_new_widgets(codec);
         return 0;
 }
 
@@ -972,8 +972,8 @@ static void pll_factors(struct _pll_div *pll_div, unsigned int target,
         pll_div->k = K;
 }
 
-static int wm8990_set_dai_pll(struct snd_soc_dai *codec_dai,
-                int pll_id, unsigned int freq_in, unsigned int freq_out)
+static int wm8990_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id,
+                int source, unsigned int freq_in, unsigned int freq_out)
 {
         u16 reg;
         struct snd_soc_codec *codec = codec_dai->codec;
@@ -991,7 +991,7 @@ static int wm8990_set_dai_pll(struct snd_soc_dai *codec_dai,
                 reg = snd_soc_read(codec, WM8990_CLOCKING_2);
                 snd_soc_write(codec, WM8990_CLOCKING_2, reg | WM8990_SYSCLK_SRC);
 
-                /* set up N , fractional mode and pre-divisor if neccessary */
+                /* set up N , fractional mode and pre-divisor if necessary */
                 snd_soc_write(codec, WM8990_PLL1, pll_div.n | WM8990_SDM |
                         (pll_div.div2?WM8990_PRESCALE:0));
                 snd_soc_write(codec, WM8990_PLL2, (u8)(pll_div.k>>8));
@@ -1320,10 +1320,6 @@ static int wm8990_suspend(struct platform_device *pdev, pm_message_t state)
         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
         struct snd_soc_codec *codec = socdev->card->codec;
 
-        /* we only need to suspend if we are a valid card */
-        if (!codec->card)
-                return 0;
-
         wm8990_set_bias_level(codec, SND_SOC_BIAS_OFF);
         return 0;
 }
@@ -1336,10 +1332,6 @@ static int wm8990_resume(struct platform_device *pdev)
         u8 data[2];
         u16 *cache = codec->reg_cache;
 
-        /* we only need to resume if we are a valid card */
-        if (!codec->card)
-                return 0;
-
         /* Sync reg_cache with the hardware */
         for (i = 0; i < ARRAY_SIZE(wm8990_reg); i++) {
                 if (i + 1 == WM8990_RESET)
@@ -1409,16 +1401,9 @@ static int wm8990_init(struct snd_soc_device *socdev)
         snd_soc_add_controls(codec, wm8990_snd_controls,
                                 ARRAY_SIZE(wm8990_snd_controls));
         wm8990_add_widgets(codec);
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                printk(KERN_ERR "wm8990: failed to register card\n");
-                goto card_err;
-        }
+
         return ret;
 
-card_err:
-        snd_soc_free_pcms(socdev);
-        snd_soc_dapm_free(socdev);
 pcm_err:
         kfree(codec->reg_cache);
         return ret;
diff --git a/sound/soc/codecs/wm8993.c b/sound/soc/codecs/wm8993.c
index d9987999e92c..03e8b1a6a56c 100644
--- a/sound/soc/codecs/wm8993.c
+++ b/sound/soc/codecs/wm8993.c
@@ -1,7 +1,7 @@
 /*
  * wm8993.c -- WM8993 ALSA SoC audio driver
  *
- * Copyright 2009 Wolfson Microelectronics plc
+ * Copyright 2009, 2010 Wolfson Microelectronics plc
  *
  * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
  *
@@ -16,7 +16,9 @@
 #include <linux/delay.h>
 #include <linux/pm.h>
 #include <linux/i2c.h>
+#include <linux/regulator/consumer.h>
 #include <linux/spi/spi.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
@@ -29,6 +31,16 @@
 #include "wm8993.h"
 #include "wm_hubs.h"
 
+#define WM8993_NUM_SUPPLIES 6
+static const char *wm8993_supply_names[WM8993_NUM_SUPPLIES] = {
+        "DCVDD",
+        "DBVDD",
+        "AVDD1",
+        "AVDD2",
+        "CPVDD",
+        "SPKVDD",
+};
+
 static u16 wm8993_reg_defaults[WM8993_REGISTER_COUNT] = {
         0x8993,     /* R0   - Software Reset */
         0x0000,     /* R1   - Power Management (1) */
@@ -213,7 +225,9 @@ static struct {
 };
 
 struct wm8993_priv {
+        struct wm_hubs_data hubs_data;
         u16 reg_cache[WM8993_REGISTER_COUNT];
+        struct regulator_bulk_data supplies[WM8993_NUM_SUPPLIES];
         struct wm8993_platform_data pdata;
         struct snd_soc_codec codec;
         int master;
@@ -227,36 +241,9 @@ struct wm8993_priv {
         int class_w_users;
         unsigned int fll_fref;
         unsigned int fll_fout;
+        int fll_src;
 };
 
-static unsigned int wm8993_read_hw(struct snd_soc_codec *codec, u8 reg)
-{
-        struct i2c_msg xfer[2];
-        u16 data;
-        int ret;
-        struct i2c_client *i2c = codec->control_data;
-
-        /* Write register */
-        xfer[0].addr = i2c->addr;
-        xfer[0].flags = 0;
-        xfer[0].len = 1;
-        xfer[0].buf = &reg;
-
-        /* Read data */
-        xfer[1].addr = i2c->addr;
-        xfer[1].flags = I2C_M_RD;
-        xfer[1].len = 2;
-        xfer[1].buf = (u8 *)&data;
-
-        ret = i2c_transfer(i2c->adapter, xfer, 2);
-        if (ret != 2) {
-                dev_err(codec->dev, "Failed to read 0x%x: %d\n", reg, ret);
-                return 0;
-        }
-
-        return (data >> 8) | ((data & 0xff) << 8);
-}
-
 static int wm8993_volatile(unsigned int reg)
 {
         switch (reg) {
@@ -271,48 +258,6 @@ static int wm8993_volatile(unsigned int reg)
         }
 }
 
-static unsigned int wm8993_read(struct snd_soc_codec *codec,
-                                unsigned int reg)
-{
-        u16 *reg_cache = codec->reg_cache;
-
-        BUG_ON(reg > WM8993_MAX_REGISTER);
-
-        if (wm8993_volatile(reg))
-                return wm8993_read_hw(codec, reg);
-        else
-                return reg_cache[reg];
-}
-
-static int wm8993_write(struct snd_soc_codec *codec, unsigned int reg,
-                        unsigned int value)
-{
-        u16 *reg_cache = codec->reg_cache;
-        u8 data[3];
-        int ret;
-
-        BUG_ON(reg > WM8993_MAX_REGISTER);
-
-        /* data is
-         *   D15..D9 WM8993 register offset
-         *   D8...D0 register data
-         */
-        data[0] = reg;
-        data[1] = value >> 8;
-        data[2] = value & 0x00ff;
-
-        if (!wm8993_volatile(reg))
-                reg_cache[reg] = value;
-
-        ret = codec->hw_write(codec->control_data, data, 3);
-
-        if (ret == 3)
-                return 0;
-        if (ret < 0)
-                return ret;
-        return -EIO;
-}
-
 struct _fll_div {
         u16 fll_fratio;
         u16 fll_outdiv;
@@ -422,7 +367,7 @@ static int fll_factors(struct _fll_div *fll_div, unsigned int Fref,
         return 0;
 }
 
-static int wm8993_set_fll(struct snd_soc_dai *dai, int fll_id,
+static int wm8993_set_fll(struct snd_soc_dai *dai, int fll_id, int source,
                           unsigned int Fref, unsigned int Fout)
 {
         struct snd_soc_codec *codec = dai->codec;
@@ -441,9 +386,9 @@ static int wm8993_set_fll(struct snd_soc_dai *dai, int fll_id,
                 wm8993->fll_fref = 0;
                 wm8993->fll_fout = 0;
 
-                reg1 = wm8993_read(codec, WM8993_FLL_CONTROL_1);
+                reg1 = snd_soc_read(codec, WM8993_FLL_CONTROL_1);
                 reg1 &= ~WM8993_FLL_ENA;
-                wm8993_write(codec, WM8993_FLL_CONTROL_1, reg1);
+                snd_soc_write(codec, WM8993_FLL_CONTROL_1, reg1);
 
                 return 0;
         }
@@ -452,7 +397,7 @@ static int wm8993_set_fll(struct snd_soc_dai *dai, int fll_id,
         if (ret != 0)
                 return ret;
 
-        reg5 = wm8993_read(codec, WM8993_FLL_CONTROL_5);
+        reg5 = snd_soc_read(codec, WM8993_FLL_CONTROL_5);
         reg5 &= ~WM8993_FLL_CLK_SRC_MASK;
 
         switch (fll_id) {
@@ -474,38 +419,39 @@ static int wm8993_set_fll(struct snd_soc_dai *dai, int fll_id,
 
         /* Any FLL configuration change requires that the FLL be
          * disabled first. */
-        reg1 = wm8993_read(codec, WM8993_FLL_CONTROL_1);
+        reg1 = snd_soc_read(codec, WM8993_FLL_CONTROL_1);
         reg1 &= ~WM8993_FLL_ENA;
-        wm8993_write(codec, WM8993_FLL_CONTROL_1, reg1);
+        snd_soc_write(codec, WM8993_FLL_CONTROL_1, reg1);
 
         /* Apply the configuration */
         if (fll_div.k)
                 reg1 |= WM8993_FLL_FRAC_MASK;
         else
                 reg1 &= ~WM8993_FLL_FRAC_MASK;
-        wm8993_write(codec, WM8993_FLL_CONTROL_1, reg1);
+        snd_soc_write(codec, WM8993_FLL_CONTROL_1, reg1);
 
-        wm8993_write(codec, WM8993_FLL_CONTROL_2,
-                     (fll_div.fll_outdiv << WM8993_FLL_OUTDIV_SHIFT) |
-                     (fll_div.fll_fratio << WM8993_FLL_FRATIO_SHIFT));
-        wm8993_write(codec, WM8993_FLL_CONTROL_3, fll_div.k);
+        snd_soc_write(codec, WM8993_FLL_CONTROL_2,
+                      (fll_div.fll_outdiv << WM8993_FLL_OUTDIV_SHIFT) |
+                      (fll_div.fll_fratio << WM8993_FLL_FRATIO_SHIFT));
+        snd_soc_write(codec, WM8993_FLL_CONTROL_3, fll_div.k);
 
-        reg4 = wm8993_read(codec, WM8993_FLL_CONTROL_4);
+        reg4 = snd_soc_read(codec, WM8993_FLL_CONTROL_4);
         reg4 &= ~WM8993_FLL_N_MASK;
         reg4 |= fll_div.n << WM8993_FLL_N_SHIFT;
-        wm8993_write(codec, WM8993_FLL_CONTROL_4, reg4);
+        snd_soc_write(codec, WM8993_FLL_CONTROL_4, reg4);
 
         reg5 &= ~WM8993_FLL_CLK_REF_DIV_MASK;
         reg5 |= fll_div.fll_clk_ref_div << WM8993_FLL_CLK_REF_DIV_SHIFT;
-        wm8993_write(codec, WM8993_FLL_CONTROL_5, reg5);
+        snd_soc_write(codec, WM8993_FLL_CONTROL_5, reg5);
 
         /* Enable the FLL */
-        wm8993_write(codec, WM8993_FLL_CONTROL_1, reg1 | WM8993_FLL_ENA);
+        snd_soc_write(codec, WM8993_FLL_CONTROL_1, reg1 | WM8993_FLL_ENA);
 
         dev_dbg(codec->dev, "FLL enabled at %dHz->%dHz\n", Fref, Fout);
 
         wm8993->fll_fref = Fref;
         wm8993->fll_fout = Fout;
+        wm8993->fll_src = source;
 
         return 0;
 }
@@ -520,7 +466,7 @@ static int configure_clock(struct snd_soc_codec *codec)
         case WM8993_SYSCLK_MCLK:
                 dev_dbg(codec->dev, "Using %dHz MCLK\n", wm8993->mclk_rate);
 
-                reg = wm8993_read(codec, WM8993_CLOCKING_2);
+                reg = snd_soc_read(codec, WM8993_CLOCKING_2);
                 reg &= ~(WM8993_MCLK_DIV | WM8993_SYSCLK_SRC);
                 if (wm8993->mclk_rate > 13500000) {
                         reg |= WM8993_MCLK_DIV;
@@ -529,14 +475,14 @@ static int configure_clock(struct snd_soc_codec *codec)
                         reg &= ~WM8993_MCLK_DIV;
                         wm8993->sysclk_rate = wm8993->mclk_rate;
                 }
-                wm8993_write(codec, WM8993_CLOCKING_2, reg);
+                snd_soc_write(codec, WM8993_CLOCKING_2, reg);
                 break;
 
         case WM8993_SYSCLK_FLL:
                 dev_dbg(codec->dev, "Using %dHz FLL clock\n",
                         wm8993->fll_fout);
 
-                reg = wm8993_read(codec, WM8993_CLOCKING_2);
+                reg = snd_soc_read(codec, WM8993_CLOCKING_2);
                 reg |= WM8993_SYSCLK_SRC;
                 if (wm8993->fll_fout > 13500000) {
                         reg |= WM8993_MCLK_DIV;
@@ -545,7 +491,7 @@ static int configure_clock(struct snd_soc_codec *codec)
                         reg &= ~WM8993_MCLK_DIV;
                         wm8993->sysclk_rate = wm8993->fll_fout;
                 }
-                wm8993_write(codec, WM8993_CLOCKING_2, reg);
+                snd_soc_write(codec, WM8993_CLOCKING_2, reg);
                 break;
 
         default:
@@ -689,7 +635,7 @@ SOC_DOUBLE_TLV("Digital Sidetone Volume", WM8993_DIGITAL_SIDE_TONE,
 
 SOC_SINGLE("DRC Switch", WM8993_DRC_CONTROL_1, 15, 1, 0),
 SOC_ENUM("DRC Path", drc_path),
-SOC_SINGLE_TLV("DRC Compressor Threashold Volume", WM8993_DRC_CONTROL_2,
+SOC_SINGLE_TLV("DRC Compressor Threshold Volume", WM8993_DRC_CONTROL_2,
                2, 60, 1, drc_comp_threash),
 SOC_SINGLE_TLV("DRC Compressor Amplitude Volume", WM8993_DRC_CONTROL_3,
                11, 30, 1, drc_comp_amp),
@@ -709,7 +655,7 @@ SOC_SINGLE_TLV("DRC Quick Release Volume", WM8993_DRC_CONTROL_3, 2, 3, 0,
 SOC_ENUM("DRC Quick Release Rate", drc_qr_rate),
 SOC_SINGLE("DRC Smoothing Switch", WM8993_DRC_CONTROL_1, 11, 1, 0),
 SOC_SINGLE("DRC Smoothing Hysteresis Switch", WM8993_DRC_CONTROL_1, 8, 1, 0),
-SOC_ENUM("DRC Smoothing Hysteresis Threashold", drc_smooth),
+SOC_ENUM("DRC Smoothing Hysteresis Threshold", drc_smooth),
 SOC_SINGLE_TLV("DRC Startup Volume", WM8993_DRC_CONTROL_4, 8, 18, 0,
                drc_startup_tlv),
 
@@ -978,10 +924,33 @@ static const struct snd_soc_dapm_route routes[] = {
         { "Right Headphone Mux", "DAC", "DACR" },
 };
 
+static void wm8993_cache_restore(struct snd_soc_codec *codec)
+{
+        u16 *cache = codec->reg_cache;
+        int i;
+
+        if (!codec->cache_sync)
+                return;
+
+        /* Reenable hardware writes */
+        codec->cache_only = 0;
+
+        /* Restore the register settings */
+        for (i = 1; i < WM8993_MAX_REGISTER; i++) {
+                if (cache[i] == wm8993_reg_defaults[i])
+                        continue;
+                snd_soc_write(codec, i, cache[i]);
+        }
+
+        /* We're in sync again */
+        codec->cache_sync = 0;
+}
+
 static int wm8993_set_bias_level(struct snd_soc_codec *codec,
                                  enum snd_soc_bias_level level)
 {
         struct wm8993_priv *wm8993 = codec->private_data;
+        int ret;
 
         switch (level) {
         case SND_SOC_BIAS_ON:
@@ -995,6 +964,18 @@ static int wm8993_set_bias_level(struct snd_soc_codec *codec,
 
         case SND_SOC_BIAS_STANDBY:
                 if (codec->bias_level == SND_SOC_BIAS_OFF) {
+                        ret = regulator_bulk_enable(ARRAY_SIZE(wm8993->supplies),
+                                                    wm8993->supplies);
+                        if (ret != 0)
+                                return ret;
+
+                        wm8993_cache_restore(codec);
+
+                        /* Tune DC servo configuration */
+                        snd_soc_write(codec, 0x44, 3);
+                        snd_soc_write(codec, 0x56, 3);
+                        snd_soc_write(codec, 0x44, 0);
+
                         /* Bring up VMID with fast soft start */
                         snd_soc_update_bits(codec, WM8993_ANTIPOP2,
                                             WM8993_STARTUP_BIAS_ENA |
@@ -1042,6 +1023,18 @@ static int wm8993_set_bias_level(struct snd_soc_codec *codec,
                 snd_soc_update_bits(codec, WM8993_POWER_MANAGEMENT_1,
                                     WM8993_VMID_SEL_MASK | WM8993_BIAS_ENA,
                                     0);
+
+#ifdef CONFIG_REGULATOR
+               /* Post 2.6.34 we will be able to get a callback when
+                * the regulators are disabled which we can use but
+                * for now just assume that the power will be cut if
+                * the regulator API is in use.
+                */
+                codec->cache_sync = 1;
+#endif
+
+                regulator_bulk_disable(ARRAY_SIZE(wm8993->supplies),
+                                       wm8993->supplies);
                 break;
         }
 
@@ -1075,8 +1068,8 @@ static int wm8993_set_dai_fmt(struct snd_soc_dai *dai,
 {
         struct snd_soc_codec *codec = dai->codec;
         struct wm8993_priv *wm8993 = codec->private_data;
-        unsigned int aif1 = wm8993_read(codec, WM8993_AUDIO_INTERFACE_1);
-        unsigned int aif4 = wm8993_read(codec, WM8993_AUDIO_INTERFACE_4);
+        unsigned int aif1 = snd_soc_read(codec, WM8993_AUDIO_INTERFACE_1);
+        unsigned int aif4 = snd_soc_read(codec, WM8993_AUDIO_INTERFACE_4);
 
         aif1 &= ~(WM8993_BCLK_DIR | WM8993_AIF_BCLK_INV |
                   WM8993_AIF_LRCLK_INV | WM8993_AIF_FMT_MASK);
@@ -1159,8 +1152,8 @@ static int wm8993_set_dai_fmt(struct snd_soc_dai *dai,
                 return -EINVAL;
         }
 
-        wm8993_write(codec, WM8993_AUDIO_INTERFACE_1, aif1);
-        wm8993_write(codec, WM8993_AUDIO_INTERFACE_4, aif4);
+        snd_soc_write(codec, WM8993_AUDIO_INTERFACE_1, aif1);
+        snd_soc_write(codec, WM8993_AUDIO_INTERFACE_4, aif4);
 
         return 0;
 }
@@ -1174,16 +1167,16 @@ static int wm8993_hw_params(struct snd_pcm_substream *substream,
         int ret, i, best, best_val, cur_val;
         unsigned int clocking1, clocking3, aif1, aif4;
 
-        clocking1 = wm8993_read(codec, WM8993_CLOCKING_1);
+        clocking1 = snd_soc_read(codec, WM8993_CLOCKING_1);
         clocking1 &= ~WM8993_BCLK_DIV_MASK;
 
-        clocking3 = wm8993_read(codec, WM8993_CLOCKING_3);
+        clocking3 = snd_soc_read(codec, WM8993_CLOCKING_3);
         clocking3 &= ~(WM8993_CLK_SYS_RATE_MASK | WM8993_SAMPLE_RATE_MASK);
 
-        aif1 = wm8993_read(codec, WM8993_AUDIO_INTERFACE_1);
+        aif1 = snd_soc_read(codec, WM8993_AUDIO_INTERFACE_1);
         aif1 &= ~WM8993_AIF_WL_MASK;
 
-        aif4 = wm8993_read(codec, WM8993_AUDIO_INTERFACE_4);
+        aif4 = snd_soc_read(codec, WM8993_AUDIO_INTERFACE_4);
         aif4 &= ~WM8993_LRCLK_RATE_MASK;
 
         /* What BCLK do we need? */
@@ -1276,14 +1269,14 @@ static int wm8993_hw_params(struct snd_pcm_substream *substream,
         dev_dbg(codec->dev, "LRCLK_RATE is %d\n", wm8993->bclk / wm8993->fs);
         aif4 |= wm8993->bclk / wm8993->fs;
 
-        wm8993_write(codec, WM8993_CLOCKING_1, clocking1);
-        wm8993_write(codec, WM8993_CLOCKING_3, clocking3);
-        wm8993_write(codec, WM8993_AUDIO_INTERFACE_1, aif1);
-        wm8993_write(codec, WM8993_AUDIO_INTERFACE_4, aif4);
+        snd_soc_write(codec, WM8993_CLOCKING_1, clocking1);
+        snd_soc_write(codec, WM8993_CLOCKING_3, clocking3);
+        snd_soc_write(codec, WM8993_AUDIO_INTERFACE_1, aif1);
+        snd_soc_write(codec, WM8993_AUDIO_INTERFACE_4, aif4);
 
         /* ReTune Mobile? */
         if (wm8993->pdata.num_retune_configs) {
-                u16 eq1 = wm8993_read(codec, WM8993_EQ1);
+                u16 eq1 = snd_soc_read(codec, WM8993_EQ1);
                 struct wm8993_retune_mobile_setting *s;
 
                 best = 0;
@@ -1306,7 +1299,7 @@ static int wm8993_hw_params(struct snd_pcm_substream *substream,
                 snd_soc_update_bits(codec, WM8993_EQ1, WM8993_EQ_ENA, 0);
 
                 for (i = 1; i < ARRAY_SIZE(s->config); i++)
-                        wm8993_write(codec, WM8993_EQ1 + i, s->config[i]);
+                        snd_soc_write(codec, WM8993_EQ1 + i, s->config[i]);
 
                 snd_soc_update_bits(codec, WM8993_EQ1, WM8993_EQ_ENA, eq1);
         }
@@ -1319,14 +1312,14 @@ static int wm8993_digital_mute(struct snd_soc_dai *codec_dai, int mute)
         struct snd_soc_codec *codec = codec_dai->codec;
         unsigned int reg;
 
-        reg = wm8993_read(codec, WM8993_DAC_CTRL);
+        reg = snd_soc_read(codec, WM8993_DAC_CTRL);
 
         if (mute)
                 reg |= WM8993_DAC_MUTE;
         else
                 reg &= ~WM8993_DAC_MUTE;
 
-        wm8993_write(codec, WM8993_DAC_CTRL, reg);
+        snd_soc_write(codec, WM8993_DAC_CTRL, reg);
 
         return 0;
 }
@@ -1464,19 +1457,8 @@ static int wm8993_probe(struct platform_device *pdev)
         wm_hubs_add_analogue_routes(codec, wm8993->pdata.lineout1_diff,
                                     wm8993->pdata.lineout2_diff);
 
-        snd_soc_dapm_new_widgets(codec);
-
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                dev_err(codec->dev, "failed to register card\n");
-                goto card_err;
-        }
-
         return ret;
 
-card_err:
-        snd_soc_free_pcms(socdev);
-        snd_soc_dapm_free(socdev);
 err:
         return ret;
 }
@@ -1491,9 +1473,66 @@ static int wm8993_remove(struct platform_device *pdev)
         return 0;
 }
 
+#ifdef CONFIG_PM
+static int wm8993_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec = socdev->card->codec;
+        struct wm8993_priv *wm8993 = codec->private_data;
+        int fll_fout = wm8993->fll_fout;
+        int fll_fref  = wm8993->fll_fref;
+        int ret;
+
+        /* Stop the FLL in an orderly fashion */
+        ret = wm8993_set_fll(codec->dai, 0, 0, 0, 0);
+        if (ret != 0) {
+                dev_err(&pdev->dev, "Failed to stop FLL\n");
+                return ret;
+        }
+
+        wm8993->fll_fout = fll_fout;
+        wm8993->fll_fref = fll_fref;
+
+        wm8993_set_bias_level(codec, SND_SOC_BIAS_OFF);
+
+        return 0;
+}
+
+static int wm8993_resume(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec = socdev->card->codec;
+        struct wm8993_priv *wm8993 = codec->private_data;
+        int ret;
+
+        wm8993_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+
+        /* Restart the FLL? */
+        if (wm8993->fll_fout) {
+                int fll_fout = wm8993->fll_fout;
+                int fll_fref  = wm8993->fll_fref;
+
+                wm8993->fll_fref = 0;
+                wm8993->fll_fout = 0;
+
+                ret = wm8993_set_fll(codec->dai, 0, wm8993->fll_src,
+                                     fll_fref, fll_fout);
+                if (ret != 0)
+                        dev_err(codec->dev, "Failed to restart FLL\n");
+        }
+
+        return 0;
+}
+#else
+#define wm8993_suspend NULL
+#define wm8993_resume NULL
+#endif
+
 struct snd_soc_codec_device soc_codec_dev_wm8993 = {
         .probe =        wm8993_probe,
         .remove =       wm8993_remove,
+        .suspend =      wm8993_suspend,
+        .resume =       wm8993_resume,
 };
 EXPORT_SYMBOL_GPL(soc_codec_dev_wm8993);
 
@@ -1504,6 +1543,7 @@ static int wm8993_i2c_probe(struct i2c_client *i2c,
         struct snd_soc_codec *codec;
         unsigned int val;
         int ret;
+        int i;
 
         if (wm8993_codec) {
                 dev_err(&i2c->dev, "A WM8993 is already registered\n");
@@ -1524,9 +1564,7 @@ static int wm8993_i2c_probe(struct i2c_client *i2c,
         INIT_LIST_HEAD(&codec->dapm_paths);
 
         codec->name = "WM8993";
-        codec->read = wm8993_read;
-        codec->write = wm8993_write;
-        codec->hw_write = (hw_write_t)i2c_master_send;
+        codec->volatile_register = wm8993_volatile;
         codec->reg_cache = wm8993->reg_cache;
         codec->reg_cache_size = ARRAY_SIZE(wm8993->reg_cache);
         codec->bias_level = SND_SOC_BIAS_OFF;
@@ -1535,25 +1573,53 @@ static int wm8993_i2c_probe(struct i2c_client *i2c,
         codec->num_dai = 1;
         codec->private_data = wm8993;
 
+        wm8993->hubs_data.hp_startup_mode = 1;
+        wm8993->hubs_data.dcs_codes = -2;
+
         memcpy(wm8993->reg_cache, wm8993_reg_defaults,
                sizeof(wm8993->reg_cache));
 
+        ret = snd_soc_codec_set_cache_io(codec, 8, 16, SND_SOC_I2C);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
+                goto err;
+        }
+
         i2c_set_clientdata(i2c, wm8993);
         codec->control_data = i2c;
         wm8993_codec = codec;
 
         codec->dev = &i2c->dev;
 
-        val = wm8993_read_hw(codec, WM8993_SOFTWARE_RESET);
+        for (i = 0; i < ARRAY_SIZE(wm8993->supplies); i++)
+                wm8993->supplies[i].supply = wm8993_supply_names[i];
+
+        ret = regulator_bulk_get(codec->dev, ARRAY_SIZE(wm8993->supplies),
+                                 wm8993->supplies);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to request supplies: %d\n", ret);
+                goto err;
+        }
+
+        ret = regulator_bulk_enable(ARRAY_SIZE(wm8993->supplies),
+                                    wm8993->supplies);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to enable supplies: %d\n", ret);
+                goto err_get;
+        }
+
+        val = snd_soc_read(codec, WM8993_SOFTWARE_RESET);
         if (val != wm8993_reg_defaults[WM8993_SOFTWARE_RESET]) {
                 dev_err(codec->dev, "Invalid ID register value %x\n", val);
                 ret = -EINVAL;
-                goto err;
+                goto err_enable;
         }
 
-        ret = wm8993_write(codec, WM8993_SOFTWARE_RESET, 0xffff);
+        ret = snd_soc_write(codec, WM8993_SOFTWARE_RESET, 0xffff);
         if (ret != 0)
-                goto err;
+                goto err_enable;
+
+        codec->cache_only = 1;
 
         /* By default we're using the output mixers */
         wm8993->class_w_users = 2;
@@ -1572,36 +1638,18 @@ static int wm8993_i2c_probe(struct i2c_client *i2c,
         /* Use automatic clock configuration */
         snd_soc_update_bits(codec, WM8993_CLOCKING_4, WM8993_SR_MODE, 0);
 
-        if (!wm8993->pdata.lineout1_diff)
-                snd_soc_update_bits(codec, WM8993_LINE_MIXER1,
-                                    WM8993_LINEOUT1_MODE,
-                                    WM8993_LINEOUT1_MODE);
-        if (!wm8993->pdata.lineout2_diff)
-                snd_soc_update_bits(codec, WM8993_LINE_MIXER2,
-                                    WM8993_LINEOUT2_MODE,
-                                    WM8993_LINEOUT2_MODE);
-
-        if (wm8993->pdata.lineout1fb)
-                snd_soc_update_bits(codec, WM8993_ADDITIONAL_CONTROL,
-                                    WM8993_LINEOUT1_FB, WM8993_LINEOUT1_FB);
-
-        if (wm8993->pdata.lineout2fb)
-                snd_soc_update_bits(codec, WM8993_ADDITIONAL_CONTROL,
-                                    WM8993_LINEOUT2_FB, WM8993_LINEOUT2_FB);
-
-        /* Apply the microphone bias/detection configuration - the
-         * platform data is directly applicable to the register. */
-        snd_soc_update_bits(codec, WM8993_MICBIAS,
-                            WM8993_JD_SCTHR_MASK | WM8993_JD_THR_MASK |
-                            WM8993_MICB1_LVL | WM8993_MICB2_LVL,
-                            wm8993->pdata.jd_scthr << WM8993_JD_SCTHR_SHIFT |
-                            wm8993->pdata.jd_thr << WM8993_JD_THR_SHIFT |
-                            wm8993->pdata.micbias1_lvl |
-                            wm8993->pdata.micbias1_lvl << 1);
-
+        wm_hubs_handle_analogue_pdata(codec, wm8993->pdata.lineout1_diff,
+                                      wm8993->pdata.lineout2_diff,
+                                      wm8993->pdata.lineout1fb,
+                                      wm8993->pdata.lineout2fb,
+                                      wm8993->pdata.jd_scthr,
+                                      wm8993->pdata.jd_thr,
+                                      wm8993->pdata.micbias1_lvl,
+                                      wm8993->pdata.micbias2_lvl);
+                             
         ret = wm8993_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
         if (ret != 0)
-                goto err;
+                goto err_enable;
 
         wm8993_dai.dev = codec->dev;
 
@@ -1615,6 +1663,10 @@ static int wm8993_i2c_probe(struct i2c_client *i2c,
 
 err_bias:
         wm8993_set_bias_level(codec, SND_SOC_BIAS_OFF);
+err_enable:
+        regulator_bulk_disable(ARRAY_SIZE(wm8993->supplies), wm8993->supplies);
+err_get:
+        regulator_bulk_free(ARRAY_SIZE(wm8993->supplies), wm8993->supplies);
 err:
         wm8993_codec = NULL;
         kfree(wm8993);
@@ -1629,6 +1681,7 @@ static int wm8993_i2c_remove(struct i2c_client *client)
         snd_soc_unregister_dai(&wm8993_dai);
 
         wm8993_set_bias_level(&wm8993->codec, SND_SOC_BIAS_OFF);
+        regulator_bulk_free(ARRAY_SIZE(wm8993->supplies), wm8993->supplies);
         kfree(wm8993);
 
         return 0;
diff --git a/sound/soc/codecs/wm8994.c b/sound/soc/codecs/wm8994.c
new file mode 100644
index 000000000000..9da0724cd47a
--- /dev/null
+++ b/sound/soc/codecs/wm8994.c
@@ -0,0 +1,3874 @@
+/*
+ * wm8994.c  --  WM8994 ALSA SoC Audio driver
+ *
+ * Copyright 2009 Wolfson Microelectronics plc
+ *
+ * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
+ *
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/pm.h>
+#include <linux/i2c.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/consumer.h>
+#include <linux/slab.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+#include <sound/initval.h>
+#include <sound/tlv.h>
+
+#include <linux/mfd/wm8994/core.h>
+#include <linux/mfd/wm8994/registers.h>
+#include <linux/mfd/wm8994/pdata.h>
+#include <linux/mfd/wm8994/gpio.h>
+
+#include "wm8994.h"
+#include "wm_hubs.h"
+
+static struct snd_soc_codec *wm8994_codec;
+struct snd_soc_codec_device soc_codec_dev_wm8994;
+
+struct fll_config {
+        int src;
+        int in;
+        int out;
+};
+
+#define WM8994_NUM_DRC 3
+#define WM8994_NUM_EQ  3
+
+static int wm8994_drc_base[] = {
+        WM8994_AIF1_DRC1_1,
+        WM8994_AIF1_DRC2_1,
+        WM8994_AIF2_DRC_1,
+};
+
+static int wm8994_retune_mobile_base[] = {
+        WM8994_AIF1_DAC1_EQ_GAINS_1,
+        WM8994_AIF1_DAC2_EQ_GAINS_1,
+        WM8994_AIF2_EQ_GAINS_1,
+};
+
+#define WM8994_REG_CACHE_SIZE  0x621
+
+/* codec private data */
+struct wm8994_priv {
+        struct wm_hubs_data hubs;
+        struct snd_soc_codec codec;
+        u16 reg_cache[WM8994_REG_CACHE_SIZE + 1];
+        int sysclk[2];
+        int sysclk_rate[2];
+        int mclk[2];
+        int aifclk[2];
+        struct fll_config fll[2], fll_suspend[2];
+
+        int dac_rates[2];
+        int lrclk_shared[2];
+
+        /* Platform dependant DRC configuration */
+        const char **drc_texts;
+        int drc_cfg[WM8994_NUM_DRC];
+        struct soc_enum drc_enum;
+
+        /* Platform dependant ReTune mobile configuration */
+        int num_retune_mobile_texts;
+        const char **retune_mobile_texts;
+        int retune_mobile_cfg[WM8994_NUM_EQ];
+        struct soc_enum retune_mobile_enum;
+
+        struct wm8994_pdata *pdata;
+};
+
+static struct {
+        unsigned short  readable;   /* Mask of readable bits */
+        unsigned short  writable;   /* Mask of writable bits */
+        unsigned short  vol;        /* Mask of volatile bits */
+} access_masks[] = {
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R0     - Software Reset */
+        { 0x3B37, 0x3B37, 0x0000 }, /* R1     - Power Management (1) */
+        { 0x6BF0, 0x6BF0, 0x0000 }, /* R2     - Power Management (2) */
+        { 0x3FF0, 0x3FF0, 0x0000 }, /* R3     - Power Management (3) */
+        { 0x3F3F, 0x3F3F, 0x0000 }, /* R4     - Power Management (4) */
+        { 0x3F0F, 0x3F0F, 0x0000 }, /* R5     - Power Management (5) */
+        { 0x003F, 0x003F, 0x0000 }, /* R6     - Power Management (6) */
+        { 0x0000, 0x0000, 0x0000 }, /* R7 */
+        { 0x0000, 0x0000, 0x0000 }, /* R8 */
+        { 0x0000, 0x0000, 0x0000 }, /* R9 */
+        { 0x0000, 0x0000, 0x0000 }, /* R10 */
+        { 0x0000, 0x0000, 0x0000 }, /* R11 */
+        { 0x0000, 0x0000, 0x0000 }, /* R12 */
+        { 0x0000, 0x0000, 0x0000 }, /* R13 */
+        { 0x0000, 0x0000, 0x0000 }, /* R14 */
+        { 0x0000, 0x0000, 0x0000 }, /* R15 */
+        { 0x0000, 0x0000, 0x0000 }, /* R16 */
+        { 0x0000, 0x0000, 0x0000 }, /* R17 */
+        { 0x0000, 0x0000, 0x0000 }, /* R18 */
+        { 0x0000, 0x0000, 0x0000 }, /* R19 */
+        { 0x0000, 0x0000, 0x0000 }, /* R20 */
+        { 0x01C0, 0x01C0, 0x0000 }, /* R21    - Input Mixer (1) */
+        { 0x0000, 0x0000, 0x0000 }, /* R22 */
+        { 0x0000, 0x0000, 0x0000 }, /* R23 */
+        { 0x00DF, 0x01DF, 0x0000 }, /* R24    - Left Line Input 1&2 Volume */
+        { 0x00DF, 0x01DF, 0x0000 }, /* R25    - Left Line Input 3&4 Volume */
+        { 0x00DF, 0x01DF, 0x0000 }, /* R26    - Right Line Input 1&2 Volume */
+        { 0x00DF, 0x01DF, 0x0000 }, /* R27    - Right Line Input 3&4 Volume */
+        { 0x00FF, 0x01FF, 0x0000 }, /* R28    - Left Output Volume */
+        { 0x00FF, 0x01FF, 0x0000 }, /* R29    - Right Output Volume */
+        { 0x0077, 0x0077, 0x0000 }, /* R30    - Line Outputs Volume */
+        { 0x0030, 0x0030, 0x0000 }, /* R31    - HPOUT2 Volume */
+        { 0x00FF, 0x01FF, 0x0000 }, /* R32    - Left OPGA Volume */
+        { 0x00FF, 0x01FF, 0x0000 }, /* R33    - Right OPGA Volume */
+        { 0x007F, 0x007F, 0x0000 }, /* R34    - SPKMIXL Attenuation */
+        { 0x017F, 0x017F, 0x0000 }, /* R35    - SPKMIXR Attenuation */
+        { 0x003F, 0x003F, 0x0000 }, /* R36    - SPKOUT Mixers */
+        { 0x003F, 0x003F, 0x0000 }, /* R37    - ClassD */
+        { 0x00FF, 0x01FF, 0x0000 }, /* R38    - Speaker Volume Left */
+        { 0x00FF, 0x01FF, 0x0000 }, /* R39    - Speaker Volume Right */
+        { 0x00FF, 0x00FF, 0x0000 }, /* R40    - Input Mixer (2) */
+        { 0x01B7, 0x01B7, 0x0000 }, /* R41    - Input Mixer (3) */
+        { 0x01B7, 0x01B7, 0x0000 }, /* R42    - Input Mixer (4) */
+        { 0x01C7, 0x01C7, 0x0000 }, /* R43    - Input Mixer (5) */
+        { 0x01C7, 0x01C7, 0x0000 }, /* R44    - Input Mixer (6) */
+        { 0x01FF, 0x01FF, 0x0000 }, /* R45    - Output Mixer (1) */
+        { 0x01FF, 0x01FF, 0x0000 }, /* R46    - Output Mixer (2) */
+        { 0x0FFF, 0x0FFF, 0x0000 }, /* R47    - Output Mixer (3) */
+        { 0x0FFF, 0x0FFF, 0x0000 }, /* R48    - Output Mixer (4) */
+        { 0x0FFF, 0x0FFF, 0x0000 }, /* R49    - Output Mixer (5) */
+        { 0x0FFF, 0x0FFF, 0x0000 }, /* R50    - Output Mixer (6) */
+        { 0x0038, 0x0038, 0x0000 }, /* R51    - HPOUT2 Mixer */
+        { 0x0077, 0x0077, 0x0000 }, /* R52    - Line Mixer (1) */
+        { 0x0077, 0x0077, 0x0000 }, /* R53    - Line Mixer (2) */
+        { 0x03FF, 0x03FF, 0x0000 }, /* R54    - Speaker Mixer */
+        { 0x00C1, 0x00C1, 0x0000 }, /* R55    - Additional Control */
+        { 0x00F0, 0x00F0, 0x0000 }, /* R56    - AntiPOP (1) */
+        { 0x01EF, 0x01EF, 0x0000 }, /* R57    - AntiPOP (2) */
+        { 0x00FF, 0x00FF, 0x0000 }, /* R58    - MICBIAS */
+        { 0x000F, 0x000F, 0x0000 }, /* R59    - LDO 1 */
+        { 0x0007, 0x0007, 0x0000 }, /* R60    - LDO 2 */
+        { 0x0000, 0x0000, 0x0000 }, /* R61 */
+        { 0x0000, 0x0000, 0x0000 }, /* R62 */
+        { 0x0000, 0x0000, 0x0000 }, /* R63 */
+        { 0x0000, 0x0000, 0x0000 }, /* R64 */
+        { 0x0000, 0x0000, 0x0000 }, /* R65 */
+        { 0x0000, 0x0000, 0x0000 }, /* R66 */
+        { 0x0000, 0x0000, 0x0000 }, /* R67 */
+        { 0x0000, 0x0000, 0x0000 }, /* R68 */
+        { 0x0000, 0x0000, 0x0000 }, /* R69 */
+        { 0x0000, 0x0000, 0x0000 }, /* R70 */
+        { 0x0000, 0x0000, 0x0000 }, /* R71 */
+        { 0x0000, 0x0000, 0x0000 }, /* R72 */
+        { 0x0000, 0x0000, 0x0000 }, /* R73 */
+        { 0x0000, 0x0000, 0x0000 }, /* R74 */
+        { 0x0000, 0x0000, 0x0000 }, /* R75 */
+        { 0x8000, 0x8000, 0x0000 }, /* R76    - Charge Pump (1) */
+        { 0x0000, 0x0000, 0x0000 }, /* R77 */
+        { 0x0000, 0x0000, 0x0000 }, /* R78 */
+        { 0x0000, 0x0000, 0x0000 }, /* R79 */
+        { 0x0000, 0x0000, 0x0000 }, /* R80 */
+        { 0x0301, 0x0301, 0x0000 }, /* R81    - Class W (1) */
+        { 0x0000, 0x0000, 0x0000 }, /* R82 */
+        { 0x0000, 0x0000, 0x0000 }, /* R83 */
+        { 0x333F, 0x333F, 0x0000 }, /* R84    - DC Servo (1) */
+        { 0x0FEF, 0x0FEF, 0x0000 }, /* R85    - DC Servo (2) */
+        { 0x0000, 0x0000, 0x0000 }, /* R86 */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R87    - DC Servo (4) */
+        { 0x0333, 0x0000, 0x0000 }, /* R88    - DC Servo Readback */
+        { 0x0000, 0x0000, 0x0000 }, /* R89 */
+        { 0x0000, 0x0000, 0x0000 }, /* R90 */
+        { 0x0000, 0x0000, 0x0000 }, /* R91 */
+        { 0x0000, 0x0000, 0x0000 }, /* R92 */
+        { 0x0000, 0x0000, 0x0000 }, /* R93 */
+        { 0x0000, 0x0000, 0x0000 }, /* R94 */
+        { 0x0000, 0x0000, 0x0000 }, /* R95 */
+        { 0x00EE, 0x00EE, 0x0000 }, /* R96    - Analogue HP (1) */
+        { 0x0000, 0x0000, 0x0000 }, /* R97 */
+        { 0x0000, 0x0000, 0x0000 }, /* R98 */
+        { 0x0000, 0x0000, 0x0000 }, /* R99 */
+        { 0x0000, 0x0000, 0x0000 }, /* R100 */
+        { 0x0000, 0x0000, 0x0000 }, /* R101 */
+        { 0x0000, 0x0000, 0x0000 }, /* R102 */
+        { 0x0000, 0x0000, 0x0000 }, /* R103 */
+        { 0x0000, 0x0000, 0x0000 }, /* R104 */
+        { 0x0000, 0x0000, 0x0000 }, /* R105 */
+        { 0x0000, 0x0000, 0x0000 }, /* R106 */
+        { 0x0000, 0x0000, 0x0000 }, /* R107 */
+        { 0x0000, 0x0000, 0x0000 }, /* R108 */
+        { 0x0000, 0x0000, 0x0000 }, /* R109 */
+        { 0x0000, 0x0000, 0x0000 }, /* R110 */
+        { 0x0000, 0x0000, 0x0000 }, /* R111 */
+        { 0x0000, 0x0000, 0x0000 }, /* R112 */
+        { 0x0000, 0x0000, 0x0000 }, /* R113 */
+        { 0x0000, 0x0000, 0x0000 }, /* R114 */
+        { 0x0000, 0x0000, 0x0000 }, /* R115 */
+        { 0x0000, 0x0000, 0x0000 }, /* R116 */
+        { 0x0000, 0x0000, 0x0000 }, /* R117 */
+        { 0x0000, 0x0000, 0x0000 }, /* R118 */
+        { 0x0000, 0x0000, 0x0000 }, /* R119 */
+        { 0x0000, 0x0000, 0x0000 }, /* R120 */
+        { 0x0000, 0x0000, 0x0000 }, /* R121 */
+        { 0x0000, 0x0000, 0x0000 }, /* R122 */
+        { 0x0000, 0x0000, 0x0000 }, /* R123 */
+        { 0x0000, 0x0000, 0x0000 }, /* R124 */
+        { 0x0000, 0x0000, 0x0000 }, /* R125 */
+        { 0x0000, 0x0000, 0x0000 }, /* R126 */
+        { 0x0000, 0x0000, 0x0000 }, /* R127 */
+        { 0x0000, 0x0000, 0x0000 }, /* R128 */
+        { 0x0000, 0x0000, 0x0000 }, /* R129 */
+        { 0x0000, 0x0000, 0x0000 }, /* R130 */
+        { 0x0000, 0x0000, 0x0000 }, /* R131 */
+        { 0x0000, 0x0000, 0x0000 }, /* R132 */
+        { 0x0000, 0x0000, 0x0000 }, /* R133 */
+        { 0x0000, 0x0000, 0x0000 }, /* R134 */
+        { 0x0000, 0x0000, 0x0000 }, /* R135 */
+        { 0x0000, 0x0000, 0x0000 }, /* R136 */
+        { 0x0000, 0x0000, 0x0000 }, /* R137 */
+        { 0x0000, 0x0000, 0x0000 }, /* R138 */
+        { 0x0000, 0x0000, 0x0000 }, /* R139 */
+        { 0x0000, 0x0000, 0x0000 }, /* R140 */
+        { 0x0000, 0x0000, 0x0000 }, /* R141 */
+        { 0x0000, 0x0000, 0x0000 }, /* R142 */
+        { 0x0000, 0x0000, 0x0000 }, /* R143 */
+        { 0x0000, 0x0000, 0x0000 }, /* R144 */
+        { 0x0000, 0x0000, 0x0000 }, /* R145 */
+        { 0x0000, 0x0000, 0x0000 }, /* R146 */
+        { 0x0000, 0x0000, 0x0000 }, /* R147 */
+        { 0x0000, 0x0000, 0x0000 }, /* R148 */
+        { 0x0000, 0x0000, 0x0000 }, /* R149 */
+        { 0x0000, 0x0000, 0x0000 }, /* R150 */
+        { 0x0000, 0x0000, 0x0000 }, /* R151 */
+        { 0x0000, 0x0000, 0x0000 }, /* R152 */
+        { 0x0000, 0x0000, 0x0000 }, /* R153 */
+        { 0x0000, 0x0000, 0x0000 }, /* R154 */
+        { 0x0000, 0x0000, 0x0000 }, /* R155 */
+        { 0x0000, 0x0000, 0x0000 }, /* R156 */
+        { 0x0000, 0x0000, 0x0000 }, /* R157 */
+        { 0x0000, 0x0000, 0x0000 }, /* R158 */
+        { 0x0000, 0x0000, 0x0000 }, /* R159 */
+        { 0x0000, 0x0000, 0x0000 }, /* R160 */
+        { 0x0000, 0x0000, 0x0000 }, /* R161 */
+        { 0x0000, 0x0000, 0x0000 }, /* R162 */
+        { 0x0000, 0x0000, 0x0000 }, /* R163 */
+        { 0x0000, 0x0000, 0x0000 }, /* R164 */
+        { 0x0000, 0x0000, 0x0000 }, /* R165 */
+        { 0x0000, 0x0000, 0x0000 }, /* R166 */
+        { 0x0000, 0x0000, 0x0000 }, /* R167 */
+        { 0x0000, 0x0000, 0x0000 }, /* R168 */
+        { 0x0000, 0x0000, 0x0000 }, /* R169 */
+        { 0x0000, 0x0000, 0x0000 }, /* R170 */
+        { 0x0000, 0x0000, 0x0000 }, /* R171 */
+        { 0x0000, 0x0000, 0x0000 }, /* R172 */
+        { 0x0000, 0x0000, 0x0000 }, /* R173 */
+        { 0x0000, 0x0000, 0x0000 }, /* R174 */
+        { 0x0000, 0x0000, 0x0000 }, /* R175 */
+        { 0x0000, 0x0000, 0x0000 }, /* R176 */
+        { 0x0000, 0x0000, 0x0000 }, /* R177 */
+        { 0x0000, 0x0000, 0x0000 }, /* R178 */
+        { 0x0000, 0x0000, 0x0000 }, /* R179 */
+        { 0x0000, 0x0000, 0x0000 }, /* R180 */
+        { 0x0000, 0x0000, 0x0000 }, /* R181 */
+        { 0x0000, 0x0000, 0x0000 }, /* R182 */
+        { 0x0000, 0x0000, 0x0000 }, /* R183 */
+        { 0x0000, 0x0000, 0x0000 }, /* R184 */
+        { 0x0000, 0x0000, 0x0000 }, /* R185 */
+        { 0x0000, 0x0000, 0x0000 }, /* R186 */
+        { 0x0000, 0x0000, 0x0000 }, /* R187 */
+        { 0x0000, 0x0000, 0x0000 }, /* R188 */
+        { 0x0000, 0x0000, 0x0000 }, /* R189 */
+        { 0x0000, 0x0000, 0x0000 }, /* R190 */
+        { 0x0000, 0x0000, 0x0000 }, /* R191 */
+        { 0x0000, 0x0000, 0x0000 }, /* R192 */
+        { 0x0000, 0x0000, 0x0000 }, /* R193 */
+        { 0x0000, 0x0000, 0x0000 }, /* R194 */
+        { 0x0000, 0x0000, 0x0000 }, /* R195 */
+        { 0x0000, 0x0000, 0x0000 }, /* R196 */
+        { 0x0000, 0x0000, 0x0000 }, /* R197 */
+        { 0x0000, 0x0000, 0x0000 }, /* R198 */
+        { 0x0000, 0x0000, 0x0000 }, /* R199 */
+        { 0x0000, 0x0000, 0x0000 }, /* R200 */
+        { 0x0000, 0x0000, 0x0000 }, /* R201 */
+        { 0x0000, 0x0000, 0x0000 }, /* R202 */
+        { 0x0000, 0x0000, 0x0000 }, /* R203 */
+        { 0x0000, 0x0000, 0x0000 }, /* R204 */
+        { 0x0000, 0x0000, 0x0000 }, /* R205 */
+        { 0x0000, 0x0000, 0x0000 }, /* R206 */
+        { 0x0000, 0x0000, 0x0000 }, /* R207 */
+        { 0x0000, 0x0000, 0x0000 }, /* R208 */
+        { 0x0000, 0x0000, 0x0000 }, /* R209 */
+        { 0x0000, 0x0000, 0x0000 }, /* R210 */
+        { 0x0000, 0x0000, 0x0000 }, /* R211 */
+        { 0x0000, 0x0000, 0x0000 }, /* R212 */
+        { 0x0000, 0x0000, 0x0000 }, /* R213 */
+        { 0x0000, 0x0000, 0x0000 }, /* R214 */
+        { 0x0000, 0x0000, 0x0000 }, /* R215 */
+        { 0x0000, 0x0000, 0x0000 }, /* R216 */
+        { 0x0000, 0x0000, 0x0000 }, /* R217 */
+        { 0x0000, 0x0000, 0x0000 }, /* R218 */
+        { 0x0000, 0x0000, 0x0000 }, /* R219 */
+        { 0x0000, 0x0000, 0x0000 }, /* R220 */
+        { 0x0000, 0x0000, 0x0000 }, /* R221 */
+        { 0x0000, 0x0000, 0x0000 }, /* R222 */
+        { 0x0000, 0x0000, 0x0000 }, /* R223 */
+        { 0x0000, 0x0000, 0x0000 }, /* R224 */
+        { 0x0000, 0x0000, 0x0000 }, /* R225 */
+        { 0x0000, 0x0000, 0x0000 }, /* R226 */
+        { 0x0000, 0x0000, 0x0000 }, /* R227 */
+        { 0x0000, 0x0000, 0x0000 }, /* R228 */
+        { 0x0000, 0x0000, 0x0000 }, /* R229 */
+        { 0x0000, 0x0000, 0x0000 }, /* R230 */
+        { 0x0000, 0x0000, 0x0000 }, /* R231 */
+        { 0x0000, 0x0000, 0x0000 }, /* R232 */
+        { 0x0000, 0x0000, 0x0000 }, /* R233 */
+        { 0x0000, 0x0000, 0x0000 }, /* R234 */
+        { 0x0000, 0x0000, 0x0000 }, /* R235 */
+        { 0x0000, 0x0000, 0x0000 }, /* R236 */
+        { 0x0000, 0x0000, 0x0000 }, /* R237 */
+        { 0x0000, 0x0000, 0x0000 }, /* R238 */
+        { 0x0000, 0x0000, 0x0000 }, /* R239 */
+        { 0x0000, 0x0000, 0x0000 }, /* R240 */
+        { 0x0000, 0x0000, 0x0000 }, /* R241 */
+        { 0x0000, 0x0000, 0x0000 }, /* R242 */
+        { 0x0000, 0x0000, 0x0000 }, /* R243 */
+        { 0x0000, 0x0000, 0x0000 }, /* R244 */
+        { 0x0000, 0x0000, 0x0000 }, /* R245 */
+        { 0x0000, 0x0000, 0x0000 }, /* R246 */
+        { 0x0000, 0x0000, 0x0000 }, /* R247 */
+        { 0x0000, 0x0000, 0x0000 }, /* R248 */
+        { 0x0000, 0x0000, 0x0000 }, /* R249 */
+        { 0x0000, 0x0000, 0x0000 }, /* R250 */
+        { 0x0000, 0x0000, 0x0000 }, /* R251 */
+        { 0x0000, 0x0000, 0x0000 }, /* R252 */
+        { 0x0000, 0x0000, 0x0000 }, /* R253 */
+        { 0x0000, 0x0000, 0x0000 }, /* R254 */
+        { 0x0000, 0x0000, 0x0000 }, /* R255 */
+        { 0x000F, 0x0000, 0x0000 }, /* R256   - Chip Revision */
+        { 0x0074, 0x0074, 0x0000 }, /* R257   - Control Interface */
+        { 0x0000, 0x0000, 0x0000 }, /* R258 */
+        { 0x0000, 0x0000, 0x0000 }, /* R259 */
+        { 0x0000, 0x0000, 0x0000 }, /* R260 */
+        { 0x0000, 0x0000, 0x0000 }, /* R261 */
+        { 0x0000, 0x0000, 0x0000 }, /* R262 */
+        { 0x0000, 0x0000, 0x0000 }, /* R263 */
+        { 0x0000, 0x0000, 0x0000 }, /* R264 */
+        { 0x0000, 0x0000, 0x0000 }, /* R265 */
+        { 0x0000, 0x0000, 0x0000 }, /* R266 */
+        { 0x0000, 0x0000, 0x0000 }, /* R267 */
+        { 0x0000, 0x0000, 0x0000 }, /* R268 */
+        { 0x0000, 0x0000, 0x0000 }, /* R269 */
+        { 0x0000, 0x0000, 0x0000 }, /* R270 */
+        { 0x0000, 0x0000, 0x0000 }, /* R271 */
+        { 0x807F, 0x837F, 0x0000 }, /* R272   - Write Sequencer Ctrl (1) */
+        { 0x017F, 0x0000, 0x0000 }, /* R273   - Write Sequencer Ctrl (2) */
+        { 0x0000, 0x0000, 0x0000 }, /* R274 */
+        { 0x0000, 0x0000, 0x0000 }, /* R275 */
+        { 0x0000, 0x0000, 0x0000 }, /* R276 */
+        { 0x0000, 0x0000, 0x0000 }, /* R277 */
+        { 0x0000, 0x0000, 0x0000 }, /* R278 */
+        { 0x0000, 0x0000, 0x0000 }, /* R279 */
+        { 0x0000, 0x0000, 0x0000 }, /* R280 */
+        { 0x0000, 0x0000, 0x0000 }, /* R281 */
+        { 0x0000, 0x0000, 0x0000 }, /* R282 */
+        { 0x0000, 0x0000, 0x0000 }, /* R283 */
+        { 0x0000, 0x0000, 0x0000 }, /* R284 */
+        { 0x0000, 0x0000, 0x0000 }, /* R285 */
+        { 0x0000, 0x0000, 0x0000 }, /* R286 */
+        { 0x0000, 0x0000, 0x0000 }, /* R287 */
+        { 0x0000, 0x0000, 0x0000 }, /* R288 */
+        { 0x0000, 0x0000, 0x0000 }, /* R289 */
+        { 0x0000, 0x0000, 0x0000 }, /* R290 */
+        { 0x0000, 0x0000, 0x0000 }, /* R291 */
+        { 0x0000, 0x0000, 0x0000 }, /* R292 */
+        { 0x0000, 0x0000, 0x0000 }, /* R293 */
+        { 0x0000, 0x0000, 0x0000 }, /* R294 */
+        { 0x0000, 0x0000, 0x0000 }, /* R295 */
+        { 0x0000, 0x0000, 0x0000 }, /* R296 */
+        { 0x0000, 0x0000, 0x0000 }, /* R297 */
+        { 0x0000, 0x0000, 0x0000 }, /* R298 */
+        { 0x0000, 0x0000, 0x0000 }, /* R299 */
+        { 0x0000, 0x0000, 0x0000 }, /* R300 */
+        { 0x0000, 0x0000, 0x0000 }, /* R301 */
+        { 0x0000, 0x0000, 0x0000 }, /* R302 */
+        { 0x0000, 0x0000, 0x0000 }, /* R303 */
+        { 0x0000, 0x0000, 0x0000 }, /* R304 */
+        { 0x0000, 0x0000, 0x0000 }, /* R305 */
+        { 0x0000, 0x0000, 0x0000 }, /* R306 */
+        { 0x0000, 0x0000, 0x0000 }, /* R307 */
+        { 0x0000, 0x0000, 0x0000 }, /* R308 */
+        { 0x0000, 0x0000, 0x0000 }, /* R309 */
+        { 0x0000, 0x0000, 0x0000 }, /* R310 */
+        { 0x0000, 0x0000, 0x0000 }, /* R311 */
+        { 0x0000, 0x0000, 0x0000 }, /* R312 */
+        { 0x0000, 0x0000, 0x0000 }, /* R313 */
+        { 0x0000, 0x0000, 0x0000 }, /* R314 */
+        { 0x0000, 0x0000, 0x0000 }, /* R315 */
+        { 0x0000, 0x0000, 0x0000 }, /* R316 */
+        { 0x0000, 0x0000, 0x0000 }, /* R317 */
+        { 0x0000, 0x0000, 0x0000 }, /* R318 */
+        { 0x0000, 0x0000, 0x0000 }, /* R319 */
+        { 0x0000, 0x0000, 0x0000 }, /* R320 */
+        { 0x0000, 0x0000, 0x0000 }, /* R321 */
+        { 0x0000, 0x0000, 0x0000 }, /* R322 */
+        { 0x0000, 0x0000, 0x0000 }, /* R323 */
+        { 0x0000, 0x0000, 0x0000 }, /* R324 */
+        { 0x0000, 0x0000, 0x0000 }, /* R325 */
+        { 0x0000, 0x0000, 0x0000 }, /* R326 */
+        { 0x0000, 0x0000, 0x0000 }, /* R327 */
+        { 0x0000, 0x0000, 0x0000 }, /* R328 */
+        { 0x0000, 0x0000, 0x0000 }, /* R329 */
+        { 0x0000, 0x0000, 0x0000 }, /* R330 */
+        { 0x0000, 0x0000, 0x0000 }, /* R331 */
+        { 0x0000, 0x0000, 0x0000 }, /* R332 */
+        { 0x0000, 0x0000, 0x0000 }, /* R333 */
+        { 0x0000, 0x0000, 0x0000 }, /* R334 */
+        { 0x0000, 0x0000, 0x0000 }, /* R335 */
+        { 0x0000, 0x0000, 0x0000 }, /* R336 */
+        { 0x0000, 0x0000, 0x0000 }, /* R337 */
+        { 0x0000, 0x0000, 0x0000 }, /* R338 */
+        { 0x0000, 0x0000, 0x0000 }, /* R339 */
+        { 0x0000, 0x0000, 0x0000 }, /* R340 */
+        { 0x0000, 0x0000, 0x0000 }, /* R341 */
+        { 0x0000, 0x0000, 0x0000 }, /* R342 */
+        { 0x0000, 0x0000, 0x0000 }, /* R343 */
+        { 0x0000, 0x0000, 0x0000 }, /* R344 */
+        { 0x0000, 0x0000, 0x0000 }, /* R345 */
+        { 0x0000, 0x0000, 0x0000 }, /* R346 */
+        { 0x0000, 0x0000, 0x0000 }, /* R347 */
+        { 0x0000, 0x0000, 0x0000 }, /* R348 */
+        { 0x0000, 0x0000, 0x0000 }, /* R349 */
+        { 0x0000, 0x0000, 0x0000 }, /* R350 */
+        { 0x0000, 0x0000, 0x0000 }, /* R351 */
+        { 0x0000, 0x0000, 0x0000 }, /* R352 */
+        { 0x0000, 0x0000, 0x0000 }, /* R353 */
+        { 0x0000, 0x0000, 0x0000 }, /* R354 */
+        { 0x0000, 0x0000, 0x0000 }, /* R355 */
+        { 0x0000, 0x0000, 0x0000 }, /* R356 */
+        { 0x0000, 0x0000, 0x0000 }, /* R357 */
+        { 0x0000, 0x0000, 0x0000 }, /* R358 */
+        { 0x0000, 0x0000, 0x0000 }, /* R359 */
+        { 0x0000, 0x0000, 0x0000 }, /* R360 */
+        { 0x0000, 0x0000, 0x0000 }, /* R361 */
+        { 0x0000, 0x0000, 0x0000 }, /* R362 */
+        { 0x0000, 0x0000, 0x0000 }, /* R363 */
+        { 0x0000, 0x0000, 0x0000 }, /* R364 */
+        { 0x0000, 0x0000, 0x0000 }, /* R365 */
+        { 0x0000, 0x0000, 0x0000 }, /* R366 */
+        { 0x0000, 0x0000, 0x0000 }, /* R367 */
+        { 0x0000, 0x0000, 0x0000 }, /* R368 */
+        { 0x0000, 0x0000, 0x0000 }, /* R369 */
+        { 0x0000, 0x0000, 0x0000 }, /* R370 */
+        { 0x0000, 0x0000, 0x0000 }, /* R371 */
+        { 0x0000, 0x0000, 0x0000 }, /* R372 */
+        { 0x0000, 0x0000, 0x0000 }, /* R373 */
+        { 0x0000, 0x0000, 0x0000 }, /* R374 */
+        { 0x0000, 0x0000, 0x0000 }, /* R375 */
+        { 0x0000, 0x0000, 0x0000 }, /* R376 */
+        { 0x0000, 0x0000, 0x0000 }, /* R377 */
+        { 0x0000, 0x0000, 0x0000 }, /* R378 */
+        { 0x0000, 0x0000, 0x0000 }, /* R379 */
+        { 0x0000, 0x0000, 0x0000 }, /* R380 */
+        { 0x0000, 0x0000, 0x0000 }, /* R381 */
+        { 0x0000, 0x0000, 0x0000 }, /* R382 */
+        { 0x0000, 0x0000, 0x0000 }, /* R383 */
+        { 0x0000, 0x0000, 0x0000 }, /* R384 */
+        { 0x0000, 0x0000, 0x0000 }, /* R385 */
+        { 0x0000, 0x0000, 0x0000 }, /* R386 */
+        { 0x0000, 0x0000, 0x0000 }, /* R387 */
+        { 0x0000, 0x0000, 0x0000 }, /* R388 */
+        { 0x0000, 0x0000, 0x0000 }, /* R389 */
+        { 0x0000, 0x0000, 0x0000 }, /* R390 */
+        { 0x0000, 0x0000, 0x0000 }, /* R391 */
+        { 0x0000, 0x0000, 0x0000 }, /* R392 */
+        { 0x0000, 0x0000, 0x0000 }, /* R393 */
+        { 0x0000, 0x0000, 0x0000 }, /* R394 */
+        { 0x0000, 0x0000, 0x0000 }, /* R395 */
+        { 0x0000, 0x0000, 0x0000 }, /* R396 */
+        { 0x0000, 0x0000, 0x0000 }, /* R397 */
+        { 0x0000, 0x0000, 0x0000 }, /* R398 */
+        { 0x0000, 0x0000, 0x0000 }, /* R399 */
+        { 0x0000, 0x0000, 0x0000 }, /* R400 */
+        { 0x0000, 0x0000, 0x0000 }, /* R401 */
+        { 0x0000, 0x0000, 0x0000 }, /* R402 */
+        { 0x0000, 0x0000, 0x0000 }, /* R403 */
+        { 0x0000, 0x0000, 0x0000 }, /* R404 */
+        { 0x0000, 0x0000, 0x0000 }, /* R405 */
+        { 0x0000, 0x0000, 0x0000 }, /* R406 */
+        { 0x0000, 0x0000, 0x0000 }, /* R407 */
+        { 0x0000, 0x0000, 0x0000 }, /* R408 */
+        { 0x0000, 0x0000, 0x0000 }, /* R409 */
+        { 0x0000, 0x0000, 0x0000 }, /* R410 */
+        { 0x0000, 0x0000, 0x0000 }, /* R411 */
+        { 0x0000, 0x0000, 0x0000 }, /* R412 */
+        { 0x0000, 0x0000, 0x0000 }, /* R413 */
+        { 0x0000, 0x0000, 0x0000 }, /* R414 */
+        { 0x0000, 0x0000, 0x0000 }, /* R415 */
+        { 0x0000, 0x0000, 0x0000 }, /* R416 */
+        { 0x0000, 0x0000, 0x0000 }, /* R417 */
+        { 0x0000, 0x0000, 0x0000 }, /* R418 */
+        { 0x0000, 0x0000, 0x0000 }, /* R419 */
+        { 0x0000, 0x0000, 0x0000 }, /* R420 */
+        { 0x0000, 0x0000, 0x0000 }, /* R421 */
+        { 0x0000, 0x0000, 0x0000 }, /* R422 */
+        { 0x0000, 0x0000, 0x0000 }, /* R423 */
+        { 0x0000, 0x0000, 0x0000 }, /* R424 */
+        { 0x0000, 0x0000, 0x0000 }, /* R425 */
+        { 0x0000, 0x0000, 0x0000 }, /* R426 */
+        { 0x0000, 0x0000, 0x0000 }, /* R427 */
+        { 0x0000, 0x0000, 0x0000 }, /* R428 */
+        { 0x0000, 0x0000, 0x0000 }, /* R429 */
+        { 0x0000, 0x0000, 0x0000 }, /* R430 */
+        { 0x0000, 0x0000, 0x0000 }, /* R431 */
+        { 0x0000, 0x0000, 0x0000 }, /* R432 */
+        { 0x0000, 0x0000, 0x0000 }, /* R433 */
+        { 0x0000, 0x0000, 0x0000 }, /* R434 */
+        { 0x0000, 0x0000, 0x0000 }, /* R435 */
+        { 0x0000, 0x0000, 0x0000 }, /* R436 */
+        { 0x0000, 0x0000, 0x0000 }, /* R437 */
+        { 0x0000, 0x0000, 0x0000 }, /* R438 */
+        { 0x0000, 0x0000, 0x0000 }, /* R439 */
+        { 0x0000, 0x0000, 0x0000 }, /* R440 */
+        { 0x0000, 0x0000, 0x0000 }, /* R441 */
+        { 0x0000, 0x0000, 0x0000 }, /* R442 */
+        { 0x0000, 0x0000, 0x0000 }, /* R443 */
+        { 0x0000, 0x0000, 0x0000 }, /* R444 */
+        { 0x0000, 0x0000, 0x0000 }, /* R445 */
+        { 0x0000, 0x0000, 0x0000 }, /* R446 */
+        { 0x0000, 0x0000, 0x0000 }, /* R447 */
+        { 0x0000, 0x0000, 0x0000 }, /* R448 */
+        { 0x0000, 0x0000, 0x0000 }, /* R449 */
+        { 0x0000, 0x0000, 0x0000 }, /* R450 */
+        { 0x0000, 0x0000, 0x0000 }, /* R451 */
+        { 0x0000, 0x0000, 0x0000 }, /* R452 */
+        { 0x0000, 0x0000, 0x0000 }, /* R453 */
+        { 0x0000, 0x0000, 0x0000 }, /* R454 */
+        { 0x0000, 0x0000, 0x0000 }, /* R455 */
+        { 0x0000, 0x0000, 0x0000 }, /* R456 */
+        { 0x0000, 0x0000, 0x0000 }, /* R457 */
+        { 0x0000, 0x0000, 0x0000 }, /* R458 */
+        { 0x0000, 0x0000, 0x0000 }, /* R459 */
+        { 0x0000, 0x0000, 0x0000 }, /* R460 */
+        { 0x0000, 0x0000, 0x0000 }, /* R461 */
+        { 0x0000, 0x0000, 0x0000 }, /* R462 */
+        { 0x0000, 0x0000, 0x0000 }, /* R463 */
+        { 0x0000, 0x0000, 0x0000 }, /* R464 */
+        { 0x0000, 0x0000, 0x0000 }, /* R465 */
+        { 0x0000, 0x0000, 0x0000 }, /* R466 */
+        { 0x0000, 0x0000, 0x0000 }, /* R467 */
+        { 0x0000, 0x0000, 0x0000 }, /* R468 */
+        { 0x0000, 0x0000, 0x0000 }, /* R469 */
+        { 0x0000, 0x0000, 0x0000 }, /* R470 */
+        { 0x0000, 0x0000, 0x0000 }, /* R471 */
+        { 0x0000, 0x0000, 0x0000 }, /* R472 */
+        { 0x0000, 0x0000, 0x0000 }, /* R473 */
+        { 0x0000, 0x0000, 0x0000 }, /* R474 */
+        { 0x0000, 0x0000, 0x0000 }, /* R475 */
+        { 0x0000, 0x0000, 0x0000 }, /* R476 */
+        { 0x0000, 0x0000, 0x0000 }, /* R477 */
+        { 0x0000, 0x0000, 0x0000 }, /* R478 */
+        { 0x0000, 0x0000, 0x0000 }, /* R479 */
+        { 0x0000, 0x0000, 0x0000 }, /* R480 */
+        { 0x0000, 0x0000, 0x0000 }, /* R481 */
+        { 0x0000, 0x0000, 0x0000 }, /* R482 */
+        { 0x0000, 0x0000, 0x0000 }, /* R483 */
+        { 0x0000, 0x0000, 0x0000 }, /* R484 */
+        { 0x0000, 0x0000, 0x0000 }, /* R485 */
+        { 0x0000, 0x0000, 0x0000 }, /* R486 */
+        { 0x0000, 0x0000, 0x0000 }, /* R487 */
+        { 0x0000, 0x0000, 0x0000 }, /* R488 */
+        { 0x0000, 0x0000, 0x0000 }, /* R489 */
+        { 0x0000, 0x0000, 0x0000 }, /* R490 */
+        { 0x0000, 0x0000, 0x0000 }, /* R491 */
+        { 0x0000, 0x0000, 0x0000 }, /* R492 */
+        { 0x0000, 0x0000, 0x0000 }, /* R493 */
+        { 0x0000, 0x0000, 0x0000 }, /* R494 */
+        { 0x0000, 0x0000, 0x0000 }, /* R495 */
+        { 0x0000, 0x0000, 0x0000 }, /* R496 */
+        { 0x0000, 0x0000, 0x0000 }, /* R497 */
+        { 0x0000, 0x0000, 0x0000 }, /* R498 */
+        { 0x0000, 0x0000, 0x0000 }, /* R499 */
+        { 0x0000, 0x0000, 0x0000 }, /* R500 */
+        { 0x0000, 0x0000, 0x0000 }, /* R501 */
+        { 0x0000, 0x0000, 0x0000 }, /* R502 */
+        { 0x0000, 0x0000, 0x0000 }, /* R503 */
+        { 0x0000, 0x0000, 0x0000 }, /* R504 */
+        { 0x0000, 0x0000, 0x0000 }, /* R505 */
+        { 0x0000, 0x0000, 0x0000 }, /* R506 */
+        { 0x0000, 0x0000, 0x0000 }, /* R507 */
+        { 0x0000, 0x0000, 0x0000 }, /* R508 */
+        { 0x0000, 0x0000, 0x0000 }, /* R509 */
+        { 0x0000, 0x0000, 0x0000 }, /* R510 */
+        { 0x0000, 0x0000, 0x0000 }, /* R511 */
+        { 0x001F, 0x001F, 0x0000 }, /* R512   - AIF1 Clocking (1) */
+        { 0x003F, 0x003F, 0x0000 }, /* R513   - AIF1 Clocking (2) */
+        { 0x0000, 0x0000, 0x0000 }, /* R514 */
+        { 0x0000, 0x0000, 0x0000 }, /* R515 */
+        { 0x001F, 0x001F, 0x0000 }, /* R516   - AIF2 Clocking (1) */
+        { 0x003F, 0x003F, 0x0000 }, /* R517   - AIF2 Clocking (2) */
+        { 0x0000, 0x0000, 0x0000 }, /* R518 */
+        { 0x0000, 0x0000, 0x0000 }, /* R519 */
+        { 0x001F, 0x001F, 0x0000 }, /* R520   - Clocking (1) */
+        { 0x0777, 0x0777, 0x0000 }, /* R521   - Clocking (2) */
+        { 0x0000, 0x0000, 0x0000 }, /* R522 */
+        { 0x0000, 0x0000, 0x0000 }, /* R523 */
+        { 0x0000, 0x0000, 0x0000 }, /* R524 */
+        { 0x0000, 0x0000, 0x0000 }, /* R525 */
+        { 0x0000, 0x0000, 0x0000 }, /* R526 */
+        { 0x0000, 0x0000, 0x0000 }, /* R527 */
+        { 0x00FF, 0x00FF, 0x0000 }, /* R528   - AIF1 Rate */
+        { 0x00FF, 0x00FF, 0x0000 }, /* R529   - AIF2 Rate */
+        { 0x000F, 0x0000, 0x0000 }, /* R530   - Rate Status */
+        { 0x0000, 0x0000, 0x0000 }, /* R531 */
+        { 0x0000, 0x0000, 0x0000 }, /* R532 */
+        { 0x0000, 0x0000, 0x0000 }, /* R533 */
+        { 0x0000, 0x0000, 0x0000 }, /* R534 */
+        { 0x0000, 0x0000, 0x0000 }, /* R535 */
+        { 0x0000, 0x0000, 0x0000 }, /* R536 */
+        { 0x0000, 0x0000, 0x0000 }, /* R537 */
+        { 0x0000, 0x0000, 0x0000 }, /* R538 */
+        { 0x0000, 0x0000, 0x0000 }, /* R539 */
+        { 0x0000, 0x0000, 0x0000 }, /* R540 */
+        { 0x0000, 0x0000, 0x0000 }, /* R541 */
+        { 0x0000, 0x0000, 0x0000 }, /* R542 */
+        { 0x0000, 0x0000, 0x0000 }, /* R543 */
+        { 0x0007, 0x0007, 0x0000 }, /* R544   - FLL1 Control (1) */
+        { 0x3F77, 0x3F77, 0x0000 }, /* R545   - FLL1 Control (2) */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R546   - FLL1 Control (3) */
+        { 0x7FEF, 0x7FEF, 0x0000 }, /* R547   - FLL1 Control (4) */
+        { 0x1FDB, 0x1FDB, 0x0000 }, /* R548   - FLL1 Control (5) */
+        { 0x0000, 0x0000, 0x0000 }, /* R549 */
+        { 0x0000, 0x0000, 0x0000 }, /* R550 */
+        { 0x0000, 0x0000, 0x0000 }, /* R551 */
+        { 0x0000, 0x0000, 0x0000 }, /* R552 */
+        { 0x0000, 0x0000, 0x0000 }, /* R553 */
+        { 0x0000, 0x0000, 0x0000 }, /* R554 */
+        { 0x0000, 0x0000, 0x0000 }, /* R555 */
+        { 0x0000, 0x0000, 0x0000 }, /* R556 */
+        { 0x0000, 0x0000, 0x0000 }, /* R557 */
+        { 0x0000, 0x0000, 0x0000 }, /* R558 */
+        { 0x0000, 0x0000, 0x0000 }, /* R559 */
+        { 0x0000, 0x0000, 0x0000 }, /* R560 */
+        { 0x0000, 0x0000, 0x0000 }, /* R561 */
+        { 0x0000, 0x0000, 0x0000 }, /* R562 */
+        { 0x0000, 0x0000, 0x0000 }, /* R563 */
+        { 0x0000, 0x0000, 0x0000 }, /* R564 */
+        { 0x0000, 0x0000, 0x0000 }, /* R565 */
+        { 0x0000, 0x0000, 0x0000 }, /* R566 */
+        { 0x0000, 0x0000, 0x0000 }, /* R567 */
+        { 0x0000, 0x0000, 0x0000 }, /* R568 */
+        { 0x0000, 0x0000, 0x0000 }, /* R569 */
+        { 0x0000, 0x0000, 0x0000 }, /* R570 */
+        { 0x0000, 0x0000, 0x0000 }, /* R571 */
+        { 0x0000, 0x0000, 0x0000 }, /* R572 */
+        { 0x0000, 0x0000, 0x0000 }, /* R573 */
+        { 0x0000, 0x0000, 0x0000 }, /* R574 */
+        { 0x0000, 0x0000, 0x0000 }, /* R575 */
+        { 0x0007, 0x0007, 0x0000 }, /* R576   - FLL2 Control (1) */
+        { 0x3F77, 0x3F77, 0x0000 }, /* R577   - FLL2 Control (2) */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R578   - FLL2 Control (3) */
+        { 0x7FEF, 0x7FEF, 0x0000 }, /* R579   - FLL2 Control (4) */
+        { 0x1FDB, 0x1FDB, 0x0000 }, /* R580   - FLL2 Control (5) */
+        { 0x0000, 0x0000, 0x0000 }, /* R581 */
+        { 0x0000, 0x0000, 0x0000 }, /* R582 */
+        { 0x0000, 0x0000, 0x0000 }, /* R583 */
+        { 0x0000, 0x0000, 0x0000 }, /* R584 */
+        { 0x0000, 0x0000, 0x0000 }, /* R585 */
+        { 0x0000, 0x0000, 0x0000 }, /* R586 */
+        { 0x0000, 0x0000, 0x0000 }, /* R587 */
+        { 0x0000, 0x0000, 0x0000 }, /* R588 */
+        { 0x0000, 0x0000, 0x0000 }, /* R589 */
+        { 0x0000, 0x0000, 0x0000 }, /* R590 */
+        { 0x0000, 0x0000, 0x0000 }, /* R591 */
+        { 0x0000, 0x0000, 0x0000 }, /* R592 */
+        { 0x0000, 0x0000, 0x0000 }, /* R593 */
+        { 0x0000, 0x0000, 0x0000 }, /* R594 */
+        { 0x0000, 0x0000, 0x0000 }, /* R595 */
+        { 0x0000, 0x0000, 0x0000 }, /* R596 */
+        { 0x0000, 0x0000, 0x0000 }, /* R597 */
+        { 0x0000, 0x0000, 0x0000 }, /* R598 */
+        { 0x0000, 0x0000, 0x0000 }, /* R599 */
+        { 0x0000, 0x0000, 0x0000 }, /* R600 */
+        { 0x0000, 0x0000, 0x0000 }, /* R601 */
+        { 0x0000, 0x0000, 0x0000 }, /* R602 */
+        { 0x0000, 0x0000, 0x0000 }, /* R603 */
+        { 0x0000, 0x0000, 0x0000 }, /* R604 */
+        { 0x0000, 0x0000, 0x0000 }, /* R605 */
+        { 0x0000, 0x0000, 0x0000 }, /* R606 */
+        { 0x0000, 0x0000, 0x0000 }, /* R607 */
+        { 0x0000, 0x0000, 0x0000 }, /* R608 */
+        { 0x0000, 0x0000, 0x0000 }, /* R609 */
+        { 0x0000, 0x0000, 0x0000 }, /* R610 */
+        { 0x0000, 0x0000, 0x0000 }, /* R611 */
+        { 0x0000, 0x0000, 0x0000 }, /* R612 */
+        { 0x0000, 0x0000, 0x0000 }, /* R613 */
+        { 0x0000, 0x0000, 0x0000 }, /* R614 */
+        { 0x0000, 0x0000, 0x0000 }, /* R615 */
+        { 0x0000, 0x0000, 0x0000 }, /* R616 */
+        { 0x0000, 0x0000, 0x0000 }, /* R617 */
+        { 0x0000, 0x0000, 0x0000 }, /* R618 */
+        { 0x0000, 0x0000, 0x0000 }, /* R619 */
+        { 0x0000, 0x0000, 0x0000 }, /* R620 */
+        { 0x0000, 0x0000, 0x0000 }, /* R621 */
+        { 0x0000, 0x0000, 0x0000 }, /* R622 */
+        { 0x0000, 0x0000, 0x0000 }, /* R623 */
+        { 0x0000, 0x0000, 0x0000 }, /* R624 */
+        { 0x0000, 0x0000, 0x0000 }, /* R625 */
+        { 0x0000, 0x0000, 0x0000 }, /* R626 */
+        { 0x0000, 0x0000, 0x0000 }, /* R627 */
+        { 0x0000, 0x0000, 0x0000 }, /* R628 */
+        { 0x0000, 0x0000, 0x0000 }, /* R629 */
+        { 0x0000, 0x0000, 0x0000 }, /* R630 */
+        { 0x0000, 0x0000, 0x0000 }, /* R631 */
+        { 0x0000, 0x0000, 0x0000 }, /* R632 */
+        { 0x0000, 0x0000, 0x0000 }, /* R633 */
+        { 0x0000, 0x0000, 0x0000 }, /* R634 */
+        { 0x0000, 0x0000, 0x0000 }, /* R635 */
+        { 0x0000, 0x0000, 0x0000 }, /* R636 */
+        { 0x0000, 0x0000, 0x0000 }, /* R637 */
+        { 0x0000, 0x0000, 0x0000 }, /* R638 */
+        { 0x0000, 0x0000, 0x0000 }, /* R639 */
+        { 0x0000, 0x0000, 0x0000 }, /* R640 */
+        { 0x0000, 0x0000, 0x0000 }, /* R641 */
+        { 0x0000, 0x0000, 0x0000 }, /* R642 */
+        { 0x0000, 0x0000, 0x0000 }, /* R643 */
+        { 0x0000, 0x0000, 0x0000 }, /* R644 */
+        { 0x0000, 0x0000, 0x0000 }, /* R645 */
+        { 0x0000, 0x0000, 0x0000 }, /* R646 */
+        { 0x0000, 0x0000, 0x0000 }, /* R647 */
+        { 0x0000, 0x0000, 0x0000 }, /* R648 */
+        { 0x0000, 0x0000, 0x0000 }, /* R649 */
+        { 0x0000, 0x0000, 0x0000 }, /* R650 */
+        { 0x0000, 0x0000, 0x0000 }, /* R651 */
+        { 0x0000, 0x0000, 0x0000 }, /* R652 */
+        { 0x0000, 0x0000, 0x0000 }, /* R653 */
+        { 0x0000, 0x0000, 0x0000 }, /* R654 */
+        { 0x0000, 0x0000, 0x0000 }, /* R655 */
+        { 0x0000, 0x0000, 0x0000 }, /* R656 */
+        { 0x0000, 0x0000, 0x0000 }, /* R657 */
+        { 0x0000, 0x0000, 0x0000 }, /* R658 */
+        { 0x0000, 0x0000, 0x0000 }, /* R659 */
+        { 0x0000, 0x0000, 0x0000 }, /* R660 */
+        { 0x0000, 0x0000, 0x0000 }, /* R661 */
+        { 0x0000, 0x0000, 0x0000 }, /* R662 */
+        { 0x0000, 0x0000, 0x0000 }, /* R663 */
+        { 0x0000, 0x0000, 0x0000 }, /* R664 */
+        { 0x0000, 0x0000, 0x0000 }, /* R665 */
+        { 0x0000, 0x0000, 0x0000 }, /* R666 */
+        { 0x0000, 0x0000, 0x0000 }, /* R667 */
+        { 0x0000, 0x0000, 0x0000 }, /* R668 */
+        { 0x0000, 0x0000, 0x0000 }, /* R669 */
+        { 0x0000, 0x0000, 0x0000 }, /* R670 */
+        { 0x0000, 0x0000, 0x0000 }, /* R671 */
+        { 0x0000, 0x0000, 0x0000 }, /* R672 */
+        { 0x0000, 0x0000, 0x0000 }, /* R673 */
+        { 0x0000, 0x0000, 0x0000 }, /* R674 */
+        { 0x0000, 0x0000, 0x0000 }, /* R675 */
+        { 0x0000, 0x0000, 0x0000 }, /* R676 */
+        { 0x0000, 0x0000, 0x0000 }, /* R677 */
+        { 0x0000, 0x0000, 0x0000 }, /* R678 */
+        { 0x0000, 0x0000, 0x0000 }, /* R679 */
+        { 0x0000, 0x0000, 0x0000 }, /* R680 */
+        { 0x0000, 0x0000, 0x0000 }, /* R681 */
+        { 0x0000, 0x0000, 0x0000 }, /* R682 */
+        { 0x0000, 0x0000, 0x0000 }, /* R683 */
+        { 0x0000, 0x0000, 0x0000 }, /* R684 */
+        { 0x0000, 0x0000, 0x0000 }, /* R685 */
+        { 0x0000, 0x0000, 0x0000 }, /* R686 */
+        { 0x0000, 0x0000, 0x0000 }, /* R687 */
+        { 0x0000, 0x0000, 0x0000 }, /* R688 */
+        { 0x0000, 0x0000, 0x0000 }, /* R689 */
+        { 0x0000, 0x0000, 0x0000 }, /* R690 */
+        { 0x0000, 0x0000, 0x0000 }, /* R691 */
+        { 0x0000, 0x0000, 0x0000 }, /* R692 */
+        { 0x0000, 0x0000, 0x0000 }, /* R693 */
+        { 0x0000, 0x0000, 0x0000 }, /* R694 */
+        { 0x0000, 0x0000, 0x0000 }, /* R695 */
+        { 0x0000, 0x0000, 0x0000 }, /* R696 */
+        { 0x0000, 0x0000, 0x0000 }, /* R697 */
+        { 0x0000, 0x0000, 0x0000 }, /* R698 */
+        { 0x0000, 0x0000, 0x0000 }, /* R699 */
+        { 0x0000, 0x0000, 0x0000 }, /* R700 */
+        { 0x0000, 0x0000, 0x0000 }, /* R701 */
+        { 0x0000, 0x0000, 0x0000 }, /* R702 */
+        { 0x0000, 0x0000, 0x0000 }, /* R703 */
+        { 0x0000, 0x0000, 0x0000 }, /* R704 */
+        { 0x0000, 0x0000, 0x0000 }, /* R705 */
+        { 0x0000, 0x0000, 0x0000 }, /* R706 */
+        { 0x0000, 0x0000, 0x0000 }, /* R707 */
+        { 0x0000, 0x0000, 0x0000 }, /* R708 */
+        { 0x0000, 0x0000, 0x0000 }, /* R709 */
+        { 0x0000, 0x0000, 0x0000 }, /* R710 */
+        { 0x0000, 0x0000, 0x0000 }, /* R711 */
+        { 0x0000, 0x0000, 0x0000 }, /* R712 */
+        { 0x0000, 0x0000, 0x0000 }, /* R713 */
+        { 0x0000, 0x0000, 0x0000 }, /* R714 */
+        { 0x0000, 0x0000, 0x0000 }, /* R715 */
+        { 0x0000, 0x0000, 0x0000 }, /* R716 */
+        { 0x0000, 0x0000, 0x0000 }, /* R717 */
+        { 0x0000, 0x0000, 0x0000 }, /* R718 */
+        { 0x0000, 0x0000, 0x0000 }, /* R719 */
+        { 0x0000, 0x0000, 0x0000 }, /* R720 */
+        { 0x0000, 0x0000, 0x0000 }, /* R721 */
+        { 0x0000, 0x0000, 0x0000 }, /* R722 */
+        { 0x0000, 0x0000, 0x0000 }, /* R723 */
+        { 0x0000, 0x0000, 0x0000 }, /* R724 */
+        { 0x0000, 0x0000, 0x0000 }, /* R725 */
+        { 0x0000, 0x0000, 0x0000 }, /* R726 */
+        { 0x0000, 0x0000, 0x0000 }, /* R727 */
+        { 0x0000, 0x0000, 0x0000 }, /* R728 */
+        { 0x0000, 0x0000, 0x0000 }, /* R729 */
+        { 0x0000, 0x0000, 0x0000 }, /* R730 */
+        { 0x0000, 0x0000, 0x0000 }, /* R731 */
+        { 0x0000, 0x0000, 0x0000 }, /* R732 */
+        { 0x0000, 0x0000, 0x0000 }, /* R733 */
+        { 0x0000, 0x0000, 0x0000 }, /* R734 */
+        { 0x0000, 0x0000, 0x0000 }, /* R735 */
+        { 0x0000, 0x0000, 0x0000 }, /* R736 */
+        { 0x0000, 0x0000, 0x0000 }, /* R737 */
+        { 0x0000, 0x0000, 0x0000 }, /* R738 */
+        { 0x0000, 0x0000, 0x0000 }, /* R739 */
+        { 0x0000, 0x0000, 0x0000 }, /* R740 */
+        { 0x0000, 0x0000, 0x0000 }, /* R741 */
+        { 0x0000, 0x0000, 0x0000 }, /* R742 */
+        { 0x0000, 0x0000, 0x0000 }, /* R743 */
+        { 0x0000, 0x0000, 0x0000 }, /* R744 */
+        { 0x0000, 0x0000, 0x0000 }, /* R745 */
+        { 0x0000, 0x0000, 0x0000 }, /* R746 */
+        { 0x0000, 0x0000, 0x0000 }, /* R747 */
+        { 0x0000, 0x0000, 0x0000 }, /* R748 */
+        { 0x0000, 0x0000, 0x0000 }, /* R749 */
+        { 0x0000, 0x0000, 0x0000 }, /* R750 */
+        { 0x0000, 0x0000, 0x0000 }, /* R751 */
+        { 0x0000, 0x0000, 0x0000 }, /* R752 */
+        { 0x0000, 0x0000, 0x0000 }, /* R753 */
+        { 0x0000, 0x0000, 0x0000 }, /* R754 */
+        { 0x0000, 0x0000, 0x0000 }, /* R755 */
+        { 0x0000, 0x0000, 0x0000 }, /* R756 */
+        { 0x0000, 0x0000, 0x0000 }, /* R757 */
+        { 0x0000, 0x0000, 0x0000 }, /* R758 */
+        { 0x0000, 0x0000, 0x0000 }, /* R759 */
+        { 0x0000, 0x0000, 0x0000 }, /* R760 */
+        { 0x0000, 0x0000, 0x0000 }, /* R761 */
+        { 0x0000, 0x0000, 0x0000 }, /* R762 */
+        { 0x0000, 0x0000, 0x0000 }, /* R763 */
+        { 0x0000, 0x0000, 0x0000 }, /* R764 */
+        { 0x0000, 0x0000, 0x0000 }, /* R765 */
+        { 0x0000, 0x0000, 0x0000 }, /* R766 */
+        { 0x0000, 0x0000, 0x0000 }, /* R767 */
+        { 0xE1F8, 0xE1F8, 0x0000 }, /* R768   - AIF1 Control (1) */
+        { 0xCD1F, 0xCD1F, 0x0000 }, /* R769   - AIF1 Control (2) */
+        { 0xF000, 0xF000, 0x0000 }, /* R770   - AIF1 Master/Slave */
+        { 0x01F0, 0x01F0, 0x0000 }, /* R771   - AIF1 BCLK */
+        { 0x0FFF, 0x0FFF, 0x0000 }, /* R772   - AIF1ADC LRCLK */
+        { 0x0FFF, 0x0FFF, 0x0000 }, /* R773   - AIF1DAC LRCLK */
+        { 0x0003, 0x0003, 0x0000 }, /* R774   - AIF1DAC Data */
+        { 0x0003, 0x0003, 0x0000 }, /* R775   - AIF1ADC Data */
+        { 0x0000, 0x0000, 0x0000 }, /* R776 */
+        { 0x0000, 0x0000, 0x0000 }, /* R777 */
+        { 0x0000, 0x0000, 0x0000 }, /* R778 */
+        { 0x0000, 0x0000, 0x0000 }, /* R779 */
+        { 0x0000, 0x0000, 0x0000 }, /* R780 */
+        { 0x0000, 0x0000, 0x0000 }, /* R781 */
+        { 0x0000, 0x0000, 0x0000 }, /* R782 */
+        { 0x0000, 0x0000, 0x0000 }, /* R783 */
+        { 0xF1F8, 0xF1F8, 0x0000 }, /* R784   - AIF2 Control (1) */
+        { 0xFD1F, 0xFD1F, 0x0000 }, /* R785   - AIF2 Control (2) */
+        { 0xF000, 0xF000, 0x0000 }, /* R786   - AIF2 Master/Slave */
+        { 0x01F0, 0x01F0, 0x0000 }, /* R787   - AIF2 BCLK */
+        { 0x0FFF, 0x0FFF, 0x0000 }, /* R788   - AIF2ADC LRCLK */
+        { 0x0FFF, 0x0FFF, 0x0000 }, /* R789   - AIF2DAC LRCLK */
+        { 0x0003, 0x0003, 0x0000 }, /* R790   - AIF2DAC Data */
+        { 0x0003, 0x0003, 0x0000 }, /* R791   - AIF2ADC Data */
+        { 0x0000, 0x0000, 0x0000 }, /* R792 */
+        { 0x0000, 0x0000, 0x0000 }, /* R793 */
+        { 0x0000, 0x0000, 0x0000 }, /* R794 */
+        { 0x0000, 0x0000, 0x0000 }, /* R795 */
+        { 0x0000, 0x0000, 0x0000 }, /* R796 */
+        { 0x0000, 0x0000, 0x0000 }, /* R797 */
+        { 0x0000, 0x0000, 0x0000 }, /* R798 */
+        { 0x0000, 0x0000, 0x0000 }, /* R799 */
+        { 0x0000, 0x0000, 0x0000 }, /* R800 */
+        { 0x0000, 0x0000, 0x0000 }, /* R801 */
+        { 0x0000, 0x0000, 0x0000 }, /* R802 */
+        { 0x0000, 0x0000, 0x0000 }, /* R803 */
+        { 0x0000, 0x0000, 0x0000 }, /* R804 */
+        { 0x0000, 0x0000, 0x0000 }, /* R805 */
+        { 0x0000, 0x0000, 0x0000 }, /* R806 */
+        { 0x0000, 0x0000, 0x0000 }, /* R807 */
+        { 0x0000, 0x0000, 0x0000 }, /* R808 */
+        { 0x0000, 0x0000, 0x0000 }, /* R809 */
+        { 0x0000, 0x0000, 0x0000 }, /* R810 */
+        { 0x0000, 0x0000, 0x0000 }, /* R811 */
+        { 0x0000, 0x0000, 0x0000 }, /* R812 */
+        { 0x0000, 0x0000, 0x0000 }, /* R813 */
+        { 0x0000, 0x0000, 0x0000 }, /* R814 */
+        { 0x0000, 0x0000, 0x0000 }, /* R815 */
+        { 0x0000, 0x0000, 0x0000 }, /* R816 */
+        { 0x0000, 0x0000, 0x0000 }, /* R817 */
+        { 0x0000, 0x0000, 0x0000 }, /* R818 */
+        { 0x0000, 0x0000, 0x0000 }, /* R819 */
+        { 0x0000, 0x0000, 0x0000 }, /* R820 */
+        { 0x0000, 0x0000, 0x0000 }, /* R821 */
+        { 0x0000, 0x0000, 0x0000 }, /* R822 */
+        { 0x0000, 0x0000, 0x0000 }, /* R823 */
+        { 0x0000, 0x0000, 0x0000 }, /* R824 */
+        { 0x0000, 0x0000, 0x0000 }, /* R825 */
+        { 0x0000, 0x0000, 0x0000 }, /* R826 */
+        { 0x0000, 0x0000, 0x0000 }, /* R827 */
+        { 0x0000, 0x0000, 0x0000 }, /* R828 */
+        { 0x0000, 0x0000, 0x0000 }, /* R829 */
+        { 0x0000, 0x0000, 0x0000 }, /* R830 */
+        { 0x0000, 0x0000, 0x0000 }, /* R831 */
+        { 0x0000, 0x0000, 0x0000 }, /* R832 */
+        { 0x0000, 0x0000, 0x0000 }, /* R833 */
+        { 0x0000, 0x0000, 0x0000 }, /* R834 */
+        { 0x0000, 0x0000, 0x0000 }, /* R835 */
+        { 0x0000, 0x0000, 0x0000 }, /* R836 */
+        { 0x0000, 0x0000, 0x0000 }, /* R837 */
+        { 0x0000, 0x0000, 0x0000 }, /* R838 */
+        { 0x0000, 0x0000, 0x0000 }, /* R839 */
+        { 0x0000, 0x0000, 0x0000 }, /* R840 */
+        { 0x0000, 0x0000, 0x0000 }, /* R841 */
+        { 0x0000, 0x0000, 0x0000 }, /* R842 */
+        { 0x0000, 0x0000, 0x0000 }, /* R843 */
+        { 0x0000, 0x0000, 0x0000 }, /* R844 */
+        { 0x0000, 0x0000, 0x0000 }, /* R845 */
+        { 0x0000, 0x0000, 0x0000 }, /* R846 */
+        { 0x0000, 0x0000, 0x0000 }, /* R847 */
+        { 0x0000, 0x0000, 0x0000 }, /* R848 */
+        { 0x0000, 0x0000, 0x0000 }, /* R849 */
+        { 0x0000, 0x0000, 0x0000 }, /* R850 */
+        { 0x0000, 0x0000, 0x0000 }, /* R851 */
+        { 0x0000, 0x0000, 0x0000 }, /* R852 */
+        { 0x0000, 0x0000, 0x0000 }, /* R853 */
+        { 0x0000, 0x0000, 0x0000 }, /* R854 */
+        { 0x0000, 0x0000, 0x0000 }, /* R855 */
+        { 0x0000, 0x0000, 0x0000 }, /* R856 */
+        { 0x0000, 0x0000, 0x0000 }, /* R857 */
+        { 0x0000, 0x0000, 0x0000 }, /* R858 */
+        { 0x0000, 0x0000, 0x0000 }, /* R859 */
+        { 0x0000, 0x0000, 0x0000 }, /* R860 */
+        { 0x0000, 0x0000, 0x0000 }, /* R861 */
+        { 0x0000, 0x0000, 0x0000 }, /* R862 */
+        { 0x0000, 0x0000, 0x0000 }, /* R863 */
+        { 0x0000, 0x0000, 0x0000 }, /* R864 */
+        { 0x0000, 0x0000, 0x0000 }, /* R865 */
+        { 0x0000, 0x0000, 0x0000 }, /* R866 */
+        { 0x0000, 0x0000, 0x0000 }, /* R867 */
+        { 0x0000, 0x0000, 0x0000 }, /* R868 */
+        { 0x0000, 0x0000, 0x0000 }, /* R869 */
+        { 0x0000, 0x0000, 0x0000 }, /* R870 */
+        { 0x0000, 0x0000, 0x0000 }, /* R871 */
+        { 0x0000, 0x0000, 0x0000 }, /* R872 */
+        { 0x0000, 0x0000, 0x0000 }, /* R873 */
+        { 0x0000, 0x0000, 0x0000 }, /* R874 */
+        { 0x0000, 0x0000, 0x0000 }, /* R875 */
+        { 0x0000, 0x0000, 0x0000 }, /* R876 */
+        { 0x0000, 0x0000, 0x0000 }, /* R877 */
+        { 0x0000, 0x0000, 0x0000 }, /* R878 */
+        { 0x0000, 0x0000, 0x0000 }, /* R879 */
+        { 0x0000, 0x0000, 0x0000 }, /* R880 */
+        { 0x0000, 0x0000, 0x0000 }, /* R881 */
+        { 0x0000, 0x0000, 0x0000 }, /* R882 */
+        { 0x0000, 0x0000, 0x0000 }, /* R883 */
+        { 0x0000, 0x0000, 0x0000 }, /* R884 */
+        { 0x0000, 0x0000, 0x0000 }, /* R885 */
+        { 0x0000, 0x0000, 0x0000 }, /* R886 */
+        { 0x0000, 0x0000, 0x0000 }, /* R887 */
+        { 0x0000, 0x0000, 0x0000 }, /* R888 */
+        { 0x0000, 0x0000, 0x0000 }, /* R889 */
+        { 0x0000, 0x0000, 0x0000 }, /* R890 */
+        { 0x0000, 0x0000, 0x0000 }, /* R891 */
+        { 0x0000, 0x0000, 0x0000 }, /* R892 */
+        { 0x0000, 0x0000, 0x0000 }, /* R893 */
+        { 0x0000, 0x0000, 0x0000 }, /* R894 */
+        { 0x0000, 0x0000, 0x0000 }, /* R895 */
+        { 0x0000, 0x0000, 0x0000 }, /* R896 */
+        { 0x0000, 0x0000, 0x0000 }, /* R897 */
+        { 0x0000, 0x0000, 0x0000 }, /* R898 */
+        { 0x0000, 0x0000, 0x0000 }, /* R899 */
+        { 0x0000, 0x0000, 0x0000 }, /* R900 */
+        { 0x0000, 0x0000, 0x0000 }, /* R901 */
+        { 0x0000, 0x0000, 0x0000 }, /* R902 */
+        { 0x0000, 0x0000, 0x0000 }, /* R903 */
+        { 0x0000, 0x0000, 0x0000 }, /* R904 */
+        { 0x0000, 0x0000, 0x0000 }, /* R905 */
+        { 0x0000, 0x0000, 0x0000 }, /* R906 */
+        { 0x0000, 0x0000, 0x0000 }, /* R907 */
+        { 0x0000, 0x0000, 0x0000 }, /* R908 */
+        { 0x0000, 0x0000, 0x0000 }, /* R909 */
+        { 0x0000, 0x0000, 0x0000 }, /* R910 */
+        { 0x0000, 0x0000, 0x0000 }, /* R911 */
+        { 0x0000, 0x0000, 0x0000 }, /* R912 */
+        { 0x0000, 0x0000, 0x0000 }, /* R913 */
+        { 0x0000, 0x0000, 0x0000 }, /* R914 */
+        { 0x0000, 0x0000, 0x0000 }, /* R915 */
+        { 0x0000, 0x0000, 0x0000 }, /* R916 */
+        { 0x0000, 0x0000, 0x0000 }, /* R917 */
+        { 0x0000, 0x0000, 0x0000 }, /* R918 */
+        { 0x0000, 0x0000, 0x0000 }, /* R919 */
+        { 0x0000, 0x0000, 0x0000 }, /* R920 */
+        { 0x0000, 0x0000, 0x0000 }, /* R921 */
+        { 0x0000, 0x0000, 0x0000 }, /* R922 */
+        { 0x0000, 0x0000, 0x0000 }, /* R923 */
+        { 0x0000, 0x0000, 0x0000 }, /* R924 */
+        { 0x0000, 0x0000, 0x0000 }, /* R925 */
+        { 0x0000, 0x0000, 0x0000 }, /* R926 */
+        { 0x0000, 0x0000, 0x0000 }, /* R927 */
+        { 0x0000, 0x0000, 0x0000 }, /* R928 */
+        { 0x0000, 0x0000, 0x0000 }, /* R929 */
+        { 0x0000, 0x0000, 0x0000 }, /* R930 */
+        { 0x0000, 0x0000, 0x0000 }, /* R931 */
+        { 0x0000, 0x0000, 0x0000 }, /* R932 */
+        { 0x0000, 0x0000, 0x0000 }, /* R933 */
+        { 0x0000, 0x0000, 0x0000 }, /* R934 */
+        { 0x0000, 0x0000, 0x0000 }, /* R935 */
+        { 0x0000, 0x0000, 0x0000 }, /* R936 */
+        { 0x0000, 0x0000, 0x0000 }, /* R937 */
+        { 0x0000, 0x0000, 0x0000 }, /* R938 */
+        { 0x0000, 0x0000, 0x0000 }, /* R939 */
+        { 0x0000, 0x0000, 0x0000 }, /* R940 */
+        { 0x0000, 0x0000, 0x0000 }, /* R941 */
+        { 0x0000, 0x0000, 0x0000 }, /* R942 */
+        { 0x0000, 0x0000, 0x0000 }, /* R943 */
+        { 0x0000, 0x0000, 0x0000 }, /* R944 */
+        { 0x0000, 0x0000, 0x0000 }, /* R945 */
+        { 0x0000, 0x0000, 0x0000 }, /* R946 */
+        { 0x0000, 0x0000, 0x0000 }, /* R947 */
+        { 0x0000, 0x0000, 0x0000 }, /* R948 */
+        { 0x0000, 0x0000, 0x0000 }, /* R949 */
+        { 0x0000, 0x0000, 0x0000 }, /* R950 */
+        { 0x0000, 0x0000, 0x0000 }, /* R951 */
+        { 0x0000, 0x0000, 0x0000 }, /* R952 */
+        { 0x0000, 0x0000, 0x0000 }, /* R953 */
+        { 0x0000, 0x0000, 0x0000 }, /* R954 */
+        { 0x0000, 0x0000, 0x0000 }, /* R955 */
+        { 0x0000, 0x0000, 0x0000 }, /* R956 */
+        { 0x0000, 0x0000, 0x0000 }, /* R957 */
+        { 0x0000, 0x0000, 0x0000 }, /* R958 */
+        { 0x0000, 0x0000, 0x0000 }, /* R959 */
+        { 0x0000, 0x0000, 0x0000 }, /* R960 */
+        { 0x0000, 0x0000, 0x0000 }, /* R961 */
+        { 0x0000, 0x0000, 0x0000 }, /* R962 */
+        { 0x0000, 0x0000, 0x0000 }, /* R963 */
+        { 0x0000, 0x0000, 0x0000 }, /* R964 */
+        { 0x0000, 0x0000, 0x0000 }, /* R965 */
+        { 0x0000, 0x0000, 0x0000 }, /* R966 */
+        { 0x0000, 0x0000, 0x0000 }, /* R967 */
+        { 0x0000, 0x0000, 0x0000 }, /* R968 */
+        { 0x0000, 0x0000, 0x0000 }, /* R969 */
+        { 0x0000, 0x0000, 0x0000 }, /* R970 */
+        { 0x0000, 0x0000, 0x0000 }, /* R971 */
+        { 0x0000, 0x0000, 0x0000 }, /* R972 */
+        { 0x0000, 0x0000, 0x0000 }, /* R973 */
+        { 0x0000, 0x0000, 0x0000 }, /* R974 */
+        { 0x0000, 0x0000, 0x0000 }, /* R975 */
+        { 0x0000, 0x0000, 0x0000 }, /* R976 */
+        { 0x0000, 0x0000, 0x0000 }, /* R977 */
+        { 0x0000, 0x0000, 0x0000 }, /* R978 */
+        { 0x0000, 0x0000, 0x0000 }, /* R979 */
+        { 0x0000, 0x0000, 0x0000 }, /* R980 */
+        { 0x0000, 0x0000, 0x0000 }, /* R981 */
+        { 0x0000, 0x0000, 0x0000 }, /* R982 */
+        { 0x0000, 0x0000, 0x0000 }, /* R983 */
+        { 0x0000, 0x0000, 0x0000 }, /* R984 */
+        { 0x0000, 0x0000, 0x0000 }, /* R985 */
+        { 0x0000, 0x0000, 0x0000 }, /* R986 */
+        { 0x0000, 0x0000, 0x0000 }, /* R987 */
+        { 0x0000, 0x0000, 0x0000 }, /* R988 */
+        { 0x0000, 0x0000, 0x0000 }, /* R989 */
+        { 0x0000, 0x0000, 0x0000 }, /* R990 */
+        { 0x0000, 0x0000, 0x0000 }, /* R991 */
+        { 0x0000, 0x0000, 0x0000 }, /* R992 */
+        { 0x0000, 0x0000, 0x0000 }, /* R993 */
+        { 0x0000, 0x0000, 0x0000 }, /* R994 */
+        { 0x0000, 0x0000, 0x0000 }, /* R995 */
+        { 0x0000, 0x0000, 0x0000 }, /* R996 */
+        { 0x0000, 0x0000, 0x0000 }, /* R997 */
+        { 0x0000, 0x0000, 0x0000 }, /* R998 */
+        { 0x0000, 0x0000, 0x0000 }, /* R999 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1000 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1001 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1002 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1003 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1004 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1005 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1006 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1007 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1008 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1009 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1010 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1011 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1012 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1013 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1014 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1015 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1016 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1017 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1018 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1019 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1020 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1021 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1022 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1023 */
+        { 0x00FF, 0x01FF, 0x0000 }, /* R1024  - AIF1 ADC1 Left Volume */
+        { 0x00FF, 0x01FF, 0x0000 }, /* R1025  - AIF1 ADC1 Right Volume */
+        { 0x00FF, 0x01FF, 0x0000 }, /* R1026  - AIF1 DAC1 Left Volume */
+        { 0x00FF, 0x01FF, 0x0000 }, /* R1027  - AIF1 DAC1 Right Volume */
+        { 0x00FF, 0x01FF, 0x0000 }, /* R1028  - AIF1 ADC2 Left Volume */
+        { 0x00FF, 0x01FF, 0x0000 }, /* R1029  - AIF1 ADC2 Right Volume */
+        { 0x00FF, 0x01FF, 0x0000 }, /* R1030  - AIF1 DAC2 Left Volume */
+        { 0x00FF, 0x01FF, 0x0000 }, /* R1031  - AIF1 DAC2 Right Volume */
+        { 0x0000, 0x0000, 0x0000 }, /* R1032 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1033 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1034 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1035 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1036 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1037 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1038 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1039 */
+        { 0xF800, 0xF800, 0x0000 }, /* R1040  - AIF1 ADC1 Filters */
+        { 0x7800, 0x7800, 0x0000 }, /* R1041  - AIF1 ADC2 Filters */
+        { 0x0000, 0x0000, 0x0000 }, /* R1042 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1043 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1044 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1045 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1046 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1047 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1048 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1049 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1050 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1051 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1052 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1053 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1054 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1055 */
+        { 0x02B6, 0x02B6, 0x0000 }, /* R1056  - AIF1 DAC1 Filters (1) */
+        { 0x3F00, 0x3F00, 0x0000 }, /* R1057  - AIF1 DAC1 Filters (2) */
+        { 0x02B6, 0x02B6, 0x0000 }, /* R1058  - AIF1 DAC2 Filters (1) */
+        { 0x3F00, 0x3F00, 0x0000 }, /* R1059  - AIF1 DAC2 Filters (2) */
+        { 0x0000, 0x0000, 0x0000 }, /* R1060 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1061 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1062 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1063 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1064 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1065 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1066 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1067 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1068 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1069 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1070 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1071 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1072 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1073 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1074 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1075 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1076 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1077 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1078 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1079 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1080 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1081 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1082 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1083 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1084 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1085 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1086 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1087 */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1088  - AIF1 DRC1 (1) */
+        { 0x1FFF, 0x1FFF, 0x0000 }, /* R1089  - AIF1 DRC1 (2) */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1090  - AIF1 DRC1 (3) */
+        { 0x07FF, 0x07FF, 0x0000 }, /* R1091  - AIF1 DRC1 (4) */
+        { 0x03FF, 0x03FF, 0x0000 }, /* R1092  - AIF1 DRC1 (5) */
+        { 0x0000, 0x0000, 0x0000 }, /* R1093 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1094 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1095 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1096 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1097 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1098 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1099 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1100 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1101 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1102 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1103 */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1104  - AIF1 DRC2 (1) */
+        { 0x1FFF, 0x1FFF, 0x0000 }, /* R1105  - AIF1 DRC2 (2) */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1106  - AIF1 DRC2 (3) */
+        { 0x07FF, 0x07FF, 0x0000 }, /* R1107  - AIF1 DRC2 (4) */
+        { 0x03FF, 0x03FF, 0x0000 }, /* R1108  - AIF1 DRC2 (5) */
+        { 0x0000, 0x0000, 0x0000 }, /* R1109 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1110 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1111 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1112 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1113 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1114 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1115 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1116 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1117 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1118 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1119 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1120 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1121 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1122 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1123 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1124 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1125 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1126 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1127 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1128 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1129 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1130 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1131 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1132 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1133 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1134 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1135 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1136 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1137 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1138 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1139 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1140 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1141 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1142 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1143 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1144 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1145 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1146 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1147 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1148 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1149 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1150 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1151 */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1152  - AIF1 DAC1 EQ Gains (1) */
+        { 0xFFC0, 0xFFC0, 0x0000 }, /* R1153  - AIF1 DAC1 EQ Gains (2) */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1154  - AIF1 DAC1 EQ Band 1 A */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1155  - AIF1 DAC1 EQ Band 1 B */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1156  - AIF1 DAC1 EQ Band 1 PG */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1157  - AIF1 DAC1 EQ Band 2 A */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1158  - AIF1 DAC1 EQ Band 2 B */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1159  - AIF1 DAC1 EQ Band 2 C */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1160  - AIF1 DAC1 EQ Band 2 PG */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1161  - AIF1 DAC1 EQ Band 3 A */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1162  - AIF1 DAC1 EQ Band 3 B */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1163  - AIF1 DAC1 EQ Band 3 C */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1164  - AIF1 DAC1 EQ Band 3 PG */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1165  - AIF1 DAC1 EQ Band 4 A */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1166  - AIF1 DAC1 EQ Band 4 B */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1167  - AIF1 DAC1 EQ Band 4 C */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1168  - AIF1 DAC1 EQ Band 4 PG */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1169  - AIF1 DAC1 EQ Band 5 A */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1170  - AIF1 DAC1 EQ Band 5 B */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1171  - AIF1 DAC1 EQ Band 5 PG */
+        { 0x0000, 0x0000, 0x0000 }, /* R1172 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1173 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1174 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1175 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1176 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1177 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1178 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1179 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1180 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1181 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1182 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1183 */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1184  - AIF1 DAC2 EQ Gains (1) */
+        { 0xFFC0, 0xFFC0, 0x0000 }, /* R1185  - AIF1 DAC2 EQ Gains (2) */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1186  - AIF1 DAC2 EQ Band 1 A */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1187  - AIF1 DAC2 EQ Band 1 B */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1188  - AIF1 DAC2 EQ Band 1 PG */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1189  - AIF1 DAC2 EQ Band 2 A */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1190  - AIF1 DAC2 EQ Band 2 B */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1191  - AIF1 DAC2 EQ Band 2 C */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1192  - AIF1 DAC2 EQ Band 2 PG */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1193  - AIF1 DAC2 EQ Band 3 A */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1194  - AIF1 DAC2 EQ Band 3 B */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1195  - AIF1 DAC2 EQ Band 3 C */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1196  - AIF1 DAC2 EQ Band 3 PG */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1197  - AIF1 DAC2 EQ Band 4 A */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1198  - AIF1 DAC2 EQ Band 4 B */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1199  - AIF1 DAC2 EQ Band 4 C */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1200  - AIF1 DAC2 EQ Band 4 PG */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1201  - AIF1 DAC2 EQ Band 5 A */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1202  - AIF1 DAC2 EQ Band 5 B */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1203  - AIF1 DAC2 EQ Band 5 PG */
+        { 0x0000, 0x0000, 0x0000 }, /* R1204 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1205 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1206 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1207 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1208 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1209 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1210 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1211 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1212 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1213 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1214 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1215 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1216 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1217 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1218 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1219 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1220 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1221 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1222 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1223 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1224 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1225 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1226 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1227 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1228 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1229 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1230 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1231 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1232 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1233 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1234 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1235 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1236 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1237 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1238 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1239 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1240 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1241 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1242 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1243 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1244 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1245 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1246 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1247 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1248 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1249 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1250 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1251 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1252 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1253 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1254 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1255 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1256 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1257 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1258 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1259 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1260 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1261 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1262 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1263 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1264 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1265 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1266 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1267 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1268 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1269 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1270 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1271 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1272 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1273 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1274 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1275 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1276 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1277 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1278 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1279 */
+        { 0x00FF, 0x01FF, 0x0000 }, /* R1280  - AIF2 ADC Left Volume */
+        { 0x00FF, 0x01FF, 0x0000 }, /* R1281  - AIF2 ADC Right Volume */
+        { 0x00FF, 0x01FF, 0x0000 }, /* R1282  - AIF2 DAC Left Volume */
+        { 0x00FF, 0x01FF, 0x0000 }, /* R1283  - AIF2 DAC Right Volume */
+        { 0x0000, 0x0000, 0x0000 }, /* R1284 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1285 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1286 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1287 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1288 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1289 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1290 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1291 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1292 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1293 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1294 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1295 */
+        { 0xF800, 0xF800, 0x0000 }, /* R1296  - AIF2 ADC Filters */
+        { 0x0000, 0x0000, 0x0000 }, /* R1297 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1298 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1299 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1300 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1301 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1302 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1303 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1304 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1305 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1306 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1307 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1308 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1309 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1310 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1311 */
+        { 0x02B6, 0x02B6, 0x0000 }, /* R1312  - AIF2 DAC Filters (1) */
+        { 0x3F00, 0x3F00, 0x0000 }, /* R1313  - AIF2 DAC Filters (2) */
+        { 0x0000, 0x0000, 0x0000 }, /* R1314 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1315 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1316 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1317 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1318 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1319 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1320 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1321 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1322 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1323 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1324 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1325 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1326 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1327 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1328 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1329 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1330 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1331 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1332 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1333 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1334 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1335 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1336 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1337 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1338 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1339 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1340 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1341 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1342 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1343 */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1344  - AIF2 DRC (1) */
+        { 0x1FFF, 0x1FFF, 0x0000 }, /* R1345  - AIF2 DRC (2) */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1346  - AIF2 DRC (3) */
+        { 0x07FF, 0x07FF, 0x0000 }, /* R1347  - AIF2 DRC (4) */
+        { 0x03FF, 0x03FF, 0x0000 }, /* R1348  - AIF2 DRC (5) */
+        { 0x0000, 0x0000, 0x0000 }, /* R1349 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1350 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1351 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1352 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1353 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1354 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1355 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1356 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1357 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1358 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1359 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1360 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1361 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1362 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1363 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1364 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1365 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1366 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1367 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1368 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1369 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1370 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1371 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1372 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1373 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1374 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1375 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1376 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1377 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1378 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1379 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1380 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1381 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1382 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1383 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1384 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1385 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1386 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1387 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1388 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1389 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1390 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1391 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1392 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1393 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1394 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1395 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1396 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1397 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1398 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1399 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1400 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1401 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1402 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1403 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1404 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1405 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1406 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1407 */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1408  - AIF2 EQ Gains (1) */
+        { 0xFFC0, 0xFFC0, 0x0000 }, /* R1409  - AIF2 EQ Gains (2) */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1410  - AIF2 EQ Band 1 A */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1411  - AIF2 EQ Band 1 B */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1412  - AIF2 EQ Band 1 PG */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1413  - AIF2 EQ Band 2 A */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1414  - AIF2 EQ Band 2 B */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1415  - AIF2 EQ Band 2 C */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1416  - AIF2 EQ Band 2 PG */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1417  - AIF2 EQ Band 3 A */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1418  - AIF2 EQ Band 3 B */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1419  - AIF2 EQ Band 3 C */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1420  - AIF2 EQ Band 3 PG */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1421  - AIF2 EQ Band 4 A */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1422  - AIF2 EQ Band 4 B */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1423  - AIF2 EQ Band 4 C */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1424  - AIF2 EQ Band 4 PG */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1425  - AIF2 EQ Band 5 A */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1426  - AIF2 EQ Band 5 B */
+        { 0xFFFF, 0xFFFF, 0x0000 }, /* R1427  - AIF2 EQ Band 5 PG */
+        { 0x0000, 0x0000, 0x0000 }, /* R1428 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1429 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1430 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1431 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1432 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1433 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1434 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1435 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1436 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1437 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1438 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1439 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1440 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1441 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1442 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1443 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1444 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1445 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1446 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1447 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1448 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1449 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1450 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1451 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1452 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1453 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1454 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1455 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1456 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1457 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1458 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1459 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1460 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1461 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1462 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1463 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1464 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1465 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1466 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1467 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1468 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1469 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1470 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1471 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1472 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1473 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1474 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1475 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1476 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1477 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1478 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1479 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1480 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1481 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1482 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1483 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1484 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1485 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1486 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1487 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1488 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1489 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1490 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1491 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1492 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1493 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1494 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1495 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1496 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1497 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1498 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1499 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1500 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1501 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1502 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1503 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1504 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1505 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1506 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1507 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1508 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1509 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1510 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1511 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1512 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1513 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1514 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1515 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1516 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1517 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1518 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1519 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1520 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1521 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1522 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1523 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1524 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1525 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1526 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1527 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1528 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1529 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1530 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1531 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1532 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1533 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1534 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1535 */
+        { 0x01EF, 0x01EF, 0x0000 }, /* R1536  - DAC1 Mixer Volumes */
+        { 0x0037, 0x0037, 0x0000 }, /* R1537  - DAC1 Left Mixer Routing */
+        { 0x0037, 0x0037, 0x0000 }, /* R1538  - DAC1 Right Mixer Routing */
+        { 0x01EF, 0x01EF, 0x0000 }, /* R1539  - DAC2 Mixer Volumes */
+        { 0x0037, 0x0037, 0x0000 }, /* R1540  - DAC2 Left Mixer Routing */
+        { 0x0037, 0x0037, 0x0000 }, /* R1541  - DAC2 Right Mixer Routing */
+        { 0x0003, 0x0003, 0x0000 }, /* R1542  - AIF1 ADC1 Left Mixer Routing */
+        { 0x0003, 0x0003, 0x0000 }, /* R1543  - AIF1 ADC1 Right Mixer Routing */
+        { 0x0003, 0x0003, 0x0000 }, /* R1544  - AIF1 ADC2 Left Mixer Routing */
+        { 0x0003, 0x0003, 0x0000 }, /* R1545  - AIF1 ADC2 Right mixer Routing */
+        { 0x0000, 0x0000, 0x0000 }, /* R1546 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1547 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1548 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1549 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1550 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1551 */
+        { 0x02FF, 0x03FF, 0x0000 }, /* R1552  - DAC1 Left Volume */
+        { 0x02FF, 0x03FF, 0x0000 }, /* R1553  - DAC1 Right Volume */
+        { 0x02FF, 0x03FF, 0x0000 }, /* R1554  - DAC2 Left Volume */
+        { 0x02FF, 0x03FF, 0x0000 }, /* R1555  - DAC2 Right Volume */
+        { 0x0003, 0x0003, 0x0000 }, /* R1556  - DAC Softmute */
+        { 0x0000, 0x0000, 0x0000 }, /* R1557 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1558 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1559 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1560 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1561 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1562 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1563 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1564 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1565 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1566 */
+        { 0x0000, 0x0000, 0x0000 }, /* R1567 */
+        { 0x0003, 0x0003, 0x0000 }, /* R1568  - Oversampling */
+        { 0x03C3, 0x03C3, 0x0000 }, /* R1569  - Sidetone */
+};
+
+static int wm8994_readable(unsigned int reg)
+{
+        if (reg >= ARRAY_SIZE(access_masks))
+                return 0;
+        return access_masks[reg].readable != 0;
+}
+
+static int wm8994_volatile(unsigned int reg)
+{
+        if (reg >= WM8994_REG_CACHE_SIZE)
+                return 1;
+
+        switch (reg) {
+        case WM8994_SOFTWARE_RESET:
+        case WM8994_CHIP_REVISION:
+        case WM8994_DC_SERVO_1:
+        case WM8994_DC_SERVO_READBACK:
+        case WM8994_RATE_STATUS:
+        case WM8994_LDO_1:
+        case WM8994_LDO_2:
+                return 1;
+        default:
+                return 0;
+        }
+}
+
+static int wm8994_write(struct snd_soc_codec *codec, unsigned int reg,
+        unsigned int value)
+{
+        struct wm8994_priv *wm8994 = codec->private_data;
+
+        BUG_ON(reg > WM8994_MAX_REGISTER);
+
+        if (!wm8994_volatile(reg))
+                wm8994->reg_cache[reg] = value;
+
+        return wm8994_reg_write(codec->control_data, reg, value);
+}
+
+static unsigned int wm8994_read(struct snd_soc_codec *codec,
+                                unsigned int reg)
+{
+        u16 *reg_cache = codec->reg_cache;
+
+        BUG_ON(reg > WM8994_MAX_REGISTER);
+
+        if (wm8994_volatile(reg))
+                return wm8994_reg_read(codec->control_data, reg);
+        else
+                return reg_cache[reg];
+}
+
+static int configure_aif_clock(struct snd_soc_codec *codec, int aif)
+{
+        struct wm8994_priv *wm8994 = codec->private_data;
+        int rate;
+        int reg1 = 0;
+        int offset;
+
+        if (aif)
+                offset = 4;
+        else
+                offset = 0;
+
+        switch (wm8994->sysclk[aif]) {
+        case WM8994_SYSCLK_MCLK1:
+                rate = wm8994->mclk[0];
+                break;
+
+        case WM8994_SYSCLK_MCLK2:
+                reg1 |= 0x8;
+                rate = wm8994->mclk[1];
+                break;
+
+        case WM8994_SYSCLK_FLL1:
+                reg1 |= 0x10;
+                rate = wm8994->fll[0].out;
+                break;
+
+        case WM8994_SYSCLK_FLL2:
+                reg1 |= 0x18;
+                rate = wm8994->fll[1].out;
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        if (rate >= 13500000) {
+                rate /= 2;
+                reg1 |= WM8994_AIF1CLK_DIV;
+
+                dev_dbg(codec->dev, "Dividing AIF%d clock to %dHz\n",
+                        aif + 1, rate);
+        }
+        wm8994->aifclk[aif] = rate;
+
+        snd_soc_update_bits(codec, WM8994_AIF1_CLOCKING_1 + offset,
+                            WM8994_AIF1CLK_SRC_MASK | WM8994_AIF1CLK_DIV,
+                            reg1);
+
+        return 0;
+}
+
+static int configure_clock(struct snd_soc_codec *codec)
+{
+        struct wm8994_priv *wm8994 = codec->private_data;
+        int old, new;
+
+        /* Bring up the AIF clocks first */
+        configure_aif_clock(codec, 0);
+        configure_aif_clock(codec, 1);
+
+        /* Then switch CLK_SYS over to the higher of them; a change
+         * can only happen as a result of a clocking change which can
+         * only be made outside of DAPM so we can safely redo the
+         * clocking.
+         */
+
+        /* If they're equal it doesn't matter which is used */
+        if (wm8994->aifclk[0] == wm8994->aifclk[1])
+                return 0;
+
+        if (wm8994->aifclk[0] < wm8994->aifclk[1])
+                new = WM8994_SYSCLK_SRC;
+        else
+                new = 0;
+
+        old = snd_soc_read(codec, WM8994_CLOCKING_1) & WM8994_SYSCLK_SRC;
+
+        /* If there's no change then we're done. */
+        if (old == new)
+                return 0;
+
+        snd_soc_update_bits(codec, WM8994_CLOCKING_1, WM8994_SYSCLK_SRC, new);
+
+        snd_soc_dapm_sync(codec);
+
+        return 0;
+}
+
+static int check_clk_sys(struct snd_soc_dapm_widget *source,
+                         struct snd_soc_dapm_widget *sink)
+{
+        int reg = snd_soc_read(source->codec, WM8994_CLOCKING_1);
+        const char *clk;
+
+        /* Check what we're currently using for CLK_SYS */
+        if (reg & WM8994_SYSCLK_SRC)
+                clk = "AIF2CLK";
+        else
+                clk = "AIF1CLK";
+
+        return strcmp(source->name, clk) == 0;
+}
+
+static const char *sidetone_hpf_text[] = {
+        "2.7kHz", "1.35kHz", "675Hz", "370Hz", "180Hz", "90Hz", "45Hz"
+};
+
+static const struct soc_enum sidetone_hpf =
+        SOC_ENUM_SINGLE(WM8994_SIDETONE, 7, 7, sidetone_hpf_text);
+
+static const DECLARE_TLV_DB_SCALE(aif_tlv, 0, 600, 0);
+static const DECLARE_TLV_DB_SCALE(digital_tlv, -7200, 75, 1);
+static const DECLARE_TLV_DB_SCALE(st_tlv, -3600, 300, 0);
+static const DECLARE_TLV_DB_SCALE(wm8994_3d_tlv, -1600, 183, 0);
+static const DECLARE_TLV_DB_SCALE(eq_tlv, -1200, 100, 0);
+
+#define WM8994_DRC_SWITCH(xname, reg, shift) \
+{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
+        .info = snd_soc_info_volsw, .get = snd_soc_get_volsw,\
+        .put = wm8994_put_drc_sw, \
+        .private_value =  SOC_SINGLE_VALUE(reg, shift, 1, 0) }
+
+static int wm8994_put_drc_sw(struct snd_kcontrol *kcontrol,
+                             struct snd_ctl_elem_value *ucontrol)
+{
+        struct soc_mixer_control *mc =
+                (struct soc_mixer_control *)kcontrol->private_value;
+        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+        int mask, ret;
+
+        /* Can't enable both ADC and DAC paths simultaneously */
+        if (mc->shift == WM8994_AIF1DAC1_DRC_ENA_SHIFT)
+                mask = WM8994_AIF1ADC1L_DRC_ENA_MASK |
+                        WM8994_AIF1ADC1R_DRC_ENA_MASK;
+        else
+                mask = WM8994_AIF1DAC1_DRC_ENA_MASK;
+
+        ret = snd_soc_read(codec, mc->reg);
+        if (ret < 0)
+                return ret;
+        if (ret & mask)
+                return -EINVAL;
+
+        return snd_soc_put_volsw(kcontrol, ucontrol);
+}
+
+
+
+static void wm8994_set_drc(struct snd_soc_codec *codec, int drc)
+{
+        struct wm8994_priv *wm8994 = codec->private_data;
+        struct wm8994_pdata *pdata = wm8994->pdata;
+        int base = wm8994_drc_base[drc];
+        int cfg = wm8994->drc_cfg[drc];
+        int save, i;
+
+        /* Save any enables; the configuration should clear them. */
+        save = snd_soc_read(codec, base);
+        save &= WM8994_AIF1DAC1_DRC_ENA | WM8994_AIF1ADC1L_DRC_ENA |
+                WM8994_AIF1ADC1R_DRC_ENA;
+
+        for (i = 0; i < WM8994_DRC_REGS; i++)
+                snd_soc_update_bits(codec, base + i, 0xffff,
+                                    pdata->drc_cfgs[cfg].regs[i]);
+
+        snd_soc_update_bits(codec, base, WM8994_AIF1DAC1_DRC_ENA |
+                             WM8994_AIF1ADC1L_DRC_ENA |
+                             WM8994_AIF1ADC1R_DRC_ENA, save);
+}
+
+/* Icky as hell but saves code duplication */
+static int wm8994_get_drc(const char *name)
+{
+        if (strcmp(name, "AIF1DRC1 Mode") == 0)
+                return 0;
+        if (strcmp(name, "AIF1DRC2 Mode") == 0)
+                return 1;
+        if (strcmp(name, "AIF2DRC Mode") == 0)
+                return 2;
+        return -EINVAL;
+}
+
+static int wm8994_put_drc_enum(struct snd_kcontrol *kcontrol,
+                               struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct wm8994_priv *wm8994 = codec->private_data;       
+        struct wm8994_pdata *pdata = wm8994->pdata;
+        int drc = wm8994_get_drc(kcontrol->id.name);
+        int value = ucontrol->value.integer.value[0];
+
+        if (drc < 0)
+                return drc;
+
+        if (value >= pdata->num_drc_cfgs)
+                return -EINVAL;
+
+        wm8994->drc_cfg[drc] = value;
+
+        wm8994_set_drc(codec, drc);
+
+        return 0;
+}
+
+static int wm8994_get_drc_enum(struct snd_kcontrol *kcontrol,
+                               struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct wm8994_priv *wm8994 = codec->private_data;
+        int drc = wm8994_get_drc(kcontrol->id.name);
+
+        ucontrol->value.enumerated.item[0] = wm8994->drc_cfg[drc];
+
+        return 0;
+}
+
+static void wm8994_set_retune_mobile(struct snd_soc_codec *codec, int block)
+{
+        struct wm8994_priv *wm8994 = codec->private_data;
+        struct wm8994_pdata *pdata = wm8994->pdata;
+        int base = wm8994_retune_mobile_base[block];
+        int iface, best, best_val, save, i, cfg;
+
+        if (!pdata || !wm8994->num_retune_mobile_texts)
+                return;
+
+        switch (block) {
+        case 0:
+        case 1:
+                iface = 0;
+                break;
+        case 2:
+                iface = 1;
+                break;
+        default:
+                return;
+        }
+
+        /* Find the version of the currently selected configuration
+         * with the nearest sample rate. */
+        cfg = wm8994->retune_mobile_cfg[block];
+        best = 0;
+        best_val = INT_MAX;
+        for (i = 0; i < pdata->num_retune_mobile_cfgs; i++) {
+                if (strcmp(pdata->retune_mobile_cfgs[i].name,
+                           wm8994->retune_mobile_texts[cfg]) == 0 &&
+                    abs(pdata->retune_mobile_cfgs[i].rate
+                        - wm8994->dac_rates[iface]) < best_val) {
+                        best = i;
+                        best_val = abs(pdata->retune_mobile_cfgs[i].rate
+                                       - wm8994->dac_rates[iface]);
+                }
+        }
+
+        dev_dbg(codec->dev, "ReTune Mobile %d %s/%dHz for %dHz sample rate\n",
+                block,
+                pdata->retune_mobile_cfgs[best].name,
+                pdata->retune_mobile_cfgs[best].rate,
+                wm8994->dac_rates[iface]);
+
+        /* The EQ will be disabled while reconfiguring it, remember the
+         * current configuration. 
+         */
+        save = snd_soc_read(codec, base);
+        save &= WM8994_AIF1DAC1_EQ_ENA;
+
+        for (i = 0; i < WM8994_EQ_REGS; i++)
+                snd_soc_update_bits(codec, base + i, 0xffff,
+                                pdata->retune_mobile_cfgs[best].regs[i]);
+
+        snd_soc_update_bits(codec, base, WM8994_AIF1DAC1_EQ_ENA, save);
+}
+
+/* Icky as hell but saves code duplication */
+static int wm8994_get_retune_mobile_block(const char *name)
+{
+        if (strcmp(name, "AIF1.1 EQ Mode") == 0)
+                return 0;
+        if (strcmp(name, "AIF1.2 EQ Mode") == 0)
+                return 1;
+        if (strcmp(name, "AIF2 EQ Mode") == 0)
+                return 2;
+        return -EINVAL;
+}
+
+static int wm8994_put_retune_mobile_enum(struct snd_kcontrol *kcontrol,
+                                         struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct wm8994_priv *wm8994 = codec->private_data;       
+        struct wm8994_pdata *pdata = wm8994->pdata;
+        int block = wm8994_get_retune_mobile_block(kcontrol->id.name);
+        int value = ucontrol->value.integer.value[0];
+
+        if (block < 0)
+                return block;
+
+        if (value >= pdata->num_retune_mobile_cfgs)
+                return -EINVAL;
+
+        wm8994->retune_mobile_cfg[block] = value;
+
+        wm8994_set_retune_mobile(codec, block);
+
+        return 0;
+}
+
+static int wm8994_get_retune_mobile_enum(struct snd_kcontrol *kcontrol,
+                                         struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct wm8994_priv *wm8994 = codec->private_data;
+        int block = wm8994_get_retune_mobile_block(kcontrol->id.name);
+
+        ucontrol->value.enumerated.item[0] = wm8994->retune_mobile_cfg[block];
+
+        return 0;
+}
+
+static const struct snd_kcontrol_new wm8994_snd_controls[] = {
+SOC_DOUBLE_R_TLV("AIF1ADC1 Volume", WM8994_AIF1_ADC1_LEFT_VOLUME,
+                 WM8994_AIF1_ADC1_RIGHT_VOLUME,
+                 1, 119, 0, digital_tlv),
+SOC_DOUBLE_R_TLV("AIF1ADC2 Volume", WM8994_AIF1_ADC2_LEFT_VOLUME,
+                 WM8994_AIF1_ADC2_RIGHT_VOLUME,
+                 1, 119, 0, digital_tlv),
+SOC_DOUBLE_R_TLV("AIF2ADC Volume", WM8994_AIF2_ADC_LEFT_VOLUME,
+                 WM8994_AIF2_ADC_RIGHT_VOLUME,
+                 1, 119, 0, digital_tlv),
+
+SOC_DOUBLE_R_TLV("AIF1DAC1 Volume", WM8994_AIF1_DAC1_LEFT_VOLUME,
+                 WM8994_AIF1_DAC1_RIGHT_VOLUME, 1, 96, 0, digital_tlv),
+SOC_DOUBLE_R_TLV("AIF1DAC2 Volume", WM8994_AIF1_DAC2_LEFT_VOLUME,
+                 WM8994_AIF1_DAC2_RIGHT_VOLUME, 1, 96, 0, digital_tlv),
+SOC_DOUBLE_R_TLV("AIF2DAC Volume", WM8994_AIF2_DAC_LEFT_VOLUME,
+                 WM8994_AIF2_DAC_RIGHT_VOLUME, 1, 96, 0, digital_tlv),
+
+SOC_SINGLE_TLV("AIF1 Boost Volume", WM8994_AIF1_CONTROL_2, 10, 3, 0, aif_tlv),
+SOC_SINGLE_TLV("AIF2 Boost Volume", WM8994_AIF2_CONTROL_2, 10, 3, 0, aif_tlv),
+
+SOC_SINGLE("AIF1DAC1 EQ Switch", WM8994_AIF1_DAC1_EQ_GAINS_1, 0, 1, 0),
+SOC_SINGLE("AIF1DAC2 EQ Switch", WM8994_AIF1_DAC2_EQ_GAINS_1, 0, 1, 0),
+SOC_SINGLE("AIF2 EQ Switch", WM8994_AIF2_EQ_GAINS_1, 0, 1, 0),
+
+WM8994_DRC_SWITCH("AIF1DAC1 DRC Switch", WM8994_AIF1_DRC1_1, 2),
+WM8994_DRC_SWITCH("AIF1ADC1L DRC Switch", WM8994_AIF1_DRC1_1, 1),
+WM8994_DRC_SWITCH("AIF1ADC1R DRC Switch", WM8994_AIF1_DRC1_1, 0),
+
+WM8994_DRC_SWITCH("AIF1DAC2 DRC Switch", WM8994_AIF1_DRC2_1, 2),
+WM8994_DRC_SWITCH("AIF1ADC2L DRC Switch", WM8994_AIF1_DRC2_1, 1),
+WM8994_DRC_SWITCH("AIF1ADC2R DRC Switch", WM8994_AIF1_DRC2_1, 0),
+
+WM8994_DRC_SWITCH("AIF2DAC DRC Switch", WM8994_AIF2_DRC_1, 2),
+WM8994_DRC_SWITCH("AIF2ADCL DRC Switch", WM8994_AIF2_DRC_1, 1),
+WM8994_DRC_SWITCH("AIF2ADCR DRC Switch", WM8994_AIF2_DRC_1, 0),
+
+SOC_SINGLE_TLV("DAC1 Right Sidetone Volume", WM8994_DAC1_MIXER_VOLUMES,
+               5, 12, 0, st_tlv),
+SOC_SINGLE_TLV("DAC1 Left Sidetone Volume", WM8994_DAC1_MIXER_VOLUMES,
+               0, 12, 0, st_tlv),
+SOC_SINGLE_TLV("DAC2 Right Sidetone Volume", WM8994_DAC2_MIXER_VOLUMES,
+               5, 12, 0, st_tlv),
+SOC_SINGLE_TLV("DAC2 Left Sidetone Volume", WM8994_DAC2_MIXER_VOLUMES,
+               0, 12, 0, st_tlv),
+SOC_ENUM("Sidetone HPF Mux", sidetone_hpf),
+SOC_SINGLE("Sidetone HPF Switch", WM8994_SIDETONE, 6, 1, 0),
+
+SOC_DOUBLE_R_TLV("DAC1 Volume", WM8994_DAC1_LEFT_VOLUME,
+                 WM8994_DAC1_RIGHT_VOLUME, 1, 96, 0, digital_tlv),
+SOC_DOUBLE_R("DAC1 Switch", WM8994_DAC1_LEFT_VOLUME,
+             WM8994_DAC1_RIGHT_VOLUME, 9, 1, 1),
+
+SOC_DOUBLE_R_TLV("DAC2 Volume", WM8994_DAC2_LEFT_VOLUME,
+                 WM8994_DAC2_RIGHT_VOLUME, 1, 96, 0, digital_tlv),
+SOC_DOUBLE_R("DAC2 Switch", WM8994_DAC2_LEFT_VOLUME,
+             WM8994_DAC2_RIGHT_VOLUME, 9, 1, 1),
+
+SOC_SINGLE_TLV("SPKL DAC2 Volume", WM8994_SPKMIXL_ATTENUATION,
+               6, 1, 1, wm_hubs_spkmix_tlv),
+SOC_SINGLE_TLV("SPKL DAC1 Volume", WM8994_SPKMIXL_ATTENUATION,
+               2, 1, 1, wm_hubs_spkmix_tlv),
+
+SOC_SINGLE_TLV("SPKR DAC2 Volume", WM8994_SPKMIXR_ATTENUATION,
+               6, 1, 1, wm_hubs_spkmix_tlv),
+SOC_SINGLE_TLV("SPKR DAC1 Volume", WM8994_SPKMIXR_ATTENUATION,
+               2, 1, 1, wm_hubs_spkmix_tlv),
+
+SOC_SINGLE_TLV("AIF1DAC1 3D Stereo Volume", WM8994_AIF1_DAC1_FILTERS_2,
+               10, 15, 0, wm8994_3d_tlv),
+SOC_SINGLE("AIF1DAC1 3D Stereo Switch", WM8994_AIF1_DAC2_FILTERS_2,
+           8, 1, 0),
+SOC_SINGLE_TLV("AIF1DAC2 3D Stereo Volume", WM8994_AIF1_DAC2_FILTERS_2,
+               10, 15, 0, wm8994_3d_tlv),
+SOC_SINGLE("AIF1DAC2 3D Stereo Switch", WM8994_AIF1_DAC2_FILTERS_2,
+           8, 1, 0),
+SOC_SINGLE_TLV("AIF2DAC 3D Stereo Volume", WM8994_AIF1_DAC1_FILTERS_2,
+               10, 15, 0, wm8994_3d_tlv),
+SOC_SINGLE("AIF2DAC 3D Stereo Switch", WM8994_AIF1_DAC2_FILTERS_2,
+           8, 1, 0),
+};
+
+static const struct snd_kcontrol_new wm8994_eq_controls[] = {
+SOC_SINGLE_TLV("AIF1DAC1 EQ1 Volume", WM8994_AIF1_DAC1_EQ_GAINS_1, 11, 31, 0,
+               eq_tlv),
+SOC_SINGLE_TLV("AIF1DAC1 EQ2 Volume", WM8994_AIF1_DAC1_EQ_GAINS_1, 6, 31, 0,
+               eq_tlv),
+SOC_SINGLE_TLV("AIF1DAC1 EQ3 Volume", WM8994_AIF1_DAC1_EQ_GAINS_1, 1, 31, 0,
+               eq_tlv),
+SOC_SINGLE_TLV("AIF1DAC1 EQ4 Volume", WM8994_AIF1_DAC1_EQ_GAINS_2, 11, 31, 0,
+               eq_tlv),
+SOC_SINGLE_TLV("AIF1DAC1 EQ5 Volume", WM8994_AIF1_DAC1_EQ_GAINS_2, 6, 31, 0,
+               eq_tlv),
+
+SOC_SINGLE_TLV("AIF1DAC2 EQ1 Volume", WM8994_AIF1_DAC2_EQ_GAINS_1, 11, 31, 0,
+               eq_tlv),
+SOC_SINGLE_TLV("AIF1DAC2 EQ2 Volume", WM8994_AIF1_DAC2_EQ_GAINS_1, 6, 31, 0,
+               eq_tlv),
+SOC_SINGLE_TLV("AIF1DAC2 EQ3 Volume", WM8994_AIF1_DAC2_EQ_GAINS_1, 1, 31, 0,
+               eq_tlv),
+SOC_SINGLE_TLV("AIF1DAC2 EQ4 Volume", WM8994_AIF1_DAC2_EQ_GAINS_2, 11, 31, 0,
+               eq_tlv),
+SOC_SINGLE_TLV("AIF1DAC2 EQ5 Volume", WM8994_AIF1_DAC2_EQ_GAINS_2, 6, 31, 0,
+               eq_tlv),
+
+SOC_SINGLE_TLV("AIF2 EQ1 Volume", WM8994_AIF2_EQ_GAINS_1, 11, 31, 0,
+               eq_tlv),
+SOC_SINGLE_TLV("AIF2 EQ2 Volume", WM8994_AIF2_EQ_GAINS_1, 6, 31, 0,
+               eq_tlv),
+SOC_SINGLE_TLV("AIF2 EQ3 Volume", WM8994_AIF2_EQ_GAINS_1, 1, 31, 0,
+               eq_tlv),
+SOC_SINGLE_TLV("AIF2 EQ4 Volume", WM8994_AIF2_EQ_GAINS_2, 11, 31, 0,
+               eq_tlv),
+SOC_SINGLE_TLV("AIF2 EQ5 Volume", WM8994_AIF2_EQ_GAINS_2, 6, 31, 0,
+               eq_tlv),
+};
+
+static int clk_sys_event(struct snd_soc_dapm_widget *w,
+                         struct snd_kcontrol *kcontrol, int event)
+{
+        struct snd_soc_codec *codec = w->codec;
+
+        switch (event) {
+        case SND_SOC_DAPM_PRE_PMU:
+                return configure_clock(codec);
+
+        case SND_SOC_DAPM_POST_PMD:
+                configure_clock(codec);
+                break;
+        }
+
+        return 0;
+}
+
+static void wm8994_update_class_w(struct snd_soc_codec *codec)
+{
+        int enable = 1;
+        int source = 0;  /* GCC flow analysis can't track enable */
+        int reg, reg_r;
+
+        /* Only support direct DAC->headphone paths */
+        reg = snd_soc_read(codec, WM8994_OUTPUT_MIXER_1);
+        if (!(reg & WM8994_DAC1L_TO_HPOUT1L)) {
+                dev_dbg(codec->dev, "HPL connected to output mixer\n");
+                enable = 0;
+        }
+
+        reg = snd_soc_read(codec, WM8994_OUTPUT_MIXER_2);
+        if (!(reg & WM8994_DAC1R_TO_HPOUT1R)) {
+                dev_dbg(codec->dev, "HPR connected to output mixer\n");
+                enable = 0;
+        }
+
+        /* We also need the same setting for L/R and only one path */
+        reg = snd_soc_read(codec, WM8994_DAC1_LEFT_MIXER_ROUTING);
+        switch (reg) {
+        case WM8994_AIF2DACL_TO_DAC1L:
+                dev_dbg(codec->dev, "Class W source AIF2DAC\n");
+                source = 2 << WM8994_CP_DYN_SRC_SEL_SHIFT;
+                break;
+        case WM8994_AIF1DAC2L_TO_DAC1L:
+                dev_dbg(codec->dev, "Class W source AIF1DAC2\n");
+                source = 1 << WM8994_CP_DYN_SRC_SEL_SHIFT;
+                break;
+        case WM8994_AIF1DAC1L_TO_DAC1L:
+                dev_dbg(codec->dev, "Class W source AIF1DAC1\n");
+                source = 0 << WM8994_CP_DYN_SRC_SEL_SHIFT;
+                break;
+        default:
+                dev_dbg(codec->dev, "DAC mixer setting: %x\n", reg);
+                enable = 0;
+                break;
+        }
+
+        reg_r = snd_soc_read(codec, WM8994_DAC1_RIGHT_MIXER_ROUTING);
+        if (reg_r != reg) {
+                dev_dbg(codec->dev, "Left and right DAC mixers different\n");
+                enable = 0;
+        }
+
+        if (enable) {
+                dev_dbg(codec->dev, "Class W enabled\n");
+                snd_soc_update_bits(codec, WM8994_CLASS_W_1,
+                                    WM8994_CP_DYN_PWR |
+                                    WM8994_CP_DYN_SRC_SEL_MASK,
+                                    source | WM8994_CP_DYN_PWR);
+                
+        } else {
+                dev_dbg(codec->dev, "Class W disabled\n");
+                snd_soc_update_bits(codec, WM8994_CLASS_W_1,
+                                    WM8994_CP_DYN_PWR, 0);
+        }
+}
+
+static const char *hp_mux_text[] = {
+        "Mixer",
+        "DAC",
+};
+
+#define WM8994_HP_ENUM(xname, xenum) \
+{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
+        .info = snd_soc_info_enum_double, \
+        .get = snd_soc_dapm_get_enum_double, \
+        .put = wm8994_put_hp_enum, \
+        .private_value = (unsigned long)&xenum }
+
+static int wm8994_put_hp_enum(struct snd_kcontrol *kcontrol,
+                              struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_dapm_widget *w = snd_kcontrol_chip(kcontrol);
+        struct snd_soc_codec *codec = w->codec;
+        int ret;
+
+        ret = snd_soc_dapm_put_enum_double(kcontrol, ucontrol);
+
+        wm8994_update_class_w(codec);
+
+        return ret;
+}
+
+static const struct soc_enum hpl_enum =
+        SOC_ENUM_SINGLE(WM8994_OUTPUT_MIXER_1, 8, 2, hp_mux_text);
+
+static const struct snd_kcontrol_new hpl_mux =
+        WM8994_HP_ENUM("Left Headphone Mux", hpl_enum);
+
+static const struct soc_enum hpr_enum =
+        SOC_ENUM_SINGLE(WM8994_OUTPUT_MIXER_2, 8, 2, hp_mux_text);
+
+static const struct snd_kcontrol_new hpr_mux =
+        WM8994_HP_ENUM("Right Headphone Mux", hpr_enum);
+
+static const char *adc_mux_text[] = {
+        "ADC",
+        "DMIC",
+};
+
+static const struct soc_enum adc_enum =
+        SOC_ENUM_SINGLE(0, 0, 2, adc_mux_text);
+
+static const struct snd_kcontrol_new adcl_mux =
+        SOC_DAPM_ENUM_VIRT("ADCL Mux", adc_enum);
+
+static const struct snd_kcontrol_new adcr_mux =
+        SOC_DAPM_ENUM_VIRT("ADCR Mux", adc_enum);
+
+static const struct snd_kcontrol_new left_speaker_mixer[] = {
+SOC_DAPM_SINGLE("DAC2 Switch", WM8994_SPEAKER_MIXER, 9, 1, 0),
+SOC_DAPM_SINGLE("Input Switch", WM8994_SPEAKER_MIXER, 7, 1, 0),
+SOC_DAPM_SINGLE("IN1LP Switch", WM8994_SPEAKER_MIXER, 5, 1, 0),
+SOC_DAPM_SINGLE("Output Switch", WM8994_SPEAKER_MIXER, 3, 1, 0),
+SOC_DAPM_SINGLE("DAC1 Switch", WM8994_SPEAKER_MIXER, 1, 1, 0),
+};
+
+static const struct snd_kcontrol_new right_speaker_mixer[] = {
+SOC_DAPM_SINGLE("DAC2 Switch", WM8994_SPEAKER_MIXER, 8, 1, 0),
+SOC_DAPM_SINGLE("Input Switch", WM8994_SPEAKER_MIXER, 6, 1, 0),
+SOC_DAPM_SINGLE("IN1RP Switch", WM8994_SPEAKER_MIXER, 4, 1, 0),
+SOC_DAPM_SINGLE("Output Switch", WM8994_SPEAKER_MIXER, 2, 1, 0),
+SOC_DAPM_SINGLE("DAC1 Switch", WM8994_SPEAKER_MIXER, 0, 1, 0),
+};
+
+/* Debugging; dump chip status after DAPM transitions */
+static int post_ev(struct snd_soc_dapm_widget *w,
+            struct snd_kcontrol *kcontrol, int event)
+{
+        struct snd_soc_codec *codec = w->codec;
+        dev_dbg(codec->dev, "SRC status: %x\n",
+                snd_soc_read(codec,
+                             WM8994_RATE_STATUS));
+        return 0;
+}
+
+static const struct snd_kcontrol_new aif1adc1l_mix[] = {
+SOC_DAPM_SINGLE("ADC/DMIC Switch", WM8994_AIF1_ADC1_LEFT_MIXER_ROUTING,
+                1, 1, 0),
+SOC_DAPM_SINGLE("AIF2 Switch", WM8994_AIF1_ADC1_LEFT_MIXER_ROUTING,
+                0, 1, 0),
+};
+
+static const struct snd_kcontrol_new aif1adc1r_mix[] = {
+SOC_DAPM_SINGLE("ADC/DMIC Switch", WM8994_AIF1_ADC1_RIGHT_MIXER_ROUTING,
+                1, 1, 0),
+SOC_DAPM_SINGLE("AIF2 Switch", WM8994_AIF1_ADC1_RIGHT_MIXER_ROUTING,
+                0, 1, 0),
+};
+
+static const struct snd_kcontrol_new aif2dac2l_mix[] = {
+SOC_DAPM_SINGLE("Right Sidetone Switch", WM8994_DAC2_LEFT_MIXER_ROUTING,
+                5, 1, 0),
+SOC_DAPM_SINGLE("Left Sidetone Switch", WM8994_DAC2_LEFT_MIXER_ROUTING,
+                4, 1, 0),
+SOC_DAPM_SINGLE("AIF2 Switch", WM8994_DAC2_LEFT_MIXER_ROUTING,
+                2, 1, 0),
+SOC_DAPM_SINGLE("AIF1.2 Switch", WM8994_DAC2_LEFT_MIXER_ROUTING,
+                1, 1, 0),
+SOC_DAPM_SINGLE("AIF1.1 Switch", WM8994_DAC2_LEFT_MIXER_ROUTING,
+                0, 1, 0),
+};
+
+static const struct snd_kcontrol_new aif2dac2r_mix[] = {
+SOC_DAPM_SINGLE("Right Sidetone Switch", WM8994_DAC2_RIGHT_MIXER_ROUTING,
+                5, 1, 0),
+SOC_DAPM_SINGLE("Left Sidetone Switch", WM8994_DAC2_RIGHT_MIXER_ROUTING,
+                4, 1, 0),
+SOC_DAPM_SINGLE("AIF2 Switch", WM8994_DAC2_RIGHT_MIXER_ROUTING,
+                2, 1, 0),
+SOC_DAPM_SINGLE("AIF1.2 Switch", WM8994_DAC2_RIGHT_MIXER_ROUTING,
+                1, 1, 0),
+SOC_DAPM_SINGLE("AIF1.1 Switch", WM8994_DAC2_RIGHT_MIXER_ROUTING,
+                0, 1, 0),
+};
+
+#define WM8994_CLASS_W_SWITCH(xname, reg, shift, max, invert) \
+{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
+        .info = snd_soc_info_volsw, \
+        .get = snd_soc_dapm_get_volsw, .put = wm8994_put_class_w, \
+        .private_value =  SOC_SINGLE_VALUE(reg, shift, max, invert) }
+
+static int wm8994_put_class_w(struct snd_kcontrol *kcontrol,
+                              struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_dapm_widget *w = snd_kcontrol_chip(kcontrol);
+        struct snd_soc_codec *codec = w->codec;
+        int ret;
+
+        ret = snd_soc_dapm_put_volsw(kcontrol, ucontrol);
+
+        wm8994_update_class_w(codec);
+
+        return ret;
+}
+
+static const struct snd_kcontrol_new dac1l_mix[] = {
+WM8994_CLASS_W_SWITCH("Right Sidetone Switch", WM8994_DAC1_LEFT_MIXER_ROUTING,
+                      5, 1, 0),
+WM8994_CLASS_W_SWITCH("Left Sidetone Switch", WM8994_DAC1_LEFT_MIXER_ROUTING,
+                      4, 1, 0),
+WM8994_CLASS_W_SWITCH("AIF2 Switch", WM8994_DAC1_LEFT_MIXER_ROUTING,
+                      2, 1, 0),
+WM8994_CLASS_W_SWITCH("AIF1.2 Switch", WM8994_DAC1_LEFT_MIXER_ROUTING,
+                      1, 1, 0),
+WM8994_CLASS_W_SWITCH("AIF1.1 Switch", WM8994_DAC1_LEFT_MIXER_ROUTING,
+                      0, 1, 0),
+};
+
+static const struct snd_kcontrol_new dac1r_mix[] = {
+WM8994_CLASS_W_SWITCH("Right Sidetone Switch", WM8994_DAC1_RIGHT_MIXER_ROUTING,
+                      5, 1, 0),
+WM8994_CLASS_W_SWITCH("Left Sidetone Switch", WM8994_DAC1_RIGHT_MIXER_ROUTING,
+                      4, 1, 0),
+WM8994_CLASS_W_SWITCH("AIF2 Switch", WM8994_DAC1_RIGHT_MIXER_ROUTING,
+                      2, 1, 0),
+WM8994_CLASS_W_SWITCH("AIF1.2 Switch", WM8994_DAC1_RIGHT_MIXER_ROUTING,
+                      1, 1, 0),
+WM8994_CLASS_W_SWITCH("AIF1.1 Switch", WM8994_DAC1_RIGHT_MIXER_ROUTING,
+                      0, 1, 0),
+};
+
+static const char *sidetone_text[] = {
+        "ADC/DMIC1", "DMIC2",
+};
+
+static const struct soc_enum sidetone1_enum =
+        SOC_ENUM_SINGLE(WM8994_SIDETONE, 0, 2, sidetone_text);
+
+static const struct snd_kcontrol_new sidetone1_mux =
+        SOC_DAPM_ENUM("Left Sidetone Mux", sidetone1_enum);
+
+static const struct soc_enum sidetone2_enum =
+        SOC_ENUM_SINGLE(WM8994_SIDETONE, 1, 2, sidetone_text);
+
+static const struct snd_kcontrol_new sidetone2_mux =
+        SOC_DAPM_ENUM("Right Sidetone Mux", sidetone2_enum);
+
+static const char *aif1dac_text[] = {
+        "AIF1DACDAT", "AIF3DACDAT",
+};
+
+static const struct soc_enum aif1dac_enum =
+        SOC_ENUM_SINGLE(WM8994_POWER_MANAGEMENT_6, 0, 2, aif1dac_text);
+
+static const struct snd_kcontrol_new aif1dac_mux =
+        SOC_DAPM_ENUM("AIF1DAC Mux", aif1dac_enum);
+
+static const char *aif2dac_text[] = {
+        "AIF2DACDAT", "AIF3DACDAT",
+};
+
+static const struct soc_enum aif2dac_enum =
+        SOC_ENUM_SINGLE(WM8994_POWER_MANAGEMENT_6, 1, 2, aif2dac_text);
+
+static const struct snd_kcontrol_new aif2dac_mux =
+        SOC_DAPM_ENUM("AIF2DAC Mux", aif2dac_enum);
+
+static const char *aif2adc_text[] = {
+        "AIF2ADCDAT", "AIF3DACDAT",
+};
+
+static const struct soc_enum aif2adc_enum =
+        SOC_ENUM_SINGLE(WM8994_POWER_MANAGEMENT_6, 2, 2, aif2adc_text);
+
+static const struct snd_kcontrol_new aif2adc_mux =
+        SOC_DAPM_ENUM("AIF2ADC Mux", aif2adc_enum);
+
+static const char *aif3adc_text[] = {
+        "AIF1ADCDAT", "AIF2ADCDAT", "AIF2DACDAT",
+};
+
+static const struct soc_enum aif3adc_enum =
+        SOC_ENUM_SINGLE(WM8994_POWER_MANAGEMENT_6, 3, 3, aif3adc_text);
+
+static const struct snd_kcontrol_new aif3adc_mux =
+        SOC_DAPM_ENUM("AIF3ADC Mux", aif3adc_enum);
+
+static const struct snd_soc_dapm_widget wm8994_dapm_widgets[] = {
+SND_SOC_DAPM_INPUT("DMIC1DAT"),
+SND_SOC_DAPM_INPUT("DMIC2DAT"),
+
+SND_SOC_DAPM_SUPPLY("CLK_SYS", SND_SOC_NOPM, 0, 0, clk_sys_event,
+                    SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
+
+SND_SOC_DAPM_SUPPLY("DSP1CLK", WM8994_CLOCKING_1, 3, 0, NULL, 0),
+SND_SOC_DAPM_SUPPLY("DSP2CLK", WM8994_CLOCKING_1, 2, 0, NULL, 0),
+SND_SOC_DAPM_SUPPLY("DSPINTCLK", WM8994_CLOCKING_1, 1, 0, NULL, 0),
+
+SND_SOC_DAPM_SUPPLY("AIF1CLK", WM8994_AIF1_CLOCKING_1, 0, 0, NULL, 0),
+SND_SOC_DAPM_SUPPLY("AIF2CLK", WM8994_AIF2_CLOCKING_1, 0, 0, NULL, 0),
+
+SND_SOC_DAPM_AIF_OUT("AIF1ADC1L", "AIF1 Capture",
+                     0, WM8994_POWER_MANAGEMENT_4, 9, 0),
+SND_SOC_DAPM_AIF_OUT("AIF1ADC1R", "AIF1 Capture",
+                     0, WM8994_POWER_MANAGEMENT_4, 8, 0),
+SND_SOC_DAPM_AIF_IN("AIF1DAC1L", NULL, 0,
+                    WM8994_POWER_MANAGEMENT_5, 9, 0),
+SND_SOC_DAPM_AIF_IN("AIF1DAC1R", NULL, 0,
+                    WM8994_POWER_MANAGEMENT_5, 8, 0),
+
+SND_SOC_DAPM_AIF_OUT("AIF1ADC2L", "AIF1 Capture",
+                     0, WM8994_POWER_MANAGEMENT_4, 11, 0),
+SND_SOC_DAPM_AIF_OUT("AIF1ADC2R", "AIF1 Capture",
+                     0, WM8994_POWER_MANAGEMENT_4, 10, 0),
+SND_SOC_DAPM_AIF_IN("AIF1DAC2L", NULL, 0,
+                    WM8994_POWER_MANAGEMENT_5, 11, 0),
+SND_SOC_DAPM_AIF_IN("AIF1DAC2R", NULL, 0,
+                    WM8994_POWER_MANAGEMENT_5, 10, 0),
+
+SND_SOC_DAPM_MIXER("AIF1ADC1L Mixer", SND_SOC_NOPM, 0, 0,
+                   aif1adc1l_mix, ARRAY_SIZE(aif1adc1l_mix)),
+SND_SOC_DAPM_MIXER("AIF1ADC1R Mixer", SND_SOC_NOPM, 0, 0,
+                   aif1adc1r_mix, ARRAY_SIZE(aif1adc1r_mix)),
+
+SND_SOC_DAPM_MIXER("AIF2DAC2L Mixer", SND_SOC_NOPM, 0, 0,
+                   aif2dac2l_mix, ARRAY_SIZE(aif2dac2l_mix)),
+SND_SOC_DAPM_MIXER("AIF2DAC2R Mixer", SND_SOC_NOPM, 0, 0,
+                   aif2dac2r_mix, ARRAY_SIZE(aif2dac2r_mix)),
+
+SND_SOC_DAPM_MUX("Left Sidetone", SND_SOC_NOPM, 0, 0, &sidetone1_mux),
+SND_SOC_DAPM_MUX("Right Sidetone", SND_SOC_NOPM, 0, 0, &sidetone2_mux),
+
+SND_SOC_DAPM_MIXER("DAC1L Mixer", SND_SOC_NOPM, 0, 0,
+                   dac1l_mix, ARRAY_SIZE(dac1l_mix)),
+SND_SOC_DAPM_MIXER("DAC1R Mixer", SND_SOC_NOPM, 0, 0,
+                   dac1r_mix, ARRAY_SIZE(dac1r_mix)),
+
+SND_SOC_DAPM_AIF_OUT("AIF2ADCL", NULL, 0,
+                     WM8994_POWER_MANAGEMENT_4, 13, 0),
+SND_SOC_DAPM_AIF_OUT("AIF2ADCR", NULL, 0,
+                     WM8994_POWER_MANAGEMENT_4, 12, 0),
+SND_SOC_DAPM_AIF_IN("AIF2DACL", NULL, 0,
+                    WM8994_POWER_MANAGEMENT_5, 13, 0),
+SND_SOC_DAPM_AIF_IN("AIF2DACR", NULL, 0,
+                    WM8994_POWER_MANAGEMENT_5, 12, 0),
+
+SND_SOC_DAPM_AIF_IN("AIF1DACDAT", "AIF1 Playback", 0, SND_SOC_NOPM, 0, 0),
+SND_SOC_DAPM_AIF_IN("AIF2DACDAT", "AIF2 Playback", 0, SND_SOC_NOPM, 0, 0),
+SND_SOC_DAPM_AIF_OUT("AIF2ADCDAT", "AIF2 Capture", 0, SND_SOC_NOPM, 0, 0),
+
+SND_SOC_DAPM_MUX("AIF1DAC Mux", SND_SOC_NOPM, 0, 0, &aif1dac_mux),
+SND_SOC_DAPM_MUX("AIF2DAC Mux", SND_SOC_NOPM, 0, 0, &aif2dac_mux),
+SND_SOC_DAPM_MUX("AIF2ADC Mux", SND_SOC_NOPM, 0, 0, &aif2adc_mux),
+SND_SOC_DAPM_MUX("AIF3ADC Mux", SND_SOC_NOPM, 0, 0, &aif3adc_mux),
+
+SND_SOC_DAPM_AIF_IN("AIF3DACDAT", "AIF3 Playback", 0, SND_SOC_NOPM, 0, 0),
+SND_SOC_DAPM_AIF_IN("AIF3ADCDAT", "AIF3 Capture", 0, SND_SOC_NOPM, 0, 0),
+
+SND_SOC_DAPM_SUPPLY("TOCLK", WM8994_CLOCKING_1, 4, 0, NULL, 0),
+
+SND_SOC_DAPM_ADC("DMIC2L", NULL, WM8994_POWER_MANAGEMENT_4, 5, 0),
+SND_SOC_DAPM_ADC("DMIC2R", NULL, WM8994_POWER_MANAGEMENT_4, 4, 0),
+SND_SOC_DAPM_ADC("DMIC1L", NULL, WM8994_POWER_MANAGEMENT_4, 3, 0),
+SND_SOC_DAPM_ADC("DMIC1R", NULL, WM8994_POWER_MANAGEMENT_4, 2, 0),
+
+/* Power is done with the muxes since the ADC power also controls the
+ * downsampling chain, the chip will automatically manage the analogue
+ * specific portions.
+ */
+SND_SOC_DAPM_ADC("ADCL", NULL, SND_SOC_NOPM, 1, 0),
+SND_SOC_DAPM_ADC("ADCR", NULL, SND_SOC_NOPM, 0, 0),
+
+SND_SOC_DAPM_MUX("ADCL Mux", WM8994_POWER_MANAGEMENT_4, 1, 0, &adcl_mux),
+SND_SOC_DAPM_MUX("ADCR Mux", WM8994_POWER_MANAGEMENT_4, 0, 0, &adcr_mux),
+
+SND_SOC_DAPM_DAC("DAC2L", NULL, WM8994_POWER_MANAGEMENT_5, 3, 0),
+SND_SOC_DAPM_DAC("DAC2R", NULL, WM8994_POWER_MANAGEMENT_5, 2, 0),
+SND_SOC_DAPM_DAC("DAC1L", NULL, WM8994_POWER_MANAGEMENT_5, 1, 0),
+SND_SOC_DAPM_DAC("DAC1R", NULL, WM8994_POWER_MANAGEMENT_5, 0, 0),
+
+SND_SOC_DAPM_MUX("Left Headphone Mux", SND_SOC_NOPM, 0, 0, &hpl_mux),
+SND_SOC_DAPM_MUX("Right Headphone Mux", SND_SOC_NOPM, 0, 0, &hpr_mux),
+
+SND_SOC_DAPM_MIXER("SPKL", WM8994_POWER_MANAGEMENT_3, 8, 0,
+                   left_speaker_mixer, ARRAY_SIZE(left_speaker_mixer)),
+SND_SOC_DAPM_MIXER("SPKR", WM8994_POWER_MANAGEMENT_3, 9, 0,
+                   right_speaker_mixer, ARRAY_SIZE(right_speaker_mixer)),
+
+SND_SOC_DAPM_POST("Debug log", post_ev),
+};
+
+static const struct snd_soc_dapm_route intercon[] = {
+
+        { "CLK_SYS", NULL, "AIF1CLK", check_clk_sys },
+        { "CLK_SYS", NULL, "AIF2CLK", check_clk_sys },
+
+        { "DSP1CLK", NULL, "CLK_SYS" },
+        { "DSP2CLK", NULL, "CLK_SYS" },
+        { "DSPINTCLK", NULL, "CLK_SYS" },
+
+        { "AIF1ADC1L", NULL, "AIF1CLK" },
+        { "AIF1ADC1L", NULL, "DSP1CLK" },
+        { "AIF1ADC1R", NULL, "AIF1CLK" },
+        { "AIF1ADC1R", NULL, "DSP1CLK" },
+        { "AIF1ADC1R", NULL, "DSPINTCLK" },
+
+        { "AIF1DAC1L", NULL, "AIF1CLK" },
+        { "AIF1DAC1L", NULL, "DSP1CLK" },
+        { "AIF1DAC1R", NULL, "AIF1CLK" },
+        { "AIF1DAC1R", NULL, "DSP1CLK" },
+        { "AIF1DAC1R", NULL, "DSPINTCLK" },
+
+        { "AIF1ADC2L", NULL, "AIF1CLK" },
+        { "AIF1ADC2L", NULL, "DSP1CLK" },
+        { "AIF1ADC2R", NULL, "AIF1CLK" },
+        { "AIF1ADC2R", NULL, "DSP1CLK" },
+        { "AIF1ADC2R", NULL, "DSPINTCLK" },
+
+        { "AIF1DAC2L", NULL, "AIF1CLK" },
+        { "AIF1DAC2L", NULL, "DSP1CLK" },
+        { "AIF1DAC2R", NULL, "AIF1CLK" },
+        { "AIF1DAC2R", NULL, "DSP1CLK" },
+        { "AIF1DAC2R", NULL, "DSPINTCLK" },
+
+        { "AIF2ADCL", NULL, "AIF2CLK" },
+        { "AIF2ADCL", NULL, "DSP2CLK" },
+        { "AIF2ADCR", NULL, "AIF2CLK" },
+        { "AIF2ADCR", NULL, "DSP2CLK" },
+        { "AIF2ADCR", NULL, "DSPINTCLK" },
+
+        { "AIF2DACL", NULL, "AIF2CLK" },
+        { "AIF2DACL", NULL, "DSP2CLK" },
+        { "AIF2DACR", NULL, "AIF2CLK" },
+        { "AIF2DACR", NULL, "DSP2CLK" },
+        { "AIF2DACR", NULL, "DSPINTCLK" },
+
+        { "DMIC1L", NULL, "DMIC1DAT" },
+        { "DMIC1L", NULL, "CLK_SYS" },
+        { "DMIC1R", NULL, "DMIC1DAT" },
+        { "DMIC1R", NULL, "CLK_SYS" },
+        { "DMIC2L", NULL, "DMIC2DAT" },
+        { "DMIC2L", NULL, "CLK_SYS" },
+        { "DMIC2R", NULL, "DMIC2DAT" },
+        { "DMIC2R", NULL, "CLK_SYS" },
+
+        { "ADCL", NULL, "AIF1CLK" },
+        { "ADCL", NULL, "DSP1CLK" },
+        { "ADCL", NULL, "DSPINTCLK" },
+
+        { "ADCR", NULL, "AIF1CLK" },
+        { "ADCR", NULL, "DSP1CLK" },
+        { "ADCR", NULL, "DSPINTCLK" },
+
+        { "ADCL Mux", "ADC", "ADCL" },
+        { "ADCL Mux", "DMIC", "DMIC1L" },
+        { "ADCR Mux", "ADC", "ADCR" },
+        { "ADCR Mux", "DMIC", "DMIC1R" },
+
+        { "DAC1L", NULL, "AIF1CLK" },
+        { "DAC1L", NULL, "DSP1CLK" },
+        { "DAC1L", NULL, "DSPINTCLK" },
+
+        { "DAC1R", NULL, "AIF1CLK" },
+        { "DAC1R", NULL, "DSP1CLK" },
+        { "DAC1R", NULL, "DSPINTCLK" },
+
+        { "DAC2L", NULL, "AIF2CLK" },
+        { "DAC2L", NULL, "DSP2CLK" },
+        { "DAC2L", NULL, "DSPINTCLK" },
+
+        { "DAC2R", NULL, "AIF2DACR" },
+        { "DAC2R", NULL, "AIF2CLK" },
+        { "DAC2R", NULL, "DSP2CLK" },
+        { "DAC2R", NULL, "DSPINTCLK" },
+
+        { "TOCLK", NULL, "CLK_SYS" },
+
+        /* AIF1 outputs */
+        { "AIF1ADC1L", NULL, "AIF1ADC1L Mixer" },
+        { "AIF1ADC1L Mixer", "ADC/DMIC Switch", "ADCL Mux" },
+        { "AIF1ADC1L Mixer", "AIF2 Switch", "AIF2DACL" },
+
+        { "AIF1ADC1R", NULL, "AIF1ADC1R Mixer" },
+        { "AIF1ADC1R Mixer", "ADC/DMIC Switch", "ADCR Mux" },
+        { "AIF1ADC1R Mixer", "AIF2 Switch", "AIF2DACR" },
+
+        /* Pin level routing for AIF3 */
+        { "AIF1DAC1L", NULL, "AIF1DAC Mux" },
+        { "AIF1DAC1R", NULL, "AIF1DAC Mux" },
+        { "AIF1DAC2L", NULL, "AIF1DAC Mux" },
+        { "AIF1DAC2R", NULL, "AIF1DAC Mux" },
+
+        { "AIF2DACL", NULL, "AIF2DAC Mux" },
+        { "AIF2DACR", NULL, "AIF2DAC Mux" },
+
+        { "AIF1DAC Mux", "AIF1DACDAT", "AIF1DACDAT" },
+        { "AIF1DAC Mux", "AIF3DACDAT", "AIF3DACDAT" },
+        { "AIF2DAC Mux", "AIF2DACDAT", "AIF2DACDAT" },
+        { "AIF2DAC Mux", "AIF3DACDAT", "AIF3DACDAT" },
+        { "AIF2ADC Mux", "AIF2ADCDAT", "AIF2ADCL" },
+        { "AIF2ADC Mux", "AIF2ADCDAT", "AIF2ADCR" },
+        { "AIF2ADC Mux", "AIF3DACDAT", "AIF3ADCDAT" },
+
+        /* DAC1 inputs */
+        { "DAC1L", NULL, "DAC1L Mixer" },
+        { "DAC1L Mixer", "AIF2 Switch", "AIF2DACL" },
+        { "DAC1L Mixer", "AIF1.2 Switch", "AIF1DAC2L" },
+        { "DAC1L Mixer", "AIF1.1 Switch", "AIF1DAC1L" },
+        { "DAC1L Mixer", "Left Sidetone Switch", "Left Sidetone" },
+        { "DAC1L Mixer", "Right Sidetone Switch", "Right Sidetone" },
+
+        { "DAC1R", NULL, "DAC1R Mixer" },
+        { "DAC1R Mixer", "AIF2 Switch", "AIF2DACR" },
+        { "DAC1R Mixer", "AIF1.2 Switch", "AIF1DAC2R" },
+        { "DAC1R Mixer", "AIF1.1 Switch", "AIF1DAC1R" },
+        { "DAC1R Mixer", "Left Sidetone Switch", "Left Sidetone" },
+        { "DAC1R Mixer", "Right Sidetone Switch", "Right Sidetone" },
+
+        /* DAC2/AIF2 outputs  */
+        { "AIF2ADCL", NULL, "AIF2DAC2L Mixer" },
+        { "DAC2L", NULL, "AIF2DAC2L Mixer" },
+        { "AIF2DAC2L Mixer", "AIF2 Switch", "AIF2DACL" },
+        { "AIF2DAC2L Mixer", "AIF1.2 Switch", "AIF1DAC2L" },
+        { "AIF2DAC2L Mixer", "AIF1.1 Switch", "AIF1DAC1L" },
+        { "AIF2DAC2L Mixer", "Left Sidetone Switch", "Left Sidetone" },
+        { "AIF2DAC2L Mixer", "Right Sidetone Switch", "Right Sidetone" },
+
+        { "AIF2ADCR", NULL, "AIF2DAC2R Mixer" },
+        { "DAC2R", NULL, "AIF2DAC2R Mixer" },
+        { "AIF2DAC2R Mixer", "AIF2 Switch", "AIF2DACR" },
+        { "AIF2DAC2R Mixer", "AIF1.2 Switch", "AIF1DAC2R" },
+        { "AIF2DAC2R Mixer", "AIF1.1 Switch", "AIF1DAC1R" },
+        { "AIF2DAC2R Mixer", "Left Sidetone Switch", "Left Sidetone" },
+        { "AIF2DAC2R Mixer", "Right Sidetone Switch", "Right Sidetone" },
+
+        { "AIF2ADCDAT", NULL, "AIF2ADC Mux" },
+
+        /* AIF3 output */
+        { "AIF3ADCDAT", "AIF1ADCDAT", "AIF1ADC1L" },
+        { "AIF3ADCDAT", "AIF1ADCDAT", "AIF1ADC1R" },
+        { "AIF3ADCDAT", "AIF1ADCDAT", "AIF1ADC2L" },
+        { "AIF3ADCDAT", "AIF1ADCDAT", "AIF1ADC2R" },
+        { "AIF3ADCDAT", "AIF2ADCDAT", "AIF2ADCL" },
+        { "AIF3ADCDAT", "AIF2ADCDAT", "AIF2ADCR" },
+        { "AIF3ADCDAT", "AIF2DACDAT", "AIF2DACL" },
+        { "AIF3ADCDAT", "AIF2DACDAT", "AIF2DACR" },
+
+        /* Sidetone */
+        { "Left Sidetone", "ADC/DMIC1", "ADCL Mux" },
+        { "Left Sidetone", "DMIC2", "DMIC2L" },
+        { "Right Sidetone", "ADC/DMIC1", "ADCR Mux" },
+        { "Right Sidetone", "DMIC2", "DMIC2R" },
+
+        /* Output stages */
+        { "Left Output Mixer", "DAC Switch", "DAC1L" },
+        { "Right Output Mixer", "DAC Switch", "DAC1R" },
+
+        { "SPKL", "DAC1 Switch", "DAC1L" },
+        { "SPKL", "DAC2 Switch", "DAC2L" },
+
+        { "SPKR", "DAC1 Switch", "DAC1R" },
+        { "SPKR", "DAC2 Switch", "DAC2R" },
+
+        { "Left Headphone Mux", "DAC", "DAC1L" },
+        { "Right Headphone Mux", "DAC", "DAC1R" },
+};
+
+/* The size in bits of the FLL divide multiplied by 10
+ * to allow rounding later */
+#define FIXED_FLL_SIZE ((1 << 16) * 10)
+
+struct fll_div {
+        u16 outdiv;
+        u16 n;
+        u16 k;
+        u16 clk_ref_div;
+        u16 fll_fratio;
+};
+
+static int wm8994_get_fll_config(struct fll_div *fll,
+                                 int freq_in, int freq_out)
+{
+        u64 Kpart;
+        unsigned int K, Ndiv, Nmod;
+
+        pr_debug("FLL input=%dHz, output=%dHz\n", freq_in, freq_out);
+
+        /* Scale the input frequency down to <= 13.5MHz */
+        fll->clk_ref_div = 0;
+        while (freq_in > 13500000) {
+                fll->clk_ref_div++;
+                freq_in /= 2;
+
+                if (fll->clk_ref_div > 3)
+                        return -EINVAL;
+        }
+        pr_debug("CLK_REF_DIV=%d, Fref=%dHz\n", fll->clk_ref_div, freq_in);
+
+        /* Scale the output to give 90MHz<=Fvco<=100MHz */
+        fll->outdiv = 3;
+        while (freq_out * (fll->outdiv + 1) < 90000000) {
+                fll->outdiv++;
+                if (fll->outdiv > 63)
+                        return -EINVAL;
+        }
+        freq_out *= fll->outdiv + 1;
+        pr_debug("OUTDIV=%d, Fvco=%dHz\n", fll->outdiv, freq_out);
+
+        if (freq_in > 1000000) {
+                fll->fll_fratio = 0;
+        } else {
+                fll->fll_fratio = 3;
+                freq_in *= 8;
+        }
+        pr_debug("FLL_FRATIO=%d, Fref=%dHz\n", fll->fll_fratio, freq_in);
+
+        /* Now, calculate N.K */
+        Ndiv = freq_out / freq_in;
+
+        fll->n = Ndiv;
+        Nmod = freq_out % freq_in;
+        pr_debug("Nmod=%d\n", Nmod);
+
+        /* Calculate fractional part - scale up so we can round. */
+        Kpart = FIXED_FLL_SIZE * (long long)Nmod;
+
+        do_div(Kpart, freq_in);
+
+        K = Kpart & 0xFFFFFFFF;
+
+        if ((K % 10) >= 5)
+                K += 5;
+
+        /* Move down to proper range now rounding is done */
+        fll->k = K / 10;
+
+        pr_debug("N=%x K=%x\n", fll->n, fll->k);
+
+        return 0;
+}
+
+static int wm8994_set_fll(struct snd_soc_dai *dai, int id, int src,
+                          unsigned int freq_in, unsigned int freq_out)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        struct wm8994_priv *wm8994 = codec->private_data;
+        int reg_offset, ret;
+        struct fll_div fll;
+        u16 reg, aif1, aif2;
+
+        aif1 = snd_soc_read(codec, WM8994_AIF1_CLOCKING_1)
+                & WM8994_AIF1CLK_ENA;
+
+        aif2 = snd_soc_read(codec, WM8994_AIF2_CLOCKING_1)
+                & WM8994_AIF2CLK_ENA;
+
+        switch (id) {
+        case WM8994_FLL1:
+                reg_offset = 0;
+                id = 0;
+                break;
+        case WM8994_FLL2:
+                reg_offset = 0x20;
+                id = 1;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        /* Are we changing anything? */
+        if (wm8994->fll[id].src == src &&
+            wm8994->fll[id].in == freq_in && wm8994->fll[id].out == freq_out)
+                return 0;
+
+        /* If we're stopping the FLL redo the old config - no
+         * registers will actually be written but we avoid GCC flow
+         * analysis bugs spewing warnings.
+         */
+        if (freq_out)
+                ret = wm8994_get_fll_config(&fll, freq_in, freq_out);
+        else
+                ret = wm8994_get_fll_config(&fll, wm8994->fll[id].in,
+                                            wm8994->fll[id].out);
+        if (ret < 0)
+                return ret;
+
+        /* Gate the AIF clocks while we reclock */
+        snd_soc_update_bits(codec, WM8994_AIF1_CLOCKING_1,
+                            WM8994_AIF1CLK_ENA, 0);
+        snd_soc_update_bits(codec, WM8994_AIF2_CLOCKING_1,
+                            WM8994_AIF2CLK_ENA, 0);
+
+        /* We always need to disable the FLL while reconfiguring */
+        snd_soc_update_bits(codec, WM8994_FLL1_CONTROL_1 + reg_offset,
+                            WM8994_FLL1_ENA, 0);
+
+        reg = (fll.outdiv << WM8994_FLL1_OUTDIV_SHIFT) |
+                (fll.fll_fratio << WM8994_FLL1_FRATIO_SHIFT);
+        snd_soc_update_bits(codec, WM8994_FLL1_CONTROL_2 + reg_offset,
+                            WM8994_FLL1_OUTDIV_MASK |
+                            WM8994_FLL1_FRATIO_MASK, reg);
+
+        snd_soc_write(codec, WM8994_FLL1_CONTROL_3 + reg_offset, fll.k);
+
+        snd_soc_update_bits(codec, WM8994_FLL1_CONTROL_4 + reg_offset,
+                            WM8994_FLL1_N_MASK,
+                                    fll.n << WM8994_FLL1_N_SHIFT);
+
+        snd_soc_update_bits(codec, WM8994_FLL1_CONTROL_5 + reg_offset,
+                            WM8994_FLL1_REFCLK_DIV_MASK,
+                            fll.clk_ref_div << WM8994_FLL1_REFCLK_DIV_SHIFT);
+
+        /* Enable (with fractional mode if required) */
+        if (freq_out) {
+                if (fll.k)
+                        reg = WM8994_FLL1_ENA | WM8994_FLL1_FRAC;
+                else
+                        reg = WM8994_FLL1_ENA;
+                snd_soc_update_bits(codec, WM8994_FLL1_CONTROL_1 + reg_offset,
+                                    WM8994_FLL1_ENA | WM8994_FLL1_FRAC,
+                                    reg);
+        }
+
+        wm8994->fll[id].in = freq_in;
+        wm8994->fll[id].out = freq_out;
+
+        /* Enable any gated AIF clocks */
+        snd_soc_update_bits(codec, WM8994_AIF1_CLOCKING_1,
+                            WM8994_AIF1CLK_ENA, aif1);
+        snd_soc_update_bits(codec, WM8994_AIF2_CLOCKING_1,
+                            WM8994_AIF2CLK_ENA, aif2);
+
+        configure_clock(codec);
+
+        return 0;
+}
+
+static int wm8994_set_dai_sysclk(struct snd_soc_dai *dai,
+                int clk_id, unsigned int freq, int dir)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        struct wm8994_priv *wm8994 = codec->private_data;
+
+        switch (dai->id) {
+        case 1:
+        case 2:
+                break;
+
+        default:
+                /* AIF3 shares clocking with AIF1/2 */
+                return -EINVAL;
+        }
+
+        switch (clk_id) {
+        case WM8994_SYSCLK_MCLK1:
+                wm8994->sysclk[dai->id - 1] = WM8994_SYSCLK_MCLK1;
+                wm8994->mclk[0] = freq;
+                dev_dbg(dai->dev, "AIF%d using MCLK1 at %uHz\n",
+                        dai->id, freq);
+                break;
+
+        case WM8994_SYSCLK_MCLK2:
+                /* TODO: Set GPIO AF */
+                wm8994->sysclk[dai->id - 1] = WM8994_SYSCLK_MCLK2;
+                wm8994->mclk[1] = freq;
+                dev_dbg(dai->dev, "AIF%d using MCLK2 at %uHz\n",
+                        dai->id, freq);
+                break;
+
+        case WM8994_SYSCLK_FLL1:
+                wm8994->sysclk[dai->id - 1] = WM8994_SYSCLK_FLL1;
+                dev_dbg(dai->dev, "AIF%d using FLL1\n", dai->id);
+                break;
+
+        case WM8994_SYSCLK_FLL2:
+                wm8994->sysclk[dai->id - 1] = WM8994_SYSCLK_FLL2;
+                dev_dbg(dai->dev, "AIF%d using FLL2\n", dai->id);
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        configure_clock(codec);
+
+        return 0;
+}
+
+static int wm8994_set_bias_level(struct snd_soc_codec *codec,
+                                 enum snd_soc_bias_level level)
+{
+        switch (level) {
+        case SND_SOC_BIAS_ON:
+                break;
+
+        case SND_SOC_BIAS_PREPARE:
+                /* VMID=2x40k */
+                snd_soc_update_bits(codec, WM8994_POWER_MANAGEMENT_1,
+                                    WM8994_VMID_SEL_MASK, 0x2);
+                break;
+
+        case SND_SOC_BIAS_STANDBY:
+                if (codec->bias_level == SND_SOC_BIAS_OFF) {
+                        /* Tweak DC servo configuration for improved
+                         * performance. */
+                        snd_soc_write(codec, 0x102, 0x3);
+                        snd_soc_write(codec, 0x56, 0x3);
+                        snd_soc_write(codec, 0x102, 0);
+
+                        /* Discharge LINEOUT1 & 2 */
+                        snd_soc_update_bits(codec, WM8994_ANTIPOP_1,
+                                            WM8994_LINEOUT1_DISCH |
+                                            WM8994_LINEOUT2_DISCH,
+                                            WM8994_LINEOUT1_DISCH |
+                                            WM8994_LINEOUT2_DISCH);
+
+                        /* Startup bias, VMID ramp & buffer */
+                        snd_soc_update_bits(codec, WM8994_ANTIPOP_2,
+                                            WM8994_STARTUP_BIAS_ENA |
+                                            WM8994_VMID_BUF_ENA |
+                                            WM8994_VMID_RAMP_MASK,
+                                            WM8994_STARTUP_BIAS_ENA |
+                                            WM8994_VMID_BUF_ENA |
+                                            (0x11 << WM8994_VMID_RAMP_SHIFT));
+
+                        /* Main bias enable, VMID=2x40k */
+                        snd_soc_update_bits(codec, WM8994_POWER_MANAGEMENT_1,
+                                            WM8994_BIAS_ENA |
+                                            WM8994_VMID_SEL_MASK,
+                                            WM8994_BIAS_ENA | 0x2);
+
+                        msleep(20);
+                }
+
+                /* VMID=2x500k */
+                snd_soc_update_bits(codec, WM8994_POWER_MANAGEMENT_1,
+                                    WM8994_VMID_SEL_MASK, 0x4);
+
+                break;
+
+        case SND_SOC_BIAS_OFF:
+                if (codec->bias_level == SND_SOC_BIAS_STANDBY) {
+                        /* Switch over to startup biases */
+                        snd_soc_update_bits(codec, WM8994_ANTIPOP_2,
+                                            WM8994_BIAS_SRC |
+                                            WM8994_STARTUP_BIAS_ENA |
+                                            WM8994_VMID_BUF_ENA |
+                                            WM8994_VMID_RAMP_MASK,
+                                            WM8994_BIAS_SRC |
+                                            WM8994_STARTUP_BIAS_ENA |
+                                            WM8994_VMID_BUF_ENA |
+                                            (1 << WM8994_VMID_RAMP_SHIFT));
+
+                        /* Disable main biases */
+                        snd_soc_update_bits(codec, WM8994_POWER_MANAGEMENT_1,
+                                            WM8994_BIAS_ENA |
+                                            WM8994_VMID_SEL_MASK, 0);
+
+                        /* Discharge line */
+                        snd_soc_update_bits(codec, WM8994_ANTIPOP_1,
+                                            WM8994_LINEOUT1_DISCH |
+                                            WM8994_LINEOUT2_DISCH,
+                                            WM8994_LINEOUT1_DISCH |
+                                            WM8994_LINEOUT2_DISCH);
+
+                        msleep(5);
+
+                        /* Switch off startup biases */
+                        snd_soc_update_bits(codec, WM8994_ANTIPOP_2,
+                                            WM8994_BIAS_SRC |
+                                            WM8994_STARTUP_BIAS_ENA |
+                                            WM8994_VMID_BUF_ENA |
+                                            WM8994_VMID_RAMP_MASK, 0);
+                }
+                break;
+        }
+        codec->bias_level = level;
+        return 0;
+}
+
+static int wm8994_set_dai_fmt(struct snd_soc_dai *dai, unsigned int fmt)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        int ms_reg;
+        int aif1_reg;
+        int ms = 0;
+        int aif1 = 0;
+
+        switch (dai->id) {
+        case 1:
+                ms_reg = WM8994_AIF1_MASTER_SLAVE;
+                aif1_reg = WM8994_AIF1_CONTROL_1;
+                break;
+        case 2:
+                ms_reg = WM8994_AIF2_MASTER_SLAVE;
+                aif1_reg = WM8994_AIF2_CONTROL_1;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
+        case SND_SOC_DAIFMT_CBS_CFS:
+                break;
+        case SND_SOC_DAIFMT_CBM_CFM:
+                ms = WM8994_AIF1_MSTR;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
+        case SND_SOC_DAIFMT_DSP_B:
+                aif1 |= WM8994_AIF1_LRCLK_INV;
+        case SND_SOC_DAIFMT_DSP_A:
+                aif1 |= 0x18;
+                break;
+        case SND_SOC_DAIFMT_I2S:
+                aif1 |= 0x10;
+                break;
+        case SND_SOC_DAIFMT_RIGHT_J:
+                break;
+        case SND_SOC_DAIFMT_LEFT_J:
+                aif1 |= 0x8;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
+        case SND_SOC_DAIFMT_DSP_A:
+        case SND_SOC_DAIFMT_DSP_B:
+                /* frame inversion not valid for DSP modes */
+                switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
+                case SND_SOC_DAIFMT_NB_NF:
+                        break;
+                case SND_SOC_DAIFMT_IB_NF:
+                        aif1 |= WM8994_AIF1_BCLK_INV;
+                        break;
+                default:
+                        return -EINVAL;
+                }
+                break;
+
+        case SND_SOC_DAIFMT_I2S:
+        case SND_SOC_DAIFMT_RIGHT_J:
+        case SND_SOC_DAIFMT_LEFT_J:
+                switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
+                case SND_SOC_DAIFMT_NB_NF:
+                        break;
+                case SND_SOC_DAIFMT_IB_IF:
+                        aif1 |= WM8994_AIF1_BCLK_INV | WM8994_AIF1_LRCLK_INV;
+                        break;
+                case SND_SOC_DAIFMT_IB_NF:
+                        aif1 |= WM8994_AIF1_BCLK_INV;
+                        break;
+                case SND_SOC_DAIFMT_NB_IF:
+                        aif1 |= WM8994_AIF1_LRCLK_INV;
+                        break;
+                default:
+                        return -EINVAL;
+                }
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        snd_soc_update_bits(codec, aif1_reg,
+                            WM8994_AIF1_BCLK_INV | WM8994_AIF1_LRCLK_INV |
+                            WM8994_AIF1_FMT_MASK,
+                            aif1);
+        snd_soc_update_bits(codec, ms_reg, WM8994_AIF1_MSTR,
+                            ms);
+
+        return 0;
+}
+
+static struct {
+        int val, rate;
+} srs[] = {
+        { 0,   8000 },
+        { 1,  11025 },
+        { 2,  12000 },
+        { 3,  16000 },
+        { 4,  22050 },
+        { 5,  24000 },
+        { 6,  32000 },
+        { 7,  44100 },
+        { 8,  48000 },
+        { 9,  88200 },
+        { 10, 96000 },
+};
+
+static int fs_ratios[] = {
+        64, 128, 192, 256, 348, 512, 768, 1024, 1408, 1536
+};
+
+static int bclk_divs[] = {
+        10, 15, 20, 30, 40, 50, 60, 80, 110, 120, 160, 220, 240, 320, 440, 480,
+        640, 880, 960, 1280, 1760, 1920
+};
+
+static int wm8994_hw_params(struct snd_pcm_substream *substream,
+                            struct snd_pcm_hw_params *params,
+                            struct snd_soc_dai *dai)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        struct wm8994_priv *wm8994 = codec->private_data;
+        int aif1_reg;
+        int bclk_reg;
+        int lrclk_reg;
+        int rate_reg;
+        int aif1 = 0;
+        int bclk = 0;
+        int lrclk = 0;
+        int rate_val = 0;
+        int id = dai->id - 1;
+
+        int i, cur_val, best_val, bclk_rate, best;
+
+        switch (dai->id) {
+        case 1:
+                aif1_reg = WM8994_AIF1_CONTROL_1;
+                bclk_reg = WM8994_AIF1_BCLK;
+                rate_reg = WM8994_AIF1_RATE;
+                if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK ||
+                    wm8994->lrclk_shared[0])
+                        lrclk_reg = WM8994_AIF1DAC_LRCLK;
+                else
+                        lrclk_reg = WM8994_AIF1ADC_LRCLK;
+                break;
+        case 2:
+                aif1_reg = WM8994_AIF2_CONTROL_1;
+                bclk_reg = WM8994_AIF2_BCLK;
+                rate_reg = WM8994_AIF2_RATE;
+                if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK ||
+                    wm8994->lrclk_shared[1])
+                        lrclk_reg = WM8994_AIF2DAC_LRCLK;
+                else
+                        lrclk_reg = WM8994_AIF2ADC_LRCLK;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        bclk_rate = params_rate(params) * 2;
+        switch (params_format(params)) {
+        case SNDRV_PCM_FORMAT_S16_LE:
+                bclk_rate *= 16;
+                break;
+        case SNDRV_PCM_FORMAT_S20_3LE:
+                bclk_rate *= 20;
+                aif1 |= 0x20;
+                break;
+        case SNDRV_PCM_FORMAT_S24_LE:
+                bclk_rate *= 24;
+                aif1 |= 0x40;
+                break;
+        case SNDRV_PCM_FORMAT_S32_LE:
+                bclk_rate *= 32;
+                aif1 |= 0x60;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        /* Try to find an appropriate sample rate; look for an exact match. */
+        for (i = 0; i < ARRAY_SIZE(srs); i++)
+                if (srs[i].rate == params_rate(params))
+                        break;
+        if (i == ARRAY_SIZE(srs))
+                return -EINVAL;
+        rate_val |= srs[i].val << WM8994_AIF1_SR_SHIFT;
+
+        dev_dbg(dai->dev, "Sample rate is %dHz\n", srs[i].rate);
+        dev_dbg(dai->dev, "AIF%dCLK is %dHz, target BCLK %dHz\n",
+                dai->id, wm8994->aifclk[id], bclk_rate);
+
+        if (wm8994->aifclk[id] == 0) {
+                dev_err(dai->dev, "AIF%dCLK not configured\n", dai->id);
+                return -EINVAL;
+        }
+
+        /* AIFCLK/fs ratio; look for a close match in either direction */
+        best = 0;
+        best_val = abs((fs_ratios[0] * params_rate(params))
+                       - wm8994->aifclk[id]);
+        for (i = 1; i < ARRAY_SIZE(fs_ratios); i++) {
+                cur_val = abs((fs_ratios[i] * params_rate(params))
+                              - wm8994->aifclk[id]);
+                if (cur_val >= best_val)
+                        continue;
+                best = i;
+                best_val = cur_val;
+        }
+        dev_dbg(dai->dev, "Selected AIF%dCLK/fs = %d\n",
+                dai->id, fs_ratios[best]);
+        rate_val |= best;
+
+        /* We may not get quite the right frequency if using
+         * approximate clocks so look for the closest match that is
+         * higher than the target (we need to ensure that there enough
+         * BCLKs to clock out the samples).
+         */
+        best = 0;
+        for (i = 0; i < ARRAY_SIZE(bclk_divs); i++) {
+                cur_val = (wm8994->aifclk[id] * 10 / bclk_divs[i]) - bclk_rate;
+                if (cur_val < 0) /* BCLK table is sorted */
+                        break;
+                best = i;
+        }
+        bclk_rate = wm8994->aifclk[id] * 10 / bclk_divs[best];
+        dev_dbg(dai->dev, "Using BCLK_DIV %d for actual BCLK %dHz\n",
+                bclk_divs[best], bclk_rate);
+        bclk |= best << WM8994_AIF1_BCLK_DIV_SHIFT;
+
+        lrclk = bclk_rate / params_rate(params);
+        dev_dbg(dai->dev, "Using LRCLK rate %d for actual LRCLK %dHz\n",
+                lrclk, bclk_rate / lrclk);
+
+        snd_soc_update_bits(codec, aif1_reg, WM8994_AIF1_WL_MASK, aif1);
+        snd_soc_update_bits(codec, bclk_reg, WM8994_AIF1_BCLK_DIV_MASK, bclk);
+        snd_soc_update_bits(codec, lrclk_reg, WM8994_AIF1DAC_RATE_MASK,
+                            lrclk);
+        snd_soc_update_bits(codec, rate_reg, WM8994_AIF1_SR_MASK |
+                            WM8994_AIF1CLK_RATE_MASK, rate_val);
+
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+                switch (dai->id) {
+                case 1:
+                        wm8994->dac_rates[0] = params_rate(params);
+                        wm8994_set_retune_mobile(codec, 0);
+                        wm8994_set_retune_mobile(codec, 1);
+                        break;
+                case 2:
+                        wm8994->dac_rates[1] = params_rate(params);
+                        wm8994_set_retune_mobile(codec, 2);
+                        break;
+                }
+        }
+
+        return 0;
+}
+
+static int wm8994_aif_mute(struct snd_soc_dai *codec_dai, int mute)
+{
+        struct snd_soc_codec *codec = codec_dai->codec;
+        int mute_reg;
+        int reg;
+
+        switch (codec_dai->id) {
+        case 1:
+                mute_reg = WM8994_AIF1_DAC1_FILTERS_1;
+                break;
+        case 2:
+                mute_reg = WM8994_AIF2_DAC_FILTERS_1;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        if (mute)
+                reg = WM8994_AIF1DAC1_MUTE;
+        else
+                reg = 0;
+
+        snd_soc_update_bits(codec, mute_reg, WM8994_AIF1DAC1_MUTE, reg);
+
+        return 0;
+}
+
+#define WM8994_RATES SNDRV_PCM_RATE_8000_96000
+
+#define WM8994_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
+                        SNDRV_PCM_FMTBIT_S24_LE)
+
+static struct snd_soc_dai_ops wm8994_aif1_dai_ops = {
+        .set_sysclk     = wm8994_set_dai_sysclk,
+        .set_fmt        = wm8994_set_dai_fmt,
+        .hw_params      = wm8994_hw_params,
+        .digital_mute   = wm8994_aif_mute,
+        .set_pll        = wm8994_set_fll,
+};
+
+static struct snd_soc_dai_ops wm8994_aif2_dai_ops = {
+        .set_sysclk     = wm8994_set_dai_sysclk,
+        .set_fmt        = wm8994_set_dai_fmt,
+        .hw_params      = wm8994_hw_params,
+        .digital_mute   = wm8994_aif_mute,
+        .set_pll        = wm8994_set_fll,
+};
+
+struct snd_soc_dai wm8994_dai[] = {
+        {
+                .name = "WM8994 AIF1",
+                .id = 1,
+                .playback = {
+                        .stream_name = "AIF1 Playback",
+                        .channels_min = 2,
+                        .channels_max = 2,
+                        .rates = WM8994_RATES,
+                        .formats = WM8994_FORMATS,
+                },
+                .capture = {
+                        .stream_name = "AIF1 Capture",
+                        .channels_min = 2,
+                        .channels_max = 2,
+                        .rates = WM8994_RATES,
+                        .formats = WM8994_FORMATS,
+                 },
+                .ops = &wm8994_aif1_dai_ops,
+        },
+        {
+                .name = "WM8994 AIF2",
+                .id = 2,
+                .playback = {
+                        .stream_name = "AIF2 Playback",
+                        .channels_min = 2,
+                        .channels_max = 2,
+                        .rates = WM8994_RATES,
+                        .formats = WM8994_FORMATS,
+                },
+                .capture = {
+                        .stream_name = "AIF2 Capture",
+                        .channels_min = 2,
+                        .channels_max = 2,
+                        .rates = WM8994_RATES,
+                        .formats = WM8994_FORMATS,
+                },
+                .ops = &wm8994_aif2_dai_ops,
+        },
+        {
+                .name = "WM8994 AIF3",
+                .playback = {
+                        .stream_name = "AIF3 Playback",
+                        .channels_min = 2,
+                        .channels_max = 2,
+                        .rates = WM8994_RATES,
+                        .formats = WM8994_FORMATS,
+                },
+                .capture = {
+                        .stream_name = "AIF3 Capture",
+                        .channels_min = 2,
+                        .channels_max = 2,
+                        .rates = WM8994_RATES,
+                        .formats = WM8994_FORMATS,
+                },
+        }
+};
+EXPORT_SYMBOL_GPL(wm8994_dai);
+
+#ifdef CONFIG_PM
+static int wm8994_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec = socdev->card->codec;
+        struct wm8994_priv *wm8994 = codec->private_data;
+        int i, ret;
+
+        for (i = 0; i < ARRAY_SIZE(wm8994->fll); i++) {
+                memcpy(&wm8994->fll_suspend[i], &wm8994->fll[i],
+                       sizeof(struct fll_config));
+                ret = wm8994_set_fll(&codec->dai[0], i + 1, 0, 0, 0);
+                if (ret < 0)
+                        dev_warn(codec->dev, "Failed to stop FLL%d: %d\n",
+                                 i + 1, ret);
+        }
+
+        wm8994_set_bias_level(codec, SND_SOC_BIAS_OFF);
+
+        return 0;
+}
+
+static int wm8994_resume(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec = socdev->card->codec;
+        struct wm8994_priv *wm8994 = codec->private_data;
+        u16 *reg_cache = codec->reg_cache;
+        int i, ret;
+
+        /* Restore the registers */
+        for (i = 1; i < ARRAY_SIZE(wm8994->reg_cache); i++) {
+                switch (i) {
+                case WM8994_LDO_1:
+                case WM8994_LDO_2:
+                case WM8994_SOFTWARE_RESET:
+                        /* Handled by other MFD drivers */
+                        continue;
+                default:
+                        break;
+                }
+
+                if (!access_masks[i].writable)
+                        continue;
+
+                wm8994_reg_write(codec->control_data, i, reg_cache[i]);
+        }
+
+        wm8994_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+
+        for (i = 0; i < ARRAY_SIZE(wm8994->fll); i++) {
+                ret = wm8994_set_fll(&codec->dai[0], i + 1,
+                                     wm8994->fll_suspend[i].src,
+                                     wm8994->fll_suspend[i].in,
+                                     wm8994->fll_suspend[i].out);
+                if (ret < 0)
+                        dev_warn(codec->dev, "Failed to restore FLL%d: %d\n",
+                                 i + 1, ret);
+        }
+
+        return 0;
+}
+#else
+#define wm8994_suspend NULL
+#define wm8994_resume NULL
+#endif
+
+static void wm8994_handle_retune_mobile_pdata(struct wm8994_priv *wm8994)
+{
+        struct snd_soc_codec *codec = &wm8994->codec;
+        struct wm8994_pdata *pdata = wm8994->pdata;
+        struct snd_kcontrol_new controls[] = {
+                SOC_ENUM_EXT("AIF1.1 EQ Mode",
+                             wm8994->retune_mobile_enum,
+                             wm8994_get_retune_mobile_enum,
+                             wm8994_put_retune_mobile_enum),
+                SOC_ENUM_EXT("AIF1.2 EQ Mode",
+                             wm8994->retune_mobile_enum,
+                             wm8994_get_retune_mobile_enum,
+                             wm8994_put_retune_mobile_enum),
+                SOC_ENUM_EXT("AIF2 EQ Mode",
+                             wm8994->retune_mobile_enum,
+                             wm8994_get_retune_mobile_enum,
+                             wm8994_put_retune_mobile_enum),
+        };
+        int ret, i, j;
+        const char **t;
+
+        /* We need an array of texts for the enum API but the number
+         * of texts is likely to be less than the number of
+         * configurations due to the sample rate dependency of the
+         * configurations. */
+        wm8994->num_retune_mobile_texts = 0;
+        wm8994->retune_mobile_texts = NULL;
+        for (i = 0; i < pdata->num_retune_mobile_cfgs; i++) {
+                for (j = 0; j < wm8994->num_retune_mobile_texts; j++) {
+                        if (strcmp(pdata->retune_mobile_cfgs[i].name,
+                                   wm8994->retune_mobile_texts[j]) == 0)
+                                break;
+                }
+
+                if (j != wm8994->num_retune_mobile_texts)
+                        continue;
+
+                /* Expand the array... */
+                t = krealloc(wm8994->retune_mobile_texts,
+                             sizeof(char *) * 
+                             (wm8994->num_retune_mobile_texts + 1),
+                             GFP_KERNEL);
+                if (t == NULL)
+                        continue;
+
+                /* ...store the new entry... */
+                t[wm8994->num_retune_mobile_texts] = 
+                        pdata->retune_mobile_cfgs[i].name;
+
+                /* ...and remember the new version. */
+                wm8994->num_retune_mobile_texts++;
+                wm8994->retune_mobile_texts = t;
+        }
+
+        dev_dbg(codec->dev, "Allocated %d unique ReTune Mobile names\n",
+                wm8994->num_retune_mobile_texts);
+
+        wm8994->retune_mobile_enum.max = wm8994->num_retune_mobile_texts;
+        wm8994->retune_mobile_enum.texts = wm8994->retune_mobile_texts;
+
+        ret = snd_soc_add_controls(&wm8994->codec, controls,
+                                   ARRAY_SIZE(controls));
+        if (ret != 0)
+                dev_err(wm8994->codec.dev,
+                        "Failed to add ReTune Mobile controls: %d\n", ret);
+}
+
+static void wm8994_handle_pdata(struct wm8994_priv *wm8994)
+{
+        struct snd_soc_codec *codec = &wm8994->codec;
+        struct wm8994_pdata *pdata = wm8994->pdata;
+        int ret, i;
+
+        if (!pdata)
+                return;
+
+        wm_hubs_handle_analogue_pdata(codec, pdata->lineout1_diff,
+                                      pdata->lineout2_diff,
+                                      pdata->lineout1fb,
+                                      pdata->lineout2fb,
+                                      pdata->jd_scthr,
+                                      pdata->jd_thr,
+                                      pdata->micbias1_lvl,
+                                      pdata->micbias2_lvl);
+
+        dev_dbg(codec->dev, "%d DRC configurations\n", pdata->num_drc_cfgs);
+
+        if (pdata->num_drc_cfgs) {
+                struct snd_kcontrol_new controls[] = {
+                        SOC_ENUM_EXT("AIF1DRC1 Mode", wm8994->drc_enum,
+                                     wm8994_get_drc_enum, wm8994_put_drc_enum),
+                        SOC_ENUM_EXT("AIF1DRC2 Mode", wm8994->drc_enum,
+                                     wm8994_get_drc_enum, wm8994_put_drc_enum),
+                        SOC_ENUM_EXT("AIF2DRC Mode", wm8994->drc_enum,
+                                     wm8994_get_drc_enum, wm8994_put_drc_enum),
+                };
+
+                /* We need an array of texts for the enum API */
+                wm8994->drc_texts = kmalloc(sizeof(char *)
+                                            * pdata->num_drc_cfgs, GFP_KERNEL);
+                if (!wm8994->drc_texts) {
+                        dev_err(wm8994->codec.dev,
+                                "Failed to allocate %d DRC config texts\n",
+                                pdata->num_drc_cfgs);
+                        return;
+                }
+
+                for (i = 0; i < pdata->num_drc_cfgs; i++)
+                        wm8994->drc_texts[i] = pdata->drc_cfgs[i].name;
+
+                wm8994->drc_enum.max = pdata->num_drc_cfgs;
+                wm8994->drc_enum.texts = wm8994->drc_texts;
+
+                ret = snd_soc_add_controls(&wm8994->codec, controls,
+                                           ARRAY_SIZE(controls));
+                if (ret != 0)
+                        dev_err(wm8994->codec.dev,
+                                "Failed to add DRC mode controls: %d\n", ret);
+
+                for (i = 0; i < WM8994_NUM_DRC; i++)
+                        wm8994_set_drc(codec, i);
+        }
+
+        dev_dbg(codec->dev, "%d ReTune Mobile configurations\n",
+                pdata->num_retune_mobile_cfgs);
+
+        if (pdata->num_retune_mobile_cfgs)
+                wm8994_handle_retune_mobile_pdata(wm8994);
+        else
+                snd_soc_add_controls(&wm8994->codec, wm8994_eq_controls,
+                                     ARRAY_SIZE(wm8994_eq_controls));
+}
+
+static int wm8994_probe(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec;
+        int ret = 0;
+
+        if (wm8994_codec == NULL) {
+                dev_err(&pdev->dev, "Codec device not registered\n");
+                return -ENODEV;
+        }
+
+        socdev->card->codec = wm8994_codec;
+        codec = wm8994_codec;
+
+        /* register pcms */
+        ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
+        if (ret < 0) {
+                dev_err(codec->dev, "failed to create pcms: %d\n", ret);
+                return ret;
+        }
+
+        wm8994_handle_pdata(codec->private_data);
+
+        wm_hubs_add_analogue_controls(codec);
+        snd_soc_add_controls(codec, wm8994_snd_controls,
+                             ARRAY_SIZE(wm8994_snd_controls));
+        snd_soc_dapm_new_controls(codec, wm8994_dapm_widgets,
+                                  ARRAY_SIZE(wm8994_dapm_widgets));
+        wm_hubs_add_analogue_routes(codec, 0, 0);
+        snd_soc_dapm_add_routes(codec, intercon, ARRAY_SIZE(intercon));
+
+        return 0;
+}
+
+static int wm8994_remove(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+
+        snd_soc_free_pcms(socdev);
+        snd_soc_dapm_free(socdev);
+
+        return 0;
+}
+
+struct snd_soc_codec_device soc_codec_dev_wm8994 = {
+        .probe =        wm8994_probe,
+        .remove =       wm8994_remove,
+        .suspend =      wm8994_suspend,
+        .resume =       wm8994_resume,
+};
+EXPORT_SYMBOL_GPL(soc_codec_dev_wm8994);
+
+static int wm8994_codec_probe(struct platform_device *pdev)
+{
+        int ret;
+        struct wm8994_priv *wm8994;
+        struct snd_soc_codec *codec;
+        int i;
+        u16 rev;
+
+        if (wm8994_codec) {
+                dev_err(&pdev->dev, "Another WM8994 is registered\n");
+                return -EINVAL;
+        }
+
+        wm8994 = kzalloc(sizeof(struct wm8994_priv), GFP_KERNEL);
+        if (!wm8994) {
+                dev_err(&pdev->dev, "Failed to allocate private data\n");
+                return -ENOMEM;
+        }
+
+        codec = &wm8994->codec;
+
+        mutex_init(&codec->mutex);
+        INIT_LIST_HEAD(&codec->dapm_widgets);
+        INIT_LIST_HEAD(&codec->dapm_paths);
+
+        codec->private_data = wm8994;
+        codec->control_data = dev_get_drvdata(pdev->dev.parent);
+        codec->name = "WM8994";
+        codec->owner = THIS_MODULE;
+        codec->read = wm8994_read;
+        codec->write = wm8994_write;
+        codec->readable_register = wm8994_readable;
+        codec->bias_level = SND_SOC_BIAS_OFF;
+        codec->set_bias_level = wm8994_set_bias_level;
+        codec->dai = &wm8994_dai[0];
+        codec->num_dai = 3;
+        codec->reg_cache_size = WM8994_MAX_REGISTER;
+        codec->reg_cache = &wm8994->reg_cache;
+        codec->dev = &pdev->dev;
+
+        wm8994->pdata = pdev->dev.parent->platform_data;
+
+        /* Fill the cache with physical values we inherited; don't reset */
+        ret = wm8994_bulk_read(codec->control_data, 0,
+                               ARRAY_SIZE(wm8994->reg_cache) - 1,
+                               codec->reg_cache);
+        if (ret < 0) {
+                dev_err(codec->dev, "Failed to fill register cache: %d\n",
+                        ret);
+                goto err;
+        }
+
+        /* Clear the cached values for unreadable/volatile registers to
+         * avoid potential confusion.
+         */
+        for (i = 0; i < ARRAY_SIZE(wm8994->reg_cache); i++)
+                if (wm8994_volatile(i) || !wm8994_readable(i))
+                        wm8994->reg_cache[i] = 0;
+
+        /* Set revision-specific configuration */
+        rev = snd_soc_read(codec, WM8994_CHIP_REVISION);
+        switch (rev) {
+        case 2:
+        case 3:
+                wm8994->hubs.dcs_codes = -5;
+                wm8994->hubs.hp_startup_mode = 1;
+                wm8994->hubs.dcs_readback_mode = 1;
+                break;
+        default:
+                wm8994->hubs.dcs_readback_mode = 1;
+                break;
+        }
+
+        /* Remember if AIFnLRCLK is configured as a GPIO.  This should be
+         * configured on init - if a system wants to do this dynamically
+         * at runtime we can deal with that then.
+         */
+        ret = wm8994_reg_read(codec->control_data, WM8994_GPIO_1);
+        if (ret < 0) {
+                dev_err(codec->dev, "Failed to read GPIO1 state: %d\n", ret);
+                goto err;
+        }
+        if ((ret & WM8994_GPN_FN_MASK) != WM8994_GP_FN_PIN_SPECIFIC) {
+                wm8994->lrclk_shared[0] = 1;
+                wm8994_dai[0].symmetric_rates = 1;
+        } else {
+                wm8994->lrclk_shared[0] = 0;
+        }
+
+        ret = wm8994_reg_read(codec->control_data, WM8994_GPIO_6);
+        if (ret < 0) {
+                dev_err(codec->dev, "Failed to read GPIO6 state: %d\n", ret);
+                goto err;
+        }
+        if ((ret & WM8994_GPN_FN_MASK) != WM8994_GP_FN_PIN_SPECIFIC) {
+                wm8994->lrclk_shared[1] = 1;
+                wm8994_dai[1].symmetric_rates = 1;
+        } else {
+                wm8994->lrclk_shared[1] = 0;
+        }
+
+        for (i = 0; i < ARRAY_SIZE(wm8994_dai); i++)
+                wm8994_dai[i].dev = codec->dev;
+
+        wm8994_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+
+        wm8994_codec = codec;
+
+        /* Latch volume updates (right only; we always do left then right). */
+        snd_soc_update_bits(codec, WM8994_AIF1_DAC1_RIGHT_VOLUME,
+                            WM8994_AIF1DAC1_VU, WM8994_AIF1DAC1_VU);
+        snd_soc_update_bits(codec, WM8994_AIF1_DAC2_RIGHT_VOLUME,
+                            WM8994_AIF1DAC2_VU, WM8994_AIF1DAC2_VU);
+        snd_soc_update_bits(codec, WM8994_AIF2_DAC_RIGHT_VOLUME,
+                            WM8994_AIF2DAC_VU, WM8994_AIF2DAC_VU);
+        snd_soc_update_bits(codec, WM8994_AIF1_ADC1_RIGHT_VOLUME,
+                            WM8994_AIF1ADC1_VU, WM8994_AIF1ADC1_VU);
+        snd_soc_update_bits(codec, WM8994_AIF1_ADC2_RIGHT_VOLUME,
+                            WM8994_AIF1ADC2_VU, WM8994_AIF1ADC2_VU);
+        snd_soc_update_bits(codec, WM8994_AIF2_ADC_RIGHT_VOLUME,
+                            WM8994_AIF2ADC_VU, WM8994_AIF1ADC2_VU);
+        snd_soc_update_bits(codec, WM8994_DAC1_RIGHT_VOLUME,
+                            WM8994_DAC1_VU, WM8994_DAC1_VU);
+        snd_soc_update_bits(codec, WM8994_DAC2_RIGHT_VOLUME,
+                            WM8994_DAC2_VU, WM8994_DAC2_VU);
+
+        /* Set the low bit of the 3D stereo depth so TLV matches */
+        snd_soc_update_bits(codec, WM8994_AIF1_DAC1_FILTERS_2,
+                            1 << WM8994_AIF1DAC1_3D_GAIN_SHIFT,
+                            1 << WM8994_AIF1DAC1_3D_GAIN_SHIFT);
+        snd_soc_update_bits(codec, WM8994_AIF1_DAC2_FILTERS_2,
+                            1 << WM8994_AIF1DAC2_3D_GAIN_SHIFT,
+                            1 << WM8994_AIF1DAC2_3D_GAIN_SHIFT);
+        snd_soc_update_bits(codec, WM8994_AIF2_DAC_FILTERS_2,
+                            1 << WM8994_AIF2DAC_3D_GAIN_SHIFT,
+                            1 << WM8994_AIF2DAC_3D_GAIN_SHIFT);
+
+        wm8994_update_class_w(codec);
+
+        ret = snd_soc_register_codec(codec);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to register codec: %d\n", ret);
+                goto err;
+        }
+
+        ret = snd_soc_register_dais(wm8994_dai, ARRAY_SIZE(wm8994_dai));
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to register DAIs: %d\n", ret);
+                goto err_codec;
+        }
+
+        platform_set_drvdata(pdev, wm8994);
+
+        return 0;
+
+err_codec:
+        snd_soc_unregister_codec(codec);
+err:
+        kfree(wm8994);
+        return ret;
+}
+
+static int __devexit wm8994_codec_remove(struct platform_device *pdev)
+{
+        struct wm8994_priv *wm8994 = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec = &wm8994->codec;
+
+        wm8994_set_bias_level(codec, SND_SOC_BIAS_OFF);
+        snd_soc_unregister_dais(wm8994_dai, ARRAY_SIZE(wm8994_dai));
+        snd_soc_unregister_codec(&wm8994->codec);
+        kfree(wm8994);
+        wm8994_codec = NULL;
+
+        return 0;
+}
+
+static struct platform_driver wm8994_codec_driver = {
+        .driver = {
+                   .name = "wm8994-codec",
+                   .owner = THIS_MODULE,
+                   },
+        .probe = wm8994_codec_probe,
+        .remove = __devexit_p(wm8994_codec_remove),
+};
+
+static __init int wm8994_init(void)
+{
+        return platform_driver_register(&wm8994_codec_driver);
+}
+module_init(wm8994_init);
+
+static __exit void wm8994_exit(void)
+{
+        platform_driver_unregister(&wm8994_codec_driver);
+}
+module_exit(wm8994_exit);
+
+
+MODULE_DESCRIPTION("ASoC WM8994 driver");
+MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:wm8994-codec");
diff --git a/sound/soc/codecs/wm8994.h b/sound/soc/codecs/wm8994.h
new file mode 100644
index 000000000000..0a5e1424dea0
--- /dev/null
+++ b/sound/soc/codecs/wm8994.h
@@ -0,0 +1,26 @@
+/*
+ * wm8994.h  --  WM8994 Soc Audio driver
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef _WM8994_H
+#define _WM8994_H
+
+#include <sound/soc.h>
+
+extern struct snd_soc_codec_device soc_codec_dev_wm8994;
+extern struct snd_soc_dai wm8994_dai[];
+
+/* Sources for AIF1/2 SYSCLK - use with set_dai_sysclk() */
+#define WM8994_SYSCLK_MCLK1 1
+#define WM8994_SYSCLK_MCLK2 2
+#define WM8994_SYSCLK_FLL1  3
+#define WM8994_SYSCLK_FLL2  4
+
+#define WM8994_FLL1 1
+#define WM8994_FLL2 2
+
+#endif
diff --git a/sound/soc/codecs/wm9081.c b/sound/soc/codecs/wm9081.c
index 686e5aa97206..3a184fcb702b 100644
--- a/sound/soc/codecs/wm9081.c
+++ b/sound/soc/codecs/wm9081.c
@@ -18,6 +18,7 @@
 #include <linux/pm.h>
 #include <linux/i2c.h>
 #include <linux/platform_device.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
@@ -1262,19 +1263,9 @@ static int wm9081_probe(struct platform_device *pdev)
         snd_soc_dapm_new_controls(codec, wm9081_dapm_widgets,
                                   ARRAY_SIZE(wm9081_dapm_widgets));
         snd_soc_dapm_add_routes(codec, audio_paths, ARRAY_SIZE(audio_paths));
-        snd_soc_dapm_new_widgets(codec);
-
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                dev_err(codec->dev, "failed to register card: %d\n", ret);
-                goto card_err;
-        }
 
         return ret;
 
-card_err:
-        snd_soc_free_pcms(socdev);
-        snd_soc_dapm_free(socdev);
 pcm_err:
         return ret;
 }
@@ -1452,21 +1443,6 @@ static __devexit int wm9081_i2c_remove(struct i2c_client *client)
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int wm9081_i2c_suspend(struct i2c_client *client, pm_message_t msg)
-{
-        return snd_soc_suspend_device(&client->dev);
-}
-
-static int wm9081_i2c_resume(struct i2c_client *client)
-{
-        return snd_soc_resume_device(&client->dev);
-}
-#else
-#define wm9081_i2c_suspend NULL
-#define wm9081_i2c_resume NULL
-#endif
-
 static const struct i2c_device_id wm9081_i2c_id[] = {
         { "wm9081", 0 },
         { }
@@ -1480,8 +1456,6 @@ static struct i2c_driver wm9081_i2c_driver = {
         },
         .probe =    wm9081_i2c_probe,
         .remove =   __devexit_p(wm9081_i2c_remove),
-        .suspend =  wm9081_i2c_suspend,
-        .resume =   wm9081_i2c_resume,
         .id_table = wm9081_i2c_id,
 };
 
diff --git a/sound/soc/codecs/wm9705.c b/sound/soc/codecs/wm9705.c
index e7d2840d9e59..8793341849d1 100644
--- a/sound/soc/codecs/wm9705.c
+++ b/sound/soc/codecs/wm9705.c
@@ -10,6 +10,7 @@
  */
 
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/device.h>
@@ -205,7 +206,6 @@ static int wm9705_add_widgets(struct snd_soc_codec *codec)
         snd_soc_dapm_new_controls(codec, wm9705_dapm_widgets,
                                         ARRAY_SIZE(wm9705_dapm_widgets));
         snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
-        snd_soc_dapm_new_widgets(codec);
 
         return 0;
 }
@@ -403,12 +403,6 @@ static int wm9705_soc_probe(struct platform_device *pdev)
                                 ARRAY_SIZE(wm9705_snd_ac97_controls));
         wm9705_add_widgets(codec);
 
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                printk(KERN_ERR "wm9705: failed to register card\n");
-                goto reset_err;
-        }
-
         return 0;
 
 reset_err:
diff --git a/sound/soc/codecs/wm9712.c b/sound/soc/codecs/wm9712.c
index 1fd4e88f50cf..2f48a8aae22c 100644
--- a/sound/soc/codecs/wm9712.c
+++ b/sound/soc/codecs/wm9712.c
@@ -11,6 +11,7 @@
  */
 
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/device.h>
@@ -436,7 +437,6 @@ static int wm9712_add_widgets(struct snd_soc_codec *codec)
 
         snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
 
-        snd_soc_dapm_new_widgets(codec);
         return 0;
 }
 
@@ -464,7 +464,8 @@ static int ac97_write(struct snd_soc_codec *codec, unsigned int reg,
 {
         u16 *cache = codec->reg_cache;
 
-        soc_ac97_ops.write(codec->ac97, reg, val);
+        if (reg < 0x7c)
+                soc_ac97_ops.write(codec->ac97, reg, val);
         reg = reg >> 1;
         if (reg < (ARRAY_SIZE(wm9712_reg)))
                 cache[reg] = val;
@@ -695,17 +696,11 @@ static int wm9712_soc_probe(struct platform_device *pdev)
         snd_soc_add_controls(codec, wm9712_snd_ac97_controls,
                                 ARRAY_SIZE(wm9712_snd_ac97_controls));
         wm9712_add_widgets(codec);
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0) {
-                printk(KERN_ERR "wm9712: failed to register card\n");
-                goto reset_err;
-        }
 
         return 0;
 
 reset_err:
         snd_soc_free_pcms(socdev);
-
 pcm_err:
         snd_soc_free_ac97_codec(codec);
 
diff --git a/sound/soc/codecs/wm9713.c b/sound/soc/codecs/wm9713.c
index abed37acf787..2fca514fde58 100644
--- a/sound/soc/codecs/wm9713.c
+++ b/sound/soc/codecs/wm9713.c
@@ -16,6 +16,7 @@
  */
 
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/device.h>
 #include <sound/core.h>
@@ -23,13 +24,12 @@
 #include <sound/ac97_codec.h>
 #include <sound/initval.h>
 #include <sound/pcm_params.h>
+#include <sound/tlv.h>
 #include <sound/soc.h>
 #include <sound/soc-dapm.h>
 
 #include "wm9713.h"
 
-#define WM9713_VERSION "0.15"
-
 struct wm9713_priv {
         u32 pll_in; /* PLL input frequency */
 };
@@ -115,15 +115,27 @@ SOC_ENUM_SINGLE(AC97_3D_CONTROL, 12, 3, wm9713_mic_select), /* mic selection 18
 SOC_ENUM_SINGLE(MICB_MUX, 0, 2, wm9713_micb_select), /* mic selection 19 */
 };
 
+static const DECLARE_TLV_DB_SCALE(out_tlv, -4650, 150, 0);
+static const DECLARE_TLV_DB_SCALE(main_tlv, -3450, 150, 0);
+static const DECLARE_TLV_DB_SCALE(misc_tlv, -1500, 300, 0);
+static unsigned int mic_tlv[] = {
+        TLV_DB_RANGE_HEAD(2),
+        0, 2, TLV_DB_SCALE_ITEM(1200, 600, 0),
+        3, 3, TLV_DB_SCALE_ITEM(3000, 0, 0),
+};
+
 static const struct snd_kcontrol_new wm9713_snd_ac97_controls[] = {
-SOC_DOUBLE("Speaker Playback Volume", AC97_MASTER, 8, 0, 31, 1),
+SOC_DOUBLE_TLV("Speaker Playback Volume", AC97_MASTER, 8, 0, 31, 1, out_tlv),
 SOC_DOUBLE("Speaker Playback Switch", AC97_MASTER, 15, 7, 1, 1),
-SOC_DOUBLE("Headphone Playback Volume", AC97_HEADPHONE, 8, 0, 31, 1),
+SOC_DOUBLE_TLV("Headphone Playback Volume", AC97_HEADPHONE, 8, 0, 31, 1,
+               out_tlv),
 SOC_DOUBLE("Headphone Playback Switch", AC97_HEADPHONE, 15, 7, 1, 1),
-SOC_DOUBLE("Line In Volume", AC97_PC_BEEP, 8, 0, 31, 1),
-SOC_DOUBLE("PCM Playback Volume", AC97_PHONE, 8, 0, 31, 1),
-SOC_SINGLE("Mic 1 Volume", AC97_MIC, 8, 31, 1),
-SOC_SINGLE("Mic 2 Volume", AC97_MIC, 0, 31, 1),
+SOC_DOUBLE_TLV("Line In Volume", AC97_PC_BEEP, 8, 0, 31, 1, main_tlv),
+SOC_DOUBLE_TLV("PCM Playback Volume", AC97_PHONE, 8, 0, 31, 1, main_tlv),
+SOC_SINGLE_TLV("Mic 1 Volume", AC97_MIC, 8, 31, 1, main_tlv),
+SOC_SINGLE_TLV("Mic 2 Volume", AC97_MIC, 0, 31, 1, main_tlv),
+SOC_SINGLE_TLV("Mic 1 Preamp Volume", AC97_3D_CONTROL, 10, 3, 0, mic_tlv),
+SOC_SINGLE_TLV("Mic 2 Preamp Volume", AC97_3D_CONTROL, 12, 3, 0, mic_tlv),
 
 SOC_SINGLE("Mic Boost (+20dB) Switch", AC97_LINE, 5, 1, 0),
 SOC_SINGLE("Mic Headphone Mixer Volume", AC97_LINE, 0, 7, 1),
@@ -133,7 +145,7 @@ SOC_ENUM("Capture Volume Steps", wm9713_enum[5]),
 SOC_DOUBLE("Capture Volume", AC97_CD, 8, 0, 31, 0),
 SOC_SINGLE("Capture ZC Switch", AC97_CD, 7, 1, 0),
 
-SOC_SINGLE("Capture to Headphone Volume", AC97_VIDEO, 11, 7, 1),
+SOC_SINGLE_TLV("Capture to Headphone Volume", AC97_VIDEO, 11, 7, 1, misc_tlv),
 SOC_SINGLE("Capture to Mono Boost (+20dB) Switch", AC97_VIDEO, 8, 1, 0),
 SOC_SINGLE("Capture ADC Boost (+20dB) Switch", AC97_VIDEO, 6, 1, 0),
 
@@ -154,28 +166,43 @@ SOC_DOUBLE("Headphone Playback ZC Switch", AC97_HEADPHONE, 14, 6, 1, 0),
 
 SOC_SINGLE("Out4 Playback Switch", AC97_MASTER_MONO, 15, 1, 1),
 SOC_SINGLE("Out4 Playback ZC Switch", AC97_MASTER_MONO, 14, 1, 0),
-SOC_SINGLE("Out4 Playback Volume", AC97_MASTER_MONO, 8, 63, 1),
+SOC_SINGLE_TLV("Out4 Playback Volume", AC97_MASTER_MONO, 8, 31, 1, out_tlv),
 
 SOC_SINGLE("Out3 Playback Switch", AC97_MASTER_MONO, 7, 1, 1),
 SOC_SINGLE("Out3 Playback ZC Switch", AC97_MASTER_MONO, 6, 1, 0),
-SOC_SINGLE("Out3 Playback Volume", AC97_MASTER_MONO, 0, 63, 1),
+SOC_SINGLE_TLV("Out3 Playback Volume", AC97_MASTER_MONO, 0, 31, 1, out_tlv),
 
-SOC_SINGLE("Mono Capture Volume", AC97_MASTER_TONE, 8, 31, 1),
+SOC_SINGLE_TLV("Mono Capture Volume", AC97_MASTER_TONE, 8, 31, 1, main_tlv),
 SOC_SINGLE("Mono Playback Switch", AC97_MASTER_TONE, 7, 1, 1),
 SOC_SINGLE("Mono Playback ZC Switch", AC97_MASTER_TONE, 6, 1, 0),
-SOC_SINGLE("Mono Playback Volume", AC97_MASTER_TONE, 0, 31, 1),
+SOC_SINGLE_TLV("Mono Playback Volume", AC97_MASTER_TONE, 0, 31, 1, out_tlv),
 
-SOC_SINGLE("PC Beep Playback Headphone Volume", AC97_AUX, 12, 7, 1),
-SOC_SINGLE("PC Beep Playback Speaker Volume", AC97_AUX, 8, 7, 1),
-SOC_SINGLE("PC Beep Playback Mono Volume", AC97_AUX, 4, 7, 1),
+SOC_SINGLE_TLV("Headphone Mixer Beep Playback Volume", AC97_AUX, 12, 7, 1,
+               misc_tlv),
+SOC_SINGLE_TLV("Speaker Mixer Beep Playback Volume", AC97_AUX, 8, 7, 1,
+               misc_tlv),
+SOC_SINGLE_TLV("Mono Mixer Beep Playback Volume", AC97_AUX, 4, 7, 1, misc_tlv),
 
-SOC_SINGLE("Voice Playback Headphone Volume", AC97_PCM, 12, 7, 1),
+SOC_SINGLE_TLV("Voice Playback Headphone Volume", AC97_PCM, 12, 7, 1,
+               misc_tlv),
 SOC_SINGLE("Voice Playback Master Volume", AC97_PCM, 8, 7, 1),
 SOC_SINGLE("Voice Playback Mono Volume", AC97_PCM, 4, 7, 1),
 
+SOC_SINGLE_TLV("Headphone Mixer Aux Playback Volume", AC97_REC_SEL, 12, 7, 1,
+               misc_tlv),
+
+SOC_SINGLE_TLV("Speaker Mixer Voice Playback Volume", AC97_PCM, 8, 7, 1,
+               misc_tlv),
+SOC_SINGLE_TLV("Speaker Mixer Aux Playback Volume", AC97_REC_SEL, 8, 7, 1,
+               misc_tlv),
+
+SOC_SINGLE_TLV("Mono Mixer Voice Playback Volume", AC97_PCM, 4, 7, 1,
+               misc_tlv),
+SOC_SINGLE_TLV("Mono Mixer Aux Playback Volume", AC97_REC_SEL, 4, 7, 1,
+               misc_tlv),
+
 SOC_SINGLE("Aux Playback Headphone Volume", AC97_REC_SEL, 12, 7, 1),
 SOC_SINGLE("Aux Playback Master Volume", AC97_REC_SEL, 8, 7, 1),
-SOC_SINGLE("Aux Playback Mono Volume", AC97_REC_SEL, 4, 7, 1),
 
 SOC_ENUM("Bass Control", wm9713_enum[16]),
 SOC_SINGLE("Bass Cut-off Switch", AC97_GENERAL_PURPOSE, 12, 1, 1),
@@ -266,7 +293,7 @@ static int mixer_event(struct snd_soc_dapm_widget *w,
 
 /* Left Headphone Mixers */
 static const struct snd_kcontrol_new wm9713_hpl_mixer_controls[] = {
-SOC_DAPM_SINGLE("PC Beep Playback Switch", HPL_MIXER, 5, 1, 0),
+SOC_DAPM_SINGLE("Beep Playback Switch", HPL_MIXER, 5, 1, 0),
 SOC_DAPM_SINGLE("Voice Playback Switch", HPL_MIXER, 4, 1, 0),
 SOC_DAPM_SINGLE("Aux Playback Switch", HPL_MIXER, 3, 1, 0),
 SOC_DAPM_SINGLE("PCM Playback Switch", HPL_MIXER, 2, 1, 0),
@@ -276,7 +303,7 @@ SOC_DAPM_SINGLE("Bypass Playback Switch", HPL_MIXER, 0, 1, 0),
 
 /* Right Headphone Mixers */
 static const struct snd_kcontrol_new wm9713_hpr_mixer_controls[] = {
-SOC_DAPM_SINGLE("PC Beep Playback Switch", HPR_MIXER, 5, 1, 0),
+SOC_DAPM_SINGLE("Beep Playback Switch", HPR_MIXER, 5, 1, 0),
 SOC_DAPM_SINGLE("Voice Playback Switch", HPR_MIXER, 4, 1, 0),
 SOC_DAPM_SINGLE("Aux Playback Switch", HPR_MIXER, 3, 1, 0),
 SOC_DAPM_SINGLE("PCM Playback Switch", HPR_MIXER, 2, 1, 0),
@@ -294,7 +321,7 @@ SOC_DAPM_ENUM("Route", wm9713_enum[0]);
 
 /* Speaker Mixer */
 static const struct snd_kcontrol_new wm9713_speaker_mixer_controls[] = {
-SOC_DAPM_SINGLE("PC Beep Playback Switch", AC97_AUX, 11, 1, 1),
+SOC_DAPM_SINGLE("Beep Playback Switch", AC97_AUX, 11, 1, 1),
 SOC_DAPM_SINGLE("Voice Playback Switch", AC97_PCM, 11, 1, 1),
 SOC_DAPM_SINGLE("Aux Playback Switch", AC97_REC_SEL, 11, 1, 1),
 SOC_DAPM_SINGLE("PCM Playback Switch", AC97_PHONE, 14, 1, 1),
@@ -304,7 +331,7 @@ SOC_DAPM_SINGLE("Bypass Playback Switch", AC97_PC_BEEP, 14, 1, 1),
 
 /* Mono Mixer */
 static const struct snd_kcontrol_new wm9713_mono_mixer_controls[] = {
-SOC_DAPM_SINGLE("PC Beep Playback Switch", AC97_AUX, 7, 1, 1),
+SOC_DAPM_SINGLE("Beep Playback Switch", AC97_AUX, 7, 1, 1),
 SOC_DAPM_SINGLE("Voice Playback Switch", AC97_PCM, 7, 1, 1),
 SOC_DAPM_SINGLE("Aux Playback Switch", AC97_REC_SEL, 7, 1, 1),
 SOC_DAPM_SINGLE("PCM Playback Switch", AC97_PHONE, 13, 1, 1),
@@ -463,7 +490,7 @@ SND_SOC_DAPM_VMID("VMID"),
 
 static const struct snd_soc_dapm_route audio_map[] = {
         /* left HP mixer */
-        {"Left HP Mixer", "PC Beep Playback Switch", "PCBEEP"},
+        {"Left HP Mixer", "Beep Playback Switch",    "PCBEEP"},
         {"Left HP Mixer", "Voice Playback Switch",   "Voice DAC"},
         {"Left HP Mixer", "Aux Playback Switch",     "Aux DAC"},
         {"Left HP Mixer", "Bypass Playback Switch",  "Left Line In"},
@@ -472,7 +499,7 @@ static const struct snd_soc_dapm_route audio_map[] = {
         {"Left HP Mixer", NULL,  "Capture Headphone Mux"},
 
         /* right HP mixer */
-        {"Right HP Mixer", "PC Beep Playback Switch", "PCBEEP"},
+        {"Right HP Mixer", "Beep Playback Switch",    "PCBEEP"},
         {"Right HP Mixer", "Voice Playback Switch",   "Voice DAC"},
         {"Right HP Mixer", "Aux Playback Switch",     "Aux DAC"},
         {"Right HP Mixer", "Bypass Playback Switch",  "Right Line In"},
@@ -491,7 +518,7 @@ static const struct snd_soc_dapm_route audio_map[] = {
         {"Capture Mixer", NULL, "Right Capture Source"},
 
         /* speaker mixer */
-        {"Speaker Mixer", "PC Beep Playback Switch", "PCBEEP"},
+        {"Speaker Mixer", "Beep Playback Switch",    "PCBEEP"},
         {"Speaker Mixer", "Voice Playback Switch",   "Voice DAC"},
         {"Speaker Mixer", "Aux Playback Switch",     "Aux DAC"},
         {"Speaker Mixer", "Bypass Playback Switch",  "Line Mixer"},
@@ -499,7 +526,7 @@ static const struct snd_soc_dapm_route audio_map[] = {
         {"Speaker Mixer", "MonoIn Playback Switch",  "Mono In"},
 
         /* mono mixer */
-        {"Mono Mixer", "PC Beep Playback Switch", "PCBEEP"},
+        {"Mono Mixer", "Beep Playback Switch",    "PCBEEP"},
         {"Mono Mixer", "Voice Playback Switch",   "Voice DAC"},
         {"Mono Mixer", "Aux Playback Switch",     "Aux DAC"},
         {"Mono Mixer", "Bypass Playback Switch",  "Line Mixer"},
@@ -625,7 +652,6 @@ static int wm9713_add_widgets(struct snd_soc_codec *codec)
 
         snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
 
-        snd_soc_dapm_new_widgets(codec);
         return 0;
 }
 
@@ -800,8 +826,8 @@ static int wm9713_set_pll(struct snd_soc_codec *codec,
         return 0;
 }
 
-static int wm9713_set_dai_pll(struct snd_soc_dai *codec_dai,
-                int pll_id, unsigned int freq_in, unsigned int freq_out)
+static int wm9713_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id,
+                int source, unsigned int freq_in, unsigned int freq_out)
 {
         struct snd_soc_codec *codec = codec_dai->codec;
         return wm9713_set_pll(codec, pll_id, freq_in, freq_out);
@@ -1187,8 +1213,6 @@ static int wm9713_soc_probe(struct platform_device *pdev)
         struct snd_soc_codec *codec;
         int ret = 0, reg;
 
-        printk(KERN_INFO "WM9713/WM9714 SoC Audio Codec %s\n", WM9713_VERSION);
-
         socdev->card->codec = kzalloc(sizeof(struct snd_soc_codec),
                                       GFP_KERNEL);
         if (socdev->card->codec == NULL)
@@ -1247,14 +1271,11 @@ static int wm9713_soc_probe(struct platform_device *pdev)
         snd_soc_add_controls(codec, wm9713_snd_ac97_controls,
                                 ARRAY_SIZE(wm9713_snd_ac97_controls));
         wm9713_add_widgets(codec);
-        ret = snd_soc_init_card(socdev);
-        if (ret < 0)
-                goto reset_err;
+
         return 0;
 
 reset_err:
         snd_soc_free_pcms(socdev);
-
 pcm_err:
         snd_soc_free_ac97_codec(codec);
 
diff --git a/sound/soc/codecs/wm_hubs.c b/sound/soc/codecs/wm_hubs.c
index e542027eea89..e1f225a3ac46 100644
--- a/sound/soc/codecs/wm_hubs.c
+++ b/sound/soc/codecs/wm_hubs.c
@@ -62,36 +62,108 @@ static const char *speaker_mode_text[] = {
 static const struct soc_enum speaker_mode =
         SOC_ENUM_SINGLE(WM8993_SPKMIXR_ATTENUATION, 8, 2, speaker_mode_text);
 
-static void wait_for_dc_servo(struct snd_soc_codec *codec)
+static void wait_for_dc_servo(struct snd_soc_codec *codec, unsigned int op)
 {
         unsigned int reg;
         int count = 0;
+        unsigned int val;
+
+        val = op | WM8993_DCS_ENA_CHAN_0 | WM8993_DCS_ENA_CHAN_1;
+
+        /* Trigger the command */
+        snd_soc_write(codec, WM8993_DC_SERVO_0, val);
 
         dev_dbg(codec->dev, "Waiting for DC servo...\n");
+
         do {
                 count++;
                 msleep(1);
-                reg = snd_soc_read(codec, WM8993_DC_SERVO_READBACK_0);
-                dev_dbg(codec->dev, "DC servo status: %x\n", reg);
-        } while ((reg & WM8993_DCS_CAL_COMPLETE_MASK)
-                 != WM8993_DCS_CAL_COMPLETE_MASK && count < 1000);
+                reg = snd_soc_read(codec, WM8993_DC_SERVO_0);
+                dev_dbg(codec->dev, "DC servo: %x\n", reg);
+        } while (reg & op && count < 400);
 
-        if ((reg & WM8993_DCS_CAL_COMPLETE_MASK)
-            != WM8993_DCS_CAL_COMPLETE_MASK)
+        if (reg & op)
                 dev_err(codec->dev, "Timed out waiting for DC Servo\n");
 }
 
 /*
+ * Startup calibration of the DC servo
+ */
+static void calibrate_dc_servo(struct snd_soc_codec *codec)
+{
+        struct wm_hubs_data *hubs = codec->private_data;
+        u16 reg, reg_l, reg_r, dcs_cfg;
+
+        /* Set for 32 series updates */
+        snd_soc_update_bits(codec, WM8993_DC_SERVO_1,
+                            WM8993_DCS_SERIES_NO_01_MASK,
+                            32 << WM8993_DCS_SERIES_NO_01_SHIFT);
+        wait_for_dc_servo(codec,
+                          WM8993_DCS_TRIG_SERIES_0 | WM8993_DCS_TRIG_SERIES_1);
+
+        /* Apply correction to DC servo result */
+        if (hubs->dcs_codes) {
+                dev_dbg(codec->dev, "Applying %d code DC servo correction\n",
+                        hubs->dcs_codes);
+
+                /* Different chips in the family support different
+                 * readback methods.
+                 */
+                switch (hubs->dcs_readback_mode) {
+                case 0:
+                        reg_l = snd_soc_read(codec, WM8993_DC_SERVO_READBACK_1)
+                                & WM8993_DCS_INTEG_CHAN_0_MASK;;
+                        reg_r = snd_soc_read(codec, WM8993_DC_SERVO_READBACK_2)
+                                & WM8993_DCS_INTEG_CHAN_1_MASK;
+                        break;
+                case 1:
+                        reg = snd_soc_read(codec, WM8993_DC_SERVO_3);
+                        reg_l = (reg & WM8993_DCS_DAC_WR_VAL_1_MASK)
+                                >> WM8993_DCS_DAC_WR_VAL_1_SHIFT;
+                        reg_r = reg & WM8993_DCS_DAC_WR_VAL_0_MASK;
+                        break;
+                default:
+                        WARN(1, "Unknown DCS readback method");
+                        break;
+                }
+
+                /* HPOUT1L */
+                if (reg_l + hubs->dcs_codes > 0 &&
+                    reg_l + hubs->dcs_codes < 0xff)
+                        reg_l += hubs->dcs_codes;
+                dcs_cfg = reg_l << WM8993_DCS_DAC_WR_VAL_1_SHIFT;
+
+                /* HPOUT1R */
+                if (reg_r + hubs->dcs_codes > 0 &&
+                    reg_r + hubs->dcs_codes < 0xff)
+                        reg_r += hubs->dcs_codes;
+                dcs_cfg |= reg_r;
+
+                /* Do it */
+                snd_soc_write(codec, WM8993_DC_SERVO_3, dcs_cfg);
+                wait_for_dc_servo(codec,
+                                  WM8993_DCS_TRIG_DAC_WR_0 |
+                                  WM8993_DCS_TRIG_DAC_WR_1);
+        }
+}
+
+/*
  * Update the DC servo calibration on gain changes
  */
 static int wm8993_put_dc_servo(struct snd_kcontrol *kcontrol,
-                              struct snd_ctl_elem_value *ucontrol)
+                               struct snd_ctl_elem_value *ucontrol)
 {
         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct wm_hubs_data *hubs = codec->private_data;
         int ret;
 
         ret = snd_soc_put_volsw_2r(kcontrol, ucontrol);
 
+        /* If we're applying an offset correction then updating the
+         * callibration would be likely to introduce further offsets. */
+        if (hubs->dcs_codes)
+                return ret;
+
         /* Only need to do this if the outputs are active */
         if (snd_soc_read(codec, WM8993_POWER_MANAGEMENT_1)
             & (WM8993_HPOUT1L_ENA | WM8993_HPOUT1R_ENA))
@@ -251,6 +323,47 @@ SOC_SINGLE_TLV("LINEOUT2 Volume", WM8993_LINE_OUTPUTS_VOLUME, 0, 1, 1,
                line_tlv),
 };
 
+static int hp_supply_event(struct snd_soc_dapm_widget *w,
+                           struct snd_kcontrol *kcontrol, int event)
+{
+        struct snd_soc_codec *codec = w->codec;
+        struct wm_hubs_data *hubs = codec->private_data;
+
+        switch (event) {
+        case SND_SOC_DAPM_PRE_PMU:
+                switch (hubs->hp_startup_mode) {
+                case 0:
+                        break;
+                case 1:
+                        /* Enable the headphone amp */
+                        snd_soc_update_bits(codec, WM8993_POWER_MANAGEMENT_1,
+                                            WM8993_HPOUT1L_ENA |
+                                            WM8993_HPOUT1R_ENA,
+                                            WM8993_HPOUT1L_ENA |
+                                            WM8993_HPOUT1R_ENA);
+
+                        /* Enable the second stage */
+                        snd_soc_update_bits(codec, WM8993_ANALOGUE_HP_0,
+                                            WM8993_HPOUT1L_DLY |
+                                            WM8993_HPOUT1R_DLY,
+                                            WM8993_HPOUT1L_DLY |
+                                            WM8993_HPOUT1R_DLY);
+                        break;
+                default:
+                        dev_err(codec->dev, "Unknown HP startup mode %d\n",
+                                hubs->hp_startup_mode);
+                        break;
+                }
+
+        case SND_SOC_DAPM_PRE_PMD:
+                snd_soc_update_bits(codec, WM8993_CHARGE_PUMP_1,
+                                    WM8993_CP_ENA, 0);
+                break;
+        }
+
+        return 0;
+}
+
 static int hp_event(struct snd_soc_dapm_widget *w,
                     struct snd_kcontrol *kcontrol, int event)
 {
@@ -271,14 +384,11 @@ static int hp_event(struct snd_soc_dapm_widget *w,
                 reg |= WM8993_HPOUT1L_DLY | WM8993_HPOUT1R_DLY;
                 snd_soc_write(codec, WM8993_ANALOGUE_HP_0, reg);
 
-                /* Start the DC servo */
-                snd_soc_update_bits(codec, WM8993_DC_SERVO_0,
-                                    0xFFFF,
-                                    WM8993_DCS_ENA_CHAN_0 |
-                                    WM8993_DCS_ENA_CHAN_1 |
-                                    WM8993_DCS_TRIG_STARTUP_1 |
-                                    WM8993_DCS_TRIG_STARTUP_0);
-                wait_for_dc_servo(codec);
+                /* Smallest supported update interval */
+                snd_soc_update_bits(codec, WM8993_DC_SERVO_1,
+                                    WM8993_DCS_TIMER_PERIOD_01_MASK, 1);
+
+                calibrate_dc_servo(codec);
 
                 reg |= WM8993_HPOUT1R_OUTP | WM8993_HPOUT1R_RMV_SHORT |
                         WM8993_HPOUT1L_OUTP | WM8993_HPOUT1L_RMV_SHORT;
@@ -286,23 +396,19 @@ static int hp_event(struct snd_soc_dapm_widget *w,
                 break;
 
         case SND_SOC_DAPM_PRE_PMD:
-                reg &= ~(WM8993_HPOUT1L_RMV_SHORT |
-                         WM8993_HPOUT1L_DLY |
-                         WM8993_HPOUT1L_OUTP |
-                         WM8993_HPOUT1R_RMV_SHORT |
-                         WM8993_HPOUT1R_DLY |
-                         WM8993_HPOUT1R_OUTP);
+                snd_soc_update_bits(codec, WM8993_ANALOGUE_HP_0,
+                                    WM8993_HPOUT1L_DLY |
+                                    WM8993_HPOUT1R_DLY |
+                                    WM8993_HPOUT1L_RMV_SHORT |
+                                    WM8993_HPOUT1R_RMV_SHORT, 0);
 
-                snd_soc_update_bits(codec, WM8993_DC_SERVO_0,
-                                    0xffff, 0);
+                snd_soc_update_bits(codec, WM8993_ANALOGUE_HP_0,
+                                    WM8993_HPOUT1L_OUTP |
+                                    WM8993_HPOUT1R_OUTP, 0);
 
-                snd_soc_write(codec, WM8993_ANALOGUE_HP_0, reg);
                 snd_soc_update_bits(codec, WM8993_POWER_MANAGEMENT_1,
                                     WM8993_HPOUT1L_ENA | WM8993_HPOUT1R_ENA,
                                     0);
-
-                snd_soc_update_bits(codec, WM8993_CHARGE_PUMP_1,
-                                    WM8993_CP_ENA, 0);
                 break;
         }
 
@@ -438,11 +544,11 @@ static const struct snd_soc_dapm_widget analogue_dapm_widgets[] = {
 SND_SOC_DAPM_INPUT("IN1LN"),
 SND_SOC_DAPM_INPUT("IN1LP"),
 SND_SOC_DAPM_INPUT("IN2LN"),
-SND_SOC_DAPM_INPUT("IN2LP/VXRN"),
+SND_SOC_DAPM_INPUT("IN2LP:VXRN"),
 SND_SOC_DAPM_INPUT("IN1RN"),
 SND_SOC_DAPM_INPUT("IN1RP"),
 SND_SOC_DAPM_INPUT("IN2RN"),
-SND_SOC_DAPM_INPUT("IN2RP/VXRP"),
+SND_SOC_DAPM_INPUT("IN2RP:VXRP"),
 
 SND_SOC_DAPM_MICBIAS("MICBIAS2", WM8993_POWER_MANAGEMENT_1, 5, 0),
 SND_SOC_DAPM_MICBIAS("MICBIAS1", WM8993_POWER_MANAGEMENT_1, 4, 0),
@@ -473,6 +579,8 @@ SND_SOC_DAPM_MIXER("Right Output Mixer", WM8993_POWER_MANAGEMENT_3, 4, 0,
 SND_SOC_DAPM_PGA("Left Output PGA", WM8993_POWER_MANAGEMENT_3, 7, 0, NULL, 0),
 SND_SOC_DAPM_PGA("Right Output PGA", WM8993_POWER_MANAGEMENT_3, 6, 0, NULL, 0),
 
+SND_SOC_DAPM_SUPPLY("Headphone Supply", SND_SOC_NOPM, 0, 0, hp_supply_event, 
+                    SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_PRE_PMD),
 SND_SOC_DAPM_PGA_E("Headphone PGA", SND_SOC_NOPM, 0, 0,
                    NULL, 0,
                    hp_event, SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
@@ -537,14 +645,14 @@ static const struct snd_soc_dapm_route analogue_routes[] = {
         { "IN1R PGA", "IN1RP Switch", "IN1RP" },
         { "IN1R PGA", "IN1RN Switch", "IN1RN" },
 
-        { "IN2L PGA", "IN2LP Switch", "IN2LP/VXRN" },
+        { "IN2L PGA", "IN2LP Switch", "IN2LP:VXRN" },
         { "IN2L PGA", "IN2LN Switch", "IN2LN" },
 
-        { "IN2R PGA", "IN2RP Switch", "IN2RP/VXRP" },
+        { "IN2R PGA", "IN2RP Switch", "IN2RP:VXRP" },
         { "IN2R PGA", "IN2RN Switch", "IN2RN" },
 
-        { "Direct Voice", NULL, "IN2LP/VXRN" },
-        { "Direct Voice", NULL, "IN2RP/VXRP" },
+        { "Direct Voice", NULL, "IN2LP:VXRN" },
+        { "Direct Voice", NULL, "IN2RP:VXRP" },
 
         { "MIXINL", "IN1L Switch", "IN1L PGA" },
         { "MIXINL", "IN2L Switch", "IN2L PGA" },
@@ -565,7 +673,7 @@ static const struct snd_soc_dapm_route analogue_routes[] = {
         { "Left Output Mixer", "Right Input Switch", "MIXINR" },
         { "Left Output Mixer", "IN2RN Switch", "IN2RN" },
         { "Left Output Mixer", "IN2LN Switch", "IN2LN" },
-        { "Left Output Mixer", "IN2LP Switch", "IN2LP/VXRN" },
+        { "Left Output Mixer", "IN2LP Switch", "IN2LP:VXRN" },
         { "Left Output Mixer", "IN1L Switch", "IN1L PGA" },
         { "Left Output Mixer", "IN1R Switch", "IN1R PGA" },
 
@@ -573,7 +681,7 @@ static const struct snd_soc_dapm_route analogue_routes[] = {
         { "Right Output Mixer", "Right Input Switch", "MIXINR" },
         { "Right Output Mixer", "IN2LN Switch", "IN2LN" },
         { "Right Output Mixer", "IN2RN Switch", "IN2RN" },
-        { "Right Output Mixer", "IN2RP Switch", "IN2RP/VXRP" },
+        { "Right Output Mixer", "IN2RP Switch", "IN2RP:VXRP" },
         { "Right Output Mixer", "IN1L Switch", "IN1L PGA" },
         { "Right Output Mixer", "IN1R Switch", "IN1R PGA" },
 
@@ -626,6 +734,7 @@ static const struct snd_soc_dapm_route analogue_routes[] = {
         { "Headphone PGA", NULL, "Left Headphone Mux" },
         { "Headphone PGA", NULL, "Right Headphone Mux" },
         { "Headphone PGA", NULL, "CLK_SYS" },
+        { "Headphone PGA", NULL, "Headphone Supply" },
 
         { "HPOUT1L", NULL, "Headphone PGA" },
         { "HPOUT1R", NULL, "Headphone PGA" },
@@ -738,6 +847,47 @@ int wm_hubs_add_analogue_routes(struct snd_soc_codec *codec,
 }
 EXPORT_SYMBOL_GPL(wm_hubs_add_analogue_routes);
 
+int wm_hubs_handle_analogue_pdata(struct snd_soc_codec *codec,
+                                  int lineout1_diff, int lineout2_diff,
+                                  int lineout1fb, int lineout2fb,
+                                  int jd_scthr, int jd_thr, int micbias1_lvl,
+                                  int micbias2_lvl)
+{
+        if (!lineout1_diff)
+                snd_soc_update_bits(codec, WM8993_LINE_MIXER1,
+                                    WM8993_LINEOUT1_MODE,
+                                    WM8993_LINEOUT1_MODE);
+        if (!lineout2_diff)
+                snd_soc_update_bits(codec, WM8993_LINE_MIXER2,
+                                    WM8993_LINEOUT2_MODE,
+                                    WM8993_LINEOUT2_MODE);
+
+        /* If the line outputs are differential then we aren't presenting
+         * VMID as an output and can disable it.
+         */
+        if (lineout1_diff && lineout2_diff)
+                codec->idle_bias_off = 1;
+
+        if (lineout1fb)
+                snd_soc_update_bits(codec, WM8993_ADDITIONAL_CONTROL,
+                                    WM8993_LINEOUT1_FB, WM8993_LINEOUT1_FB);
+
+        if (lineout2fb)
+                snd_soc_update_bits(codec, WM8993_ADDITIONAL_CONTROL,
+                                    WM8993_LINEOUT2_FB, WM8993_LINEOUT2_FB);
+
+        snd_soc_update_bits(codec, WM8993_MICBIAS,
+                            WM8993_JD_SCTHR_MASK | WM8993_JD_THR_MASK |
+                            WM8993_MICB1_LVL | WM8993_MICB2_LVL,
+                            jd_scthr << WM8993_JD_SCTHR_SHIFT |
+                            jd_thr << WM8993_JD_THR_SHIFT |
+                            micbias1_lvl |
+                            micbias2_lvl << WM8993_MICB2_LVL_SHIFT);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(wm_hubs_handle_analogue_pdata);
+
 MODULE_DESCRIPTION("Shared support for Wolfson hubs products");
 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
 MODULE_LICENSE("GPL");
diff --git a/sound/soc/codecs/wm_hubs.h b/sound/soc/codecs/wm_hubs.h
index ec09cb6a2939..e51c16683589 100644
--- a/sound/soc/codecs/wm_hubs.h
+++ b/sound/soc/codecs/wm_hubs.h
@@ -18,7 +18,19 @@ struct snd_soc_codec;
 
 extern const unsigned int wm_hubs_spkmix_tlv[];
 
+/* This *must* be the first element of the codec->private_data struct */
+struct wm_hubs_data {
+        int dcs_codes;
+        int dcs_readback_mode;
+        int hp_startup_mode;
+};
+
 extern int wm_hubs_add_analogue_controls(struct snd_soc_codec *);
 extern int wm_hubs_add_analogue_routes(struct snd_soc_codec *, int, int);
+extern int wm_hubs_handle_analogue_pdata(struct snd_soc_codec *,
+                                         int lineout1_diff, int lineout2_diff,
+                                         int lineout1fb, int lineout2fb,
+                                         int jd_scthr, int jd_thr,
+                                         int micbias1_lvl, int micbias2_lvl);
 
 #endif
diff --git a/sound/soc/davinci/Kconfig b/sound/soc/davinci/Kconfig
index 4dfd4ad9d90e..047ee39418c0 100644
--- a/sound/soc/davinci/Kconfig
+++ b/sound/soc/davinci/Kconfig
@@ -13,9 +13,9 @@ config SND_DAVINCI_SOC_MCASP
         tristate
 
 config SND_DAVINCI_SOC_EVM
-        tristate "SoC Audio support for DaVinci DM6446 or DM355 EVM"
+        tristate "SoC Audio support for DaVinci DM6446, DM355 or DM365 EVM"
         depends on SND_DAVINCI_SOC
-        depends on MACH_DAVINCI_EVM || MACH_DAVINCI_DM355_EVM
+        depends on MACH_DAVINCI_EVM || MACH_DAVINCI_DM355_EVM  || MACH_DAVINCI_DM365_EVM
         select SND_DAVINCI_SOC_I2S
         select SND_SOC_TLV320AIC3X
         help
diff --git a/sound/soc/davinci/davinci-evm.c b/sound/soc/davinci/davinci-evm.c
index 67414f659405..7ccbe6684fc2 100644
--- a/sound/soc/davinci/davinci-evm.c
+++ b/sound/soc/davinci/davinci-evm.c
@@ -45,7 +45,8 @@ static int evm_hw_params(struct snd_pcm_substream *substream,
         unsigned sysclk;
 
         /* ASP1 on DM355 EVM is clocked by an external oscillator */
-        if (machine_is_davinci_dm355_evm() || machine_is_davinci_dm6467_evm())
+        if (machine_is_davinci_dm355_evm() || machine_is_davinci_dm6467_evm() ||
+            machine_is_davinci_dm365_evm())
                 sysclk = 27000000;
 
         /* ASP0 in DM6446 EVM is clocked by U55, as configured by
@@ -176,7 +177,7 @@ static struct snd_soc_dai_link da8xx_evm_dai = {
         .ops = &evm_ops,
 };
 
-/* davinci-evm audio machine driver */
+/* davinci dm6446, dm355 or dm365 evm audio machine driver */
 static struct snd_soc_card snd_soc_card_evm = {
         .name = "DaVinci EVM",
         .platform = &davinci_soc_platform,
@@ -243,7 +244,7 @@ static int __init evm_init(void)
         int index;
         int ret;
 
-        if (machine_is_davinci_evm()) {
+        if (machine_is_davinci_evm() || machine_is_davinci_dm365_evm()) {
                 evm_snd_dev_data = &evm_snd_devdata;
                 index = 0;
         } else if (machine_is_davinci_dm355_evm()) {
diff --git a/sound/soc/davinci/davinci-i2s.c b/sound/soc/davinci/davinci-i2s.c
index 4ae707048021..adadcd3aa1b1 100644
--- a/sound/soc/davinci/davinci-i2s.c
+++ b/sound/soc/davinci/davinci-i2s.c
@@ -12,6 +12,7 @@
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/device.h>
+#include <linux/slab.h>
 #include <linux/delay.h>
 #include <linux/io.h>
 #include <linux/clk.h>
@@ -97,12 +98,24 @@ enum {
         DAVINCI_MCBSP_WORD_32,
 };
 
+static const unsigned char data_type[SNDRV_PCM_FORMAT_S32_LE + 1] = {
+        [SNDRV_PCM_FORMAT_S8]           = 1,
+        [SNDRV_PCM_FORMAT_S16_LE]       = 2,
+        [SNDRV_PCM_FORMAT_S32_LE]       = 4,
+};
+
+static const unsigned char asp_word_length[SNDRV_PCM_FORMAT_S32_LE + 1] = {
+        [SNDRV_PCM_FORMAT_S8]           = DAVINCI_MCBSP_WORD_8,
+        [SNDRV_PCM_FORMAT_S16_LE]       = DAVINCI_MCBSP_WORD_16,
+        [SNDRV_PCM_FORMAT_S32_LE]       = DAVINCI_MCBSP_WORD_32,
+};
+
+static const unsigned char double_fmt[SNDRV_PCM_FORMAT_S32_LE + 1] = {
+        [SNDRV_PCM_FORMAT_S8]           = SNDRV_PCM_FORMAT_S16_LE,
+        [SNDRV_PCM_FORMAT_S16_LE]       = SNDRV_PCM_FORMAT_S32_LE,
+};
+
 struct davinci_mcbsp_dev {
-        /*
-         * dma_params must be first because rtd->dai->cpu_dai->private_data
-         * is cast to a pointer of an array of struct davinci_pcm_dma_params in
-         * davinci_pcm_open.
-         */
         struct davinci_pcm_dma_params   dma_params[2];
         void __iomem                    *base;
 #define MOD_DSP_A       0
@@ -110,6 +123,27 @@ struct davinci_mcbsp_dev {
         int                             mode;
         u32                             pcr;
         struct clk                      *clk;
+        /*
+         * Combining both channels into 1 element will at least double the
+         * amount of time between servicing the dma channel, increase
+         * effiency, and reduce the chance of overrun/underrun. But,
+         * it will result in the left & right channels being swapped.
+         *
+         * If relabeling the left and right channels is not possible,
+         * you may want to let the codec know to swap them back.
+         *
+         * It may allow x10 the amount of time to service dma requests,
+         * if the codec is master and is using an unnecessarily fast bit clock
+         * (ie. tlvaic23b), independent of the sample rate. So, having an
+         * entire frame at once means it can be serviced at the sample rate
+         * instead of the bit clock rate.
+         *
+         * In the now unlikely case that an underrun still
+         * occurs, both the left and right samples will be repeated
+         * so that no pops are heard, and the left and right channels
+         * won't end up being swapped because of the underrun.
+         */
+        unsigned enable_channel_combine:1;
 };
 
 static inline void davinci_mcbsp_write_reg(struct davinci_mcbsp_dev *dev,
@@ -349,6 +383,8 @@ static int davinci_i2s_hw_params(struct snd_pcm_substream *substream,
         int mcbsp_word_length;
         unsigned int rcr, xcr, srgr;
         u32 spcr;
+        snd_pcm_format_t fmt;
+        unsigned element_cnt = 1;
 
         /* general line settings */
         spcr = davinci_mcbsp_read_reg(dev, DAVINCI_MCBSP_SPCR_REG);
@@ -378,27 +414,24 @@ static int davinci_i2s_hw_params(struct snd_pcm_substream *substream,
                 xcr |= DAVINCI_MCBSP_XCR_XDATDLY(1);
         }
         /* Determine xfer data type */
-        switch (params_format(params)) {
-        case SNDRV_PCM_FORMAT_S8:
-                dma_params->data_type = 1;
-                mcbsp_word_length = DAVINCI_MCBSP_WORD_8;
-                break;
-        case SNDRV_PCM_FORMAT_S16_LE:
-                dma_params->data_type = 2;
-                mcbsp_word_length = DAVINCI_MCBSP_WORD_16;
-                break;
-        case SNDRV_PCM_FORMAT_S32_LE:
-                dma_params->data_type = 4;
-                mcbsp_word_length = DAVINCI_MCBSP_WORD_32;
-                break;
-        default:
+        fmt = params_format(params);
+        if ((fmt > SNDRV_PCM_FORMAT_S32_LE) || !data_type[fmt]) {
                 printk(KERN_WARNING "davinci-i2s: unsupported PCM format\n");
                 return -EINVAL;
         }
 
-        dma_params->acnt  = dma_params->data_type;
-        rcr |= DAVINCI_MCBSP_RCR_RFRLEN1(1);
-        xcr |= DAVINCI_MCBSP_XCR_XFRLEN1(1);
+        if (params_channels(params) == 2) {
+                element_cnt = 2;
+                if (double_fmt[fmt] && dev->enable_channel_combine) {
+                        element_cnt = 1;
+                        fmt = double_fmt[fmt];
+                }
+        }
+        dma_params->acnt = dma_params->data_type = data_type[fmt];
+        dma_params->fifo_level = 0;
+        mcbsp_word_length = asp_word_length[fmt];
+        rcr |= DAVINCI_MCBSP_RCR_RFRLEN1(element_cnt - 1);
+        xcr |= DAVINCI_MCBSP_XCR_XFRLEN1(element_cnt - 1);
 
         rcr |= DAVINCI_MCBSP_RCR_RWDLEN1(mcbsp_word_length) |
                 DAVINCI_MCBSP_RCR_RWDLEN2(mcbsp_word_length);
@@ -513,7 +546,13 @@ static int davinci_i2s_probe(struct platform_device *pdev)
                 ret = -ENOMEM;
                 goto err_release_region;
         }
-
+        if (pdata) {
+                dev->enable_channel_combine = pdata->enable_channel_combine;
+                dev->dma_params[SNDRV_PCM_STREAM_PLAYBACK].sram_size =
+                        pdata->sram_size_playback;
+                dev->dma_params[SNDRV_PCM_STREAM_CAPTURE].sram_size =
+                        pdata->sram_size_capture;
+        }
         dev->clk = clk_get(&pdev->dev, NULL);
         if (IS_ERR(dev->clk)) {
                 ret = -ENODEV;
@@ -547,6 +586,8 @@ static int davinci_i2s_probe(struct platform_device *pdev)
         dev->dma_params[SNDRV_PCM_STREAM_CAPTURE].channel = res->start;
 
         davinci_i2s_dai.private_data = dev;
+        davinci_i2s_dai.capture.dma_data = dev->dma_params;
+        davinci_i2s_dai.playback.dma_data = dev->dma_params;
         ret = snd_soc_register_dai(&davinci_i2s_dai);
         if (ret != 0)
                 goto err_free_mem;
diff --git a/sound/soc/davinci/davinci-mcasp.c b/sound/soc/davinci/davinci-mcasp.c
index 5d1f98a4c978..79f0f4ad242c 100644
--- a/sound/soc/davinci/davinci-mcasp.c
+++ b/sound/soc/davinci/davinci-mcasp.c
@@ -18,6 +18,7 @@
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/device.h>
+#include <linux/slab.h>
 #include <linux/delay.h>
 #include <linux/io.h>
 #include <linux/clk.h>
@@ -714,16 +715,13 @@ static int davinci_mcasp_hw_params(struct snd_pcm_substream *substream,
         struct davinci_pcm_dma_params *dma_params =
                                         &dev->dma_params[substream->stream];
         int word_length;
-        u8 numevt;
+        u8 fifo_level;
 
         davinci_hw_common_param(dev, substream->stream);
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
-                numevt = dev->txnumevt;
+                fifo_level = dev->txnumevt;
         else
-                numevt = dev->rxnumevt;
-
-        if (!numevt)
-                numevt = 1;
+                fifo_level = dev->rxnumevt;
 
         if (dev->op_mode == DAVINCI_MCASP_DIT_MODE)
                 davinci_hw_dit_param(dev);
@@ -751,12 +749,12 @@ static int davinci_mcasp_hw_params(struct snd_pcm_substream *substream,
                 return -EINVAL;
         }
 
-        if (dev->version == MCASP_VERSION_2) {
-                dma_params->data_type *= numevt;
-                dma_params->acnt = 4 * numevt;
-        } else
+        if (dev->version == MCASP_VERSION_2 && !fifo_level)
+                dma_params->acnt = 4;
+        else
                 dma_params->acnt = dma_params->data_type;
 
+        dma_params->fifo_level = fifo_level;
         davinci_config_channel_size(dev, word_length);
 
         return 0;
@@ -770,14 +768,26 @@ static int davinci_mcasp_trigger(struct snd_pcm_substream *substream,
         int ret = 0;
 
         switch (cmd) {
-        case SNDRV_PCM_TRIGGER_START:
         case SNDRV_PCM_TRIGGER_RESUME:
+        case SNDRV_PCM_TRIGGER_START:
         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
+                if (!dev->clk_active) {
+                        clk_enable(dev->clk);
+                        dev->clk_active = 1;
+                }
                 davinci_mcasp_start(dev, substream->stream);
                 break;
 
-        case SNDRV_PCM_TRIGGER_STOP:
         case SNDRV_PCM_TRIGGER_SUSPEND:
+                davinci_mcasp_stop(dev, substream->stream);
+                if (dev->clk_active) {
+                        clk_disable(dev->clk);
+                        dev->clk_active = 0;
+                }
+
+                break;
+
+        case SNDRV_PCM_TRIGGER_STOP:
         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
                 davinci_mcasp_stop(dev, substream->stream);
                 break;
@@ -869,6 +879,7 @@ static int davinci_mcasp_probe(struct platform_device *pdev)
         }
 
         clk_enable(dev->clk);
+        dev->clk_active = 1;
 
         dev->base = (void __iomem *)IO_ADDRESS(mem->start);
         dev->op_mode = pdata->op_mode;
@@ -907,6 +918,8 @@ static int davinci_mcasp_probe(struct platform_device *pdev)
 
         dma_data->channel = res->start;
         davinci_mcasp_dai[pdata->op_mode].private_data = dev;
+        davinci_mcasp_dai[pdata->op_mode].capture.dma_data = dev->dma_params;
+        davinci_mcasp_dai[pdata->op_mode].playback.dma_data = dev->dma_params;
         davinci_mcasp_dai[pdata->op_mode].dev = &pdev->dev;
         ret = snd_soc_register_dai(&davinci_mcasp_dai[pdata->op_mode]);
 
diff --git a/sound/soc/davinci/davinci-mcasp.h b/sound/soc/davinci/davinci-mcasp.h
index 9d179cc88f7b..e755b5121ec7 100644
--- a/sound/soc/davinci/davinci-mcasp.h
+++ b/sound/soc/davinci/davinci-mcasp.h
@@ -39,16 +39,12 @@ enum {
 };
 
 struct davinci_audio_dev {
-        /*
-         * dma_params must be first because rtd->dai->cpu_dai->private_data
-         * is cast to a pointer of an array of struct davinci_pcm_dma_params in
-         * davinci_pcm_open.
-         */
         struct davinci_pcm_dma_params dma_params[2];
         void __iomem *base;
         int sample_rate;
         struct clk *clk;
         unsigned int codec_fmt;
+        u8 clk_active;
 
         /* McASP specific data */
         int     tdm_slots;
diff --git a/sound/soc/davinci/davinci-pcm.c b/sound/soc/davinci/davinci-pcm.c
index c73a915f233f..2dc406f42fe7 100644
--- a/sound/soc/davinci/davinci-pcm.c
+++ b/sound/soc/davinci/davinci-pcm.c
@@ -3,6 +3,7 @@
  *
  * Author:      Vladimir Barinov, <vbarinov@embeddedalley.com>
  * Copyright:   (C) 2007 MontaVista Software, Inc., <source@mvista.com>
+ * added SRAM ping/pong (C) 2008 Troy Kisky <troy.kisky@boundarydevices.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -23,10 +24,51 @@
 
 #include <asm/dma.h>
 #include <mach/edma.h>
+#include <mach/sram.h>
 
 #include "davinci-pcm.h"
 
-static struct snd_pcm_hardware davinci_pcm_hardware = {
+#ifdef DEBUG
+static void print_buf_info(int slot, char *name)
+{
+        struct edmacc_param p;
+        if (slot < 0)
+                return;
+        edma_read_slot(slot, &p);
+        printk(KERN_DEBUG "%s: 0x%x, opt=%x, src=%x, a_b_cnt=%x dst=%x\n",
+                        name, slot, p.opt, p.src, p.a_b_cnt, p.dst);
+        printk(KERN_DEBUG "    src_dst_bidx=%x link_bcntrld=%x src_dst_cidx=%x ccnt=%x\n",
+                        p.src_dst_bidx, p.link_bcntrld, p.src_dst_cidx, p.ccnt);
+}
+#else
+static void print_buf_info(int slot, char *name)
+{
+}
+#endif
+
+static struct snd_pcm_hardware pcm_hardware_playback = {
+        .info = (SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER |
+                 SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID |
+                 SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME),
+        .formats = (SNDRV_PCM_FMTBIT_S16_LE),
+        .rates = (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_16000 |
+                  SNDRV_PCM_RATE_22050 | SNDRV_PCM_RATE_32000 |
+                  SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |
+                  SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000 |
+                  SNDRV_PCM_RATE_KNOT),
+        .rate_min = 8000,
+        .rate_max = 96000,
+        .channels_min = 2,
+        .channels_max = 2,
+        .buffer_bytes_max = 128 * 1024,
+        .period_bytes_min = 32,
+        .period_bytes_max = 8 * 1024,
+        .periods_min = 16,
+        .periods_max = 255,
+        .fifo_size = 0,
+};
+
+static struct snd_pcm_hardware pcm_hardware_capture = {
         .info = (SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER |
                  SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID |
                  SNDRV_PCM_INFO_PAUSE),
@@ -48,102 +90,410 @@ static struct snd_pcm_hardware davinci_pcm_hardware = {
         .fifo_size = 0,
 };
 
+/*
+ * How ping/pong works....
+ *
+ * Playback:
+ * ram_params - copys 2*ping_size from start of SDRAM to iram,
+ *      links to ram_link2
+ * ram_link2 - copys rest of SDRAM to iram in ping_size units,
+ *      links to ram_link
+ * ram_link - copys entire SDRAM to iram in ping_size uints,
+ *      links to self
+ *
+ * asp_params - same as asp_link[0]
+ * asp_link[0] - copys from lower half of iram to asp port
+ *      links to asp_link[1], triggers iram copy event on completion
+ * asp_link[1] - copys from upper half of iram to asp port
+ *      links to asp_link[0], triggers iram copy event on completion
+ *      triggers interrupt only needed to let upper SOC levels update position
+ *      in stream on completion
+ *
+ * When playback is started:
+ *      ram_params started
+ *      asp_params started
+ *
+ * Capture:
+ * ram_params - same as ram_link,
+ *      links to ram_link
+ * ram_link - same as playback
+ *      links to self
+ *
+ * asp_params - same as playback
+ * asp_link[0] - same as playback
+ * asp_link[1] - same as playback
+ *
+ * When capture is started:
+ *      asp_params started
+ */
 struct davinci_runtime_data {
         spinlock_t lock;
         int period;             /* current DMA period */
-        int master_lch;         /* Master DMA channel */
-        int slave_lch;          /* linked parameter RAM reload slot */
+        int asp_channel;        /* Master DMA channel */
+        int asp_link[2];        /* asp parameter link channel, ping/pong */
         struct davinci_pcm_dma_params *params;  /* DMA params */
+        int ram_channel;
+        int ram_link;
+        int ram_link2;
+        struct edmacc_param asp_params;
+        struct edmacc_param ram_params;
 };
 
+/*
+ * Not used with ping/pong
+ */
 static void davinci_pcm_enqueue_dma(struct snd_pcm_substream *substream)
 {
         struct davinci_runtime_data *prtd = substream->runtime->private_data;
         struct snd_pcm_runtime *runtime = substream->runtime;
-        int lch = prtd->slave_lch;
+        int link = prtd->asp_link[0];
         unsigned int period_size;
         unsigned int dma_offset;
         dma_addr_t dma_pos;
         dma_addr_t src, dst;
         unsigned short src_bidx, dst_bidx;
+        unsigned short src_cidx, dst_cidx;
         unsigned int data_type;
         unsigned short acnt;
         unsigned int count;
+        unsigned int fifo_level;
 
         period_size = snd_pcm_lib_period_bytes(substream);
         dma_offset = prtd->period * period_size;
         dma_pos = runtime->dma_addr + dma_offset;
+        fifo_level = prtd->params->fifo_level;
 
         pr_debug("davinci_pcm: audio_set_dma_params_play channel = %d "
-                "dma_ptr = %x period_size=%x\n", lch, dma_pos, period_size);
+                "dma_ptr = %x period_size=%x\n", link, dma_pos, period_size);
 
         data_type = prtd->params->data_type;
         count = period_size / data_type;
+        if (fifo_level)
+                count /= fifo_level;
 
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
                 src = dma_pos;
                 dst = prtd->params->dma_addr;
                 src_bidx = data_type;
                 dst_bidx = 0;
+                src_cidx = data_type * fifo_level;
+                dst_cidx = 0;
         } else {
                 src = prtd->params->dma_addr;
                 dst = dma_pos;
                 src_bidx = 0;
                 dst_bidx = data_type;
+                src_cidx = 0;
+                dst_cidx = data_type * fifo_level;
         }
 
         acnt = prtd->params->acnt;
-        edma_set_src(lch, src, INCR, W8BIT);
-        edma_set_dest(lch, dst, INCR, W8BIT);
-        edma_set_src_index(lch, src_bidx, 0);
-        edma_set_dest_index(lch, dst_bidx, 0);
-        edma_set_transfer_params(lch, acnt, count, 1, 0, ASYNC);
+        edma_set_src(link, src, INCR, W8BIT);
+        edma_set_dest(link, dst, INCR, W8BIT);
+
+        edma_set_src_index(link, src_bidx, src_cidx);
+        edma_set_dest_index(link, dst_bidx, dst_cidx);
+
+        if (!fifo_level)
+                edma_set_transfer_params(link, acnt, count, 1, 0, ASYNC);
+        else
+                edma_set_transfer_params(link, acnt, fifo_level, count,
+                                                        fifo_level, ABSYNC);
 
         prtd->period++;
         if (unlikely(prtd->period >= runtime->periods))
                 prtd->period = 0;
 }
 
-static void davinci_pcm_dma_irq(unsigned lch, u16 ch_status, void *data)
+static void davinci_pcm_dma_irq(unsigned link, u16 ch_status, void *data)
 {
         struct snd_pcm_substream *substream = data;
         struct davinci_runtime_data *prtd = substream->runtime->private_data;
 
-        pr_debug("davinci_pcm: lch=%d, status=0x%x\n", lch, ch_status);
+        print_buf_info(prtd->ram_channel, "i ram_channel");
+        pr_debug("davinci_pcm: link=%d, status=0x%x\n", link, ch_status);
 
         if (unlikely(ch_status != DMA_COMPLETE))
                 return;
 
         if (snd_pcm_running(substream)) {
+                if (prtd->ram_channel < 0) {
+                        /* No ping/pong must fix up link dma data*/
+                        spin_lock(&prtd->lock);
+                        davinci_pcm_enqueue_dma(substream);
+                        spin_unlock(&prtd->lock);
+                }
                 snd_pcm_period_elapsed(substream);
+        }
+}
+
+static int allocate_sram(struct snd_pcm_substream *substream, unsigned size,
+                struct snd_pcm_hardware *ppcm)
+{
+        struct snd_dma_buffer *buf = &substream->dma_buffer;
+        struct snd_dma_buffer *iram_dma = NULL;
+        dma_addr_t iram_phys = 0;
+        void *iram_virt = NULL;
+
+        if (buf->private_data || !size)
+                return 0;
+
+        ppcm->period_bytes_max = size;
+        iram_virt = sram_alloc(size, &iram_phys);
+        if (!iram_virt)
+                goto exit1;
+        iram_dma = kzalloc(sizeof(*iram_dma), GFP_KERNEL);
+        if (!iram_dma)
+                goto exit2;
+        iram_dma->area = iram_virt;
+        iram_dma->addr = iram_phys;
+        memset(iram_dma->area, 0, size);
+        iram_dma->bytes = size;
+        buf->private_data = iram_dma;
+        return 0;
+exit2:
+        if (iram_virt)
+                sram_free(iram_virt, size);
+exit1:
+        return -ENOMEM;
+}
+
+/*
+ * Only used with ping/pong.
+ * This is called after runtime->dma_addr, period_bytes and data_type are valid
+ */
+static int ping_pong_dma_setup(struct snd_pcm_substream *substream)
+{
+        unsigned short ram_src_cidx, ram_dst_cidx;
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct davinci_runtime_data *prtd = runtime->private_data;
+        struct snd_dma_buffer *iram_dma =
+                (struct snd_dma_buffer *)substream->dma_buffer.private_data;
+        struct davinci_pcm_dma_params *params = prtd->params;
+        unsigned int data_type = params->data_type;
+        unsigned int acnt = params->acnt;
+        /* divide by 2 for ping/pong */
+        unsigned int ping_size = snd_pcm_lib_period_bytes(substream) >> 1;
+        int link = prtd->asp_link[1];
+        unsigned int fifo_level = prtd->params->fifo_level;
+        unsigned int count;
+        if ((data_type == 0) || (data_type > 4)) {
+                printk(KERN_ERR "%s: data_type=%i\n", __func__, data_type);
+                return -EINVAL;
+        }
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+                dma_addr_t asp_src_pong = iram_dma->addr + ping_size;
+                ram_src_cidx = ping_size;
+                ram_dst_cidx = -ping_size;
+                edma_set_src(link, asp_src_pong, INCR, W8BIT);
+
+                link = prtd->asp_link[0];
+                edma_set_src_index(link, data_type, data_type * fifo_level);
+                link = prtd->asp_link[1];
+                edma_set_src_index(link, data_type, data_type * fifo_level);
+
+                link = prtd->ram_link;
+                edma_set_src(link, runtime->dma_addr, INCR, W32BIT);
+        } else {
+                dma_addr_t asp_dst_pong = iram_dma->addr + ping_size;
+                ram_src_cidx = -ping_size;
+                ram_dst_cidx = ping_size;
+                edma_set_dest(link, asp_dst_pong, INCR, W8BIT);
+
+                link = prtd->asp_link[0];
+                edma_set_dest_index(link, data_type, data_type * fifo_level);
+                link = prtd->asp_link[1];
+                edma_set_dest_index(link, data_type, data_type * fifo_level);
+
+                link = prtd->ram_link;
+                edma_set_dest(link, runtime->dma_addr, INCR, W32BIT);
+        }
+
+        if (!fifo_level) {
+                count = ping_size / data_type;
+                edma_set_transfer_params(prtd->asp_link[0], acnt, count,
+                                1, 0, ASYNC);
+                edma_set_transfer_params(prtd->asp_link[1], acnt, count,
+                                1, 0, ASYNC);
+        } else {
+                count = ping_size / (data_type * fifo_level);
+                edma_set_transfer_params(prtd->asp_link[0], acnt, fifo_level,
+                                count, fifo_level, ABSYNC);
+                edma_set_transfer_params(prtd->asp_link[1], acnt, fifo_level,
+                                count, fifo_level, ABSYNC);
+        }
+
+        link = prtd->ram_link;
+        edma_set_src_index(link, ping_size, ram_src_cidx);
+        edma_set_dest_index(link, ping_size, ram_dst_cidx);
+        edma_set_transfer_params(link, ping_size, 2,
+                        runtime->periods, 2, ASYNC);
 
-                spin_lock(&prtd->lock);
-                davinci_pcm_enqueue_dma(substream);
-                spin_unlock(&prtd->lock);
+        /* init master params */
+        edma_read_slot(prtd->asp_link[0], &prtd->asp_params);
+        edma_read_slot(prtd->ram_link, &prtd->ram_params);
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+                struct edmacc_param p_ram;
+                /* Copy entire iram buffer before playback started */
+                prtd->ram_params.a_b_cnt = (1 << 16) | (ping_size << 1);
+                /* 0 dst_bidx */
+                prtd->ram_params.src_dst_bidx = (ping_size << 1);
+                /* 0 dst_cidx */
+                prtd->ram_params.src_dst_cidx = (ping_size << 1);
+                prtd->ram_params.ccnt = 1;
+
+                /* Skip 1st period */
+                edma_read_slot(prtd->ram_link, &p_ram);
+                p_ram.src += (ping_size << 1);
+                p_ram.ccnt -= 1;
+                edma_write_slot(prtd->ram_link2, &p_ram);
+                /*
+                 * When 1st started, ram -> iram dma channel will fill the
+                 * entire iram.  Then, whenever a ping/pong asp buffer finishes,
+                 * 1/2 iram will be filled.
+                 */
+                prtd->ram_params.link_bcntrld =
+                        EDMA_CHAN_SLOT(prtd->ram_link2) << 5;
         }
+        return 0;
+}
+
+/* 1 asp tx or rx channel using 2 parameter channels
+ * 1 ram to/from iram channel using 1 parameter channel
+ *
+ * Playback
+ * ram copy channel kicks off first,
+ * 1st ram copy of entire iram buffer completion kicks off asp channel
+ * asp tcc always kicks off ram copy of 1/2 iram buffer
+ *
+ * Record
+ * asp channel starts, tcc kicks off ram copy
+ */
+static int request_ping_pong(struct snd_pcm_substream *substream,
+                struct davinci_runtime_data *prtd,
+                struct snd_dma_buffer *iram_dma)
+{
+        dma_addr_t asp_src_ping;
+        dma_addr_t asp_dst_ping;
+        int link;
+        struct davinci_pcm_dma_params *params = prtd->params;
+
+        /* Request ram master channel */
+        link = prtd->ram_channel = edma_alloc_channel(EDMA_CHANNEL_ANY,
+                                  davinci_pcm_dma_irq, substream,
+                                  EVENTQ_1);
+        if (link < 0)
+                goto exit1;
+
+        /* Request ram link channel */
+        link = prtd->ram_link = edma_alloc_slot(
+                        EDMA_CTLR(prtd->ram_channel), EDMA_SLOT_ANY);
+        if (link < 0)
+                goto exit2;
+
+        link = prtd->asp_link[1] = edma_alloc_slot(
+                        EDMA_CTLR(prtd->asp_channel), EDMA_SLOT_ANY);
+        if (link < 0)
+                goto exit3;
+
+        prtd->ram_link2 = -1;
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+                link = prtd->ram_link2 = edma_alloc_slot(
+                        EDMA_CTLR(prtd->ram_channel), EDMA_SLOT_ANY);
+                if (link < 0)
+                        goto exit4;
+        }
+        /* circle ping-pong buffers */
+        edma_link(prtd->asp_link[0], prtd->asp_link[1]);
+        edma_link(prtd->asp_link[1], prtd->asp_link[0]);
+        /* circle ram buffers */
+        edma_link(prtd->ram_link, prtd->ram_link);
+
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+                asp_src_ping = iram_dma->addr;
+                asp_dst_ping = params->dma_addr;        /* fifo */
+        } else {
+                asp_src_ping = params->dma_addr;        /* fifo */
+                asp_dst_ping = iram_dma->addr;
+        }
+        /* ping */
+        link = prtd->asp_link[0];
+        edma_set_src(link, asp_src_ping, INCR, W16BIT);
+        edma_set_dest(link, asp_dst_ping, INCR, W16BIT);
+        edma_set_src_index(link, 0, 0);
+        edma_set_dest_index(link, 0, 0);
+
+        edma_read_slot(link, &prtd->asp_params);
+        prtd->asp_params.opt &= ~(TCCMODE | EDMA_TCC(0x3f) | TCINTEN);
+        prtd->asp_params.opt |= TCCHEN | EDMA_TCC(prtd->ram_channel & 0x3f);
+        edma_write_slot(link, &prtd->asp_params);
+
+        /* pong */
+        link = prtd->asp_link[1];
+        edma_set_src(link, asp_src_ping, INCR, W16BIT);
+        edma_set_dest(link, asp_dst_ping, INCR, W16BIT);
+        edma_set_src_index(link, 0, 0);
+        edma_set_dest_index(link, 0, 0);
+
+        edma_read_slot(link, &prtd->asp_params);
+        prtd->asp_params.opt &= ~(TCCMODE | EDMA_TCC(0x3f));
+        /* interrupt after every pong completion */
+        prtd->asp_params.opt |= TCINTEN | TCCHEN |
+                EDMA_TCC(EDMA_CHAN_SLOT(prtd->ram_channel));
+        edma_write_slot(link, &prtd->asp_params);
+
+        /* ram */
+        link = prtd->ram_link;
+        edma_set_src(link, iram_dma->addr, INCR, W32BIT);
+        edma_set_dest(link, iram_dma->addr, INCR, W32BIT);
+        pr_debug("%s: audio dma channels/slots in use for ram:%u %u %u,"
+                "for asp:%u %u %u\n", __func__,
+                prtd->ram_channel, prtd->ram_link, prtd->ram_link2,
+                prtd->asp_channel, prtd->asp_link[0],
+                prtd->asp_link[1]);
+        return 0;
+exit4:
+        edma_free_channel(prtd->asp_link[1]);
+        prtd->asp_link[1] = -1;
+exit3:
+        edma_free_channel(prtd->ram_link);
+        prtd->ram_link = -1;
+exit2:
+        edma_free_channel(prtd->ram_channel);
+        prtd->ram_channel = -1;
+exit1:
+        return link;
 }
 
 static int davinci_pcm_dma_request(struct snd_pcm_substream *substream)
 {
+        struct snd_dma_buffer *iram_dma;
         struct davinci_runtime_data *prtd = substream->runtime->private_data;
-        struct edmacc_param p_ram;
-        int ret;
+        struct davinci_pcm_dma_params *params = prtd->params;
+        int link;
 
-        /* Request master DMA channel */
-        ret = edma_alloc_channel(prtd->params->channel,
-                                  davinci_pcm_dma_irq, substream,
-                                  EVENTQ_0);
-        if (ret < 0)
-                return ret;
-        prtd->master_lch = ret;
+        if (!params)
+                return -ENODEV;
 
-        /* Request parameter RAM reload slot */
-        ret = edma_alloc_slot(EDMA_CTLR(prtd->master_lch), EDMA_SLOT_ANY);
-        if (ret < 0) {
-                edma_free_channel(prtd->master_lch);
-                return ret;
+        /* Request asp master DMA channel */
+        link = prtd->asp_channel = edma_alloc_channel(params->channel,
+                        davinci_pcm_dma_irq, substream, EVENTQ_0);
+        if (link < 0)
+                goto exit1;
+
+        /* Request asp link channels */
+        link = prtd->asp_link[0] = edma_alloc_slot(
+                        EDMA_CTLR(prtd->asp_channel), EDMA_SLOT_ANY);
+        if (link < 0)
+                goto exit2;
+
+        iram_dma = (struct snd_dma_buffer *)substream->dma_buffer.private_data;
+        if (iram_dma) {
+                if (request_ping_pong(substream, prtd, iram_dma) == 0)
+                        return 0;
+                printk(KERN_WARNING "%s: dma channel allocation failed,"
+                                "not using sram\n", __func__);
         }
-        prtd->slave_lch = ret;
 
         /* Issue transfer completion IRQ when the channel completes a
          * transfer, then always reload from the same slot (by a kind
@@ -154,12 +504,17 @@ static int davinci_pcm_dma_request(struct snd_pcm_substream *substream)
          * the buffer and its length (ccnt) ... use it as a template
          * so davinci_pcm_enqueue_dma() takes less time in IRQ.
          */
-        edma_read_slot(prtd->slave_lch, &p_ram);
-        p_ram.opt |= TCINTEN | EDMA_TCC(EDMA_CHAN_SLOT(prtd->master_lch));
-        p_ram.link_bcntrld = EDMA_CHAN_SLOT(prtd->slave_lch) << 5;
-        edma_write_slot(prtd->slave_lch, &p_ram);
-
+        edma_read_slot(link, &prtd->asp_params);
+        prtd->asp_params.opt |= TCINTEN |
+                EDMA_TCC(EDMA_CHAN_SLOT(prtd->asp_channel));
+        prtd->asp_params.link_bcntrld = EDMA_CHAN_SLOT(link) << 5;
+        edma_write_slot(link, &prtd->asp_params);
         return 0;
+exit2:
+        edma_free_channel(prtd->asp_channel);
+        prtd->asp_channel = -1;
+exit1:
+        return link;
 }
 
 static int davinci_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
@@ -173,12 +528,12 @@ static int davinci_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
         case SNDRV_PCM_TRIGGER_START:
         case SNDRV_PCM_TRIGGER_RESUME:
         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
-                edma_start(prtd->master_lch);
+                edma_resume(prtd->asp_channel);
                 break;
         case SNDRV_PCM_TRIGGER_STOP:
         case SNDRV_PCM_TRIGGER_SUSPEND:
         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
-                edma_stop(prtd->master_lch);
+                edma_pause(prtd->asp_channel);
                 break;
         default:
                 ret = -EINVAL;
@@ -193,15 +548,37 @@ static int davinci_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
 static int davinci_pcm_prepare(struct snd_pcm_substream *substream)
 {
         struct davinci_runtime_data *prtd = substream->runtime->private_data;
-        struct edmacc_param temp;
 
+        if (prtd->ram_channel >= 0) {
+                int ret = ping_pong_dma_setup(substream);
+                if (ret < 0)
+                        return ret;
+
+                edma_write_slot(prtd->ram_channel, &prtd->ram_params);
+                edma_write_slot(prtd->asp_channel, &prtd->asp_params);
+
+                print_buf_info(prtd->ram_channel, "ram_channel");
+                print_buf_info(prtd->ram_link, "ram_link");
+                print_buf_info(prtd->ram_link2, "ram_link2");
+                print_buf_info(prtd->asp_channel, "asp_channel");
+                print_buf_info(prtd->asp_link[0], "asp_link[0]");
+                print_buf_info(prtd->asp_link[1], "asp_link[1]");
+
+                if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+                        /* copy 1st iram buffer */
+                        edma_start(prtd->ram_channel);
+                }
+                edma_start(prtd->asp_channel);
+                return 0;
+        }
         prtd->period = 0;
         davinci_pcm_enqueue_dma(substream);
 
         /* Copy self-linked parameter RAM entry into master channel */
-        edma_read_slot(prtd->slave_lch, &temp);
-        edma_write_slot(prtd->master_lch, &temp);
+        edma_read_slot(prtd->asp_link[0], &prtd->asp_params);
+        edma_write_slot(prtd->asp_channel, &prtd->asp_params);
         davinci_pcm_enqueue_dma(substream);
+        edma_start(prtd->asp_channel);
 
         return 0;
 }
@@ -212,20 +589,53 @@ davinci_pcm_pointer(struct snd_pcm_substream *substream)
         struct snd_pcm_runtime *runtime = substream->runtime;
         struct davinci_runtime_data *prtd = runtime->private_data;
         unsigned int offset;
-        dma_addr_t count;
-        dma_addr_t src, dst;
+        int asp_count;
+        dma_addr_t asp_src, asp_dst;
 
         spin_lock(&prtd->lock);
-
-        edma_get_position(prtd->master_lch, &src, &dst);
-        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
-                count = src - runtime->dma_addr;
-        else
-                count = dst - runtime->dma_addr;
-
+        if (prtd->ram_channel >= 0) {
+                int ram_count;
+                int mod_ram;
+                dma_addr_t ram_src, ram_dst;
+                unsigned int period_size = snd_pcm_lib_period_bytes(substream);
+                if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+                        /* reading ram before asp should be safe
+                         * as long as the asp transfers less than a ping size
+                         * of bytes between the 2 reads
+                         */
+                        edma_get_position(prtd->ram_channel,
+                                        &ram_src, &ram_dst);
+                        edma_get_position(prtd->asp_channel,
+                                        &asp_src, &asp_dst);
+                        asp_count = asp_src - prtd->asp_params.src;
+                        ram_count = ram_src - prtd->ram_params.src;
+                        mod_ram = ram_count % period_size;
+                        mod_ram -= asp_count;
+                        if (mod_ram < 0)
+                                mod_ram += period_size;
+                        else if (mod_ram == 0) {
+                                if (snd_pcm_running(substream))
+                                        mod_ram += period_size;
+                        }
+                        ram_count -= mod_ram;
+                        if (ram_count < 0)
+                                ram_count += period_size * runtime->periods;
+                } else {
+                        edma_get_position(prtd->ram_channel,
+                                        &ram_src, &ram_dst);
+                        ram_count = ram_dst - prtd->ram_params.dst;
+                }
+                asp_count = ram_count;
+        } else {
+                edma_get_position(prtd->asp_channel, &asp_src, &asp_dst);
+                if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+                        asp_count = asp_src - runtime->dma_addr;
+                else
+                        asp_count = asp_dst - runtime->dma_addr;
+        }
         spin_unlock(&prtd->lock);
 
-        offset = bytes_to_frames(runtime, count);
+        offset = bytes_to_frames(runtime, asp_count);
         if (offset >= runtime->buffer_size)
                 offset = 0;
 
@@ -236,14 +646,21 @@ static int davinci_pcm_open(struct snd_pcm_substream *substream)
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
         struct davinci_runtime_data *prtd;
+        struct snd_pcm_hardware *ppcm;
         int ret = 0;
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
-        struct davinci_pcm_dma_params *pa = rtd->dai->cpu_dai->private_data;
-        struct davinci_pcm_dma_params *params = &pa[substream->stream];
-        if (!params)
+        struct davinci_pcm_dma_params *pa;
+        struct davinci_pcm_dma_params *params;
+
+        pa = snd_soc_dai_get_dma_data(rtd->dai->cpu_dai, substream);
+        if (!pa)
                 return -ENODEV;
+        params = &pa[substream->stream];
 
-        snd_soc_set_runtime_hwparams(substream, &davinci_pcm_hardware);
+        ppcm = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ?
+                        &pcm_hardware_playback : &pcm_hardware_capture;
+        allocate_sram(substream, params->sram_size, ppcm);
+        snd_soc_set_runtime_hwparams(substream, ppcm);
         /* ensure that buffer size is a multiple of period size */
         ret = snd_pcm_hw_constraint_integer(runtime,
                                                 SNDRV_PCM_HW_PARAM_PERIODS);
@@ -256,6 +673,11 @@ static int davinci_pcm_open(struct snd_pcm_substream *substream)
 
         spin_lock_init(&prtd->lock);
         prtd->params = params;
+        prtd->asp_channel = -1;
+        prtd->asp_link[0] = prtd->asp_link[1] = -1;
+        prtd->ram_channel = -1;
+        prtd->ram_link = -1;
+        prtd->ram_link2 = -1;
 
         runtime->private_data = prtd;
 
@@ -273,10 +695,29 @@ static int davinci_pcm_close(struct snd_pcm_substream *substream)
         struct snd_pcm_runtime *runtime = substream->runtime;
         struct davinci_runtime_data *prtd = runtime->private_data;
 
-        edma_unlink(prtd->slave_lch);
-
-        edma_free_slot(prtd->slave_lch);
-        edma_free_channel(prtd->master_lch);
+        if (prtd->ram_channel >= 0)
+                edma_stop(prtd->ram_channel);
+        if (prtd->asp_channel >= 0)
+                edma_stop(prtd->asp_channel);
+        if (prtd->asp_link[0] >= 0)
+                edma_unlink(prtd->asp_link[0]);
+        if (prtd->asp_link[1] >= 0)
+                edma_unlink(prtd->asp_link[1]);
+        if (prtd->ram_link >= 0)
+                edma_unlink(prtd->ram_link);
+
+        if (prtd->asp_link[0] >= 0)
+                edma_free_slot(prtd->asp_link[0]);
+        if (prtd->asp_link[1] >= 0)
+                edma_free_slot(prtd->asp_link[1]);
+        if (prtd->asp_channel >= 0)
+                edma_free_channel(prtd->asp_channel);
+        if (prtd->ram_link >= 0)
+                edma_free_slot(prtd->ram_link);
+        if (prtd->ram_link2 >= 0)
+                edma_free_slot(prtd->ram_link2);
+        if (prtd->ram_channel >= 0)
+                edma_free_channel(prtd->ram_channel);
 
         kfree(prtd);
 
@@ -318,11 +759,11 @@ static struct snd_pcm_ops davinci_pcm_ops = {
         .mmap =         davinci_pcm_mmap,
 };
 
-static int davinci_pcm_preallocate_dma_buffer(struct snd_pcm *pcm, int stream)
+static int davinci_pcm_preallocate_dma_buffer(struct snd_pcm *pcm, int stream,
+                size_t size)
 {
         struct snd_pcm_substream *substream = pcm->streams[stream].substream;
         struct snd_dma_buffer *buf = &substream->dma_buffer;
-        size_t size = davinci_pcm_hardware.buffer_bytes_max;
 
         buf->dev.type = SNDRV_DMA_TYPE_DEV;
         buf->dev.dev = pcm->card->dev;
@@ -347,6 +788,7 @@ static void davinci_pcm_free(struct snd_pcm *pcm)
         int stream;
 
         for (stream = 0; stream < 2; stream++) {
+                struct snd_dma_buffer *iram_dma;
                 substream = pcm->streams[stream].substream;
                 if (!substream)
                         continue;
@@ -358,6 +800,11 @@ static void davinci_pcm_free(struct snd_pcm *pcm)
                 dma_free_writecombine(pcm->card->dev, buf->bytes,
                                       buf->area, buf->addr);
                 buf->area = NULL;
+                iram_dma = (struct snd_dma_buffer *)buf->private_data;
+                if (iram_dma) {
+                        sram_free(iram_dma->area, iram_dma->bytes);
+                        kfree(iram_dma);
+                }
         }
 }
 
@@ -375,14 +822,16 @@ static int davinci_pcm_new(struct snd_card *card,
 
         if (dai->playback.channels_min) {
                 ret = davinci_pcm_preallocate_dma_buffer(pcm,
-                        SNDRV_PCM_STREAM_PLAYBACK);
+                        SNDRV_PCM_STREAM_PLAYBACK,
+                        pcm_hardware_playback.buffer_bytes_max);
                 if (ret)
                         return ret;
         }
 
         if (dai->capture.channels_min) {
                 ret = davinci_pcm_preallocate_dma_buffer(pcm,
-                        SNDRV_PCM_STREAM_CAPTURE);
+                        SNDRV_PCM_STREAM_CAPTURE,
+                        pcm_hardware_capture.buffer_bytes_max);
                 if (ret)
                         return ret;
         }
diff --git a/sound/soc/davinci/davinci-pcm.h b/sound/soc/davinci/davinci-pcm.h
index 8746606efc89..0764944cf10f 100644
--- a/sound/soc/davinci/davinci-pcm.h
+++ b/sound/soc/davinci/davinci-pcm.h
@@ -20,9 +20,11 @@ struct davinci_pcm_dma_params {
         int channel;                    /* sync dma channel ID */
         unsigned short acnt;
         dma_addr_t dma_addr;            /* device physical address for DMA */
+        unsigned sram_size;
         enum dma_event_q eventq_no;     /* event queue number */
         unsigned char data_type;        /* xfer data type */
         unsigned char convert_mono_stereo;
+        unsigned int fifo_level;
 };
 
 
diff --git a/sound/soc/fsl/efika-audio-fabric.c b/sound/soc/fsl/efika-audio-fabric.c
index 3326e2a1e863..1a5b8e0d6a34 100644
--- a/sound/soc/fsl/efika-audio-fabric.c
+++ b/sound/soc/fsl/efika-audio-fabric.c
@@ -55,7 +55,7 @@ static __init int efika_fabric_init(void)
         struct platform_device *pdev;
         int rc;
 
-        if (!machine_is_compatible("bplan,efika"))
+        if (!of_machine_is_compatible("bplan,efika"))
                 return -ENODEV;
 
         card.platform = &mpc5200_audio_dma_platform;
diff --git a/sound/soc/fsl/fsl_dma.c b/sound/soc/fsl/fsl_dma.c
index b1a3a278819f..410c7496a18d 100644
--- a/sound/soc/fsl/fsl_dma.c
+++ b/sound/soc/fsl/fsl_dma.c
@@ -19,6 +19,7 @@
 #include <linux/dma-mapping.h>
 #include <linux/interrupt.h>
 #include <linux/delay.h>
+#include <linux/gfp.h>
 
 #include <sound/core.h>
 #include <sound/pcm.h>
diff --git a/sound/soc/fsl/fsl_ssi.c b/sound/soc/fsl/fsl_ssi.c
index 93f0f38a32c9..762c1b8e8e4e 100644
--- a/sound/soc/fsl/fsl_ssi.c
+++ b/sound/soc/fsl/fsl_ssi.c
@@ -14,6 +14,7 @@
 #include <linux/interrupt.h>
 #include <linux/device.h>
 #include <linux/delay.h>
+#include <linux/slab.h>
 
 #include <sound/core.h>
 #include <sound/pcm.h>
diff --git a/sound/soc/fsl/mpc5200_dma.c b/sound/soc/fsl/mpc5200_dma.c
index 6096d22283e6..d639e55c5124 100644
--- a/sound/soc/fsl/mpc5200_dma.c
+++ b/sound/soc/fsl/mpc5200_dma.c
@@ -8,6 +8,7 @@
 
 #include <linux/module.h>
 #include <linux/of_device.h>
+#include <linux/slab.h>
 
 #include <sound/soc.h>
 
@@ -58,47 +59,15 @@ static void psc_dma_bcom_enqueue_next_buffer(struct psc_dma_stream *s)
         /* Prepare and enqueue the next buffer descriptor */
         bd = bcom_prepare_next_buffer(s->bcom_task);
         bd->status = s->period_bytes;
-        bd->data[0] = s->period_next_pt;
+        bd->data[0] = s->runtime->dma_addr + (s->period_next * s->period_bytes);
         bcom_submit_next_buffer(s->bcom_task, NULL);
 
         /* Update for next period */
-        s->period_next_pt += s->period_bytes;
-        if (s->period_next_pt >= s->period_end)
-                s->period_next_pt = s->period_start;
-}
-
-static void psc_dma_bcom_enqueue_tx(struct psc_dma_stream *s)
-{
-        if (s->appl_ptr > s->runtime->control->appl_ptr) {
-                /*
-                 * In this case s->runtime->control->appl_ptr has wrapped around.
-                 * Play the data to the end of the boundary, then wrap our own
-                 * appl_ptr back around.
-                 */
-                while (s->appl_ptr < s->runtime->boundary) {
-                        if (bcom_queue_full(s->bcom_task))
-                                return;
-
-                        s->appl_ptr += s->period_size;
-
-                        psc_dma_bcom_enqueue_next_buffer(s);
-                }
-                s->appl_ptr -= s->runtime->boundary;
-        }
-
-        while (s->appl_ptr < s->runtime->control->appl_ptr) {
-
-                if (bcom_queue_full(s->bcom_task))
-                        return;
-
-                s->appl_ptr += s->period_size;
-
-                psc_dma_bcom_enqueue_next_buffer(s);
-        }
+        s->period_next = (s->period_next + 1) % s->runtime->periods;
 }
 
 /* Bestcomm DMA irq handler */
-static irqreturn_t psc_dma_bcom_irq_tx(int irq, void *_psc_dma_stream)
+static irqreturn_t psc_dma_bcom_irq(int irq, void *_psc_dma_stream)
 {
         struct psc_dma_stream *s = _psc_dma_stream;
 
@@ -108,34 +77,8 @@ static irqreturn_t psc_dma_bcom_irq_tx(int irq, void *_psc_dma_stream)
         while (bcom_buffer_done(s->bcom_task)) {
                 bcom_retrieve_buffer(s->bcom_task, NULL, NULL);
 
-                s->period_current_pt += s->period_bytes;
-                if (s->period_current_pt >= s->period_end)
-                        s->period_current_pt = s->period_start;
-        }
-        psc_dma_bcom_enqueue_tx(s);
-        spin_unlock(&s->psc_dma->lock);
-
-        /* If the stream is active, then also inform the PCM middle layer
-         * of the period finished event. */
-        if (s->active)
-                snd_pcm_period_elapsed(s->stream);
-
-        return IRQ_HANDLED;
-}
-
-static irqreturn_t psc_dma_bcom_irq_rx(int irq, void *_psc_dma_stream)
-{
-        struct psc_dma_stream *s = _psc_dma_stream;
-
-        spin_lock(&s->psc_dma->lock);
-        /* For each finished period, dequeue the completed period buffer
-         * and enqueue a new one in it's place. */
-        while (bcom_buffer_done(s->bcom_task)) {
-                bcom_retrieve_buffer(s->bcom_task, NULL, NULL);
-
-                s->period_current_pt += s->period_bytes;
-                if (s->period_current_pt >= s->period_end)
-                        s->period_current_pt = s->period_start;
+                s->period_current = (s->period_current+1) % s->runtime->periods;
+                s->period_count++;
 
                 psc_dma_bcom_enqueue_next_buffer(s);
         }
@@ -166,54 +109,38 @@ static int psc_dma_trigger(struct snd_pcm_substream *substream, int cmd)
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
         struct psc_dma *psc_dma = rtd->dai->cpu_dai->private_data;
         struct snd_pcm_runtime *runtime = substream->runtime;
-        struct psc_dma_stream *s;
+        struct psc_dma_stream *s = to_psc_dma_stream(substream, psc_dma);
         struct mpc52xx_psc __iomem *regs = psc_dma->psc_regs;
         u16 imr;
         unsigned long flags;
         int i;
 
-        if (substream->pstr->stream == SNDRV_PCM_STREAM_CAPTURE)
-                s = &psc_dma->capture;
-        else
-                s = &psc_dma->playback;
-
-        dev_dbg(psc_dma->dev, "psc_dma_trigger(substream=%p, cmd=%i)"
-                " stream_id=%i\n",
-                substream, cmd, substream->pstr->stream);
-
         switch (cmd) {
         case SNDRV_PCM_TRIGGER_START:
+                dev_dbg(psc_dma->dev, "START: stream=%i fbits=%u ps=%u #p=%u\n",
+                        substream->pstr->stream, runtime->frame_bits,
+                        (int)runtime->period_size, runtime->periods);
                 s->period_bytes = frames_to_bytes(runtime,
                                                   runtime->period_size);
-                s->period_start = virt_to_phys(runtime->dma_area);
-                s->period_end = s->period_start +
-                                (s->period_bytes * runtime->periods);
-                s->period_next_pt = s->period_start;
-                s->period_current_pt = s->period_start;
-                s->period_size = runtime->period_size;
+                s->period_next = 0;
+                s->period_current = 0;
                 s->active = 1;
-
-                /* track appl_ptr so that we have a better chance of detecting
-                 * end of stream and not over running it.
-                 */
+                s->period_count = 0;
                 s->runtime = runtime;
-                s->appl_ptr = s->runtime->control->appl_ptr -
-                                (runtime->period_size * runtime->periods);
 
                 /* Fill up the bestcomm bd queue and enable DMA.
                  * This will begin filling the PSC's fifo.
                  */
                 spin_lock_irqsave(&psc_dma->lock, flags);
 
-                if (substream->pstr->stream == SNDRV_PCM_STREAM_CAPTURE) {
+                if (substream->pstr->stream == SNDRV_PCM_STREAM_CAPTURE)
                         bcom_gen_bd_rx_reset(s->bcom_task);
-                        for (i = 0; i < runtime->periods; i++)
-                                if (!bcom_queue_full(s->bcom_task))
-                                        psc_dma_bcom_enqueue_next_buffer(s);
-                } else {
+                else
                         bcom_gen_bd_tx_reset(s->bcom_task);
-                        psc_dma_bcom_enqueue_tx(s);
-                }
+
+                for (i = 0; i < runtime->periods; i++)
+                        if (!bcom_queue_full(s->bcom_task))
+                                psc_dma_bcom_enqueue_next_buffer(s);
 
                 bcom_enable(s->bcom_task);
                 spin_unlock_irqrestore(&psc_dma->lock, flags);
@@ -223,6 +150,8 @@ static int psc_dma_trigger(struct snd_pcm_substream *substream, int cmd)
                 break;
 
         case SNDRV_PCM_TRIGGER_STOP:
+                dev_dbg(psc_dma->dev, "STOP: stream=%i periods_count=%i\n",
+                        substream->pstr->stream, s->period_count);
                 s->active = 0;
 
                 spin_lock_irqsave(&psc_dma->lock, flags);
@@ -236,7 +165,8 @@ static int psc_dma_trigger(struct snd_pcm_substream *substream, int cmd)
                 break;
 
         default:
-                dev_dbg(psc_dma->dev, "invalid command\n");
+                dev_dbg(psc_dma->dev, "unhandled trigger: stream=%i cmd=%i\n",
+                        substream->pstr->stream, cmd);
                 return -EINVAL;
         }
 
@@ -343,7 +273,7 @@ psc_dma_pointer(struct snd_pcm_substream *substream)
         else
                 s = &psc_dma->playback;
 
-        count = s->period_current_pt - s->period_start;
+        count = s->period_current * s->period_bytes;
 
         return bytes_to_frames(substream->runtime, count);
 }
@@ -532,11 +462,9 @@ int mpc5200_audio_dma_create(struct of_device *op)
 
         rc = request_irq(psc_dma->irq, &psc_dma_status_irq, IRQF_SHARED,
                          "psc-dma-status", psc_dma);
-        rc |= request_irq(psc_dma->capture.irq,
-                          &psc_dma_bcom_irq_rx, IRQF_SHARED,
+        rc |= request_irq(psc_dma->capture.irq, &psc_dma_bcom_irq, IRQF_SHARED,
                           "psc-dma-capture", &psc_dma->capture);
-        rc |= request_irq(psc_dma->playback.irq,
-                          &psc_dma_bcom_irq_tx, IRQF_SHARED,
+        rc |= request_irq(psc_dma->playback.irq, &psc_dma_bcom_irq, IRQF_SHARED,
                           "psc-dma-playback", &psc_dma->playback);
         if (rc) {
                 ret = -ENODEV;
diff --git a/sound/soc/fsl/mpc5200_dma.h b/sound/soc/fsl/mpc5200_dma.h
index 8d396bb9d9fe..22208b373fb9 100644
--- a/sound/soc/fsl/mpc5200_dma.h
+++ b/sound/soc/fsl/mpc5200_dma.h
@@ -13,26 +13,25 @@
  * @psc_dma:            pointer back to parent psc_dma data structure
  * @bcom_task:          bestcomm task structure
  * @irq:                irq number for bestcomm task
- * @period_start:       physical address of start of DMA region
  * @period_end:         physical address of end of DMA region
  * @period_next_pt:     physical address of next DMA buffer to enqueue
  * @period_bytes:       size of DMA period in bytes
+ * @ac97_slot_bits:     Enable bits for turning on the correct AC97 slot
  */
 struct psc_dma_stream {
         struct snd_pcm_runtime *runtime;
-        snd_pcm_uframes_t appl_ptr;
-
         int active;
         struct psc_dma *psc_dma;
         struct bcom_task *bcom_task;
         int irq;
         struct snd_pcm_substream *stream;
-        dma_addr_t period_start;
-        dma_addr_t period_end;
-        dma_addr_t period_next_pt;
-        dma_addr_t period_current_pt;
+        int period_next;
+        int period_current;
         int period_bytes;
-        int period_size;
+        int period_count;
+
+        /* AC97 state */
+        u32 ac97_slot_bits;
 };
 
 /**
@@ -73,6 +72,15 @@ struct psc_dma {
         } stats;
 };
 
+/* Utility for retrieving psc_dma_stream structure from a substream */
+inline struct psc_dma_stream *
+to_psc_dma_stream(struct snd_pcm_substream *substream, struct psc_dma *psc_dma)
+{
+        if (substream->pstr->stream == SNDRV_PCM_STREAM_CAPTURE)
+                return &psc_dma->capture;
+        return &psc_dma->playback;
+}
+
 int mpc5200_audio_dma_create(struct of_device *op);
 int mpc5200_audio_dma_destroy(struct of_device *op);
 
diff --git a/sound/soc/fsl/mpc5200_psc_ac97.c b/sound/soc/fsl/mpc5200_psc_ac97.c
index c4ae3e096bb9..3dbc7f7cd7b9 100644
--- a/sound/soc/fsl/mpc5200_psc_ac97.c
+++ b/sound/soc/fsl/mpc5200_psc_ac97.c
@@ -130,6 +130,7 @@ static int psc_ac97_hw_analog_params(struct snd_pcm_substream *substream,
                                  struct snd_soc_dai *cpu_dai)
 {
         struct psc_dma *psc_dma = cpu_dai->private_data;
+        struct psc_dma_stream *s = to_psc_dma_stream(substream, psc_dma);
 
         dev_dbg(psc_dma->dev, "%s(substream=%p) p_size=%i p_bytes=%i"
                 " periods=%i buffer_size=%i  buffer_bytes=%i channels=%i"
@@ -140,20 +141,10 @@ static int psc_ac97_hw_analog_params(struct snd_pcm_substream *substream,
                 params_channels(params), params_rate(params),
                 params_format(params));
 
-
-        if (substream->pstr->stream == SNDRV_PCM_STREAM_CAPTURE) {
-                if (params_channels(params) == 1)
-                        psc_dma->slots |= 0x00000100;
-                else
-                        psc_dma->slots |= 0x00000300;
-        } else {
-                if (params_channels(params) == 1)
-                        psc_dma->slots |= 0x01000000;
-                else
-                        psc_dma->slots |= 0x03000000;
-        }
-        out_be32(&psc_dma->psc_regs->ac97_slots, psc_dma->slots);
-
+        /* Determine the set of enable bits to turn on */
+        s->ac97_slot_bits = (params_channels(params) == 1) ? 0x100 : 0x300;
+        if (substream->pstr->stream != SNDRV_PCM_STREAM_CAPTURE)
+                s->ac97_slot_bits <<= 16;
         return 0;
 }
 
@@ -163,6 +154,8 @@ static int psc_ac97_hw_digital_params(struct snd_pcm_substream *substream,
 {
         struct psc_dma *psc_dma = cpu_dai->private_data;
 
+        dev_dbg(psc_dma->dev, "%s(substream=%p)\n", __func__, substream);
+
         if (params_channels(params) == 1)
                 out_be32(&psc_dma->psc_regs->ac97_slots, 0x01000000);
         else
@@ -176,14 +169,24 @@ static int psc_ac97_trigger(struct snd_pcm_substream *substream, int cmd,
 {
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
         struct psc_dma *psc_dma = rtd->dai->cpu_dai->private_data;
+        struct psc_dma_stream *s = to_psc_dma_stream(substream, psc_dma);
 
         switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+                dev_dbg(psc_dma->dev, "AC97 START: stream=%i\n",
+                        substream->pstr->stream);
+
+                /* Set the slot enable bits */
+                psc_dma->slots |= s->ac97_slot_bits;
+                out_be32(&psc_dma->psc_regs->ac97_slots, psc_dma->slots);
+                break;
+
         case SNDRV_PCM_TRIGGER_STOP:
-                if (substream->pstr->stream == SNDRV_PCM_STREAM_CAPTURE)
-                        psc_dma->slots &= 0xFFFF0000;
-                else
-                        psc_dma->slots &= 0x0000FFFF;
+                dev_dbg(psc_dma->dev, "AC97 STOP: stream=%i\n",
+                        substream->pstr->stream);
 
+                /* Clear the slot enable bits */
+                psc_dma->slots &= ~(s->ac97_slot_bits);
                 out_be32(&psc_dma->psc_regs->ac97_slots, psc_dma->slots);
                 break;
         }
diff --git a/sound/soc/fsl/mpc8610_hpcd.c b/sound/soc/fsl/mpc8610_hpcd.c
index ef67d1cdffe7..83de1c81c8c4 100644
--- a/sound/soc/fsl/mpc8610_hpcd.c
+++ b/sound/soc/fsl/mpc8610_hpcd.c
@@ -9,6 +9,7 @@
  * express or implied.
  */
 
+#include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/interrupt.h>
 #include <linux/of_device.h>
diff --git a/sound/soc/fsl/pcm030-audio-fabric.c b/sound/soc/fsl/pcm030-audio-fabric.c
index b928ef7d28eb..6644cba7cbf2 100644
--- a/sound/soc/fsl/pcm030-audio-fabric.c
+++ b/sound/soc/fsl/pcm030-audio-fabric.c
@@ -55,7 +55,7 @@ static __init int pcm030_fabric_init(void)
         struct platform_device *pdev;
         int rc;
 
-        if (!machine_is_compatible("phytec,pcm030"))
+        if (!of_machine_is_compatible("phytec,pcm030"))
                 return -ENODEV;
 
         card.platform = &mpc5200_audio_dma_platform;
diff --git a/sound/soc/fsl/soc-of-simple.c b/sound/soc/fsl/soc-of-simple.c
index 8bc5cd9e972f..3bc13fd89096 100644
--- a/sound/soc/fsl/soc-of-simple.c
+++ b/sound/soc/fsl/soc-of-simple.c
@@ -12,6 +12,7 @@
 #include <linux/bitops.h>
 #include <linux/platform_device.h>
 #include <linux/of.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
diff --git a/sound/soc/imx/Kconfig b/sound/soc/imx/Kconfig
index a700562e8692..7174b4c710de 100644
--- a/sound/soc/imx/Kconfig
+++ b/sound/soc/imx/Kconfig
@@ -1,21 +1,13 @@
-config SND_MX1_MX2_SOC
-        tristate "SoC Audio for Freecale i.MX1x i.MX2x CPUs"
-        depends on ARCH_MX2 || ARCH_MX1
+config SND_IMX_SOC
+        tristate "SoC Audio for Freescale i.MX CPUs"
+        depends on ARCH_MXC
         select SND_PCM
+        select FIQ
+        select SND_SOC_AC97_BUS
         help
           Say Y or M if you want to add support for codecs attached to
-          the MX1 or MX2 SSI interface.
+          the i.MX SSI interface.
 
 config SND_MXC_SOC_SSI
         tristate
 
-config SND_SOC_MX27VIS_WM8974
-        tristate "SoC Audio support for MX27 - WM8974 Visstrim_sm10 board"
-        depends on SND_MX1_MX2_SOC && MACH_MX27 && MACH_IMX27_VISSTRIM_M10
-        select SND_MXC_SOC_SSI
-        select SND_SOC_WM8974
-        help
-          Say Y if you want to add support for SoC audio on Visstrim SM10
-          board with WM8974.
-
-
diff --git a/sound/soc/imx/Makefile b/sound/soc/imx/Makefile
index c2ffd2c8df5a..9f8bb92ddfcc 100644
--- a/sound/soc/imx/Makefile
+++ b/sound/soc/imx/Makefile
@@ -1,10 +1,12 @@
 # i.MX Platform Support
-snd-soc-mx1_mx2-objs := mx1_mx2-pcm.o
-snd-soc-mxc-ssi-objs := mxc-ssi.o
+snd-soc-imx-objs := imx-ssi.o imx-pcm-fiq.o
 
-obj-$(CONFIG_SND_MX1_MX2_SOC) += snd-soc-mx1_mx2.o
-obj-$(CONFIG_SND_MXC_SOC_SSI) += snd-soc-mxc-ssi.o
+ifdef CONFIG_MACH_MX27
+snd-soc-imx-objs += imx-pcm-dma-mx2.o
+endif
+
+obj-$(CONFIG_SND_IMX_SOC) += snd-soc-imx.o
 
 # i.MX Machine Support
-snd-soc-mx27vis-wm8974-objs := mx27vis_wm8974.o
-obj-$(CONFIG_SND_SOC_MX27VIS_WM8974) += snd-soc-mx27vis-wm8974.o
+snd-soc-phycore-ac97-objs := phycore-ac97.o
+obj-$(CONFIG_SND_SOC_PHYCORE_AC97) += snd-soc-phycore-ac97.o
diff --git a/sound/soc/imx/imx-pcm-dma-mx2.c b/sound/soc/imx/imx-pcm-dma-mx2.c
new file mode 100644
index 000000000000..2b31ac673ea4
--- /dev/null
+++ b/sound/soc/imx/imx-pcm-dma-mx2.c
@@ -0,0 +1,331 @@
+/*
+ * imx-pcm-dma-mx2.c  --  ALSA Soc Audio Layer
+ *
+ * Copyright 2009 Sascha Hauer <s.hauer@pengutronix.de>
+ *
+ * This code is based on code copyrighted by Freescale,
+ * Liam Girdwood, Javier Martin and probably others.
+ *
+ *  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 the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ */
+#include <linux/clk.h>
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <linux/dma-mapping.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+
+#include <sound/core.h>
+#include <sound/initval.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/soc.h>
+
+#include <mach/dma-mx1-mx2.h>
+
+#include "imx-ssi.h"
+
+struct imx_pcm_runtime_data {
+        int sg_count;
+        struct scatterlist *sg_list;
+        int period;
+        int periods;
+        unsigned long dma_addr;
+        int dma;
+        struct snd_pcm_substream *substream;
+        unsigned long offset;
+        unsigned long size;
+        unsigned long period_cnt;
+        void *buf;
+        int period_time;
+};
+
+/* Called by the DMA framework when a period has elapsed */
+static void imx_ssi_dma_progression(int channel, void *data,
+                                        struct scatterlist *sg)
+{
+        struct snd_pcm_substream *substream = data;
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct imx_pcm_runtime_data *iprtd = runtime->private_data;
+
+        if (!sg)
+                return;
+
+        runtime = iprtd->substream->runtime;
+
+        iprtd->offset = sg->dma_address - runtime->dma_addr;
+
+        snd_pcm_period_elapsed(iprtd->substream);
+}
+
+static void imx_ssi_dma_callback(int channel, void *data)
+{
+        pr_err("%s shouldn't be called\n", __func__);
+}
+
+static void snd_imx_dma_err_callback(int channel, void *data, int err)
+{
+        struct snd_pcm_substream *substream = data;
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct imx_pcm_dma_params *dma_params = rtd->dai->cpu_dai->dma_data;
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct imx_pcm_runtime_data *iprtd = runtime->private_data;
+        int ret;
+
+        pr_err("DMA timeout on channel %d -%s%s%s%s\n",
+                 channel,
+                 err & IMX_DMA_ERR_BURST ?    " burst" : "",
+                 err & IMX_DMA_ERR_REQUEST ?  " request" : "",
+                 err & IMX_DMA_ERR_TRANSFER ? " transfer" : "",
+                 err & IMX_DMA_ERR_BUFFER ?   " buffer" : "");
+
+        imx_dma_disable(iprtd->dma);
+        ret = imx_dma_setup_sg(iprtd->dma, iprtd->sg_list, iprtd->sg_count,
+                        IMX_DMA_LENGTH_LOOP, dma_params->dma_addr,
+                        substream->stream == SNDRV_PCM_STREAM_PLAYBACK ?
+                        DMA_MODE_WRITE : DMA_MODE_READ);
+        if (!ret)
+                imx_dma_enable(iprtd->dma);
+}
+
+static int imx_ssi_dma_alloc(struct snd_pcm_substream *substream)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct imx_pcm_dma_params *dma_params;
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct imx_pcm_runtime_data *iprtd = runtime->private_data;
+        int ret;
+
+        dma_params = snd_soc_get_dma_data(rtd->dai->cpu_dai, substream);
+
+        iprtd->dma = imx_dma_request_by_prio(DRV_NAME, DMA_PRIO_HIGH);
+        if (iprtd->dma < 0) {
+                pr_err("Failed to claim the audio DMA\n");
+                return -ENODEV;
+        }
+
+        ret = imx_dma_setup_handlers(iprtd->dma,
+                                imx_ssi_dma_callback,
+                                snd_imx_dma_err_callback, substream);
+        if (ret)
+                goto out;
+
+        ret = imx_dma_setup_progression_handler(iprtd->dma,
+                        imx_ssi_dma_progression);
+        if (ret) {
+                pr_err("Failed to setup the DMA handler\n");
+                goto out;
+        }
+
+        ret = imx_dma_config_channel(iprtd->dma,
+                        IMX_DMA_MEMSIZE_16 | IMX_DMA_TYPE_FIFO,
+                        IMX_DMA_MEMSIZE_32 | IMX_DMA_TYPE_LINEAR,
+                        dma_params->dma, 1);
+        if (ret < 0) {
+                pr_err("Cannot configure DMA channel: %d\n", ret);
+                goto out;
+        }
+
+        imx_dma_config_burstlen(iprtd->dma, dma_params->burstsize * 2);
+
+        return 0;
+out:
+        imx_dma_free(iprtd->dma);
+        return ret;
+}
+
+static int snd_imx_pcm_hw_params(struct snd_pcm_substream *substream,
+                                struct snd_pcm_hw_params *params)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct imx_pcm_runtime_data *iprtd = runtime->private_data;
+        int i;
+        unsigned long dma_addr;
+
+        imx_ssi_dma_alloc(substream);
+
+        iprtd->size = params_buffer_bytes(params);
+        iprtd->periods = params_periods(params);
+        iprtd->period = params_period_bytes(params);
+        iprtd->offset = 0;
+        iprtd->period_time = HZ / (params_rate(params) /
+                        params_period_size(params));
+
+        snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer);
+
+        if (iprtd->sg_count != iprtd->periods) {
+                kfree(iprtd->sg_list);
+
+                iprtd->sg_list = kcalloc(iprtd->periods + 1,
+                                sizeof(struct scatterlist), GFP_KERNEL);
+                if (!iprtd->sg_list)
+                        return -ENOMEM;
+                iprtd->sg_count = iprtd->periods + 1;
+        }
+
+        sg_init_table(iprtd->sg_list, iprtd->sg_count);
+        dma_addr = runtime->dma_addr;
+
+        for (i = 0; i < iprtd->periods; i++) {
+                iprtd->sg_list[i].page_link = 0;
+                iprtd->sg_list[i].offset = 0;
+                iprtd->sg_list[i].dma_address = dma_addr;
+                iprtd->sg_list[i].length = iprtd->period;
+                dma_addr += iprtd->period;
+        }
+
+        /* close the loop */
+        iprtd->sg_list[iprtd->sg_count - 1].offset = 0;
+        iprtd->sg_list[iprtd->sg_count - 1].length = 0;
+        iprtd->sg_list[iprtd->sg_count - 1].page_link =
+                        ((unsigned long) iprtd->sg_list | 0x01) & ~0x02;
+        return 0;
+}
+
+static int snd_imx_pcm_hw_free(struct snd_pcm_substream *substream)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct imx_pcm_runtime_data *iprtd = runtime->private_data;
+
+        if (iprtd->dma >= 0) {
+                imx_dma_free(iprtd->dma);
+                iprtd->dma = -EINVAL;
+        }
+
+        kfree(iprtd->sg_list);
+        iprtd->sg_list = NULL;
+
+        return 0;
+}
+
+static int snd_imx_pcm_prepare(struct snd_pcm_substream *substream)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct imx_pcm_dma_params *dma_params;
+        struct imx_pcm_runtime_data *iprtd = runtime->private_data;
+        int err;
+
+        dma_params = snd_soc_get_dma_data(rtd->dai->cpu_dai, substream);
+
+        iprtd->substream = substream;
+        iprtd->buf = (unsigned int *)substream->dma_buffer.area;
+        iprtd->period_cnt = 0;
+
+        pr_debug("%s: buf: %p period: %d periods: %d\n",
+                        __func__, iprtd->buf, iprtd->period, iprtd->periods);
+
+        err = imx_dma_setup_sg(iprtd->dma, iprtd->sg_list, iprtd->sg_count,
+                        IMX_DMA_LENGTH_LOOP, dma_params->dma_addr,
+                        substream->stream == SNDRV_PCM_STREAM_PLAYBACK ?
+                        DMA_MODE_WRITE : DMA_MODE_READ);
+        if (err)
+                return err;
+
+        return 0;
+}
+
+static int snd_imx_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct imx_pcm_runtime_data *iprtd = runtime->private_data;
+
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+        case SNDRV_PCM_TRIGGER_RESUME:
+        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
+                imx_dma_enable(iprtd->dma);
+
+                break;
+
+        case SNDRV_PCM_TRIGGER_STOP:
+        case SNDRV_PCM_TRIGGER_SUSPEND:
+        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
+                imx_dma_disable(iprtd->dma);
+
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static snd_pcm_uframes_t snd_imx_pcm_pointer(struct snd_pcm_substream *substream)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct imx_pcm_runtime_data *iprtd = runtime->private_data;
+
+        return bytes_to_frames(substream->runtime, iprtd->offset);
+}
+
+static struct snd_pcm_hardware snd_imx_hardware = {
+        .info = SNDRV_PCM_INFO_INTERLEAVED |
+                SNDRV_PCM_INFO_BLOCK_TRANSFER |
+                SNDRV_PCM_INFO_MMAP |
+                SNDRV_PCM_INFO_MMAP_VALID |
+                SNDRV_PCM_INFO_PAUSE |
+                SNDRV_PCM_INFO_RESUME,
+        .formats = SNDRV_PCM_FMTBIT_S16_LE,
+        .rate_min = 8000,
+        .channels_min = 2,
+        .channels_max = 2,
+        .buffer_bytes_max = IMX_SSI_DMABUF_SIZE,
+        .period_bytes_min = 128,
+        .period_bytes_max = 16 * 1024,
+        .periods_min = 2,
+        .periods_max = 255,
+        .fifo_size = 0,
+};
+
+static int snd_imx_open(struct snd_pcm_substream *substream)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct imx_pcm_runtime_data *iprtd;
+        int ret;
+
+        iprtd = kzalloc(sizeof(*iprtd), GFP_KERNEL);
+        runtime->private_data = iprtd;
+
+        ret = snd_pcm_hw_constraint_integer(substream->runtime,
+                        SNDRV_PCM_HW_PARAM_PERIODS);
+        if (ret < 0)
+                return ret;
+
+        snd_soc_set_runtime_hwparams(substream, &snd_imx_hardware);
+        return 0;
+}
+
+static struct snd_pcm_ops imx_pcm_ops = {
+        .open           = snd_imx_open,
+        .ioctl          = snd_pcm_lib_ioctl,
+        .hw_params      = snd_imx_pcm_hw_params,
+        .hw_free        = snd_imx_pcm_hw_free,
+        .prepare        = snd_imx_pcm_prepare,
+        .trigger        = snd_imx_pcm_trigger,
+        .pointer        = snd_imx_pcm_pointer,
+        .mmap           = snd_imx_pcm_mmap,
+};
+
+static struct snd_soc_platform imx_soc_platform_dma = {
+        .name           = "imx-audio",
+        .pcm_ops        = &imx_pcm_ops,
+        .pcm_new        = imx_pcm_new,
+        .pcm_free       = imx_pcm_free,
+};
+
+struct snd_soc_platform *imx_ssi_dma_mx2_init(struct platform_device *pdev,
+                struct imx_ssi *ssi)
+{
+        ssi->dma_params_tx.burstsize = DMA_TXFIFO_BURST;
+        ssi->dma_params_rx.burstsize = DMA_RXFIFO_BURST;
+
+        return &imx_soc_platform_dma;
+}
+
diff --git a/sound/soc/imx/imx-pcm-fiq.c b/sound/soc/imx/imx-pcm-fiq.c
new file mode 100644
index 000000000000..6b518e07eea9
--- /dev/null
+++ b/sound/soc/imx/imx-pcm-fiq.c
@@ -0,0 +1,301 @@
+/*
+ * imx-pcm-fiq.c  --  ALSA Soc Audio Layer
+ *
+ * Copyright 2009 Sascha Hauer <s.hauer@pengutronix.de>
+ *
+ * This code is based on code copyrighted by Freescale,
+ * Liam Girdwood, Javier Martin and probably others.
+ *
+ *  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 the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ */
+#include <linux/clk.h>
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <linux/dma-mapping.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+
+#include <sound/core.h>
+#include <sound/initval.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/soc.h>
+
+#include <asm/fiq.h>
+
+#include <mach/ssi.h>
+
+#include "imx-ssi.h"
+
+struct imx_pcm_runtime_data {
+        int period;
+        int periods;
+        unsigned long offset;
+        unsigned long last_offset;
+        unsigned long size;
+        struct hrtimer hrt;
+        int poll_time_ns;
+        struct snd_pcm_substream *substream;
+        atomic_t running;
+};
+
+static enum hrtimer_restart snd_hrtimer_callback(struct hrtimer *hrt)
+{
+        struct imx_pcm_runtime_data *iprtd =
+                container_of(hrt, struct imx_pcm_runtime_data, hrt);
+        struct snd_pcm_substream *substream = iprtd->substream;
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct pt_regs regs;
+        unsigned long delta;
+
+        if (!atomic_read(&iprtd->running))
+                return HRTIMER_NORESTART;
+
+        get_fiq_regs(&regs);
+
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+                iprtd->offset = regs.ARM_r8 & 0xffff;
+        else
+                iprtd->offset = regs.ARM_r9 & 0xffff;
+
+        /* How much data have we transferred since the last period report? */
+        if (iprtd->offset >= iprtd->last_offset)
+                delta = iprtd->offset - iprtd->last_offset;
+        else
+                delta = runtime->buffer_size + iprtd->offset
+                        - iprtd->last_offset;
+
+        /* If we've transferred at least a period then report it and
+         * reset our poll time */
+        if (delta >= iprtd->period) {
+                snd_pcm_period_elapsed(substream);
+                iprtd->last_offset = iprtd->offset;
+        }
+
+        hrtimer_forward_now(hrt, ns_to_ktime(iprtd->poll_time_ns));
+
+        return HRTIMER_RESTART;
+}
+
+static struct fiq_handler fh = {
+        .name           = DRV_NAME,
+};
+
+static int snd_imx_pcm_hw_params(struct snd_pcm_substream *substream,
+                                struct snd_pcm_hw_params *params)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct imx_pcm_runtime_data *iprtd = runtime->private_data;
+
+        iprtd->size = params_buffer_bytes(params);
+        iprtd->periods = params_periods(params);
+        iprtd->period = params_period_bytes(params) ;
+        iprtd->offset = 0;
+        iprtd->last_offset = 0;
+        iprtd->poll_time_ns = 1000000000 / params_rate(params) *
+                                params_period_size(params);
+        snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer);
+
+        return 0;
+}
+
+static int snd_imx_pcm_prepare(struct snd_pcm_substream *substream)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct imx_pcm_runtime_data *iprtd = runtime->private_data;
+        struct pt_regs regs;
+
+        get_fiq_regs(&regs);
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+                regs.ARM_r8 = (iprtd->period * iprtd->periods - 1) << 16;
+        else
+                regs.ARM_r9 = (iprtd->period * iprtd->periods - 1) << 16;
+
+        set_fiq_regs(&regs);
+
+        return 0;
+}
+
+static int fiq_enable;
+static int imx_pcm_fiq;
+
+static int snd_imx_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct imx_pcm_runtime_data *iprtd = runtime->private_data;
+
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+        case SNDRV_PCM_TRIGGER_RESUME:
+        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
+                atomic_set(&iprtd->running, 1);
+                hrtimer_start(&iprtd->hrt, ns_to_ktime(iprtd->poll_time_ns),
+                      HRTIMER_MODE_REL);
+                if (++fiq_enable == 1)
+                        enable_fiq(imx_pcm_fiq);
+
+                break;
+
+        case SNDRV_PCM_TRIGGER_STOP:
+        case SNDRV_PCM_TRIGGER_SUSPEND:
+        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
+                atomic_set(&iprtd->running, 0);
+
+                if (--fiq_enable == 0)
+                        disable_fiq(imx_pcm_fiq);
+
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static snd_pcm_uframes_t snd_imx_pcm_pointer(struct snd_pcm_substream *substream)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct imx_pcm_runtime_data *iprtd = runtime->private_data;
+
+        return bytes_to_frames(substream->runtime, iprtd->offset);
+}
+
+static struct snd_pcm_hardware snd_imx_hardware = {
+        .info = SNDRV_PCM_INFO_INTERLEAVED |
+                SNDRV_PCM_INFO_BLOCK_TRANSFER |
+                SNDRV_PCM_INFO_MMAP |
+                SNDRV_PCM_INFO_MMAP_VALID |
+                SNDRV_PCM_INFO_PAUSE |
+                SNDRV_PCM_INFO_RESUME,
+        .formats = SNDRV_PCM_FMTBIT_S16_LE,
+        .rate_min = 8000,
+        .channels_min = 2,
+        .channels_max = 2,
+        .buffer_bytes_max = IMX_SSI_DMABUF_SIZE,
+        .period_bytes_min = 128,
+        .period_bytes_max = 16 * 1024,
+        .periods_min = 4,
+        .periods_max = 255,
+        .fifo_size = 0,
+};
+
+static int snd_imx_open(struct snd_pcm_substream *substream)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct imx_pcm_runtime_data *iprtd;
+        int ret;
+
+        iprtd = kzalloc(sizeof(*iprtd), GFP_KERNEL);
+        runtime->private_data = iprtd;
+
+        iprtd->substream = substream;
+
+        atomic_set(&iprtd->running, 0);
+        hrtimer_init(&iprtd->hrt, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
+        iprtd->hrt.function = snd_hrtimer_callback;
+
+        ret = snd_pcm_hw_constraint_integer(substream->runtime,
+                        SNDRV_PCM_HW_PARAM_PERIODS);
+        if (ret < 0)
+                return ret;
+
+        snd_soc_set_runtime_hwparams(substream, &snd_imx_hardware);
+        return 0;
+}
+
+static int snd_imx_close(struct snd_pcm_substream *substream)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct imx_pcm_runtime_data *iprtd = runtime->private_data;
+
+        hrtimer_cancel(&iprtd->hrt);
+
+        kfree(iprtd);
+
+        return 0;
+}
+
+static struct snd_pcm_ops imx_pcm_ops = {
+        .open           = snd_imx_open,
+        .close          = snd_imx_close,
+        .ioctl          = snd_pcm_lib_ioctl,
+        .hw_params      = snd_imx_pcm_hw_params,
+        .prepare        = snd_imx_pcm_prepare,
+        .trigger        = snd_imx_pcm_trigger,
+        .pointer        = snd_imx_pcm_pointer,
+        .mmap           = snd_imx_pcm_mmap,
+};
+
+static int imx_pcm_fiq_new(struct snd_card *card, struct snd_soc_dai *dai,
+        struct snd_pcm *pcm)
+{
+        int ret;
+
+        ret = imx_pcm_new(card, dai, pcm);
+        if (ret)
+                return ret;
+
+        if (dai->playback.channels_min) {
+                struct snd_pcm_substream *substream =
+                        pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream;
+                struct snd_dma_buffer *buf = &substream->dma_buffer;
+
+                imx_ssi_fiq_tx_buffer = (unsigned long)buf->area;
+        }
+
+        if (dai->capture.channels_min) {
+                struct snd_pcm_substream *substream =
+                        pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream;
+                struct snd_dma_buffer *buf = &substream->dma_buffer;
+
+                imx_ssi_fiq_rx_buffer = (unsigned long)buf->area;
+        }
+
+        set_fiq_handler(&imx_ssi_fiq_start,
+                &imx_ssi_fiq_end - &imx_ssi_fiq_start);
+
+        return 0;
+}
+
+static struct snd_soc_platform imx_soc_platform_fiq = {
+        .pcm_ops        = &imx_pcm_ops,
+        .pcm_new        = imx_pcm_fiq_new,
+        .pcm_free       = imx_pcm_free,
+};
+
+struct snd_soc_platform *imx_ssi_fiq_init(struct platform_device *pdev,
+                struct imx_ssi *ssi)
+{
+        int ret = 0;
+
+        ret = claim_fiq(&fh);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to claim fiq: %d", ret);
+                return ERR_PTR(ret);
+        }
+
+        mxc_set_irq_fiq(ssi->irq, 1);
+
+        imx_pcm_fiq = ssi->irq;
+
+        imx_ssi_fiq_base = (unsigned long)ssi->base;
+
+        ssi->dma_params_tx.burstsize = 4;
+        ssi->dma_params_rx.burstsize = 6;
+
+        return &imx_soc_platform_fiq;
+}
+
+void imx_ssi_fiq_exit(struct platform_device *pdev,
+                struct imx_ssi *ssi)
+{
+        mxc_set_irq_fiq(ssi->irq, 0);
+        release_fiq(&fh);
+}
+
diff --git a/sound/soc/imx/imx-ssi.c b/sound/soc/imx/imx-ssi.c
new file mode 100644
index 000000000000..80b4fee2442b
--- /dev/null
+++ b/sound/soc/imx/imx-ssi.c
@@ -0,0 +1,763 @@
+/*
+ * imx-ssi.c  --  ALSA Soc Audio Layer
+ *
+ * Copyright 2009 Sascha Hauer <s.hauer@pengutronix.de>
+ *
+ * This code is based on code copyrighted by Freescale,
+ * Liam Girdwood, Javier Martin and probably others.
+ *
+ *  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 the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ *
+ *
+ * The i.MX SSI core has some nasty limitations in AC97 mode. While most
+ * sane processor vendors have a FIFO per AC97 slot, the i.MX has only
+ * one FIFO which combines all valid receive slots. We cannot even select
+ * which slots we want to receive. The WM9712 with which this driver
+ * was developped with always sends GPIO status data in slot 12 which
+ * we receive in our (PCM-) data stream. The only chance we have is to
+ * manually skip this data in the FIQ handler. With sampling rates different
+ * from 48000Hz not every frame has valid receive data, so the ratio
+ * between pcm data and GPIO status data changes. Our FIQ handler is not
+ * able to handle this, hence this driver only works with 48000Hz sampling
+ * rate.
+ * Reading and writing AC97 registers is another challange. The core
+ * provides us status bits when the read register is updated with *another*
+ * value. When we read the same register two times (and the register still
+ * contains the same value) these status bits are not set. We work
+ * around this by not polling these bits but only wait a fixed delay.
+ * 
+ */
+
+#include <linux/clk.h>
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <linux/dma-mapping.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+
+#include <sound/core.h>
+#include <sound/initval.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/soc.h>
+
+#include <mach/ssi.h>
+#include <mach/hardware.h>
+
+#include "imx-ssi.h"
+
+#define SSI_SACNT_DEFAULT (SSI_SACNT_AC97EN | SSI_SACNT_FV)
+
+/*
+ * SSI Network Mode or TDM slots configuration.
+ * Should only be called when port is inactive (i.e. SSIEN = 0).
+ */
+static int imx_ssi_set_dai_tdm_slot(struct snd_soc_dai *cpu_dai,
+        unsigned int tx_mask, unsigned int rx_mask, int slots, int slot_width)
+{
+        struct imx_ssi *ssi = cpu_dai->private_data;
+        u32 sccr;
+
+        sccr = readl(ssi->base + SSI_STCCR);
+        sccr &= ~SSI_STCCR_DC_MASK;
+        sccr |= SSI_STCCR_DC(slots - 1);
+        writel(sccr, ssi->base + SSI_STCCR);
+
+        sccr = readl(ssi->base + SSI_SRCCR);
+        sccr &= ~SSI_STCCR_DC_MASK;
+        sccr |= SSI_STCCR_DC(slots - 1);
+        writel(sccr, ssi->base + SSI_SRCCR);
+
+        writel(tx_mask, ssi->base + SSI_STMSK);
+        writel(rx_mask, ssi->base + SSI_SRMSK);
+
+        return 0;
+}
+
+/*
+ * SSI DAI format configuration.
+ * Should only be called when port is inactive (i.e. SSIEN = 0).
+ * Note: We don't use the I2S modes but instead manually configure the
+ * SSI for I2S because the I2S mode is only a register preset.
+ */
+static int imx_ssi_set_dai_fmt(struct snd_soc_dai *cpu_dai, unsigned int fmt)
+{
+        struct imx_ssi *ssi = cpu_dai->private_data;
+        u32 strcr = 0, scr;
+
+        scr = readl(ssi->base + SSI_SCR) & ~(SSI_SCR_SYN | SSI_SCR_NET);
+
+        /* DAI mode */
+        switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
+        case SND_SOC_DAIFMT_I2S:
+                /* data on rising edge of bclk, frame low 1clk before data */
+                strcr |= SSI_STCR_TFSI | SSI_STCR_TEFS | SSI_STCR_TXBIT0;
+                scr |= SSI_SCR_NET;
+                break;
+        case SND_SOC_DAIFMT_LEFT_J:
+                /* data on rising edge of bclk, frame high with data */
+                strcr |= SSI_STCR_TXBIT0;
+                break;
+        case SND_SOC_DAIFMT_DSP_B:
+                /* data on rising edge of bclk, frame high with data */
+                strcr |= SSI_STCR_TFSL;
+                break;
+        case SND_SOC_DAIFMT_DSP_A:
+                /* data on rising edge of bclk, frame high 1clk before data */
+                strcr |= SSI_STCR_TFSL | SSI_STCR_TEFS;
+                break;
+        }
+
+        /* DAI clock inversion */
+        switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
+        case SND_SOC_DAIFMT_IB_IF:
+                strcr |= SSI_STCR_TFSI;
+                strcr &= ~SSI_STCR_TSCKP;
+                break;
+        case SND_SOC_DAIFMT_IB_NF:
+                strcr &= ~(SSI_STCR_TSCKP | SSI_STCR_TFSI);
+                break;
+        case SND_SOC_DAIFMT_NB_IF:
+                strcr |= SSI_STCR_TFSI | SSI_STCR_TSCKP;
+                break;
+        case SND_SOC_DAIFMT_NB_NF:
+                strcr &= ~SSI_STCR_TFSI;
+                strcr |= SSI_STCR_TSCKP;
+                break;
+        }
+
+        /* DAI clock master masks */
+        switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
+        case SND_SOC_DAIFMT_CBM_CFM:
+                break;
+        default:
+                /* Master mode not implemented, needs handling of clocks. */
+                return -EINVAL;
+        }
+
+        strcr |= SSI_STCR_TFEN0;
+
+        writel(strcr, ssi->base + SSI_STCR);
+        writel(strcr, ssi->base + SSI_SRCR);
+        writel(scr, ssi->base + SSI_SCR);
+
+        return 0;
+}
+
+/*
+ * SSI system clock configuration.
+ * Should only be called when port is inactive (i.e. SSIEN = 0).
+ */
+static int imx_ssi_set_dai_sysclk(struct snd_soc_dai *cpu_dai,
+                                  int clk_id, unsigned int freq, int dir)
+{
+        struct imx_ssi *ssi = cpu_dai->private_data;
+        u32 scr;
+
+        scr = readl(ssi->base + SSI_SCR);
+
+        switch (clk_id) {
+        case IMX_SSP_SYS_CLK:
+                if (dir == SND_SOC_CLOCK_OUT)
+                        scr |= SSI_SCR_SYS_CLK_EN;
+                else
+                        scr &= ~SSI_SCR_SYS_CLK_EN;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        writel(scr, ssi->base + SSI_SCR);
+
+        return 0;
+}
+
+/*
+ * SSI Clock dividers
+ * Should only be called when port is inactive (i.e. SSIEN = 0).
+ */
+static int imx_ssi_set_dai_clkdiv(struct snd_soc_dai *cpu_dai,
+                                  int div_id, int div)
+{
+        struct imx_ssi *ssi = cpu_dai->private_data;
+        u32 stccr, srccr;
+
+        stccr = readl(ssi->base + SSI_STCCR);
+        srccr = readl(ssi->base + SSI_SRCCR);
+
+        switch (div_id) {
+        case IMX_SSI_TX_DIV_2:
+                stccr &= ~SSI_STCCR_DIV2;
+                stccr |= div;
+                break;
+        case IMX_SSI_TX_DIV_PSR:
+                stccr &= ~SSI_STCCR_PSR;
+                stccr |= div;
+                break;
+        case IMX_SSI_TX_DIV_PM:
+                stccr &= ~0xff;
+                stccr |= SSI_STCCR_PM(div);
+                break;
+        case IMX_SSI_RX_DIV_2:
+                stccr &= ~SSI_STCCR_DIV2;
+                stccr |= div;
+                break;
+        case IMX_SSI_RX_DIV_PSR:
+                stccr &= ~SSI_STCCR_PSR;
+                stccr |= div;
+                break;
+        case IMX_SSI_RX_DIV_PM:
+                stccr &= ~0xff;
+                stccr |= SSI_STCCR_PM(div);
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        writel(stccr, ssi->base + SSI_STCCR);
+        writel(srccr, ssi->base + SSI_SRCCR);
+
+        return 0;
+}
+
+/*
+ * Should only be called when port is inactive (i.e. SSIEN = 0),
+ * although can be called multiple times by upper layers.
+ */
+static int imx_ssi_hw_params(struct snd_pcm_substream *substream,
+                             struct snd_pcm_hw_params *params,
+                             struct snd_soc_dai *cpu_dai)
+{
+        struct imx_ssi *ssi = cpu_dai->private_data;
+        struct imx_pcm_dma_params *dma_data;
+        u32 reg, sccr;
+
+        /* Tx/Rx config */
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+                reg = SSI_STCCR;
+                dma_data = &ssi->dma_params_tx;
+        } else {
+                reg = SSI_SRCCR;
+                dma_data = &ssi->dma_params_rx;
+        }
+
+        snd_soc_dai_set_dma_data(cpu_dai, substream, dma_data);
+
+        sccr = readl(ssi->base + reg) & ~SSI_STCCR_WL_MASK;
+
+        /* DAI data (word) size */
+        switch (params_format(params)) {
+        case SNDRV_PCM_FORMAT_S16_LE:
+                sccr |= SSI_SRCCR_WL(16);
+                break;
+        case SNDRV_PCM_FORMAT_S20_3LE:
+                sccr |= SSI_SRCCR_WL(20);
+                break;
+        case SNDRV_PCM_FORMAT_S24_LE:
+                sccr |= SSI_SRCCR_WL(24);
+                break;
+        }
+
+        writel(sccr, ssi->base + reg);
+
+        return 0;
+}
+
+static int imx_ssi_trigger(struct snd_pcm_substream *substream, int cmd,
+                struct snd_soc_dai *dai)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
+        struct imx_ssi *ssi = cpu_dai->private_data;
+        unsigned int sier_bits, sier;
+        unsigned int scr;
+
+        scr = readl(ssi->base + SSI_SCR);
+        sier = readl(ssi->base + SSI_SIER);
+
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+                if (ssi->flags & IMX_SSI_DMA)
+                        sier_bits = SSI_SIER_TDMAE;
+                else
+                        sier_bits = SSI_SIER_TIE | SSI_SIER_TFE0_EN;
+        } else {
+                if (ssi->flags & IMX_SSI_DMA)
+                        sier_bits = SSI_SIER_RDMAE;
+                else
+                        sier_bits = SSI_SIER_RIE | SSI_SIER_RFF0_EN;
+        }
+
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+        case SNDRV_PCM_TRIGGER_RESUME:
+        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
+                if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+                        scr |= SSI_SCR_TE;
+                else
+                        scr |= SSI_SCR_RE;
+                sier |= sier_bits;
+
+                if (++ssi->enabled == 1)
+                        scr |= SSI_SCR_SSIEN;
+
+                break;
+
+        case SNDRV_PCM_TRIGGER_STOP:
+        case SNDRV_PCM_TRIGGER_SUSPEND:
+        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
+                if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+                        scr &= ~SSI_SCR_TE;
+                else
+                        scr &= ~SSI_SCR_RE;
+                sier &= ~sier_bits;
+
+                if (--ssi->enabled == 0)
+                        scr &= ~SSI_SCR_SSIEN;
+
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        if (!(ssi->flags & IMX_SSI_USE_AC97))
+                /* rx/tx are always enabled to access ac97 registers */
+                writel(scr, ssi->base + SSI_SCR);
+
+        writel(sier, ssi->base + SSI_SIER);
+
+        return 0;
+}
+
+static struct snd_soc_dai_ops imx_ssi_pcm_dai_ops = {
+        .hw_params      = imx_ssi_hw_params,
+        .set_fmt        = imx_ssi_set_dai_fmt,
+        .set_clkdiv     = imx_ssi_set_dai_clkdiv,
+        .set_sysclk     = imx_ssi_set_dai_sysclk,
+        .set_tdm_slot   = imx_ssi_set_dai_tdm_slot,
+        .trigger        = imx_ssi_trigger,
+};
+
+static struct snd_soc_dai imx_ssi_dai = {
+        .playback = {
+                .channels_min = 2,
+                .channels_max = 2,
+                .rates = SNDRV_PCM_RATE_8000_96000,
+                .formats = SNDRV_PCM_FMTBIT_S16_LE,
+        },
+        .capture = {
+                .channels_min = 2,
+                .channels_max = 2,
+                .rates = SNDRV_PCM_RATE_8000_96000,
+                .formats = SNDRV_PCM_FMTBIT_S16_LE,
+        },
+        .ops = &imx_ssi_pcm_dai_ops,
+};
+
+int snd_imx_pcm_mmap(struct snd_pcm_substream *substream,
+                struct vm_area_struct *vma)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        int ret;
+
+        ret = dma_mmap_coherent(NULL, vma, runtime->dma_area,
+                        runtime->dma_addr, runtime->dma_bytes);
+
+        pr_debug("%s: ret: %d %p 0x%08x 0x%08x\n", __func__, ret,
+                        runtime->dma_area,
+                        runtime->dma_addr,
+                        runtime->dma_bytes);
+        return ret;
+}
+
+static int imx_pcm_preallocate_dma_buffer(struct snd_pcm *pcm, int stream)
+{
+        struct snd_pcm_substream *substream = pcm->streams[stream].substream;
+        struct snd_dma_buffer *buf = &substream->dma_buffer;
+        size_t size = IMX_SSI_DMABUF_SIZE;
+
+        buf->dev.type = SNDRV_DMA_TYPE_DEV;
+        buf->dev.dev = pcm->card->dev;
+        buf->private_data = NULL;
+        buf->area = dma_alloc_writecombine(pcm->card->dev, size,
+                                           &buf->addr, GFP_KERNEL);
+        if (!buf->area)
+                return -ENOMEM;
+        buf->bytes = size;
+
+        return 0;
+}
+
+static u64 imx_pcm_dmamask = DMA_BIT_MASK(32);
+
+int imx_pcm_new(struct snd_card *card, struct snd_soc_dai *dai,
+        struct snd_pcm *pcm)
+{
+
+        int ret = 0;
+
+        if (!card->dev->dma_mask)
+                card->dev->dma_mask = &imx_pcm_dmamask;
+        if (!card->dev->coherent_dma_mask)
+                card->dev->coherent_dma_mask = DMA_BIT_MASK(32);
+        if (dai->playback.channels_min) {
+                ret = imx_pcm_preallocate_dma_buffer(pcm,
+                        SNDRV_PCM_STREAM_PLAYBACK);
+                if (ret)
+                        goto out;
+        }
+
+        if (dai->capture.channels_min) {
+                ret = imx_pcm_preallocate_dma_buffer(pcm,
+                        SNDRV_PCM_STREAM_CAPTURE);
+                if (ret)
+                        goto out;
+        }
+
+out:
+        return ret;
+}
+
+void imx_pcm_free(struct snd_pcm *pcm)
+{
+        struct snd_pcm_substream *substream;
+        struct snd_dma_buffer *buf;
+        int stream;
+
+        for (stream = 0; stream < 2; stream++) {
+                substream = pcm->streams[stream].substream;
+                if (!substream)
+                        continue;
+
+                buf = &substream->dma_buffer;
+                if (!buf->area)
+                        continue;
+
+                dma_free_writecombine(pcm->card->dev, buf->bytes,
+                                      buf->area, buf->addr);
+                buf->area = NULL;
+        }
+}
+
+struct snd_soc_platform imx_soc_platform = {
+        .name           = "imx-audio",
+};
+EXPORT_SYMBOL_GPL(imx_soc_platform);
+
+static struct snd_soc_dai imx_ac97_dai = {
+        .name = "AC97",
+        .ac97_control = 1,
+        .playback = {
+                .stream_name = "AC97 Playback",
+                .channels_min = 2,
+                .channels_max = 2,
+                .rates = SNDRV_PCM_RATE_48000,
+                .formats = SNDRV_PCM_FMTBIT_S16_LE,
+        },
+        .capture = {
+                .stream_name = "AC97 Capture",
+                .channels_min = 2,
+                .channels_max = 2,
+                .rates = SNDRV_PCM_RATE_48000,
+                .formats = SNDRV_PCM_FMTBIT_S16_LE,
+        },
+        .ops = &imx_ssi_pcm_dai_ops,
+};
+
+static void setup_channel_to_ac97(struct imx_ssi *imx_ssi)
+{
+        void __iomem *base = imx_ssi->base;
+
+        writel(0x0, base + SSI_SCR);
+        writel(0x0, base + SSI_STCR);
+        writel(0x0, base + SSI_SRCR);
+
+        writel(SSI_SCR_SYN | SSI_SCR_NET, base + SSI_SCR);
+
+        writel(SSI_SFCSR_RFWM0(8) |
+                SSI_SFCSR_TFWM0(8) |
+                SSI_SFCSR_RFWM1(8) |
+                SSI_SFCSR_TFWM1(8), base + SSI_SFCSR);
+
+        writel(SSI_STCCR_WL(16) | SSI_STCCR_DC(12), base + SSI_STCCR);
+        writel(SSI_STCCR_WL(16) | SSI_STCCR_DC(12), base + SSI_SRCCR);
+
+        writel(SSI_SCR_SYN | SSI_SCR_NET | SSI_SCR_SSIEN, base + SSI_SCR);
+        writel(SSI_SOR_WAIT(3), base + SSI_SOR);
+
+        writel(SSI_SCR_SYN | SSI_SCR_NET | SSI_SCR_SSIEN |
+                        SSI_SCR_TE | SSI_SCR_RE,
+                        base + SSI_SCR);
+
+        writel(SSI_SACNT_DEFAULT, base + SSI_SACNT);
+        writel(0xff, base + SSI_SACCDIS);
+        writel(0x300, base + SSI_SACCEN);
+}
+
+static struct imx_ssi *ac97_ssi;
+
+static void imx_ssi_ac97_write(struct snd_ac97 *ac97, unsigned short reg,
+                unsigned short val)
+{
+        struct imx_ssi *imx_ssi = ac97_ssi;
+        void __iomem *base = imx_ssi->base;
+        unsigned int lreg;
+        unsigned int lval;
+
+        if (reg > 0x7f)
+                return;
+
+        pr_debug("%s: 0x%02x 0x%04x\n", __func__, reg, val);
+
+        lreg = reg <<  12;
+        writel(lreg, base + SSI_SACADD);
+
+        lval = val << 4;
+        writel(lval , base + SSI_SACDAT);
+
+        writel(SSI_SACNT_DEFAULT | SSI_SACNT_WR, base + SSI_SACNT);
+        udelay(100);
+}
+
+static unsigned short imx_ssi_ac97_read(struct snd_ac97 *ac97,
+                unsigned short reg)
+{
+        struct imx_ssi *imx_ssi = ac97_ssi;
+        void __iomem *base = imx_ssi->base;
+
+        unsigned short val = -1;
+        unsigned int lreg;
+
+        lreg = (reg & 0x7f) <<  12 ;
+        writel(lreg, base + SSI_SACADD);
+        writel(SSI_SACNT_DEFAULT | SSI_SACNT_RD, base + SSI_SACNT);
+
+        udelay(100);
+
+        val = (readl(base + SSI_SACDAT) >> 4) & 0xffff;
+
+        pr_debug("%s: 0x%02x 0x%04x\n", __func__, reg, val);
+
+        return val;
+}
+
+static void imx_ssi_ac97_reset(struct snd_ac97 *ac97)
+{
+        struct imx_ssi *imx_ssi = ac97_ssi;
+
+        if (imx_ssi->ac97_reset)
+                imx_ssi->ac97_reset(ac97);
+}
+
+static void imx_ssi_ac97_warm_reset(struct snd_ac97 *ac97)
+{
+        struct imx_ssi *imx_ssi = ac97_ssi;
+
+        if (imx_ssi->ac97_warm_reset)
+                imx_ssi->ac97_warm_reset(ac97);
+}
+
+struct snd_ac97_bus_ops soc_ac97_ops = {
+        .read           = imx_ssi_ac97_read,
+        .write          = imx_ssi_ac97_write,
+        .reset          = imx_ssi_ac97_reset,
+        .warm_reset     = imx_ssi_ac97_warm_reset
+};
+EXPORT_SYMBOL_GPL(soc_ac97_ops);
+
+struct snd_soc_dai imx_ssi_pcm_dai[2];
+EXPORT_SYMBOL_GPL(imx_ssi_pcm_dai);
+
+static int imx_ssi_probe(struct platform_device *pdev)
+{
+        struct resource *res;
+        struct imx_ssi *ssi;
+        struct imx_ssi_platform_data *pdata = pdev->dev.platform_data;
+        struct snd_soc_platform *platform;
+        int ret = 0;
+        unsigned int val;
+        struct snd_soc_dai *dai = &imx_ssi_pcm_dai[pdev->id];
+
+        if (dai->id >= ARRAY_SIZE(imx_ssi_pcm_dai))
+                return -EINVAL;
+
+        ssi = kzalloc(sizeof(*ssi), GFP_KERNEL);
+        if (!ssi)
+                return -ENOMEM;
+
+        if (pdata) {
+                ssi->ac97_reset = pdata->ac97_reset;
+                ssi->ac97_warm_reset = pdata->ac97_warm_reset;
+                ssi->flags = pdata->flags;
+        }
+
+        ssi->irq = platform_get_irq(pdev, 0);
+
+        ssi->clk = clk_get(&pdev->dev, NULL);
+        if (IS_ERR(ssi->clk)) {
+                ret = PTR_ERR(ssi->clk);
+                dev_err(&pdev->dev, "Cannot get the clock: %d\n",
+                        ret);
+                goto failed_clk;
+        }
+        clk_enable(ssi->clk);
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                ret = -ENODEV;
+                goto failed_get_resource;
+        }
+
+        if (!request_mem_region(res->start, resource_size(res), DRV_NAME)) {
+                dev_err(&pdev->dev, "request_mem_region failed\n");
+                ret = -EBUSY;
+                goto failed_get_resource;
+        }
+
+        ssi->base = ioremap(res->start, resource_size(res));
+        if (!ssi->base) {
+                dev_err(&pdev->dev, "ioremap failed\n");
+                ret = -ENODEV;
+                goto failed_ioremap;
+        }
+
+        if (ssi->flags & IMX_SSI_USE_AC97) {
+                if (ac97_ssi) {
+                        ret = -EBUSY;
+                        goto failed_ac97;
+                }
+                ac97_ssi = ssi;
+                setup_channel_to_ac97(ssi);
+                memcpy(dai, &imx_ac97_dai, sizeof(imx_ac97_dai));
+        } else
+                memcpy(dai, &imx_ssi_dai, sizeof(imx_ssi_dai));
+
+        writel(0x0, ssi->base + SSI_SIER);
+
+        ssi->dma_params_rx.dma_addr = res->start + SSI_SRX0;
+        ssi->dma_params_tx.dma_addr = res->start + SSI_STX0;
+
+        res = platform_get_resource_byname(pdev, IORESOURCE_DMA, "tx0");
+        if (res)
+                ssi->dma_params_tx.dma = res->start;
+
+        res = platform_get_resource_byname(pdev, IORESOURCE_DMA, "rx0");
+        if (res)
+                ssi->dma_params_rx.dma = res->start;
+
+        dai->id = pdev->id;
+        dai->dev = &pdev->dev;
+        dai->name = kasprintf(GFP_KERNEL, "imx-ssi.%d", pdev->id);
+        dai->private_data = ssi;
+
+        if ((cpu_is_mx27() || cpu_is_mx21()) &&
+                        !(ssi->flags & IMX_SSI_USE_AC97) &&
+                        (ssi->flags & IMX_SSI_DMA)) {
+                ssi->flags |= IMX_SSI_DMA;
+                platform = imx_ssi_dma_mx2_init(pdev, ssi);
+        } else
+                platform = imx_ssi_fiq_init(pdev, ssi);
+
+        imx_soc_platform.pcm_ops = platform->pcm_ops;
+        imx_soc_platform.pcm_new = platform->pcm_new;
+        imx_soc_platform.pcm_free = platform->pcm_free;
+
+        val = SSI_SFCSR_TFWM0(ssi->dma_params_tx.burstsize) |
+                SSI_SFCSR_RFWM0(ssi->dma_params_rx.burstsize);
+        writel(val, ssi->base + SSI_SFCSR);
+
+        ret = snd_soc_register_dai(dai);
+        if (ret) {
+                dev_err(&pdev->dev, "register DAI failed\n");
+                goto failed_register;
+        }
+
+        platform_set_drvdata(pdev, ssi);
+
+        return 0;
+
+failed_register:
+failed_ac97:
+        iounmap(ssi->base);
+failed_ioremap:
+        release_mem_region(res->start, resource_size(res));
+failed_get_resource:
+        clk_disable(ssi->clk);
+        clk_put(ssi->clk);
+failed_clk:
+        kfree(ssi);
+
+        return ret;
+}
+
+static int __devexit imx_ssi_remove(struct platform_device *pdev)
+{
+        struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        struct imx_ssi *ssi = platform_get_drvdata(pdev);
+        struct snd_soc_dai *dai = &imx_ssi_pcm_dai[pdev->id];
+
+        snd_soc_unregister_dai(dai);
+
+        if (ssi->flags & IMX_SSI_USE_AC97)
+                ac97_ssi = NULL;
+
+        if (!(ssi->flags & IMX_SSI_DMA))
+                imx_ssi_fiq_exit(pdev, ssi);
+
+        iounmap(ssi->base);
+        release_mem_region(res->start, resource_size(res));
+        clk_disable(ssi->clk);
+        clk_put(ssi->clk);
+        kfree(ssi);
+
+        return 0;
+}
+
+static struct platform_driver imx_ssi_driver = {
+        .probe = imx_ssi_probe,
+        .remove = __devexit_p(imx_ssi_remove),
+
+        .driver = {
+                .name = DRV_NAME,
+                .owner = THIS_MODULE,
+        },
+};
+
+static int __init imx_ssi_init(void)
+{
+        int ret;
+
+        ret = snd_soc_register_platform(&imx_soc_platform);
+        if (ret) {
+                pr_err("failed to register soc platform: %d\n", ret);
+                return ret;
+        }
+
+        ret = platform_driver_register(&imx_ssi_driver);
+        if (ret) {
+                snd_soc_unregister_platform(&imx_soc_platform);
+                return ret;
+        }
+
+        return 0;
+}
+
+static void __exit imx_ssi_exit(void)
+{
+        platform_driver_unregister(&imx_ssi_driver);
+        snd_soc_unregister_platform(&imx_soc_platform);
+}
+
+module_init(imx_ssi_init);
+module_exit(imx_ssi_exit);
+
+/* Module information */
+MODULE_AUTHOR("Sascha Hauer, <s.hauer@pengutronix.de>");
+MODULE_DESCRIPTION("i.MX I2S/ac97 SoC Interface");
+MODULE_LICENSE("GPL");
+
diff --git a/sound/soc/imx/imx-ssi.h b/sound/soc/imx/imx-ssi.h
new file mode 100644
index 000000000000..55f26ebcd8c2
--- /dev/null
+++ b/sound/soc/imx/imx-ssi.h
@@ -0,0 +1,237 @@
+/*
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef _IMX_SSI_H
+#define _IMX_SSI_H
+
+#define SSI_STX0        0x00
+#define SSI_STX1        0x04
+#define SSI_SRX0        0x08
+#define SSI_SRX1        0x0c
+
+#define SSI_SCR         0x10
+#define SSI_SCR_CLK_IST         (1 << 9)
+#define SSI_SCR_CLK_IST_SHIFT   9
+#define SSI_SCR_TCH_EN          (1 << 8)
+#define SSI_SCR_SYS_CLK_EN      (1 << 7)
+#define SSI_SCR_I2S_MODE_NORM   (0 << 5)
+#define SSI_SCR_I2S_MODE_MSTR   (1 << 5)
+#define SSI_SCR_I2S_MODE_SLAVE  (2 << 5)
+#define SSI_I2S_MODE_MASK       (3 << 5)
+#define SSI_SCR_SYN             (1 << 4)
+#define SSI_SCR_NET             (1 << 3)
+#define SSI_SCR_RE              (1 << 2)
+#define SSI_SCR_TE              (1 << 1)
+#define SSI_SCR_SSIEN           (1 << 0)
+
+#define SSI_SISR        0x14
+#define SSI_SISR_MASK           ((1 << 19) - 1)
+#define SSI_SISR_CMDAU          (1 << 18)
+#define SSI_SISR_CMDDU          (1 << 17)
+#define SSI_SISR_RXT            (1 << 16)
+#define SSI_SISR_RDR1           (1 << 15)
+#define SSI_SISR_RDR0           (1 << 14)
+#define SSI_SISR_TDE1           (1 << 13)
+#define SSI_SISR_TDE0           (1 << 12)
+#define SSI_SISR_ROE1           (1 << 11)
+#define SSI_SISR_ROE0           (1 << 10)
+#define SSI_SISR_TUE1           (1 << 9)
+#define SSI_SISR_TUE0           (1 << 8)
+#define SSI_SISR_TFS            (1 << 7)
+#define SSI_SISR_RFS            (1 << 6)
+#define SSI_SISR_TLS            (1 << 5)
+#define SSI_SISR_RLS            (1 << 4)
+#define SSI_SISR_RFF1           (1 << 3)
+#define SSI_SISR_RFF0           (1 << 2)
+#define SSI_SISR_TFE1           (1 << 1)
+#define SSI_SISR_TFE0           (1 << 0)
+
+#define SSI_SIER        0x18
+#define SSI_SIER_RDMAE          (1 << 22)
+#define SSI_SIER_RIE            (1 << 21)
+#define SSI_SIER_TDMAE          (1 << 20)
+#define SSI_SIER_TIE            (1 << 19)
+#define SSI_SIER_CMDAU_EN       (1 << 18)
+#define SSI_SIER_CMDDU_EN       (1 << 17)
+#define SSI_SIER_RXT_EN         (1 << 16)
+#define SSI_SIER_RDR1_EN        (1 << 15)
+#define SSI_SIER_RDR0_EN        (1 << 14)
+#define SSI_SIER_TDE1_EN        (1 << 13)
+#define SSI_SIER_TDE0_EN        (1 << 12)
+#define SSI_SIER_ROE1_EN        (1 << 11)
+#define SSI_SIER_ROE0_EN        (1 << 10)
+#define SSI_SIER_TUE1_EN        (1 << 9)
+#define SSI_SIER_TUE0_EN        (1 << 8)
+#define SSI_SIER_TFS_EN         (1 << 7)
+#define SSI_SIER_RFS_EN         (1 << 6)
+#define SSI_SIER_TLS_EN         (1 << 5)
+#define SSI_SIER_RLS_EN         (1 << 4)
+#define SSI_SIER_RFF1_EN        (1 << 3)
+#define SSI_SIER_RFF0_EN        (1 << 2)
+#define SSI_SIER_TFE1_EN        (1 << 1)
+#define SSI_SIER_TFE0_EN        (1 << 0)
+
+#define SSI_STCR        0x1c
+#define SSI_STCR_TXBIT0         (1 << 9)
+#define SSI_STCR_TFEN1          (1 << 8)
+#define SSI_STCR_TFEN0          (1 << 7)
+#define SSI_FIFO_ENABLE_0_SHIFT 7
+#define SSI_STCR_TFDIR          (1 << 6)
+#define SSI_STCR_TXDIR          (1 << 5)
+#define SSI_STCR_TSHFD          (1 << 4)
+#define SSI_STCR_TSCKP          (1 << 3)
+#define SSI_STCR_TFSI           (1 << 2)
+#define SSI_STCR_TFSL           (1 << 1)
+#define SSI_STCR_TEFS           (1 << 0)
+
+#define SSI_SRCR        0x20
+#define SSI_SRCR_RXBIT0         (1 << 9)
+#define SSI_SRCR_RFEN1          (1 << 8)
+#define SSI_SRCR_RFEN0          (1 << 7)
+#define SSI_FIFO_ENABLE_0_SHIFT 7
+#define SSI_SRCR_RFDIR          (1 << 6)
+#define SSI_SRCR_RXDIR          (1 << 5)
+#define SSI_SRCR_RSHFD          (1 << 4)
+#define SSI_SRCR_RSCKP          (1 << 3)
+#define SSI_SRCR_RFSI           (1 << 2)
+#define SSI_SRCR_RFSL           (1 << 1)
+#define SSI_SRCR_REFS           (1 << 0)
+
+#define SSI_SRCCR               0x28
+#define SSI_SRCCR_DIV2          (1 << 18)
+#define SSI_SRCCR_PSR           (1 << 17)
+#define SSI_SRCCR_WL(x)         ((((x) - 2) >> 1) << 13)
+#define SSI_SRCCR_DC(x)         (((x) & 0x1f) << 8)
+#define SSI_SRCCR_PM(x)         (((x) & 0xff) << 0)
+#define SSI_SRCCR_WL_MASK       (0xf << 13)
+#define SSI_SRCCR_DC_MASK       (0x1f << 8)
+#define SSI_SRCCR_PM_MASK       (0xff << 0)
+
+#define SSI_STCCR               0x24
+#define SSI_STCCR_DIV2          (1 << 18)
+#define SSI_STCCR_PSR           (1 << 17)
+#define SSI_STCCR_WL(x)         ((((x) - 2) >> 1) << 13)
+#define SSI_STCCR_DC(x)         (((x) & 0x1f) << 8)
+#define SSI_STCCR_PM(x)         (((x) & 0xff) << 0)
+#define SSI_STCCR_WL_MASK       (0xf << 13)
+#define SSI_STCCR_DC_MASK       (0x1f << 8)
+#define SSI_STCCR_PM_MASK       (0xff << 0)
+
+#define SSI_SFCSR       0x2c
+#define SSI_SFCSR_RFCNT1(x)     (((x) & 0xf) << 28)
+#define SSI_RX_FIFO_1_COUNT_SHIFT 28
+#define SSI_SFCSR_TFCNT1(x)     (((x) & 0xf) << 24)
+#define SSI_TX_FIFO_1_COUNT_SHIFT 24
+#define SSI_SFCSR_RFWM1(x)      (((x) & 0xf) << 20)
+#define SSI_SFCSR_TFWM1(x)      (((x) & 0xf) << 16)
+#define SSI_SFCSR_RFCNT0(x)     (((x) & 0xf) << 12)
+#define SSI_RX_FIFO_0_COUNT_SHIFT 12
+#define SSI_SFCSR_TFCNT0(x)     (((x) & 0xf) <<  8)
+#define SSI_TX_FIFO_0_COUNT_SHIFT 8
+#define SSI_SFCSR_RFWM0(x)      (((x) & 0xf) <<  4)
+#define SSI_SFCSR_TFWM0(x)      (((x) & 0xf) <<  0)
+#define SSI_SFCSR_RFWM0_MASK    (0xf <<  4)
+#define SSI_SFCSR_TFWM0_MASK    (0xf <<  0)
+
+#define SSI_STR         0x30
+#define SSI_STR_TEST            (1 << 15)
+#define SSI_STR_RCK2TCK         (1 << 14)
+#define SSI_STR_RFS2TFS         (1 << 13)
+#define SSI_STR_RXSTATE(x)      (((x) & 0xf) << 8)
+#define SSI_STR_TXD2RXD         (1 <<  7)
+#define SSI_STR_TCK2RCK         (1 <<  6)
+#define SSI_STR_TFS2RFS         (1 <<  5)
+#define SSI_STR_TXSTATE(x)      (((x) & 0xf) << 0)
+
+#define SSI_SOR         0x34
+#define SSI_SOR_CLKOFF          (1 << 6)
+#define SSI_SOR_RX_CLR          (1 << 5)
+#define SSI_SOR_TX_CLR          (1 << 4)
+#define SSI_SOR_INIT            (1 << 3)
+#define SSI_SOR_WAIT(x)         (((x) & 0x3) << 1)
+#define SSI_SOR_WAIT_MASK       (0x3 << 1)
+#define SSI_SOR_SYNRST          (1 << 0)
+
+#define SSI_SACNT       0x38
+#define SSI_SACNT_FRDIV(x)      (((x) & 0x3f) << 5)
+#define SSI_SACNT_WR            (1 << 4)
+#define SSI_SACNT_RD            (1 << 3)
+#define SSI_SACNT_TIF           (1 << 2)
+#define SSI_SACNT_FV            (1 << 1)
+#define SSI_SACNT_AC97EN        (1 << 0)
+
+#define SSI_SACADD      0x3c
+#define SSI_SACDAT      0x40
+#define SSI_SATAG       0x44
+#define SSI_STMSK       0x48
+#define SSI_SRMSK       0x4c
+#define SSI_SACCST      0x50
+#define SSI_SACCEN      0x54
+#define SSI_SACCDIS     0x58
+
+/* SSI clock sources */
+#define IMX_SSP_SYS_CLK         0
+
+/* SSI audio dividers */
+#define IMX_SSI_TX_DIV_2        0
+#define IMX_SSI_TX_DIV_PSR      1
+#define IMX_SSI_TX_DIV_PM       2
+#define IMX_SSI_RX_DIV_2        3
+#define IMX_SSI_RX_DIV_PSR      4
+#define IMX_SSI_RX_DIV_PM       5
+
+extern struct snd_soc_dai imx_ssi_pcm_dai[2];
+extern struct snd_soc_platform imx_soc_platform;
+
+#define DRV_NAME "imx-ssi"
+
+struct imx_pcm_dma_params {
+        int dma;
+        unsigned long dma_addr;
+        int burstsize;
+};
+
+struct imx_ssi {
+        struct platform_device *ac97_dev;
+
+        struct snd_soc_device imx_ac97;
+        struct clk *clk;
+        void __iomem *base;
+        int irq;
+        int fiq_enable;
+        unsigned int offset;
+
+        unsigned int flags;
+
+        void (*ac97_reset) (struct snd_ac97 *ac97);
+        void (*ac97_warm_reset)(struct snd_ac97 *ac97);
+
+        struct imx_pcm_dma_params       dma_params_rx;
+        struct imx_pcm_dma_params       dma_params_tx;
+
+        int enabled;
+};
+
+struct snd_soc_platform *imx_ssi_fiq_init(struct platform_device *pdev,
+                struct imx_ssi *ssi);
+void imx_ssi_fiq_exit(struct platform_device *pdev, struct imx_ssi *ssi);
+struct snd_soc_platform *imx_ssi_dma_mx2_init(struct platform_device *pdev,
+                struct imx_ssi *ssi);
+
+int snd_imx_pcm_mmap(struct snd_pcm_substream *substream, struct vm_area_struct *vma);
+int imx_pcm_new(struct snd_card *card, struct snd_soc_dai *dai,
+        struct snd_pcm *pcm);
+void imx_pcm_free(struct snd_pcm *pcm);
+
+/*
+ * Do not change this as the FIQ handler depends on this size
+ */
+#define IMX_SSI_DMABUF_SIZE     (64 * 1024)
+
+#define DMA_RXFIFO_BURST      0x4
+#define DMA_TXFIFO_BURST      0x6
+
+#endif /* _IMX_SSI_H */
diff --git a/sound/soc/imx/mx1_mx2-pcm.c b/sound/soc/imx/mx1_mx2-pcm.c
deleted file mode 100644
index b83866529397..000000000000
--- a/sound/soc/imx/mx1_mx2-pcm.c
+++ /dev/null
@@ -1,488 +0,0 @@
-/*
- * mx1_mx2-pcm.c -- ALSA SoC interface for Freescale i.MX1x, i.MX2x CPUs
- *
- * Copyright 2009 Vista Silicon S.L.
- * Author: Javier Martin
- *         javier.martin@vista-silicon.com
- *
- * Based on mxc-pcm.c by Liam Girdwood.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- *
- */
-
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/platform_device.h>
-#include <linux/slab.h>
-#include <linux/dma-mapping.h>
-#include <sound/core.h>
-#include <sound/pcm.h>
-#include <sound/pcm_params.h>
-#include <sound/soc.h>
-#include <asm/dma.h>
-#include <mach/hardware.h>
-#include <mach/dma-mx1-mx2.h>
-
-#include "mx1_mx2-pcm.h"
-
-
-static const struct snd_pcm_hardware mx1_mx2_pcm_hardware = {
-        .info                   = (SNDRV_PCM_INFO_INTERLEAVED |
-                                   SNDRV_PCM_INFO_BLOCK_TRANSFER |
-                                   SNDRV_PCM_INFO_MMAP |
-                                   SNDRV_PCM_INFO_MMAP_VALID),
-        .formats                = SNDRV_PCM_FMTBIT_S16_LE,
-        .buffer_bytes_max       = 32 * 1024,
-        .period_bytes_min       = 64,
-        .period_bytes_max       = 8 * 1024,
-        .periods_min            = 2,
-        .periods_max            = 255,
-        .fifo_size              = 0,
-};
-
-struct mx1_mx2_runtime_data {
-        int dma_ch;
-        int active;
-        unsigned int period;
-        unsigned int periods;
-        int tx_spin;
-        spinlock_t dma_lock;
-        struct mx1_mx2_pcm_dma_params *dma_params;
-};
-
-
-/**
-  * This function stops the current dma transfer for playback
-  * and clears the dma pointers.
-  *
-  * @param      substream       pointer to the structure of the current stream.
-  *
-  */
-static int audio_stop_dma(struct snd_pcm_substream *substream)
-{
-        struct snd_pcm_runtime *runtime = substream->runtime;
-        struct mx1_mx2_runtime_data *prtd = runtime->private_data;
-        unsigned long flags;
-
-        spin_lock_irqsave(&prtd->dma_lock, flags);
-
-        pr_debug("%s\n", __func__);
-
-        prtd->active = 0;
-        prtd->period = 0;
-        prtd->periods = 0;
-
-        /* this stops the dma channel and clears the buffer ptrs */
-
-        imx_dma_disable(prtd->dma_ch);
-
-        spin_unlock_irqrestore(&prtd->dma_lock, flags);
-
-        return 0;
-}
-
-/**
-  * This function is called whenever a new audio block needs to be
-  * transferred to the codec. The function receives the address and the size
-  * of the new block and start a new DMA transfer.
-  *
-  * @param      substream       pointer to the structure of the current stream.
-  *
-  */
-static int dma_new_period(struct snd_pcm_substream *substream)
-{
-        struct snd_pcm_runtime *runtime =  substream->runtime;
-        struct mx1_mx2_runtime_data *prtd = runtime->private_data;
-        unsigned int dma_size;
-        unsigned int offset;
-        int ret = 0;
-        dma_addr_t mem_addr;
-        unsigned int dev_addr;
-
-        if (prtd->active) {
-                dma_size = frames_to_bytes(runtime, runtime->period_size);
-                offset = dma_size * prtd->period;
-
-                pr_debug("%s: period (%d) out of (%d)\n", __func__,
-                        prtd->period,
-                        runtime->periods);
-                pr_debug("period_size %d frames\n offset %d bytes\n",
-                        (unsigned int)runtime->period_size,
-                        offset);
-                pr_debug("dma_size %d bytes\n", dma_size);
-
-                snd_BUG_ON(dma_size > mx1_mx2_pcm_hardware.period_bytes_max);
-
-                mem_addr = (dma_addr_t)(runtime->dma_addr + offset);
-                dev_addr = prtd->dma_params->per_address;
-                pr_debug("%s: mem_addr is %x\n dev_addr is %x\n",
-                                 __func__, mem_addr, dev_addr);
-
-                ret = imx_dma_setup_single(prtd->dma_ch, mem_addr,
-                                        dma_size, dev_addr,
-                                        prtd->dma_params->transfer_type);
-                if (ret < 0) {
-                        printk(KERN_ERR "Error %d configuring DMA\n", ret);
-                        return ret;
-                }
-                imx_dma_enable(prtd->dma_ch);
-
-                pr_debug("%s: transfer enabled\nmem_addr = %x\n",
-                        __func__, (unsigned int) mem_addr);
-                pr_debug("dev_addr = %x\ndma_size = %d\n",
-                        (unsigned int) dev_addr, dma_size);
-
-                prtd->tx_spin = 1; /* FGA little trick to retrieve DMA pos */
-                prtd->period++;
-                prtd->period %= runtime->periods;
-    }
-        return ret;
-}
-
-
-/**
-  * This is a callback which will be called
-  * when a TX transfer finishes. The call occurs
-  * in interrupt context.
-  *
-  * @param      dat     pointer to the structure of the current stream.
-  *
-  */
-static void audio_dma_irq(int channel, void *data)
-{
-        struct snd_pcm_substream *substream;
-        struct snd_pcm_runtime *runtime;
-        struct mx1_mx2_runtime_data *prtd;
-        unsigned int dma_size;
-        unsigned int previous_period;
-        unsigned int offset;
-
-        substream = data;
-        runtime = substream->runtime;
-        prtd = runtime->private_data;
-        previous_period  = prtd->periods;
-        dma_size = frames_to_bytes(runtime, runtime->period_size);
-        offset = dma_size * previous_period;
-
-        prtd->tx_spin = 0;
-        prtd->periods++;
-        prtd->periods %= runtime->periods;
-
-        pr_debug("%s: irq per %d offset %x\n", __func__, prtd->periods, offset);
-
-        /*
-          * If we are getting a callback for an active stream then we inform
-          * the PCM middle layer we've finished a period
-          */
-        if (prtd->active)
-                snd_pcm_period_elapsed(substream);
-
-        /*
-          * Trig next DMA transfer
-          */
-        dma_new_period(substream);
-}
-
-/**
-  * This function configures the hardware to allow audio
-  * playback operations. It is called by ALSA framework.
-  *
-  * @param      substream       pointer to the structure of the current stream.
-  *
-  * @return              0 on success, -1 otherwise.
-  */
-static int
-snd_mx1_mx2_prepare(struct snd_pcm_substream *substream)
-{
-        struct snd_pcm_runtime *runtime =  substream->runtime;
-        struct mx1_mx2_runtime_data *prtd = runtime->private_data;
-
-        prtd->period = 0;
-        prtd->periods = 0;
-
-        return 0;
-}
-
-static int mx1_mx2_pcm_hw_params(struct snd_pcm_substream *substream,
-        struct snd_pcm_hw_params *hw_params)
-{
-        struct snd_pcm_runtime *runtime = substream->runtime;
-        int ret;
-
-        ret = snd_pcm_lib_malloc_pages(substream,
-                                        params_buffer_bytes(hw_params));
-        if (ret < 0) {
-                printk(KERN_ERR "%s: Error %d failed to malloc pcm pages \n",
-                __func__, ret);
-                return ret;
-        }
-
-        pr_debug("%s: snd_imx1_mx2_audio_hw_params runtime->dma_addr 0x(%x)\n",
-                __func__, (unsigned int)runtime->dma_addr);
-        pr_debug("%s: snd_imx1_mx2_audio_hw_params runtime->dma_area 0x(%x)\n",
-                __func__, (unsigned int)runtime->dma_area);
-        pr_debug("%s: snd_imx1_mx2_audio_hw_params runtime->dma_bytes 0x(%x)\n",
-                __func__, (unsigned int)runtime->dma_bytes);
-
-        return ret;
-}
-
-static int mx1_mx2_pcm_hw_free(struct snd_pcm_substream *substream)
-{
-        struct snd_pcm_runtime *runtime = substream->runtime;
-        struct mx1_mx2_runtime_data *prtd = runtime->private_data;
-
-        imx_dma_free(prtd->dma_ch);
-
-        snd_pcm_lib_free_pages(substream);
-
-        return 0;
-}
-
-static int mx1_mx2_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
-{
-        struct mx1_mx2_runtime_data *prtd = substream->runtime->private_data;
-        int ret = 0;
-
-        switch (cmd) {
-        case SNDRV_PCM_TRIGGER_START:
-                prtd->tx_spin = 0;
-                /* requested stream startup */
-                prtd->active = 1;
-                pr_debug("%s: starting dma_new_period\n", __func__);
-                ret = dma_new_period(substream);
-                break;
-        case SNDRV_PCM_TRIGGER_STOP:
-                /* requested stream shutdown */
-                pr_debug("%s: stopping dma transfer\n", __func__);
-                ret = audio_stop_dma(substream);
-                break;
-        default:
-                ret = -EINVAL;
-                break;
-        }
-
-        return ret;
-}
-
-static snd_pcm_uframes_t
-mx1_mx2_pcm_pointer(struct snd_pcm_substream *substream)
-{
-        struct snd_pcm_runtime *runtime = substream->runtime;
-        struct mx1_mx2_runtime_data *prtd = runtime->private_data;
-        unsigned int offset = 0;
-
-        /* tx_spin value is used here to check if a transfer is active */
-        if (prtd->tx_spin) {
-                offset = (runtime->period_size * (prtd->periods)) +
-                                                (runtime->period_size >> 1);
-                if (offset >= runtime->buffer_size)
-                        offset = runtime->period_size >> 1;
-        } else {
-                offset = (runtime->period_size * (prtd->periods));
-                if (offset >= runtime->buffer_size)
-                        offset = 0;
-        }
-        pr_debug("%s: pointer offset %x\n", __func__, offset);
-
-        return offset;
-}
-
-static int mx1_mx2_pcm_open(struct snd_pcm_substream *substream)
-{
-        struct snd_pcm_runtime *runtime = substream->runtime;
-        struct mx1_mx2_runtime_data *prtd;
-        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-        struct mx1_mx2_pcm_dma_params *dma_data = rtd->dai->cpu_dai->dma_data;
-        int ret;
-
-        snd_soc_set_runtime_hwparams(substream, &mx1_mx2_pcm_hardware);
-
-        ret = snd_pcm_hw_constraint_integer(runtime,
-                                        SNDRV_PCM_HW_PARAM_PERIODS);
-        if (ret < 0)
-                return ret;
-
-        prtd = kzalloc(sizeof(struct mx1_mx2_runtime_data), GFP_KERNEL);
-        if (prtd == NULL) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        runtime->private_data = prtd;
-
-        if (!dma_data)
-                return -ENODEV;
-
-        prtd->dma_params = dma_data;
-
-        pr_debug("%s: Requesting dma channel (%s)\n", __func__,
-                                                prtd->dma_params->name);
-        prtd->dma_ch = imx_dma_request_by_prio(prtd->dma_params->name,
-                                                DMA_PRIO_HIGH);
-        if (prtd->dma_ch < 0) {
-                printk(KERN_ERR "Error %d requesting dma channel\n", ret);
-                return ret;
-        }
-        imx_dma_config_burstlen(prtd->dma_ch,
-                                prtd->dma_params->watermark_level);
-
-        ret = imx_dma_config_channel(prtd->dma_ch,
-                        prtd->dma_params->per_config,
-                        prtd->dma_params->mem_config,
-                        prtd->dma_params->event_id, 0);
-
-        if (ret) {
-                pr_debug(KERN_ERR "Error %d configuring dma channel %d\n",
-                        ret, prtd->dma_ch);
-                return ret;
-        }
-
-        pr_debug("%s: Setting tx dma callback function\n", __func__);
-        ret = imx_dma_setup_handlers(prtd->dma_ch,
-                                audio_dma_irq, NULL,
-                                (void *)substream);
-        if (ret < 0) {
-                printk(KERN_ERR "Error %d setting dma callback function\n", ret);
-                return ret;
-        }
-        return 0;
-
- out:
-        return ret;
-}
-
-static int mx1_mx2_pcm_close(struct snd_pcm_substream *substream)
-{
-        struct snd_pcm_runtime *runtime = substream->runtime;
-        struct mx1_mx2_runtime_data *prtd = runtime->private_data;
-
-        kfree(prtd);
-
-        return 0;
-}
-
-static int mx1_mx2_pcm_mmap(struct snd_pcm_substream *substream,
-                                struct vm_area_struct *vma)
-{
-        struct snd_pcm_runtime *runtime = substream->runtime;
-        return dma_mmap_writecombine(substream->pcm->card->dev, vma,
-                                     runtime->dma_area,
-                                     runtime->dma_addr,
-                                     runtime->dma_bytes);
-}
-
-static struct snd_pcm_ops mx1_mx2_pcm_ops = {
-        .open           = mx1_mx2_pcm_open,
-        .close          = mx1_mx2_pcm_close,
-        .ioctl          = snd_pcm_lib_ioctl,
-        .hw_params      = mx1_mx2_pcm_hw_params,
-        .hw_free        = mx1_mx2_pcm_hw_free,
-        .prepare        = snd_mx1_mx2_prepare,
-        .trigger        = mx1_mx2_pcm_trigger,
-        .pointer        = mx1_mx2_pcm_pointer,
-        .mmap           = mx1_mx2_pcm_mmap,
-};
-
-static u64 mx1_mx2_pcm_dmamask = 0xffffffff;
-
-static int mx1_mx2_pcm_preallocate_dma_buffer(struct snd_pcm *pcm, int stream)
-{
-        struct snd_pcm_substream *substream = pcm->streams[stream].substream;
-        struct snd_dma_buffer *buf = &substream->dma_buffer;
-        size_t size = mx1_mx2_pcm_hardware.buffer_bytes_max;
-        buf->dev.type = SNDRV_DMA_TYPE_DEV;
-        buf->dev.dev = pcm->card->dev;
-        buf->private_data = NULL;
-
-        /* Reserve uncached-buffered memory area for DMA */
-        buf->area = dma_alloc_writecombine(pcm->card->dev, size,
-                                           &buf->addr, GFP_KERNEL);
-
-        pr_debug("%s: preallocate_dma_buffer: area=%p, addr=%p, size=%d\n",
-                __func__, (void *) buf->area, (void *) buf->addr, size);
-
-        if (!buf->area)
-                return -ENOMEM;
-
-        buf->bytes = size;
-        return 0;
-}
-
-static void mx1_mx2_pcm_free_dma_buffers(struct snd_pcm *pcm)
-{
-        struct snd_pcm_substream *substream;
-        struct snd_dma_buffer *buf;
-        int stream;
-
-        for (stream = 0; stream < 2; stream++) {
-                substream = pcm->streams[stream].substream;
-                if (!substream)
-                        continue;
-
-                buf = &substream->dma_buffer;
-                if (!buf->area)
-                        continue;
-
-                dma_free_writecombine(pcm->card->dev, buf->bytes,
-                                      buf->area, buf->addr);
-                buf->area = NULL;
-        }
-}
-
-static int mx1_mx2_pcm_new(struct snd_card *card, struct snd_soc_dai *dai,
-        struct snd_pcm *pcm)
-{
-        int ret = 0;
-
-        if (!card->dev->dma_mask)
-                card->dev->dma_mask = &mx1_mx2_pcm_dmamask;
-        if (!card->dev->coherent_dma_mask)
-                card->dev->coherent_dma_mask = 0xffffffff;
-
-        if (dai->playback.channels_min) {
-                ret = mx1_mx2_pcm_preallocate_dma_buffer(pcm,
-                        SNDRV_PCM_STREAM_PLAYBACK);
-                pr_debug("%s: preallocate playback buffer\n", __func__);
-                if (ret)
-                        goto out;
-        }
-
-        if (dai->capture.channels_min) {
-                ret = mx1_mx2_pcm_preallocate_dma_buffer(pcm,
-                        SNDRV_PCM_STREAM_CAPTURE);
-                pr_debug("%s: preallocate capture buffer\n", __func__);
-                if (ret)
-                        goto out;
-        }
- out:
-        return ret;
-}
-
-struct snd_soc_platform mx1_mx2_soc_platform = {
-        .name           = "mx1_mx2-audio",
-        .pcm_ops        = &mx1_mx2_pcm_ops,
-        .pcm_new        = mx1_mx2_pcm_new,
-        .pcm_free       = mx1_mx2_pcm_free_dma_buffers,
-};
-EXPORT_SYMBOL_GPL(mx1_mx2_soc_platform);
-
-static int __init mx1_mx2_soc_platform_init(void)
-{
-        return snd_soc_register_platform(&mx1_mx2_soc_platform);
-}
-module_init(mx1_mx2_soc_platform_init);
-
-static void __exit mx1_mx2_soc_platform_exit(void)
-{
-        snd_soc_unregister_platform(&mx1_mx2_soc_platform);
-}
-module_exit(mx1_mx2_soc_platform_exit);
-
-MODULE_AUTHOR("Javier Martin, javier.martin@vista-silicon.com");
-MODULE_DESCRIPTION("Freescale i.MX2x, i.MX1x PCM DMA module");
-MODULE_LICENSE("GPL");
diff --git a/sound/soc/imx/mx1_mx2-pcm.h b/sound/soc/imx/mx1_mx2-pcm.h
deleted file mode 100644
index 2e528106570b..000000000000
--- a/sound/soc/imx/mx1_mx2-pcm.h
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
- * mx1_mx2-pcm.h :- ASoC platform header for Freescale i.MX1x, i.MX2x
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-#ifndef _MX1_MX2_PCM_H
-#define _MX1_MX2_PCM_H
-
-/* DMA information for mx1_mx2 platforms */
-struct mx1_mx2_pcm_dma_params {
-        char *name;                     /* stream identifier */
-        unsigned int transfer_type;     /* READ or WRITE DMA transfer */
-        dma_addr_t per_address;         /* physical address of SSI fifo */
-        int event_id;                   /* fixed DMA number for SSI fifo */
-        int watermark_level;            /* SSI fifo watermark level */
-        int per_config;                 /* DMA Config flags for peripheral */
-        int mem_config;                 /* DMA Config flags for RAM */
- };
-
-/* platform data */
-extern struct snd_soc_platform mx1_mx2_soc_platform;
-
-#endif
diff --git a/sound/soc/imx/mx27vis_wm8974.c b/sound/soc/imx/mx27vis_wm8974.c
deleted file mode 100644
index e4dcb539108a..000000000000
--- a/sound/soc/imx/mx27vis_wm8974.c
+++ /dev/null
@@ -1,317 +0,0 @@
-/*
- * mx27vis_wm8974.c  --  SoC audio for mx27vis
- *
- * Copyright 2009 Vista Silicon S.L.
- * Author: Javier Martin
- *         javier.martin@vista-silicon.com
- *
- *  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 the
- *  Free Software Foundation;  either version 2 of the  License, or (at your
- *  option) any later version.
- *
- */
-
-#include <linux/module.h>
-#include <linux/moduleparam.h>
-#include <linux/device.h>
-#include <linux/i2c.h>
-#include <sound/core.h>
-#include <sound/pcm.h>
-#include <sound/soc.h>
-#include <sound/soc-dapm.h>
-
-
-#include "../codecs/wm8974.h"
-#include "mx1_mx2-pcm.h"
-#include "mxc-ssi.h"
-#include <mach/gpio.h>
-#include <mach/iomux.h>
-
-#define IGNORED_ARG 0
-
-
-static struct snd_soc_card mx27vis;
-
-/**
-  * This function connects SSI1 (HPCR1) as slave to
-  * SSI1 external signals (PPCR1)
-  * As slave, HPCR1 must set TFSDIR and TCLKDIR as inputs from
-  * port 4
-  */
-void audmux_connect_1_4(void)
-{
-        pr_debug("AUDMUX: normal operation mode\n");
-        /* Reset HPCR1 and PPCR1 */
-
-        DAM_HPCR1 = 0x00000000;
-        DAM_PPCR1 = 0x00000000;
-
-        /* set to synchronous */
-        DAM_HPCR1 |= AUDMUX_HPCR_SYN;
-        DAM_PPCR1 |= AUDMUX_PPCR_SYN;
-
-
-        /* set Rx sources 1 <--> 4 */
-        DAM_HPCR1 |= AUDMUX_HPCR_RXDSEL(3); /* port 4 */
-        DAM_PPCR1 |= AUDMUX_PPCR_RXDSEL(0); /* port 1 */
-
-        /* set Tx frame and Clock direction and source  4 --> 1 output */
-        DAM_HPCR1 |= AUDMUX_HPCR_TFSDIR | AUDMUX_HPCR_TCLKDIR;
-        DAM_HPCR1 |= AUDMUX_HPCR_TFCSEL(3); /* TxDS and TxCclk from port 4 */
-
-        return;
-}
-
-static int mx27vis_hifi_hw_params(struct snd_pcm_substream *substream,
-        struct snd_pcm_hw_params *params)
-{
-        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-        struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
-        struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
-        unsigned int pll_out = 0, bclk = 0, fmt = 0, mclk = 0;
-        int ret = 0;
-
-        /*
-         * The WM8974 is better at generating accurate audio clocks than the
-         * MX27 SSI controller, so we will use it as master when we can.
-         */
-        switch (params_rate(params)) {
-        case 8000:
-                fmt = SND_SOC_DAIFMT_CBM_CFM;
-                mclk = WM8974_MCLKDIV_12;
-                pll_out = 24576000;
-                break;
-        case 16000:
-                fmt = SND_SOC_DAIFMT_CBM_CFM;
-                pll_out = 12288000;
-                break;
-        case 48000:
-                fmt = SND_SOC_DAIFMT_CBM_CFM;
-                bclk = WM8974_BCLKDIV_4;
-                pll_out = 12288000;
-                break;
-        case 96000:
-                fmt = SND_SOC_DAIFMT_CBM_CFM;
-                bclk = WM8974_BCLKDIV_2;
-                pll_out = 12288000;
-                break;
-        case 11025:
-                fmt = SND_SOC_DAIFMT_CBM_CFM;
-                bclk = WM8974_BCLKDIV_16;
-                pll_out = 11289600;
-                break;
-        case 22050:
-                fmt = SND_SOC_DAIFMT_CBM_CFM;
-                bclk = WM8974_BCLKDIV_8;
-                pll_out = 11289600;
-                break;
-        case 44100:
-                fmt = SND_SOC_DAIFMT_CBM_CFM;
-                bclk = WM8974_BCLKDIV_4;
-                mclk = WM8974_MCLKDIV_2;
-                pll_out = 11289600;
-                break;
-        case 88200:
-                fmt = SND_SOC_DAIFMT_CBM_CFM;
-                bclk = WM8974_BCLKDIV_2;
-                pll_out = 11289600;
-                break;
-        }
-
-        /* set codec DAI configuration */
-        ret = codec_dai->ops->set_fmt(codec_dai,
-                SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_IF |
-                SND_SOC_DAIFMT_SYNC | fmt);
-        if (ret < 0) {
-                printk(KERN_ERR "Error from codec DAI configuration\n");
-                return ret;
-        }
-
-        /* set cpu DAI configuration */
-        ret = cpu_dai->ops->set_fmt(cpu_dai,
-                SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
-                SND_SOC_DAIFMT_SYNC | fmt);
-        if (ret < 0) {
-                printk(KERN_ERR "Error from cpu DAI configuration\n");
-                return ret;
-        }
-
-        /* Put DC field of STCCR to 1 (not zero) */
-        ret = cpu_dai->ops->set_tdm_slot(cpu_dai, 0, 2);
-
-        /* set the SSI system clock as input */
-        ret = cpu_dai->ops->set_sysclk(cpu_dai, IMX_SSP_SYS_CLK, 0,
-                SND_SOC_CLOCK_IN);
-        if (ret < 0) {
-                printk(KERN_ERR "Error when setting system SSI clk\n");
-                return ret;
-        }
-
-        /* set codec BCLK division for sample rate */
-        ret = codec_dai->ops->set_clkdiv(codec_dai, WM8974_BCLKDIV, bclk);
-        if (ret < 0) {
-                printk(KERN_ERR "Error when setting BCLK division\n");
-                return ret;
-        }
-
-
-        /* codec PLL input is 25 MHz */
-        ret = codec_dai->ops->set_pll(codec_dai, IGNORED_ARG,
-                                        25000000, pll_out);
-        if (ret < 0) {
-                printk(KERN_ERR "Error when setting PLL input\n");
-                return ret;
-        }
-
-        /*set codec MCLK division for sample rate */
-        ret = codec_dai->ops->set_clkdiv(codec_dai, WM8974_MCLKDIV, mclk);
-        if (ret < 0) {
-                printk(KERN_ERR "Error when setting MCLK division\n");
-                return ret;
-        }
-
-        return 0;
-}
-
-static int mx27vis_hifi_hw_free(struct snd_pcm_substream *substream)
-{
-        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-        struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
-
-        /* disable the PLL */
-        return codec_dai->ops->set_pll(codec_dai, IGNORED_ARG, 0, 0);
-}
-
-/*
- * mx27vis WM8974 HiFi DAI opserations.
- */
-static struct snd_soc_ops mx27vis_hifi_ops = {
-        .hw_params = mx27vis_hifi_hw_params,
-        .hw_free = mx27vis_hifi_hw_free,
-};
-
-
-static int mx27vis_suspend(struct platform_device *pdev, pm_message_t state)
-{
-        return 0;
-}
-
-static int mx27vis_resume(struct platform_device *pdev)
-{
-        return 0;
-}
-
-static int mx27vis_probe(struct platform_device *pdev)
-{
-        int ret = 0;
-
-        ret = get_ssi_clk(0, &pdev->dev);
-
-        if (ret < 0) {
-                printk(KERN_ERR "%s: cant get ssi clock\n", __func__);
-                return ret;
-        }
-
-
-        return 0;
-}
-
-static int mx27vis_remove(struct platform_device *pdev)
-{
-        put_ssi_clk(0);
-        return 0;
-}
-
-static struct snd_soc_dai_link mx27vis_dai[] = {
-{ /* Hifi Playback*/
-        .name = "WM8974",
-        .stream_name = "WM8974 HiFi",
-        .cpu_dai = &imx_ssi_pcm_dai[0],
-        .codec_dai = &wm8974_dai,
-        .ops = &mx27vis_hifi_ops,
-},
-};
-
-static struct snd_soc_card mx27vis = {
-        .name = "mx27vis",
-        .platform = &mx1_mx2_soc_platform,
-        .probe = mx27vis_probe,
-        .remove = mx27vis_remove,
-        .suspend_pre = mx27vis_suspend,
-        .resume_post = mx27vis_resume,
-        .dai_link = mx27vis_dai,
-        .num_links = ARRAY_SIZE(mx27vis_dai),
-};
-
-static struct snd_soc_device mx27vis_snd_devdata = {
-        .card = &mx27vis,
-        .codec_dev = &soc_codec_dev_wm8974,
-};
-
-static struct platform_device *mx27vis_snd_device;
-
-/* Temporal definition of board specific behaviour */
-void gpio_ssi_active(int ssi_num)
-{
-        int ret = 0;
-
-        unsigned int ssi1_pins[] = {
-                PC20_PF_SSI1_FS,
-                PC21_PF_SSI1_RXD,
-                PC22_PF_SSI1_TXD,
-                PC23_PF_SSI1_CLK,
-        };
-        unsigned int ssi2_pins[] = {
-                PC24_PF_SSI2_FS,
-                PC25_PF_SSI2_RXD,
-                PC26_PF_SSI2_TXD,
-                PC27_PF_SSI2_CLK,
-        };
-        if (ssi_num == 0)
-                ret = mxc_gpio_setup_multiple_pins(ssi1_pins,
-                                ARRAY_SIZE(ssi1_pins), "USB OTG");
-        else
-                ret = mxc_gpio_setup_multiple_pins(ssi2_pins,
-                                ARRAY_SIZE(ssi2_pins), "USB OTG");
-        if (ret)
-                printk(KERN_ERR "Error requesting ssi %x pins\n", ssi_num);
-}
-
-
-static int __init mx27vis_init(void)
-{
-        int ret;
-
-        mx27vis_snd_device = platform_device_alloc("soc-audio", -1);
-        if (!mx27vis_snd_device)
-                return -ENOMEM;
-
-        platform_set_drvdata(mx27vis_snd_device, &mx27vis_snd_devdata);
-        mx27vis_snd_devdata.dev = &mx27vis_snd_device->dev;
-        ret = platform_device_add(mx27vis_snd_device);
-
-        if (ret) {
-                printk(KERN_ERR "ASoC: Platform device allocation failed\n");
-                platform_device_put(mx27vis_snd_device);
-        }
-
-        /* WM8974 uses SSI1 (HPCR1) via AUDMUX port 4 for audio (PPCR1) */
-        gpio_ssi_active(0);
-        audmux_connect_1_4();
-
-        return ret;
-}
-
-static void __exit mx27vis_exit(void)
-{
-        /* We should call some "ssi_gpio_inactive()" properly */
-}
-
-module_init(mx27vis_init);
-module_exit(mx27vis_exit);
-
-
-MODULE_AUTHOR("Javier Martin, javier.martin@vista-silicon.com");
-MODULE_DESCRIPTION("ALSA SoC WM8974 mx27vis");
-MODULE_LICENSE("GPL");
diff --git a/sound/soc/imx/mxc-ssi.c b/sound/soc/imx/mxc-ssi.c
deleted file mode 100644
index ccdefe60e752..000000000000
--- a/sound/soc/imx/mxc-ssi.c
+++ /dev/null
@@ -1,860 +0,0 @@
-/*
- * mxc-ssi.c  --  SSI driver for Freescale IMX
- *
- * Copyright 2006 Wolfson Microelectronics PLC.
- * Author: Liam Girdwood
- *         liam.girdwood@wolfsonmicro.com or linux@wolfsonmicro.com
- *
- *  Based on mxc-alsa-mc13783 (C) 2006 Freescale.
- *
- *  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 the
- *  Free Software Foundation;  either version 2 of the  License, or (at your
- *  option) any later version.
- *
- * TODO:
- *   Need to rework SSI register defs when new defs go into mainline.
- *   Add support for TDM and FIFO 1.
- *   Add support for i.mx3x DMA interface.
- *
- */
-
-
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/platform_device.h>
-#include <linux/slab.h>
-#include <linux/dma-mapping.h>
-#include <linux/clk.h>
-#include <sound/core.h>
-#include <sound/pcm.h>
-#include <sound/pcm_params.h>
-#include <sound/soc.h>
-#include <mach/dma-mx1-mx2.h>
-#include <asm/mach-types.h>
-
-#include "mxc-ssi.h"
-#include "mx1_mx2-pcm.h"
-
-#define SSI1_PORT       0
-#define SSI2_PORT       1
-
-static int ssi_active[2] = {0, 0};
-
-/* DMA information for mx1_mx2 platforms */
-static struct mx1_mx2_pcm_dma_params imx_ssi1_pcm_stereo_out0 = {
-        .name                   = "SSI1 PCM Stereo out 0",
-        .transfer_type = DMA_MODE_WRITE,
-        .per_address = SSI1_BASE_ADDR + STX0,
-        .event_id = DMA_REQ_SSI1_TX0,
-        .watermark_level = TXFIFO_WATERMARK,
-        .per_config = IMX_DMA_MEMSIZE_16 | IMX_DMA_TYPE_FIFO,
-        .mem_config = IMX_DMA_MEMSIZE_32 | IMX_DMA_TYPE_LINEAR,
-};
-
-static struct mx1_mx2_pcm_dma_params imx_ssi1_pcm_stereo_out1 = {
-        .name                   = "SSI1 PCM Stereo out 1",
-        .transfer_type = DMA_MODE_WRITE,
-        .per_address = SSI1_BASE_ADDR + STX1,
-        .event_id = DMA_REQ_SSI1_TX1,
-        .watermark_level = TXFIFO_WATERMARK,
-        .per_config = IMX_DMA_MEMSIZE_16 | IMX_DMA_TYPE_FIFO,
-        .mem_config = IMX_DMA_MEMSIZE_32 | IMX_DMA_TYPE_LINEAR,
-};
-
-static struct mx1_mx2_pcm_dma_params imx_ssi1_pcm_stereo_in0 = {
-        .name                   = "SSI1 PCM Stereo in 0",
-        .transfer_type = DMA_MODE_READ,
-        .per_address = SSI1_BASE_ADDR + SRX0,
-        .event_id = DMA_REQ_SSI1_RX0,
-        .watermark_level = RXFIFO_WATERMARK,
-        .per_config = IMX_DMA_MEMSIZE_16 | IMX_DMA_TYPE_FIFO,
-        .mem_config = IMX_DMA_MEMSIZE_32 | IMX_DMA_TYPE_LINEAR,
-};
-
-static struct mx1_mx2_pcm_dma_params imx_ssi1_pcm_stereo_in1 = {
-        .name                   = "SSI1 PCM Stereo in 1",
-        .transfer_type = DMA_MODE_READ,
-        .per_address = SSI1_BASE_ADDR + SRX1,
-        .event_id = DMA_REQ_SSI1_RX1,
-        .watermark_level = RXFIFO_WATERMARK,
-        .per_config = IMX_DMA_MEMSIZE_16 | IMX_DMA_TYPE_FIFO,
-        .mem_config = IMX_DMA_MEMSIZE_32 | IMX_DMA_TYPE_LINEAR,
-};
-
-static struct mx1_mx2_pcm_dma_params imx_ssi2_pcm_stereo_out0 = {
-        .name                   = "SSI2 PCM Stereo out 0",
-        .transfer_type = DMA_MODE_WRITE,
-        .per_address = SSI2_BASE_ADDR + STX0,
-        .event_id = DMA_REQ_SSI2_TX0,
-        .watermark_level = TXFIFO_WATERMARK,
-        .per_config = IMX_DMA_MEMSIZE_16 | IMX_DMA_TYPE_FIFO,
-        .mem_config = IMX_DMA_MEMSIZE_32 | IMX_DMA_TYPE_LINEAR,
-};
-
-static struct mx1_mx2_pcm_dma_params imx_ssi2_pcm_stereo_out1 = {
-        .name                   = "SSI2 PCM Stereo out 1",
-        .transfer_type = DMA_MODE_WRITE,
-        .per_address = SSI2_BASE_ADDR + STX1,
-        .event_id = DMA_REQ_SSI2_TX1,
-        .watermark_level = TXFIFO_WATERMARK,
-        .per_config = IMX_DMA_MEMSIZE_16 | IMX_DMA_TYPE_FIFO,
-        .mem_config = IMX_DMA_MEMSIZE_32 | IMX_DMA_TYPE_LINEAR,
-};
-
-static struct mx1_mx2_pcm_dma_params imx_ssi2_pcm_stereo_in0 = {
-        .name                   = "SSI2 PCM Stereo in 0",
-        .transfer_type = DMA_MODE_READ,
-        .per_address = SSI2_BASE_ADDR + SRX0,
-        .event_id = DMA_REQ_SSI2_RX0,
-        .watermark_level = RXFIFO_WATERMARK,
-        .per_config = IMX_DMA_MEMSIZE_16 | IMX_DMA_TYPE_FIFO,
-        .mem_config = IMX_DMA_MEMSIZE_32 | IMX_DMA_TYPE_LINEAR,
-};
-
-static struct mx1_mx2_pcm_dma_params imx_ssi2_pcm_stereo_in1 = {
-        .name                   = "SSI2 PCM Stereo in 1",
-        .transfer_type = DMA_MODE_READ,
-        .per_address = SSI2_BASE_ADDR + SRX1,
-        .event_id = DMA_REQ_SSI2_RX1,
-        .watermark_level = RXFIFO_WATERMARK,
-        .per_config = IMX_DMA_MEMSIZE_16 | IMX_DMA_TYPE_FIFO,
-        .mem_config = IMX_DMA_MEMSIZE_32 | IMX_DMA_TYPE_LINEAR,
-};
-
-static struct clk *ssi_clk0, *ssi_clk1;
-
-int get_ssi_clk(int ssi, struct device *dev)
-{
-        switch (ssi) {
-        case 0:
-                ssi_clk0 = clk_get(dev, "ssi1");
-                if (IS_ERR(ssi_clk0))
-                        return PTR_ERR(ssi_clk0);
-                return 0;
-        case 1:
-                ssi_clk1 = clk_get(dev, "ssi2");
-                if (IS_ERR(ssi_clk1))
-                        return PTR_ERR(ssi_clk1);
-                return 0;
-        default:
-                return -EINVAL;
-        }
-}
-EXPORT_SYMBOL(get_ssi_clk);
-
-void put_ssi_clk(int ssi)
-{
-        switch (ssi) {
-        case 0:
-                clk_put(ssi_clk0);
-                ssi_clk0 = NULL;
-                break;
-        case 1:
-                clk_put(ssi_clk1);
-                ssi_clk1 = NULL;
-                break;
-        }
-}
-EXPORT_SYMBOL(put_ssi_clk);
-
-/*
- * SSI system clock configuration.
- * Should only be called when port is inactive (i.e. SSIEN = 0).
- */
-static int imx_ssi_set_dai_sysclk(struct snd_soc_dai *cpu_dai,
-        int clk_id, unsigned int freq, int dir)
-{
-        u32 scr;
-
-        if (cpu_dai->id == IMX_DAI_SSI0 || cpu_dai->id == IMX_DAI_SSI2) {
-                scr = SSI1_SCR;
-                pr_debug("%s: SCR for SSI1 is %x\n", __func__, scr);
-        } else {
-                scr = SSI2_SCR;
-                pr_debug("%s: SCR for SSI2 is %x\n", __func__, scr);
-        }
-
-        if (scr & SSI_SCR_SSIEN) {
-                printk(KERN_WARNING "Warning ssi already enabled\n");
-                return 0;
-        }
-
-        switch (clk_id) {
-        case IMX_SSP_SYS_CLK:
-                if (dir == SND_SOC_CLOCK_OUT) {
-                        scr |= SSI_SCR_SYS_CLK_EN;
-                        pr_debug("%s: clk of is output\n", __func__);
-                } else {
-                        scr &= ~SSI_SCR_SYS_CLK_EN;
-                        pr_debug("%s: clk of is input\n", __func__);
-                }
-                break;
-        default:
-                return -EINVAL;
-        }
-
-        if (cpu_dai->id == IMX_DAI_SSI0 || cpu_dai->id == IMX_DAI_SSI2) {
-                pr_debug("%s: writeback of SSI1_SCR\n", __func__);
-                SSI1_SCR = scr;
-        } else {
-                pr_debug("%s: writeback of SSI2_SCR\n", __func__);
-                SSI2_SCR = scr;
-        }
-
-        return 0;
-}
-
-/*
- * SSI Clock dividers
- * Should only be called when port is inactive (i.e. SSIEN = 0).
- */
-static int imx_ssi_set_dai_clkdiv(struct snd_soc_dai *cpu_dai,
-        int div_id, int div)
-{
-        u32 stccr, srccr;
-
-        pr_debug("%s\n", __func__);
-        if (cpu_dai->id == IMX_DAI_SSI0 || cpu_dai->id == IMX_DAI_SSI2) {
-                if (SSI1_SCR & SSI_SCR_SSIEN)
-                        return 0;
-                srccr = SSI1_STCCR;
-                stccr = SSI1_STCCR;
-        } else {
-                if (SSI2_SCR & SSI_SCR_SSIEN)
-                        return 0;
-                srccr = SSI2_STCCR;
-                stccr = SSI2_STCCR;
-        }
-
-        switch (div_id) {
-        case IMX_SSI_TX_DIV_2:
-                stccr &= ~SSI_STCCR_DIV2;
-                stccr |= div;
-                break;
-        case IMX_SSI_TX_DIV_PSR:
-                stccr &= ~SSI_STCCR_PSR;
-                stccr |= div;
-                break;
-        case IMX_SSI_TX_DIV_PM:
-                stccr &= ~0xff;
-                stccr |= SSI_STCCR_PM(div);
-                break;
-        case IMX_SSI_RX_DIV_2:
-                stccr &= ~SSI_STCCR_DIV2;
-                stccr |= div;
-                break;
-        case IMX_SSI_RX_DIV_PSR:
-                stccr &= ~SSI_STCCR_PSR;
-                stccr |= div;
-                break;
-        case IMX_SSI_RX_DIV_PM:
-                stccr &= ~0xff;
-                stccr |= SSI_STCCR_PM(div);
-                break;
-        default:
-                return -EINVAL;
-        }
-
-        if (cpu_dai->id == IMX_DAI_SSI0 || cpu_dai->id == IMX_DAI_SSI2) {
-                SSI1_STCCR = stccr;
-                SSI1_SRCCR = srccr;
-        } else {
-                SSI2_STCCR = stccr;
-                SSI2_SRCCR = srccr;
-        }
-        return 0;
-}
-
-/*
- * SSI Network Mode or TDM slots configuration.
- * Should only be called when port is inactive (i.e. SSIEN = 0).
- */
-static int imx_ssi_set_dai_tdm_slot(struct snd_soc_dai *cpu_dai,
-        unsigned int mask, int slots)
-{
-        u32 stmsk, srmsk, stccr;
-
-        if (cpu_dai->id == IMX_DAI_SSI0 || cpu_dai->id == IMX_DAI_SSI2) {
-                if (SSI1_SCR & SSI_SCR_SSIEN) {
-                        printk(KERN_WARNING "Warning ssi already enabled\n");
-                        return 0;
-                }
-                stccr = SSI1_STCCR;
-        } else {
-                if (SSI2_SCR & SSI_SCR_SSIEN) {
-                        printk(KERN_WARNING "Warning ssi already enabled\n");
-                        return 0;
-                }
-                stccr = SSI2_STCCR;
-        }
-
-        stmsk = srmsk = mask;
-        stccr &= ~SSI_STCCR_DC_MASK;
-        stccr |= SSI_STCCR_DC(slots - 1);
-
-        if (cpu_dai->id == IMX_DAI_SSI0 || cpu_dai->id == IMX_DAI_SSI2) {
-                SSI1_STMSK = stmsk;
-                SSI1_SRMSK = srmsk;
-                SSI1_SRCCR = SSI1_STCCR = stccr;
-        } else {
-                SSI2_STMSK = stmsk;
-                SSI2_SRMSK = srmsk;
-                SSI2_SRCCR = SSI2_STCCR = stccr;
-        }
-
-        return 0;
-}
-
-/*
- * SSI DAI format configuration.
- * Should only be called when port is inactive (i.e. SSIEN = 0).
- * Note: We don't use the I2S modes but instead manually configure the
- * SSI for I2S.
- */
-static int imx_ssi_set_dai_fmt(struct snd_soc_dai *cpu_dai,
-                unsigned int fmt)
-{
-        u32 stcr = 0, srcr = 0, scr;
-
-        /*
-         * This is done to avoid this function to modify
-         * previous set values in stcr
-         */
-        stcr = SSI1_STCR;
-
-        if (cpu_dai->id == IMX_DAI_SSI0 || cpu_dai->id == IMX_DAI_SSI2)
-                scr = SSI1_SCR & ~(SSI_SCR_SYN | SSI_SCR_NET);
-        else
-                scr = SSI2_SCR & ~(SSI_SCR_SYN | SSI_SCR_NET);
-
-        if (scr & SSI_SCR_SSIEN) {
-                printk(KERN_WARNING "Warning ssi already enabled\n");
-                return 0;
-        }
-
-        /* DAI mode */
-        switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
-        case SND_SOC_DAIFMT_I2S:
-                /* data on rising edge of bclk, frame low 1clk before data */
-                stcr |= SSI_STCR_TFSI | SSI_STCR_TEFS | SSI_STCR_TXBIT0;
-                srcr |= SSI_SRCR_RFSI | SSI_SRCR_REFS | SSI_SRCR_RXBIT0;
-                break;
-        case SND_SOC_DAIFMT_LEFT_J:
-                /* data on rising edge of bclk, frame high with data */
-                stcr |= SSI_STCR_TXBIT0;
-                srcr |= SSI_SRCR_RXBIT0;
-                break;
-        case SND_SOC_DAIFMT_DSP_B:
-                /* data on rising edge of bclk, frame high with data */
-                stcr |= SSI_STCR_TFSL;
-                srcr |= SSI_SRCR_RFSL;
-                break;
-        case SND_SOC_DAIFMT_DSP_A:
-                /* data on rising edge of bclk, frame high 1clk before data */
-                stcr |= SSI_STCR_TFSL | SSI_STCR_TEFS;
-                srcr |= SSI_SRCR_RFSL | SSI_SRCR_REFS;
-                break;
-        }
-
-        /* DAI clock inversion */
-        switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
-        case SND_SOC_DAIFMT_IB_IF:
-                stcr |= SSI_STCR_TFSI;
-                stcr &= ~SSI_STCR_TSCKP;
-                srcr |= SSI_SRCR_RFSI;
-                srcr &= ~SSI_SRCR_RSCKP;
-                break;
-        case SND_SOC_DAIFMT_IB_NF:
-                stcr &= ~(SSI_STCR_TSCKP | SSI_STCR_TFSI);
-                srcr &= ~(SSI_SRCR_RSCKP | SSI_SRCR_RFSI);
-                break;
-        case SND_SOC_DAIFMT_NB_IF:
-                stcr |= SSI_STCR_TFSI | SSI_STCR_TSCKP;
-                srcr |= SSI_SRCR_RFSI | SSI_SRCR_RSCKP;
-                break;
-        case SND_SOC_DAIFMT_NB_NF:
-                stcr &= ~SSI_STCR_TFSI;
-                stcr |= SSI_STCR_TSCKP;
-                srcr &= ~SSI_SRCR_RFSI;
-                srcr |= SSI_SRCR_RSCKP;
-                break;
-        }
-
-        /* DAI clock master masks */
-        switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
-        case SND_SOC_DAIFMT_CBS_CFS:
-                stcr |= SSI_STCR_TFDIR | SSI_STCR_TXDIR;
-                srcr |= SSI_SRCR_RFDIR | SSI_SRCR_RXDIR;
-                break;
-        case SND_SOC_DAIFMT_CBM_CFS:
-                stcr |= SSI_STCR_TFDIR;
-                srcr |= SSI_SRCR_RFDIR;
-                break;
-        case SND_SOC_DAIFMT_CBS_CFM:
-                stcr |= SSI_STCR_TXDIR;
-                srcr |= SSI_SRCR_RXDIR;
-                break;
-        }
-
-        if (cpu_dai->id == IMX_DAI_SSI0 || cpu_dai->id == IMX_DAI_SSI2) {
-                SSI1_STCR = stcr;
-                SSI1_SRCR = srcr;
-                SSI1_SCR = scr;
-        } else {
-                SSI2_STCR = stcr;
-                SSI2_SRCR = srcr;
-                SSI2_SCR = scr;
-        }
-
-        return 0;
-}
-
-static int imx_ssi_startup(struct snd_pcm_substream *substream,
-                        struct snd_soc_dai *dai)
-{
-        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-        struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
-
-        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
-                /* set up TX DMA params */
-                switch (cpu_dai->id) {
-                case IMX_DAI_SSI0:
-                        cpu_dai->dma_data = &imx_ssi1_pcm_stereo_out0;
-                        break;
-                case IMX_DAI_SSI1:
-                        cpu_dai->dma_data = &imx_ssi1_pcm_stereo_out1;
-                        break;
-                case IMX_DAI_SSI2:
-                        cpu_dai->dma_data = &imx_ssi2_pcm_stereo_out0;
-                        break;
-                case IMX_DAI_SSI3:
-                        cpu_dai->dma_data = &imx_ssi2_pcm_stereo_out1;
-                }
-                pr_debug("%s: (playback)\n", __func__);
-        } else {
-                /* set up RX DMA params */
-                switch (cpu_dai->id) {
-                case IMX_DAI_SSI0:
-                        cpu_dai->dma_data = &imx_ssi1_pcm_stereo_in0;
-                        break;
-                case IMX_DAI_SSI1:
-                        cpu_dai->dma_data = &imx_ssi1_pcm_stereo_in1;
-                        break;
-                case IMX_DAI_SSI2:
-                        cpu_dai->dma_data = &imx_ssi2_pcm_stereo_in0;
-                        break;
-                case IMX_DAI_SSI3:
-                        cpu_dai->dma_data = &imx_ssi2_pcm_stereo_in1;
-                }
-                pr_debug("%s: (capture)\n", __func__);
-        }
-
-        /*
-         * we cant really change any SSI values after SSI is enabled
-         * need to fix in software for max flexibility - lrg
-         */
-        if (cpu_dai->active) {
-                printk(KERN_WARNING "Warning ssi already enabled\n");
-                return 0;
-        }
-
-        /* reset the SSI port - Sect 45.4.4 */
-        if (cpu_dai->id == IMX_DAI_SSI0 || cpu_dai->id == IMX_DAI_SSI2) {
-
-                if (!ssi_clk0)
-                        return -EINVAL;
-
-                if (ssi_active[SSI1_PORT]++) {
-                        pr_debug("%s: exit before reset\n", __func__);
-                        return 0;
-                }
-
-                /* SSI1 Reset */
-                SSI1_SCR = 0;
-
-                SSI1_SFCSR = SSI_SFCSR_RFWM1(RXFIFO_WATERMARK) |
-                        SSI_SFCSR_RFWM0(RXFIFO_WATERMARK) |
-                        SSI_SFCSR_TFWM1(TXFIFO_WATERMARK) |
-                        SSI_SFCSR_TFWM0(TXFIFO_WATERMARK);
-        } else {
-
-                if (!ssi_clk1)
-                        return -EINVAL;
-
-                if (ssi_active[SSI2_PORT]++) {
-                        pr_debug("%s: exit before reset\n", __func__);
-                        return 0;
-                }
-
-                /* SSI2 Reset */
-                SSI2_SCR = 0;
-
-                SSI2_SFCSR = SSI_SFCSR_RFWM1(RXFIFO_WATERMARK) |
-                        SSI_SFCSR_RFWM0(RXFIFO_WATERMARK) |
-                        SSI_SFCSR_TFWM1(TXFIFO_WATERMARK) |
-                        SSI_SFCSR_TFWM0(TXFIFO_WATERMARK);
-        }
-
-        return 0;
-}
-
-int imx_ssi_hw_tx_params(struct snd_pcm_substream *substream,
-                                struct snd_pcm_hw_params *params)
-{
-        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-        struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
-        u32 stccr, stcr, sier;
-
-        pr_debug("%s\n", __func__);
-
-        if (cpu_dai->id == IMX_DAI_SSI0 || cpu_dai->id == IMX_DAI_SSI2) {
-                stccr = SSI1_STCCR & ~SSI_STCCR_WL_MASK;
-                stcr = SSI1_STCR;
-                sier = SSI1_SIER;
-        } else {
-                stccr = SSI2_STCCR & ~SSI_STCCR_WL_MASK;
-                stcr = SSI2_STCR;
-                sier = SSI2_SIER;
-        }
-
-        /* DAI data (word) size */
-        switch (params_format(params)) {
-        case SNDRV_PCM_FORMAT_S16_LE:
-                stccr |= SSI_STCCR_WL(16);
-                break;
-        case SNDRV_PCM_FORMAT_S20_3LE:
-                stccr |= SSI_STCCR_WL(20);
-                break;
-        case SNDRV_PCM_FORMAT_S24_LE:
-                stccr |= SSI_STCCR_WL(24);
-                break;
-        }
-
-        /* enable interrupts */
-        if (cpu_dai->id == IMX_DAI_SSI0 || cpu_dai->id == IMX_DAI_SSI2)
-                stcr |= SSI_STCR_TFEN0;
-        else
-                stcr |= SSI_STCR_TFEN1;
-        sier |= SSI_SIER_TDMAE;
-
-        if (cpu_dai->id == IMX_DAI_SSI0 || cpu_dai->id == IMX_DAI_SSI2) {
-                SSI1_STCR = stcr;
-                SSI1_STCCR = stccr;
-                SSI1_SIER = sier;
-        } else {
-                SSI2_STCR = stcr;
-                SSI2_STCCR = stccr;
-                SSI2_SIER = sier;
-        }
-
-        return 0;
-}
-
-int imx_ssi_hw_rx_params(struct snd_pcm_substream *substream,
-                                struct snd_pcm_hw_params *params)
-{
-        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-        struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
-        u32 srccr, srcr, sier;
-
-        pr_debug("%s\n", __func__);
-
-        if (cpu_dai->id == IMX_DAI_SSI0 || cpu_dai->id == IMX_DAI_SSI2) {
-                srccr = SSI1_SRCCR & ~SSI_SRCCR_WL_MASK;
-                srcr = SSI1_SRCR;
-                sier = SSI1_SIER;
-        } else {
-                srccr = SSI2_SRCCR & ~SSI_SRCCR_WL_MASK;
-                srcr = SSI2_SRCR;
-                sier = SSI2_SIER;
-        }
-
-        /* DAI data (word) size */
-        switch (params_format(params)) {
-        case SNDRV_PCM_FORMAT_S16_LE:
-                srccr |= SSI_SRCCR_WL(16);
-                break;
-        case SNDRV_PCM_FORMAT_S20_3LE:
-                srccr |= SSI_SRCCR_WL(20);
-                break;
-        case SNDRV_PCM_FORMAT_S24_LE:
-                srccr |= SSI_SRCCR_WL(24);
-                break;
-        }
-
-        /* enable interrupts */
-        if (cpu_dai->id == IMX_DAI_SSI0 || cpu_dai->id == IMX_DAI_SSI2)
-                srcr |= SSI_SRCR_RFEN0;
-        else
-                srcr |= SSI_SRCR_RFEN1;
-        sier |= SSI_SIER_RDMAE;
-
-        if (cpu_dai->id == IMX_DAI_SSI0 || cpu_dai->id == IMX_DAI_SSI2) {
-                SSI1_SRCR = srcr;
-                SSI1_SRCCR = srccr;
-                SSI1_SIER = sier;
-        } else {
-                SSI2_SRCR = srcr;
-                SSI2_SRCCR = srccr;
-                SSI2_SIER = sier;
-        }
-
-        return 0;
-}
-
-/*
- * Should only be called when port is inactive (i.e. SSIEN = 0),
- * although can be called multiple times by upper layers.
- */
-int imx_ssi_hw_params(struct snd_pcm_substream *substream,
-                                struct snd_pcm_hw_params *params,
-                                struct snd_soc_dai *dai)
-{
-        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-        struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
-
-        int ret;
-
-        /* cant change any parameters when SSI is running */
-        if (cpu_dai->id == IMX_DAI_SSI0 || cpu_dai->id == IMX_DAI_SSI2) {
-                if (SSI1_SCR & SSI_SCR_SSIEN) {
-                        printk(KERN_WARNING "Warning ssi already enabled\n");
-                        return 0;
-                }
-        } else {
-                if (SSI2_SCR & SSI_SCR_SSIEN) {
-                        printk(KERN_WARNING "Warning ssi already enabled\n");
-                        return 0;
-                }
-        }
-
-        /*
-         * Configure both tx and rx params with the same settings. This is
-         * really a harware restriction because SSI must be disabled until
-         * we can change those values. If there is an active audio stream in
-         * one direction, enabling the other direction with different
-         * settings would mean disturbing the running one.
-         */
-        ret = imx_ssi_hw_tx_params(substream, params);
-        if (ret < 0)
-                return ret;
-        return imx_ssi_hw_rx_params(substream, params);
-}
-
-int imx_ssi_prepare(struct snd_pcm_substream *substream,
-                        struct snd_soc_dai *dai)
-{
-        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-        struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
-        int ret;
-
-        pr_debug("%s\n", __func__);
-
-        /* Enable clks here to follow SSI recommended init sequence */
-        if (cpu_dai->id == IMX_DAI_SSI0 || cpu_dai->id == IMX_DAI_SSI2) {
-                ret = clk_enable(ssi_clk0);
-                if (ret < 0)
-                        printk(KERN_ERR "Unable to enable ssi_clk0\n");
-        } else {
-                ret = clk_enable(ssi_clk1);
-                if (ret < 0)
-                        printk(KERN_ERR "Unable to enable ssi_clk1\n");
-        }
-
-        return 0;
-}
-
-static int imx_ssi_trigger(struct snd_pcm_substream *substream, int cmd,
-                        struct snd_soc_dai *dai)
-{
-        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-        struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
-        u32 scr;
-
-        if (cpu_dai->id == IMX_DAI_SSI0 || cpu_dai->id == IMX_DAI_SSI2)
-                scr = SSI1_SCR;
-        else
-                scr = SSI2_SCR;
-
-        switch (cmd) {
-        case SNDRV_PCM_TRIGGER_START:
-        case SNDRV_PCM_TRIGGER_RESUME:
-        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
-                if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
-                        scr |= SSI_SCR_TE | SSI_SCR_SSIEN;
-                else
-                        scr |= SSI_SCR_RE | SSI_SCR_SSIEN;
-                break;
-        case SNDRV_PCM_TRIGGER_SUSPEND:
-        case SNDRV_PCM_TRIGGER_STOP:
-        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
-                if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
-                        scr &= ~SSI_SCR_TE;
-                else
-                        scr &= ~SSI_SCR_RE;
-                break;
-        default:
-                return -EINVAL;
-        }
-
-        if (cpu_dai->id == IMX_DAI_SSI0 || cpu_dai->id == IMX_DAI_SSI2)
-                SSI1_SCR = scr;
-        else
-                SSI2_SCR = scr;
-
-        return 0;
-}
-
-static void imx_ssi_shutdown(struct snd_pcm_substream *substream,
-                        struct snd_soc_dai *dai)
-{
-        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-        struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
-
-        /* shutdown SSI if neither Tx or Rx is active */
-        if (!cpu_dai->active) {
-
-                if (cpu_dai->id == IMX_DAI_SSI0 ||
-                        cpu_dai->id == IMX_DAI_SSI2) {
-
-                        if (--ssi_active[SSI1_PORT] > 1)
-                                return;
-
-                        SSI1_SCR = 0;
-                        clk_disable(ssi_clk0);
-                } else {
-                        if (--ssi_active[SSI2_PORT])
-                                return;
-                        SSI2_SCR = 0;
-                        clk_disable(ssi_clk1);
-                }
-        }
-}
-
-#ifdef CONFIG_PM
-static int imx_ssi_suspend(struct platform_device *dev,
-        struct snd_soc_dai *dai)
-{
-        return 0;
-}
-
-static int imx_ssi_resume(struct platform_device *pdev,
-        struct snd_soc_dai *dai)
-{
-        return 0;
-}
-
-#else
-#define imx_ssi_suspend NULL
-#define imx_ssi_resume  NULL
-#endif
-
-#define IMX_SSI_RATES \
-        (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_11025 | \
-        SNDRV_PCM_RATE_16000 | SNDRV_PCM_RATE_22050 | \
-        SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | \
-        SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_88200 | \
-        SNDRV_PCM_RATE_96000)
-
-#define IMX_SSI_BITS \
-        (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE | \
-        SNDRV_PCM_FMTBIT_S24_LE)
-
-static struct snd_soc_dai_ops imx_ssi_pcm_dai_ops = {
-        .startup = imx_ssi_startup,
-        .shutdown = imx_ssi_shutdown,
-        .trigger = imx_ssi_trigger,
-        .prepare = imx_ssi_prepare,
-        .hw_params = imx_ssi_hw_params,
-        .set_sysclk = imx_ssi_set_dai_sysclk,
-        .set_clkdiv = imx_ssi_set_dai_clkdiv,
-        .set_fmt = imx_ssi_set_dai_fmt,
-        .set_tdm_slot = imx_ssi_set_dai_tdm_slot,
-};
-
-struct snd_soc_dai imx_ssi_pcm_dai[] = {
-{
-        .name = "imx-i2s-1-0",
-        .id = IMX_DAI_SSI0,
-        .suspend = imx_ssi_suspend,
-        .resume = imx_ssi_resume,
-        .playback = {
-                .channels_min = 1,
-                .channels_max = 2,
-                .formats = IMX_SSI_BITS,
-                .rates = IMX_SSI_RATES,},
-        .capture = {
-                .channels_min = 1,
-                .channels_max = 2,
-                .formats = IMX_SSI_BITS,
-                .rates = IMX_SSI_RATES,},
-        .ops = &imx_ssi_pcm_dai_ops,
-},
-{
-        .name = "imx-i2s-2-0",
-        .id = IMX_DAI_SSI1,
-        .playback = {
-                .channels_min = 1,
-                .channels_max = 2,
-                .formats = IMX_SSI_BITS,
-                .rates = IMX_SSI_RATES,},
-        .capture = {
-                .channels_min = 1,
-                .channels_max = 2,
-                .formats = IMX_SSI_BITS,
-                .rates = IMX_SSI_RATES,},
-        .ops = &imx_ssi_pcm_dai_ops,
-},
-{
-        .name = "imx-i2s-1-1",
-        .id = IMX_DAI_SSI2,
-        .suspend = imx_ssi_suspend,
-        .resume = imx_ssi_resume,
-        .playback = {
-                .channels_min = 1,
-                .channels_max = 2,
-                .formats = IMX_SSI_BITS,
-                .rates = IMX_SSI_RATES,},
-        .capture = {
-                .channels_min = 1,
-                .channels_max = 2,
-                .formats = IMX_SSI_BITS,
-                .rates = IMX_SSI_RATES,},
-        .ops = &imx_ssi_pcm_dai_ops,
-},
-{
-        .name = "imx-i2s-2-1",
-        .id = IMX_DAI_SSI3,
-        .playback = {
-                .channels_min = 1,
-                .channels_max = 2,
-                .formats = IMX_SSI_BITS,
-                .rates = IMX_SSI_RATES,},
-        .capture = {
-                .channels_min = 1,
-                .channels_max = 2,
-                .formats = IMX_SSI_BITS,
-                .rates = IMX_SSI_RATES,},
-        .ops = &imx_ssi_pcm_dai_ops,
-},
-};
-EXPORT_SYMBOL_GPL(imx_ssi_pcm_dai);
-
-static int __init imx_ssi_init(void)
-{
-        return snd_soc_register_dais(imx_ssi_pcm_dai,
-                                ARRAY_SIZE(imx_ssi_pcm_dai));
-}
-
-static void __exit imx_ssi_exit(void)
-{
-        snd_soc_unregister_dais(imx_ssi_pcm_dai,
-                                ARRAY_SIZE(imx_ssi_pcm_dai));
-}
-
-module_init(imx_ssi_init);
-module_exit(imx_ssi_exit);
-MODULE_AUTHOR("Liam Girdwood, liam.girdwood@wolfsonmicro.com");
-MODULE_DESCRIPTION("i.MX ASoC I2S driver");
-MODULE_LICENSE("GPL");
diff --git a/sound/soc/imx/mxc-ssi.h b/sound/soc/imx/mxc-ssi.h
deleted file mode 100644
index 12bbdc9c7ecd..000000000000
--- a/sound/soc/imx/mxc-ssi.h
+++ /dev/null
@@ -1,238 +0,0 @@
-/*
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-#ifndef _IMX_SSI_H
-#define _IMX_SSI_H
-
-#include <mach/hardware.h>
-
-/* SSI regs definition - MOVE to /arch/arm/plat-mxc/include/mach/ when stable */
-#define SSI1_IO_BASE_ADDR       IO_ADDRESS(SSI1_BASE_ADDR)
-#define SSI2_IO_BASE_ADDR       IO_ADDRESS(SSI2_BASE_ADDR)
-
-#define STX0   0x00
-#define STX1   0x04
-#define SRX0   0x08
-#define SRX1   0x0c
-#define SCR    0x10
-#define SISR   0x14
-#define SIER   0x18
-#define STCR   0x1c
-#define SRCR   0x20
-#define STCCR  0x24
-#define SRCCR  0x28
-#define SFCSR  0x2c
-#define STR    0x30
-#define SOR    0x34
-#define SACNT  0x38
-#define SACADD 0x3c
-#define SACDAT 0x40
-#define SATAG  0x44
-#define STMSK  0x48
-#define SRMSK  0x4c
-
-#define SSI1_STX0       (*((volatile u32 *)(SSI1_IO_BASE_ADDR + STX0)))
-#define SSI1_STX1   (*((volatile u32 *)(SSI1_IO_BASE_ADDR + STX1)))
-#define SSI1_SRX0   (*((volatile u32 *)(SSI1_IO_BASE_ADDR + SRX0)))
-#define SSI1_SRX1   (*((volatile u32 *)(SSI1_IO_BASE_ADDR + SRX1)))
-#define SSI1_SCR    (*((volatile u32 *)(SSI1_IO_BASE_ADDR + SCR)))
-#define SSI1_SISR   (*((volatile u32 *)(SSI1_IO_BASE_ADDR + SISR)))
-#define SSI1_SIER   (*((volatile u32 *)(SSI1_IO_BASE_ADDR + SIER)))
-#define SSI1_STCR   (*((volatile u32 *)(SSI1_IO_BASE_ADDR + STCR)))
-#define SSI1_SRCR   (*((volatile u32 *)(SSI1_IO_BASE_ADDR + SRCR)))
-#define SSI1_STCCR  (*((volatile u32 *)(SSI1_IO_BASE_ADDR + STCCR)))
-#define SSI1_SRCCR  (*((volatile u32 *)(SSI1_IO_BASE_ADDR + SRCCR)))
-#define SSI1_SFCSR  (*((volatile u32 *)(SSI1_IO_BASE_ADDR + SFCSR)))
-#define SSI1_STR    (*((volatile u32 *)(SSI1_IO_BASE_ADDR + STR)))
-#define SSI1_SOR    (*((volatile u32 *)(SSI1_IO_BASE_ADDR + SOR)))
-#define SSI1_SACNT  (*((volatile u32 *)(SSI1_IO_BASE_ADDR + SACNT)))
-#define SSI1_SACADD (*((volatile u32 *)(SSI1_IO_BASE_ADDR + SACADD)))
-#define SSI1_SACDAT (*((volatile u32 *)(SSI1_IO_BASE_ADDR + SACDAT)))
-#define SSI1_SATAG  (*((volatile u32 *)(SSI1_IO_BASE_ADDR + SATAG)))
-#define SSI1_STMSK  (*((volatile u32 *)(SSI1_IO_BASE_ADDR + STMSK)))
-#define SSI1_SRMSK  (*((volatile u32 *)(SSI1_IO_BASE_ADDR + SRMSK)))
-
-
-#define SSI2_STX0       (*((volatile u32 *)(SSI2_IO_BASE_ADDR + STX0)))
-#define SSI2_STX1   (*((volatile u32 *)(SSI2_IO_BASE_ADDR + STX1)))
-#define SSI2_SRX0   (*((volatile u32 *)(SSI2_IO_BASE_ADDR + SRX0)))
-#define SSI2_SRX1   (*((volatile u32 *)(SSI2_IO_BASE_ADDR + SRX1)))
-#define SSI2_SCR    (*((volatile u32 *)(SSI2_IO_BASE_ADDR + SCR)))
-#define SSI2_SISR   (*((volatile u32 *)(SSI2_IO_BASE_ADDR + SISR)))
-#define SSI2_SIER   (*((volatile u32 *)(SSI2_IO_BASE_ADDR + SIER)))
-#define SSI2_STCR   (*((volatile u32 *)(SSI2_IO_BASE_ADDR + STCR)))
-#define SSI2_SRCR   (*((volatile u32 *)(SSI2_IO_BASE_ADDR + SRCR)))
-#define SSI2_STCCR  (*((volatile u32 *)(SSI2_IO_BASE_ADDR + STCCR)))
-#define SSI2_SRCCR  (*((volatile u32 *)(SSI2_IO_BASE_ADDR + SRCCR)))
-#define SSI2_SFCSR  (*((volatile u32 *)(SSI2_IO_BASE_ADDR + SFCSR)))
-#define SSI2_STR    (*((volatile u32 *)(SSI2_IO_BASE_ADDR + STR)))
-#define SSI2_SOR    (*((volatile u32 *)(SSI2_IO_BASE_ADDR + SOR)))
-#define SSI2_SACNT  (*((volatile u32 *)(SSI2_IO_BASE_ADDR + SACNT)))
-#define SSI2_SACADD (*((volatile u32 *)(SSI2_IO_BASE_ADDR + SACADD)))
-#define SSI2_SACDAT (*((volatile u32 *)(SSI2_IO_BASE_ADDR + SACDAT)))
-#define SSI2_SATAG  (*((volatile u32 *)(SSI2_IO_BASE_ADDR + SATAG)))
-#define SSI2_STMSK  (*((volatile u32 *)(SSI2_IO_BASE_ADDR + STMSK)))
-#define SSI2_SRMSK  (*((volatile u32 *)(SSI2_IO_BASE_ADDR + SRMSK)))
-
-#define SSI_SCR_CLK_IST        (1 << 9)
-#define SSI_SCR_TCH_EN         (1 << 8)
-#define SSI_SCR_SYS_CLK_EN     (1 << 7)
-#define SSI_SCR_I2S_MODE_NORM  (0 << 5)
-#define SSI_SCR_I2S_MODE_MSTR  (1 << 5)
-#define SSI_SCR_I2S_MODE_SLAVE (2 << 5)
-#define SSI_SCR_SYN            (1 << 4)
-#define SSI_SCR_NET            (1 << 3)
-#define SSI_SCR_RE             (1 << 2)
-#define SSI_SCR_TE             (1 << 1)
-#define SSI_SCR_SSIEN          (1 << 0)
-
-#define SSI_SISR_CMDAU         (1 << 18)
-#define SSI_SISR_CMDDU         (1 << 17)
-#define SSI_SISR_RXT           (1 << 16)
-#define SSI_SISR_RDR1          (1 << 15)
-#define SSI_SISR_RDR0          (1 << 14)
-#define SSI_SISR_TDE1          (1 << 13)
-#define SSI_SISR_TDE0          (1 << 12)
-#define SSI_SISR_ROE1          (1 << 11)
-#define SSI_SISR_ROE0          (1 << 10)
-#define SSI_SISR_TUE1          (1 << 9)
-#define SSI_SISR_TUE0          (1 << 8)
-#define SSI_SISR_TFS           (1 << 7)
-#define SSI_SISR_RFS           (1 << 6)
-#define SSI_SISR_TLS           (1 << 5)
-#define SSI_SISR_RLS           (1 << 4)
-#define SSI_SISR_RFF1          (1 << 3)
-#define SSI_SISR_RFF0          (1 << 2)
-#define SSI_SISR_TFE1          (1 << 1)
-#define SSI_SISR_TFE0          (1 << 0)
-
-#define SSI_SIER_RDMAE         (1 << 22)
-#define SSI_SIER_RIE           (1 << 21)
-#define SSI_SIER_TDMAE         (1 << 20)
-#define SSI_SIER_TIE           (1 << 19)
-#define SSI_SIER_CMDAU_EN      (1 << 18)
-#define SSI_SIER_CMDDU_EN      (1 << 17)
-#define SSI_SIER_RXT_EN        (1 << 16)
-#define SSI_SIER_RDR1_EN       (1 << 15)
-#define SSI_SIER_RDR0_EN       (1 << 14)
-#define SSI_SIER_TDE1_EN       (1 << 13)
-#define SSI_SIER_TDE0_EN       (1 << 12)
-#define SSI_SIER_ROE1_EN       (1 << 11)
-#define SSI_SIER_ROE0_EN       (1 << 10)
-#define SSI_SIER_TUE1_EN       (1 << 9)
-#define SSI_SIER_TUE0_EN       (1 << 8)
-#define SSI_SIER_TFS_EN        (1 << 7)
-#define SSI_SIER_RFS_EN        (1 << 6)
-#define SSI_SIER_TLS_EN        (1 << 5)
-#define SSI_SIER_RLS_EN        (1 << 4)
-#define SSI_SIER_RFF1_EN       (1 << 3)
-#define SSI_SIER_RFF0_EN       (1 << 2)
-#define SSI_SIER_TFE1_EN       (1 << 1)
-#define SSI_SIER_TFE0_EN       (1 << 0)
-
-#define SSI_STCR_TXBIT0        (1 << 9)
-#define SSI_STCR_TFEN1         (1 << 8)
-#define SSI_STCR_TFEN0         (1 << 7)
-#define SSI_STCR_TFDIR         (1 << 6)
-#define SSI_STCR_TXDIR         (1 << 5)
-#define SSI_STCR_TSHFD         (1 << 4)
-#define SSI_STCR_TSCKP         (1 << 3)
-#define SSI_STCR_TFSI          (1 << 2)
-#define SSI_STCR_TFSL          (1 << 1)
-#define SSI_STCR_TEFS          (1 << 0)
-
-#define SSI_SRCR_RXBIT0        (1 << 9)
-#define SSI_SRCR_RFEN1         (1 << 8)
-#define SSI_SRCR_RFEN0         (1 << 7)
-#define SSI_SRCR_RFDIR         (1 << 6)
-#define SSI_SRCR_RXDIR         (1 << 5)
-#define SSI_SRCR_RSHFD         (1 << 4)
-#define SSI_SRCR_RSCKP         (1 << 3)
-#define SSI_SRCR_RFSI          (1 << 2)
-#define SSI_SRCR_RFSL          (1 << 1)
-#define SSI_SRCR_REFS          (1 << 0)
-
-#define SSI_STCCR_DIV2         (1 << 18)
-#define SSI_STCCR_PSR          (1 << 15)
-#define SSI_STCCR_WL(x)        ((((x) - 2) >> 1) << 13)
-#define SSI_STCCR_DC(x)        (((x) & 0x1f) << 8)
-#define SSI_STCCR_PM(x)        (((x) & 0xff) << 0)
-#define SSI_STCCR_WL_MASK        (0xf << 13)
-#define SSI_STCCR_DC_MASK        (0x1f << 8)
-#define SSI_STCCR_PM_MASK        (0xff << 0)
-
-#define SSI_SRCCR_DIV2         (1 << 18)
-#define SSI_SRCCR_PSR          (1 << 15)
-#define SSI_SRCCR_WL(x)        ((((x) - 2) >> 1) << 13)
-#define SSI_SRCCR_DC(x)        (((x) & 0x1f) << 8)
-#define SSI_SRCCR_PM(x)        (((x) & 0xff) << 0)
-#define SSI_SRCCR_WL_MASK        (0xf << 13)
-#define SSI_SRCCR_DC_MASK        (0x1f << 8)
-#define SSI_SRCCR_PM_MASK        (0xff << 0)
-
-
-#define SSI_SFCSR_RFCNT1(x)   (((x) & 0xf) << 28)
-#define SSI_SFCSR_TFCNT1(x)   (((x) & 0xf) << 24)
-#define SSI_SFCSR_RFWM1(x)    (((x) & 0xf) << 20)
-#define SSI_SFCSR_TFWM1(x)    (((x) & 0xf) << 16)
-#define SSI_SFCSR_RFCNT0(x)   (((x) & 0xf) << 12)
-#define SSI_SFCSR_TFCNT0(x)   (((x) & 0xf) <<  8)
-#define SSI_SFCSR_RFWM0(x)    (((x) & 0xf) <<  4)
-#define SSI_SFCSR_TFWM0(x)    (((x) & 0xf) <<  0)
-
-#define SSI_STR_TEST          (1 << 15)
-#define SSI_STR_RCK2TCK       (1 << 14)
-#define SSI_STR_RFS2TFS       (1 << 13)
-#define SSI_STR_RXSTATE(x)    (((x) & 0xf) << 8)
-#define SSI_STR_TXD2RXD       (1 <<  7)
-#define SSI_STR_TCK2RCK       (1 <<  6)
-#define SSI_STR_TFS2RFS       (1 <<  5)
-#define SSI_STR_TXSTATE(x)    (((x) & 0xf) << 0)
-
-#define SSI_SOR_CLKOFF        (1 << 6)
-#define SSI_SOR_RX_CLR        (1 << 5)
-#define SSI_SOR_TX_CLR        (1 << 4)
-#define SSI_SOR_INIT          (1 << 3)
-#define SSI_SOR_WAIT(x)       (((x) & 0x3) << 1)
-#define SSI_SOR_SYNRST        (1 << 0)
-
-#define SSI_SACNT_FRDIV(x)    (((x) & 0x3f) << 5)
-#define SSI_SACNT_WR          (x << 4)
-#define SSI_SACNT_RD          (x << 3)
-#define SSI_SACNT_TIF         (x << 2)
-#define SSI_SACNT_FV          (x << 1)
-#define SSI_SACNT_AC97EN      (x << 0)
-
-/* Watermarks for FIFO's */
-#define TXFIFO_WATERMARK                                0x4
-#define RXFIFO_WATERMARK                                0x4
-
-/* i.MX DAI SSP ID's */
-#define IMX_DAI_SSI0                    0 /* SSI1 FIFO 0 */
-#define IMX_DAI_SSI1                    1 /* SSI1 FIFO 1 */
-#define IMX_DAI_SSI2                    2 /* SSI2 FIFO 0 */
-#define IMX_DAI_SSI3                    3 /* SSI2 FIFO 1 */
-
-/* SSI clock sources */
-#define IMX_SSP_SYS_CLK         0
-
-/* SSI audio dividers */
-#define IMX_SSI_TX_DIV_2                        0
-#define IMX_SSI_TX_DIV_PSR                      1
-#define IMX_SSI_TX_DIV_PM                       2
-#define IMX_SSI_RX_DIV_2                        3
-#define IMX_SSI_RX_DIV_PSR                      4
-#define IMX_SSI_RX_DIV_PM                       5
-
-
-/* SSI Div 2 */
-#define IMX_SSI_DIV_2_OFF               (~SSI_STCCR_DIV2)
-#define IMX_SSI_DIV_2_ON                SSI_STCCR_DIV2
-
-extern struct snd_soc_dai imx_ssi_pcm_dai[4];
-extern int get_ssi_clk(int ssi, struct device *dev);
-extern void put_ssi_clk(int ssi);
-#endif
diff --git a/sound/soc/imx/phycore-ac97.c b/sound/soc/imx/phycore-ac97.c
new file mode 100644
index 000000000000..a8307d55c70e
--- /dev/null
+++ b/sound/soc/imx/phycore-ac97.c
@@ -0,0 +1,90 @@
+/*
+ * phycore-ac97.c  --  SoC audio for imx_phycore in AC97 mode
+ *
+ * Copyright 2009 Sascha Hauer, Pengutronix <s.hauer@pengutronix.de>
+ *
+ *  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 the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/device.h>
+#include <linux/i2c.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+#include <asm/mach-types.h>
+
+#include "../codecs/wm9712.h"
+#include "imx-ssi.h"
+
+static struct snd_soc_card imx_phycore;
+
+static struct snd_soc_ops imx_phycore_hifi_ops = {
+};
+
+static struct snd_soc_dai_link imx_phycore_dai_ac97[] = {
+        {
+                .name           = "HiFi",
+                .stream_name    = "HiFi",
+                .codec_dai      = &wm9712_dai[WM9712_DAI_AC97_HIFI],
+                .ops            = &imx_phycore_hifi_ops,
+        },
+};
+
+static struct snd_soc_card imx_phycore = {
+        .name           = "PhyCORE-audio",
+        .platform       = &imx_soc_platform,
+        .dai_link       = imx_phycore_dai_ac97,
+        .num_links      = ARRAY_SIZE(imx_phycore_dai_ac97),
+};
+
+static struct snd_soc_device imx_phycore_snd_devdata = {
+        .card           = &imx_phycore,
+        .codec_dev      = &soc_codec_dev_wm9712,
+};
+
+static struct platform_device *imx_phycore_snd_device;
+
+static int __init imx_phycore_init(void)
+{
+        int ret;
+
+        if (!machine_is_pcm043() && !machine_is_pca100())
+                /* return happy. We might run on a totally different machine */
+                return 0;
+
+        imx_phycore_snd_device = platform_device_alloc("soc-audio", -1);
+        if (!imx_phycore_snd_device)
+                return -ENOMEM;
+
+        imx_phycore_dai_ac97[0].cpu_dai = &imx_ssi_pcm_dai[0];
+
+        platform_set_drvdata(imx_phycore_snd_device, &imx_phycore_snd_devdata);
+        imx_phycore_snd_devdata.dev = &imx_phycore_snd_device->dev;
+        ret = platform_device_add(imx_phycore_snd_device);
+
+        if (ret) {
+                printk(KERN_ERR "ASoC: Platform device allocation failed\n");
+                platform_device_put(imx_phycore_snd_device);
+        }
+
+        return ret;
+}
+
+static void __exit imx_phycore_exit(void)
+{
+        platform_device_unregister(imx_phycore_snd_device);
+}
+
+late_initcall(imx_phycore_init);
+module_exit(imx_phycore_exit);
+
+MODULE_AUTHOR("Sascha Hauer <s.hauer@pengutronix.de>");
+MODULE_DESCRIPTION("PhyCORE ALSA SoC driver");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/omap/Kconfig b/sound/soc/omap/Kconfig
index 653a362425df..f11963c21873 100644
--- a/sound/soc/omap/Kconfig
+++ b/sound/soc/omap/Kconfig
@@ -6,6 +6,9 @@ config SND_OMAP_SOC_MCBSP
         tristate
         select OMAP_MCBSP
 
+config SND_OMAP_SOC_MCPDM
+        tristate
+
 config SND_OMAP_SOC_N810
         tristate "SoC Audio support for Nokia N810"
         depends on SND_OMAP_SOC && MACH_NOKIA_N810 && I2C
@@ -43,12 +46,13 @@ config SND_OMAP_SOC_OSK5912
           Say Y if you want to add support for SoC audio on osk5912.
 
 config SND_OMAP_SOC_OVERO
-        tristate "SoC Audio support for Gumstix Overo"
-        depends on TWL4030_CORE && SND_OMAP_SOC && MACH_OVERO
+        tristate "SoC Audio support for Gumstix Overo and CompuLab CM-T35"
+        depends on TWL4030_CORE && SND_OMAP_SOC && (MACH_OVERO || MACH_CM_T35)
         select SND_OMAP_SOC_MCBSP
         select SND_SOC_TWL4030
         help
-          Say Y if you want to add support for SoC audio on the Gumstix Overo.
+          Say Y if you want to add support for SoC audio on the
+          Gumstix Overo or CompuLab CM-T35
 
 config SND_OMAP_SOC_OMAP2EVM
         tristate "SoC Audio support for OMAP2EVM board"
@@ -66,6 +70,15 @@ config SND_OMAP_SOC_OMAP3EVM
         help
           Say Y if you want to add support for SoC audio on the omap3evm board.
 
+config SND_OMAP_SOC_AM3517EVM
+        tristate "SoC Audio support for OMAP3517 / AM3517 EVM"
+        depends on SND_OMAP_SOC && MACH_OMAP3517EVM && I2C
+        select SND_OMAP_SOC_MCBSP
+        select SND_SOC_TLV320AIC23
+        help
+          Say Y if you want to add support for SoC audio on the OMAP3517 / AM3517
+          EVM.
+
 config SND_OMAP_SOC_SDP3430
         tristate "SoC Audio support for Texas Instruments SDP3430"
         depends on TWL4030_CORE && SND_OMAP_SOC && MACH_OMAP_3430SDP
@@ -84,12 +97,14 @@ config SND_OMAP_SOC_OMAP3_PANDORA
           Say Y if you want to add support for SoC audio on the OMAP3 Pandora.
 
 config SND_OMAP_SOC_OMAP3_BEAGLE
-        tristate "SoC Audio support for OMAP3 Beagle"
-        depends on TWL4030_CORE && SND_OMAP_SOC && MACH_OMAP3_BEAGLE
+        tristate "SoC Audio support for OMAP3 Beagle and Devkit8000"
+        depends on TWL4030_CORE && SND_OMAP_SOC
+        depends on (MACH_OMAP3_BEAGLE || MACH_DEVKIT8000)
         select SND_OMAP_SOC_MCBSP
         select SND_SOC_TWL4030
         help
-          Say Y if you want to add support for SoC audio on the Beagleboard.
+          Say Y if you want to add support for SoC audio on the Beagleboard or
+          the clone Devkit8000.
 
 config SND_OMAP_SOC_ZOOM2
         tristate "SoC Audio support for Zoom2"
@@ -99,3 +114,10 @@ config SND_OMAP_SOC_ZOOM2
         help
           Say Y if you want to add support for Soc audio on Zoom2 board.
 
+config SND_OMAP_SOC_IGEP0020
+        tristate "SoC Audio support for IGEP v2"
+        depends on TWL4030_CORE && SND_OMAP_SOC && MACH_IGEP0020
+        select SND_OMAP_SOC_MCBSP
+        select SND_SOC_TWL4030
+        help
+          Say Y if you want to add support for Soc audio on IGEP v2 board.
diff --git a/sound/soc/omap/Makefile b/sound/soc/omap/Makefile
index 02d69471dcb5..0bc00ca14b37 100644
--- a/sound/soc/omap/Makefile
+++ b/sound/soc/omap/Makefile
@@ -1,9 +1,11 @@
 # OMAP Platform Support
 snd-soc-omap-objs := omap-pcm.o
 snd-soc-omap-mcbsp-objs := omap-mcbsp.o
+snd-soc-omap-mcpdm-objs := omap-mcpdm.o mcpdm.o
 
 obj-$(CONFIG_SND_OMAP_SOC) += snd-soc-omap.o
 obj-$(CONFIG_SND_OMAP_SOC_MCBSP) += snd-soc-omap-mcbsp.o
+obj-$(CONFIG_SND_OMAP_SOC_MCPDM) += snd-soc-omap-mcpdm.o
 
 # OMAP Machine Support
 snd-soc-n810-objs := n810.o
@@ -12,18 +14,22 @@ snd-soc-osk5912-objs := osk5912.o
 snd-soc-overo-objs := overo.o
 snd-soc-omap2evm-objs := omap2evm.o
 snd-soc-omap3evm-objs := omap3evm.o
+snd-soc-am3517evm-objs := am3517evm.o
 snd-soc-sdp3430-objs := sdp3430.o
 snd-soc-omap3pandora-objs := omap3pandora.o
 snd-soc-omap3beagle-objs := omap3beagle.o
 snd-soc-zoom2-objs := zoom2.o
+snd-soc-igep0020-objs := igep0020.o
 
 obj-$(CONFIG_SND_OMAP_SOC_N810) += snd-soc-n810.o
 obj-$(CONFIG_SND_OMAP_SOC_AMS_DELTA) += snd-soc-ams-delta.o
 obj-$(CONFIG_SND_OMAP_SOC_OSK5912) += snd-soc-osk5912.o
 obj-$(CONFIG_SND_OMAP_SOC_OVERO) += snd-soc-overo.o
-obj-$(CONFIG_MACH_OMAP2EVM) += snd-soc-omap2evm.o
-obj-$(CONFIG_MACH_OMAP3EVM) += snd-soc-omap3evm.o
+obj-$(CONFIG_SND_OMAP_SOC_OMAP2EVM) += snd-soc-omap2evm.o
+obj-$(CONFIG_SND_OMAP_SOC_OMAP3EVM) += snd-soc-omap3evm.o
+obj-$(CONFIG_SND_OMAP_SOC_AM3517EVM) += snd-soc-am3517evm.o
 obj-$(CONFIG_SND_OMAP_SOC_SDP3430) += snd-soc-sdp3430.o
 obj-$(CONFIG_SND_OMAP_SOC_OMAP3_PANDORA) += snd-soc-omap3pandora.o
 obj-$(CONFIG_SND_OMAP_SOC_OMAP3_BEAGLE) += snd-soc-omap3beagle.o
 obj-$(CONFIG_SND_OMAP_SOC_ZOOM2) += snd-soc-zoom2.o
+obj-$(CONFIG_SND_OMAP_SOC_IGEP0020) += snd-soc-igep0020.o
diff --git a/sound/soc/omap/am3517evm.c b/sound/soc/omap/am3517evm.c
new file mode 100644
index 000000000000..135901b2ea11
--- /dev/null
+++ b/sound/soc/omap/am3517evm.c
@@ -0,0 +1,202 @@
+/*
+ * am3517evm.c  -- ALSA SoC support for OMAP3517 / AM3517 EVM
+ *
+ * Author: Anuj Aggarwal <anuj.aggarwal@ti.com>
+ *
+ * Based on sound/soc/omap/beagle.c by Steve Sakoman
+ *
+ * Copyright (C) 2009 Texas Instruments Incorporated
+ *
+ * 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 the
+ * Free Software Foundation version 2.
+ *
+ * This program is distributed "as is" WITHOUT ANY WARRANTY of any kind,
+ * whether express or implied; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ */
+
+#include <linux/clk.h>
+#include <linux/platform_device.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+
+#include <asm/mach-types.h>
+#include <mach/hardware.h>
+#include <mach/gpio.h>
+#include <plat/mcbsp.h>
+
+#include "omap-mcbsp.h"
+#include "omap-pcm.h"
+
+#include "../codecs/tlv320aic23.h"
+
+#define CODEC_CLOCK     12000000
+
+static int am3517evm_hw_params(struct snd_pcm_substream *substream,
+        struct snd_pcm_hw_params *params)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
+        struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
+        int ret;
+
+        /* Set codec DAI configuration */
+        ret = snd_soc_dai_set_fmt(codec_dai,
+                                  SND_SOC_DAIFMT_DSP_B |
+                                  SND_SOC_DAIFMT_NB_NF |
+                                  SND_SOC_DAIFMT_CBM_CFM);
+        if (ret < 0) {
+                printk(KERN_ERR "can't set codec DAI configuration\n");
+                return ret;
+        }
+
+        /* Set cpu DAI configuration */
+        ret = snd_soc_dai_set_fmt(cpu_dai,
+                                  SND_SOC_DAIFMT_DSP_B |
+                                  SND_SOC_DAIFMT_NB_NF |
+                                  SND_SOC_DAIFMT_CBM_CFM);
+        if (ret < 0) {
+                printk(KERN_ERR "can't set cpu DAI configuration\n");
+                return ret;
+        }
+
+        /* Set the codec system clock for DAC and ADC */
+        ret = snd_soc_dai_set_sysclk(codec_dai, 0,
+                        CODEC_CLOCK, SND_SOC_CLOCK_IN);
+        if (ret < 0) {
+                printk(KERN_ERR "can't set codec system clock\n");
+                return ret;
+        }
+
+        ret = snd_soc_dai_set_sysclk(cpu_dai, OMAP_MCBSP_CLKR_SRC_CLKX, 0,
+                                SND_SOC_CLOCK_IN);
+        if (ret < 0) {
+                printk(KERN_ERR "can't set CPU system clock OMAP_MCBSP_CLKR_SRC_CLKX\n");
+                return ret;
+        }
+
+        snd_soc_dai_set_sysclk(cpu_dai, OMAP_MCBSP_FSR_SRC_FSX, 0,
+                                SND_SOC_CLOCK_IN);
+        if (ret < 0) {
+                printk(KERN_ERR "can't set CPU system clock OMAP_MCBSP_FSR_SRC_FSX\n");
+                return ret;
+        }
+
+        return 0;
+}
+
+static struct snd_soc_ops am3517evm_ops = {
+        .hw_params = am3517evm_hw_params,
+};
+
+/* am3517evm machine dapm widgets */
+static const struct snd_soc_dapm_widget tlv320aic23_dapm_widgets[] = {
+        SND_SOC_DAPM_HP("Line Out", NULL),
+        SND_SOC_DAPM_LINE("Line In", NULL),
+        SND_SOC_DAPM_MIC("Mic In", NULL),
+};
+
+static const struct snd_soc_dapm_route audio_map[] = {
+        /* Line Out connected to LLOUT, RLOUT */
+        {"Line Out", NULL, "LOUT"},
+        {"Line Out", NULL, "ROUT"},
+
+        {"LLINEIN", NULL, "Line In"},
+        {"RLINEIN", NULL, "Line In"},
+
+        {"MICIN", NULL, "Mic In"},
+};
+
+static int am3517evm_aic23_init(struct snd_soc_codec *codec)
+{
+        /* Add am3517-evm specific widgets */
+        snd_soc_dapm_new_controls(codec, tlv320aic23_dapm_widgets,
+                                  ARRAY_SIZE(tlv320aic23_dapm_widgets));
+
+        /* Set up davinci-evm specific audio path audio_map */
+        snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
+
+        /* always connected */
+        snd_soc_dapm_enable_pin(codec, "Line Out");
+        snd_soc_dapm_enable_pin(codec, "Line In");
+        snd_soc_dapm_enable_pin(codec, "Mic In");
+
+        snd_soc_dapm_sync(codec);
+
+        return 0;
+}
+
+/* Digital audio interface glue - connects codec <--> CPU */
+static struct snd_soc_dai_link am3517evm_dai = {
+        .name = "TLV320AIC23",
+        .stream_name = "AIC23",
+        .cpu_dai = &omap_mcbsp_dai[0],
+        .codec_dai = &tlv320aic23_dai,
+        .init = am3517evm_aic23_init,
+        .ops = &am3517evm_ops,
+};
+
+/* Audio machine driver */
+static struct snd_soc_card snd_soc_am3517evm = {
+        .name = "am3517evm",
+        .platform = &omap_soc_platform,
+        .dai_link = &am3517evm_dai,
+        .num_links = 1,
+};
+
+/* Audio subsystem */
+static struct snd_soc_device am3517evm_snd_devdata = {
+        .card = &snd_soc_am3517evm,
+        .codec_dev = &soc_codec_dev_tlv320aic23,
+};
+
+static struct platform_device *am3517evm_snd_device;
+
+static int __init am3517evm_soc_init(void)
+{
+        int ret;
+
+        if (!machine_is_omap3517evm()) {
+                pr_err("Not OMAP3517 / AM3517 EVM!\n");
+                return -ENODEV;
+        }
+        pr_info("OMAP3517 / AM3517 EVM SoC init\n");
+
+        am3517evm_snd_device = platform_device_alloc("soc-audio", -1);
+        if (!am3517evm_snd_device) {
+                printk(KERN_ERR "Platform device allocation failed\n");
+                return -ENOMEM;
+        }
+
+        platform_set_drvdata(am3517evm_snd_device, &am3517evm_snd_devdata);
+        am3517evm_snd_devdata.dev = &am3517evm_snd_device->dev;
+        *(unsigned int *)am3517evm_dai.cpu_dai->private_data = 0; /* McBSP1 */
+
+        ret = platform_device_add(am3517evm_snd_device);
+        if (ret)
+                goto err1;
+
+        return 0;
+
+err1:
+        printk(KERN_ERR "Unable to add platform device\n");
+        platform_device_put(am3517evm_snd_device);
+
+        return ret;
+}
+
+static void __exit am3517evm_soc_exit(void)
+{
+        platform_device_unregister(am3517evm_snd_device);
+}
+
+module_init(am3517evm_soc_init);
+module_exit(am3517evm_soc_exit);
+
+MODULE_AUTHOR("Anuj Aggarwal <anuj.aggarwal@ti.com>");
+MODULE_DESCRIPTION("ALSA SoC OMAP3517 / AM3517 EVM");
+MODULE_LICENSE("GPL v2");
diff --git a/sound/soc/omap/ams-delta.c b/sound/soc/omap/ams-delta.c
index 5a5166ac7279..b0f618e44840 100644
--- a/sound/soc/omap/ams-delta.c
+++ b/sound/soc/omap/ams-delta.c
@@ -31,8 +31,8 @@
 
 #include <asm/mach-types.h>
 
-#include <mach/board-ams-delta.h>
-#include <mach/mcbsp.h>
+#include <plat/board-ams-delta.h>
+#include <plat/mcbsp.h>
 
 #include "omap-mcbsp.h"
 #include "omap-pcm.h"
@@ -40,7 +40,7 @@
 
 
 /* Board specific DAPM widgets */
- const struct snd_soc_dapm_widget ams_delta_dapm_widgets[] = {
+static const struct snd_soc_dapm_widget ams_delta_dapm_widgets[] = {
         /* Handset */
         SND_SOC_DAPM_MIC("Mouthpiece", NULL),
         SND_SOC_DAPM_HP("Earpiece", NULL),
@@ -81,7 +81,7 @@ static const char *ams_delta_audio_mode[] =
                                                 (1 << AMS_DELTA_SPEAKER))
 #define AMS_DELTA_SPEAKERPHONE  (AMS_DELTA_HANDSFREE | (1 << AMS_DELTA_AGC))
 
-unsigned short ams_delta_audio_mode_pins[] = {
+static const unsigned short ams_delta_audio_mode_pins[] = {
         AMS_DELTA_MIXED,
         AMS_DELTA_HANDSET,
         AMS_DELTA_HANDSFREE,
diff --git a/sound/soc/omap/igep0020.c b/sound/soc/omap/igep0020.c
new file mode 100644
index 000000000000..3583c429f9be
--- /dev/null
+++ b/sound/soc/omap/igep0020.c
@@ -0,0 +1,148 @@
+/*
+ * igep0020.c  --  SoC audio for IGEP v2
+ *
+ * Based on sound/soc/omap/overo.c by Steve Sakoman
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program 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., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#include <linux/clk.h>
+#include <linux/platform_device.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+
+#include <asm/mach-types.h>
+#include <mach/hardware.h>
+#include <mach/gpio.h>
+#include <plat/mcbsp.h>
+
+#include "omap-mcbsp.h"
+#include "omap-pcm.h"
+#include "../codecs/twl4030.h"
+
+static int igep2_hw_params(struct snd_pcm_substream *substream,
+        struct snd_pcm_hw_params *params)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
+        struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
+        int ret;
+
+        /* Set codec DAI configuration */
+        ret = snd_soc_dai_set_fmt(codec_dai,
+                                  SND_SOC_DAIFMT_I2S |
+                                  SND_SOC_DAIFMT_NB_NF |
+                                  SND_SOC_DAIFMT_CBM_CFM);
+        if (ret < 0) {
+                printk(KERN_ERR "can't set codec DAI configuration\n");
+                return ret;
+        }
+
+        /* Set cpu DAI configuration */
+        ret = snd_soc_dai_set_fmt(cpu_dai,
+                                  SND_SOC_DAIFMT_I2S |
+                                  SND_SOC_DAIFMT_NB_NF |
+                                  SND_SOC_DAIFMT_CBM_CFM);
+        if (ret < 0) {
+                printk(KERN_ERR "can't set cpu DAI configuration\n");
+                return ret;
+        }
+
+        /* Set the codec system clock for DAC and ADC */
+        ret = snd_soc_dai_set_sysclk(codec_dai, 0, 26000000,
+                                            SND_SOC_CLOCK_IN);
+        if (ret < 0) {
+                printk(KERN_ERR "can't set codec system clock\n");
+                return ret;
+        }
+
+        return 0;
+}
+
+static struct snd_soc_ops igep2_ops = {
+        .hw_params = igep2_hw_params,
+};
+
+/* Digital audio interface glue - connects codec <--> CPU */
+static struct snd_soc_dai_link igep2_dai = {
+        .name = "TWL4030",
+        .stream_name = "TWL4030",
+        .cpu_dai = &omap_mcbsp_dai[0],
+        .codec_dai = &twl4030_dai[TWL4030_DAI_HIFI],
+        .ops = &igep2_ops,
+};
+
+/* Audio machine driver */
+static struct snd_soc_card snd_soc_card_igep2 = {
+        .name = "igep2",
+        .platform = &omap_soc_platform,
+        .dai_link = &igep2_dai,
+        .num_links = 1,
+};
+
+/* Audio subsystem */
+static struct snd_soc_device igep2_snd_devdata = {
+        .card = &snd_soc_card_igep2,
+        .codec_dev = &soc_codec_dev_twl4030,
+};
+
+static struct platform_device *igep2_snd_device;
+
+static int __init igep2_soc_init(void)
+{
+        int ret;
+
+        if (!machine_is_igep0020()) {
+                pr_debug("Not IGEP v2!\n");
+                return -ENODEV;
+        }
+        printk(KERN_INFO "IGEP v2 SoC init\n");
+
+        igep2_snd_device = platform_device_alloc("soc-audio", -1);
+        if (!igep2_snd_device) {
+                printk(KERN_ERR "Platform device allocation failed\n");
+                return -ENOMEM;
+        }
+
+        platform_set_drvdata(igep2_snd_device, &igep2_snd_devdata);
+        igep2_snd_devdata.dev = &igep2_snd_device->dev;
+        *(unsigned int *)igep2_dai.cpu_dai->private_data = 1; /* McBSP2 */
+
+        ret = platform_device_add(igep2_snd_device);
+        if (ret)
+                goto err1;
+
+        return 0;
+
+err1:
+        printk(KERN_ERR "Unable to add platform device\n");
+        platform_device_put(igep2_snd_device);
+
+        return ret;
+}
+module_init(igep2_soc_init);
+
+static void __exit igep2_soc_exit(void)
+{
+        platform_device_unregister(igep2_snd_device);
+}
+module_exit(igep2_soc_exit);
+
+MODULE_AUTHOR("Enric Balletbo i Serra <eballetbo@iseebcn.com>");
+MODULE_DESCRIPTION("ALSA SoC IGEP v2");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/omap/mcpdm.c b/sound/soc/omap/mcpdm.c
new file mode 100644
index 000000000000..1dab4c14874d
--- /dev/null
+++ b/sound/soc/omap/mcpdm.c
@@ -0,0 +1,485 @@
+/*
+ * mcpdm.c  --  McPDM interface driver
+ *
+ * Author: Jorge Eduardo Candelaria <x0107209@ti.com>
+ * Copyright (C) 2009 - Texas Instruments, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program 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., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/device.h>
+#include <linux/platform_device.h>
+#include <linux/wait.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/err.h>
+#include <linux/clk.h>
+#include <linux/delay.h>
+#include <linux/io.h>
+#include <linux/irq.h>
+
+#include "mcpdm.h"
+
+static struct omap_mcpdm *mcpdm;
+
+static inline void omap_mcpdm_write(u16 reg, u32 val)
+{
+       __raw_writel(val, mcpdm->io_base + reg);
+}
+
+static inline int omap_mcpdm_read(u16 reg)
+{
+       return __raw_readl(mcpdm->io_base + reg);
+}
+
+static void omap_mcpdm_reg_dump(void)
+{
+       dev_dbg(mcpdm->dev, "***********************\n");
+       dev_dbg(mcpdm->dev, "IRQSTATUS_RAW:  0x%04x\n",
+                       omap_mcpdm_read(MCPDM_IRQSTATUS_RAW));
+       dev_dbg(mcpdm->dev, "IRQSTATUS:  0x%04x\n",
+                       omap_mcpdm_read(MCPDM_IRQSTATUS));
+       dev_dbg(mcpdm->dev, "IRQENABLE_SET:  0x%04x\n",
+                       omap_mcpdm_read(MCPDM_IRQENABLE_SET));
+       dev_dbg(mcpdm->dev, "IRQENABLE_CLR:  0x%04x\n",
+                       omap_mcpdm_read(MCPDM_IRQENABLE_CLR));
+       dev_dbg(mcpdm->dev, "IRQWAKE_EN: 0x%04x\n",
+                       omap_mcpdm_read(MCPDM_IRQWAKE_EN));
+       dev_dbg(mcpdm->dev, "DMAENABLE_SET: 0x%04x\n",
+                       omap_mcpdm_read(MCPDM_DMAENABLE_SET));
+       dev_dbg(mcpdm->dev, "DMAENABLE_CLR:  0x%04x\n",
+                       omap_mcpdm_read(MCPDM_DMAENABLE_CLR));
+       dev_dbg(mcpdm->dev, "DMAWAKEEN:  0x%04x\n",
+                       omap_mcpdm_read(MCPDM_DMAWAKEEN));
+       dev_dbg(mcpdm->dev, "CTRL:  0x%04x\n",
+                       omap_mcpdm_read(MCPDM_CTRL));
+       dev_dbg(mcpdm->dev, "DN_DATA:  0x%04x\n",
+                       omap_mcpdm_read(MCPDM_DN_DATA));
+       dev_dbg(mcpdm->dev, "UP_DATA: 0x%04x\n",
+                       omap_mcpdm_read(MCPDM_UP_DATA));
+       dev_dbg(mcpdm->dev, "FIFO_CTRL_DN: 0x%04x\n",
+                       omap_mcpdm_read(MCPDM_FIFO_CTRL_DN));
+       dev_dbg(mcpdm->dev, "FIFO_CTRL_UP:  0x%04x\n",
+                       omap_mcpdm_read(MCPDM_FIFO_CTRL_UP));
+       dev_dbg(mcpdm->dev, "DN_OFFSET:  0x%04x\n",
+                       omap_mcpdm_read(MCPDM_DN_OFFSET));
+       dev_dbg(mcpdm->dev, "***********************\n");
+}
+
+/*
+ * Takes the McPDM module in and out of reset state.
+ * Uplink and downlink can be reset individually.
+ */
+static void omap_mcpdm_reset_capture(int reset)
+{
+       int ctrl = omap_mcpdm_read(MCPDM_CTRL);
+
+       if (reset)
+               ctrl |= SW_UP_RST;
+       else
+               ctrl &= ~SW_UP_RST;
+
+       omap_mcpdm_write(MCPDM_CTRL, ctrl);
+}
+
+static void omap_mcpdm_reset_playback(int reset)
+{
+       int ctrl = omap_mcpdm_read(MCPDM_CTRL);
+
+       if (reset)
+               ctrl |= SW_DN_RST;
+       else
+               ctrl &= ~SW_DN_RST;
+
+       omap_mcpdm_write(MCPDM_CTRL, ctrl);
+}
+
+/*
+ * Enables the transfer through the PDM interface to/from the Phoenix
+ * codec by enabling the corresponding UP or DN channels.
+ */
+void omap_mcpdm_start(int stream)
+{
+       int ctrl = omap_mcpdm_read(MCPDM_CTRL);
+
+       if (stream)
+               ctrl |= mcpdm->up_channels;
+       else
+               ctrl |= mcpdm->dn_channels;
+
+       omap_mcpdm_write(MCPDM_CTRL, ctrl);
+}
+
+/*
+ * Disables the transfer through the PDM interface to/from the Phoenix
+ * codec by disabling the corresponding UP or DN channels.
+ */
+void omap_mcpdm_stop(int stream)
+{
+       int ctrl = omap_mcpdm_read(MCPDM_CTRL);
+
+       if (stream)
+               ctrl &= ~mcpdm->up_channels;
+       else
+               ctrl &= ~mcpdm->dn_channels;
+
+       omap_mcpdm_write(MCPDM_CTRL, ctrl);
+}
+
+/*
+ * Configures McPDM uplink for audio recording.
+ * This function should be called before omap_mcpdm_start.
+ */
+int omap_mcpdm_capture_open(struct omap_mcpdm_link *uplink)
+{
+       int irq_mask = 0;
+       int ctrl;
+
+       if (!uplink)
+               return -EINVAL;
+
+       mcpdm->uplink = uplink;
+
+       /* Enable irq request generation */
+       irq_mask |= uplink->irq_mask & MCPDM_UPLINK_IRQ_MASK;
+       omap_mcpdm_write(MCPDM_IRQENABLE_SET, irq_mask);
+
+       /* Configure uplink threshold */
+       if (uplink->threshold > UP_THRES_MAX)
+               uplink->threshold = UP_THRES_MAX;
+
+       omap_mcpdm_write(MCPDM_FIFO_CTRL_UP, uplink->threshold);
+
+       /* Configure DMA controller */
+       omap_mcpdm_write(MCPDM_DMAENABLE_SET, DMA_UP_ENABLE);
+
+       /* Set pdm out format */
+       ctrl = omap_mcpdm_read(MCPDM_CTRL);
+       ctrl &= ~PDMOUTFORMAT;
+       ctrl |= uplink->format & PDMOUTFORMAT;
+
+       /* Uplink channels */
+       mcpdm->up_channels = uplink->channels & (PDM_UP_MASK | PDM_STATUS_MASK);
+
+       omap_mcpdm_write(MCPDM_CTRL, ctrl);
+
+       return 0;
+}
+
+/*
+ * Configures McPDM downlink for audio playback.
+ * This function should be called before omap_mcpdm_start.
+ */
+int omap_mcpdm_playback_open(struct omap_mcpdm_link *downlink)
+{
+       int irq_mask = 0;
+       int ctrl;
+
+       if (!downlink)
+               return -EINVAL;
+
+       mcpdm->downlink = downlink;
+
+       /* Enable irq request generation */
+       irq_mask |= downlink->irq_mask & MCPDM_DOWNLINK_IRQ_MASK;
+       omap_mcpdm_write(MCPDM_IRQENABLE_SET, irq_mask);
+
+       /* Configure uplink threshold */
+       if (downlink->threshold > DN_THRES_MAX)
+               downlink->threshold = DN_THRES_MAX;
+
+       omap_mcpdm_write(MCPDM_FIFO_CTRL_DN, downlink->threshold);
+
+       /* Enable DMA request generation */
+       omap_mcpdm_write(MCPDM_DMAENABLE_SET, DMA_DN_ENABLE);
+
+       /* Set pdm out format */
+       ctrl = omap_mcpdm_read(MCPDM_CTRL);
+       ctrl &= ~PDMOUTFORMAT;
+       ctrl |= downlink->format & PDMOUTFORMAT;
+
+       /* Downlink channels */
+       mcpdm->dn_channels = downlink->channels & (PDM_DN_MASK | PDM_CMD_MASK);
+
+       omap_mcpdm_write(MCPDM_CTRL, ctrl);
+
+       return 0;
+}
+
+/*
+ * Cleans McPDM uplink configuration.
+ * This function should be called when the stream is closed.
+ */
+int omap_mcpdm_capture_close(struct omap_mcpdm_link *uplink)
+{
+       int irq_mask = 0;
+
+       if (!uplink)
+               return -EINVAL;
+
+       /* Disable irq request generation */
+       irq_mask |= uplink->irq_mask & MCPDM_UPLINK_IRQ_MASK;
+       omap_mcpdm_write(MCPDM_IRQENABLE_CLR, irq_mask);
+
+       /* Disable DMA request generation */
+       omap_mcpdm_write(MCPDM_DMAENABLE_CLR, DMA_UP_ENABLE);
+
+       /* Clear Downlink channels */
+       mcpdm->up_channels = 0;
+
+       mcpdm->uplink = NULL;
+
+       return 0;
+}
+
+/*
+ * Cleans McPDM downlink configuration.
+ * This function should be called when the stream is closed.
+ */
+int omap_mcpdm_playback_close(struct omap_mcpdm_link *downlink)
+{
+       int irq_mask = 0;
+
+       if (!downlink)
+               return -EINVAL;
+
+       /* Disable irq request generation */
+       irq_mask |= downlink->irq_mask & MCPDM_DOWNLINK_IRQ_MASK;
+       omap_mcpdm_write(MCPDM_IRQENABLE_CLR, irq_mask);
+
+       /* Disable DMA request generation */
+       omap_mcpdm_write(MCPDM_DMAENABLE_CLR, DMA_DN_ENABLE);
+
+       /* clear Downlink channels */
+       mcpdm->dn_channels = 0;
+
+       mcpdm->downlink = NULL;
+
+       return 0;
+}
+
+static irqreturn_t omap_mcpdm_irq_handler(int irq, void *dev_id)
+{
+       struct omap_mcpdm *mcpdm_irq = dev_id;
+       int irq_status;
+
+       irq_status = omap_mcpdm_read(MCPDM_IRQSTATUS);
+
+       /* Acknowledge irq event */
+       omap_mcpdm_write(MCPDM_IRQSTATUS, irq_status);
+
+       if (irq & MCPDM_DN_IRQ_FULL) {
+               dev_err(mcpdm_irq->dev, "DN FIFO error %x\n", irq_status);
+               omap_mcpdm_reset_playback(1);
+               omap_mcpdm_playback_open(mcpdm_irq->downlink);
+               omap_mcpdm_reset_playback(0);
+       }
+
+       if (irq & MCPDM_DN_IRQ_EMPTY) {
+               dev_err(mcpdm_irq->dev, "DN FIFO error %x\n", irq_status);
+               omap_mcpdm_reset_playback(1);
+               omap_mcpdm_playback_open(mcpdm_irq->downlink);
+               omap_mcpdm_reset_playback(0);
+       }
+
+       if (irq & MCPDM_DN_IRQ) {
+               dev_dbg(mcpdm_irq->dev, "DN write request\n");
+       }
+
+       if (irq & MCPDM_UP_IRQ_FULL) {
+               dev_err(mcpdm_irq->dev, "UP FIFO error %x\n", irq_status);
+               omap_mcpdm_reset_capture(1);
+               omap_mcpdm_capture_open(mcpdm_irq->uplink);
+               omap_mcpdm_reset_capture(0);
+       }
+
+       if (irq & MCPDM_UP_IRQ_EMPTY) {
+               dev_err(mcpdm_irq->dev, "UP FIFO error %x\n", irq_status);
+               omap_mcpdm_reset_capture(1);
+               omap_mcpdm_capture_open(mcpdm_irq->uplink);
+               omap_mcpdm_reset_capture(0);
+       }
+
+       if (irq & MCPDM_UP_IRQ) {
+               dev_dbg(mcpdm_irq->dev, "UP write request\n");
+       }
+
+       return IRQ_HANDLED;
+}
+
+int omap_mcpdm_request(void)
+{
+       int ret;
+
+       clk_enable(mcpdm->clk);
+
+       spin_lock(&mcpdm->lock);
+
+       if (!mcpdm->free) {
+               dev_err(mcpdm->dev, "McPDM interface is in use\n");
+               spin_unlock(&mcpdm->lock);
+               ret = -EBUSY;
+               goto err;
+       }
+       mcpdm->free = 0;
+
+       spin_unlock(&mcpdm->lock);
+
+       /* Disable lines while request is ongoing */
+       omap_mcpdm_write(MCPDM_CTRL, 0x00);
+
+       ret = request_irq(mcpdm->irq, omap_mcpdm_irq_handler,
+                               0, "McPDM", (void *)mcpdm);
+       if (ret) {
+               dev_err(mcpdm->dev, "Request for McPDM IRQ failed\n");
+               goto err;
+       }
+
+       return 0;
+
+err:
+       clk_disable(mcpdm->clk);
+       return ret;
+}
+
+void omap_mcpdm_free(void)
+{
+       spin_lock(&mcpdm->lock);
+       if (mcpdm->free) {
+               dev_err(mcpdm->dev, "McPDM interface is already free\n");
+               spin_unlock(&mcpdm->lock);
+               return;
+       }
+       mcpdm->free = 1;
+       spin_unlock(&mcpdm->lock);
+
+       clk_disable(mcpdm->clk);
+
+       free_irq(mcpdm->irq, (void *)mcpdm);
+}
+
+/* Enable/disable DC offset cancelation for the analog
+ * headset path (PDM channels 1 and 2).
+ */
+int omap_mcpdm_set_offset(int offset1, int offset2)
+{
+       int offset;
+
+       if ((offset1 > DN_OFST_MAX) || (offset2 > DN_OFST_MAX))
+               return -EINVAL;
+
+       offset = (offset1 << DN_OFST_RX1) | (offset2 << DN_OFST_RX2);
+
+       /* offset cancellation for channel 1 */
+       if (offset1)
+               offset |= DN_OFST_RX1_EN;
+       else
+               offset &= ~DN_OFST_RX1_EN;
+
+       /* offset cancellation for channel 2 */
+       if (offset2)
+               offset |= DN_OFST_RX2_EN;
+       else
+               offset &= ~DN_OFST_RX2_EN;
+
+       omap_mcpdm_write(MCPDM_DN_OFFSET, offset);
+
+       return 0;
+}
+
+static int __devinit omap_mcpdm_probe(struct platform_device *pdev)
+{
+       struct resource *res;
+       int ret = 0;
+
+       mcpdm = kzalloc(sizeof(struct omap_mcpdm), GFP_KERNEL);
+       if (!mcpdm) {
+               ret = -ENOMEM;
+               goto exit;
+       }
+
+       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+       if (res == NULL) {
+               dev_err(&pdev->dev, "no resource\n");
+               goto err_resource;
+       }
+
+       spin_lock_init(&mcpdm->lock);
+       mcpdm->free = 1;
+       mcpdm->io_base = ioremap(res->start, resource_size(res));
+       if (!mcpdm->io_base) {
+               ret = -ENOMEM;
+               goto err_resource;
+       }
+
+       mcpdm->irq = platform_get_irq(pdev, 0);
+
+       mcpdm->clk = clk_get(&pdev->dev, "pdm_ck");
+       if (IS_ERR(mcpdm->clk)) {
+               ret = PTR_ERR(mcpdm->clk);
+               dev_err(&pdev->dev, "unable to get pdm_ck: %d\n", ret);
+               goto err_clk;
+       }
+
+       mcpdm->dev = &pdev->dev;
+       platform_set_drvdata(pdev, mcpdm);
+
+       return 0;
+
+err_clk:
+       iounmap(mcpdm->io_base);
+err_resource:
+       kfree(mcpdm);
+exit:
+       return ret;
+}
+
+static int __devexit omap_mcpdm_remove(struct platform_device *pdev)
+{
+       struct omap_mcpdm *mcpdm_ptr = platform_get_drvdata(pdev);
+
+       platform_set_drvdata(pdev, NULL);
+
+       clk_put(mcpdm_ptr->clk);
+
+       iounmap(mcpdm_ptr->io_base);
+
+       mcpdm_ptr->clk = NULL;
+       mcpdm_ptr->free = 0;
+       mcpdm_ptr->dev = NULL;
+
+       kfree(mcpdm_ptr);
+
+       return 0;
+}
+
+static struct platform_driver omap_mcpdm_driver = {
+       .probe = omap_mcpdm_probe,
+       .remove = __devexit_p(omap_mcpdm_remove),
+       .driver = {
+               .name = "omap-mcpdm",
+       },
+};
+
+static struct platform_device *omap_mcpdm_device;
+
+static int __init omap_mcpdm_init(void)
+{
+       return platform_driver_register(&omap_mcpdm_driver);
+}
+arch_initcall(omap_mcpdm_init);
diff --git a/sound/soc/omap/mcpdm.h b/sound/soc/omap/mcpdm.h
new file mode 100644
index 000000000000..7bb326ef0886
--- /dev/null
+++ b/sound/soc/omap/mcpdm.h
@@ -0,0 +1,151 @@
+/*
+ * mcpdm.h -- Defines for McPDM driver
+ *
+ * Author: Jorge Eduardo Candelaria <x0107209@ti.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program 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., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+/* McPDM registers */
+
+#define MCPDM_REVISION         0x00
+#define MCPDM_SYSCONFIG                0x10
+#define MCPDM_IRQSTATUS_RAW    0x24
+#define MCPDM_IRQSTATUS                0x28
+#define MCPDM_IRQENABLE_SET    0x2C
+#define MCPDM_IRQENABLE_CLR    0x30
+#define MCPDM_IRQWAKE_EN       0x34
+#define MCPDM_DMAENABLE_SET    0x38
+#define MCPDM_DMAENABLE_CLR    0x3C
+#define MCPDM_DMAWAKEEN                0x40
+#define MCPDM_CTRL             0x44
+#define MCPDM_DN_DATA          0x48
+#define MCPDM_UP_DATA          0x4C
+#define MCPDM_FIFO_CTRL_DN     0x50
+#define MCPDM_FIFO_CTRL_UP     0x54
+#define MCPDM_DN_OFFSET                0x58
+
+/*
+ * MCPDM_IRQ bit fields
+ * IRQSTATUS_RAW, IRQSTATUS, IRQENABLE_SET, IRQENABLE_CLR
+ */
+
+#define MCPDM_DN_IRQ                   (1 << 0)
+#define MCPDM_DN_IRQ_EMPTY             (1 << 1)
+#define MCPDM_DN_IRQ_ALMST_EMPTY       (1 << 2)
+#define MCPDM_DN_IRQ_FULL              (1 << 3)
+
+#define MCPDM_UP_IRQ                   (1 << 8)
+#define MCPDM_UP_IRQ_EMPTY             (1 << 9)
+#define MCPDM_UP_IRQ_ALMST_FULL                (1 << 10)
+#define MCPDM_UP_IRQ_FULL              (1 << 11)
+
+#define MCPDM_DOWNLINK_IRQ_MASK                0x00F
+#define MCPDM_UPLINK_IRQ_MASK          0xF00
+
+/*
+ * MCPDM_DMAENABLE bit fields
+ */
+
+#define DMA_DN_ENABLE          0x1
+#define DMA_UP_ENABLE          0x2
+
+/*
+ * MCPDM_CTRL bit fields
+ */
+
+#define PDM_UP1_EN             0x0001
+#define PDM_UP2_EN             0x0002
+#define PDM_UP3_EN             0x0004
+#define PDM_DN1_EN             0x0008
+#define PDM_DN2_EN             0x0010
+#define PDM_DN3_EN             0x0020
+#define PDM_DN4_EN             0x0040
+#define PDM_DN5_EN             0x0080
+#define PDMOUTFORMAT           0x0100
+#define CMD_INT                        0x0200
+#define STATUS_INT             0x0400
+#define SW_UP_RST              0x0800
+#define SW_DN_RST              0x1000
+#define PDM_UP_MASK            0x007
+#define PDM_DN_MASK            0x0F8
+#define PDM_CMD_MASK           0x200
+#define PDM_STATUS_MASK                0x400
+
+
+#define PDMOUTFORMAT_LJUST     (0 << 8)
+#define PDMOUTFORMAT_RJUST     (1 << 8)
+
+/*
+ * MCPDM_FIFO_CTRL bit fields
+ */
+
+#define UP_THRES_MAX           0xF
+#define DN_THRES_MAX           0xF
+
+/*
+ * MCPDM_DN_OFFSET bit fields
+ */
+
+#define DN_OFST_RX1_EN         0x0001
+#define DN_OFST_RX2_EN         0x0100
+
+#define DN_OFST_RX1            1
+#define DN_OFST_RX2            9
+#define DN_OFST_MAX            0x1F
+
+#define MCPDM_UPLINK           1
+#define MCPDM_DOWNLINK         2
+
+struct omap_mcpdm_link {
+       int irq_mask;
+       int threshold;
+       int format;
+       int channels;
+};
+
+struct omap_mcpdm_platform_data {
+       unsigned long phys_base;
+       u16 irq;
+};
+
+struct omap_mcpdm {
+       struct device *dev;
+       unsigned long phys_base;
+       void __iomem *io_base;
+       u8 free;
+       int irq;
+
+       spinlock_t lock;
+       struct omap_mcpdm_platform_data *pdata;
+       struct clk *clk;
+       struct omap_mcpdm_link *downlink;
+       struct omap_mcpdm_link *uplink;
+       struct completion irq_completion;
+
+       int dn_channels;
+       int up_channels;
+};
+
+extern void omap_mcpdm_start(int stream);
+extern void omap_mcpdm_stop(int stream);
+extern int omap_mcpdm_capture_open(struct omap_mcpdm_link *uplink);
+extern int omap_mcpdm_playback_open(struct omap_mcpdm_link *downlink);
+extern int omap_mcpdm_capture_close(struct omap_mcpdm_link *uplink);
+extern int omap_mcpdm_playback_close(struct omap_mcpdm_link *downlink);
+extern int omap_mcpdm_request(void);
+extern void omap_mcpdm_free(void);
+extern int omap_mcpdm_set_offset(int offset1, int offset2);
diff --git a/sound/soc/omap/n810.c b/sound/soc/omap/n810.c
index 0a505938e42b..08e09d72790f 100644
--- a/sound/soc/omap/n810.c
+++ b/sound/soc/omap/n810.c
@@ -32,7 +32,7 @@
 #include <asm/mach-types.h>
 #include <mach/hardware.h>
 #include <linux/gpio.h>
-#include <mach/mcbsp.h>
+#include <plat/mcbsp.h>
 
 #include "omap-mcbsp.h"
 #include "omap-pcm.h"
diff --git a/sound/soc/omap/omap-mcbsp.c b/sound/soc/omap/omap-mcbsp.c
index 3341f49402ca..8ad9dc901007 100644
--- a/sound/soc/omap/omap-mcbsp.c
+++ b/sound/soc/omap/omap-mcbsp.c
@@ -31,14 +31,22 @@
 #include <sound/initval.h>
 #include <sound/soc.h>
 
-#include <mach/control.h>
-#include <mach/dma.h>
-#include <mach/mcbsp.h>
+#include <plat/control.h>
+#include <plat/dma.h>
+#include <plat/mcbsp.h>
 #include "omap-mcbsp.h"
 #include "omap-pcm.h"
 
 #define OMAP_MCBSP_RATES        (SNDRV_PCM_RATE_8000_96000)
 
+#define OMAP_MCBSP_SOC_SINGLE_S16_EXT(xname, xmin, xmax, \
+        xhandler_get, xhandler_put) \
+{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
+        .info = omap_mcbsp_st_info_volsw, \
+        .get = xhandler_get, .put = xhandler_put, \
+        .private_value = (unsigned long) &(struct soc_mixer_control) \
+        {.min = xmin, .max = xmax} }
+
 struct omap_mcbsp_data {
         unsigned int                    bus_id;
         struct omap_mcbsp_reg_cfg       regs;
@@ -49,6 +57,8 @@ struct omap_mcbsp_data {
          */
         int                             active;
         int                             configured;
+        unsigned int                    in_freq;
+        int                             clk_div;
 };
 
 #define to_mcbsp(priv)  container_of((priv), struct omap_mcbsp_data, bus_id)
@@ -80,11 +90,11 @@ static const int omap1_dma_reqs[][2] = {};
 static const unsigned long omap1_mcbsp_port[][2] = {};
 #endif
 
-#if defined(CONFIG_ARCH_OMAP24XX) || defined(CONFIG_ARCH_OMAP34XX)
+#if defined(CONFIG_ARCH_OMAP2) || defined(CONFIG_ARCH_OMAP3)
 static const int omap24xx_dma_reqs[][2] = {
         { OMAP24XX_DMA_MCBSP1_TX, OMAP24XX_DMA_MCBSP1_RX },
         { OMAP24XX_DMA_MCBSP2_TX, OMAP24XX_DMA_MCBSP2_RX },
-#if defined(CONFIG_ARCH_OMAP2430) || defined(CONFIG_ARCH_OMAP34XX)
+#if defined(CONFIG_ARCH_OMAP2430) || defined(CONFIG_ARCH_OMAP3)
         { OMAP24XX_DMA_MCBSP3_TX, OMAP24XX_DMA_MCBSP3_RX },
         { OMAP24XX_DMA_MCBSP4_TX, OMAP24XX_DMA_MCBSP4_RX },
         { OMAP24XX_DMA_MCBSP5_TX, OMAP24XX_DMA_MCBSP5_RX },
@@ -122,7 +132,7 @@ static const unsigned long omap2430_mcbsp_port[][2] = {
 static const unsigned long omap2430_mcbsp_port[][2] = {};
 #endif
 
-#if defined(CONFIG_ARCH_OMAP34XX)
+#if defined(CONFIG_ARCH_OMAP3)
 static const unsigned long omap34xx_mcbsp_port[][2] = {
         { OMAP34XX_MCBSP1_BASE + OMAP_MCBSP_REG_DXR,
           OMAP34XX_MCBSP1_BASE + OMAP_MCBSP_REG_DRR },
@@ -257,7 +267,7 @@ static int omap_mcbsp_dai_hw_params(struct snd_pcm_substream *substream,
         int dma, bus_id = mcbsp_data->bus_id, id = cpu_dai->id;
         int wlen, channels, wpf, sync_mode = OMAP_DMA_SYNC_ELEMENT;
         unsigned long port;
-        unsigned int format;
+        unsigned int format, div, framesize, master;
 
         if (cpu_class_is_omap1()) {
                 dma = omap1_dma_reqs[bus_id][substream->stream];
@@ -285,7 +295,11 @@ static int omap_mcbsp_dai_hw_params(struct snd_pcm_substream *substream,
         omap_mcbsp_dai_dma_params[id][substream->stream].dma_req = dma;
         omap_mcbsp_dai_dma_params[id][substream->stream].port_addr = port;
         omap_mcbsp_dai_dma_params[id][substream->stream].sync_mode = sync_mode;
-        cpu_dai->dma_data = &omap_mcbsp_dai_dma_params[id][substream->stream];
+        omap_mcbsp_dai_dma_params[id][substream->stream].data_type =
+                                                        OMAP_DMA_DATA_TYPE_S16;
+
+        snd_soc_dai_set_dma_data(cpu_dai, substream,
+                &omap_mcbsp_dai_dma_params[id][substream->stream]);
 
         if (mcbsp_data->configured) {
                 /* McBSP already configured by another stream */
@@ -294,28 +308,19 @@ static int omap_mcbsp_dai_hw_params(struct snd_pcm_substream *substream,
 
         format = mcbsp_data->fmt & SND_SOC_DAIFMT_FORMAT_MASK;
         wpf = channels = params_channels(params);
-        switch (channels) {
-        case 2:
-                if (format == SND_SOC_DAIFMT_I2S) {
-                        /* Use dual-phase frames */
-                        regs->rcr2      |= RPHASE;
-                        regs->xcr2      |= XPHASE;
-                        /* Set 1 word per (McBSP) frame for phase1 and phase2 */
-                        wpf--;
-                        regs->rcr2      |= RFRLEN2(wpf - 1);
-                        regs->xcr2      |= XFRLEN2(wpf - 1);
-                }
-        case 1:
-        case 4:
-                /* Set word per (McBSP) frame for phase1 */
-                regs->rcr1      |= RFRLEN1(wpf - 1);
-                regs->xcr1      |= XFRLEN1(wpf - 1);
-                break;
-        default:
-                /* Unsupported number of channels */
-                return -EINVAL;
+        if (channels == 2 && format == SND_SOC_DAIFMT_I2S) {
+                /* Use dual-phase frames */
+                regs->rcr2      |= RPHASE;
+                regs->xcr2      |= XPHASE;
+                /* Set 1 word per (McBSP) frame for phase1 and phase2 */
+                wpf--;
+                regs->rcr2      |= RFRLEN2(wpf - 1);
+                regs->xcr2      |= XFRLEN2(wpf - 1);
         }
 
+        regs->rcr1      |= RFRLEN1(wpf - 1);
+        regs->xcr1      |= XFRLEN1(wpf - 1);
+
         switch (params_format(params)) {
         case SNDRV_PCM_FORMAT_S16_LE:
                 /* Set word lengths */
@@ -330,15 +335,30 @@ static int omap_mcbsp_dai_hw_params(struct snd_pcm_substream *substream,
                 return -EINVAL;
         }
 
+        /* In McBSP master modes, FRAME (i.e. sample rate) is generated
+         * by _counting_ BCLKs. Calculate frame size in BCLKs */
+        master = mcbsp_data->fmt & SND_SOC_DAIFMT_MASTER_MASK;
+        if (master ==   SND_SOC_DAIFMT_CBS_CFS) {
+                div = mcbsp_data->clk_div ? mcbsp_data->clk_div : 1;
+                framesize = (mcbsp_data->in_freq / div) / params_rate(params);
+
+                if (framesize < wlen * channels) {
+                        printk(KERN_ERR "%s: not enough bandwidth for desired rate and "
+                                        "channels\n", __func__);
+                        return -EINVAL;
+                }
+        } else
+                framesize = wlen * channels;
+
         /* Set FS period and length in terms of bit clock periods */
         switch (format) {
         case SND_SOC_DAIFMT_I2S:
-                regs->srgr2     |= FPER(wlen * channels - 1);
-                regs->srgr1     |= FWID(wlen - 1);
+                regs->srgr2     |= FPER(framesize - 1);
+                regs->srgr1     |= FWID((framesize >> 1) - 1);
                 break;
         case SND_SOC_DAIFMT_DSP_A:
         case SND_SOC_DAIFMT_DSP_B:
-                regs->srgr2     |= FPER(wlen * channels - 1);
+                regs->srgr2     |= FPER(framesize - 1);
                 regs->srgr1     |= FWID(0);
                 break;
         }
@@ -454,6 +474,7 @@ static int omap_mcbsp_dai_set_clkdiv(struct snd_soc_dai *cpu_dai,
         if (div_id != OMAP_MCBSP_CLKGDV)
                 return -ENODEV;
 
+        mcbsp_data->clk_div = div;
         regs->srgr1     |= CLKGDV(div - 1);
 
         return 0;
@@ -554,6 +575,8 @@ static int omap_mcbsp_dai_set_dai_sysclk(struct snd_soc_dai *cpu_dai,
         struct omap_mcbsp_reg_cfg *regs = &mcbsp_data->regs;
         int err = 0;
 
+        mcbsp_data->in_freq = freq;
+
         switch (clk_id) {
         case OMAP_MCBSP_SYSCLK_CLK:
                 regs->srgr2     |= CLKSM;
@@ -598,13 +621,13 @@ static struct snd_soc_dai_ops omap_mcbsp_dai_ops = {
         .id = (link_id),                                        \
         .playback = {                                           \
                 .channels_min = 1,                              \
-                .channels_max = 4,                              \
+                .channels_max = 16,                             \
                 .rates = OMAP_MCBSP_RATES,                      \
                 .formats = SNDRV_PCM_FMTBIT_S16_LE,             \
         },                                                      \
         .capture = {                                            \
                 .channels_min = 1,                              \
-                .channels_max = 4,                              \
+                .channels_max = 16,                             \
                 .rates = OMAP_MCBSP_RATES,                      \
                 .formats = SNDRV_PCM_FMTBIT_S16_LE,             \
         },                                                      \
@@ -626,6 +649,136 @@ struct snd_soc_dai omap_mcbsp_dai[] = {
 
 EXPORT_SYMBOL_GPL(omap_mcbsp_dai);
 
+int omap_mcbsp_st_info_volsw(struct snd_kcontrol *kcontrol,
+                        struct snd_ctl_elem_info *uinfo)
+{
+        struct soc_mixer_control *mc =
+                (struct soc_mixer_control *)kcontrol->private_value;
+        int max = mc->max;
+        int min = mc->min;
+
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+        uinfo->count = 1;
+        uinfo->value.integer.min = min;
+        uinfo->value.integer.max = max;
+        return 0;
+}
+
+#define OMAP_MCBSP_ST_SET_CHANNEL_VOLUME(id, channel)                   \
+static int                                                              \
+omap_mcbsp##id##_set_st_ch##channel##_volume(struct snd_kcontrol *kc,   \
+                                        struct snd_ctl_elem_value *uc)  \
+{                                                                       \
+        struct soc_mixer_control *mc =                                  \
+                (struct soc_mixer_control *)kc->private_value;          \
+        int max = mc->max;                                              \
+        int min = mc->min;                                              \
+        int val = uc->value.integer.value[0];                           \
+                                                                        \
+        if (val < min || val > max)                                     \
+                return -EINVAL;                                         \
+                                                                        \
+        /* OMAP McBSP implementation uses index values 0..4 */          \
+        return omap_st_set_chgain((id)-1, channel, val);                \
+}
+
+#define OMAP_MCBSP_ST_GET_CHANNEL_VOLUME(id, channel)                   \
+static int                                                              \
+omap_mcbsp##id##_get_st_ch##channel##_volume(struct snd_kcontrol *kc,   \
+                                        struct snd_ctl_elem_value *uc)  \
+{                                                                       \
+        s16 chgain;                                                     \
+                                                                        \
+        if (omap_st_get_chgain((id)-1, channel, &chgain))               \
+                return -EAGAIN;                                         \
+                                                                        \
+        uc->value.integer.value[0] = chgain;                            \
+        return 0;                                                       \
+}
+
+OMAP_MCBSP_ST_SET_CHANNEL_VOLUME(2, 0)
+OMAP_MCBSP_ST_SET_CHANNEL_VOLUME(2, 1)
+OMAP_MCBSP_ST_SET_CHANNEL_VOLUME(3, 0)
+OMAP_MCBSP_ST_SET_CHANNEL_VOLUME(3, 1)
+OMAP_MCBSP_ST_GET_CHANNEL_VOLUME(2, 0)
+OMAP_MCBSP_ST_GET_CHANNEL_VOLUME(2, 1)
+OMAP_MCBSP_ST_GET_CHANNEL_VOLUME(3, 0)
+OMAP_MCBSP_ST_GET_CHANNEL_VOLUME(3, 1)
+
+static int omap_mcbsp_st_put_mode(struct snd_kcontrol *kcontrol,
+                                struct snd_ctl_elem_value *ucontrol)
+{
+        struct soc_mixer_control *mc =
+                (struct soc_mixer_control *)kcontrol->private_value;
+        u8 value = ucontrol->value.integer.value[0];
+
+        if (value == omap_st_is_enabled(mc->reg))
+                return 0;
+
+        if (value)
+                omap_st_enable(mc->reg);
+        else
+                omap_st_disable(mc->reg);
+
+        return 1;
+}
+
+static int omap_mcbsp_st_get_mode(struct snd_kcontrol *kcontrol,
+                                struct snd_ctl_elem_value *ucontrol)
+{
+        struct soc_mixer_control *mc =
+                (struct soc_mixer_control *)kcontrol->private_value;
+
+        ucontrol->value.integer.value[0] = omap_st_is_enabled(mc->reg);
+        return 0;
+}
+
+static const struct snd_kcontrol_new omap_mcbsp2_st_controls[] = {
+        SOC_SINGLE_EXT("McBSP2 Sidetone Switch", 1, 0, 1, 0,
+                        omap_mcbsp_st_get_mode, omap_mcbsp_st_put_mode),
+        OMAP_MCBSP_SOC_SINGLE_S16_EXT("McBSP2 Sidetone Channel 0 Volume",
+                                      -32768, 32767,
+                                      omap_mcbsp2_get_st_ch0_volume,
+                                      omap_mcbsp2_set_st_ch0_volume),
+        OMAP_MCBSP_SOC_SINGLE_S16_EXT("McBSP2 Sidetone Channel 1 Volume",
+                                      -32768, 32767,
+                                      omap_mcbsp2_get_st_ch1_volume,
+                                      omap_mcbsp2_set_st_ch1_volume),
+};
+
+static const struct snd_kcontrol_new omap_mcbsp3_st_controls[] = {
+        SOC_SINGLE_EXT("McBSP3 Sidetone Switch", 2, 0, 1, 0,
+                        omap_mcbsp_st_get_mode, omap_mcbsp_st_put_mode),
+        OMAP_MCBSP_SOC_SINGLE_S16_EXT("McBSP3 Sidetone Channel 0 Volume",
+                                      -32768, 32767,
+                                      omap_mcbsp3_get_st_ch0_volume,
+                                      omap_mcbsp3_set_st_ch0_volume),
+        OMAP_MCBSP_SOC_SINGLE_S16_EXT("McBSP3 Sidetone Channel 1 Volume",
+                                      -32768, 32767,
+                                      omap_mcbsp3_get_st_ch1_volume,
+                                      omap_mcbsp3_set_st_ch1_volume),
+};
+
+int omap_mcbsp_st_add_controls(struct snd_soc_codec *codec, int mcbsp_id)
+{
+        if (!cpu_is_omap34xx())
+                return -ENODEV;
+
+        switch (mcbsp_id) {
+        case 1: /* McBSP 2 */
+                return snd_soc_add_controls(codec, omap_mcbsp2_st_controls,
+                                        ARRAY_SIZE(omap_mcbsp2_st_controls));
+        case 2: /* McBSP 3 */
+                return snd_soc_add_controls(codec, omap_mcbsp3_st_controls,
+                                        ARRAY_SIZE(omap_mcbsp3_st_controls));
+        default:
+                break;
+        }
+
+        return -EINVAL;
+}
+EXPORT_SYMBOL_GPL(omap_mcbsp_st_add_controls);
+
 static int __init snd_omap_mcbsp_init(void)
 {
         return snd_soc_register_dais(omap_mcbsp_dai,
diff --git a/sound/soc/omap/omap-mcbsp.h b/sound/soc/omap/omap-mcbsp.h
index 647d2f981ab0..6c363e5f4387 100644
--- a/sound/soc/omap/omap-mcbsp.h
+++ b/sound/soc/omap/omap-mcbsp.h
@@ -50,11 +50,13 @@ enum omap_mcbsp_div {
 #undef  NUM_LINKS
 #define NUM_LINKS       3
 #endif
-#if defined(CONFIG_ARCH_OMAP2430) || defined(CONFIG_ARCH_OMAP34XX)
+#if defined(CONFIG_ARCH_OMAP2430) || defined(CONFIG_ARCH_OMAP3)
 #undef  NUM_LINKS
 #define NUM_LINKS       5
 #endif
 
 extern struct snd_soc_dai omap_mcbsp_dai[NUM_LINKS];
 
+int omap_mcbsp_st_add_controls(struct snd_soc_codec *codec, int mcbsp_id);
+
 #endif
diff --git a/sound/soc/omap/omap-mcpdm.c b/sound/soc/omap/omap-mcpdm.c
new file mode 100644
index 000000000000..b7f4f7e015f3
--- /dev/null
+++ b/sound/soc/omap/omap-mcpdm.c
@@ -0,0 +1,252 @@
+/*
+ * omap-mcpdm.c  --  OMAP ALSA SoC DAI driver using McPDM port
+ *
+ * Copyright (C) 2009 Texas Instruments
+ *
+ * Author: Misael Lopez Cruz <x0052729@ti.com>
+ * Contact: Jorge Eduardo Candelaria <x0107209@ti.com>
+ *          Margarita Olaya <magi.olaya@ti.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program 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., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/device.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/initval.h>
+#include <sound/soc.h>
+
+#include <plat/control.h>
+#include <plat/dma.h>
+#include <plat/mcbsp.h>
+#include "mcpdm.h"
+#include "omap-mcpdm.h"
+#include "omap-pcm.h"
+
+struct omap_mcpdm_data {
+        struct omap_mcpdm_link *links;
+        int active;
+};
+
+static struct omap_mcpdm_link omap_mcpdm_links[] = {
+        /* downlink */
+        {
+                .irq_mask = MCPDM_DN_IRQ_EMPTY | MCPDM_DN_IRQ_FULL,
+                .threshold = 1,
+                .format = PDMOUTFORMAT_LJUST,
+        },
+        /* uplink */
+        {
+                .irq_mask = MCPDM_UP_IRQ_EMPTY | MCPDM_UP_IRQ_FULL,
+                .threshold = 1,
+                .format = PDMOUTFORMAT_LJUST,
+        },
+};
+
+static struct omap_mcpdm_data mcpdm_data = {
+        .links = omap_mcpdm_links,
+        .active = 0,
+};
+
+/*
+ * Stream DMA parameters
+ */
+static struct omap_pcm_dma_data omap_mcpdm_dai_dma_params[] = {
+        {
+                .name = "Audio playback",
+                .dma_req = OMAP44XX_DMA_MCPDM_DL,
+                .data_type = OMAP_DMA_DATA_TYPE_S32,
+                .sync_mode = OMAP_DMA_SYNC_PACKET,
+                .packet_size = 16,
+                .port_addr = OMAP44XX_MCPDM_L3_BASE + MCPDM_DN_DATA,
+        },
+        {
+                .name = "Audio capture",
+                .dma_req = OMAP44XX_DMA_MCPDM_UP,
+                .data_type = OMAP_DMA_DATA_TYPE_S32,
+                .sync_mode = OMAP_DMA_SYNC_PACKET,
+                .packet_size = 16,
+                .port_addr = OMAP44XX_MCPDM_L3_BASE + MCPDM_UP_DATA,
+        },
+};
+
+static int omap_mcpdm_dai_startup(struct snd_pcm_substream *substream,
+                                  struct snd_soc_dai *dai)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
+        int err = 0;
+
+        if (!cpu_dai->active)
+                err = omap_mcpdm_request();
+
+        return err;
+}
+
+static void omap_mcpdm_dai_shutdown(struct snd_pcm_substream *substream,
+                                    struct snd_soc_dai *dai)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
+
+        if (!cpu_dai->active)
+                omap_mcpdm_free();
+}
+
+static int omap_mcpdm_dai_trigger(struct snd_pcm_substream *substream, int cmd,
+                                  struct snd_soc_dai *dai)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
+        struct omap_mcpdm_data *mcpdm_priv = cpu_dai->private_data;
+        int stream = substream->stream;
+        int err = 0;
+
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+        case SNDRV_PCM_TRIGGER_RESUME:
+        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
+                if (!mcpdm_priv->active++)
+                        omap_mcpdm_start(stream);
+                break;
+
+        case SNDRV_PCM_TRIGGER_STOP:
+        case SNDRV_PCM_TRIGGER_SUSPEND:
+        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
+                if (!--mcpdm_priv->active)
+                        omap_mcpdm_stop(stream);
+                break;
+        default:
+                err = -EINVAL;
+        }
+
+        return err;
+}
+
+static int omap_mcpdm_dai_hw_params(struct snd_pcm_substream *substream,
+                                    struct snd_pcm_hw_params *params,
+                                    struct snd_soc_dai *dai)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
+        struct omap_mcpdm_data *mcpdm_priv = cpu_dai->private_data;
+        struct omap_mcpdm_link *mcpdm_links = mcpdm_priv->links;
+        int stream = substream->stream;
+        int channels, err, link_mask = 0;
+
+        snd_soc_dai_set_dma_data(cpu_dai, substream,
+                                 &omap_mcpdm_dai_dma_params[stream]);
+
+        channels = params_channels(params);
+        switch (channels) {
+        case 4:
+                if (stream == SNDRV_PCM_STREAM_CAPTURE)
+                        /* up to 2 channels for capture */
+                        return -EINVAL;
+                link_mask |= 1 << 3;
+        case 3:
+                if (stream == SNDRV_PCM_STREAM_CAPTURE)
+                        /* up to 2 channels for capture */
+                        return -EINVAL;
+                link_mask |= 1 << 2;
+        case 2:
+                link_mask |= 1 << 1;
+        case 1:
+                link_mask |= 1 << 0;
+                break;
+        default:
+                /* unsupported number of channels */
+                return -EINVAL;
+        }
+
+        if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
+                mcpdm_links[stream].channels = link_mask << 3;
+                err = omap_mcpdm_playback_open(&mcpdm_links[stream]);
+        } else {
+                mcpdm_links[stream].channels = link_mask << 0;
+                err = omap_mcpdm_capture_open(&mcpdm_links[stream]);
+        }
+
+        return err;
+}
+
+static int omap_mcpdm_dai_hw_free(struct snd_pcm_substream *substream,
+                                  struct snd_soc_dai *dai)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
+        struct omap_mcpdm_data *mcpdm_priv = cpu_dai->private_data;
+        struct omap_mcpdm_link *mcpdm_links = mcpdm_priv->links;
+        int stream = substream->stream;
+        int err;
+
+        if (substream->stream ==  SNDRV_PCM_STREAM_PLAYBACK)
+                err = omap_mcpdm_playback_close(&mcpdm_links[stream]);
+        else
+                err = omap_mcpdm_capture_close(&mcpdm_links[stream]);
+
+        return err;
+}
+
+static struct snd_soc_dai_ops omap_mcpdm_dai_ops = {
+        .startup        = omap_mcpdm_dai_startup,
+        .shutdown       = omap_mcpdm_dai_shutdown,
+        .trigger        = omap_mcpdm_dai_trigger,
+        .hw_params      = omap_mcpdm_dai_hw_params,
+        .hw_free        = omap_mcpdm_dai_hw_free,
+};
+
+#define OMAP_MCPDM_RATES        (SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000)
+#define OMAP_MCPDM_FORMATS      (SNDRV_PCM_FMTBIT_S32_LE)
+
+struct snd_soc_dai omap_mcpdm_dai = {
+        .name = "omap-mcpdm",
+        .id = -1,
+        .playback = {
+                .channels_min = 1,
+                .channels_max = 4,
+                .rates = OMAP_MCPDM_RATES,
+                .formats = OMAP_MCPDM_FORMATS,
+        },
+        .capture = {
+                .channels_min = 1,
+                .channels_max = 2,
+                .rates = OMAP_MCPDM_RATES,
+                .formats = OMAP_MCPDM_FORMATS,
+        },
+        .ops = &omap_mcpdm_dai_ops,
+        .private_data = &mcpdm_data,
+};
+EXPORT_SYMBOL_GPL(omap_mcpdm_dai);
+
+static int __init snd_omap_mcpdm_init(void)
+{
+        return snd_soc_register_dai(&omap_mcpdm_dai);
+}
+module_init(snd_omap_mcpdm_init);
+
+static void __exit snd_omap_mcpdm_exit(void)
+{
+        snd_soc_unregister_dai(&omap_mcpdm_dai);
+}
+module_exit(snd_omap_mcpdm_exit);
+
+MODULE_AUTHOR("Misael Lopez Cruz <x0052729@ti.com>");
+MODULE_DESCRIPTION("OMAP PDM SoC Interface");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/omap/omap-mcpdm.h b/sound/soc/omap/omap-mcpdm.h
new file mode 100644
index 000000000000..73b80d559345
--- /dev/null
+++ b/sound/soc/omap/omap-mcpdm.h
@@ -0,0 +1,29 @@
+/*
+ * omap-mcpdm.h
+ *
+ * Copyright (C) 2009 Texas Instruments
+ *
+ * Contact: Misael Lopez Cruz <x0052729@ti.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program 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., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#ifndef __OMAP_MCPDM_H__
+#define __OMAP_MCPDM_H__
+
+extern struct snd_soc_dai omap_mcpdm_dai;
+
+#endif  /* End of __OMAP_MCPDM_H__ */
diff --git a/sound/soc/omap/omap-pcm.c b/sound/soc/omap/omap-pcm.c
index 6a829eef2a4f..1e521904ea64 100644
--- a/sound/soc/omap/omap-pcm.c
+++ b/sound/soc/omap/omap-pcm.c
@@ -23,12 +23,13 @@
  */
 
 #include <linux/dma-mapping.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
 #include <sound/soc.h>
 
-#include <mach/dma.h>
+#include <plat/dma.h>
 #include "omap-pcm.h"
 
 static const struct snd_pcm_hardware omap_pcm_hardware = {
@@ -37,7 +38,8 @@ static const struct snd_pcm_hardware omap_pcm_hardware = {
                                   SNDRV_PCM_INFO_INTERLEAVED |
                                   SNDRV_PCM_INFO_PAUSE |
                                   SNDRV_PCM_INFO_RESUME,
-        .formats                = SNDRV_PCM_FMTBIT_S16_LE,
+        .formats                = SNDRV_PCM_FMTBIT_S16_LE |
+                                  SNDRV_PCM_FMTBIT_S32_LE,
         .period_bytes_min       = 32,
         .period_bytes_max       = 64 * 1024,
         .periods_min            = 2,
@@ -59,12 +61,11 @@ static void omap_pcm_dma_irq(int ch, u16 stat, void *data)
         struct omap_runtime_data *prtd = runtime->private_data;
         unsigned long flags;
 
-        if ((cpu_is_omap1510()) &&
-                        (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)) {
+        if ((cpu_is_omap1510())) {
                 /*
                  * OMAP1510 doesn't fully support DMA progress counter
                  * and there is no software emulation implemented yet,
-                 * so have to maintain our own playback progress counter
+                 * so have to maintain our own progress counters
                  * that can be used by omap_pcm_pointer() instead.
                  */
                 spin_lock_irqsave(&prtd->lock, flags);
@@ -99,9 +100,11 @@ static int omap_pcm_hw_params(struct snd_pcm_substream *substream,
         struct snd_pcm_runtime *runtime = substream->runtime;
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
         struct omap_runtime_data *prtd = runtime->private_data;
-        struct omap_pcm_dma_data *dma_data = rtd->dai->cpu_dai->dma_data;
+        struct omap_pcm_dma_data *dma_data;
         int err = 0;
 
+        dma_data = snd_soc_dai_get_dma_data(rtd->dai->cpu_dai, substream);
+
         /* return if this is a bufferless transfer e.g.
          * codec <--> BT codec or GSM modem -- lg FIXME */
         if (!dma_data)
@@ -149,6 +152,7 @@ static int omap_pcm_prepare(struct snd_pcm_substream *substream)
         struct omap_runtime_data *prtd = runtime->private_data;
         struct omap_pcm_dma_data *dma_data = prtd->dma_data;
         struct omap_dma_channel_params dma_params;
+        int bytes;
 
         /* return if this is a bufferless transfer e.g.
          * codec <--> BT codec or GSM modem -- lg FIXME */
@@ -156,11 +160,7 @@ static int omap_pcm_prepare(struct snd_pcm_substream *substream)
                 return 0;
 
         memset(&dma_params, 0, sizeof(dma_params));
-        /*
-         * Note: Regardless of interface data formats supported by OMAP McBSP
-         * or EAC blocks, internal representation is always fixed 16-bit/sample
-         */
-        dma_params.data_type                    = OMAP_DMA_DATA_TYPE_S16;
+        dma_params.data_type                    = dma_data->data_type;
         dma_params.trigger                      = dma_data->dma_req;
         dma_params.sync_mode                    = dma_data->sync_mode;
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
@@ -170,6 +170,7 @@ static int omap_pcm_prepare(struct snd_pcm_substream *substream)
                 dma_params.src_start            = runtime->dma_addr;
                 dma_params.dst_start            = dma_data->port_addr;
                 dma_params.dst_port             = OMAP_DMA_PORT_MPUI;
+                dma_params.dst_fi               = dma_data->packet_size;
         } else {
                 dma_params.src_amode            = OMAP_DMA_AMODE_CONSTANT;
                 dma_params.dst_amode            = OMAP_DMA_AMODE_POST_INC;
@@ -177,6 +178,7 @@ static int omap_pcm_prepare(struct snd_pcm_substream *substream)
                 dma_params.src_start            = dma_data->port_addr;
                 dma_params.dst_start            = runtime->dma_addr;
                 dma_params.src_port             = OMAP_DMA_PORT_MPUI;
+                dma_params.src_fi               = dma_data->packet_size;
         }
         /*
          * Set DMA transfer frame size equal to ALSA period size and frame
@@ -184,12 +186,12 @@ static int omap_pcm_prepare(struct snd_pcm_substream *substream)
          * we can transfer the whole ALSA buffer with single DMA transfer but
          * still can get an interrupt at each period bounary
          */
-        dma_params.elem_count   = snd_pcm_lib_period_bytes(substream) / 2;
+        bytes = snd_pcm_lib_period_bytes(substream);
+        dma_params.elem_count   = bytes >> dma_data->data_type;
         dma_params.frame_count  = runtime->periods;
         omap_set_dma_params(prtd->dma_ch, &dma_params);
 
-        if ((cpu_is_omap1510()) &&
-                        (substream->stream == SNDRV_PCM_STREAM_PLAYBACK))
+        if ((cpu_is_omap1510()))
                 omap_enable_dma_irq(prtd->dma_ch, OMAP_DMA_FRAME_IRQ |
                               OMAP_DMA_LAST_IRQ | OMAP_DMA_BLOCK_IRQ);
         else
@@ -247,14 +249,15 @@ static snd_pcm_uframes_t omap_pcm_pointer(struct snd_pcm_substream *substream)
         dma_addr_t ptr;
         snd_pcm_uframes_t offset;
 
-        if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
+        if (cpu_is_omap1510()) {
+                offset = prtd->period_index * runtime->period_size;
+        } else if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
                 ptr = omap_get_dma_dst_pos(prtd->dma_ch);
                 offset = bytes_to_frames(runtime, ptr - runtime->dma_addr);
-        } else if (!(cpu_is_omap1510())) {
+        } else {
                 ptr = omap_get_dma_src_pos(prtd->dma_ch);
                 offset = bytes_to_frames(runtime, ptr - runtime->dma_addr);
-        } else
-                offset = prtd->period_index * runtime->period_size;
+        }
 
         if (offset >= runtime->buffer_size)
                 offset = 0;
diff --git a/sound/soc/omap/omap-pcm.h b/sound/soc/omap/omap-pcm.h
index 38a821dd4118..b19975d26907 100644
--- a/sound/soc/omap/omap-pcm.h
+++ b/sound/soc/omap/omap-pcm.h
@@ -29,8 +29,10 @@ struct omap_pcm_dma_data {
         char            *name;          /* stream identifier */
         int             dma_req;        /* DMA request line */
         unsigned long   port_addr;      /* transmit/receive register */
-        int             sync_mode;      /* DMA sync mode */
         void (*set_threshold)(struct snd_pcm_substream *substream);
+        int             data_type;      /* data type 8,16,32 */
+        int             sync_mode;      /* DMA sync mode */
+        int             packet_size;    /* packet size only in PACKET mode */
 };
 
 extern struct snd_soc_platform omap_soc_platform;
diff --git a/sound/soc/omap/omap2evm.c b/sound/soc/omap/omap2evm.c
index 027e1a40f8a1..c7adea38274c 100644
--- a/sound/soc/omap/omap2evm.c
+++ b/sound/soc/omap/omap2evm.c
@@ -31,7 +31,7 @@
 #include <asm/mach-types.h>
 #include <mach/hardware.h>
 #include <mach/gpio.h>
-#include <mach/mcbsp.h>
+#include <plat/mcbsp.h>
 
 #include "omap-mcbsp.h"
 #include "omap-pcm.h"
diff --git a/sound/soc/omap/omap3beagle.c b/sound/soc/omap/omap3beagle.c
index b0cff9f33b7e..240e0975dd6a 100644
--- a/sound/soc/omap/omap3beagle.c
+++ b/sound/soc/omap/omap3beagle.c
@@ -29,7 +29,7 @@
 #include <asm/mach-types.h>
 #include <mach/hardware.h>
 #include <mach/gpio.h>
-#include <mach/mcbsp.h>
+#include <plat/mcbsp.h>
 
 #include "omap-mcbsp.h"
 #include "omap-pcm.h"
@@ -117,11 +117,11 @@ static int __init omap3beagle_soc_init(void)
 {
         int ret;
 
-        if (!machine_is_omap3_beagle()) {
-                pr_debug("Not OMAP3 Beagle!\n");
+        if (!(machine_is_omap3_beagle() || machine_is_devkit8000())) {
+                pr_debug("Not OMAP3 Beagle or Devkit8000!\n");
                 return -ENODEV;
         }
-        pr_info("OMAP3 Beagle SoC init\n");
+        pr_info("OMAP3 Beagle/Devkit8000 SoC init\n");
 
         omap3beagle_snd_device = platform_device_alloc("soc-audio", -1);
         if (!omap3beagle_snd_device) {
diff --git a/sound/soc/omap/omap3evm.c b/sound/soc/omap/omap3evm.c
index 13aa380de162..dfcb344092e4 100644
--- a/sound/soc/omap/omap3evm.c
+++ b/sound/soc/omap/omap3evm.c
@@ -27,7 +27,7 @@
 #include <asm/mach-types.h>
 #include <mach/hardware.h>
 #include <mach/gpio.h>
-#include <mach/mcbsp.h>
+#include <plat/mcbsp.h>
 
 #include "omap-mcbsp.h"
 #include "omap-pcm.h"
@@ -93,10 +93,17 @@ static struct snd_soc_card snd_soc_omap3evm = {
         .num_links = 1,
 };
 
+/* twl4030 setup */
+static struct twl4030_setup_data twl4030_setup = {
+        .ramp_delay_value = 4,
+        .sysclk = 26000,
+};
+
 /* Audio subsystem */
 static struct snd_soc_device omap3evm_snd_devdata = {
         .card = &snd_soc_omap3evm,
         .codec_dev = &soc_codec_dev_twl4030,
+        .codec_data = &twl4030_setup,
 };
 
 static struct platform_device *omap3evm_snd_device;
diff --git a/sound/soc/omap/omap3pandora.c b/sound/soc/omap/omap3pandora.c
index 0cd06f5dd356..de10f76baded 100644
--- a/sound/soc/omap/omap3pandora.c
+++ b/sound/soc/omap/omap3pandora.c
@@ -23,6 +23,7 @@
 #include <linux/platform_device.h>
 #include <linux/gpio.h>
 #include <linux/delay.h>
+#include <linux/regulator/consumer.h>
 
 #include <sound/core.h>
 #include <sound/pcm.h>
@@ -40,9 +41,14 @@
 
 #define PREFIX "ASoC omap3pandora: "
 
-static int omap3pandora_cmn_hw_params(struct snd_soc_dai *codec_dai,
-        struct snd_soc_dai *cpu_dai, unsigned int fmt)
+static struct regulator *omap3pandora_dac_reg;
+
+static int omap3pandora_cmn_hw_params(struct snd_pcm_substream *substream,
+        struct snd_pcm_hw_params *params, unsigned int fmt)
 {
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
+        struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
         int ret;
 
         /* Set codec DAI configuration */
@@ -68,8 +74,9 @@ static int omap3pandora_cmn_hw_params(struct snd_soc_dai *codec_dai,
         }
 
         /* Set McBSP clock to external */
-        ret = snd_soc_dai_set_sysclk(cpu_dai, OMAP_MCBSP_SYSCLK_CLKS_EXT, 0,
-                                            SND_SOC_CLOCK_IN);
+        ret = snd_soc_dai_set_sysclk(cpu_dai, OMAP_MCBSP_SYSCLK_CLKS_EXT,
+                                     256 * params_rate(params),
+                                     SND_SOC_CLOCK_IN);
         if (ret < 0) {
                 pr_err(PREFIX "can't set cpu system clock\n");
                 return ret;
@@ -87,11 +94,7 @@ static int omap3pandora_cmn_hw_params(struct snd_soc_dai *codec_dai,
 static int omap3pandora_out_hw_params(struct snd_pcm_substream *substream,
         struct snd_pcm_hw_params *params)
 {
-        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-        struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
-        struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
-
-        return omap3pandora_cmn_hw_params(codec_dai, cpu_dai,
+        return omap3pandora_cmn_hw_params(substream, params,
                                           SND_SOC_DAIFMT_I2S |
                                           SND_SOC_DAIFMT_IB_NF |
                                           SND_SOC_DAIFMT_CBS_CFS);
@@ -100,31 +103,43 @@ static int omap3pandora_out_hw_params(struct snd_pcm_substream *substream,
 static int omap3pandora_in_hw_params(struct snd_pcm_substream *substream,
         struct snd_pcm_hw_params *params)
 {
-        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-        struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
-        struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
-
-        return omap3pandora_cmn_hw_params(codec_dai, cpu_dai,
+        return omap3pandora_cmn_hw_params(substream, params,
                                           SND_SOC_DAIFMT_I2S |
                                           SND_SOC_DAIFMT_NB_NF |
                                           SND_SOC_DAIFMT_CBS_CFS);
 }
 
-static int omap3pandora_hp_event(struct snd_soc_dapm_widget *w,
+static int omap3pandora_dac_event(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *k, int event)
 {
+        /*
+         * The PCM1773 DAC datasheet requires 1ms delay between switching
+         * VCC power on/off and /PD pin high/low
+         */
         if (SND_SOC_DAPM_EVENT_ON(event)) {
+                regulator_enable(omap3pandora_dac_reg);
+                mdelay(1);
                 gpio_set_value(OMAP3_PANDORA_DAC_POWER_GPIO, 1);
-                gpio_set_value(OMAP3_PANDORA_AMP_POWER_GPIO, 1);
         } else {
-                gpio_set_value(OMAP3_PANDORA_AMP_POWER_GPIO, 0);
-                mdelay(1);
                 gpio_set_value(OMAP3_PANDORA_DAC_POWER_GPIO, 0);
+                mdelay(1);
+                regulator_disable(omap3pandora_dac_reg);
         }
 
         return 0;
 }
 
+static int omap3pandora_hp_event(struct snd_soc_dapm_widget *w,
+        struct snd_kcontrol *k, int event)
+{
+        if (SND_SOC_DAPM_EVENT_ON(event))
+                gpio_set_value(OMAP3_PANDORA_AMP_POWER_GPIO, 1);
+        else
+                gpio_set_value(OMAP3_PANDORA_AMP_POWER_GPIO, 0);
+
+        return 0;
+}
+
 /*
  * Audio paths on Pandora board:
  *
@@ -134,7 +149,9 @@ static int omap3pandora_hp_event(struct snd_soc_dapm_widget *w,
  *  |P| <--- TWL4030 <--------- Line In and MICs
  */
 static const struct snd_soc_dapm_widget omap3pandora_out_dapm_widgets[] = {
-        SND_SOC_DAPM_DAC("PCM DAC", "HiFi Playback", SND_SOC_NOPM, 0, 0),
+        SND_SOC_DAPM_DAC_E("PCM DAC", "HiFi Playback", SND_SOC_NOPM,
+                           0, 0, omap3pandora_dac_event,
+                           SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
         SND_SOC_DAPM_PGA_E("Headphone Amplifier", SND_SOC_NOPM,
                            0, 0, NULL, 0, omap3pandora_hp_event,
                            SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
@@ -149,6 +166,7 @@ static const struct snd_soc_dapm_widget omap3pandora_in_dapm_widgets[] = {
 };
 
 static const struct snd_soc_dapm_route omap3pandora_out_map[] = {
+        {"PCM DAC", NULL, "APLL Enable"},
         {"Headphone Amplifier", NULL, "PCM DAC"},
         {"Line Out", NULL, "PCM DAC"},
         {"Headphone Jack", NULL, "Headphone Amplifier"},
@@ -309,8 +327,18 @@ static int __init omap3pandora_soc_init(void)
                 goto fail2;
         }
 
+        omap3pandora_dac_reg = regulator_get(&omap3pandora_snd_device->dev, "vcc");
+        if (IS_ERR(omap3pandora_dac_reg)) {
+                pr_err(PREFIX "Failed to get DAC regulator from %s: %ld\n",
+                        dev_name(&omap3pandora_snd_device->dev),
+                        PTR_ERR(omap3pandora_dac_reg));
+                goto fail3;
+        }
+
         return 0;
 
+fail3:
+        platform_device_del(omap3pandora_snd_device);
 fail2:
         platform_device_put(omap3pandora_snd_device);
 fail1:
@@ -323,6 +351,7 @@ module_init(omap3pandora_soc_init);
 
 static void __exit omap3pandora_soc_exit(void)
 {
+        regulator_put(omap3pandora_dac_reg);
         platform_device_unregister(omap3pandora_snd_device);
         gpio_free(OMAP3_PANDORA_AMP_POWER_GPIO);
         gpio_free(OMAP3_PANDORA_DAC_POWER_GPIO);
diff --git a/sound/soc/omap/osk5912.c b/sound/soc/omap/osk5912.c
index a4e149b7f0eb..498ca2e03519 100644
--- a/sound/soc/omap/osk5912.c
+++ b/sound/soc/omap/osk5912.c
@@ -31,7 +31,7 @@
 #include <asm/mach-types.h>
 #include <mach/hardware.h>
 #include <linux/gpio.h>
-#include <mach/mcbsp.h>
+#include <plat/mcbsp.h>
 
 #include "omap-mcbsp.h"
 #include "omap-pcm.h"
diff --git a/sound/soc/omap/overo.c b/sound/soc/omap/overo.c
index ec4f8fd8b3a2..c25f5276ad6f 100644
--- a/sound/soc/omap/overo.c
+++ b/sound/soc/omap/overo.c
@@ -29,7 +29,7 @@
 #include <asm/mach-types.h>
 #include <mach/hardware.h>
 #include <mach/gpio.h>
-#include <mach/mcbsp.h>
+#include <plat/mcbsp.h>
 
 #include "omap-mcbsp.h"
 #include "omap-pcm.h"
@@ -107,8 +107,8 @@ static int __init overo_soc_init(void)
 {
         int ret;
 
-        if (!machine_is_overo()) {
-                pr_debug("Not Overo!\n");
+        if (!(machine_is_overo() || machine_is_cm_t35())) {
+                pr_debug("Incomatible machine!\n");
                 return -ENODEV;
         }
         printk(KERN_INFO "overo SoC init\n");
diff --git a/sound/soc/omap/sdp3430.c b/sound/soc/omap/sdp3430.c
index 4a3f62d1f295..3c85c0f92823 100644
--- a/sound/soc/omap/sdp3430.c
+++ b/sound/soc/omap/sdp3430.c
@@ -24,7 +24,7 @@
 
 #include <linux/clk.h>
 #include <linux/platform_device.h>
-#include <linux/i2c/twl4030.h>
+#include <linux/i2c/twl.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/soc.h>
@@ -34,7 +34,7 @@
 #include <asm/mach-types.h>
 #include <mach/hardware.h>
 #include <mach/gpio.h>
-#include <mach/mcbsp.h>
+#include <plat/mcbsp.h>
 
 #include "omap-mcbsp.h"
 #include "omap-pcm.h"
@@ -321,11 +321,11 @@ static int __init sdp3430_soc_init(void)
         *(unsigned int *)sdp3430_dai[1].cpu_dai->private_data = 2; /* McBSP3 */
 
         /* Set TWL4030 GPIO6 as EXTMUTE signal */
-        twl4030_i2c_read_u8(TWL4030_MODULE_INTBR, &pin_mux,
+        twl_i2c_read_u8(TWL4030_MODULE_INTBR, &pin_mux,
                                                 TWL4030_INTBR_PMBR1);
         pin_mux &= ~TWL4030_GPIO6_PWM0_MUTE(0x03);
         pin_mux |= TWL4030_GPIO6_PWM0_MUTE(0x02);
-        twl4030_i2c_write_u8(TWL4030_MODULE_INTBR, pin_mux,
+        twl_i2c_write_u8(TWL4030_MODULE_INTBR, pin_mux,
                                                 TWL4030_INTBR_PMBR1);
 
         ret = platform_device_add(sdp3430_snd_device);
diff --git a/sound/soc/omap/zoom2.c b/sound/soc/omap/zoom2.c
index f90b45f56220..f90a2ac888cf 100644
--- a/sound/soc/omap/zoom2.c
+++ b/sound/soc/omap/zoom2.c
@@ -29,7 +29,7 @@
 #include <asm/mach-types.h>
 #include <mach/hardware.h>
 #include <mach/gpio.h>
-#include <mach/mcbsp.h>
+#include <plat/mcbsp.h>
 
 #include "omap-mcbsp.h"
 #include "omap-pcm.h"
diff --git a/sound/soc/pxa/Kconfig b/sound/soc/pxa/Kconfig
index dcb3181bb340..376e14a9c273 100644
--- a/sound/soc/pxa/Kconfig
+++ b/sound/soc/pxa/Kconfig
@@ -90,7 +90,8 @@ config SND_PXA2XX_SOC_E800
 
 config SND_PXA2XX_SOC_EM_X270
         tristate "SoC Audio support for CompuLab EM-x270, eXeda and CM-X300"
-        depends on SND_PXA2XX_SOC && MACH_EM_X270
+        depends on SND_PXA2XX_SOC && (MACH_EM_X270 || MACH_EXEDA || \
+                        MACH_CM_X300)
         select SND_PXA2XX_SOC_AC97
         select SND_SOC_WM9712
         help
@@ -117,6 +118,15 @@ config SND_SOC_ZYLONITE
           Say Y if you want to add support for SoC audio on the
           Marvell Zylonite reference platform.
 
+config SND_SOC_RAUMFELD
+        tristate "SoC Audio support Raumfeld audio adapter"
+        depends on SND_PXA2XX_SOC && (MACH_RAUMFELD_SPEAKER || MACH_RAUMFELD_CONNECTOR)
+        select SND_PXA_SOC_SSP
+        select SND_SOC_CS4270
+        select SND_SOC_AK4104
+        help
+          Say Y if you want to add support for SoC audio on Raumfeld devices
+
 config SND_PXA2XX_SOC_MAGICIAN
         tristate "SoC Audio support for HTC Magician"
         depends on SND_PXA2XX_SOC && MACH_MAGICIAN
diff --git a/sound/soc/pxa/Makefile b/sound/soc/pxa/Makefile
index 6e096b480335..f3e08fd40ca2 100644
--- a/sound/soc/pxa/Makefile
+++ b/sound/soc/pxa/Makefile
@@ -23,6 +23,7 @@ snd-soc-zylonite-objs := zylonite.o
 snd-soc-magician-objs := magician.o
 snd-soc-mioa701-objs := mioa701_wm9713.o
 snd-soc-imote2-objs := imote2.o
+snd-soc-raumfeld-objs := raumfeld.o
 
 obj-$(CONFIG_SND_PXA2XX_SOC_CORGI) += snd-soc-corgi.o
 obj-$(CONFIG_SND_PXA2XX_SOC_POODLE) += snd-soc-poodle.o
@@ -37,3 +38,4 @@ obj-$(CONFIG_SND_PXA2XX_SOC_MAGICIAN) += snd-soc-magician.o
 obj-$(CONFIG_SND_PXA2XX_SOC_MIOA701) += snd-soc-mioa701.o
 obj-$(CONFIG_SND_SOC_ZYLONITE) += snd-soc-zylonite.o
 obj-$(CONFIG_SND_PXA2XX_SOC_IMOTE2) += snd-soc-imote2.o
+obj-$(CONFIG_SND_SOC_RAUMFELD) += snd-soc-raumfeld.o
diff --git a/sound/soc/pxa/magician.c b/sound/soc/pxa/magician.c
index 9f7c61e23daf..4c8d99a8d386 100644
--- a/sound/soc/pxa/magician.c
+++ b/sound/soc/pxa/magician.c
@@ -213,7 +213,7 @@ static int magician_playback_hw_params(struct snd_pcm_substream *substream,
                 return ret;
 
         /* set SSP audio pll clock */
-        ret = snd_soc_dai_set_pll(cpu_dai, 0, 0, acps);
+        ret = snd_soc_dai_set_pll(cpu_dai, 0, 0, 0, acps);
         if (ret < 0)
                 return ret;
 
diff --git a/sound/soc/pxa/pxa-ssp.c b/sound/soc/pxa/pxa-ssp.c
index d11a6d7e384a..544fd9566f4d 100644
--- a/sound/soc/pxa/pxa-ssp.c
+++ b/sound/soc/pxa/pxa-ssp.c
@@ -16,6 +16,7 @@
 
 #include <linux/init.h>
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/platform_device.h>
 #include <linux/clk.h>
 #include <linux/io.h>
@@ -42,11 +43,14 @@
  * SSP audio private data
  */
 struct ssp_priv {
-        struct ssp_dev dev;
+        struct ssp_device *ssp;
         unsigned int sysclk;
         int dai_fmt;
 #ifdef CONFIG_PM
-        struct ssp_state state;
+        uint32_t        cr0;
+        uint32_t        cr1;
+        uint32_t        to;
+        uint32_t        psp;
 #endif
 };
 
@@ -61,6 +65,22 @@ static void dump_registers(struct ssp_device *ssp)
                  ssp_read_reg(ssp, SSACD));
 }
 
+static void ssp_enable(struct ssp_device *ssp)
+{
+        uint32_t sscr0;
+
+        sscr0 = __raw_readl(ssp->mmio_base + SSCR0) | SSCR0_SSE;
+        __raw_writel(sscr0, ssp->mmio_base + SSCR0);
+}
+
+static void ssp_disable(struct ssp_device *ssp)
+{
+        uint32_t sscr0;
+
+        sscr0 = __raw_readl(ssp->mmio_base + SSCR0) & ~SSCR0_SSE;
+        __raw_writel(sscr0, ssp->mmio_base + SSCR0);
+}
+
 struct pxa2xx_pcm_dma_data {
         struct pxa2xx_pcm_dma_params params;
         char name[20];
@@ -94,19 +114,17 @@ static int pxa_ssp_startup(struct snd_pcm_substream *substream,
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
         struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
         struct ssp_priv *priv = cpu_dai->private_data;
+        struct ssp_device *ssp = priv->ssp;
         int ret = 0;
 
         if (!cpu_dai->active) {
-                priv->dev.port = cpu_dai->id + 1;
-                priv->dev.irq = NO_IRQ;
-                clk_enable(priv->dev.ssp->clk);
-                ssp_disable(&priv->dev);
+                clk_enable(ssp->clk);
+                ssp_disable(ssp);
         }
 
-        if (cpu_dai->dma_data) {
-                kfree(cpu_dai->dma_data);
-                cpu_dai->dma_data = NULL;
-        }
+        kfree(snd_soc_dai_get_dma_data(cpu_dai, substream));
+        snd_soc_dai_set_dma_data(cpu_dai, substream, NULL);
+
         return ret;
 }
 
@@ -116,16 +134,15 @@ static void pxa_ssp_shutdown(struct snd_pcm_substream *substream,
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
         struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
         struct ssp_priv *priv = cpu_dai->private_data;
+        struct ssp_device *ssp = priv->ssp;
 
         if (!cpu_dai->active) {
-                ssp_disable(&priv->dev);
-                clk_disable(priv->dev.ssp->clk);
+                ssp_disable(ssp);
+                clk_disable(ssp->clk);
         }
 
-        if (cpu_dai->dma_data) {
-                kfree(cpu_dai->dma_data);
-                cpu_dai->dma_data = NULL;
-        }
+        kfree(snd_soc_dai_get_dma_data(cpu_dai, substream));
+        snd_soc_dai_set_dma_data(cpu_dai, substream, NULL);
 }
 
 #ifdef CONFIG_PM
@@ -133,25 +150,39 @@ static void pxa_ssp_shutdown(struct snd_pcm_substream *substream,
 static int pxa_ssp_suspend(struct snd_soc_dai *cpu_dai)
 {
         struct ssp_priv *priv = cpu_dai->private_data;
+        struct ssp_device *ssp = priv->ssp;
 
         if (!cpu_dai->active)
-                return 0;
+                clk_enable(ssp->clk);
+
+        priv->cr0 = __raw_readl(ssp->mmio_base + SSCR0);
+        priv->cr1 = __raw_readl(ssp->mmio_base + SSCR1);
+        priv->to  = __raw_readl(ssp->mmio_base + SSTO);
+        priv->psp = __raw_readl(ssp->mmio_base + SSPSP);
 
-        ssp_save_state(&priv->dev, &priv->state);
-        clk_disable(priv->dev.ssp->clk);
+        ssp_disable(ssp);
+        clk_disable(ssp->clk);
         return 0;
 }
 
 static int pxa_ssp_resume(struct snd_soc_dai *cpu_dai)
 {
         struct ssp_priv *priv = cpu_dai->private_data;
+        struct ssp_device *ssp = priv->ssp;
+        uint32_t sssr = SSSR_ROR | SSSR_TUR | SSSR_BCE;
 
-        if (!cpu_dai->active)
-                return 0;
+        clk_enable(ssp->clk);
 
-        clk_enable(priv->dev.ssp->clk);
-        ssp_restore_state(&priv->dev, &priv->state);
-        ssp_enable(&priv->dev);
+        __raw_writel(sssr, ssp->mmio_base + SSSR);
+        __raw_writel(priv->cr0 & ~SSCR0_SSE, ssp->mmio_base + SSCR0);
+        __raw_writel(priv->cr1, ssp->mmio_base + SSCR1);
+        __raw_writel(priv->to,  ssp->mmio_base + SSTO);
+        __raw_writel(priv->psp, ssp->mmio_base + SSPSP);
+
+        if (cpu_dai->active)
+                ssp_enable(ssp);
+        else
+                clk_disable(ssp->clk);
 
         return 0;
 }
@@ -201,7 +232,7 @@ static int pxa_ssp_set_dai_sysclk(struct snd_soc_dai *cpu_dai,
         int clk_id, unsigned int freq, int dir)
 {
         struct ssp_priv *priv = cpu_dai->private_data;
-        struct ssp_device *ssp = priv->dev.ssp;
+        struct ssp_device *ssp = priv->ssp;
         int val;
 
         u32 sscr0 = ssp_read_reg(ssp, SSCR0) &
@@ -242,11 +273,11 @@ static int pxa_ssp_set_dai_sysclk(struct snd_soc_dai *cpu_dai,
         /* The SSP clock must be disabled when changing SSP clock mode
          * on PXA2xx.  On PXA3xx it must be enabled when doing so. */
         if (!cpu_is_pxa3xx())
-                clk_disable(priv->dev.ssp->clk);
+                clk_disable(ssp->clk);
         val = ssp_read_reg(ssp, SSCR0) | sscr0;
         ssp_write_reg(ssp, SSCR0, val);
         if (!cpu_is_pxa3xx())
-                clk_enable(priv->dev.ssp->clk);
+                clk_enable(ssp->clk);
 
         return 0;
 }
@@ -258,7 +289,7 @@ static int pxa_ssp_set_dai_clkdiv(struct snd_soc_dai *cpu_dai,
         int div_id, int div)
 {
         struct ssp_priv *priv = cpu_dai->private_data;
-        struct ssp_device *ssp = priv->dev.ssp;
+        struct ssp_device *ssp = priv->ssp;
         int val;
 
         switch (div_id) {
@@ -305,11 +336,11 @@ static int pxa_ssp_set_dai_clkdiv(struct snd_soc_dai *cpu_dai,
 /*
  * Configure the PLL frequency pxa27x and (afaik - pxa320 only)
  */
-static int pxa_ssp_set_dai_pll(struct snd_soc_dai *cpu_dai,
-        int pll_id, unsigned int freq_in, unsigned int freq_out)
+static int pxa_ssp_set_dai_pll(struct snd_soc_dai *cpu_dai, int pll_id,
+        int source, unsigned int freq_in, unsigned int freq_out)
 {
         struct ssp_priv *priv = cpu_dai->private_data;
-        struct ssp_device *ssp = priv->dev.ssp;
+        struct ssp_device *ssp = priv->ssp;
         u32 ssacd = ssp_read_reg(ssp, SSACD) & ~0x70;
 
 #if defined(CONFIG_PXA3xx)
@@ -378,7 +409,7 @@ static int pxa_ssp_set_dai_tdm_slot(struct snd_soc_dai *cpu_dai,
         unsigned int tx_mask, unsigned int rx_mask, int slots, int slot_width)
 {
         struct ssp_priv *priv = cpu_dai->private_data;
-        struct ssp_device *ssp = priv->dev.ssp;
+        struct ssp_device *ssp = priv->ssp;
         u32 sscr0;
 
         sscr0 = ssp_read_reg(ssp, SSCR0);
@@ -413,7 +444,7 @@ static int pxa_ssp_set_dai_tristate(struct snd_soc_dai *cpu_dai,
         int tristate)
 {
         struct ssp_priv *priv = cpu_dai->private_data;
-        struct ssp_device *ssp = priv->dev.ssp;
+        struct ssp_device *ssp = priv->ssp;
         u32 sscr1;
 
         sscr1 = ssp_read_reg(ssp, SSCR1);
@@ -435,7 +466,7 @@ static int pxa_ssp_set_dai_fmt(struct snd_soc_dai *cpu_dai,
                 unsigned int fmt)
 {
         struct ssp_priv *priv = cpu_dai->private_data;
-        struct ssp_device *ssp = priv->dev.ssp;
+        struct ssp_device *ssp = priv->ssp;
         u32 sscr0;
         u32 sscr1;
         u32 sspsp;
@@ -530,25 +561,29 @@ static int pxa_ssp_hw_params(struct snd_pcm_substream *substream,
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
         struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
         struct ssp_priv *priv = cpu_dai->private_data;
-        struct ssp_device *ssp = priv->dev.ssp;
+        struct ssp_device *ssp = priv->ssp;
         int chn = params_channels(params);
         u32 sscr0;
         u32 sspsp;
         int width = snd_pcm_format_physical_width(params_format(params));
         int ttsa = ssp_read_reg(ssp, SSTSA) & 0xf;
+        struct pxa2xx_pcm_dma_params *dma_data;
+
+        dma_data = snd_soc_dai_get_dma_data(dai, substream);
 
         /* generate correct DMA params */
-        if (cpu_dai->dma_data)
-                kfree(cpu_dai->dma_data);
+        kfree(dma_data);
 
         /* Network mode with one active slot (ttsa == 1) can be used
          * to force 16-bit frame width on the wire (for S16_LE), even
          * with two channels. Use 16-bit DMA transfers for this case.
          */
-        cpu_dai->dma_data = ssp_get_dma_params(ssp,
+        dma_data = ssp_get_dma_params(ssp,
                         ((chn == 2) && (ttsa != 1)) || (width == 32),
                         substream->stream == SNDRV_PCM_STREAM_PLAYBACK);
 
+        snd_soc_dai_set_dma_data(dai, substream, dma_data);
+
         /* we can only change the settings if the port is not in use */
         if (ssp_read_reg(ssp, SSCR0) & SSCR0_SSE)
                 return 0;
@@ -640,12 +675,12 @@ static int pxa_ssp_trigger(struct snd_pcm_substream *substream, int cmd,
         struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
         int ret = 0;
         struct ssp_priv *priv = cpu_dai->private_data;
-        struct ssp_device *ssp = priv->dev.ssp;
+        struct ssp_device *ssp = priv->ssp;
         int val;
 
         switch (cmd) {
         case SNDRV_PCM_TRIGGER_RESUME:
-                ssp_enable(&priv->dev);
+                ssp_enable(ssp);
                 break;
         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
                 val = ssp_read_reg(ssp, SSCR1);
@@ -664,7 +699,7 @@ static int pxa_ssp_trigger(struct snd_pcm_substream *substream, int cmd,
                 else
                         val |= SSCR1_RSRE;
                 ssp_write_reg(ssp, SSCR1, val);
-                ssp_enable(&priv->dev);
+                ssp_enable(ssp);
                 break;
         case SNDRV_PCM_TRIGGER_STOP:
                 val = ssp_read_reg(ssp, SSCR1);
@@ -675,7 +710,7 @@ static int pxa_ssp_trigger(struct snd_pcm_substream *substream, int cmd,
                 ssp_write_reg(ssp, SSCR1, val);
                 break;
         case SNDRV_PCM_TRIGGER_SUSPEND:
-                ssp_disable(&priv->dev);
+                ssp_disable(ssp);
                 break;
         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
                 val = ssp_read_reg(ssp, SSCR1);
@@ -705,8 +740,8 @@ static int pxa_ssp_probe(struct platform_device *pdev,
         if (!priv)
                 return -ENOMEM;
 
-        priv->dev.ssp = ssp_request(dai->id + 1, "SoC audio");
-        if (priv->dev.ssp == NULL) {
+        priv->ssp = ssp_request(dai->id + 1, "SoC audio");
+        if (priv->ssp == NULL) {
                 ret = -ENODEV;
                 goto err_priv;
         }
@@ -725,7 +760,7 @@ static void pxa_ssp_remove(struct platform_device *pdev,
                               struct snd_soc_dai *dai)
 {
         struct ssp_priv *priv = dai->private_data;
-        ssp_free(priv->dev.ssp);
+        ssp_free(priv->ssp);
 }
 
 #define PXA_SSP_RATES (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_11025 |\
@@ -760,13 +795,13 @@ struct snd_soc_dai pxa_ssp_dai[] = {
                 .resume = pxa_ssp_resume,
                 .playback = {
                         .channels_min = 1,
-                        .channels_max = 2,
+                        .channels_max = 8,
                         .rates = PXA_SSP_RATES,
                         .formats = PXA_SSP_FORMATS,
                 },
                 .capture = {
                          .channels_min = 1,
-                         .channels_max = 2,
+                         .channels_max = 8,
                         .rates = PXA_SSP_RATES,
                         .formats = PXA_SSP_FORMATS,
                  },
@@ -780,13 +815,13 @@ struct snd_soc_dai pxa_ssp_dai[] = {
                 .resume = pxa_ssp_resume,
                 .playback = {
                         .channels_min = 1,
-                        .channels_max = 2,
+                        .channels_max = 8,
                         .rates = PXA_SSP_RATES,
                         .formats = PXA_SSP_FORMATS,
                 },
                 .capture = {
                         .channels_min = 1,
-                        .channels_max = 2,
+                        .channels_max = 8,
                         .rates = PXA_SSP_RATES,
                         .formats = PXA_SSP_FORMATS,
                  },
@@ -801,13 +836,13 @@ struct snd_soc_dai pxa_ssp_dai[] = {
                 .resume = pxa_ssp_resume,
                 .playback = {
                         .channels_min = 1,
-                        .channels_max = 2,
+                        .channels_max = 8,
                         .rates = PXA_SSP_RATES,
                         .formats = PXA_SSP_FORMATS,
                 },
                 .capture = {
                         .channels_min = 1,
-                        .channels_max = 2,
+                        .channels_max = 8,
                         .rates = PXA_SSP_RATES,
                         .formats = PXA_SSP_FORMATS,
                  },
@@ -822,13 +857,13 @@ struct snd_soc_dai pxa_ssp_dai[] = {
                 .resume = pxa_ssp_resume,
                 .playback = {
                         .channels_min = 1,
-                        .channels_max = 2,
+                        .channels_max = 8,
                         .rates = PXA_SSP_RATES,
                         .formats = PXA_SSP_FORMATS,
                 },
                 .capture = {
                         .channels_min = 1,
-                        .channels_max = 2,
+                        .channels_max = 8,
                         .rates = PXA_SSP_RATES,
                         .formats = PXA_SSP_FORMATS,
                  },
diff --git a/sound/soc/pxa/pxa2xx-ac97.c b/sound/soc/pxa/pxa2xx-ac97.c
index e9ae7b3a7e00..d314115e3dd7 100644
--- a/sound/soc/pxa/pxa2xx-ac97.c
+++ b/sound/soc/pxa/pxa2xx-ac97.c
@@ -122,11 +122,14 @@ static int pxa2xx_ac97_hw_params(struct snd_pcm_substream *substream,
 {
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
         struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
+        struct pxa2xx_pcm_dma_params *dma_data;
 
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
-                cpu_dai->dma_data = &pxa2xx_ac97_pcm_stereo_out;
+                dma_data = &pxa2xx_ac97_pcm_stereo_out;
         else
-                cpu_dai->dma_data = &pxa2xx_ac97_pcm_stereo_in;
+                dma_data = &pxa2xx_ac97_pcm_stereo_in;
+
+        snd_soc_dai_set_dma_data(cpu_dai, substream, dma_data);
 
         return 0;
 }
@@ -137,11 +140,14 @@ static int pxa2xx_ac97_hw_aux_params(struct snd_pcm_substream *substream,
 {
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
         struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
+        struct pxa2xx_pcm_dma_params *dma_data;
 
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
-                cpu_dai->dma_data = &pxa2xx_ac97_pcm_aux_mono_out;
+                dma_data = &pxa2xx_ac97_pcm_aux_mono_out;
         else
-                cpu_dai->dma_data = &pxa2xx_ac97_pcm_aux_mono_in;
+                dma_data = &pxa2xx_ac97_pcm_aux_mono_in;
+
+        snd_soc_dai_set_dma_data(cpu_dai, substream, dma_data);
 
         return 0;
 }
@@ -156,7 +162,8 @@ static int pxa2xx_ac97_hw_mic_params(struct snd_pcm_substream *substream,
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
                 return -ENODEV;
         else
-                cpu_dai->dma_data = &pxa2xx_ac97_pcm_mic_mono_in;
+                snd_soc_dai_set_dma_data(cpu_dai, substream,
+                                         &pxa2xx_ac97_pcm_mic_mono_in);
 
         return 0;
 }
diff --git a/sound/soc/pxa/pxa2xx-i2s.c b/sound/soc/pxa/pxa2xx-i2s.c
index 6b8f655d1ad8..c1a5275721e4 100644
--- a/sound/soc/pxa/pxa2xx-i2s.c
+++ b/sound/soc/pxa/pxa2xx-i2s.c
@@ -164,6 +164,7 @@ static int pxa2xx_i2s_hw_params(struct snd_pcm_substream *substream,
 {
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
         struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
+        struct pxa2xx_pcm_dma_params *dma_data;
 
         BUG_ON(IS_ERR(clk_i2s));
         clk_enable(clk_i2s);
@@ -171,9 +172,11 @@ static int pxa2xx_i2s_hw_params(struct snd_pcm_substream *substream,
         pxa_i2s_wait();
 
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
-                cpu_dai->dma_data = &pxa2xx_i2s_pcm_stereo_out;
+                dma_data = &pxa2xx_i2s_pcm_stereo_out;
         else
-                cpu_dai->dma_data = &pxa2xx_i2s_pcm_stereo_in;
+                dma_data = &pxa2xx_i2s_pcm_stereo_in;
+
+        snd_soc_dai_set_dma_data(cpu_dai, substream, dma_data);
 
         /* is port used by another stream */
         if (!(SACR0 & SACR0_ENB)) {
diff --git a/sound/soc/pxa/pxa2xx-pcm.c b/sound/soc/pxa/pxa2xx-pcm.c
index d38e39575f51..adc7e6f15f93 100644
--- a/sound/soc/pxa/pxa2xx-pcm.c
+++ b/sound/soc/pxa/pxa2xx-pcm.c
@@ -25,9 +25,11 @@ static int pxa2xx_pcm_hw_params(struct snd_pcm_substream *substream,
         struct snd_pcm_runtime *runtime = substream->runtime;
         struct pxa2xx_runtime_data *prtd = runtime->private_data;
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
-        struct pxa2xx_pcm_dma_params *dma = rtd->dai->cpu_dai->dma_data;
+        struct pxa2xx_pcm_dma_params *dma;
         int ret;
 
+        dma = snd_soc_dai_get_dma_data(rtd->dai->cpu_dai, substream);
+
         /* return if this is a bufferless transfer e.g.
          * codec <--> BT codec or GSM modem -- lg FIXME */
         if (!dma)
diff --git a/sound/soc/pxa/raumfeld.c b/sound/soc/pxa/raumfeld.c
new file mode 100644
index 000000000000..7e3f41696c41
--- /dev/null
+++ b/sound/soc/pxa/raumfeld.c
@@ -0,0 +1,354 @@
+/*
+ * raumfeld_audio.c  --  SoC audio for Raumfeld audio devices
+ *
+ * Copyright (c) 2009 Daniel Mack <daniel@caiaq.de>
+ *
+ * based on code from:
+ *
+ *    Wolfson Microelectronics PLC.
+ *    Openedhand Ltd.
+ *    Liam Girdwood <lrg@slimlogic.co.uk>
+ *    Richard Purdie <richard@openedhand.com>
+ *
+ * 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 the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ */
+
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/delay.h>
+#include <linux/gpio.h>
+#include <sound/pcm.h>
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+
+#include <asm/mach-types.h>
+
+#include "../codecs/cs4270.h"
+#include "../codecs/ak4104.h"
+#include "pxa2xx-pcm.h"
+#include "pxa-ssp.h"
+
+#define GPIO_SPDIF_RESET        (38)
+#define GPIO_MCLK_RESET         (111)
+#define GPIO_CODEC_RESET        (120)
+
+static struct i2c_client *max9486_client;
+static struct i2c_board_info max9486_hwmon_info = {
+        I2C_BOARD_INFO("max9485", 0x63),
+};
+
+#define MAX9485_MCLK_FREQ_112896 0x22
+#define MAX9485_MCLK_FREQ_122880 0x23
+#define MAX9485_MCLK_FREQ_225792 0x32
+#define MAX9485_MCLK_FREQ_245760 0x33
+
+static void set_max9485_clk(char clk)
+{
+        i2c_master_send(max9486_client, &clk, 1);
+}
+
+static void raumfeld_enable_audio(bool en)
+{
+        if (en) {
+                gpio_set_value(GPIO_MCLK_RESET, 1);
+
+                /* wait some time to let the clocks become stable */
+                msleep(100);
+
+                gpio_set_value(GPIO_SPDIF_RESET, 1);
+                gpio_set_value(GPIO_CODEC_RESET, 1);
+        } else {
+                gpio_set_value(GPIO_MCLK_RESET, 0);
+                gpio_set_value(GPIO_SPDIF_RESET, 0);
+                gpio_set_value(GPIO_CODEC_RESET, 0);
+        }
+}
+
+/* CS4270 */
+static int raumfeld_cs4270_startup(struct snd_pcm_substream *substream)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
+
+        /* set freq to 0 to enable all possible codec sample rates */
+        return snd_soc_dai_set_sysclk(codec_dai, 0, 0, 0);
+}
+
+static void raumfeld_cs4270_shutdown(struct snd_pcm_substream *substream)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
+
+        /* set freq to 0 to enable all possible codec sample rates */
+        snd_soc_dai_set_sysclk(codec_dai, 0, 0, 0);
+}
+
+static int raumfeld_cs4270_hw_params(struct snd_pcm_substream *substream,
+                                     struct snd_pcm_hw_params *params)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
+        struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
+        unsigned int fmt, clk = 0;
+        int ret = 0;
+
+        switch (params_rate(params)) {
+        case 44100:
+                set_max9485_clk(MAX9485_MCLK_FREQ_112896);
+                clk = 11289600;
+                break;
+        case 48000:
+                set_max9485_clk(MAX9485_MCLK_FREQ_122880);
+                clk = 12288000;
+                break;
+        case 88200:
+                set_max9485_clk(MAX9485_MCLK_FREQ_225792);
+                clk = 22579200;
+                break;
+        case 96000:
+                set_max9485_clk(MAX9485_MCLK_FREQ_245760);
+                clk = 24576000;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        fmt = SND_SOC_DAIFMT_I2S |
+              SND_SOC_DAIFMT_NB_NF |
+              SND_SOC_DAIFMT_CBS_CFS;
+
+        /* setup the CODEC DAI */
+        ret = snd_soc_dai_set_fmt(codec_dai, fmt);
+        if (ret < 0)
+                return ret;
+
+        ret = snd_soc_dai_set_sysclk(codec_dai, 0, clk, 0);
+        if (ret < 0)
+                return ret;
+
+        /* setup the CPU DAI */
+        ret = snd_soc_dai_set_pll(cpu_dai, 0, 0, 0, clk);
+        if (ret < 0)
+                return ret;
+
+        ret = snd_soc_dai_set_fmt(cpu_dai, fmt);
+        if (ret < 0)
+                return ret;
+
+        ret = snd_soc_dai_set_clkdiv(cpu_dai, PXA_SSP_DIV_SCR, 4);
+        if (ret < 0)
+                return ret;
+
+        ret = snd_soc_dai_set_sysclk(cpu_dai, PXA_SSP_CLK_EXT, clk, 1);
+        if (ret < 0)
+                return ret;
+
+        return 0;
+}
+
+static struct snd_soc_ops raumfeld_cs4270_ops = {
+        .startup = raumfeld_cs4270_startup,
+        .shutdown = raumfeld_cs4270_shutdown,
+        .hw_params = raumfeld_cs4270_hw_params,
+};
+
+static int raumfeld_line_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        raumfeld_enable_audio(false);
+        return 0;
+}
+
+static int raumfeld_line_resume(struct platform_device *pdev)
+{
+        raumfeld_enable_audio(true);
+        return 0;
+}
+
+static struct snd_soc_dai_link raumfeld_line_dai = {
+        .name           = "CS4270",
+        .stream_name    = "CS4270",
+        .cpu_dai        = &pxa_ssp_dai[PXA_DAI_SSP1],
+        .codec_dai      = &cs4270_dai,
+        .ops            = &raumfeld_cs4270_ops,
+};
+
+static struct snd_soc_card snd_soc_line_raumfeld = {
+        .name           = "Raumfeld analog",
+        .platform       = &pxa2xx_soc_platform,
+        .dai_link       = &raumfeld_line_dai,
+        .suspend_post   = raumfeld_line_suspend,
+        .resume_pre     = raumfeld_line_resume,
+        .num_links      = 1,
+};
+
+
+/* AK4104 */
+
+static int raumfeld_ak4104_hw_params(struct snd_pcm_substream *substream,
+                                     struct snd_pcm_hw_params *params)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
+        struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
+        int fmt, ret = 0, clk = 0;
+
+        switch (params_rate(params)) {
+        case 44100:
+                set_max9485_clk(MAX9485_MCLK_FREQ_112896);
+                clk = 11289600;
+                break;
+        case 48000:
+                set_max9485_clk(MAX9485_MCLK_FREQ_122880);
+                clk = 12288000;
+                break;
+        case 88200:
+                set_max9485_clk(MAX9485_MCLK_FREQ_225792);
+                clk = 22579200;
+                break;
+        case 96000:
+                set_max9485_clk(MAX9485_MCLK_FREQ_245760);
+                clk = 24576000;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF;
+
+        /* setup the CODEC DAI */
+        ret = snd_soc_dai_set_fmt(codec_dai, fmt | SND_SOC_DAIFMT_CBS_CFS);
+        if (ret < 0)
+                return ret;
+
+        /* setup the CPU DAI */
+        ret = snd_soc_dai_set_pll(cpu_dai, 0, 0, 0, clk);
+        if (ret < 0)
+                return ret;
+
+        ret = snd_soc_dai_set_fmt(cpu_dai, fmt | SND_SOC_DAIFMT_CBS_CFS);
+        if (ret < 0)
+                return ret;
+
+        ret = snd_soc_dai_set_clkdiv(cpu_dai, PXA_SSP_DIV_SCR, 4);
+        if (ret < 0)
+                return ret;
+
+        ret = snd_soc_dai_set_sysclk(cpu_dai, PXA_SSP_CLK_EXT, clk, 1);
+        if (ret < 0)
+                return ret;
+
+        return 0;
+}
+
+static struct snd_soc_ops raumfeld_ak4104_ops = {
+        .hw_params = raumfeld_ak4104_hw_params,
+};
+
+static struct snd_soc_dai_link raumfeld_spdif_dai = {
+        .name           = "ak4104",
+        .stream_name    = "Playback",
+        .cpu_dai        = &pxa_ssp_dai[PXA_DAI_SSP2],
+        .codec_dai      = &ak4104_dai,
+        .ops            = &raumfeld_ak4104_ops,
+};
+
+static struct snd_soc_card snd_soc_spdif_raumfeld = {
+        .name           = "Raumfeld S/PDIF",
+        .platform       = &pxa2xx_soc_platform,
+        .dai_link       = &raumfeld_spdif_dai,
+        .num_links      = 1
+};
+
+/* raumfeld_audio audio subsystem */
+static struct snd_soc_device raumfeld_line_devdata = {
+        .card = &snd_soc_line_raumfeld,
+        .codec_dev = &soc_codec_device_cs4270,
+};
+
+static struct snd_soc_device raumfeld_spdif_devdata = {
+        .card = &snd_soc_spdif_raumfeld,
+        .codec_dev = &soc_codec_device_ak4104,
+};
+
+static struct platform_device *raumfeld_audio_line_device;
+static struct platform_device *raumfeld_audio_spdif_device;
+
+static int __init raumfeld_audio_init(void)
+{
+        int ret;
+
+        if (!machine_is_raumfeld_speaker() &&
+            !machine_is_raumfeld_connector())
+                return 0;
+
+        max9486_client = i2c_new_device(i2c_get_adapter(0),
+                                        &max9486_hwmon_info);
+
+        if (!max9486_client)
+                return -ENOMEM;
+
+        set_max9485_clk(MAX9485_MCLK_FREQ_122880);
+
+        /* LINE */
+        raumfeld_audio_line_device = platform_device_alloc("soc-audio", 0);
+        if (!raumfeld_audio_line_device)
+                return -ENOMEM;
+
+        platform_set_drvdata(raumfeld_audio_line_device,
+                             &raumfeld_line_devdata);
+        raumfeld_line_devdata.dev = &raumfeld_audio_line_device->dev;
+        ret = platform_device_add(raumfeld_audio_line_device);
+        if (ret)
+                platform_device_put(raumfeld_audio_line_device);
+
+        /* no S/PDIF on Speakers */
+        if (machine_is_raumfeld_speaker())
+                return ret;
+
+        /* S/PDIF */
+        raumfeld_audio_spdif_device = platform_device_alloc("soc-audio", 1);
+        if (!raumfeld_audio_spdif_device) {
+                platform_device_put(raumfeld_audio_line_device);
+                return -ENOMEM;
+        }
+
+        platform_set_drvdata(raumfeld_audio_spdif_device,
+                             &raumfeld_spdif_devdata);
+        raumfeld_spdif_devdata.dev = &raumfeld_audio_spdif_device->dev;
+        ret = platform_device_add(raumfeld_audio_spdif_device);
+        if (ret) {
+                platform_device_put(raumfeld_audio_line_device);
+                platform_device_put(raumfeld_audio_spdif_device);
+        }
+
+        raumfeld_enable_audio(true);
+
+        return ret;
+}
+
+static void __exit raumfeld_audio_exit(void)
+{
+        raumfeld_enable_audio(false);
+
+        platform_device_unregister(raumfeld_audio_line_device);
+
+        if (machine_is_raumfeld_connector())
+                platform_device_unregister(raumfeld_audio_spdif_device);
+
+        i2c_unregister_device(max9486_client);
+
+        gpio_free(GPIO_MCLK_RESET);
+        gpio_free(GPIO_CODEC_RESET);
+        gpio_free(GPIO_SPDIF_RESET);
+}
+
+module_init(raumfeld_audio_init);
+module_exit(raumfeld_audio_exit);
+
+/* Module information */
+MODULE_AUTHOR("Daniel Mack <daniel@caiaq.de>");
+MODULE_DESCRIPTION("Raumfeld audio SoC");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/pxa/zylonite.c b/sound/soc/pxa/zylonite.c
index 9a386b4c4ed1..dd678ae24398 100644
--- a/sound/soc/pxa/zylonite.c
+++ b/sound/soc/pxa/zylonite.c
@@ -74,7 +74,8 @@ static const struct snd_soc_dapm_route audio_map[] = {
 static int zylonite_wm9713_init(struct snd_soc_codec *codec)
 {
         if (clk_pout)
-                snd_soc_dai_set_pll(&codec->dai[0], 0, clk_get_rate(pout), 0);
+                snd_soc_dai_set_pll(&codec->dai[0], 0, 0,
+                                    clk_get_rate(pout), 0);
 
         snd_soc_dapm_new_controls(codec, zylonite_dapm_widgets,
                                   ARRAY_SIZE(zylonite_dapm_widgets));
@@ -128,7 +129,7 @@ static int zylonite_voice_hw_params(struct snd_pcm_substream *substream,
         if (ret < 0)
                 return ret;
 
-        ret = snd_soc_dai_set_pll(cpu_dai, 0, 0, pll_out);
+        ret = snd_soc_dai_set_pll(cpu_dai, 0, 0, 0, pll_out);
         if (ret < 0)
                 return ret;
 
diff --git a/sound/soc/s3c24xx/Kconfig b/sound/soc/s3c24xx/Kconfig
index 923428fc1adb..15fe57e5a232 100644
--- a/sound/soc/s3c24xx/Kconfig
+++ b/sound/soc/s3c24xx/Kconfig
@@ -24,12 +24,13 @@ config SND_S3C64XX_SOC_I2S
         select SND_S3C_I2SV2_SOC
         select S3C64XX_DMA
 
-config SND_S3C2443_SOC_AC97
+config SND_S3C_SOC_PCM
+        tristate
+
+config SND_S3C_SOC_AC97
         tristate
-        select S3C2410_DMA
-        select AC97_BUS
         select SND_SOC_AC97_BUS
-        
+
 config SND_S3C24XX_SOC_NEO1973_WM8753
         tristate "SoC I2S Audio support for NEO1973 - WM8753"
         depends on SND_S3C24XX_SOC && MACH_NEO1973_GTA01
@@ -56,11 +57,22 @@ config SND_S3C24XX_SOC_JIVE_WM8750
         help
           Sat Y if you want to add support for SoC audio on the Jive.
 
+config SND_S3C64XX_SOC_WM8580
+        tristate "SoC I2S Audio support for WM8580 on SMDK64XX"
+        depends on SND_S3C24XX_SOC && (MACH_SMDK6400 || MACH_SMDK6410)
+        depends on BROKEN
+        select SND_SOC_WM8580
+        select SND_S3C64XX_SOC_I2S
+        help
+          Sat Y if you want to add support for SoC audio on the SMDK64XX.
+
 config SND_S3C24XX_SOC_SMDK2443_WM9710
         tristate "SoC AC97 Audio support for SMDK2443 - WM9710"
         depends on SND_S3C24XX_SOC && MACH_SMDK2443
-        select SND_S3C2443_SOC_AC97
+        select S3C2410_DMA
+        select AC97_BUS
         select SND_SOC_AC97_CODEC
+        select SND_S3C_SOC_AC97
         help
           Say Y if you want to add support for SoC audio on smdk2443
           with the WM9710.
@@ -68,8 +80,10 @@ config SND_S3C24XX_SOC_SMDK2443_WM9710
 config SND_S3C24XX_SOC_LN2440SBC_ALC650
         tristate "SoC AC97 Audio support for LN2440SBC - ALC650"
         depends on SND_S3C24XX_SOC && ARCH_S3C2410
-        select SND_S3C2443_SOC_AC97
+        select S3C2410_DMA
+        select AC97_BUS
         select SND_SOC_AC97_CODEC
+        select SND_S3C_SOC_AC97
         help
           Say Y if you want to add support for SoC audio on ln2440sbc
           with the ALC650.
@@ -99,3 +113,11 @@ config SND_S3C24XX_SOC_SIMTEC_HERMES
         select SND_S3C24XX_SOC_I2S
         select SND_SOC_TLV320AIC3X
         select SND_S3C24XX_SOC_SIMTEC
+
+config SND_SOC_SMDK_WM9713
+        tristate "SoC AC97 Audio support for SMDK with WM9713"
+        depends on SND_S3C24XX_SOC && MACH_SMDK6410
+        select SND_SOC_WM9713
+        select SND_S3C_SOC_AC97
+        help
+          Sat Y if you want to add support for SoC audio on the SMDK.
diff --git a/sound/soc/s3c24xx/Makefile b/sound/soc/s3c24xx/Makefile
index 99f5a7dd3fc6..df071a376fa2 100644
--- a/sound/soc/s3c24xx/Makefile
+++ b/sound/soc/s3c24xx/Makefile
@@ -1,17 +1,19 @@
 # S3c24XX Platform Support
-snd-soc-s3c24xx-objs := s3c24xx-pcm.o
+snd-soc-s3c24xx-objs := s3c-dma.o
 snd-soc-s3c24xx-i2s-objs := s3c24xx-i2s.o
 snd-soc-s3c2412-i2s-objs := s3c2412-i2s.o
 snd-soc-s3c64xx-i2s-objs := s3c64xx-i2s.o
-snd-soc-s3c2443-ac97-objs := s3c2443-ac97.o
+snd-soc-s3c-ac97-objs := s3c-ac97.o
 snd-soc-s3c-i2s-v2-objs := s3c-i2s-v2.o
+snd-soc-s3c-pcm-objs := s3c-pcm.o
 
 obj-$(CONFIG_SND_S3C24XX_SOC) += snd-soc-s3c24xx.o
 obj-$(CONFIG_SND_S3C24XX_SOC_I2S) += snd-soc-s3c24xx-i2s.o
-obj-$(CONFIG_SND_S3C2443_SOC_AC97) += snd-soc-s3c2443-ac97.o
+obj-$(CONFIG_SND_S3C_SOC_AC97) += snd-soc-s3c-ac97.o
 obj-$(CONFIG_SND_S3C2412_SOC_I2S) += snd-soc-s3c2412-i2s.o
 obj-$(CONFIG_SND_S3C64XX_SOC_I2S) += snd-soc-s3c64xx-i2s.o
 obj-$(CONFIG_SND_S3C_I2SV2_SOC) += snd-soc-s3c-i2s-v2.o
+obj-$(CONFIG_SND_S3C_SOC_PCM) += snd-soc-s3c-pcm.o
 
 # S3C24XX Machine Support
 snd-soc-jive-wm8750-objs := jive_wm8750.o
@@ -23,6 +25,8 @@ snd-soc-s3c24xx-uda134x-objs := s3c24xx_uda134x.o
 snd-soc-s3c24xx-simtec-objs := s3c24xx_simtec.o
 snd-soc-s3c24xx-simtec-hermes-objs := s3c24xx_simtec_hermes.o
 snd-soc-s3c24xx-simtec-tlv320aic23-objs := s3c24xx_simtec_tlv320aic23.o
+snd-soc-smdk64xx-wm8580-objs := smdk64xx_wm8580.o
+snd-soc-smdk-wm9713-objs := smdk_wm9713.o
 
 obj-$(CONFIG_SND_S3C24XX_SOC_JIVE_WM8750) += snd-soc-jive-wm8750.o
 obj-$(CONFIG_SND_S3C24XX_SOC_NEO1973_WM8753) += snd-soc-neo1973-wm8753.o
@@ -33,4 +37,5 @@ obj-$(CONFIG_SND_S3C24XX_SOC_S3C24XX_UDA134X) += snd-soc-s3c24xx-uda134x.o
 obj-$(CONFIG_SND_S3C24XX_SOC_SIMTEC) += snd-soc-s3c24xx-simtec.o
 obj-$(CONFIG_SND_S3C24XX_SOC_SIMTEC_HERMES) += snd-soc-s3c24xx-simtec-hermes.o
 obj-$(CONFIG_SND_S3C24XX_SOC_SIMTEC_TLV320AIC23) += snd-soc-s3c24xx-simtec-tlv320aic23.o
-
+obj-$(CONFIG_SND_S3C64XX_SOC_WM8580) += snd-soc-smdk64xx-wm8580.o
+obj-$(CONFIG_SND_SOC_SMDK_WM9713) += snd-soc-smdk-wm9713.o
diff --git a/sound/soc/s3c24xx/jive_wm8750.c b/sound/soc/s3c24xx/jive_wm8750.c
index 93e6c87b7399..59dc2c6b56d9 100644
--- a/sound/soc/s3c24xx/jive_wm8750.c
+++ b/sound/soc/s3c24xx/jive_wm8750.c
@@ -25,7 +25,7 @@
 
 #include <asm/mach-types.h>
 
-#include "s3c24xx-pcm.h"
+#include "s3c-dma.h"
 #include "s3c2412-i2s.h"
 
 #include "../codecs/wm8750.h"
diff --git a/sound/soc/s3c24xx/ln2440sbc_alc650.c b/sound/soc/s3c24xx/ln2440sbc_alc650.c
index 12c71482d258..ffa954fe6931 100644
--- a/sound/soc/s3c24xx/ln2440sbc_alc650.c
+++ b/sound/soc/s3c24xx/ln2440sbc_alc650.c
@@ -24,8 +24,8 @@
 #include <sound/soc-dapm.h>
 
 #include "../codecs/ac97.h"
-#include "s3c24xx-pcm.h"
-#include "s3c24xx-ac97.h"
+#include "s3c-dma.h"
+#include "s3c-ac97.h"
 
 static struct snd_soc_card ln2440sbc;
 
@@ -33,7 +33,7 @@ static struct snd_soc_dai_link ln2440sbc_dai[] = {
 {
         .name = "AC97",
         .stream_name = "AC97 HiFi",
-        .cpu_dai = &s3c2443_ac97_dai[0],
+        .cpu_dai = &s3c_ac97_dai[S3C_AC97_DAI_PCM],
         .codec_dai = &ac97_dai,
 },
 };
diff --git a/sound/soc/s3c24xx/neo1973_gta02_wm8753.c b/sound/soc/s3c24xx/neo1973_gta02_wm8753.c
index 0c52e36ddd87..dea83d30a5c9 100644
--- a/sound/soc/s3c24xx/neo1973_gta02_wm8753.c
+++ b/sound/soc/s3c24xx/neo1973_gta02_wm8753.c
@@ -32,7 +32,7 @@
 #include <asm/io.h>
 #include <mach/gta02.h>
 #include "../codecs/wm8753.h"
-#include "s3c24xx-pcm.h"
+#include "s3c-dma.h"
 #include "s3c24xx-i2s.h"
 
 static struct snd_soc_card neo1973_gta02;
@@ -119,7 +119,7 @@ static int neo1973_gta02_hifi_hw_params(struct snd_pcm_substream *substream,
                 return ret;
 
         /* codec PLL input is PCLK/4 */
-        ret = snd_soc_dai_set_pll(codec_dai, WM8753_PLL1,
+        ret = snd_soc_dai_set_pll(codec_dai, WM8753_PLL1, 0,
                 iis_clkrate / 4, pll_out);
         if (ret < 0)
                 return ret;
@@ -133,7 +133,7 @@ static int neo1973_gta02_hifi_hw_free(struct snd_pcm_substream *substream)
         struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
 
         /* disable the PLL */
-        return snd_soc_dai_set_pll(codec_dai, WM8753_PLL1, 0, 0);
+        return snd_soc_dai_set_pll(codec_dai, WM8753_PLL1, 0, 0, 0);
 }
 
 /*
@@ -183,7 +183,7 @@ static int neo1973_gta02_voice_hw_params(
                 return ret;
 
         /* configue and enable PLL for 12.288MHz output */
-        ret = snd_soc_dai_set_pll(codec_dai, WM8753_PLL2,
+        ret = snd_soc_dai_set_pll(codec_dai, WM8753_PLL2, 0,
                 iis_clkrate / 4, 12288000);
         if (ret < 0)
                 return ret;
@@ -197,7 +197,7 @@ static int neo1973_gta02_voice_hw_free(struct snd_pcm_substream *substream)
         struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
 
         /* disable the PLL */
-        return snd_soc_dai_set_pll(codec_dai, WM8753_PLL2, 0, 0);
+        return snd_soc_dai_set_pll(codec_dai, WM8753_PLL2, 0, 0, 0);
 }
 
 static struct snd_soc_ops neo1973_gta02_voice_ops = {
diff --git a/sound/soc/s3c24xx/neo1973_wm8753.c b/sound/soc/s3c24xx/neo1973_wm8753.c
index 906709e6dd5f..0cb4f86f6d1e 100644
--- a/sound/soc/s3c24xx/neo1973_wm8753.c
+++ b/sound/soc/s3c24xx/neo1973_wm8753.c
@@ -29,7 +29,6 @@
 #include <mach/regs-clock.h>
 #include <mach/regs-gpio.h>
 #include <mach/hardware.h>
-#include <plat/audio.h>
 #include <linux/io.h>
 #include <mach/spi-gpio.h>
 
@@ -37,7 +36,7 @@
 
 #include "../codecs/wm8753.h"
 #include "lm4857.h"
-#include "s3c24xx-pcm.h"
+#include "s3c-dma.h"
 #include "s3c24xx-i2s.h"
 
 /* define the scenarios */
@@ -137,7 +136,7 @@ static int neo1973_hifi_hw_params(struct snd_pcm_substream *substream,
                 return ret;
 
         /* codec PLL input is PCLK/4 */
-        ret = snd_soc_dai_set_pll(codec_dai, WM8753_PLL1,
+        ret = snd_soc_dai_set_pll(codec_dai, WM8753_PLL1, 0,
                 iis_clkrate / 4, pll_out);
         if (ret < 0)
                 return ret;
@@ -153,7 +152,7 @@ static int neo1973_hifi_hw_free(struct snd_pcm_substream *substream)
         pr_debug("Entered %s\n", __func__);
 
         /* disable the PLL */
-        return snd_soc_dai_set_pll(codec_dai, WM8753_PLL1, 0, 0);
+        return snd_soc_dai_set_pll(codec_dai, WM8753_PLL1, 0, 0, 0);
 }
 
 /*
@@ -203,7 +202,7 @@ static int neo1973_voice_hw_params(struct snd_pcm_substream *substream,
                 return ret;
 
         /* configue and enable PLL for 12.288MHz output */
-        ret = snd_soc_dai_set_pll(codec_dai, WM8753_PLL2,
+        ret = snd_soc_dai_set_pll(codec_dai, WM8753_PLL2, 0,
                 iis_clkrate / 4, 12288000);
         if (ret < 0)
                 return ret;
@@ -219,7 +218,7 @@ static int neo1973_voice_hw_free(struct snd_pcm_substream *substream)
         pr_debug("Entered %s\n", __func__);
 
         /* disable the PLL */
-        return snd_soc_dai_set_pll(codec_dai, WM8753_PLL2, 0, 0);
+        return snd_soc_dai_set_pll(codec_dai, WM8753_PLL2, 0, 0, 0);
 }
 
 static struct snd_soc_ops neo1973_voice_ops = {
diff --git a/sound/soc/s3c24xx/s3c-ac97.c b/sound/soc/s3c24xx/s3c-ac97.c
new file mode 100644
index 000000000000..ecf4fd04ae96
--- /dev/null
+++ b/sound/soc/s3c24xx/s3c-ac97.c
@@ -0,0 +1,521 @@
+/* sound/soc/s3c24xx/s3c-ac97.c
+ *
+ * ALSA SoC Audio Layer - S3C AC97 Controller driver
+ *      Evolved from s3c2443-ac97.c
+ *
+ * Copyright (c) 2010 Samsung Electronics Co. Ltd
+ *      Author: Jaswinder Singh <jassi.brar@samsung.com>
+ *      Credits: Graeme Gregory, Sean Choi
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/io.h>
+#include <linux/delay.h>
+#include <linux/clk.h>
+
+#include <sound/soc.h>
+
+#include <plat/regs-ac97.h>
+#include <mach/dma.h>
+#include <plat/audio.h>
+
+#include "s3c-dma.h"
+#include "s3c-ac97.h"
+
+#define AC_CMD_ADDR(x) (x << 16)
+#define AC_CMD_DATA(x) (x & 0xffff)
+
+struct s3c_ac97_info {
+        unsigned           state;
+        struct clk         *ac97_clk;
+        void __iomem       *regs;
+        struct mutex       lock;
+        struct completion  done;
+};
+static struct s3c_ac97_info s3c_ac97;
+
+static struct s3c2410_dma_client s3c_dma_client_out = {
+        .name = "AC97 PCMOut"
+};
+
+static struct s3c2410_dma_client s3c_dma_client_in = {
+        .name = "AC97 PCMIn"
+};
+
+static struct s3c2410_dma_client s3c_dma_client_micin = {
+        .name = "AC97 MicIn"
+};
+
+static struct s3c_dma_params s3c_ac97_pcm_out = {
+        .client         = &s3c_dma_client_out,
+        .dma_size       = 4,
+};
+
+static struct s3c_dma_params s3c_ac97_pcm_in = {
+        .client         = &s3c_dma_client_in,
+        .dma_size       = 4,
+};
+
+static struct s3c_dma_params s3c_ac97_mic_in = {
+        .client         = &s3c_dma_client_micin,
+        .dma_size       = 4,
+};
+
+static void s3c_ac97_activate(struct snd_ac97 *ac97)
+{
+        u32 ac_glbctrl, stat;
+
+        stat = readl(s3c_ac97.regs + S3C_AC97_GLBSTAT) & 0x7;
+        if (stat == S3C_AC97_GLBSTAT_MAINSTATE_ACTIVE)
+                return; /* Return if already active */
+
+        INIT_COMPLETION(s3c_ac97.done);
+
+        ac_glbctrl = readl(s3c_ac97.regs + S3C_AC97_GLBCTRL);
+        ac_glbctrl = S3C_AC97_GLBCTRL_ACLINKON;
+        writel(ac_glbctrl, s3c_ac97.regs + S3C_AC97_GLBCTRL);
+        msleep(1);
+
+        ac_glbctrl |= S3C_AC97_GLBCTRL_TRANSFERDATAENABLE;
+        writel(ac_glbctrl, s3c_ac97.regs + S3C_AC97_GLBCTRL);
+        msleep(1);
+
+        ac_glbctrl = readl(s3c_ac97.regs + S3C_AC97_GLBCTRL);
+        ac_glbctrl |= S3C_AC97_GLBCTRL_CODECREADYIE;
+        writel(ac_glbctrl, s3c_ac97.regs + S3C_AC97_GLBCTRL);
+
+        if (!wait_for_completion_timeout(&s3c_ac97.done, HZ))
+                printk(KERN_ERR "AC97: Unable to activate!");
+}
+
+static unsigned short s3c_ac97_read(struct snd_ac97 *ac97,
+        unsigned short reg)
+{
+        u32 ac_glbctrl, ac_codec_cmd;
+        u32 stat, addr, data;
+
+        mutex_lock(&s3c_ac97.lock);
+
+        s3c_ac97_activate(ac97);
+
+        INIT_COMPLETION(s3c_ac97.done);
+
+        ac_codec_cmd = readl(s3c_ac97.regs + S3C_AC97_CODEC_CMD);
+        ac_codec_cmd = S3C_AC97_CODEC_CMD_READ | AC_CMD_ADDR(reg);
+        writel(ac_codec_cmd, s3c_ac97.regs + S3C_AC97_CODEC_CMD);
+
+        udelay(50);
+
+        ac_glbctrl = readl(s3c_ac97.regs + S3C_AC97_GLBCTRL);
+        ac_glbctrl |= S3C_AC97_GLBCTRL_CODECREADYIE;
+        writel(ac_glbctrl, s3c_ac97.regs + S3C_AC97_GLBCTRL);
+
+        if (!wait_for_completion_timeout(&s3c_ac97.done, HZ))
+                printk(KERN_ERR "AC97: Unable to read!");
+
+        stat = readl(s3c_ac97.regs + S3C_AC97_STAT);
+        addr = (stat >> 16) & 0x7f;
+        data = (stat & 0xffff);
+
+        if (addr != reg)
+                printk(KERN_ERR "s3c-ac97: req addr = %02x, rep addr = %02x\n", reg, addr);
+
+        mutex_unlock(&s3c_ac97.lock);
+
+        return (unsigned short)data;
+}
+
+static void s3c_ac97_write(struct snd_ac97 *ac97, unsigned short reg,
+        unsigned short val)
+{
+        u32 ac_glbctrl, ac_codec_cmd;
+
+        mutex_lock(&s3c_ac97.lock);
+
+        s3c_ac97_activate(ac97);
+
+        INIT_COMPLETION(s3c_ac97.done);
+
+        ac_codec_cmd = readl(s3c_ac97.regs + S3C_AC97_CODEC_CMD);
+        ac_codec_cmd = AC_CMD_ADDR(reg) | AC_CMD_DATA(val);
+        writel(ac_codec_cmd, s3c_ac97.regs + S3C_AC97_CODEC_CMD);
+
+        udelay(50);
+
+        ac_glbctrl = readl(s3c_ac97.regs + S3C_AC97_GLBCTRL);
+        ac_glbctrl |= S3C_AC97_GLBCTRL_CODECREADYIE;
+        writel(ac_glbctrl, s3c_ac97.regs + S3C_AC97_GLBCTRL);
+
+        if (!wait_for_completion_timeout(&s3c_ac97.done, HZ))
+                printk(KERN_ERR "AC97: Unable to write!");
+
+        ac_codec_cmd = readl(s3c_ac97.regs + S3C_AC97_CODEC_CMD);
+        ac_codec_cmd |= S3C_AC97_CODEC_CMD_READ;
+        writel(ac_codec_cmd, s3c_ac97.regs + S3C_AC97_CODEC_CMD);
+
+        mutex_unlock(&s3c_ac97.lock);
+}
+
+static void s3c_ac97_cold_reset(struct snd_ac97 *ac97)
+{
+        writel(S3C_AC97_GLBCTRL_COLDRESET,
+                        s3c_ac97.regs + S3C_AC97_GLBCTRL);
+        msleep(1);
+
+        writel(0, s3c_ac97.regs + S3C_AC97_GLBCTRL);
+        msleep(1);
+}
+
+static void s3c_ac97_warm_reset(struct snd_ac97 *ac97)
+{
+        u32 stat;
+
+        stat = readl(s3c_ac97.regs + S3C_AC97_GLBSTAT) & 0x7;
+        if (stat == S3C_AC97_GLBSTAT_MAINSTATE_ACTIVE)
+                return; /* Return if already active */
+
+        writel(S3C_AC97_GLBCTRL_WARMRESET, s3c_ac97.regs + S3C_AC97_GLBCTRL);
+        msleep(1);
+
+        writel(0, s3c_ac97.regs + S3C_AC97_GLBCTRL);
+        msleep(1);
+
+        s3c_ac97_activate(ac97);
+}
+
+static irqreturn_t s3c_ac97_irq(int irq, void *dev_id)
+{
+        u32 ac_glbctrl, ac_glbstat;
+
+        ac_glbstat = readl(s3c_ac97.regs + S3C_AC97_GLBSTAT);
+
+        if (ac_glbstat & S3C_AC97_GLBSTAT_CODECREADY) {
+
+                ac_glbctrl = readl(s3c_ac97.regs + S3C_AC97_GLBCTRL);
+                ac_glbctrl &= ~S3C_AC97_GLBCTRL_CODECREADYIE;
+                writel(ac_glbctrl, s3c_ac97.regs + S3C_AC97_GLBCTRL);
+
+                complete(&s3c_ac97.done);
+        }
+
+        ac_glbctrl = readl(s3c_ac97.regs + S3C_AC97_GLBCTRL);
+        ac_glbctrl |= (1<<30); /* Clear interrupt */
+        writel(ac_glbctrl, s3c_ac97.regs + S3C_AC97_GLBCTRL);
+
+        return IRQ_HANDLED;
+}
+
+struct snd_ac97_bus_ops soc_ac97_ops = {
+        .read       = s3c_ac97_read,
+        .write      = s3c_ac97_write,
+        .warm_reset = s3c_ac97_warm_reset,
+        .reset      = s3c_ac97_cold_reset,
+};
+EXPORT_SYMBOL_GPL(soc_ac97_ops);
+
+static int s3c_ac97_hw_params(struct snd_pcm_substream *substream,
+                                  struct snd_pcm_hw_params *params,
+                                  struct snd_soc_dai *dai)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
+        struct s3c_dma_params *dma_data;
+
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+                dma_data = &s3c_ac97_pcm_out;
+        else
+                dma_data = &s3c_ac97_pcm_in;
+
+        snd_soc_dai_set_dma_data(cpu_dai, substream, dma_data);
+
+        return 0;
+}
+
+static int s3c_ac97_trigger(struct snd_pcm_substream *substream, int cmd,
+                                struct snd_soc_dai *dai)
+{
+        u32 ac_glbctrl;
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct s3c_dma_params *dma_data =
+                snd_soc_dai_get_dma_data(rtd->dai->cpu_dai, substream);
+
+        ac_glbctrl = readl(s3c_ac97.regs + S3C_AC97_GLBCTRL);
+        if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
+                ac_glbctrl &= ~S3C_AC97_GLBCTRL_PCMINTM_MASK;
+        else
+                ac_glbctrl &= ~S3C_AC97_GLBCTRL_PCMOUTTM_MASK;
+
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+        case SNDRV_PCM_TRIGGER_RESUME:
+        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
+                if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
+                        ac_glbctrl |= S3C_AC97_GLBCTRL_PCMINTM_DMA;
+                else
+                        ac_glbctrl |= S3C_AC97_GLBCTRL_PCMOUTTM_DMA;
+                break;
+
+        case SNDRV_PCM_TRIGGER_STOP:
+        case SNDRV_PCM_TRIGGER_SUSPEND:
+        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
+                break;
+        }
+
+        writel(ac_glbctrl, s3c_ac97.regs + S3C_AC97_GLBCTRL);
+
+        s3c2410_dma_ctrl(dma_data->channel, S3C2410_DMAOP_STARTED);
+
+        return 0;
+}
+
+static int s3c_ac97_hw_mic_params(struct snd_pcm_substream *substream,
+                                      struct snd_pcm_hw_params *params,
+                                      struct snd_soc_dai *dai)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
+
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+                return -ENODEV;
+        else
+                snd_soc_dai_set_dma_data(cpu_dai, substream, &s3c_ac97_mic_in);
+
+        return 0;
+}
+
+static int s3c_ac97_mic_trigger(struct snd_pcm_substream *substream,
+                                    int cmd, struct snd_soc_dai *dai)
+{
+        u32 ac_glbctrl;
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct s3c_dma_params *dma_data =
+                snd_soc_dai_get_dma_data(rtd->dai->cpu_dai, substream);
+
+        ac_glbctrl = readl(s3c_ac97.regs + S3C_AC97_GLBCTRL);
+        ac_glbctrl &= ~S3C_AC97_GLBCTRL_MICINTM_MASK;
+
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+        case SNDRV_PCM_TRIGGER_RESUME:
+        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
+                ac_glbctrl |= S3C_AC97_GLBCTRL_MICINTM_DMA;
+                break;
+
+        case SNDRV_PCM_TRIGGER_STOP:
+        case SNDRV_PCM_TRIGGER_SUSPEND:
+        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
+                break;
+        }
+
+        writel(ac_glbctrl, s3c_ac97.regs + S3C_AC97_GLBCTRL);
+
+        s3c2410_dma_ctrl(dma_data->channel, S3C2410_DMAOP_STARTED);
+
+        return 0;
+}
+
+static struct snd_soc_dai_ops s3c_ac97_dai_ops = {
+        .hw_params      = s3c_ac97_hw_params,
+        .trigger        = s3c_ac97_trigger,
+};
+
+static struct snd_soc_dai_ops s3c_ac97_mic_dai_ops = {
+        .hw_params      = s3c_ac97_hw_mic_params,
+        .trigger        = s3c_ac97_mic_trigger,
+};
+
+struct snd_soc_dai s3c_ac97_dai[] = {
+        [S3C_AC97_DAI_PCM] = {
+                .name = "s3c-ac97",
+                .id = S3C_AC97_DAI_PCM,
+                .ac97_control = 1,
+                .playback = {
+                        .stream_name = "AC97 Playback",
+                        .channels_min = 2,
+                        .channels_max = 2,
+                        .rates = SNDRV_PCM_RATE_8000_48000,
+                        .formats = SNDRV_PCM_FMTBIT_S16_LE,},
+                .capture = {
+                        .stream_name = "AC97 Capture",
+                        .channels_min = 2,
+                        .channels_max = 2,
+                        .rates = SNDRV_PCM_RATE_8000_48000,
+                        .formats = SNDRV_PCM_FMTBIT_S16_LE,},
+                .ops = &s3c_ac97_dai_ops,
+        },
+        [S3C_AC97_DAI_MIC] = {
+                .name = "s3c-ac97-mic",
+                .id = S3C_AC97_DAI_MIC,
+                .ac97_control = 1,
+                .capture = {
+                        .stream_name = "AC97 Mic Capture",
+                        .channels_min = 1,
+                        .channels_max = 1,
+                        .rates = SNDRV_PCM_RATE_8000_48000,
+                        .formats = SNDRV_PCM_FMTBIT_S16_LE,},
+                .ops = &s3c_ac97_mic_dai_ops,
+        },
+};
+EXPORT_SYMBOL_GPL(s3c_ac97_dai);
+
+static __devinit int s3c_ac97_probe(struct platform_device *pdev)
+{
+        struct resource *mem_res, *dmatx_res, *dmarx_res, *dmamic_res, *irq_res;
+        struct s3c_audio_pdata *ac97_pdata;
+        int ret;
+
+        ac97_pdata = pdev->dev.platform_data;
+        if (!ac97_pdata || !ac97_pdata->cfg_gpio) {
+                dev_err(&pdev->dev, "cfg_gpio callback not provided!\n");
+                return -EINVAL;
+        }
+
+        /* Check for availability of necessary resource */
+        dmatx_res = platform_get_resource(pdev, IORESOURCE_DMA, 0);
+        if (!dmatx_res) {
+                dev_err(&pdev->dev, "Unable to get AC97-TX dma resource\n");
+                return -ENXIO;
+        }
+
+        dmarx_res = platform_get_resource(pdev, IORESOURCE_DMA, 1);
+        if (!dmarx_res) {
+                dev_err(&pdev->dev, "Unable to get AC97-RX dma resource\n");
+                return -ENXIO;
+        }
+
+        dmamic_res = platform_get_resource(pdev, IORESOURCE_DMA, 2);
+        if (!dmamic_res) {
+                dev_err(&pdev->dev, "Unable to get AC97-MIC dma resource\n");
+                return -ENXIO;
+        }
+
+        mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!mem_res) {
+                dev_err(&pdev->dev, "Unable to get register resource\n");
+                return -ENXIO;
+        }
+
+        irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        if (!irq_res) {
+                dev_err(&pdev->dev, "AC97 IRQ not provided!\n");
+                return -ENXIO;
+        }
+
+        if (!request_mem_region(mem_res->start,
+                                resource_size(mem_res), "s3c-ac97")) {
+                dev_err(&pdev->dev, "Unable to request register region\n");
+                return -EBUSY;
+        }
+
+        s3c_ac97_pcm_out.channel = dmatx_res->start;
+        s3c_ac97_pcm_out.dma_addr = mem_res->start + S3C_AC97_PCM_DATA;
+        s3c_ac97_pcm_in.channel = dmarx_res->start;
+        s3c_ac97_pcm_in.dma_addr = mem_res->start + S3C_AC97_PCM_DATA;
+        s3c_ac97_mic_in.channel = dmamic_res->start;
+        s3c_ac97_mic_in.dma_addr = mem_res->start + S3C_AC97_MIC_DATA;
+
+        init_completion(&s3c_ac97.done);
+        mutex_init(&s3c_ac97.lock);
+
+        s3c_ac97.regs = ioremap(mem_res->start, resource_size(mem_res));
+        if (s3c_ac97.regs == NULL) {
+                dev_err(&pdev->dev, "Unable to ioremap register region\n");
+                ret = -ENXIO;
+                goto err1;
+        }
+
+        s3c_ac97.ac97_clk = clk_get(&pdev->dev, "ac97");
+        if (IS_ERR(s3c_ac97.ac97_clk)) {
+                dev_err(&pdev->dev, "s3c-ac97 failed to get ac97_clock\n");
+                ret = -ENODEV;
+                goto err2;
+        }
+        clk_enable(s3c_ac97.ac97_clk);
+
+        if (ac97_pdata->cfg_gpio(pdev)) {
+                dev_err(&pdev->dev, "Unable to configure gpio\n");
+                ret = -EINVAL;
+                goto err3;
+        }
+
+        ret = request_irq(irq_res->start, s3c_ac97_irq,
+                                        IRQF_DISABLED, "AC97", NULL);
+        if (ret < 0) {
+                printk(KERN_ERR "s3c-ac97: interrupt request failed.\n");
+                goto err4;
+        }
+
+        s3c_ac97_dai[S3C_AC97_DAI_PCM].dev = &pdev->dev;
+        s3c_ac97_dai[S3C_AC97_DAI_MIC].dev = &pdev->dev;
+
+        ret = snd_soc_register_dais(s3c_ac97_dai, ARRAY_SIZE(s3c_ac97_dai));
+        if (ret)
+                goto err5;
+
+        return 0;
+
+err5:
+        free_irq(irq_res->start, NULL);
+err4:
+err3:
+        clk_disable(s3c_ac97.ac97_clk);
+        clk_put(s3c_ac97.ac97_clk);
+err2:
+        iounmap(s3c_ac97.regs);
+err1:
+        release_mem_region(mem_res->start, resource_size(mem_res));
+
+        return ret;
+}
+
+static __devexit int s3c_ac97_remove(struct platform_device *pdev)
+{
+        struct resource *mem_res, *irq_res;
+
+        snd_soc_unregister_dais(s3c_ac97_dai, ARRAY_SIZE(s3c_ac97_dai));
+
+        irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        if (irq_res)
+                free_irq(irq_res->start, NULL);
+
+        clk_disable(s3c_ac97.ac97_clk);
+        clk_put(s3c_ac97.ac97_clk);
+
+        iounmap(s3c_ac97.regs);
+
+        mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (mem_res)
+                release_mem_region(mem_res->start, resource_size(mem_res));
+
+        return 0;
+}
+
+static struct platform_driver s3c_ac97_driver = {
+        .probe  = s3c_ac97_probe,
+        .remove = s3c_ac97_remove,
+        .driver = {
+                .name = "s3c-ac97",
+                .owner = THIS_MODULE,
+        },
+};
+
+static int __init s3c_ac97_init(void)
+{
+        return platform_driver_register(&s3c_ac97_driver);
+}
+module_init(s3c_ac97_init);
+
+static void __exit s3c_ac97_exit(void)
+{
+        platform_driver_unregister(&s3c_ac97_driver);
+}
+module_exit(s3c_ac97_exit);
+
+MODULE_AUTHOR("Jaswinder Singh, <jassi.brar@samsung.com>");
+MODULE_DESCRIPTION("AC97 driver for the Samsung SoC");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/s3c24xx/s3c-ac97.h b/sound/soc/s3c24xx/s3c-ac97.h
new file mode 100644
index 000000000000..278198379def
--- /dev/null
+++ b/sound/soc/s3c24xx/s3c-ac97.h
@@ -0,0 +1,23 @@
+/* sound/soc/s3c24xx/s3c-ac97.h
+ *
+ * ALSA SoC Audio Layer - S3C AC97 Controller driver
+ *      Evolved from s3c2443-ac97.h
+ *
+ * Copyright (c) 2010 Samsung Electronics Co. Ltd
+ *      Author: Jaswinder Singh <jassi.brar@samsung.com>
+ *      Credits: Graeme Gregory, Sean Choi
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef __S3C_AC97_H_
+#define __S3C_AC97_H_
+
+#define S3C_AC97_DAI_PCM 0
+#define S3C_AC97_DAI_MIC 1
+
+extern struct snd_soc_dai s3c_ac97_dai[];
+
+#endif /* __S3C_AC97_H_ */
diff --git a/sound/soc/s3c24xx/s3c24xx-pcm.c b/sound/soc/s3c24xx/s3c-dma.c
index 1f35c6fcf5fd..1b61c23ff300 100644
--- a/sound/soc/s3c24xx/s3c24xx-pcm.c
+++ b/sound/soc/s3c24xx/s3c-dma.c
@@ -1,5 +1,5 @@
 /*
- * s3c24xx-pcm.c  --  ALSA Soc Audio Layer
+ * s3c-dma.c  --  ALSA Soc Audio Layer
  *
  * (c) 2006 Wolfson Microelectronics PLC.
  * Graeme Gregory graeme.gregory@wolfsonmicro.com or linux@wolfsonmicro.com
@@ -29,11 +29,10 @@
 #include <asm/dma.h>
 #include <mach/hardware.h>
 #include <mach/dma.h>
-#include <plat/audio.h>
 
-#include "s3c24xx-pcm.h"
+#include "s3c-dma.h"
 
-static const struct snd_pcm_hardware s3c24xx_pcm_hardware = {
+static const struct snd_pcm_hardware s3c_dma_hardware = {
         .info                   = SNDRV_PCM_INFO_INTERLEAVED |
                                     SNDRV_PCM_INFO_BLOCK_TRANSFER |
                                     SNDRV_PCM_INFO_MMAP |
@@ -63,15 +62,15 @@ struct s3c24xx_runtime_data {
         dma_addr_t dma_start;
         dma_addr_t dma_pos;
         dma_addr_t dma_end;
-        struct s3c24xx_pcm_dma_params *params;
+        struct s3c_dma_params *params;
 };
 
-/* s3c24xx_pcm_enqueue
+/* s3c_dma_enqueue
  *
  * place a dma buffer onto the queue for the dma system
  * to handle.
 */
-static void s3c24xx_pcm_enqueue(struct snd_pcm_substream *substream)
+static void s3c_dma_enqueue(struct snd_pcm_substream *substream)
 {
         struct s3c24xx_runtime_data *prtd = substream->runtime->private_data;
         dma_addr_t pos = prtd->dma_pos;
@@ -80,12 +79,13 @@ static void s3c24xx_pcm_enqueue(struct snd_pcm_substream *substream)
 
         pr_debug("Entered %s\n", __func__);
 
-        if (s3c_dma_has_circular()) {
+        if (s3c_dma_has_circular())
                 limit = (prtd->dma_end - prtd->dma_start) / prtd->dma_period;
-        } else
+        else
                 limit = prtd->dma_limit;
 
-        pr_debug("%s: loaded %d, limit %d\n", __func__, prtd->dma_loaded, limit);
+        pr_debug("%s: loaded %d, limit %d\n",
+                                __func__, prtd->dma_loaded, limit);
 
         while (prtd->dma_loaded < limit) {
                 unsigned long len = prtd->dma_period;
@@ -133,22 +133,24 @@ static void s3c24xx_audio_buffdone(struct s3c2410_dma_chan *channel,
         spin_lock(&prtd->lock);
         if (prtd->state & ST_RUNNING && !s3c_dma_has_circular()) {
                 prtd->dma_loaded--;
-                s3c24xx_pcm_enqueue(substream);
+                s3c_dma_enqueue(substream);
         }
 
         spin_unlock(&prtd->lock);
 }
 
-static int s3c24xx_pcm_hw_params(struct snd_pcm_substream *substream,
+static int s3c_dma_hw_params(struct snd_pcm_substream *substream,
         struct snd_pcm_hw_params *params)
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
         struct s3c24xx_runtime_data *prtd = runtime->private_data;
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
-        struct s3c24xx_pcm_dma_params *dma = rtd->dai->cpu_dai->dma_data;
         unsigned long totbytes = params_buffer_bytes(params);
+        struct s3c_dma_params *dma =
+                snd_soc_dai_get_dma_data(rtd->dai->cpu_dai, substream);
         int ret = 0;
 
+
         pr_debug("Entered %s\n", __func__);
 
         /* return if this is a bufferless transfer e.g.
@@ -198,7 +200,7 @@ static int s3c24xx_pcm_hw_params(struct snd_pcm_substream *substream,
         return 0;
 }
 
-static int s3c24xx_pcm_hw_free(struct snd_pcm_substream *substream)
+static int s3c_dma_hw_free(struct snd_pcm_substream *substream)
 {
         struct s3c24xx_runtime_data *prtd = substream->runtime->private_data;
 
@@ -215,7 +217,7 @@ static int s3c24xx_pcm_hw_free(struct snd_pcm_substream *substream)
         return 0;
 }
 
-static int s3c24xx_pcm_prepare(struct snd_pcm_substream *substream)
+static int s3c_dma_prepare(struct snd_pcm_substream *substream)
 {
         struct s3c24xx_runtime_data *prtd = substream->runtime->private_data;
         int ret = 0;
@@ -248,12 +250,12 @@ static int s3c24xx_pcm_prepare(struct snd_pcm_substream *substream)
         prtd->dma_pos = prtd->dma_start;
 
         /* enqueue dma buffers */
-        s3c24xx_pcm_enqueue(substream);
+        s3c_dma_enqueue(substream);
 
         return ret;
 }
 
-static int s3c24xx_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
+static int s3c_dma_trigger(struct snd_pcm_substream *substream, int cmd)
 {
         struct s3c24xx_runtime_data *prtd = substream->runtime->private_data;
         int ret = 0;
@@ -288,7 +290,7 @@ static int s3c24xx_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
 }
 
 static snd_pcm_uframes_t
-s3c24xx_pcm_pointer(struct snd_pcm_substream *substream)
+s3c_dma_pointer(struct snd_pcm_substream *substream)
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
         struct s3c24xx_runtime_data *prtd = runtime->private_data;
@@ -323,7 +325,7 @@ s3c24xx_pcm_pointer(struct snd_pcm_substream *substream)
         return bytes_to_frames(substream->runtime, res);
 }
 
-static int s3c24xx_pcm_open(struct snd_pcm_substream *substream)
+static int s3c_dma_open(struct snd_pcm_substream *substream)
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
         struct s3c24xx_runtime_data *prtd;
@@ -331,7 +333,7 @@ static int s3c24xx_pcm_open(struct snd_pcm_substream *substream)
         pr_debug("Entered %s\n", __func__);
 
         snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
-        snd_soc_set_runtime_hwparams(substream, &s3c24xx_pcm_hardware);
+        snd_soc_set_runtime_hwparams(substream, &s3c_dma_hardware);
 
         prtd = kzalloc(sizeof(struct s3c24xx_runtime_data), GFP_KERNEL);
         if (prtd == NULL)
@@ -343,7 +345,7 @@ static int s3c24xx_pcm_open(struct snd_pcm_substream *substream)
         return 0;
 }
 
-static int s3c24xx_pcm_close(struct snd_pcm_substream *substream)
+static int s3c_dma_close(struct snd_pcm_substream *substream)
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
         struct s3c24xx_runtime_data *prtd = runtime->private_data;
@@ -351,14 +353,14 @@ static int s3c24xx_pcm_close(struct snd_pcm_substream *substream)
         pr_debug("Entered %s\n", __func__);
 
         if (!prtd)
-                pr_debug("s3c24xx_pcm_close called with prtd == NULL\n");
+                pr_debug("s3c_dma_close called with prtd == NULL\n");
 
         kfree(prtd);
 
         return 0;
 }
 
-static int s3c24xx_pcm_mmap(struct snd_pcm_substream *substream,
+static int s3c_dma_mmap(struct snd_pcm_substream *substream,
         struct vm_area_struct *vma)
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
@@ -371,23 +373,23 @@ static int s3c24xx_pcm_mmap(struct snd_pcm_substream *substream,
                                      runtime->dma_bytes);
 }
 
-static struct snd_pcm_ops s3c24xx_pcm_ops = {
-        .open           = s3c24xx_pcm_open,
-        .close          = s3c24xx_pcm_close,
+static struct snd_pcm_ops s3c_dma_ops = {
+        .open           = s3c_dma_open,
+        .close          = s3c_dma_close,
         .ioctl          = snd_pcm_lib_ioctl,
-        .hw_params      = s3c24xx_pcm_hw_params,
-        .hw_free        = s3c24xx_pcm_hw_free,
-        .prepare        = s3c24xx_pcm_prepare,
-        .trigger        = s3c24xx_pcm_trigger,
-        .pointer        = s3c24xx_pcm_pointer,
-        .mmap           = s3c24xx_pcm_mmap,
+        .hw_params      = s3c_dma_hw_params,
+        .hw_free        = s3c_dma_hw_free,
+        .prepare        = s3c_dma_prepare,
+        .trigger        = s3c_dma_trigger,
+        .pointer        = s3c_dma_pointer,
+        .mmap           = s3c_dma_mmap,
 };
 
-static int s3c24xx_pcm_preallocate_dma_buffer(struct snd_pcm *pcm, int stream)
+static int s3c_preallocate_dma_buffer(struct snd_pcm *pcm, int stream)
 {
         struct snd_pcm_substream *substream = pcm->streams[stream].substream;
         struct snd_dma_buffer *buf = &substream->dma_buffer;
-        size_t size = s3c24xx_pcm_hardware.buffer_bytes_max;
+        size_t size = s3c_dma_hardware.buffer_bytes_max;
 
         pr_debug("Entered %s\n", __func__);
 
@@ -402,7 +404,7 @@ static int s3c24xx_pcm_preallocate_dma_buffer(struct snd_pcm *pcm, int stream)
         return 0;
 }
 
-static void s3c24xx_pcm_free_dma_buffers(struct snd_pcm *pcm)
+static void s3c_dma_free_dma_buffers(struct snd_pcm *pcm)
 {
         struct snd_pcm_substream *substream;
         struct snd_dma_buffer *buf;
@@ -425,9 +427,9 @@ static void s3c24xx_pcm_free_dma_buffers(struct snd_pcm *pcm)
         }
 }
 
-static u64 s3c24xx_pcm_dmamask = DMA_BIT_MASK(32);
+static u64 s3c_dma_mask = DMA_BIT_MASK(32);
 
-static int s3c24xx_pcm_new(struct snd_card *card,
+static int s3c_dma_new(struct snd_card *card,
         struct snd_soc_dai *dai, struct snd_pcm *pcm)
 {
         int ret = 0;
@@ -435,19 +437,19 @@ static int s3c24xx_pcm_new(struct snd_card *card,
         pr_debug("Entered %s\n", __func__);
 
         if (!card->dev->dma_mask)
-                card->dev->dma_mask = &s3c24xx_pcm_dmamask;
+                card->dev->dma_mask = &s3c_dma_mask;
         if (!card->dev->coherent_dma_mask)
                 card->dev->coherent_dma_mask = 0xffffffff;
 
         if (dai->playback.channels_min) {
-                ret = s3c24xx_pcm_preallocate_dma_buffer(pcm,
+                ret = s3c_preallocate_dma_buffer(pcm,
                         SNDRV_PCM_STREAM_PLAYBACK);
                 if (ret)
                         goto out;
         }
 
         if (dai->capture.channels_min) {
-                ret = s3c24xx_pcm_preallocate_dma_buffer(pcm,
+                ret = s3c_preallocate_dma_buffer(pcm,
                         SNDRV_PCM_STREAM_CAPTURE);
                 if (ret)
                         goto out;
@@ -458,9 +460,9 @@ static int s3c24xx_pcm_new(struct snd_card *card,
 
 struct snd_soc_platform s3c24xx_soc_platform = {
         .name           = "s3c24xx-audio",
-        .pcm_ops        = &s3c24xx_pcm_ops,
-        .pcm_new        = s3c24xx_pcm_new,
-        .pcm_free       = s3c24xx_pcm_free_dma_buffers,
+        .pcm_ops        = &s3c_dma_ops,
+        .pcm_new        = s3c_dma_new,
+        .pcm_free       = s3c_dma_free_dma_buffers,
 };
 EXPORT_SYMBOL_GPL(s3c24xx_soc_platform);
 
@@ -477,5 +479,5 @@ static void __exit s3c24xx_soc_platform_exit(void)
 module_exit(s3c24xx_soc_platform_exit);
 
 MODULE_AUTHOR("Ben Dooks, <ben@simtec.co.uk>");
-MODULE_DESCRIPTION("Samsung S3C24XX PCM DMA module");
+MODULE_DESCRIPTION("Samsung S3C Audio DMA module");
 MODULE_LICENSE("GPL");
diff --git a/sound/soc/s3c24xx/s3c24xx-pcm.h b/sound/soc/s3c24xx/s3c-dma.h
index 0088c79822ea..69bb6bf6fc1c 100644
--- a/sound/soc/s3c24xx/s3c24xx-pcm.h
+++ b/sound/soc/s3c24xx/s3c-dma.h
@@ -1,5 +1,5 @@
 /*
- *  s3c24xx-pcm.h --
+ *  s3c-dma.h --
  *
  *  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 the
@@ -9,13 +9,13 @@
  *  ALSA PCM interface for the Samsung S3C24xx CPU
  */
 
-#ifndef _S3C24XX_PCM_H
-#define _S3C24XX_PCM_H
+#ifndef _S3C_AUDIO_H
+#define _S3C_AUDIO_H
 
 #define ST_RUNNING              (1<<0)
 #define ST_OPENED               (1<<1)
 
-struct s3c24xx_pcm_dma_params {
+struct s3c_dma_params {
         struct s3c2410_dma_client *client;      /* stream identifier */
         int channel;                            /* Channel ID */
         dma_addr_t dma_addr;
diff --git a/sound/soc/s3c24xx/s3c-i2s-v2.c b/sound/soc/s3c24xx/s3c-i2s-v2.c
index 9bc4aa35caab..88515946b6c0 100644
--- a/sound/soc/s3c24xx/s3c-i2s-v2.c
+++ b/sound/soc/s3c24xx/s3c-i2s-v2.c
@@ -32,11 +32,10 @@
 
 #include <plat/regs-s3c2412-iis.h>
 
-#include <plat/audio.h>
 #include <mach/dma.h>
 
 #include "s3c-i2s-v2.h"
-#include "s3c24xx-pcm.h"
+#include "s3c-dma.h"
 
 #undef S3C_IIS_V2_SUPPORTED
 
@@ -312,12 +311,15 @@ static int s3c2412_i2s_set_fmt(struct snd_soc_dai *cpu_dai,
 
         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
         case SND_SOC_DAIFMT_RIGHT_J:
+                iismod |= S3C2412_IISMOD_LR_RLOW;
                 iismod |= S3C2412_IISMOD_SDF_MSB;
                 break;
         case SND_SOC_DAIFMT_LEFT_J:
+                iismod |= S3C2412_IISMOD_LR_RLOW;
                 iismod |= S3C2412_IISMOD_SDF_LSB;
                 break;
         case SND_SOC_DAIFMT_I2S:
+                iismod &= ~S3C2412_IISMOD_LR_RLOW;
                 iismod |= S3C2412_IISMOD_SDF_IIS;
                 break;
         default:
@@ -337,14 +339,17 @@ static int s3c2412_i2s_hw_params(struct snd_pcm_substream *substream,
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
         struct snd_soc_dai_link *dai = rtd->dai;
         struct s3c_i2sv2_info *i2s = to_info(dai->cpu_dai);
+        struct s3c_dma_params *dma_data;
         u32 iismod;
 
         pr_debug("Entered %s\n", __func__);
 
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
-                dai->cpu_dai->dma_data = i2s->dma_playback;
+                dma_data = i2s->dma_playback;
         else
-                dai->cpu_dai->dma_data = i2s->dma_capture;
+                dma_data = i2s->dma_capture;
+
+        snd_soc_dai_set_dma_data(dai->cpu_dai, substream, dma_data);
 
         /* Working copies of register */
         iismod = readl(i2s->regs + S3C2412_IISMOD);
@@ -392,8 +397,8 @@ static int s3c2412_i2s_trigger(struct snd_pcm_substream *substream, int cmd,
         int capture = (substream->stream == SNDRV_PCM_STREAM_CAPTURE);
         unsigned long irqs;
         int ret = 0;
-        int channel = ((struct s3c24xx_pcm_dma_params *)
-                  rtd->dai->cpu_dai->dma_data)->channel;
+        struct s3c_dma_params *dma_data =
+                snd_soc_dai_get_dma_data(rtd->dai->cpu_dai, substream);
 
         pr_debug("Entered %s\n", __func__);
 
@@ -429,7 +434,7 @@ static int s3c2412_i2s_trigger(struct snd_pcm_substream *substream, int cmd,
                  * of the auto reload mechanism of S3C24XX.
                  * This call won't bother S3C64XX.
                  */
-                s3c2410_dma_ctrl(channel, S3C2410_DMAOP_STARTED);
+                s3c2410_dma_ctrl(dma_data->channel, S3C2410_DMAOP_STARTED);
 
                 break;
 
@@ -467,6 +472,31 @@ static int s3c2412_i2s_set_clkdiv(struct snd_soc_dai *cpu_dai,
 
         switch (div_id) {
         case S3C_I2SV2_DIV_BCLK:
+                if (div > 3) {
+                        /* convert value to bit field */
+
+                        switch (div) {
+                        case 16:
+                                div = S3C2412_IISMOD_BCLK_16FS;
+                                break;
+
+                        case 32:
+                                div = S3C2412_IISMOD_BCLK_32FS;
+                                break;
+
+                        case 24:
+                                div = S3C2412_IISMOD_BCLK_24FS;
+                                break;
+
+                        case 48:
+                                div = S3C2412_IISMOD_BCLK_48FS;
+                                break;
+
+                        default:
+                                return -EINVAL;
+                        }
+                }
+
                 reg = readl(i2s->regs + S3C2412_IISMOD);
                 reg &= ~S3C2412_IISMOD_BCLK_MASK;
                 writel(reg | div, i2s->regs + S3C2412_IISMOD);
@@ -626,7 +656,7 @@ int s3c_i2sv2_probe(struct platform_device *pdev,
         }
 
         i2s->iis_pclk = clk_get(dev, "iis");
-        if (i2s->iis_pclk == NULL) {
+        if (IS_ERR(i2s->iis_pclk)) {
                 dev_err(dev, "failed to get iis_clock\n");
                 iounmap(i2s->regs);
                 return -ENOENT;
diff --git a/sound/soc/s3c24xx/s3c-i2s-v2.h b/sound/soc/s3c24xx/s3c-i2s-v2.h
index f66854a77fb2..ecf8eaaed1db 100644
--- a/sound/soc/s3c24xx/s3c-i2s-v2.h
+++ b/sound/soc/s3c24xx/s3c-i2s-v2.h
@@ -49,8 +49,8 @@ struct s3c_i2sv2_info {
 
         unsigned char    master;
 
-        struct s3c24xx_pcm_dma_params   *dma_playback;
-        struct s3c24xx_pcm_dma_params   *dma_capture;
+        struct s3c_dma_params   *dma_playback;
+        struct s3c_dma_params   *dma_capture;
 
         u32              suspend_iismod;
         u32              suspend_iiscon;
diff --git a/sound/soc/s3c24xx/s3c-pcm.c b/sound/soc/s3c24xx/s3c-pcm.c
new file mode 100644
index 000000000000..326f0a9e7e30
--- /dev/null
+++ b/sound/soc/s3c24xx/s3c-pcm.c
@@ -0,0 +1,554 @@
+/* sound/soc/s3c24xx/s3c-pcm.c
+ *
+ * ALSA SoC Audio Layer - S3C PCM-Controller driver
+ *
+ * Copyright (c) 2009 Samsung Electronics Co. Ltd
+ * Author: Jaswinder Singh <jassi.brar@samsung.com>
+ * based upon I2S drivers by Ben Dooks.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/device.h>
+#include <linux/delay.h>
+#include <linux/clk.h>
+#include <linux/kernel.h>
+#include <linux/gpio.h>
+#include <linux/io.h>
+
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/initval.h>
+#include <sound/soc.h>
+
+#include <plat/audio.h>
+#include <plat/dma.h>
+
+#include "s3c-dma.h"
+#include "s3c-pcm.h"
+
+static struct s3c2410_dma_client s3c_pcm_dma_client_out = {
+        .name           = "PCM Stereo out"
+};
+
+static struct s3c2410_dma_client s3c_pcm_dma_client_in = {
+        .name           = "PCM Stereo in"
+};
+
+static struct s3c_dma_params s3c_pcm_stereo_out[] = {
+        [0] = {
+                .client         = &s3c_pcm_dma_client_out,
+                .dma_size       = 4,
+        },
+        [1] = {
+                .client         = &s3c_pcm_dma_client_out,
+                .dma_size       = 4,
+        },
+};
+
+static struct s3c_dma_params s3c_pcm_stereo_in[] = {
+        [0] = {
+                .client         = &s3c_pcm_dma_client_in,
+                .dma_size       = 4,
+        },
+        [1] = {
+                .client         = &s3c_pcm_dma_client_in,
+                .dma_size       = 4,
+        },
+};
+
+static struct s3c_pcm_info s3c_pcm[2];
+
+static inline struct s3c_pcm_info *to_info(struct snd_soc_dai *cpu_dai)
+{
+        return cpu_dai->private_data;
+}
+
+static void s3c_pcm_snd_txctrl(struct s3c_pcm_info *pcm, int on)
+{
+        void __iomem *regs = pcm->regs;
+        u32 ctl, clkctl;
+
+        clkctl = readl(regs + S3C_PCM_CLKCTL);
+        ctl = readl(regs + S3C_PCM_CTL);
+        ctl &= ~(S3C_PCM_CTL_TXDIPSTICK_MASK
+                         << S3C_PCM_CTL_TXDIPSTICK_SHIFT);
+
+        if (on) {
+                ctl |= S3C_PCM_CTL_TXDMA_EN;
+                ctl |= S3C_PCM_CTL_TXFIFO_EN;
+                ctl |= S3C_PCM_CTL_ENABLE;
+                ctl |= (0x20<<S3C_PCM_CTL_TXDIPSTICK_SHIFT);
+                clkctl |= S3C_PCM_CLKCTL_SERCLK_EN;
+        } else {
+                ctl &= ~S3C_PCM_CTL_TXDMA_EN;
+                ctl &= ~S3C_PCM_CTL_TXFIFO_EN;
+
+                if (!(ctl & S3C_PCM_CTL_RXFIFO_EN)) {
+                        ctl &= ~S3C_PCM_CTL_ENABLE;
+                        if (!pcm->idleclk)
+                                clkctl |= S3C_PCM_CLKCTL_SERCLK_EN;
+                }
+        }
+
+        writel(clkctl, regs + S3C_PCM_CLKCTL);
+        writel(ctl, regs + S3C_PCM_CTL);
+}
+
+static void s3c_pcm_snd_rxctrl(struct s3c_pcm_info *pcm, int on)
+{
+        void __iomem *regs = pcm->regs;
+        u32 ctl, clkctl;
+
+        ctl = readl(regs + S3C_PCM_CTL);
+        clkctl = readl(regs + S3C_PCM_CLKCTL);
+
+        if (on) {
+                ctl |= S3C_PCM_CTL_RXDMA_EN;
+                ctl |= S3C_PCM_CTL_RXFIFO_EN;
+                ctl |= S3C_PCM_CTL_ENABLE;
+                clkctl |= S3C_PCM_CLKCTL_SERCLK_EN;
+        } else {
+                ctl &= ~S3C_PCM_CTL_RXDMA_EN;
+                ctl &= ~S3C_PCM_CTL_RXFIFO_EN;
+
+                if (!(ctl & S3C_PCM_CTL_TXFIFO_EN)) {
+                        ctl &= ~S3C_PCM_CTL_ENABLE;
+                        if (!pcm->idleclk)
+                                clkctl |= S3C_PCM_CLKCTL_SERCLK_EN;
+                }
+        }
+
+        writel(clkctl, regs + S3C_PCM_CLKCTL);
+        writel(ctl, regs + S3C_PCM_CTL);
+}
+
+static int s3c_pcm_trigger(struct snd_pcm_substream *substream, int cmd,
+                               struct snd_soc_dai *dai)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct s3c_pcm_info *pcm = to_info(rtd->dai->cpu_dai);
+        unsigned long flags;
+
+        dev_dbg(pcm->dev, "Entered %s\n", __func__);
+
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+        case SNDRV_PCM_TRIGGER_RESUME:
+        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
+                spin_lock_irqsave(&pcm->lock, flags);
+
+                if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
+                        s3c_pcm_snd_rxctrl(pcm, 1);
+                else
+                        s3c_pcm_snd_txctrl(pcm, 1);
+
+                spin_unlock_irqrestore(&pcm->lock, flags);
+                break;
+
+        case SNDRV_PCM_TRIGGER_STOP:
+        case SNDRV_PCM_TRIGGER_SUSPEND:
+        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
+                spin_lock_irqsave(&pcm->lock, flags);
+
+                if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
+                        s3c_pcm_snd_rxctrl(pcm, 0);
+                else
+                        s3c_pcm_snd_txctrl(pcm, 0);
+
+                spin_unlock_irqrestore(&pcm->lock, flags);
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int s3c_pcm_hw_params(struct snd_pcm_substream *substream,
+                                 struct snd_pcm_hw_params *params,
+                                 struct snd_soc_dai *socdai)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_dai_link *dai = rtd->dai;
+        struct s3c_pcm_info *pcm = to_info(dai->cpu_dai);
+        struct s3c_dma_params *dma_data;
+        void __iomem *regs = pcm->regs;
+        struct clk *clk;
+        int sclk_div, sync_div;
+        unsigned long flags;
+        u32 clkctl;
+
+        dev_dbg(pcm->dev, "Entered %s\n", __func__);
+
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+                dma_data = pcm->dma_playback;
+        else
+                dma_data = pcm->dma_capture;
+
+        snd_soc_dai_set_dma_data(dai->cpu_dai, substream, dma_data);
+
+        /* Strictly check for sample size */
+        switch (params_format(params)) {
+        case SNDRV_PCM_FORMAT_S16_LE:
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        spin_lock_irqsave(&pcm->lock, flags);
+
+        /* Get hold of the PCMSOURCE_CLK */
+        clkctl = readl(regs + S3C_PCM_CLKCTL);
+        if (clkctl & S3C_PCM_CLKCTL_SERCLKSEL_PCLK)
+                clk = pcm->pclk;
+        else
+                clk = pcm->cclk;
+
+        /* Set the SCLK divider */
+        sclk_div = clk_get_rate(clk) / pcm->sclk_per_fs /
+                                        params_rate(params) / 2 - 1;
+
+        clkctl &= ~(S3C_PCM_CLKCTL_SCLKDIV_MASK
+                        << S3C_PCM_CLKCTL_SCLKDIV_SHIFT);
+        clkctl |= ((sclk_div & S3C_PCM_CLKCTL_SCLKDIV_MASK)
+                        << S3C_PCM_CLKCTL_SCLKDIV_SHIFT);
+
+        /* Set the SYNC divider */
+        sync_div = pcm->sclk_per_fs - 1;
+
+        clkctl &= ~(S3C_PCM_CLKCTL_SYNCDIV_MASK
+                                << S3C_PCM_CLKCTL_SYNCDIV_SHIFT);
+        clkctl |= ((sync_div & S3C_PCM_CLKCTL_SYNCDIV_MASK)
+                                << S3C_PCM_CLKCTL_SYNCDIV_SHIFT);
+
+        writel(clkctl, regs + S3C_PCM_CLKCTL);
+
+        spin_unlock_irqrestore(&pcm->lock, flags);
+
+        dev_dbg(pcm->dev, "PCMSOURCE_CLK-%lu SCLK=%ufs SCLK_DIV=%d SYNC_DIV=%d\n",
+                                clk_get_rate(clk), pcm->sclk_per_fs,
+                                sclk_div, sync_div);
+
+        return 0;
+}
+
+static int s3c_pcm_set_fmt(struct snd_soc_dai *cpu_dai,
+                               unsigned int fmt)
+{
+        struct s3c_pcm_info *pcm = to_info(cpu_dai);
+        void __iomem *regs = pcm->regs;
+        unsigned long flags;
+        int ret = 0;
+        u32 ctl;
+
+        dev_dbg(pcm->dev, "Entered %s\n", __func__);
+
+        spin_lock_irqsave(&pcm->lock, flags);
+
+        ctl = readl(regs + S3C_PCM_CTL);
+
+        switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
+        case SND_SOC_DAIFMT_NB_NF:
+                /* Nothing to do, NB_NF by default */
+                break;
+        default:
+                dev_err(pcm->dev, "Unsupported clock inversion!\n");
+                ret = -EINVAL;
+                goto exit;
+        }
+
+        switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
+        case SND_SOC_DAIFMT_CBS_CFS:
+                /* Nothing to do, Master by default */
+                break;
+        default:
+                dev_err(pcm->dev, "Unsupported master/slave format!\n");
+                ret = -EINVAL;
+                goto exit;
+        }
+
+        switch (fmt & SND_SOC_DAIFMT_CLOCK_MASK) {
+        case SND_SOC_DAIFMT_CONT:
+                pcm->idleclk = 1;
+                break;
+        case SND_SOC_DAIFMT_GATED:
+                pcm->idleclk = 0;
+                break;
+        default:
+                dev_err(pcm->dev, "Invalid Clock gating request!\n");
+                ret = -EINVAL;
+                goto exit;
+        }
+
+        switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
+        case SND_SOC_DAIFMT_DSP_A:
+                ctl |= S3C_PCM_CTL_TXMSB_AFTER_FSYNC;
+                ctl |= S3C_PCM_CTL_RXMSB_AFTER_FSYNC;
+                break;
+        case SND_SOC_DAIFMT_DSP_B:
+                ctl &= ~S3C_PCM_CTL_TXMSB_AFTER_FSYNC;
+                ctl &= ~S3C_PCM_CTL_RXMSB_AFTER_FSYNC;
+                break;
+        default:
+                dev_err(pcm->dev, "Unsupported data format!\n");
+                ret = -EINVAL;
+                goto exit;
+        }
+
+        writel(ctl, regs + S3C_PCM_CTL);
+
+exit:
+        spin_unlock_irqrestore(&pcm->lock, flags);
+
+        return ret;
+}
+
+static int s3c_pcm_set_clkdiv(struct snd_soc_dai *cpu_dai,
+                                                int div_id, int div)
+{
+        struct s3c_pcm_info *pcm = to_info(cpu_dai);
+
+        switch (div_id) {
+        case S3C_PCM_SCLK_PER_FS:
+                pcm->sclk_per_fs = div;
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int s3c_pcm_set_sysclk(struct snd_soc_dai *cpu_dai,
+                                  int clk_id, unsigned int freq, int dir)
+{
+        struct s3c_pcm_info *pcm = to_info(cpu_dai);
+        void __iomem *regs = pcm->regs;
+        u32 clkctl = readl(regs + S3C_PCM_CLKCTL);
+
+        switch (clk_id) {
+        case S3C_PCM_CLKSRC_PCLK:
+                clkctl |= S3C_PCM_CLKCTL_SERCLKSEL_PCLK;
+                break;
+
+        case S3C_PCM_CLKSRC_MUX:
+                clkctl &= ~S3C_PCM_CLKCTL_SERCLKSEL_PCLK;
+
+                if (clk_get_rate(pcm->cclk) != freq)
+                        clk_set_rate(pcm->cclk, freq);
+
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        writel(clkctl, regs + S3C_PCM_CLKCTL);
+
+        return 0;
+}
+
+static struct snd_soc_dai_ops s3c_pcm_dai_ops = {
+        .set_sysclk     = s3c_pcm_set_sysclk,
+        .set_clkdiv     = s3c_pcm_set_clkdiv,
+        .trigger        = s3c_pcm_trigger,
+        .hw_params      = s3c_pcm_hw_params,
+        .set_fmt        = s3c_pcm_set_fmt,
+};
+
+#define S3C_PCM_RATES  SNDRV_PCM_RATE_8000_96000
+
+#define S3C_PCM_DECLARE(n)                      \
+{                                                               \
+        .name            = "samsung-pcm",                       \
+        .id              = (n),                         \
+        .symmetric_rates = 1,                                   \
+        .ops = &s3c_pcm_dai_ops,                                \
+        .playback = {                                           \
+                .channels_min   = 2,                            \
+                .channels_max   = 2,                            \
+                .rates          = S3C_PCM_RATES,                \
+                .formats        = SNDRV_PCM_FMTBIT_S16_LE,      \
+        },                                                      \
+        .capture = {                                            \
+                .channels_min   = 2,                            \
+                .channels_max   = 2,                            \
+                .rates          = S3C_PCM_RATES,                \
+                .formats        = SNDRV_PCM_FMTBIT_S16_LE,      \
+        },                                                      \
+}
+
+struct snd_soc_dai s3c_pcm_dai[] = {
+        S3C_PCM_DECLARE(0),
+        S3C_PCM_DECLARE(1),
+};
+EXPORT_SYMBOL_GPL(s3c_pcm_dai);
+
+static __devinit int s3c_pcm_dev_probe(struct platform_device *pdev)
+{
+        struct s3c_pcm_info *pcm;
+        struct snd_soc_dai *dai;
+        struct resource *mem_res, *dmatx_res, *dmarx_res;
+        struct s3c_audio_pdata *pcm_pdata;
+        int ret;
+
+        /* Check for valid device index */
+        if ((pdev->id < 0) || pdev->id >= ARRAY_SIZE(s3c_pcm)) {
+                dev_err(&pdev->dev, "id %d out of range\n", pdev->id);
+                return -EINVAL;
+        }
+
+        pcm_pdata = pdev->dev.platform_data;
+
+        /* Check for availability of necessary resource */
+        dmatx_res = platform_get_resource(pdev, IORESOURCE_DMA, 0);
+        if (!dmatx_res) {
+                dev_err(&pdev->dev, "Unable to get PCM-TX dma resource\n");
+                return -ENXIO;
+        }
+
+        dmarx_res = platform_get_resource(pdev, IORESOURCE_DMA, 1);
+        if (!dmarx_res) {
+                dev_err(&pdev->dev, "Unable to get PCM-RX dma resource\n");
+                return -ENXIO;
+        }
+
+        mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!mem_res) {
+                dev_err(&pdev->dev, "Unable to get register resource\n");
+                return -ENXIO;
+        }
+
+        if (pcm_pdata && pcm_pdata->cfg_gpio && pcm_pdata->cfg_gpio(pdev)) {
+                dev_err(&pdev->dev, "Unable to configure gpio\n");
+                return -EINVAL;
+        }
+
+        pcm = &s3c_pcm[pdev->id];
+        pcm->dev = &pdev->dev;
+
+        spin_lock_init(&pcm->lock);
+
+        dai = &s3c_pcm_dai[pdev->id];
+        dai->dev = &pdev->dev;
+
+        /* Default is 128fs */
+        pcm->sclk_per_fs = 128;
+
+        pcm->cclk = clk_get(&pdev->dev, "audio-bus");
+        if (IS_ERR(pcm->cclk)) {
+                dev_err(&pdev->dev, "failed to get audio-bus\n");
+                ret = PTR_ERR(pcm->cclk);
+                goto err1;
+        }
+        clk_enable(pcm->cclk);
+
+        /* record our pcm structure for later use in the callbacks */
+        dai->private_data = pcm;
+
+        if (!request_mem_region(mem_res->start,
+                                resource_size(mem_res), "samsung-pcm")) {
+                dev_err(&pdev->dev, "Unable to request register region\n");
+                ret = -EBUSY;
+                goto err2;
+        }
+
+        pcm->regs = ioremap(mem_res->start, 0x100);
+        if (pcm->regs == NULL) {
+                dev_err(&pdev->dev, "cannot ioremap registers\n");
+                ret = -ENXIO;
+                goto err3;
+        }
+
+        pcm->pclk = clk_get(&pdev->dev, "pcm");
+        if (IS_ERR(pcm->pclk)) {
+                dev_err(&pdev->dev, "failed to get pcm_clock\n");
+                ret = -ENOENT;
+                goto err4;
+        }
+        clk_enable(pcm->pclk);
+
+        ret = snd_soc_register_dai(dai);
+        if (ret != 0) {
+                dev_err(&pdev->dev, "failed to get pcm_clock\n");
+                goto err5;
+        }
+
+        s3c_pcm_stereo_in[pdev->id].dma_addr = mem_res->start
+                                                        + S3C_PCM_RXFIFO;
+        s3c_pcm_stereo_out[pdev->id].dma_addr = mem_res->start
+                                                        + S3C_PCM_TXFIFO;
+
+        s3c_pcm_stereo_in[pdev->id].channel = dmarx_res->start;
+        s3c_pcm_stereo_out[pdev->id].channel = dmatx_res->start;
+
+        pcm->dma_capture = &s3c_pcm_stereo_in[pdev->id];
+        pcm->dma_playback = &s3c_pcm_stereo_out[pdev->id];
+
+        return 0;
+
+err5:
+        clk_disable(pcm->pclk);
+        clk_put(pcm->pclk);
+err4:
+        iounmap(pcm->regs);
+err3:
+        release_mem_region(mem_res->start, resource_size(mem_res));
+err2:
+        clk_disable(pcm->cclk);
+        clk_put(pcm->cclk);
+err1:
+        return ret;
+}
+
+static __devexit int s3c_pcm_dev_remove(struct platform_device *pdev)
+{
+        struct s3c_pcm_info *pcm = &s3c_pcm[pdev->id];
+        struct resource *mem_res;
+
+        iounmap(pcm->regs);
+
+        mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        release_mem_region(mem_res->start, resource_size(mem_res));
+
+        clk_disable(pcm->cclk);
+        clk_disable(pcm->pclk);
+        clk_put(pcm->pclk);
+        clk_put(pcm->cclk);
+
+        return 0;
+}
+
+static struct platform_driver s3c_pcm_driver = {
+        .probe  = s3c_pcm_dev_probe,
+        .remove = s3c_pcm_dev_remove,
+        .driver = {
+                .name = "samsung-pcm",
+                .owner = THIS_MODULE,
+        },
+};
+
+static int __init s3c_pcm_init(void)
+{
+        return platform_driver_register(&s3c_pcm_driver);
+}
+module_init(s3c_pcm_init);
+
+static void __exit s3c_pcm_exit(void)
+{
+        platform_driver_unregister(&s3c_pcm_driver);
+}
+module_exit(s3c_pcm_exit);
+
+/* Module information */
+MODULE_AUTHOR("Jaswinder Singh, <jassi.brar@samsung.com>");
+MODULE_DESCRIPTION("S3C PCM Controller Driver");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/s3c24xx/s3c-pcm.h b/sound/soc/s3c24xx/s3c-pcm.h
new file mode 100644
index 000000000000..69ff9971692f
--- /dev/null
+++ b/sound/soc/s3c24xx/s3c-pcm.h
@@ -0,0 +1,123 @@
+/*  sound/soc/s3c24xx/s3c-pcm.h
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ */
+
+#ifndef __S3C_PCM_H
+#define __S3C_PCM_H __FILE__
+
+/*Register Offsets */
+#define S3C_PCM_CTL     (0x00)
+#define S3C_PCM_CLKCTL  (0x04)
+#define S3C_PCM_TXFIFO  (0x08)
+#define S3C_PCM_RXFIFO  (0x0C)
+#define S3C_PCM_IRQCTL  (0x10)
+#define S3C_PCM_IRQSTAT (0x14)
+#define S3C_PCM_FIFOSTAT        (0x18)
+#define S3C_PCM_CLRINT  (0x20)
+
+/* PCM_CTL Bit-Fields */
+#define S3C_PCM_CTL_TXDIPSTICK_MASK             (0x3f)
+#define S3C_PCM_CTL_TXDIPSTICK_SHIFT    (13)
+#define S3C_PCM_CTL_RXDIPSTICK_MSK              (0x3f<<7)
+#define S3C_PCM_CTL_TXDMA_EN            (0x1<<6)
+#define S3C_PCM_CTL_RXDMA_EN            (0x1<<5)
+#define S3C_PCM_CTL_TXMSB_AFTER_FSYNC   (0x1<<4)
+#define S3C_PCM_CTL_RXMSB_AFTER_FSYNC   (0x1<<3)
+#define S3C_PCM_CTL_TXFIFO_EN           (0x1<<2)
+#define S3C_PCM_CTL_RXFIFO_EN           (0x1<<1)
+#define S3C_PCM_CTL_ENABLE                      (0x1<<0)
+
+/* PCM_CLKCTL Bit-Fields */
+#define S3C_PCM_CLKCTL_SERCLK_EN                (0x1<<19)
+#define S3C_PCM_CLKCTL_SERCLKSEL_PCLK   (0x1<<18)
+#define S3C_PCM_CLKCTL_SCLKDIV_MASK             (0x1ff)
+#define S3C_PCM_CLKCTL_SYNCDIV_MASK             (0x1ff)
+#define S3C_PCM_CLKCTL_SCLKDIV_SHIFT    (9)
+#define S3C_PCM_CLKCTL_SYNCDIV_SHIFT    (0)
+
+/* PCM_TXFIFO Bit-Fields */
+#define S3C_PCM_TXFIFO_DVALID   (0x1<<16)
+#define S3C_PCM_TXFIFO_DATA_MSK (0xffff<<0)
+
+/* PCM_RXFIFO Bit-Fields */
+#define S3C_PCM_RXFIFO_DVALID   (0x1<<16)
+#define S3C_PCM_RXFIFO_DATA_MSK (0xffff<<0)
+
+/* PCM_IRQCTL Bit-Fields */
+#define S3C_PCM_IRQCTL_IRQEN            (0x1<<14)
+#define S3C_PCM_IRQCTL_WRDEN            (0x1<<12)
+#define S3C_PCM_IRQCTL_TXEMPTYEN                (0x1<<11)
+#define S3C_PCM_IRQCTL_TXALMSTEMPTYEN   (0x1<<10)
+#define S3C_PCM_IRQCTL_TXFULLEN         (0x1<<9)
+#define S3C_PCM_IRQCTL_TXALMSTFULLEN    (0x1<<8)
+#define S3C_PCM_IRQCTL_TXSTARVEN                (0x1<<7)
+#define S3C_PCM_IRQCTL_TXERROVRFLEN             (0x1<<6)
+#define S3C_PCM_IRQCTL_RXEMPTEN         (0x1<<5)
+#define S3C_PCM_IRQCTL_RXALMSTEMPTEN    (0x1<<4)
+#define S3C_PCM_IRQCTL_RXFULLEN         (0x1<<3)
+#define S3C_PCM_IRQCTL_RXALMSTFULLEN    (0x1<<2)
+#define S3C_PCM_IRQCTL_RXSTARVEN                (0x1<<1)
+#define S3C_PCM_IRQCTL_RXERROVRFLEN             (0x1<<0)
+
+/* PCM_IRQSTAT Bit-Fields */
+#define S3C_PCM_IRQSTAT_IRQPND          (0x1<<13)
+#define S3C_PCM_IRQSTAT_WRD_XFER                (0x1<<12)
+#define S3C_PCM_IRQSTAT_TXEMPTY         (0x1<<11)
+#define S3C_PCM_IRQSTAT_TXALMSTEMPTY    (0x1<<10)
+#define S3C_PCM_IRQSTAT_TXFULL          (0x1<<9)
+#define S3C_PCM_IRQSTAT_TXALMSTFULL             (0x1<<8)
+#define S3C_PCM_IRQSTAT_TXSTARV         (0x1<<7)
+#define S3C_PCM_IRQSTAT_TXERROVRFL              (0x1<<6)
+#define S3C_PCM_IRQSTAT_RXEMPT          (0x1<<5)
+#define S3C_PCM_IRQSTAT_RXALMSTEMPT             (0x1<<4)
+#define S3C_PCM_IRQSTAT_RXFULL          (0x1<<3)
+#define S3C_PCM_IRQSTAT_RXALMSTFULL             (0x1<<2)
+#define S3C_PCM_IRQSTAT_RXSTARV         (0x1<<1)
+#define S3C_PCM_IRQSTAT_RXERROVRFL              (0x1<<0)
+
+/* PCM_FIFOSTAT Bit-Fields */
+#define S3C_PCM_FIFOSTAT_TXCNT_MSK              (0x3f<<14)
+#define S3C_PCM_FIFOSTAT_TXFIFOEMPTY    (0x1<<13)
+#define S3C_PCM_FIFOSTAT_TXFIFOALMSTEMPTY       (0x1<<12)
+#define S3C_PCM_FIFOSTAT_TXFIFOFULL             (0x1<<11)
+#define S3C_PCM_FIFOSTAT_TXFIFOALMSTFULL        (0x1<<10)
+#define S3C_PCM_FIFOSTAT_RXCNT_MSK              (0x3f<<4)
+#define S3C_PCM_FIFOSTAT_RXFIFOEMPTY    (0x1<<3)
+#define S3C_PCM_FIFOSTAT_RXFIFOALMSTEMPTY       (0x1<<2)
+#define S3C_PCM_FIFOSTAT_RXFIFOFULL             (0x1<<1)
+#define S3C_PCM_FIFOSTAT_RXFIFOALMSTFULL        (0x1<<0)
+
+#define S3C_PCM_CLKSRC_PCLK     0
+#define S3C_PCM_CLKSRC_MUX      1
+
+#define S3C_PCM_SCLK_PER_FS     0
+
+/**
+ * struct s3c_pcm_info - S3C PCM Controller information
+ * @dev: The parent device passed to use from the probe.
+ * @regs: The pointer to the device register block.
+ * @dma_playback: DMA information for playback channel.
+ * @dma_capture: DMA information for capture channel.
+ */
+struct s3c_pcm_info {
+        spinlock_t lock;
+        struct device   *dev;
+        void __iomem    *regs;
+
+        unsigned int sclk_per_fs;
+
+        /* Whether to keep PCMSCLK enabled even when idle(no active xfer) */
+        unsigned int idleclk;
+
+        struct clk      *pclk;
+        struct clk      *cclk;
+
+        struct s3c_dma_params   *dma_playback;
+        struct s3c_dma_params   *dma_capture;
+};
+
+#endif /* __S3C_PCM_H */
diff --git a/sound/soc/s3c24xx/s3c2412-i2s.c b/sound/soc/s3c24xx/s3c2412-i2s.c
index a587ec40b449..359e59346ba2 100644
--- a/sound/soc/s3c24xx/s3c2412-i2s.c
+++ b/sound/soc/s3c24xx/s3c2412-i2s.c
@@ -34,11 +34,10 @@
 
 #include <plat/regs-s3c2412-iis.h>
 
-#include <plat/audio.h>
 #include <mach/regs-gpio.h>
 #include <mach/dma.h>
 
-#include "s3c24xx-pcm.h"
+#include "s3c-dma.h"
 #include "s3c2412-i2s.h"
 
 #define S3C2412_I2S_DEBUG 0
@@ -51,14 +50,14 @@ static struct s3c2410_dma_client s3c2412_dma_client_in = {
         .name           = "I2S PCM Stereo in"
 };
 
-static struct s3c24xx_pcm_dma_params s3c2412_i2s_pcm_stereo_out = {
+static struct s3c_dma_params s3c2412_i2s_pcm_stereo_out = {
         .client         = &s3c2412_dma_client_out,
         .channel        = DMACH_I2S_OUT,
         .dma_addr       = S3C2410_PA_IIS + S3C2412_IISTXD,
         .dma_size       = 4,
 };
 
-static struct s3c24xx_pcm_dma_params s3c2412_i2s_pcm_stereo_in = {
+static struct s3c_dma_params s3c2412_i2s_pcm_stereo_in = {
         .client         = &s3c2412_dma_client_in,
         .channel        = DMACH_I2S_IN,
         .dma_addr       = S3C2410_PA_IIS + S3C2412_IISRXD,
diff --git a/sound/soc/s3c24xx/s3c2443-ac97.c b/sound/soc/s3c24xx/s3c2443-ac97.c
deleted file mode 100644
index fc1beb0930b9..000000000000
--- a/sound/soc/s3c24xx/s3c2443-ac97.c
+++ /dev/null
@@ -1,433 +0,0 @@
-/*
- * s3c2443-ac97.c  --  ALSA Soc Audio Layer
- *
- * (c) 2007 Wolfson Microelectronics PLC.
- * Graeme Gregory graeme.gregory@wolfsonmicro.com or linux@wolfsonmicro.com
- *
- *  Copyright (C) 2005, Sean Choi <sh428.choi@samsung.com>
- *  All rights reserved.
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 2 as
- *  published by the Free Software Foundation.
- */
-
-#include <linux/init.h>
-#include <linux/module.h>
-#include <linux/platform_device.h>
-#include <linux/interrupt.h>
-#include <linux/io.h>
-#include <linux/wait.h>
-#include <linux/delay.h>
-#include <linux/gpio.h>
-#include <linux/clk.h>
-
-#include <sound/core.h>
-#include <sound/pcm.h>
-#include <sound/ac97_codec.h>
-#include <sound/initval.h>
-#include <sound/soc.h>
-
-#include <mach/hardware.h>
-#include <plat/regs-ac97.h>
-#include <mach/regs-gpio.h>
-#include <mach/regs-clock.h>
-#include <plat/audio.h>
-#include <asm/dma.h>
-#include <mach/dma.h>
-
-#include "s3c24xx-pcm.h"
-#include "s3c24xx-ac97.h"
-
-struct s3c24xx_ac97_info {
-        void __iomem    *regs;
-        struct clk      *ac97_clk;
-};
-static struct s3c24xx_ac97_info s3c24xx_ac97;
-
-static DECLARE_COMPLETION(ac97_completion);
-static u32 codec_ready;
-static DEFINE_MUTEX(ac97_mutex);
-
-static unsigned short s3c2443_ac97_read(struct snd_ac97 *ac97,
-        unsigned short reg)
-{
-        u32 ac_glbctrl;
-        u32 ac_codec_cmd;
-        u32 stat, addr, data;
-
-        mutex_lock(&ac97_mutex);
-
-        codec_ready = S3C_AC97_GLBSTAT_CODECREADY;
-        ac_codec_cmd = readl(s3c24xx_ac97.regs + S3C_AC97_CODEC_CMD);
-        ac_codec_cmd = S3C_AC97_CODEC_CMD_READ | AC_CMD_ADDR(reg);
-        writel(ac_codec_cmd, s3c24xx_ac97.regs + S3C_AC97_CODEC_CMD);
-
-        udelay(50);
-
-        ac_glbctrl = readl(s3c24xx_ac97.regs + S3C_AC97_GLBCTRL);
-        ac_glbctrl |= S3C_AC97_GLBCTRL_CODECREADYIE;
-        writel(ac_glbctrl, s3c24xx_ac97.regs + S3C_AC97_GLBCTRL);
-
-        wait_for_completion(&ac97_completion);
-
-        stat = readl(s3c24xx_ac97.regs + S3C_AC97_STAT);
-        addr = (stat >> 16) & 0x7f;
-        data = (stat & 0xffff);
-
-        if (addr != reg)
-                printk(KERN_ERR "s3c24xx-ac97: req addr = %02x,"
-                                " rep addr = %02x\n", reg, addr);
-
-        mutex_unlock(&ac97_mutex);
-
-        return (unsigned short)data;
-}
-
-static void s3c2443_ac97_write(struct snd_ac97 *ac97, unsigned short reg,
-        unsigned short val)
-{
-        u32 ac_glbctrl;
-        u32 ac_codec_cmd;
-
-        mutex_lock(&ac97_mutex);
-
-        codec_ready = S3C_AC97_GLBSTAT_CODECREADY;
-        ac_codec_cmd = readl(s3c24xx_ac97.regs + S3C_AC97_CODEC_CMD);
-        ac_codec_cmd = AC_CMD_ADDR(reg) | AC_CMD_DATA(val);
-        writel(ac_codec_cmd, s3c24xx_ac97.regs + S3C_AC97_CODEC_CMD);
-
-        udelay(50);
-
-        ac_glbctrl = readl(s3c24xx_ac97.regs + S3C_AC97_GLBCTRL);
-        ac_glbctrl |= S3C_AC97_GLBCTRL_CODECREADYIE;
-        writel(ac_glbctrl, s3c24xx_ac97.regs + S3C_AC97_GLBCTRL);
-
-        wait_for_completion(&ac97_completion);
-
-        ac_codec_cmd = readl(s3c24xx_ac97.regs + S3C_AC97_CODEC_CMD);
-        ac_codec_cmd |= S3C_AC97_CODEC_CMD_READ;
-        writel(ac_codec_cmd, s3c24xx_ac97.regs + S3C_AC97_CODEC_CMD);
-
-        mutex_unlock(&ac97_mutex);
-
-}
-
-static void s3c2443_ac97_warm_reset(struct snd_ac97 *ac97)
-{
-        u32 ac_glbctrl;
-
-        ac_glbctrl = readl(s3c24xx_ac97.regs + S3C_AC97_GLBCTRL);
-        ac_glbctrl = S3C_AC97_GLBCTRL_WARMRESET;
-        writel(ac_glbctrl, s3c24xx_ac97.regs + S3C_AC97_GLBCTRL);
-        msleep(1);
-
-        ac_glbctrl = 0;
-        writel(ac_glbctrl, s3c24xx_ac97.regs + S3C_AC97_GLBCTRL);
-        msleep(1);
-}
-
-static void s3c2443_ac97_cold_reset(struct snd_ac97 *ac97)
-{
-        u32 ac_glbctrl;
-
-        ac_glbctrl = readl(s3c24xx_ac97.regs + S3C_AC97_GLBCTRL);
-        ac_glbctrl = S3C_AC97_GLBCTRL_COLDRESET;
-        writel(ac_glbctrl, s3c24xx_ac97.regs + S3C_AC97_GLBCTRL);
-        msleep(1);
-
-        ac_glbctrl = 0;
-        writel(ac_glbctrl, s3c24xx_ac97.regs + S3C_AC97_GLBCTRL);
-        msleep(1);
-
-        ac_glbctrl = readl(s3c24xx_ac97.regs + S3C_AC97_GLBCTRL);
-        ac_glbctrl = S3C_AC97_GLBCTRL_ACLINKON;
-        writel(ac_glbctrl, s3c24xx_ac97.regs + S3C_AC97_GLBCTRL);
-        msleep(1);
-
-        ac_glbctrl |= S3C_AC97_GLBCTRL_TRANSFERDATAENABLE;
-        writel(ac_glbctrl, s3c24xx_ac97.regs + S3C_AC97_GLBCTRL);
-        msleep(1);
-
-        ac_glbctrl |= S3C_AC97_GLBCTRL_PCMOUTTM_DMA |
-                S3C_AC97_GLBCTRL_PCMINTM_DMA | S3C_AC97_GLBCTRL_MICINTM_DMA;
-        writel(ac_glbctrl, s3c24xx_ac97.regs + S3C_AC97_GLBCTRL);
-}
-
-static irqreturn_t s3c2443_ac97_irq(int irq, void *dev_id)
-{
-        int status;
-        u32 ac_glbctrl;
-
-        status = readl(s3c24xx_ac97.regs + S3C_AC97_GLBSTAT) & codec_ready;
-
-        if (status) {
-                ac_glbctrl = readl(s3c24xx_ac97.regs + S3C_AC97_GLBCTRL);
-                ac_glbctrl &= ~S3C_AC97_GLBCTRL_CODECREADYIE;
-                writel(ac_glbctrl, s3c24xx_ac97.regs + S3C_AC97_GLBCTRL);
-                complete(&ac97_completion);
-        }
-        return IRQ_HANDLED;
-}
-
-struct snd_ac97_bus_ops soc_ac97_ops = {
-        .read   = s3c2443_ac97_read,
-        .write  = s3c2443_ac97_write,
-        .warm_reset     = s3c2443_ac97_warm_reset,
-        .reset  = s3c2443_ac97_cold_reset,
-};
-
-static struct s3c2410_dma_client s3c2443_dma_client_out = {
-        .name = "AC97 PCM Stereo out"
-};
-
-static struct s3c2410_dma_client s3c2443_dma_client_in = {
-        .name = "AC97 PCM Stereo in"
-};
-
-static struct s3c2410_dma_client s3c2443_dma_client_micin = {
-        .name = "AC97 Mic Mono in"
-};
-
-static struct s3c24xx_pcm_dma_params s3c2443_ac97_pcm_stereo_out = {
-        .client         = &s3c2443_dma_client_out,
-        .channel        = DMACH_PCM_OUT,
-        .dma_addr       = S3C2440_PA_AC97 + S3C_AC97_PCM_DATA,
-        .dma_size       = 4,
-};
-
-static struct s3c24xx_pcm_dma_params s3c2443_ac97_pcm_stereo_in = {
-        .client         = &s3c2443_dma_client_in,
-        .channel        = DMACH_PCM_IN,
-        .dma_addr       = S3C2440_PA_AC97 + S3C_AC97_PCM_DATA,
-        .dma_size       = 4,
-};
-
-static struct s3c24xx_pcm_dma_params s3c2443_ac97_mic_mono_in = {
-        .client         = &s3c2443_dma_client_micin,
-        .channel        = DMACH_MIC_IN,
-        .dma_addr       = S3C2440_PA_AC97 + S3C_AC97_MIC_DATA,
-        .dma_size       = 4,
-};
-
-static int s3c2443_ac97_probe(struct platform_device *pdev,
-                              struct snd_soc_dai *dai)
-{
-        int ret;
-        u32 ac_glbctrl;
-
-        s3c24xx_ac97.regs = ioremap(S3C2440_PA_AC97, 0x100);
-        if (s3c24xx_ac97.regs == NULL)
-                return -ENXIO;
-
-        s3c24xx_ac97.ac97_clk = clk_get(&pdev->dev, "ac97");
-        if (s3c24xx_ac97.ac97_clk == NULL) {
-                printk(KERN_ERR "s3c2443-ac97 failed to get ac97_clock\n");
-                iounmap(s3c24xx_ac97.regs);
-                return -ENODEV;
-        }
-        clk_enable(s3c24xx_ac97.ac97_clk);
-
-        s3c2410_gpio_cfgpin(S3C2410_GPE0, S3C2443_GPE0_AC_nRESET);
-        s3c2410_gpio_cfgpin(S3C2410_GPE1, S3C2443_GPE1_AC_SYNC);
-        s3c2410_gpio_cfgpin(S3C2410_GPE2, S3C2443_GPE2_AC_BITCLK);
-        s3c2410_gpio_cfgpin(S3C2410_GPE3, S3C2443_GPE3_AC_SDI);
-        s3c2410_gpio_cfgpin(S3C2410_GPE4, S3C2443_GPE4_AC_SDO);
-
-        ac_glbctrl = readl(s3c24xx_ac97.regs + S3C_AC97_GLBCTRL);
-        ac_glbctrl = S3C_AC97_GLBCTRL_COLDRESET;
-        writel(ac_glbctrl, s3c24xx_ac97.regs + S3C_AC97_GLBCTRL);
-        msleep(1);
-
-        ac_glbctrl = 0;
-        writel(ac_glbctrl, s3c24xx_ac97.regs + S3C_AC97_GLBCTRL);
-        msleep(1);
-
-        ac_glbctrl = readl(s3c24xx_ac97.regs + S3C_AC97_GLBCTRL);
-        ac_glbctrl = S3C_AC97_GLBCTRL_ACLINKON;
-        writel(ac_glbctrl, s3c24xx_ac97.regs + S3C_AC97_GLBCTRL);
-        msleep(1);
-
-        ac_glbctrl |= S3C_AC97_GLBCTRL_TRANSFERDATAENABLE;
-        writel(ac_glbctrl, s3c24xx_ac97.regs + S3C_AC97_GLBCTRL);
-
-        ret = request_irq(IRQ_S3C244x_AC97, s3c2443_ac97_irq,
-                IRQF_DISABLED, "AC97", NULL);
-        if (ret < 0) {
-                printk(KERN_ERR "s3c24xx-ac97: interrupt request failed.\n");
-                clk_disable(s3c24xx_ac97.ac97_clk);
-                clk_put(s3c24xx_ac97.ac97_clk);
-                iounmap(s3c24xx_ac97.regs);
-        }
-        return ret;
-}
-
-static void s3c2443_ac97_remove(struct platform_device *pdev,
-                                struct snd_soc_dai *dai)
-{
-        free_irq(IRQ_S3C244x_AC97, NULL);
-        clk_disable(s3c24xx_ac97.ac97_clk);
-        clk_put(s3c24xx_ac97.ac97_clk);
-        iounmap(s3c24xx_ac97.regs);
-}
-
-static int s3c2443_ac97_hw_params(struct snd_pcm_substream *substream,
-                                  struct snd_pcm_hw_params *params,
-                                  struct snd_soc_dai *dai)
-{
-        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-        struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
-
-        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
-                cpu_dai->dma_data = &s3c2443_ac97_pcm_stereo_out;
-        else
-                cpu_dai->dma_data = &s3c2443_ac97_pcm_stereo_in;
-
-        return 0;
-}
-
-static int s3c2443_ac97_trigger(struct snd_pcm_substream *substream, int cmd,
-                                struct snd_soc_dai *dai)
-{
-        u32 ac_glbctrl;
-        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-        int channel = ((struct s3c24xx_pcm_dma_params *)
-                  rtd->dai->cpu_dai->dma_data)->channel;
-
-        ac_glbctrl = readl(s3c24xx_ac97.regs + S3C_AC97_GLBCTRL);
-        switch (cmd) {
-        case SNDRV_PCM_TRIGGER_START:
-        case SNDRV_PCM_TRIGGER_RESUME:
-        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
-                if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
-                        ac_glbctrl |= S3C_AC97_GLBCTRL_PCMINTM_DMA;
-                else
-                        ac_glbctrl |= S3C_AC97_GLBCTRL_PCMOUTTM_DMA;
-                break;
-        case SNDRV_PCM_TRIGGER_STOP:
-        case SNDRV_PCM_TRIGGER_SUSPEND:
-        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
-                if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
-                        ac_glbctrl &= ~S3C_AC97_GLBCTRL_PCMINTM_MASK;
-                else
-                        ac_glbctrl &= ~S3C_AC97_GLBCTRL_PCMOUTTM_MASK;
-                break;
-        }
-        writel(ac_glbctrl, s3c24xx_ac97.regs + S3C_AC97_GLBCTRL);
-
-        s3c2410_dma_ctrl(channel, S3C2410_DMAOP_STARTED);
-
-        return 0;
-}
-
-static int s3c2443_ac97_hw_mic_params(struct snd_pcm_substream *substream,
-                                      struct snd_pcm_hw_params *params,
-                                      struct snd_soc_dai *dai)
-{
-        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-        struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
-
-        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
-                return -ENODEV;
-        else
-                cpu_dai->dma_data = &s3c2443_ac97_mic_mono_in;
-
-        return 0;
-}
-
-static int s3c2443_ac97_mic_trigger(struct snd_pcm_substream *substream,
-                                    int cmd, struct snd_soc_dai *dai)
-{
-        u32 ac_glbctrl;
-        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-        int channel = ((struct s3c24xx_pcm_dma_params *)
-                  rtd->dai->cpu_dai->dma_data)->channel;
-
-        ac_glbctrl = readl(s3c24xx_ac97.regs + S3C_AC97_GLBCTRL);
-        switch (cmd) {
-        case SNDRV_PCM_TRIGGER_START:
-        case SNDRV_PCM_TRIGGER_RESUME:
-        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
-                ac_glbctrl |= S3C_AC97_GLBCTRL_PCMINTM_DMA;
-                break;
-        case SNDRV_PCM_TRIGGER_STOP:
-        case SNDRV_PCM_TRIGGER_SUSPEND:
-        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
-                ac_glbctrl &= ~S3C_AC97_GLBCTRL_PCMINTM_MASK;
-        }
-        writel(ac_glbctrl, s3c24xx_ac97.regs + S3C_AC97_GLBCTRL);
-
-        s3c2410_dma_ctrl(channel, S3C2410_DMAOP_STARTED);
-
-        return 0;
-}
-
-#define s3c2443_AC97_RATES (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_11025 |\
-                SNDRV_PCM_RATE_16000 | SNDRV_PCM_RATE_22050 | \
-                SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000)
-
-static struct snd_soc_dai_ops s3c2443_ac97_dai_ops = {
-        .hw_params      = s3c2443_ac97_hw_params,
-        .trigger        = s3c2443_ac97_trigger,
-};
-
-static struct snd_soc_dai_ops s3c2443_ac97_mic_dai_ops = {
-        .hw_params      = s3c2443_ac97_hw_mic_params,
-        .trigger        = s3c2443_ac97_mic_trigger,
-};
-
-struct snd_soc_dai s3c2443_ac97_dai[] = {
-{
-        .name = "s3c2443-ac97",
-        .id = 0,
-        .ac97_control = 1,
-        .probe = s3c2443_ac97_probe,
-        .remove = s3c2443_ac97_remove,
-        .playback = {
-                .stream_name = "AC97 Playback",
-                .channels_min = 2,
-                .channels_max = 2,
-                .rates = s3c2443_AC97_RATES,
-                .formats = SNDRV_PCM_FMTBIT_S16_LE,},
-        .capture = {
-                .stream_name = "AC97 Capture",
-                .channels_min = 2,
-                .channels_max = 2,
-                .rates = s3c2443_AC97_RATES,
-                .formats = SNDRV_PCM_FMTBIT_S16_LE,},
-        .ops = &s3c2443_ac97_dai_ops,
-},
-{
-        .name = "pxa2xx-ac97-mic",
-        .id = 1,
-        .ac97_control = 1,
-        .capture = {
-                .stream_name = "AC97 Mic Capture",
-                .channels_min = 1,
-                .channels_max = 1,
-                .rates = s3c2443_AC97_RATES,
-                .formats = SNDRV_PCM_FMTBIT_S16_LE,},
-        .ops = &s3c2443_ac97_mic_dai_ops,
-},
-};
-EXPORT_SYMBOL_GPL(s3c2443_ac97_dai);
-EXPORT_SYMBOL_GPL(soc_ac97_ops);
-
-static int __init s3c2443_ac97_init(void)
-{
-        return snd_soc_register_dais(s3c2443_ac97_dai,
-                                     ARRAY_SIZE(s3c2443_ac97_dai));
-}
-module_init(s3c2443_ac97_init);
-
-static void __exit s3c2443_ac97_exit(void)
-{
-        snd_soc_unregister_dais(s3c2443_ac97_dai,
-                                ARRAY_SIZE(s3c2443_ac97_dai));
-}
-module_exit(s3c2443_ac97_exit);
-
-
-MODULE_AUTHOR("Graeme Gregory");
-MODULE_DESCRIPTION("AC97 driver for the Samsung s3c2443 chip");
-MODULE_LICENSE("GPL");
diff --git a/sound/soc/s3c24xx/s3c24xx-ac97.h b/sound/soc/s3c24xx/s3c24xx-ac97.h
deleted file mode 100644
index e96f941a810b..000000000000
--- a/sound/soc/s3c24xx/s3c24xx-ac97.h
+++ /dev/null
@@ -1,25 +0,0 @@
-/*
- * s3c24xx-ac97.c  --  ALSA Soc Audio Layer
- *
- * (c) 2007 Wolfson Microelectronics PLC.
- * Author: Graeme Gregory
- *         graeme.gregory@wolfsonmicro.com or linux@wolfsonmicro.com
- *
- *  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 the
- *  Free Software Foundation;  either version 2 of the  License, or (at your
- *  option) any later version.
- *
- *  Revision history
- *    10th Nov 2006   Initial version.
- */
-
-#ifndef S3C24XXAC97_H_
-#define S3C24XXAC97_H_
-
-#define AC_CMD_ADDR(x) (x << 16)
-#define AC_CMD_DATA(x) (x & 0xffff)
-
-extern struct snd_soc_dai s3c2443_ac97_dai[];
-
-#endif /*S3C24XXAC97_H_*/
diff --git a/sound/soc/s3c24xx/s3c24xx-i2s.c b/sound/soc/s3c24xx/s3c24xx-i2s.c
index 40e2c4790f0d..c3ac890a3986 100644
--- a/sound/soc/s3c24xx/s3c24xx-i2s.c
+++ b/sound/soc/s3c24xx/s3c24xx-i2s.c
@@ -32,13 +32,13 @@
 #include <mach/hardware.h>
 #include <mach/regs-gpio.h>
 #include <mach/regs-clock.h>
-#include <plat/audio.h>
+
 #include <asm/dma.h>
 #include <mach/dma.h>
 
 #include <plat/regs-iis.h>
 
-#include "s3c24xx-pcm.h"
+#include "s3c-dma.h"
 #include "s3c24xx-i2s.h"
 
 static struct s3c2410_dma_client s3c24xx_dma_client_out = {
@@ -49,14 +49,14 @@ static struct s3c2410_dma_client s3c24xx_dma_client_in = {
         .name = "I2S PCM Stereo in"
 };
 
-static struct s3c24xx_pcm_dma_params s3c24xx_i2s_pcm_stereo_out = {
+static struct s3c_dma_params s3c24xx_i2s_pcm_stereo_out = {
         .client         = &s3c24xx_dma_client_out,
         .channel        = DMACH_I2S_OUT,
         .dma_addr       = S3C2410_PA_IIS + S3C2410_IISFIFO,
         .dma_size       = 2,
 };
 
-static struct s3c24xx_pcm_dma_params s3c24xx_i2s_pcm_stereo_in = {
+static struct s3c_dma_params s3c24xx_i2s_pcm_stereo_in = {
         .client         = &s3c24xx_dma_client_in,
         .channel        = DMACH_I2S_IN,
         .dma_addr       = S3C2410_PA_IIS + S3C2410_IISFIFO,
@@ -242,14 +242,17 @@ static int s3c24xx_i2s_hw_params(struct snd_pcm_substream *substream,
                                  struct snd_soc_dai *dai)
 {
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct s3c_dma_params *dma_data;
         u32 iismod;
 
         pr_debug("Entered %s\n", __func__);
 
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
-                rtd->dai->cpu_dai->dma_data = &s3c24xx_i2s_pcm_stereo_out;
+                dma_data = &s3c24xx_i2s_pcm_stereo_out;
         else
-                rtd->dai->cpu_dai->dma_data = &s3c24xx_i2s_pcm_stereo_in;
+                dma_data = &s3c24xx_i2s_pcm_stereo_in;
+
+        snd_soc_dai_set_dma_data(rtd->dai->cpu_dai, substream, dma_data);
 
         /* Working copies of register */
         iismod = readl(s3c24xx_i2s.regs + S3C2410_IISMOD);
@@ -258,13 +261,11 @@ static int s3c24xx_i2s_hw_params(struct snd_pcm_substream *substream,
         switch (params_format(params)) {
         case SNDRV_PCM_FORMAT_S8:
                 iismod &= ~S3C2410_IISMOD_16BIT;
-                ((struct s3c24xx_pcm_dma_params *)
-                  rtd->dai->cpu_dai->dma_data)->dma_size = 1;
+                dma_data->dma_size = 1;
                 break;
         case SNDRV_PCM_FORMAT_S16_LE:
                 iismod |= S3C2410_IISMOD_16BIT;
-                ((struct s3c24xx_pcm_dma_params *)
-                  rtd->dai->cpu_dai->dma_data)->dma_size = 2;
+                dma_data->dma_size = 2;
                 break;
         default:
                 return -EINVAL;
@@ -280,8 +281,8 @@ static int s3c24xx_i2s_trigger(struct snd_pcm_substream *substream, int cmd,
 {
         int ret = 0;
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
-        int channel = ((struct s3c24xx_pcm_dma_params *)
-                  rtd->dai->cpu_dai->dma_data)->channel;
+        struct s3c_dma_params *dma_data =
+                snd_soc_dai_get_dma_data(rtd->dai->cpu_dai, substream);
 
         pr_debug("Entered %s\n", __func__);
 
@@ -300,7 +301,7 @@ static int s3c24xx_i2s_trigger(struct snd_pcm_substream *substream, int cmd,
                 else
                         s3c24xx_snd_txctrl(1);
 
-                s3c2410_dma_ctrl(channel, S3C2410_DMAOP_STARTED);
+                s3c2410_dma_ctrl(dma_data->channel, S3C2410_DMAOP_STARTED);
                 break;
         case SNDRV_PCM_TRIGGER_STOP:
         case SNDRV_PCM_TRIGGER_SUSPEND:
diff --git a/sound/soc/s3c24xx/s3c24xx_simtec.c b/sound/soc/s3c24xx/s3c24xx_simtec.c
index 1966e0d5652d..4984754f3298 100644
--- a/sound/soc/s3c24xx/s3c24xx_simtec.c
+++ b/sound/soc/s3c24xx/s3c24xx_simtec.c
@@ -21,7 +21,7 @@
 
 #include <plat/audio-simtec.h>
 
-#include "s3c24xx-pcm.h"
+#include "s3c-dma.h"
 #include "s3c24xx-i2s.h"
 #include "s3c24xx_simtec.h"
 
@@ -270,7 +270,7 @@ static int attach_gpio_amp(struct device *dev,
                 gpio_direction_output(pd->amp_gain[1], 0);
         }
 
-        /* note, curently we assume GPA0 isn't valid amp */
+        /* note, currently we assume GPA0 isn't valid amp */
         if (pdata->amp_gpio > 0) {
                 ret = gpio_request(pd->amp_gpio, "gpio-amp");
                 if (ret) {
@@ -312,7 +312,7 @@ int simtec_audio_resume(struct device *dev)
         return 0;
 }
 
-struct dev_pm_ops simtec_audio_pmops = {
+const struct dev_pm_ops simtec_audio_pmops = {
         .resume = simtec_audio_resume,
 };
 EXPORT_SYMBOL_GPL(simtec_audio_pmops);
diff --git a/sound/soc/s3c24xx/s3c24xx_simtec.h b/sound/soc/s3c24xx/s3c24xx_simtec.h
index 2714203af161..e18faee30cce 100644
--- a/sound/soc/s3c24xx/s3c24xx_simtec.h
+++ b/sound/soc/s3c24xx/s3c24xx_simtec.h
@@ -15,7 +15,7 @@ extern int simtec_audio_core_probe(struct platform_device *pdev,
 extern int simtec_audio_remove(struct platform_device *pdev);
 
 #ifdef CONFIG_PM
-extern struct dev_pm_ops simtec_audio_pmops;
+extern const struct dev_pm_ops simtec_audio_pmops;
 #define simtec_audio_pm &simtec_audio_pmops
 #else
 #define simtec_audio_pm NULL
diff --git a/sound/soc/s3c24xx/s3c24xx_simtec_hermes.c b/sound/soc/s3c24xx/s3c24xx_simtec_hermes.c
index 8346bd96eaf5..bdf8951af8e3 100644
--- a/sound/soc/s3c24xx/s3c24xx_simtec_hermes.c
+++ b/sound/soc/s3c24xx/s3c24xx_simtec_hermes.c
@@ -18,7 +18,7 @@
 
 #include <plat/audio-simtec.h>
 
-#include "s3c24xx-pcm.h"
+#include "s3c-dma.h"
 #include "s3c24xx-i2s.h"
 #include "s3c24xx_simtec.h"
 
diff --git a/sound/soc/s3c24xx/s3c24xx_simtec_tlv320aic23.c b/sound/soc/s3c24xx/s3c24xx_simtec_tlv320aic23.c
index 25797e096175..185c0acb5ce6 100644
--- a/sound/soc/s3c24xx/s3c24xx_simtec_tlv320aic23.c
+++ b/sound/soc/s3c24xx/s3c24xx_simtec_tlv320aic23.c
@@ -18,7 +18,7 @@
 
 #include <plat/audio-simtec.h>
 
-#include "s3c24xx-pcm.h"
+#include "s3c-dma.h"
 #include "s3c24xx-i2s.h"
 #include "s3c24xx_simtec.h"
 
diff --git a/sound/soc/s3c24xx/s3c24xx_uda134x.c b/sound/soc/s3c24xx/s3c24xx_uda134x.c
index c215d32d6322..052d59659c29 100644
--- a/sound/soc/s3c24xx/s3c24xx_uda134x.c
+++ b/sound/soc/s3c24xx/s3c24xx_uda134x.c
@@ -24,7 +24,7 @@
 
 #include <plat/regs-iis.h>
 
-#include "s3c24xx-pcm.h"
+#include "s3c-dma.h"
 #include "s3c24xx-i2s.h"
 #include "../codecs/uda134x.h"
 
diff --git a/sound/soc/s3c24xx/s3c64xx-i2s.c b/sound/soc/s3c24xx/s3c64xx-i2s.c
index 105a77eeded0..a72c251401ac 100644
--- a/sound/soc/s3c24xx/s3c64xx-i2s.c
+++ b/sound/soc/s3c24xx/s3c64xx-i2s.c
@@ -15,30 +15,28 @@
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/device.h>
-#include <linux/delay.h>
 #include <linux/clk.h>
-#include <linux/kernel.h>
 #include <linux/gpio.h>
 #include <linux/io.h>
 
-#include <sound/core.h>
-#include <sound/pcm.h>
-#include <sound/pcm_params.h>
-#include <sound/initval.h>
 #include <sound/soc.h>
 
 #include <plat/regs-s3c2412-iis.h>
-#include <plat/gpio-bank-d.h>
-#include <plat/gpio-bank-e.h>
+#include <mach/gpio-bank-d.h>
+#include <mach/gpio-bank-e.h>
 #include <plat/gpio-cfg.h>
-#include <plat/audio.h>
 
 #include <mach/map.h>
 #include <mach/dma.h>
 
-#include "s3c24xx-pcm.h"
+#include "s3c-dma.h"
 #include "s3c64xx-i2s.h"
 
+/* The value should be set to maximum of the total number
+ * of I2Sv3 controllers that any supported SoC has.
+ */
+#define MAX_I2SV3       2
+
 static struct s3c2410_dma_client s3c64xx_dma_client_out = {
         .name           = "I2S PCM Stereo out"
 };
@@ -47,37 +45,12 @@ static struct s3c2410_dma_client s3c64xx_dma_client_in = {
         .name           = "I2S PCM Stereo in"
 };
 
-static struct s3c24xx_pcm_dma_params s3c64xx_i2s_pcm_stereo_out[2] = {
-        [0] = {
-                .channel        = DMACH_I2S0_OUT,
-                .client         = &s3c64xx_dma_client_out,
-                .dma_addr       = S3C64XX_PA_IIS0 + S3C2412_IISTXD,
-                .dma_size       = 4,
-        },
-        [1] = {
-                .channel        = DMACH_I2S1_OUT,
-                .client         = &s3c64xx_dma_client_out,
-                .dma_addr       = S3C64XX_PA_IIS1 + S3C2412_IISTXD,
-                .dma_size       = 4,
-        },
-};
+static struct s3c_dma_params s3c64xx_i2s_pcm_stereo_out[MAX_I2SV3];
+static struct s3c_dma_params s3c64xx_i2s_pcm_stereo_in[MAX_I2SV3];
+static struct s3c_i2sv2_info s3c64xx_i2s[MAX_I2SV3];
 
-static struct s3c24xx_pcm_dma_params s3c64xx_i2s_pcm_stereo_in[2] = {
-        [0] = {
-                .channel        = DMACH_I2S0_IN,
-                .client         = &s3c64xx_dma_client_in,
-                .dma_addr       = S3C64XX_PA_IIS0 + S3C2412_IISRXD,
-                .dma_size       = 4,
-        },
-        [1] = {
-                .channel        = DMACH_I2S1_IN,
-                .client         = &s3c64xx_dma_client_in,
-                .dma_addr       = S3C64XX_PA_IIS1 + S3C2412_IISRXD,
-                .dma_size       = 4,
-        },
-};
-
-static struct s3c_i2sv2_info s3c64xx_i2s[2];
+struct snd_soc_dai s3c64xx_i2s_dai[MAX_I2SV3];
+EXPORT_SYMBOL_GPL(s3c64xx_i2s_dai);
 
 static inline struct s3c_i2sv2_info *to_info(struct snd_soc_dai *cpu_dai)
 {
@@ -99,6 +72,19 @@ static int s3c64xx_i2s_set_sysclk(struct snd_soc_dai *cpu_dai,
                 iismod |= S3C64XX_IISMOD_IMS_SYSMUX;
                 break;
 
+        case S3C64XX_CLKSRC_CDCLK:
+                switch (dir) {
+                case SND_SOC_CLOCK_IN:
+                        iismod |= S3C64XX_IISMOD_CDCLKCON;
+                        break;
+                case SND_SOC_CLOCK_OUT:
+                        iismod &= ~S3C64XX_IISMOD_CDCLKCON;
+                        break;
+                default:
+                        return -EINVAL;
+                }
+                break;
+
         default:
                 return -EINVAL;
         }
@@ -111,8 +97,12 @@ static int s3c64xx_i2s_set_sysclk(struct snd_soc_dai *cpu_dai,
 struct clk *s3c64xx_i2s_get_clock(struct snd_soc_dai *dai)
 {
         struct s3c_i2sv2_info *i2s = to_info(dai);
+        u32 iismod = readl(i2s->regs + S3C2412_IISMOD);
 
-        return i2s->iis_cclk;
+        if (iismod & S3C64XX_IISMOD_IMS_SYSMUX)
+                return i2s->iis_cclk;
+        else
+                return i2s->iis_pclk;
 }
 EXPORT_SYMBOL_GPL(s3c64xx_i2s_get_clock);
 
@@ -153,55 +143,13 @@ static struct snd_soc_dai_ops s3c64xx_i2s_dai_ops = {
         .set_sysclk     = s3c64xx_i2s_set_sysclk,       
 };
 
-struct snd_soc_dai s3c64xx_i2s_dai[] = {
-        {
-                .name           = "s3c64xx-i2s",
-                .id             = 0,
-                .probe          = s3c64xx_i2s_probe,
-                .playback = {
-                        .channels_min   = 2,
-                        .channels_max   = 2,
-                        .rates          = S3C64XX_I2S_RATES,
-                        .formats        = S3C64XX_I2S_FMTS,
-                },
-                .capture = {
-                         .channels_min  = 2,
-                         .channels_max  = 2,
-                         .rates         = S3C64XX_I2S_RATES,
-                         .formats       = S3C64XX_I2S_FMTS,
-                 },
-                .ops = &s3c64xx_i2s_dai_ops,
-                .symmetric_rates = 1,
-        },
-        {
-                .name           = "s3c64xx-i2s",
-                .id             = 1,
-                .probe          = s3c64xx_i2s_probe,
-                .playback = {
-                        .channels_min   = 2,
-                        .channels_max   = 2,
-                        .rates          = S3C64XX_I2S_RATES,
-                        .formats        = S3C64XX_I2S_FMTS,
-                },
-                .capture = {
-                         .channels_min  = 2,
-                         .channels_max  = 2,
-                         .rates         = S3C64XX_I2S_RATES,
-                         .formats       = S3C64XX_I2S_FMTS,
-                 },
-                .ops = &s3c64xx_i2s_dai_ops,
-                .symmetric_rates = 1,
-        },
-};
-EXPORT_SYMBOL_GPL(s3c64xx_i2s_dai);
-
 static __devinit int s3c64xx_iis_dev_probe(struct platform_device *pdev)
 {
         struct s3c_i2sv2_info *i2s;
         struct snd_soc_dai *dai;
         int ret;
 
-        if (pdev->id >= ARRAY_SIZE(s3c64xx_i2s)) {
+        if (pdev->id >= MAX_I2SV3) {
                 dev_err(&pdev->dev, "id %d out of range\n", pdev->id);
                 return -EINVAL;
         }
@@ -209,10 +157,40 @@ static __devinit int s3c64xx_iis_dev_probe(struct platform_device *pdev)
         i2s = &s3c64xx_i2s[pdev->id];
         dai = &s3c64xx_i2s_dai[pdev->id];
         dai->dev = &pdev->dev;
+        dai->name = "s3c64xx-i2s";
+        dai->id = pdev->id;
+        dai->symmetric_rates = 1;
+        dai->playback.channels_min = 2;
+        dai->playback.channels_max = 2;
+        dai->playback.rates = S3C64XX_I2S_RATES;
+        dai->playback.formats = S3C64XX_I2S_FMTS;
+        dai->capture.channels_min = 2;
+        dai->capture.channels_max = 2;
+        dai->capture.rates = S3C64XX_I2S_RATES;
+        dai->capture.formats = S3C64XX_I2S_FMTS;
+        dai->probe = s3c64xx_i2s_probe;
+        dai->ops = &s3c64xx_i2s_dai_ops;
 
         i2s->dma_capture = &s3c64xx_i2s_pcm_stereo_in[pdev->id];
         i2s->dma_playback = &s3c64xx_i2s_pcm_stereo_out[pdev->id];
 
+        if (pdev->id == 0) {
+                i2s->dma_capture->channel = DMACH_I2S0_IN;
+                i2s->dma_capture->dma_addr = S3C64XX_PA_IIS0 + S3C2412_IISRXD;
+                i2s->dma_playback->channel = DMACH_I2S0_OUT;
+                i2s->dma_playback->dma_addr = S3C64XX_PA_IIS0 + S3C2412_IISTXD;
+        } else {
+                i2s->dma_capture->channel = DMACH_I2S1_IN;
+                i2s->dma_capture->dma_addr = S3C64XX_PA_IIS1 + S3C2412_IISRXD;
+                i2s->dma_playback->channel = DMACH_I2S1_OUT;
+                i2s->dma_playback->dma_addr = S3C64XX_PA_IIS1 + S3C2412_IISTXD;
+        }
+
+        i2s->dma_capture->client = &s3c64xx_dma_client_in;
+        i2s->dma_capture->dma_size = 4;
+        i2s->dma_playback->client = &s3c64xx_dma_client_out;
+        i2s->dma_playback->dma_size = 4;
+
         i2s->iis_cclk = clk_get(&pdev->dev, "audio-bus");
         if (IS_ERR(i2s->iis_cclk)) {
                 dev_err(&pdev->dev, "failed to get audio-bus\n");
diff --git a/sound/soc/s3c24xx/s3c64xx-i2s.h b/sound/soc/s3c24xx/s3c64xx-i2s.h
index 02148cee2613..abe7253b55fc 100644
--- a/sound/soc/s3c24xx/s3c64xx-i2s.h
+++ b/sound/soc/s3c24xx/s3c64xx-i2s.h
@@ -25,6 +25,7 @@ struct clk;
 
 #define S3C64XX_CLKSRC_PCLK     (0)
 #define S3C64XX_CLKSRC_MUX      (1)
+#define S3C64XX_CLKSRC_CDCLK    (2)
 
 extern struct snd_soc_dai s3c64xx_i2s_dai[];
 
diff --git a/sound/soc/s3c24xx/smdk2443_wm9710.c b/sound/soc/s3c24xx/smdk2443_wm9710.c
index a2a4f5323c17..362258835e8d 100644
--- a/sound/soc/s3c24xx/smdk2443_wm9710.c
+++ b/sound/soc/s3c24xx/smdk2443_wm9710.c
@@ -20,8 +20,8 @@
 #include <sound/soc-dapm.h>
 
 #include "../codecs/ac97.h"
-#include "s3c24xx-pcm.h"
-#include "s3c24xx-ac97.h"
+#include "s3c-dma.h"
+#include "s3c-ac97.h"
 
 static struct snd_soc_card smdk2443;
 
@@ -29,7 +29,7 @@ static struct snd_soc_dai_link smdk2443_dai[] = {
 {
         .name = "AC97",
         .stream_name = "AC97 HiFi",
-        .cpu_dai = &s3c2443_ac97_dai[0],
+        .cpu_dai = &s3c_ac97_dai[S3C_AC97_DAI_PCM],
         .codec_dai = &ac97_dai,
 },
 };
diff --git a/sound/soc/s3c24xx/smdk64xx_wm8580.c b/sound/soc/s3c24xx/smdk64xx_wm8580.c
new file mode 100644
index 000000000000..efe4901213a3
--- /dev/null
+++ b/sound/soc/s3c24xx/smdk64xx_wm8580.c
@@ -0,0 +1,268 @@
+/*
+ *  smdk64xx_wm8580.c
+ *
+ *  Copyright (c) 2009 Samsung Electronics Co. Ltd
+ *  Author: Jaswinder Singh <jassi.brar@samsung.com>
+ *
+ *  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 the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ */
+
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+
+#include "../codecs/wm8580.h"
+#include "s3c-dma.h"
+#include "s3c64xx-i2s.h"
+
+#define S3C64XX_I2S_V4 2
+
+/* SMDK64XX has a 12MHZ crystal attached to WM8580 */
+#define SMDK64XX_WM8580_FREQ 12000000
+
+static int smdk64xx_hw_params(struct snd_pcm_substream *substream,
+        struct snd_pcm_hw_params *params)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
+        struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
+        unsigned int pll_out;
+        int bfs, rfs, ret;
+
+        switch (params_format(params)) {
+        case SNDRV_PCM_FORMAT_U8:
+        case SNDRV_PCM_FORMAT_S8:
+                bfs = 16;
+                break;
+        case SNDRV_PCM_FORMAT_U16_LE:
+        case SNDRV_PCM_FORMAT_S16_LE:
+                bfs = 32;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        /* The Fvco for WM8580 PLLs must fall within [90,100]MHz.
+         * This criterion can't be met if we request PLL output
+         * as {8000x256, 64000x256, 11025x256}Hz.
+         * As a wayout, we rather change rfs to a minimum value that
+         * results in (params_rate(params) * rfs), and itself, acceptable
+         * to both - the CODEC and the CPU.
+         */
+        switch (params_rate(params)) {
+        case 16000:
+        case 22050:
+        case 32000:
+        case 44100:
+        case 48000:
+        case 88200:
+        case 96000:
+                rfs = 256;
+                break;
+        case 64000:
+                rfs = 384;
+                break;
+        case 8000:
+        case 11025:
+                rfs = 512;
+                break;
+        default:
+                return -EINVAL;
+        }
+        pll_out = params_rate(params) * rfs;
+
+        /* Set the Codec DAI configuration */
+        ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_I2S
+                                         | SND_SOC_DAIFMT_NB_NF
+                                         | SND_SOC_DAIFMT_CBM_CFM);
+        if (ret < 0)
+                return ret;
+
+        /* Set the AP DAI configuration */
+        ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_I2S
+                                         | SND_SOC_DAIFMT_NB_NF
+                                         | SND_SOC_DAIFMT_CBM_CFM);
+        if (ret < 0)
+                return ret;
+
+        ret = snd_soc_dai_set_sysclk(cpu_dai, S3C64XX_CLKSRC_CDCLK,
+                                        0, SND_SOC_CLOCK_IN);
+        if (ret < 0)
+                return ret;
+
+        /* We use PCLK for basic ops in SoC-Slave mode */
+        ret = snd_soc_dai_set_sysclk(cpu_dai, S3C64XX_CLKSRC_PCLK,
+                                        0, SND_SOC_CLOCK_IN);
+        if (ret < 0)
+                return ret;
+
+        /* Set WM8580 to drive MCLK from its PLLA */
+        ret = snd_soc_dai_set_clkdiv(codec_dai, WM8580_MCLK,
+                                        WM8580_CLKSRC_PLLA);
+        if (ret < 0)
+                return ret;
+
+        /* Explicitly set WM8580-DAC to source from MCLK */
+        ret = snd_soc_dai_set_clkdiv(codec_dai, WM8580_DAC_CLKSEL,
+                                        WM8580_CLKSRC_MCLK);
+        if (ret < 0)
+                return ret;
+
+        ret = snd_soc_dai_set_pll(codec_dai, WM8580_PLLA, 0,
+                                        SMDK64XX_WM8580_FREQ, pll_out);
+        if (ret < 0)
+                return ret;
+
+        ret = snd_soc_dai_set_clkdiv(cpu_dai, S3C_I2SV2_DIV_BCLK, bfs);
+        if (ret < 0)
+                return ret;
+
+        ret = snd_soc_dai_set_clkdiv(cpu_dai, S3C_I2SV2_DIV_RCLK, rfs);
+        if (ret < 0)
+                return ret;
+
+        return 0;
+}
+
+/*
+ * SMDK64XX WM8580 DAI operations.
+ */
+static struct snd_soc_ops smdk64xx_ops = {
+        .hw_params = smdk64xx_hw_params,
+};
+
+/* SMDK64xx Playback widgets */
+static const struct snd_soc_dapm_widget wm8580_dapm_widgets_pbk[] = {
+        SND_SOC_DAPM_HP("Front-L/R", NULL),
+        SND_SOC_DAPM_HP("Center/Sub", NULL),
+        SND_SOC_DAPM_HP("Rear-L/R", NULL),
+};
+
+/* SMDK64xx Capture widgets */
+static const struct snd_soc_dapm_widget wm8580_dapm_widgets_cpt[] = {
+        SND_SOC_DAPM_MIC("MicIn", NULL),
+        SND_SOC_DAPM_LINE("LineIn", NULL),
+};
+
+/* SMDK-PAIFTX connections */
+static const struct snd_soc_dapm_route audio_map_tx[] = {
+        /* MicIn feeds AINL */
+        {"AINL", NULL, "MicIn"},
+
+        /* LineIn feeds AINL/R */
+        {"AINL", NULL, "LineIn"},
+        {"AINR", NULL, "LineIn"},
+};
+
+/* SMDK-PAIFRX connections */
+static const struct snd_soc_dapm_route audio_map_rx[] = {
+        /* Front Left/Right are fed VOUT1L/R */
+        {"Front-L/R", NULL, "VOUT1L"},
+        {"Front-L/R", NULL, "VOUT1R"},
+
+        /* Center/Sub are fed VOUT2L/R */
+        {"Center/Sub", NULL, "VOUT2L"},
+        {"Center/Sub", NULL, "VOUT2R"},
+
+        /* Rear Left/Right are fed VOUT3L/R */
+        {"Rear-L/R", NULL, "VOUT3L"},
+        {"Rear-L/R", NULL, "VOUT3R"},
+};
+
+static int smdk64xx_wm8580_init_paiftx(struct snd_soc_codec *codec)
+{
+        /* Add smdk64xx specific Capture widgets */
+        snd_soc_dapm_new_controls(codec, wm8580_dapm_widgets_cpt,
+                                  ARRAY_SIZE(wm8580_dapm_widgets_cpt));
+
+        /* Set up PAIFTX audio path */
+        snd_soc_dapm_add_routes(codec, audio_map_tx, ARRAY_SIZE(audio_map_tx));
+
+        /* Enabling the microphone requires the fitting of a 0R
+         * resistor to connect the line from the microphone jack.
+         */
+        snd_soc_dapm_disable_pin(codec, "MicIn");
+
+        /* signal a DAPM event */
+        snd_soc_dapm_sync(codec);
+
+        return 0;
+}
+
+static int smdk64xx_wm8580_init_paifrx(struct snd_soc_codec *codec)
+{
+        /* Add smdk64xx specific Playback widgets */
+        snd_soc_dapm_new_controls(codec, wm8580_dapm_widgets_pbk,
+                                  ARRAY_SIZE(wm8580_dapm_widgets_pbk));
+
+        /* Set up PAIFRX audio path */
+        snd_soc_dapm_add_routes(codec, audio_map_rx, ARRAY_SIZE(audio_map_rx));
+
+        /* signal a DAPM event */
+        snd_soc_dapm_sync(codec);
+
+        return 0;
+}
+
+static struct snd_soc_dai_link smdk64xx_dai[] = {
+{ /* Primary Playback i/f */
+        .name = "WM8580 PAIF RX",
+        .stream_name = "Playback",
+        .cpu_dai = &s3c64xx_i2s_dai[S3C64XX_I2S_V4],
+        .codec_dai = &wm8580_dai[WM8580_DAI_PAIFRX],
+        .init = smdk64xx_wm8580_init_paifrx,
+        .ops = &smdk64xx_ops,
+},
+{ /* Primary Capture i/f */
+        .name = "WM8580 PAIF TX",
+        .stream_name = "Capture",
+        .cpu_dai = &s3c64xx_i2s_dai[S3C64XX_I2S_V4],
+        .codec_dai = &wm8580_dai[WM8580_DAI_PAIFTX],
+        .init = smdk64xx_wm8580_init_paiftx,
+        .ops = &smdk64xx_ops,
+},
+};
+
+static struct snd_soc_card smdk64xx = {
+        .name = "smdk64xx",
+        .platform = &s3c24xx_soc_platform,
+        .dai_link = smdk64xx_dai,
+        .num_links = ARRAY_SIZE(smdk64xx_dai),
+};
+
+static struct snd_soc_device smdk64xx_snd_devdata = {
+        .card = &smdk64xx,
+        .codec_dev = &soc_codec_dev_wm8580,
+};
+
+static struct platform_device *smdk64xx_snd_device;
+
+static int __init smdk64xx_audio_init(void)
+{
+        int ret;
+
+        smdk64xx_snd_device = platform_device_alloc("soc-audio", -1);
+        if (!smdk64xx_snd_device)
+                return -ENOMEM;
+
+        platform_set_drvdata(smdk64xx_snd_device, &smdk64xx_snd_devdata);
+        smdk64xx_snd_devdata.dev = &smdk64xx_snd_device->dev;
+        ret = platform_device_add(smdk64xx_snd_device);
+
+        if (ret)
+                platform_device_put(smdk64xx_snd_device);
+
+        return ret;
+}
+module_init(smdk64xx_audio_init);
+
+MODULE_AUTHOR("Jaswinder Singh, jassi.brar@samsung.com");
+MODULE_DESCRIPTION("ALSA SoC SMDK64XX WM8580");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/s3c24xx/smdk_wm9713.c b/sound/soc/s3c24xx/smdk_wm9713.c
new file mode 100644
index 000000000000..24fd39f38ccb
--- /dev/null
+++ b/sound/soc/s3c24xx/smdk_wm9713.c
@@ -0,0 +1,94 @@
+/*
+ * smdk_wm9713.c  --  SoC audio for SMDK
+ *
+ * Copyright 2010 Samsung Electronics Co. Ltd.
+ * Author: Jaswinder Singh Brar <jassi.brar@samsung.com>
+ *
+ * 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 the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/device.h>
+#include <sound/soc.h>
+
+#include "../codecs/wm9713.h"
+#include "s3c-dma.h"
+#include "s3c-ac97.h"
+
+static struct snd_soc_card smdk;
+
+/*
+ * Default CFG switch settings to use this driver:
+ *
+ *   SMDK6410: Set CFG1 1-3 On, CFG2 1-4 Off
+ */
+
+/*
+ Playback (HeadPhone):-
+        $ amixer sset 'Headphone' unmute
+        $ amixer sset 'Right Headphone Out Mux' 'Headphone'
+        $ amixer sset 'Left Headphone Out Mux' 'Headphone'
+        $ amixer sset 'Right HP Mixer PCM' unmute
+        $ amixer sset 'Left HP Mixer PCM' unmute
+
+ Capture (LineIn):-
+        $ amixer sset 'Right Capture Source' 'Line'
+        $ amixer sset 'Left Capture Source' 'Line'
+*/
+
+static struct snd_soc_dai_link smdk_dai = {
+        .name = "AC97",
+        .stream_name = "AC97 PCM",
+        .cpu_dai = &s3c_ac97_dai[S3C_AC97_DAI_PCM],
+        .codec_dai = &wm9713_dai[WM9713_DAI_AC97_HIFI],
+};
+
+static struct snd_soc_card smdk = {
+        .name = "SMDK",
+        .platform = &s3c24xx_soc_platform,
+        .dai_link = &smdk_dai,
+        .num_links = 1,
+};
+
+static struct snd_soc_device smdk_snd_ac97_devdata = {
+        .card = &smdk,
+        .codec_dev = &soc_codec_dev_wm9713,
+};
+
+static struct platform_device *smdk_snd_ac97_device;
+
+static int __init smdk_init(void)
+{
+        int ret;
+
+        smdk_snd_ac97_device = platform_device_alloc("soc-audio", -1);
+        if (!smdk_snd_ac97_device)
+                return -ENOMEM;
+
+        platform_set_drvdata(smdk_snd_ac97_device,
+                             &smdk_snd_ac97_devdata);
+        smdk_snd_ac97_devdata.dev = &smdk_snd_ac97_device->dev;
+
+        ret = platform_device_add(smdk_snd_ac97_device);
+        if (ret)
+                platform_device_put(smdk_snd_ac97_device);
+
+        return ret;
+}
+
+static void __exit smdk_exit(void)
+{
+        platform_device_unregister(smdk_snd_ac97_device);
+}
+
+module_init(smdk_init);
+module_exit(smdk_exit);
+
+/* Module information */
+MODULE_AUTHOR("Jaswinder Singh Brar, jassi.brar@samsung.com");
+MODULE_DESCRIPTION("ALSA SoC SMDK+WM9713");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/s6000/s6000-i2s.c b/sound/soc/s6000/s6000-i2s.c
index c5cda187ecab..5b9ac1759bd2 100644
--- a/sound/soc/s6000/s6000-i2s.c
+++ b/sound/soc/s6000/s6000-i2s.c
@@ -16,6 +16,7 @@
 #include <linux/clk.h>
 #include <linux/interrupt.h>
 #include <linux/io.h>
+#include <linux/slab.h>
 
 #include <sound/core.h>
 #include <sound/pcm.h>
@@ -518,7 +519,8 @@ static int __devinit s6000_i2s_probe(struct platform_device *pdev)
 
         s6000_i2s_dai.dev = &pdev->dev;
         s6000_i2s_dai.private_data = dev;
-        s6000_i2s_dai.dma_data = &dev->dma_params;
+        s6000_i2s_dai.capture.dma_data = &dev->dma_params;
+        s6000_i2s_dai.playback.dma_data = &dev->dma_params;
 
         dev->sifbase = sifmem->start;
         dev->scbbase = mmio;
diff --git a/sound/soc/s6000/s6000-pcm.c b/sound/soc/s6000/s6000-pcm.c
index 83b8028e209d..9c7f7f00cebb 100644
--- a/sound/soc/s6000/s6000-pcm.c
+++ b/sound/soc/s6000/s6000-pcm.c
@@ -58,13 +58,15 @@ static void s6000_pcm_enqueue_dma(struct snd_pcm_substream *substream)
         struct snd_pcm_runtime *runtime = substream->runtime;
         struct s6000_runtime_data *prtd = runtime->private_data;
         struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
-        struct s6000_pcm_dma_params *par = soc_runtime->dai->cpu_dai->dma_data;
+        struct s6000_pcm_dma_params *par;
         int channel;
         unsigned int period_size;
         unsigned int dma_offset;
         dma_addr_t dma_pos;
         dma_addr_t src, dst;
 
+        par = snd_soc_dai_get_dma_data(soc_runtime->dai->cpu_dai, substream);
+
         period_size = snd_pcm_lib_period_bytes(substream);
         dma_offset = prtd->period * period_size;
         dma_pos = runtime->dma_addr + dma_offset;
@@ -101,7 +103,8 @@ static irqreturn_t s6000_pcm_irq(int irq, void *data)
 {
         struct snd_pcm *pcm = data;
         struct snd_soc_pcm_runtime *runtime = pcm->private_data;
-        struct s6000_pcm_dma_params *params = runtime->dai->cpu_dai->dma_data;
+        struct s6000_pcm_dma_params *params =
+                snd_soc_dai_get_dma_data(soc_runtime->dai->cpu_dai, substream);
         struct s6000_runtime_data *prtd;
         unsigned int has_xrun;
         int i, ret = IRQ_NONE;
@@ -172,11 +175,13 @@ static int s6000_pcm_start(struct snd_pcm_substream *substream)
 {
         struct s6000_runtime_data *prtd = substream->runtime->private_data;
         struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
-        struct s6000_pcm_dma_params *par = soc_runtime->dai->cpu_dai->dma_data;
+        struct s6000_pcm_dma_params *par;
         unsigned long flags;
         int srcinc;
         u32 dma;
 
+        par = snd_soc_dai_get_dma_data(soc_runtime->dai->cpu_dai, substream);
+
         spin_lock_irqsave(&prtd->lock, flags);
 
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
@@ -196,7 +201,7 @@ static int s6000_pcm_start(struct snd_pcm_substream *substream)
                            0 /* destination skip after chunk (impossible) */,
                            4 /* 16 byte burst size */,
                            -1 /* don't conserve bandwidth */,
-                           0 /* low watermark irq descriptor theshold */,
+                           0 /* low watermark irq descriptor threshold */,
                            0 /* disable hardware timestamps */,
                            1 /* enable channel */);
 
@@ -212,10 +217,12 @@ static int s6000_pcm_stop(struct snd_pcm_substream *substream)
 {
         struct s6000_runtime_data *prtd = substream->runtime->private_data;
         struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
-        struct s6000_pcm_dma_params *par = soc_runtime->dai->cpu_dai->dma_data;
+        struct s6000_pcm_dma_params *par;
         unsigned long flags;
         u32 channel;
 
+        par = snd_soc_dai_get_dma_data(soc_runtime->dai->cpu_dai, substream);
+
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
                 channel = par->dma_out;
         else
@@ -236,9 +243,11 @@ static int s6000_pcm_stop(struct snd_pcm_substream *substream)
 static int s6000_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
 {
         struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
-        struct s6000_pcm_dma_params *par = soc_runtime->dai->cpu_dai->dma_data;
+        struct s6000_pcm_dma_params *par;
         int ret;
 
+        par = snd_soc_dai_get_dma_data(soc_runtime->dai->cpu_dai, substream);
+
         ret = par->trigger(substream, cmd, 0);
         if (ret < 0)
                 return ret;
@@ -275,13 +284,15 @@ static int s6000_pcm_prepare(struct snd_pcm_substream *substream)
 static snd_pcm_uframes_t s6000_pcm_pointer(struct snd_pcm_substream *substream)
 {
         struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
-        struct s6000_pcm_dma_params *par = soc_runtime->dai->cpu_dai->dma_data;
+        struct s6000_pcm_dma_params *par;
         struct snd_pcm_runtime *runtime = substream->runtime;
         struct s6000_runtime_data *prtd = runtime->private_data;
         unsigned long flags;
         unsigned int offset;
         dma_addr_t count;
 
+        par = snd_soc_dai_get_dma_data(soc_runtime->dai->cpu_dai, substream);
+
         spin_lock_irqsave(&prtd->lock, flags);
 
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
@@ -305,11 +316,12 @@ static snd_pcm_uframes_t s6000_pcm_pointer(struct snd_pcm_substream *substream)
 static int s6000_pcm_open(struct snd_pcm_substream *substream)
 {
         struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
-        struct s6000_pcm_dma_params *par = soc_runtime->dai->cpu_dai->dma_data;
+        struct s6000_pcm_dma_params *par;
         struct snd_pcm_runtime *runtime = substream->runtime;
         struct s6000_runtime_data *prtd;
         int ret;
 
+        par = snd_soc_dai_get_dma_data(soc_runtime->dai->cpu_dai, substream);
         snd_soc_set_runtime_hwparams(substream, &s6000_pcm_hardware);
 
         ret = snd_pcm_hw_constraint_step(runtime, 0,
@@ -364,7 +376,7 @@ static int s6000_pcm_hw_params(struct snd_pcm_substream *substream,
                                  struct snd_pcm_hw_params *hw_params)
 {
         struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
-        struct s6000_pcm_dma_params *par = soc_runtime->dai->cpu_dai->dma_data;
+        struct s6000_pcm_dma_params *par;
         int ret;
         ret = snd_pcm_lib_malloc_pages(substream,
                                        params_buffer_bytes(hw_params));
@@ -373,6 +385,8 @@ static int s6000_pcm_hw_params(struct snd_pcm_substream *substream,
                 return ret;
         }
 
+        par = snd_soc_dai_get_dma_data(soc_runtime->dai->cpu_dai, substream);
+
         if (par->same_rate) {
                 spin_lock(&par->lock);
                 if (par->rate == -1 ||
@@ -392,7 +406,8 @@ static int s6000_pcm_hw_params(struct snd_pcm_substream *substream,
 static int s6000_pcm_hw_free(struct snd_pcm_substream *substream)
 {
         struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
-        struct s6000_pcm_dma_params *par = soc_runtime->dai->cpu_dai->dma_data;
+        struct s6000_pcm_dma_params *par =
+                snd_soc_dai_get_dma_data(soc_runtime->dai->cpu_dai, substream);
 
         spin_lock(&par->lock);
         par->in_use &= ~(1 << substream->stream);
@@ -417,25 +432,28 @@ static struct snd_pcm_ops s6000_pcm_ops = {
 static void s6000_pcm_free(struct snd_pcm *pcm)
 {
         struct snd_soc_pcm_runtime *runtime = pcm->private_data;
-        struct s6000_pcm_dma_params *params = runtime->dai->cpu_dai->dma_data;
+        struct s6000_pcm_dma_params *params =
+                snd_soc_dai_get_dma_data(soc_runtime->dai->cpu_dai, substream);
 
         free_irq(params->irq, pcm);
         snd_pcm_lib_preallocate_free_for_all(pcm);
 }
 
-static u64 s6000_pcm_dmamask = DMA_32BIT_MASK;
+static u64 s6000_pcm_dmamask = DMA_BIT_MASK(32);
 
 static int s6000_pcm_new(struct snd_card *card,
                          struct snd_soc_dai *dai, struct snd_pcm *pcm)
 {
         struct snd_soc_pcm_runtime *runtime = pcm->private_data;
-        struct s6000_pcm_dma_params *params = runtime->dai->cpu_dai->dma_data;
+        struct s6000_pcm_dma_params *params;
         int res;
 
+        params = snd_soc_dai_get_dma_data(soc_runtime->dai->cpu_dai, substream);
+
         if (!card->dev->dma_mask)
                 card->dev->dma_mask = &s6000_pcm_dmamask;
         if (!card->dev->coherent_dma_mask)
-                card->dev->coherent_dma_mask = DMA_32BIT_MASK;
+                card->dev->coherent_dma_mask = DMA_BIT_MASK(32);
 
         if (params->dma_in) {
                 s6dmac_disable_chan(DMA_MASK_DMAC(params->dma_in),
diff --git a/sound/soc/sh/Kconfig b/sound/soc/sh/Kconfig
index 9154b4363db3..f07f6d8b93e1 100644
--- a/sound/soc/sh/Kconfig
+++ b/sound/soc/sh/Kconfig
@@ -23,10 +23,17 @@ config SND_SOC_SH4_SSI
 config SND_SOC_SH4_FSI
         tristate "SH4 FSI support"
         depends on CPU_SUBTYPE_SH7724
-        select SH_DMA
         help
           This option enables FSI sound support
 
+config SND_SOC_SH4_SIU
+        tristate
+        depends on (SUPERH || ARCH_SHMOBILE) && HAVE_CLK
+        select DMA_ENGINE
+        select DMADEVICES
+        select SH_DMAE
+        select FW_LOADER
+
 ##
 ## Boards
 ##
@@ -48,4 +55,20 @@ config SND_FSI_AK4642
           This option enables generic sound support for the
           FSI - AK4642 unit
 
+config SND_FSI_DA7210
+        bool "FSI-DA7210 sound support"
+        depends on SND_SOC_SH4_FSI
+        select SND_SOC_DA7210
+        help
+          This option enables generic sound support for the
+          FSI - DA7210 unit
+
+config SND_SIU_MIGOR
+        tristate "SIU sound support on Migo-R"
+        depends on SH_MIGOR
+        select SND_SOC_SH4_SIU
+        select SND_SOC_WM8978
+        help
+          This option enables sound support for the SH7722 Migo-R board
+
 endmenu
diff --git a/sound/soc/sh/Makefile b/sound/soc/sh/Makefile
index a6997872f24e..8a5a19293bda 100644
--- a/sound/soc/sh/Makefile
+++ b/sound/soc/sh/Makefile
@@ -6,13 +6,19 @@ obj-$(CONFIG_SND_SOC_PCM_SH7760)	+= snd-soc-dma-sh7760.o
 snd-soc-hac-objs        := hac.o
 snd-soc-ssi-objs        := ssi.o
 snd-soc-fsi-objs        := fsi.o
+snd-soc-siu-objs        := siu_pcm.o siu_dai.o
 obj-$(CONFIG_SND_SOC_SH4_HAC)   += snd-soc-hac.o
 obj-$(CONFIG_SND_SOC_SH4_SSI)   += snd-soc-ssi.o
 obj-$(CONFIG_SND_SOC_SH4_FSI)   += snd-soc-fsi.o
+obj-$(CONFIG_SND_SOC_SH4_SIU)   += snd-soc-siu.o
 
 ## boards
 snd-soc-sh7760-ac97-objs        := sh7760-ac97.o
 snd-soc-fsi-ak4642-objs         := fsi-ak4642.o
+snd-soc-fsi-da7210-objs         := fsi-da7210.o
+snd-soc-migor-objs              := migor.o
 
 obj-$(CONFIG_SND_SH7760_AC97)   += snd-soc-sh7760-ac97.o
 obj-$(CONFIG_SND_FSI_AK4642)    += snd-soc-fsi-ak4642.o
+obj-$(CONFIG_SND_FSI_DA7210)    += snd-soc-fsi-da7210.o
+obj-$(CONFIG_SND_SIU_MIGOR)     += snd-soc-migor.o
diff --git a/sound/soc/sh/dma-sh7760.c b/sound/soc/sh/dma-sh7760.c
index baddb1242c71..0d8bdf07729c 100644
--- a/sound/soc/sh/dma-sh7760.c
+++ b/sound/soc/sh/dma-sh7760.c
@@ -13,6 +13,7 @@
  */
 
 #include <linux/module.h>
+#include <linux/gfp.h>
 #include <linux/init.h>
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
diff --git a/sound/soc/sh/fsi-ak4642.c b/sound/soc/sh/fsi-ak4642.c
index c7af09729c6e..5263ab18f827 100644
--- a/sound/soc/sh/fsi-ak4642.c
+++ b/sound/soc/sh/fsi-ak4642.c
@@ -42,42 +42,12 @@ static struct snd_soc_device fsi_snd_devdata = {
         .codec_dev      = &soc_codec_dev_ak4642,
 };
 
-#define AK4642_BUS 0
-#define AK4642_ADR 0x12
-static int ak4642_add_i2c_device(void)
-{
-        struct i2c_board_info info;
-        struct i2c_adapter *adapter;
-        struct i2c_client *client;
-
-        memset(&info, 0, sizeof(struct i2c_board_info));
-        info.addr = AK4642_ADR;
-        strlcpy(info.type, "ak4642", I2C_NAME_SIZE);
-
-        adapter = i2c_get_adapter(AK4642_BUS);
-        if (!adapter) {
-                printk(KERN_DEBUG "can't get i2c adapter\n");
-                return -ENODEV;
-        }
-
-        client = i2c_new_device(adapter, &info);
-        i2c_put_adapter(adapter);
-        if (!client) {
-                printk(KERN_DEBUG "can't add i2c device\n");
-                return -ENODEV;
-        }
-
-        return 0;
-}
-
 static struct platform_device *fsi_snd_device;
 
 static int __init fsi_ak4642_init(void)
 {
         int ret = -ENOMEM;
 
-        ak4642_add_i2c_device();
-
         fsi_snd_device = platform_device_alloc("soc-audio", -1);
         if (!fsi_snd_device)
                 goto out;
diff --git a/sound/soc/sh/fsi-da7210.c b/sound/soc/sh/fsi-da7210.c
new file mode 100644
index 000000000000..33b4d177f466
--- /dev/null
+++ b/sound/soc/sh/fsi-da7210.c
@@ -0,0 +1,83 @@
+/*
+ * fsi-da7210.c
+ *
+ * Copyright (C) 2009 Renesas Solutions Corp.
+ * Kuninori Morimoto <morimoto.kuninori@renesas.com>
+ *
+ *  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 the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ */
+
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/io.h>
+#include <linux/i2c.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+
+#include <sound/sh_fsi.h>
+#include "../codecs/da7210.h"
+
+static int fsi_da7210_init(struct snd_soc_codec *codec)
+{
+        return snd_soc_dai_set_fmt(&da7210_dai,
+                                   SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
+                                   SND_SOC_DAIFMT_CBM_CFM);
+}
+
+static struct snd_soc_dai_link fsi_da7210_dai = {
+        .name           = "DA7210",
+        .stream_name    = "DA7210",
+        .cpu_dai        = &fsi_soc_dai[1], /* FSI B */
+        .codec_dai      = &da7210_dai,
+        .init           = fsi_da7210_init,
+};
+
+static struct snd_soc_card fsi_soc_card = {
+        .name           = "FSI",
+        .platform       = &fsi_soc_platform,
+        .dai_link       = &fsi_da7210_dai,
+        .num_links      = 1,
+};
+
+static struct snd_soc_device fsi_da7210_snd_devdata = {
+        .card           = &fsi_soc_card,
+        .codec_dev      = &soc_codec_dev_da7210,
+};
+
+static struct platform_device *fsi_da7210_snd_device;
+
+static int __init fsi_da7210_sound_init(void)
+{
+        int ret;
+
+        fsi_da7210_snd_device = platform_device_alloc("soc-audio", -1);
+        if (!fsi_da7210_snd_device)
+                return -ENOMEM;
+
+        platform_set_drvdata(fsi_da7210_snd_device, &fsi_da7210_snd_devdata);
+        fsi_da7210_snd_devdata.dev = &fsi_da7210_snd_device->dev;
+        ret = platform_device_add(fsi_da7210_snd_device);
+        if (ret)
+                platform_device_put(fsi_da7210_snd_device);
+
+        return ret;
+}
+
+static void __exit fsi_da7210_sound_exit(void)
+{
+        platform_device_unregister(fsi_da7210_snd_device);
+}
+
+module_init(fsi_da7210_sound_init);
+module_exit(fsi_da7210_sound_exit);
+
+/* Module information */
+MODULE_DESCRIPTION("ALSA SoC FSI DA2710");
+MODULE_AUTHOR("Kuninori Morimoto <morimoto.kuninori@renesas.com>");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/sh/fsi.c b/sound/soc/sh/fsi.c
index 44123248b630..8dc966f45c36 100644
--- a/sound/soc/sh/fsi.c
+++ b/sound/soc/sh/fsi.c
@@ -17,8 +17,9 @@
 #include <linux/platform_device.h>
 #include <linux/delay.h>
 #include <linux/list.h>
-#include <linux/clk.h>
+#include <linux/pm_runtime.h>
 #include <linux/io.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/initval.h>
@@ -26,8 +27,6 @@
 #include <sound/pcm_params.h>
 #include <sound/sh_fsi.h>
 #include <asm/atomic.h>
-#include <asm/dma.h>
-#include <asm/dma-sh.h>
 
 #define DO_FMT          0x0000
 #define DOFF_CTL        0x0004
@@ -69,6 +68,7 @@
 /* DOFF_ST */
 #define ERR_OVER        0x00000010
 #define ERR_UNDER       0x00000001
+#define ST_ERR          (ERR_OVER | ERR_UNDER)
 
 /* CLK_RST */
 #define B_CLK           0x00000010
@@ -94,10 +94,10 @@
 struct fsi_priv {
         void __iomem *base;
         struct snd_pcm_substream *substream;
+        struct fsi_master *master;
 
         int fifo_max;
         int chan;
-        int dma_chan;
 
         int byte_offset;
         int period_len;
@@ -108,14 +108,12 @@ struct fsi_priv {
 struct fsi_master {
         void __iomem *base;
         int irq;
-        struct clk *clk;
         struct fsi_priv fsia;
         struct fsi_priv fsib;
         struct sh_fsi_platform_info *info;
+        spinlock_t lock;
 };
 
-static struct fsi_master *master;
-
 /************************************************************************
 
 
@@ -123,35 +121,35 @@ static struct fsi_master *master;
 
 
 ************************************************************************/
-static int __fsi_reg_write(u32 reg, u32 data)
+static void __fsi_reg_write(u32 reg, u32 data)
 {
         /* valid data area is 24bit */
         data &= 0x00ffffff;
 
-        return ctrl_outl(data, reg);
+        __raw_writel(data, reg);
 }
 
 static u32 __fsi_reg_read(u32 reg)
 {
-        return ctrl_inl(reg);
+        return __raw_readl(reg);
 }
 
-static int __fsi_reg_mask_set(u32 reg, u32 mask, u32 data)
+static void __fsi_reg_mask_set(u32 reg, u32 mask, u32 data)
 {
         u32 val = __fsi_reg_read(reg);
 
         val &= ~mask;
         val |= data & mask;
 
-        return __fsi_reg_write(reg, val);
+        __fsi_reg_write(reg, val);
 }
 
-static int fsi_reg_write(struct fsi_priv *fsi, u32 reg, u32 data)
+static void fsi_reg_write(struct fsi_priv *fsi, u32 reg, u32 data)
 {
         if (reg > REG_END)
-                return -1;
+                return;
 
-        return __fsi_reg_write((u32)(fsi->base + reg), data);
+        __fsi_reg_write((u32)(fsi->base + reg), data);
 }
 
 static u32 fsi_reg_read(struct fsi_priv *fsi, u32 reg)
@@ -162,39 +160,55 @@ static u32 fsi_reg_read(struct fsi_priv *fsi, u32 reg)
         return __fsi_reg_read((u32)(fsi->base + reg));
 }
 
-static int fsi_reg_mask_set(struct fsi_priv *fsi, u32 reg, u32 mask, u32 data)
+static void fsi_reg_mask_set(struct fsi_priv *fsi, u32 reg, u32 mask, u32 data)
 {
         if (reg > REG_END)
-                return -1;
+                return;
 
-        return __fsi_reg_mask_set((u32)(fsi->base + reg), mask, data);
+        __fsi_reg_mask_set((u32)(fsi->base + reg), mask, data);
 }
 
-static int fsi_master_write(u32 reg, u32 data)
+static void fsi_master_write(struct fsi_master *master, u32 reg, u32 data)
 {
+        unsigned long flags;
+
         if ((reg < MREG_START) ||
             (reg > MREG_END))
-                return -1;
+                return;
 
-        return __fsi_reg_write((u32)(master->base + reg), data);
+        spin_lock_irqsave(&master->lock, flags);
+        __fsi_reg_write((u32)(master->base + reg), data);
+        spin_unlock_irqrestore(&master->lock, flags);
 }
 
-static u32 fsi_master_read(u32 reg)
+static u32 fsi_master_read(struct fsi_master *master, u32 reg)
 {
+        u32 ret;
+        unsigned long flags;
+
         if ((reg < MREG_START) ||
             (reg > MREG_END))
                 return 0;
 
-        return __fsi_reg_read((u32)(master->base + reg));
+        spin_lock_irqsave(&master->lock, flags);
+        ret = __fsi_reg_read((u32)(master->base + reg));
+        spin_unlock_irqrestore(&master->lock, flags);
+
+        return ret;
 }
 
-static int fsi_master_mask_set(u32 reg, u32 mask, u32 data)
+static void fsi_master_mask_set(struct fsi_master *master,
+                               u32 reg, u32 mask, u32 data)
 {
+        unsigned long flags;
+
         if ((reg < MREG_START) ||
             (reg > MREG_END))
-                return -1;
+                return;
 
-        return __fsi_reg_mask_set((u32)(master->base + reg), mask, data);
+        spin_lock_irqsave(&master->lock, flags);
+        __fsi_reg_mask_set((u32)(master->base + reg), mask, data);
+        spin_unlock_irqrestore(&master->lock, flags);
 }
 
 /************************************************************************
@@ -204,43 +218,35 @@ static int fsi_master_mask_set(u32 reg, u32 mask, u32 data)
 
 
 ************************************************************************/
-static struct fsi_priv *fsi_get(struct snd_pcm_substream *substream)
+static struct fsi_master *fsi_get_master(struct fsi_priv *fsi)
 {
-        struct snd_soc_pcm_runtime *rtd;
-        struct fsi_priv *fsi = NULL;
+        return fsi->master;
+}
 
-        if (!substream || !master)
-                return NULL;
+static int fsi_is_port_a(struct fsi_priv *fsi)
+{
+        return fsi->master->base == fsi->base;
+}
 
-        rtd = substream->private_data;
-        switch (rtd->dai->cpu_dai->id) {
-        case 0:
-                fsi = &master->fsia;
-                break;
-        case 1:
-                fsi = &master->fsib;
-                break;
-        }
+static struct snd_soc_dai *fsi_get_dai(struct snd_pcm_substream *substream)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_dai_link *machine = rtd->dai;
 
-        return fsi;
+        return  machine->cpu_dai;
 }
 
-static int fsi_is_port_a(struct fsi_priv *fsi)
+static struct fsi_priv *fsi_get_priv(struct snd_pcm_substream *substream)
 {
-        /* return
-         * 1 : port a
-         * 0 : port b
-         */
-
-        if (fsi == &master->fsia)
-                return 1;
+        struct snd_soc_dai *dai = fsi_get_dai(substream);
 
-        return 0;
+        return dai->private_data;
 }
 
 static u32 fsi_get_info_flags(struct fsi_priv *fsi)
 {
         int is_porta = fsi_is_port_a(fsi);
+        struct fsi_master *master = fsi_get_master(fsi);
 
         return is_porta ? master->info->porta_flags :
                 master->info->portb_flags;
@@ -308,62 +314,6 @@ static int fsi_get_fifo_residue(struct fsi_priv *fsi, int is_play)
         return residue;
 }
 
-static int fsi_get_residue(struct fsi_priv *fsi, int is_play)
-{
-        int residue;
-        int width;
-        struct snd_pcm_runtime *runtime;
-
-        runtime = fsi->substream->runtime;
-
-        /* get 1 channel data width */
-        width = frames_to_bytes(runtime, 1) / fsi->chan;
-
-        if (2 == width)
-                residue = fsi_get_fifo_residue(fsi, is_play);
-        else
-                residue = get_dma_residue(fsi->dma_chan);
-
-        return residue;
-}
-
-/************************************************************************
-
-
-                basic dma function
-
-
-************************************************************************/
-#define PORTA_DMA 0
-#define PORTB_DMA 1
-
-static int fsi_get_dma_chan(void)
-{
-        if (0 != request_dma(PORTA_DMA, "fsia"))
-                return -EIO;
-
-        if (0 != request_dma(PORTB_DMA, "fsib")) {
-                free_dma(PORTA_DMA);
-                return -EIO;
-        }
-
-        master->fsia.dma_chan = PORTA_DMA;
-        master->fsib.dma_chan = PORTB_DMA;
-
-        return 0;
-}
-
-static void fsi_free_dma_chan(void)
-{
-        dma_wait_for_completion(PORTA_DMA);
-        dma_wait_for_completion(PORTB_DMA);
-        free_dma(PORTA_DMA);
-        free_dma(PORTB_DMA);
-
-        master->fsia.dma_chan = -1;
-        master->fsib.dma_chan = -1;
-}
-
 /************************************************************************
 
 
@@ -374,27 +324,30 @@ static void fsi_free_dma_chan(void)
 static void fsi_irq_enable(struct fsi_priv *fsi, int is_play)
 {
         u32 data = fsi_port_ab_io_bit(fsi, is_play);
+        struct fsi_master *master = fsi_get_master(fsi);
 
-        fsi_master_mask_set(IMSK,  data, data);
-        fsi_master_mask_set(IEMSK, data, data);
+        fsi_master_mask_set(master, IMSK,  data, data);
+        fsi_master_mask_set(master, IEMSK, data, data);
 }
 
 static void fsi_irq_disable(struct fsi_priv *fsi, int is_play)
 {
         u32 data = fsi_port_ab_io_bit(fsi, is_play);
+        struct fsi_master *master = fsi_get_master(fsi);
 
-        fsi_master_mask_set(IMSK,  data, 0);
-        fsi_master_mask_set(IEMSK, data, 0);
+        fsi_master_mask_set(master, IMSK,  data, 0);
+        fsi_master_mask_set(master, IEMSK, data, 0);
 }
 
 static void fsi_clk_ctrl(struct fsi_priv *fsi, int enable)
 {
         u32 val = fsi_is_port_a(fsi) ? (1 << 0) : (1 << 4);
+        struct fsi_master *master = fsi_get_master(fsi);
 
         if (enable)
-                fsi_master_mask_set(CLK_RST, val, val);
+                fsi_master_mask_set(master, CLK_RST, val, val);
         else
-                fsi_master_mask_set(CLK_RST, val, 0);
+                fsi_master_mask_set(master, CLK_RST, val, 0);
 }
 
 static void fsi_irq_init(struct fsi_priv *fsi, int is_play)
@@ -415,79 +368,46 @@ static void fsi_irq_init(struct fsi_priv *fsi, int is_play)
         fsi_reg_mask_set(fsi, ctrl, FIFO_CLR, FIFO_CLR);
 
         /* clear interrupt factor */
-        fsi_master_mask_set(INT_ST, data, 0);
+        fsi_master_mask_set(fsi_get_master(fsi), INT_ST, data, 0);
 }
 
-static void fsi_soft_all_reset(void)
+static void fsi_soft_all_reset(struct fsi_master *master)
 {
-        u32 status = fsi_master_read(SOFT_RST);
+        u32 status = fsi_master_read(master, SOFT_RST);
 
         /* port AB reset */
         status &= 0x000000ff;
-        fsi_master_write(SOFT_RST, status);
+        fsi_master_write(master, SOFT_RST, status);
         mdelay(10);
 
         /* soft reset */
         status &= 0x000000f0;
-        fsi_master_write(SOFT_RST, status);
+        fsi_master_write(master, SOFT_RST, status);
         status |= 0x00000001;
-        fsi_master_write(SOFT_RST, status);
+        fsi_master_write(master, SOFT_RST, status);
         mdelay(10);
 }
 
-static void fsi_16data_push(struct fsi_priv *fsi,
-                           struct snd_pcm_runtime *runtime,
-                           int send)
-{
-        u16 *dma_start;
-        u32 snd;
-        int i;
-
-        /* get dma start position for FSI */
-        dma_start = (u16 *)runtime->dma_area;
-        dma_start += fsi->byte_offset / 2;
-
-        /*
-         * soft dma
-         * FSI can not use DMA when 16bpp
-         */
-        for (i = 0; i < send; i++) {
-                snd = (u32)dma_start[i];
-                fsi_reg_write(fsi, DODT, snd << 8);
-        }
-}
-
-static void fsi_32data_push(struct fsi_priv *fsi,
-                           struct snd_pcm_runtime *runtime,
-                           int send)
-{
-        u32 *dma_start;
-
-        /* get dma start position for FSI */
-        dma_start = (u32 *)runtime->dma_area;
-        dma_start += fsi->byte_offset / 4;
-
-        dma_wait_for_completion(fsi->dma_chan);
-        dma_configure_channel(fsi->dma_chan, (SM_INC|0x400|TS_32|TM_BUR));
-        dma_write(fsi->dma_chan, (u32)dma_start,
-                  (u32)(fsi->base + DODT), send * 4);
-}
-
 /* playback interrupt */
-static int fsi_data_push(struct fsi_priv *fsi)
+static int fsi_data_push(struct fsi_priv *fsi, int startup)
 {
         struct snd_pcm_runtime *runtime;
         struct snd_pcm_substream *substream = NULL;
+        u32 status;
         int send;
         int fifo_free;
         int width;
+        u8 *start;
+        int i, over_period;
 
         if (!fsi                        ||
             !fsi->substream             ||
             !fsi->substream->runtime)
                 return -EINVAL;
 
-        runtime = fsi->substream->runtime;
+        over_period     = 0;
+        substream       = fsi->substream;
+        runtime         = substream->runtime;
 
         /* FSI FIFO has limit.
          * So, this driver can not send periods data at a time
@@ -495,7 +415,7 @@ static int fsi_data_push(struct fsi_priv *fsi)
         if (fsi->byte_offset >=
             fsi->period_len * (fsi->periods + 1)) {
 
-                substream = fsi->substream;
+                over_period = 1;
                 fsi->periods = (fsi->periods + 1) % runtime->periods;
 
                 if (0 == fsi->periods)
@@ -515,18 +435,122 @@ static int fsi_data_push(struct fsi_priv *fsi)
         if (fifo_free < send)
                 send = fifo_free;
 
-        if (2 == width)
-                fsi_16data_push(fsi, runtime, send);
-        else if (4 == width)
-                fsi_32data_push(fsi, runtime, send);
-        else
+        start = runtime->dma_area;
+        start += fsi->byte_offset;
+
+        switch (width) {
+        case 2:
+                for (i = 0; i < send; i++)
+                        fsi_reg_write(fsi, DODT,
+                                      ((u32)*((u16 *)start + i) << 8));
+                break;
+        case 4:
+                for (i = 0; i < send; i++)
+                        fsi_reg_write(fsi, DODT, *((u32 *)start + i));
+                break;
+        default:
                 return -EINVAL;
+        }
 
         fsi->byte_offset += send * width;
 
+        status = fsi_reg_read(fsi, DOFF_ST);
+        if (!startup) {
+                struct snd_soc_dai *dai = fsi_get_dai(substream);
+
+                if (status & ERR_OVER)
+                        dev_err(dai->dev, "over run\n");
+                if (status & ERR_UNDER)
+                        dev_err(dai->dev, "under run\n");
+        }
+        fsi_reg_write(fsi, DOFF_ST, 0);
+
         fsi_irq_enable(fsi, 1);
 
-        if (substream)
+        if (over_period)
+                snd_pcm_period_elapsed(substream);
+
+        return 0;
+}
+
+static int fsi_data_pop(struct fsi_priv *fsi, int startup)
+{
+        struct snd_pcm_runtime *runtime;
+        struct snd_pcm_substream *substream = NULL;
+        u32 status;
+        int free;
+        int fifo_fill;
+        int width;
+        u8 *start;
+        int i, over_period;
+
+        if (!fsi                        ||
+            !fsi->substream             ||
+            !fsi->substream->runtime)
+                return -EINVAL;
+
+        over_period     = 0;
+        substream       = fsi->substream;
+        runtime         = substream->runtime;
+
+        /* FSI FIFO has limit.
+         * So, this driver can not send periods data at a time
+         */
+        if (fsi->byte_offset >=
+            fsi->period_len * (fsi->periods + 1)) {
+
+                over_period = 1;
+                fsi->periods = (fsi->periods + 1) % runtime->periods;
+
+                if (0 == fsi->periods)
+                        fsi->byte_offset = 0;
+        }
+
+        /* get 1 channel data width */
+        width = frames_to_bytes(runtime, 1) / fsi->chan;
+
+        /* get free space for alsa */
+        free = (fsi->buffer_len - fsi->byte_offset) / width;
+
+        /* get recv size */
+        fifo_fill = fsi_get_fifo_residue(fsi, 0);
+
+        if (free < fifo_fill)
+                fifo_fill = free;
+
+        start = runtime->dma_area;
+        start += fsi->byte_offset;
+
+        switch (width) {
+        case 2:
+                for (i = 0; i < fifo_fill; i++)
+                        *((u16 *)start + i) =
+                                (u16)(fsi_reg_read(fsi, DIDT) >> 8);
+                break;
+        case 4:
+                for (i = 0; i < fifo_fill; i++)
+                        *((u32 *)start + i) = fsi_reg_read(fsi, DIDT);
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        fsi->byte_offset += fifo_fill * width;
+
+        status = fsi_reg_read(fsi, DIFF_ST);
+        if (!startup) {
+                struct snd_soc_dai *dai = fsi_get_dai(substream);
+
+                if (status & ERR_OVER)
+                        dev_err(dai->dev, "over run\n");
+                if (status & ERR_UNDER)
+                        dev_err(dai->dev, "under run\n");
+        }
+        fsi_reg_write(fsi, DIFF_ST, 0);
+
+        fsi_irq_enable(fsi, 0);
+
+        if (over_period)
                 snd_pcm_period_elapsed(substream);
 
         return 0;
@@ -534,19 +558,24 @@ static int fsi_data_push(struct fsi_priv *fsi)
 
 static irqreturn_t fsi_interrupt(int irq, void *data)
 {
-        u32 status = fsi_master_read(SOFT_RST) & ~0x00000010;
-        u32 int_st = fsi_master_read(INT_ST);
+        struct fsi_master *master = data;
+        u32 status = fsi_master_read(master, SOFT_RST) & ~0x00000010;
+        u32 int_st = fsi_master_read(master, INT_ST);
 
         /* clear irq status */
-        fsi_master_write(SOFT_RST, status);
-        fsi_master_write(SOFT_RST, status | 0x00000010);
+        fsi_master_write(master, SOFT_RST, status);
+        fsi_master_write(master, SOFT_RST, status | 0x00000010);
 
         if (int_st & INT_A_OUT)
-                fsi_data_push(&master->fsia);
+                fsi_data_push(&master->fsia, 0);
         if (int_st & INT_B_OUT)
-                fsi_data_push(&master->fsib);
+                fsi_data_push(&master->fsib, 0);
+        if (int_st & INT_A_IN)
+                fsi_data_pop(&master->fsia, 0);
+        if (int_st & INT_B_IN)
+                fsi_data_pop(&master->fsib, 0);
 
-        fsi_master_write(INT_ST, 0x0000000);
+        fsi_master_write(master, INT_ST, 0x0000000);
 
         return IRQ_HANDLED;
 }
@@ -561,7 +590,7 @@ static irqreturn_t fsi_interrupt(int irq, void *data)
 static int fsi_dai_startup(struct snd_pcm_substream *substream,
                            struct snd_soc_dai *dai)
 {
-        struct fsi_priv *fsi = fsi_get(substream);
+        struct fsi_priv *fsi = fsi_get_priv(substream);
         const char *msg;
         u32 flags = fsi_get_info_flags(fsi);
         u32 fmt;
@@ -571,7 +600,7 @@ static int fsi_dai_startup(struct snd_pcm_substream *substream,
         int is_master;
         int ret = 0;
 
-        clk_enable(master->clk);
+        pm_runtime_get_sync(dai->dev);
 
         /* CKG1 */
         data = is_play ? (1 << 0) : (1 << 4);
@@ -664,8 +693,6 @@ static int fsi_dai_startup(struct snd_pcm_substream *substream,
         }
 
         fsi_reg_write(fsi, reg, data);
-        dev_dbg(dai->dev, "use %s format (%d channel) use %d DMAC\n",
-                msg, fsi->chan, fsi->dma_chan);
 
         /*
          * clear clk reset if master mode
@@ -682,33 +709,29 @@ static int fsi_dai_startup(struct snd_pcm_substream *substream,
 static void fsi_dai_shutdown(struct snd_pcm_substream *substream,
                              struct snd_soc_dai *dai)
 {
-        struct fsi_priv *fsi = fsi_get(substream);
+        struct fsi_priv *fsi = fsi_get_priv(substream);
         int is_play = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;
 
         fsi_irq_disable(fsi, is_play);
         fsi_clk_ctrl(fsi, 0);
 
-        clk_disable(master->clk);
+        pm_runtime_put_sync(dai->dev);
 }
 
 static int fsi_dai_trigger(struct snd_pcm_substream *substream, int cmd,
                            struct snd_soc_dai *dai)
 {
-        struct fsi_priv *fsi = fsi_get(substream);
+        struct fsi_priv *fsi = fsi_get_priv(substream);
         struct snd_pcm_runtime *runtime = substream->runtime;
         int is_play = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;
         int ret = 0;
 
-        /* capture not supported */
-        if (!is_play)
-                return -ENODEV;
-
         switch (cmd) {
         case SNDRV_PCM_TRIGGER_START:
                 fsi_stream_push(fsi, substream,
                                 frames_to_bytes(runtime, runtime->buffer_size),
                                 frames_to_bytes(runtime, runtime->period_size));
-                ret = fsi_data_push(fsi);
+                ret = is_play ? fsi_data_push(fsi, 1) : fsi_data_pop(fsi, 1);
                 break;
         case SNDRV_PCM_TRIGGER_STOP:
                 fsi_irq_disable(fsi, is_play);
@@ -779,11 +802,10 @@ static int fsi_hw_free(struct snd_pcm_substream *substream)
 static snd_pcm_uframes_t fsi_pointer(struct snd_pcm_substream *substream)
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
-        struct fsi_priv *fsi = fsi_get(substream);
-        int is_play = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;
+        struct fsi_priv *fsi = fsi_get_priv(substream);
         long location;
 
-        location = (fsi->byte_offset - 1) - fsi_get_residue(fsi, is_play);
+        location = (fsi->byte_offset - 1);
         if (location < 0)
                 location = 0;
 
@@ -845,7 +867,12 @@ struct snd_soc_dai fsi_soc_dai[] = {
                         .channels_min   = 1,
                         .channels_max   = 8,
                 },
-                /* capture not supported */
+                .capture = {
+                        .rates          = FSI_RATES,
+                        .formats        = FSI_FMTS,
+                        .channels_min   = 1,
+                        .channels_max   = 8,
+                },
                 .ops = &fsi_dai_ops,
         },
         {
@@ -857,7 +884,12 @@ struct snd_soc_dai fsi_soc_dai[] = {
                         .channels_min   = 1,
                         .channels_max   = 8,
                 },
-                /* capture not supported */
+                .capture = {
+                        .rates          = FSI_RATES,
+                        .formats        = FSI_FMTS,
+                        .channels_min   = 1,
+                        .channels_max   = 8,
+                },
                 .ops = &fsi_dai_ops,
         },
 };
@@ -880,14 +912,19 @@ EXPORT_SYMBOL_GPL(fsi_soc_platform);
 ************************************************************************/
 static int fsi_probe(struct platform_device *pdev)
 {
+        struct fsi_master *master;
         struct resource *res;
-        char clk_name[8];
         unsigned int irq;
         int ret;
 
+        if (0 != pdev->id) {
+                dev_err(&pdev->dev, "current fsi support id 0 only now\n");
+                return -ENODEV;
+        }
+
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         irq = platform_get_irq(pdev, 0);
-        if (!res || !irq) {
+        if (!res || (int)irq <= 0) {
                 dev_err(&pdev->dev, "Not enough FSI platform resources.\n");
                 ret = -ENODEV;
                 goto exit;
@@ -910,35 +947,25 @@ static int fsi_probe(struct platform_device *pdev)
         master->irq             = irq;
         master->info            = pdev->dev.platform_data;
         master->fsia.base       = master->base;
+        master->fsia.master     = master;
         master->fsib.base       = master->base + 0x40;
+        master->fsib.master     = master;
+        spin_lock_init(&master->lock);
 
-        master->fsia.dma_chan = -1;
-        master->fsib.dma_chan = -1;
-
-        ret = fsi_get_dma_chan();
-        if (ret < 0) {
-                dev_err(&pdev->dev, "cannot get dma api\n");
-                goto exit_iounmap;
-        }
-
-        /* FSI is based on SPU mstp */
-        snprintf(clk_name, sizeof(clk_name), "spu%d", pdev->id);
-        master->clk = clk_get(NULL, clk_name);
-        if (IS_ERR(master->clk)) {
-                dev_err(&pdev->dev, "cannot get %s mstp\n", clk_name);
-                ret = -EIO;
-                goto exit_free_dma;
-        }
+        pm_runtime_enable(&pdev->dev);
+        pm_runtime_resume(&pdev->dev);
 
         fsi_soc_dai[0].dev              = &pdev->dev;
+        fsi_soc_dai[0].private_data     = &master->fsia;
         fsi_soc_dai[1].dev              = &pdev->dev;
+        fsi_soc_dai[1].private_data     = &master->fsib;
 
-        fsi_soft_all_reset();
+        fsi_soft_all_reset(master);
 
         ret = request_irq(irq, &fsi_interrupt, IRQF_DISABLED, "fsi", master);
         if (ret) {
                 dev_err(&pdev->dev, "irq request err\n");
-                goto exit_free_dma;
+                goto exit_iounmap;
         }
 
         ret = snd_soc_register_platform(&fsi_soc_platform);
@@ -951,10 +978,9 @@ static int fsi_probe(struct platform_device *pdev)
 
 exit_free_irq:
         free_irq(irq, master);
-exit_free_dma:
-        fsi_free_dma_chan();
 exit_iounmap:
         iounmap(master->base);
+        pm_runtime_disable(&pdev->dev);
 exit_kfree:
         kfree(master);
         master = NULL;
@@ -964,24 +990,49 @@ exit:
 
 static int fsi_remove(struct platform_device *pdev)
 {
+        struct fsi_master *master;
+
+        master = fsi_get_master(fsi_soc_dai[0].private_data);
+
         snd_soc_unregister_dais(fsi_soc_dai, ARRAY_SIZE(fsi_soc_dai));
         snd_soc_unregister_platform(&fsi_soc_platform);
 
-        clk_put(master->clk);
-
-        fsi_free_dma_chan();
+        pm_runtime_disable(&pdev->dev);
 
         free_irq(master->irq, master);
 
         iounmap(master->base);
         kfree(master);
-        master = NULL;
+
+        fsi_soc_dai[0].dev              = NULL;
+        fsi_soc_dai[0].private_data     = NULL;
+        fsi_soc_dai[1].dev              = NULL;
+        fsi_soc_dai[1].private_data     = NULL;
+
+        return 0;
+}
+
+static int fsi_runtime_nop(struct device *dev)
+{
+        /* Runtime PM callback shared between ->runtime_suspend()
+         * and ->runtime_resume(). Simply returns success.
+         *
+         * This driver re-initializes all registers after
+         * pm_runtime_get_sync() anyway so there is no need
+         * to save and restore registers here.
+         */
         return 0;
 }
 
+static struct dev_pm_ops fsi_pm_ops = {
+        .runtime_suspend        = fsi_runtime_nop,
+        .runtime_resume         = fsi_runtime_nop,
+};
+
 static struct platform_driver fsi_driver = {
         .driver         = {
                 .name   = "sh_fsi",
+                .pm     = &fsi_pm_ops,
         },
         .probe          = fsi_probe,
         .remove         = fsi_remove,
diff --git a/sound/soc/sh/migor.c b/sound/soc/sh/migor.c
new file mode 100644
index 000000000000..b823a5c9b9bc
--- /dev/null
+++ b/sound/soc/sh/migor.c
@@ -0,0 +1,218 @@
+/*
+ * ALSA SoC driver for Migo-R
+ *
+ * Copyright (C) 2009-2010 Guennadi Liakhovetski <g.liakhovetski@gmx.de>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/device.h>
+#include <linux/firmware.h>
+#include <linux/module.h>
+
+#include <asm/clock.h>
+
+#include <cpu/sh7722.h>
+
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+
+#include "../codecs/wm8978.h"
+#include "siu.h"
+
+/* Default 8000Hz sampling frequency */
+static unsigned long codec_freq = 8000 * 512;
+
+static unsigned int use_count;
+
+/* External clock, sourced from the codec at the SIUMCKB pin */
+static unsigned long siumckb_recalc(struct clk *clk)
+{
+        return codec_freq;
+}
+
+static struct clk_ops siumckb_clk_ops = {
+        .recalc = siumckb_recalc,
+};
+
+static struct clk siumckb_clk = {
+        .name           = "siumckb_clk",
+        .id             = -1,
+        .ops            = &siumckb_clk_ops,
+        .rate           = 0, /* initialised at run-time */
+};
+
+static int migor_hw_params(struct snd_pcm_substream *substream,
+                           struct snd_pcm_hw_params *params)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
+        int ret;
+        unsigned int rate = params_rate(params);
+
+        ret = snd_soc_dai_set_sysclk(codec_dai, WM8978_PLL, 13000000,
+                                     SND_SOC_CLOCK_IN);
+        if (ret < 0)
+                return ret;
+
+        ret = snd_soc_dai_set_clkdiv(codec_dai, WM8978_OPCLKRATE, rate * 512);
+        if (ret < 0)
+                return ret;
+
+        ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_NB_IF |
+                                  SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_CBS_CFS);
+        if (ret < 0)
+                return ret;
+
+        ret = snd_soc_dai_set_fmt(rtd->dai->cpu_dai, SND_SOC_DAIFMT_NB_IF |
+                                  SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_CBS_CFS);
+        if (ret < 0)
+                return ret;
+
+        codec_freq = rate * 512;
+        /*
+         * This propagates the parent frequency change to children and
+         * recalculates the frequency table
+         */
+        clk_set_rate(&siumckb_clk, codec_freq);
+        dev_dbg(codec_dai->dev, "%s: configure %luHz\n", __func__, codec_freq);
+
+        ret = snd_soc_dai_set_sysclk(rtd->dai->cpu_dai, SIU_CLKB_EXT,
+                                     codec_freq / 2, SND_SOC_CLOCK_IN);
+
+        if (!ret)
+                use_count++;
+
+        return ret;
+}
+
+static int migor_hw_free(struct snd_pcm_substream *substream)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
+
+        if (use_count) {
+                use_count--;
+
+                if (!use_count)
+                        snd_soc_dai_set_sysclk(codec_dai, WM8978_PLL, 0,
+                                               SND_SOC_CLOCK_IN);
+        } else {
+                dev_dbg(codec_dai->dev, "Unbalanced hw_free!\n");
+        }
+
+        return 0;
+}
+
+static struct snd_soc_ops migor_dai_ops = {
+        .hw_params = migor_hw_params,
+        .hw_free = migor_hw_free,
+};
+
+static const struct snd_soc_dapm_widget migor_dapm_widgets[] = {
+        SND_SOC_DAPM_HP("Headphone", NULL),
+        SND_SOC_DAPM_MIC("Onboard Microphone", NULL),
+        SND_SOC_DAPM_MIC("External Microphone", NULL),
+};
+
+static const struct snd_soc_dapm_route audio_map[] = {
+        /* Headphone output connected to LHP/RHP, enable OUT4 for VMID */
+        { "Headphone", NULL,  "OUT4 VMID" },
+        { "OUT4 VMID", NULL,  "LHP" },
+        { "OUT4 VMID", NULL,  "RHP" },
+
+        /* On-board microphone */
+        { "RMICN", NULL, "Mic Bias" },
+        { "RMICP", NULL, "Mic Bias" },
+        { "Mic Bias", NULL, "Onboard Microphone" },
+
+        /* External microphone */
+        { "LMICN", NULL, "Mic Bias" },
+        { "LMICP", NULL, "Mic Bias" },
+        { "Mic Bias", NULL, "External Microphone" },
+};
+
+static int migor_dai_init(struct snd_soc_codec *codec)
+{
+        snd_soc_dapm_new_controls(codec, migor_dapm_widgets,
+                                  ARRAY_SIZE(migor_dapm_widgets));
+
+        snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
+
+        return 0;
+}
+
+/* migor digital audio interface glue - connects codec <--> CPU */
+static struct snd_soc_dai_link migor_dai = {
+        .name = "wm8978",
+        .stream_name = "WM8978",
+        .cpu_dai = &siu_i2s_dai,
+        .codec_dai = &wm8978_dai,
+        .ops = &migor_dai_ops,
+        .init = migor_dai_init,
+};
+
+/* migor audio machine driver */
+static struct snd_soc_card snd_soc_migor = {
+        .name = "Migo-R",
+        .platform = &siu_platform,
+        .dai_link = &migor_dai,
+        .num_links = 1,
+};
+
+/* migor audio subsystem */
+static struct snd_soc_device migor_snd_devdata = {
+        .card = &snd_soc_migor,
+        .codec_dev = &soc_codec_dev_wm8978,
+};
+
+static struct platform_device *migor_snd_device;
+
+static int __init migor_init(void)
+{
+        int ret;
+
+        ret = clk_register(&siumckb_clk);
+        if (ret < 0)
+                return ret;
+
+        /* Port number used on this machine: port B */
+        migor_snd_device = platform_device_alloc("soc-audio", 1);
+        if (!migor_snd_device) {
+                ret = -ENOMEM;
+                goto epdevalloc;
+        }
+
+        platform_set_drvdata(migor_snd_device, &migor_snd_devdata);
+
+        migor_snd_devdata.dev = &migor_snd_device->dev;
+
+        ret = platform_device_add(migor_snd_device);
+        if (ret)
+                goto epdevadd;
+
+        return 0;
+
+epdevadd:
+        platform_device_put(migor_snd_device);
+epdevalloc:
+        clk_unregister(&siumckb_clk);
+        return ret;
+}
+
+static void __exit migor_exit(void)
+{
+        clk_unregister(&siumckb_clk);
+        platform_device_unregister(migor_snd_device);
+}
+
+module_init(migor_init);
+module_exit(migor_exit);
+
+MODULE_AUTHOR("Guennadi Liakhovetski <g.liakhovetski@gmx.de>");
+MODULE_DESCRIPTION("ALSA SoC Migor");
+MODULE_LICENSE("GPL v2");
diff --git a/sound/soc/sh/siu.h b/sound/soc/sh/siu.h
new file mode 100644
index 000000000000..c0bfab8fed3d
--- /dev/null
+++ b/sound/soc/sh/siu.h
@@ -0,0 +1,193 @@
+/*
+ * siu.h - ALSA SoC driver for Renesas SH7343, SH7722 SIU peripheral.
+ *
+ * Copyright (C) 2009-2010 Guennadi Liakhovetski <g.liakhovetski@gmx.de>
+ * Copyright (C) 2006 Carlos Munoz <carlos@kenati.com>
+ *
+ * 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
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef SIU_H
+#define SIU_H
+
+/* Common kernel and user-space firmware-building defines and types */
+
+#define YRAM0_SIZE              (0x0040 / 4)            /* 16 */
+#define YRAM1_SIZE              (0x0080 / 4)            /* 32 */
+#define YRAM2_SIZE              (0x0040 / 4)            /* 16 */
+#define YRAM3_SIZE              (0x0080 / 4)            /* 32 */
+#define YRAM4_SIZE              (0x0080 / 4)            /* 32 */
+#define YRAM_DEF_SIZE           (YRAM0_SIZE + YRAM1_SIZE + YRAM2_SIZE + \
+                                 YRAM3_SIZE + YRAM4_SIZE)
+#define YRAM_FIR_SIZE           (0x0400 / 4)            /* 256 */
+#define YRAM_IIR_SIZE           (0x0200 / 4)            /* 128 */
+
+#define XRAM0_SIZE              (0x0400 / 4)            /* 256 */
+#define XRAM1_SIZE              (0x0200 / 4)            /* 128 */
+#define XRAM2_SIZE              (0x0200 / 4)            /* 128 */
+
+/* PRAM program array size */
+#define PRAM0_SIZE              (0x0100 / 4)            /* 64 */
+#define PRAM1_SIZE              ((0x2000 - 0x0100) / 4) /* 1984 */
+
+#include <linux/types.h>
+
+struct siu_spb_param {
+        __u32   ab1a;   /* input FIFO address */
+        __u32   ab0a;   /* output FIFO address */
+        __u32   dir;    /* 0=the ather except CPUOUTPUT, 1=CPUINPUT */
+        __u32   event;  /* SPB program starting conditions */
+        __u32   stfifo; /* STFIFO register setting value */
+        __u32   trdat;  /* TRDAT register setting value */
+};
+
+struct siu_firmware {
+        __u32                   yram_fir_coeff[YRAM_FIR_SIZE];
+        __u32                   pram0[PRAM0_SIZE];
+        __u32                   pram1[PRAM1_SIZE];
+        __u32                   yram0[YRAM0_SIZE];
+        __u32                   yram1[YRAM1_SIZE];
+        __u32                   yram2[YRAM2_SIZE];
+        __u32                   yram3[YRAM3_SIZE];
+        __u32                   yram4[YRAM4_SIZE];
+        __u32                   spbpar_num;
+        struct siu_spb_param    spbpar[32];
+};
+
+#ifdef __KERNEL__
+
+#include <linux/dmaengine.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+
+#include <asm/dmaengine.h>
+
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/soc-dai.h>
+
+#define SIU_PERIOD_BYTES_MAX    8192            /* DMA transfer/period size */
+#define SIU_PERIOD_BYTES_MIN    256             /* DMA transfer/period size */
+#define SIU_PERIODS_MAX         64              /* Max periods in buffer */
+#define SIU_PERIODS_MIN         4               /* Min periods in buffer */
+#define SIU_BUFFER_BYTES_MAX    (SIU_PERIOD_BYTES_MAX * SIU_PERIODS_MAX)
+
+/* SIU ports: only one can be used at a time */
+enum {
+        SIU_PORT_A,
+        SIU_PORT_B,
+        SIU_PORT_NUM,
+};
+
+/* SIU clock configuration */
+enum {
+        SIU_CLKA_PLL,
+        SIU_CLKA_EXT,
+        SIU_CLKB_PLL,
+        SIU_CLKB_EXT
+};
+
+struct siu_info {
+        int                     port_id;
+        u32 __iomem             *pram;
+        u32 __iomem             *xram;
+        u32 __iomem             *yram;
+        u32 __iomem             *reg;
+        struct siu_firmware     fw;
+};
+
+struct siu_stream {
+        struct tasklet_struct           tasklet;
+        struct snd_pcm_substream        *substream;
+        snd_pcm_format_t                format;
+        size_t                          buf_bytes;
+        size_t                          period_bytes;
+        int                             cur_period;     /* Period currently in dma */
+        u32                             volume;
+        snd_pcm_sframes_t               xfer_cnt;       /* Number of frames */
+        u8                              rw_flg;         /* transfer status */
+        /* DMA status */
+        struct dma_chan                 *chan;          /* DMA channel */
+        struct dma_async_tx_descriptor  *tx_desc;
+        dma_cookie_t                    cookie;
+        struct sh_dmae_slave            param;
+};
+
+struct siu_port {
+        unsigned long           play_cap;       /* Used to track full duplex */
+        struct snd_pcm          *pcm;
+        struct siu_stream       playback;
+        struct siu_stream       capture;
+        u32                     stfifo;         /* STFIFO value from firmware */
+        u32                     trdat;          /* TRDAT value from firmware */
+};
+
+extern struct siu_port *siu_ports[SIU_PORT_NUM];
+
+static inline struct siu_port *siu_port_info(struct snd_pcm_substream *substream)
+{
+        struct platform_device *pdev =
+                to_platform_device(substream->pcm->card->dev);
+        return siu_ports[pdev->id];
+}
+
+/* Register access */
+static inline void siu_write32(u32 __iomem *addr, u32 val)
+{
+        __raw_writel(val, addr);
+}
+
+static inline u32 siu_read32(u32 __iomem *addr)
+{
+        return __raw_readl(addr);
+}
+
+/* SIU registers */
+#define SIU_IFCTL       (0x000 / sizeof(u32))
+#define SIU_SRCTL       (0x004 / sizeof(u32))
+#define SIU_SFORM       (0x008 / sizeof(u32))
+#define SIU_CKCTL       (0x00c / sizeof(u32))
+#define SIU_TRDAT       (0x010 / sizeof(u32))
+#define SIU_STFIFO      (0x014 / sizeof(u32))
+#define SIU_DPAK        (0x01c / sizeof(u32))
+#define SIU_CKREV       (0x020 / sizeof(u32))
+#define SIU_EVNTC       (0x028 / sizeof(u32))
+#define SIU_SBCTL       (0x040 / sizeof(u32))
+#define SIU_SBPSET      (0x044 / sizeof(u32))
+#define SIU_SBFSTS      (0x068 / sizeof(u32))
+#define SIU_SBDVCA      (0x06c / sizeof(u32))
+#define SIU_SBDVCB      (0x070 / sizeof(u32))
+#define SIU_SBACTIV     (0x074 / sizeof(u32))
+#define SIU_DMAIA       (0x090 / sizeof(u32))
+#define SIU_DMAIB       (0x094 / sizeof(u32))
+#define SIU_DMAOA       (0x098 / sizeof(u32))
+#define SIU_DMAOB       (0x09c / sizeof(u32))
+#define SIU_DMAML       (0x0a0 / sizeof(u32))
+#define SIU_SPSTS       (0x0cc / sizeof(u32))
+#define SIU_SPCTL       (0x0d0 / sizeof(u32))
+#define SIU_BRGASEL     (0x100 / sizeof(u32))
+#define SIU_BRRA        (0x104 / sizeof(u32))
+#define SIU_BRGBSEL     (0x108 / sizeof(u32))
+#define SIU_BRRB        (0x10c / sizeof(u32))
+
+extern struct snd_soc_platform siu_platform;
+extern struct snd_soc_dai siu_i2s_dai;
+
+int siu_init_port(int port, struct siu_port **port_info, struct snd_card *card);
+void siu_free_port(struct siu_port *port_info);
+
+#endif
+
+#endif /* SIU_H */
diff --git a/sound/soc/sh/siu_dai.c b/sound/soc/sh/siu_dai.c
new file mode 100644
index 000000000000..d86ee1bfc03a
--- /dev/null
+++ b/sound/soc/sh/siu_dai.c
@@ -0,0 +1,848 @@
+/*
+ * siu_dai.c - ALSA SoC driver for Renesas SH7343, SH7722 SIU peripheral.
+ *
+ * Copyright (C) 2009-2010 Guennadi Liakhovetski <g.liakhovetski@gmx.de>
+ * Copyright (C) 2006 Carlos Munoz <carlos@kenati.com>
+ *
+ * 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
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/delay.h>
+#include <linux/firmware.h>
+#include <linux/pm_runtime.h>
+#include <linux/slab.h>
+
+#include <asm/clock.h>
+#include <asm/siu.h>
+
+#include <sound/control.h>
+#include <sound/soc-dai.h>
+
+#include "siu.h"
+
+/* Board specifics */
+#if defined(CONFIG_CPU_SUBTYPE_SH7722)
+# define SIU_MAX_VOLUME         0x1000
+#else
+# define SIU_MAX_VOLUME         0x7fff
+#endif
+
+#define PRAM_SIZE       0x2000
+#define XRAM_SIZE       0x800
+#define YRAM_SIZE       0x800
+
+#define XRAM_OFFSET     0x4000
+#define YRAM_OFFSET     0x6000
+#define REG_OFFSET      0xc000
+
+#define PLAYBACK_ENABLED        1
+#define CAPTURE_ENABLED         2
+
+#define VOLUME_CAPTURE          0
+#define VOLUME_PLAYBACK         1
+#define DFLT_VOLUME_LEVEL       0x08000800
+
+/*
+ * SPDIF is only available on port A and on some SIU implementations it is only
+ * available for input. Due to the lack of hardware to test it, SPDIF is left
+ * disabled in this driver version
+ */
+struct format_flag {
+        u32     i2s;
+        u32     pcm;
+        u32     spdif;
+        u32     mask;
+};
+
+struct port_flag {
+        struct format_flag      playback;
+        struct format_flag      capture;
+};
+
+static struct port_flag siu_flags[SIU_PORT_NUM] = {
+        [SIU_PORT_A] = {
+                .playback = {
+                        .i2s    = 0x50000000,
+                        .pcm    = 0x40000000,
+                        .spdif  = 0x80000000,   /* not on all SIU versions */
+                        .mask   = 0xd0000000,
+                },
+                .capture = {
+                        .i2s    = 0x05000000,
+                        .pcm    = 0x04000000,
+                        .spdif  = 0x08000000,
+                        .mask   = 0x0d000000,
+                },
+        },
+        [SIU_PORT_B] = {
+                .playback = {
+                        .i2s    = 0x00500000,
+                        .pcm    = 0x00400000,
+                        .spdif  = 0,            /* impossible - turn off */
+                        .mask   = 0x00500000,
+                },
+                .capture = {
+                        .i2s    = 0x00050000,
+                        .pcm    = 0x00040000,
+                        .spdif  = 0,            /* impossible - turn off */
+                        .mask   = 0x00050000,
+                },
+        },
+};
+
+static void siu_dai_start(struct siu_port *port_info)
+{
+        struct siu_info *info = siu_i2s_dai.private_data;
+        u32 __iomem *base = info->reg;
+
+        dev_dbg(port_info->pcm->card->dev, "%s\n", __func__);
+
+        /* Turn on SIU clock */
+        pm_runtime_get_sync(siu_i2s_dai.dev);
+
+        /* Issue software reset to siu */
+        siu_write32(base + SIU_SRCTL, 0);
+
+        /* Wait for the reset to take effect */
+        udelay(1);
+
+        port_info->stfifo = 0;
+        port_info->trdat = 0;
+
+        /* portA, portB, SIU operate */
+        siu_write32(base + SIU_SRCTL, 0x301);
+
+        /* portA=256fs, portB=256fs */
+        siu_write32(base + SIU_CKCTL, 0x40400000);
+
+        /* portA's BRG does not divide SIUCKA */
+        siu_write32(base + SIU_BRGASEL, 0);
+        siu_write32(base + SIU_BRRA, 0);
+
+        /* portB's BRG divides SIUCKB by half */
+        siu_write32(base + SIU_BRGBSEL, 1);
+        siu_write32(base + SIU_BRRB, 0);
+
+        siu_write32(base + SIU_IFCTL, 0x44440000);
+
+        /* portA: 32 bit/fs, master; portB: 32 bit/fs, master */
+        siu_write32(base + SIU_SFORM, 0x0c0c0000);
+
+        /*
+         * Volume levels: looks like the DSP firmware implements volume controls
+         * differently from what's described in the datasheet
+         */
+        siu_write32(base + SIU_SBDVCA, port_info->playback.volume);
+        siu_write32(base + SIU_SBDVCB, port_info->capture.volume);
+}
+
+static void siu_dai_stop(void)
+{
+        struct siu_info *info = siu_i2s_dai.private_data;
+        u32 __iomem *base = info->reg;
+
+        /* SIU software reset */
+        siu_write32(base + SIU_SRCTL, 0);
+
+        /* Turn off SIU clock */
+        pm_runtime_put_sync(siu_i2s_dai.dev);
+}
+
+static void siu_dai_spbAselect(struct siu_port *port_info)
+{
+        struct siu_info *info = siu_i2s_dai.private_data;
+        struct siu_firmware *fw = &info->fw;
+        u32 *ydef = fw->yram0;
+        u32 idx;
+
+        /* path A use */
+        if (!info->port_id)
+                idx = 1;                /* portA */
+        else
+                idx = 2;                /* portB */
+
+        ydef[0] = (fw->spbpar[idx].ab1a << 16) |
+                (fw->spbpar[idx].ab0a << 8) |
+                (fw->spbpar[idx].dir << 7) | 3;
+        ydef[1] = fw->yram0[1]; /* 0x03000300 */
+        ydef[2] = (16 / 2) << 24;
+        ydef[3] = fw->yram0[3]; /* 0 */
+        ydef[4] = fw->yram0[4]; /* 0 */
+        ydef[7] = fw->spbpar[idx].event;
+        port_info->stfifo |= fw->spbpar[idx].stfifo;
+        port_info->trdat |= fw->spbpar[idx].trdat;
+}
+
+static void siu_dai_spbBselect(struct siu_port *port_info)
+{
+        struct siu_info *info = siu_i2s_dai.private_data;
+        struct siu_firmware *fw = &info->fw;
+        u32 *ydef = fw->yram0;
+        u32 idx;
+
+        /* path B use */
+        if (!info->port_id)
+                idx = 7;                /* portA */
+        else
+                idx = 8;                /* portB */
+
+        ydef[5] = (fw->spbpar[idx].ab1a << 16) |
+                (fw->spbpar[idx].ab0a << 8) | 1;
+        ydef[6] = fw->spbpar[idx].event;
+        port_info->stfifo |= fw->spbpar[idx].stfifo;
+        port_info->trdat |= fw->spbpar[idx].trdat;
+}
+
+static void siu_dai_open(struct siu_stream *siu_stream)
+{
+        struct siu_info *info = siu_i2s_dai.private_data;
+        u32 __iomem *base = info->reg;
+        u32 srctl, ifctl;
+
+        srctl = siu_read32(base + SIU_SRCTL);
+        ifctl = siu_read32(base + SIU_IFCTL);
+
+        switch (info->port_id) {
+        case SIU_PORT_A:
+                /* portA operates */
+                srctl |= 0x200;
+                ifctl &= ~0xc2;
+                break;
+        case SIU_PORT_B:
+                /* portB operates */
+                srctl |= 0x100;
+                ifctl &= ~0x31;
+                break;
+        }
+
+        siu_write32(base + SIU_SRCTL, srctl);
+        /* Unmute and configure portA */
+        siu_write32(base + SIU_IFCTL, ifctl);
+}
+
+/*
+ * At the moment only fixed Left-upper, Left-lower, Right-upper, Right-lower
+ * packing is supported
+ */
+static void siu_dai_pcmdatapack(struct siu_stream *siu_stream)
+{
+        struct siu_info *info = siu_i2s_dai.private_data;
+        u32 __iomem *base = info->reg;
+        u32 dpak;
+
+        dpak = siu_read32(base + SIU_DPAK);
+
+        switch (info->port_id) {
+        case SIU_PORT_A:
+                dpak &= ~0xc0000000;
+                break;
+        case SIU_PORT_B:
+                dpak &= ~0x00c00000;
+                break;
+        }
+
+        siu_write32(base + SIU_DPAK, dpak);
+}
+
+static int siu_dai_spbstart(struct siu_port *port_info)
+{
+        struct siu_info *info = siu_i2s_dai.private_data;
+        u32 __iomem *base = info->reg;
+        struct siu_firmware *fw = &info->fw;
+        u32 *ydef = fw->yram0;
+        int cnt;
+        u32 __iomem *add;
+        u32 *ptr;
+
+        /* Load SPB Program in PRAM */
+        ptr = fw->pram0;
+        add = info->pram;
+        for (cnt = 0; cnt < PRAM0_SIZE; cnt++, add++, ptr++)
+                siu_write32(add, *ptr);
+
+        ptr = fw->pram1;
+        add = info->pram + (0x0100 / sizeof(u32));
+        for (cnt = 0; cnt < PRAM1_SIZE; cnt++, add++, ptr++)
+                siu_write32(add, *ptr);
+
+        /* XRAM initialization */
+        add = info->xram;
+        for (cnt = 0; cnt < XRAM0_SIZE + XRAM1_SIZE + XRAM2_SIZE; cnt++, add++)
+                siu_write32(add, 0);
+
+        /* YRAM variable area initialization */
+        add = info->yram;
+        for (cnt = 0; cnt < YRAM_DEF_SIZE; cnt++, add++)
+                siu_write32(add, ydef[cnt]);
+
+        /* YRAM FIR coefficient area initialization */
+        add = info->yram + (0x0200 / sizeof(u32));
+        for (cnt = 0; cnt < YRAM_FIR_SIZE; cnt++, add++)
+                siu_write32(add, fw->yram_fir_coeff[cnt]);
+
+        /* YRAM IIR coefficient area initialization */
+        add = info->yram + (0x0600 / sizeof(u32));
+        for (cnt = 0; cnt < YRAM_IIR_SIZE; cnt++, add++)
+                siu_write32(add, 0);
+
+        siu_write32(base + SIU_TRDAT, port_info->trdat);
+        port_info->trdat = 0x0;
+
+
+        /* SPB start condition: software */
+        siu_write32(base + SIU_SBACTIV, 0);
+        /* Start SPB */
+        siu_write32(base + SIU_SBCTL, 0xc0000000);
+        /* Wait for program to halt */
+        cnt = 0x10000;
+        while (--cnt && siu_read32(base + SIU_SBCTL) != 0x80000000)
+                cpu_relax();
+
+        if (!cnt)
+                return -EBUSY;
+
+        /* SPB program start address setting */
+        siu_write32(base + SIU_SBPSET, 0x00400000);
+        /* SPB hardware start(FIFOCTL source) */
+        siu_write32(base + SIU_SBACTIV, 0xc0000000);
+
+        return 0;
+}
+
+static void siu_dai_spbstop(struct siu_port *port_info)
+{
+        struct siu_info *info = siu_i2s_dai.private_data;
+        u32 __iomem *base = info->reg;
+
+        siu_write32(base + SIU_SBACTIV, 0);
+        /* SPB stop */
+        siu_write32(base + SIU_SBCTL, 0);
+
+        port_info->stfifo = 0;
+}
+
+/*              API functions           */
+
+/* Playback and capture hardware properties are identical */
+static struct snd_pcm_hardware siu_dai_pcm_hw = {
+        .info                   = SNDRV_PCM_INFO_INTERLEAVED,
+        .formats                = SNDRV_PCM_FMTBIT_S16,
+        .rates                  = SNDRV_PCM_RATE_8000_48000,
+        .rate_min               = 8000,
+        .rate_max               = 48000,
+        .channels_min           = 2,
+        .channels_max           = 2,
+        .buffer_bytes_max       = SIU_BUFFER_BYTES_MAX,
+        .period_bytes_min       = SIU_PERIOD_BYTES_MIN,
+        .period_bytes_max       = SIU_PERIOD_BYTES_MAX,
+        .periods_min            = SIU_PERIODS_MIN,
+        .periods_max            = SIU_PERIODS_MAX,
+};
+
+static int siu_dai_info_volume(struct snd_kcontrol *kctrl,
+                               struct snd_ctl_elem_info *uinfo)
+{
+        struct siu_port *port_info = snd_kcontrol_chip(kctrl);
+
+        dev_dbg(port_info->pcm->card->dev, "%s\n", __func__);
+
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+        uinfo->count = 2;
+        uinfo->value.integer.min = 0;
+        uinfo->value.integer.max = SIU_MAX_VOLUME;
+
+        return 0;
+}
+
+static int siu_dai_get_volume(struct snd_kcontrol *kctrl,
+                              struct snd_ctl_elem_value *ucontrol)
+{
+        struct siu_port *port_info = snd_kcontrol_chip(kctrl);
+        struct device *dev = port_info->pcm->card->dev;
+        u32 vol;
+
+        dev_dbg(dev, "%s\n", __func__);
+
+        switch (kctrl->private_value) {
+        case VOLUME_PLAYBACK:
+                /* Playback is always on port 0 */
+                vol = port_info->playback.volume;
+                ucontrol->value.integer.value[0] = vol & 0xffff;
+                ucontrol->value.integer.value[1] = vol >> 16 & 0xffff;
+                break;
+        case VOLUME_CAPTURE:
+                /* Capture is always on port 1 */
+                vol = port_info->capture.volume;
+                ucontrol->value.integer.value[0] = vol & 0xffff;
+                ucontrol->value.integer.value[1] = vol >> 16 & 0xffff;
+                break;
+        default:
+                dev_err(dev, "%s() invalid private_value=%ld\n",
+                        __func__, kctrl->private_value);
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int siu_dai_put_volume(struct snd_kcontrol *kctrl,
+                              struct snd_ctl_elem_value *ucontrol)
+{
+        struct siu_port *port_info = snd_kcontrol_chip(kctrl);
+        struct device *dev = port_info->pcm->card->dev;
+        struct siu_info *info = siu_i2s_dai.private_data;
+        u32 __iomem *base = info->reg;
+        u32 new_vol;
+        u32 cur_vol;
+
+        dev_dbg(dev, "%s\n", __func__);
+
+        if (ucontrol->value.integer.value[0] < 0 ||
+            ucontrol->value.integer.value[0] > SIU_MAX_VOLUME ||
+            ucontrol->value.integer.value[1] < 0 ||
+            ucontrol->value.integer.value[1] > SIU_MAX_VOLUME)
+                return -EINVAL;
+
+        new_vol = ucontrol->value.integer.value[0] |
+                ucontrol->value.integer.value[1] << 16;
+
+        /* See comment above - DSP firmware implementation */
+        switch (kctrl->private_value) {
+        case VOLUME_PLAYBACK:
+                /* Playback is always on port 0 */
+                cur_vol = port_info->playback.volume;
+                siu_write32(base + SIU_SBDVCA, new_vol);
+                port_info->playback.volume = new_vol;
+                break;
+        case VOLUME_CAPTURE:
+                /* Capture is always on port 1 */
+                cur_vol = port_info->capture.volume;
+                siu_write32(base + SIU_SBDVCB, new_vol);
+                port_info->capture.volume = new_vol;
+                break;
+        default:
+                dev_err(dev, "%s() invalid private_value=%ld\n",
+                        __func__, kctrl->private_value);
+                return -EINVAL;
+        }
+
+        if (cur_vol != new_vol)
+                return 1;
+
+        return 0;
+}
+
+static struct snd_kcontrol_new playback_controls = {
+        .iface          = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name           = "PCM Playback Volume",
+        .index          = 0,
+        .info           = siu_dai_info_volume,
+        .get            = siu_dai_get_volume,
+        .put            = siu_dai_put_volume,
+        .private_value  = VOLUME_PLAYBACK,
+};
+
+static struct snd_kcontrol_new capture_controls = {
+        .iface          = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name           = "PCM Capture Volume",
+        .index          = 0,
+        .info           = siu_dai_info_volume,
+        .get            = siu_dai_get_volume,
+        .put            = siu_dai_put_volume,
+        .private_value  = VOLUME_CAPTURE,
+};
+
+int siu_init_port(int port, struct siu_port **port_info, struct snd_card *card)
+{
+        struct device *dev = card->dev;
+        struct snd_kcontrol *kctrl;
+        int ret;
+
+        *port_info = kzalloc(sizeof(**port_info), GFP_KERNEL);
+        if (!*port_info)
+                return -ENOMEM;
+
+        dev_dbg(dev, "%s: port #%d@%p\n", __func__, port, *port_info);
+
+        (*port_info)->playback.volume = DFLT_VOLUME_LEVEL;
+        (*port_info)->capture.volume = DFLT_VOLUME_LEVEL;
+
+        /*
+         * Add mixer support. The SPB is used to change the volume. Both
+         * ports use the same SPB. Therefore, we only register one
+         * control instance since it will be used by both channels.
+         * In error case we continue without controls.
+         */
+        kctrl = snd_ctl_new1(&playback_controls, *port_info);
+        ret = snd_ctl_add(card, kctrl);
+        if (ret < 0)
+                dev_err(dev,
+                        "failed to add playback controls %p port=%d err=%d\n",
+                        kctrl, port, ret);
+
+        kctrl = snd_ctl_new1(&capture_controls, *port_info);
+        ret = snd_ctl_add(card, kctrl);
+        if (ret < 0)
+                dev_err(dev,
+                        "failed to add capture controls %p port=%d err=%d\n",
+                        kctrl, port, ret);
+
+        return 0;
+}
+
+void siu_free_port(struct siu_port *port_info)
+{
+        kfree(port_info);
+}
+
+static int siu_dai_startup(struct snd_pcm_substream *substream,
+                           struct snd_soc_dai *dai)
+{
+        struct siu_info *info = siu_i2s_dai.private_data;
+        struct snd_pcm_runtime *rt = substream->runtime;
+        struct siu_port *port_info = siu_port_info(substream);
+        int ret;
+
+        dev_dbg(substream->pcm->card->dev, "%s: port=%d@%p\n", __func__,
+                info->port_id, port_info);
+
+        snd_soc_set_runtime_hwparams(substream, &siu_dai_pcm_hw);
+
+        ret = snd_pcm_hw_constraint_integer(rt, SNDRV_PCM_HW_PARAM_PERIODS);
+        if (unlikely(ret < 0))
+                return ret;
+
+        siu_dai_start(port_info);
+
+        return 0;
+}
+
+static void siu_dai_shutdown(struct snd_pcm_substream *substream,
+                             struct snd_soc_dai *dai)
+{
+        struct siu_info *info = siu_i2s_dai.private_data;
+        struct siu_port *port_info = siu_port_info(substream);
+
+        dev_dbg(substream->pcm->card->dev, "%s: port=%d@%p\n", __func__,
+                info->port_id, port_info);
+
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+                port_info->play_cap &= ~PLAYBACK_ENABLED;
+        else
+                port_info->play_cap &= ~CAPTURE_ENABLED;
+
+        /* Stop the siu if the other stream is not using it */
+        if (!port_info->play_cap) {
+                /* during stmread or stmwrite ? */
+                BUG_ON(port_info->playback.rw_flg || port_info->capture.rw_flg);
+                siu_dai_spbstop(port_info);
+                siu_dai_stop();
+        }
+}
+
+/* PCM part of siu_dai_playback_prepare() / siu_dai_capture_prepare() */
+static int siu_dai_prepare(struct snd_pcm_substream *substream,
+                           struct snd_soc_dai *dai)
+{
+        struct siu_info *info = siu_i2s_dai.private_data;
+        struct snd_pcm_runtime *rt = substream->runtime;
+        struct siu_port *port_info = siu_port_info(substream);
+        struct siu_stream *siu_stream;
+        int self, ret;
+
+        dev_dbg(substream->pcm->card->dev,
+                "%s: port %d, active streams %lx, %d channels\n",
+                __func__, info->port_id, port_info->play_cap, rt->channels);
+
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+                self = PLAYBACK_ENABLED;
+                siu_stream = &port_info->playback;
+        } else {
+                self = CAPTURE_ENABLED;
+                siu_stream = &port_info->capture;
+        }
+
+        /* Set up the siu if not already done */
+        if (!port_info->play_cap) {
+                siu_stream->rw_flg = 0; /* stream-data transfer flag */
+
+                siu_dai_spbAselect(port_info);
+                siu_dai_spbBselect(port_info);
+
+                siu_dai_open(siu_stream);
+
+                siu_dai_pcmdatapack(siu_stream);
+
+                ret = siu_dai_spbstart(port_info);
+                if (ret < 0)
+                        goto fail;
+        }
+
+        port_info->play_cap |= self;
+
+fail:
+        return ret;
+}
+
+/*
+ * SIU can set bus format to I2S / PCM / SPDIF independently for playback and
+ * capture, however, the current API sets the bus format globally for a DAI.
+ */
+static int siu_dai_set_fmt(struct snd_soc_dai *dai,
+                           unsigned int fmt)
+{
+        struct siu_info *info = siu_i2s_dai.private_data;
+        u32 __iomem *base = info->reg;
+        u32 ifctl;
+
+        dev_dbg(dai->dev, "%s: fmt 0x%x on port %d\n",
+                __func__, fmt, info->port_id);
+
+        if (info->port_id < 0)
+                return -ENODEV;
+
+        /* Here select between I2S / PCM / SPDIF */
+        switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
+        case SND_SOC_DAIFMT_I2S:
+                ifctl = siu_flags[info->port_id].playback.i2s |
+                        siu_flags[info->port_id].capture.i2s;
+                break;
+        case SND_SOC_DAIFMT_LEFT_J:
+                ifctl = siu_flags[info->port_id].playback.pcm |
+                        siu_flags[info->port_id].capture.pcm;
+                break;
+        /* SPDIF disabled - see comment at the top */
+        default:
+                return -EINVAL;
+        }
+
+        ifctl |= ~(siu_flags[info->port_id].playback.mask |
+                   siu_flags[info->port_id].capture.mask) &
+                siu_read32(base + SIU_IFCTL);
+        siu_write32(base + SIU_IFCTL, ifctl);
+
+        return 0;
+}
+
+static int siu_dai_set_sysclk(struct snd_soc_dai *dai, int clk_id,
+                              unsigned int freq, int dir)
+{
+        struct clk *siu_clk, *parent_clk;
+        char *siu_name, *parent_name;
+        int ret;
+
+        if (dir != SND_SOC_CLOCK_IN)
+                return -EINVAL;
+
+        dev_dbg(dai->dev, "%s: using clock %d\n", __func__, clk_id);
+
+        switch (clk_id) {
+        case SIU_CLKA_PLL:
+                siu_name = "siua_clk";
+                parent_name = "pll_clk";
+                break;
+        case SIU_CLKA_EXT:
+                siu_name = "siua_clk";
+                parent_name = "siumcka_clk";
+                break;
+        case SIU_CLKB_PLL:
+                siu_name = "siub_clk";
+                parent_name = "pll_clk";
+                break;
+        case SIU_CLKB_EXT:
+                siu_name = "siub_clk";
+                parent_name = "siumckb_clk";
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        siu_clk = clk_get(siu_i2s_dai.dev, siu_name);
+        if (IS_ERR(siu_clk))
+                return PTR_ERR(siu_clk);
+
+        parent_clk = clk_get(siu_i2s_dai.dev, parent_name);
+        if (!IS_ERR(parent_clk)) {
+                ret = clk_set_parent(siu_clk, parent_clk);
+                if (!ret)
+                        clk_set_rate(siu_clk, freq);
+                clk_put(parent_clk);
+        }
+
+        clk_put(siu_clk);
+
+        return 0;
+}
+
+static struct snd_soc_dai_ops siu_dai_ops = {
+        .startup        = siu_dai_startup,
+        .shutdown       = siu_dai_shutdown,
+        .prepare        = siu_dai_prepare,
+        .set_sysclk     = siu_dai_set_sysclk,
+        .set_fmt        = siu_dai_set_fmt,
+};
+
+struct snd_soc_dai siu_i2s_dai = {
+        .name = "sh-siu",
+        .id = 0,
+        .playback = {
+                .channels_min = 2,
+                .channels_max = 2,
+                .formats = SNDRV_PCM_FMTBIT_S16,
+                .rates = SNDRV_PCM_RATE_8000_48000,
+        },
+        .capture = {
+                .channels_min = 2,
+                .channels_max = 2,
+                .formats = SNDRV_PCM_FMTBIT_S16,
+                .rates = SNDRV_PCM_RATE_8000_48000,
+         },
+        .ops = &siu_dai_ops,
+};
+EXPORT_SYMBOL_GPL(siu_i2s_dai);
+
+static int __devinit siu_probe(struct platform_device *pdev)
+{
+        const struct firmware *fw_entry;
+        struct resource *res, *region;
+        struct siu_info *info;
+        int ret;
+
+        info = kmalloc(sizeof(*info), GFP_KERNEL);
+        if (!info)
+                return -ENOMEM;
+
+        ret = request_firmware(&fw_entry, "siu_spb.bin", &pdev->dev);
+        if (ret)
+                goto ereqfw;
+
+        /*
+         * Loaded firmware is "const" - read only, but we have to modify it in
+         * snd_siu_sh7343_spbAselect() and snd_siu_sh7343_spbBselect()
+         */
+        memcpy(&info->fw, fw_entry->data, fw_entry->size);
+
+        release_firmware(fw_entry);
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                ret = -ENODEV;
+                goto egetres;
+        }
+
+        region = request_mem_region(res->start, resource_size(res),
+                                    pdev->name);
+        if (!region) {
+                dev_err(&pdev->dev, "SIU region already claimed\n");
+                ret = -EBUSY;
+                goto ereqmemreg;
+        }
+
+        ret = -ENOMEM;
+        info->pram = ioremap(res->start, PRAM_SIZE);
+        if (!info->pram)
+                goto emappram;
+        info->xram = ioremap(res->start + XRAM_OFFSET, XRAM_SIZE);
+        if (!info->xram)
+                goto emapxram;
+        info->yram = ioremap(res->start + YRAM_OFFSET, YRAM_SIZE);
+        if (!info->yram)
+                goto emapyram;
+        info->reg = ioremap(res->start + REG_OFFSET, resource_size(res) -
+                            REG_OFFSET);
+        if (!info->reg)
+                goto emapreg;
+
+        siu_i2s_dai.dev = &pdev->dev;
+        siu_i2s_dai.private_data = info;
+
+        ret = snd_soc_register_dais(&siu_i2s_dai, 1);
+        if (ret < 0)
+                goto edaiinit;
+
+        ret = snd_soc_register_platform(&siu_platform);
+        if (ret < 0)
+                goto esocregp;
+
+        pm_runtime_enable(&pdev->dev);
+
+        return ret;
+
+esocregp:
+        snd_soc_unregister_dais(&siu_i2s_dai, 1);
+edaiinit:
+        iounmap(info->reg);
+emapreg:
+        iounmap(info->yram);
+emapyram:
+        iounmap(info->xram);
+emapxram:
+        iounmap(info->pram);
+emappram:
+        release_mem_region(res->start, resource_size(res));
+ereqmemreg:
+egetres:
+ereqfw:
+        kfree(info);
+
+        return ret;
+}
+
+static int __devexit siu_remove(struct platform_device *pdev)
+{
+        struct siu_info *info = siu_i2s_dai.private_data;
+        struct resource *res;
+
+        pm_runtime_disable(&pdev->dev);
+
+        snd_soc_unregister_platform(&siu_platform);
+        snd_soc_unregister_dais(&siu_i2s_dai, 1);
+
+        iounmap(info->reg);
+        iounmap(info->yram);
+        iounmap(info->xram);
+        iounmap(info->pram);
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (res)
+                release_mem_region(res->start, resource_size(res));
+        kfree(info);
+
+        return 0;
+}
+
+static struct platform_driver siu_driver = {
+        .driver         = {
+                .name   = "sh_siu",
+        },
+        .probe          = siu_probe,
+        .remove         = __devexit_p(siu_remove),
+};
+
+static int __init siu_init(void)
+{
+        return platform_driver_register(&siu_driver);
+}
+
+static void __exit siu_exit(void)
+{
+        platform_driver_unregister(&siu_driver);
+}
+
+module_init(siu_init)
+module_exit(siu_exit)
+
+MODULE_AUTHOR("Carlos Munoz <carlos@kenati.com>");
+MODULE_DESCRIPTION("ALSA SoC SH7722 SIU driver");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/sh/siu_pcm.c b/sound/soc/sh/siu_pcm.c
new file mode 100644
index 000000000000..8f85719212f9
--- /dev/null
+++ b/sound/soc/sh/siu_pcm.c
@@ -0,0 +1,615 @@
+/*
+ * siu_pcm.c - ALSA driver for Renesas SH7343, SH7722 SIU peripheral.
+ *
+ * Copyright (C) 2009-2010 Guennadi Liakhovetski <g.liakhovetski@gmx.de>
+ * Copyright (C) 2006 Carlos Munoz <carlos@kenati.com>
+ *
+ * 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
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#include <linux/delay.h>
+#include <linux/dma-mapping.h>
+#include <linux/dmaengine.h>
+#include <linux/interrupt.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+
+#include <sound/control.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/soc-dai.h>
+
+#include <asm/dmaengine.h>
+#include <asm/siu.h>
+
+#include "siu.h"
+
+#define GET_MAX_PERIODS(buf_bytes, period_bytes) \
+                                ((buf_bytes) / (period_bytes))
+#define PERIOD_OFFSET(buf_addr, period_num, period_bytes) \
+                                ((buf_addr) + ((period_num) * (period_bytes)))
+
+#define RWF_STM_RD              0x01            /* Read in progress */
+#define RWF_STM_WT              0x02            /* Write in progress */
+
+struct siu_port *siu_ports[SIU_PORT_NUM];
+
+/* transfersize is number of u32 dma transfers per period */
+static int siu_pcm_stmwrite_stop(struct siu_port *port_info)
+{
+        struct siu_info *info = siu_i2s_dai.private_data;
+        u32 __iomem *base = info->reg;
+        struct siu_stream *siu_stream = &port_info->playback;
+        u32 stfifo;
+
+        if (!siu_stream->rw_flg)
+                return -EPERM;
+
+        /* output FIFO disable */
+        stfifo = siu_read32(base + SIU_STFIFO);
+        siu_write32(base + SIU_STFIFO, stfifo & ~0x0c180c18);
+        pr_debug("%s: STFIFO %x -> %x\n", __func__,
+                 stfifo, stfifo & ~0x0c180c18);
+
+        /* during stmwrite clear */
+        siu_stream->rw_flg = 0;
+
+        return 0;
+}
+
+static int siu_pcm_stmwrite_start(struct siu_port *port_info)
+{
+        struct siu_stream *siu_stream = &port_info->playback;
+
+        if (siu_stream->rw_flg)
+                return -EPERM;
+
+        /* Current period in buffer */
+        port_info->playback.cur_period = 0;
+
+        /* during stmwrite flag set */
+        siu_stream->rw_flg = RWF_STM_WT;
+
+        /* DMA transfer start */
+        tasklet_schedule(&siu_stream->tasklet);
+
+        return 0;
+}
+
+static void siu_dma_tx_complete(void *arg)
+{
+        struct siu_stream *siu_stream = arg;
+
+        if (!siu_stream->rw_flg)
+                return;
+
+        /* Update completed period count */
+        if (++siu_stream->cur_period >=
+            GET_MAX_PERIODS(siu_stream->buf_bytes,
+                            siu_stream->period_bytes))
+                siu_stream->cur_period = 0;
+
+        pr_debug("%s: done period #%d (%u/%u bytes), cookie %d\n",
+                __func__, siu_stream->cur_period,
+                siu_stream->cur_period * siu_stream->period_bytes,
+                siu_stream->buf_bytes, siu_stream->cookie);
+
+        tasklet_schedule(&siu_stream->tasklet);
+
+        /* Notify alsa: a period is done */
+        snd_pcm_period_elapsed(siu_stream->substream);
+}
+
+static int siu_pcm_wr_set(struct siu_port *port_info,
+                          dma_addr_t buff, u32 size)
+{
+        struct siu_info *info = siu_i2s_dai.private_data;
+        u32 __iomem *base = info->reg;
+        struct siu_stream *siu_stream = &port_info->playback;
+        struct snd_pcm_substream *substream = siu_stream->substream;
+        struct device *dev = substream->pcm->card->dev;
+        struct dma_async_tx_descriptor *desc;
+        dma_cookie_t cookie;
+        struct scatterlist sg;
+        u32 stfifo;
+
+        sg_init_table(&sg, 1);
+        sg_set_page(&sg, pfn_to_page(PFN_DOWN(buff)),
+                    size, offset_in_page(buff));
+        sg_dma_address(&sg) = buff;
+
+        desc = siu_stream->chan->device->device_prep_slave_sg(siu_stream->chan,
+                &sg, 1, DMA_TO_DEVICE, DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
+        if (!desc) {
+                dev_err(dev, "Failed to allocate a dma descriptor\n");
+                return -ENOMEM;
+        }
+
+        desc->callback = siu_dma_tx_complete;
+        desc->callback_param = siu_stream;
+        cookie = desc->tx_submit(desc);
+        if (cookie < 0) {
+                dev_err(dev, "Failed to submit a dma transfer\n");
+                return cookie;
+        }
+
+        siu_stream->tx_desc = desc;
+        siu_stream->cookie = cookie;
+
+        dma_async_issue_pending(siu_stream->chan);
+
+        /* only output FIFO enable */
+        stfifo = siu_read32(base + SIU_STFIFO);
+        siu_write32(base + SIU_STFIFO, stfifo | (port_info->stfifo & 0x0c180c18));
+        dev_dbg(dev, "%s: STFIFO %x -> %x\n", __func__,
+                stfifo, stfifo | (port_info->stfifo & 0x0c180c18));
+
+        return 0;
+}
+
+static int siu_pcm_rd_set(struct siu_port *port_info,
+                          dma_addr_t buff, size_t size)
+{
+        struct siu_info *info = siu_i2s_dai.private_data;
+        u32 __iomem *base = info->reg;
+        struct siu_stream *siu_stream = &port_info->capture;
+        struct snd_pcm_substream *substream = siu_stream->substream;
+        struct device *dev = substream->pcm->card->dev;
+        struct dma_async_tx_descriptor *desc;
+        dma_cookie_t cookie;
+        struct scatterlist sg;
+        u32 stfifo;
+
+        dev_dbg(dev, "%s: %u@%llx\n", __func__, size, (unsigned long long)buff);
+
+        sg_init_table(&sg, 1);
+        sg_set_page(&sg, pfn_to_page(PFN_DOWN(buff)),
+                    size, offset_in_page(buff));
+        sg_dma_address(&sg) = buff;
+
+        desc = siu_stream->chan->device->device_prep_slave_sg(siu_stream->chan,
+                &sg, 1, DMA_FROM_DEVICE, DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
+        if (!desc) {
+                dev_err(dev, "Failed to allocate dma descriptor\n");
+                return -ENOMEM;
+        }
+
+        desc->callback = siu_dma_tx_complete;
+        desc->callback_param = siu_stream;
+        cookie = desc->tx_submit(desc);
+        if (cookie < 0) {
+                dev_err(dev, "Failed to submit dma descriptor\n");
+                return cookie;
+        }
+
+        siu_stream->tx_desc = desc;
+        siu_stream->cookie = cookie;
+
+        dma_async_issue_pending(siu_stream->chan);
+
+        /* only input FIFO enable */
+        stfifo = siu_read32(base + SIU_STFIFO);
+        siu_write32(base + SIU_STFIFO, siu_read32(base + SIU_STFIFO) |
+                    (port_info->stfifo & 0x13071307));
+        dev_dbg(dev, "%s: STFIFO %x -> %x\n", __func__,
+                stfifo, stfifo | (port_info->stfifo & 0x13071307));
+
+        return 0;
+}
+
+static void siu_io_tasklet(unsigned long data)
+{
+        struct siu_stream *siu_stream = (struct siu_stream *)data;
+        struct snd_pcm_substream *substream = siu_stream->substream;
+        struct device *dev = substream->pcm->card->dev;
+        struct snd_pcm_runtime *rt = substream->runtime;
+        struct siu_port *port_info = siu_port_info(substream);
+
+        dev_dbg(dev, "%s: flags %x\n", __func__, siu_stream->rw_flg);
+
+        if (!siu_stream->rw_flg) {
+                dev_dbg(dev, "%s: stream inactive\n", __func__);
+                return;
+        }
+
+        if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
+                dma_addr_t buff;
+                size_t count;
+                u8 *virt;
+
+                buff = (dma_addr_t)PERIOD_OFFSET(rt->dma_addr,
+                                                siu_stream->cur_period,
+                                                siu_stream->period_bytes);
+                virt = PERIOD_OFFSET(rt->dma_area,
+                                     siu_stream->cur_period,
+                                     siu_stream->period_bytes);
+                count = siu_stream->period_bytes;
+
+                /* DMA transfer start */
+                siu_pcm_rd_set(port_info, buff, count);
+        } else {
+                siu_pcm_wr_set(port_info,
+                               (dma_addr_t)PERIOD_OFFSET(rt->dma_addr,
+                                                siu_stream->cur_period,
+                                                siu_stream->period_bytes),
+                               siu_stream->period_bytes);
+        }
+}
+
+/* Capture */
+static int siu_pcm_stmread_start(struct siu_port *port_info)
+{
+        struct siu_stream *siu_stream = &port_info->capture;
+
+        if (siu_stream->xfer_cnt > 0x1000000)
+                return -EINVAL;
+        if (siu_stream->rw_flg)
+                return -EPERM;
+
+        /* Current period in buffer */
+        siu_stream->cur_period = 0;
+
+        /* during stmread flag set */
+        siu_stream->rw_flg = RWF_STM_RD;
+
+        tasklet_schedule(&siu_stream->tasklet);
+
+        return 0;
+}
+
+static int siu_pcm_stmread_stop(struct siu_port *port_info)
+{
+        struct siu_info *info = siu_i2s_dai.private_data;
+        u32 __iomem *base = info->reg;
+        struct siu_stream *siu_stream = &port_info->capture;
+        struct device *dev = siu_stream->substream->pcm->card->dev;
+        u32 stfifo;
+
+        if (!siu_stream->rw_flg)
+                return -EPERM;
+
+        /* input FIFO disable */
+        stfifo = siu_read32(base + SIU_STFIFO);
+        siu_write32(base + SIU_STFIFO, stfifo & ~0x13071307);
+        dev_dbg(dev, "%s: STFIFO %x -> %x\n", __func__,
+                stfifo, stfifo & ~0x13071307);
+
+        /* during stmread flag clear */
+        siu_stream->rw_flg = 0;
+
+        return 0;
+}
+
+static int siu_pcm_hw_params(struct snd_pcm_substream *ss,
+                             struct snd_pcm_hw_params *hw_params)
+{
+        struct siu_info *info = siu_i2s_dai.private_data;
+        struct device *dev = ss->pcm->card->dev;
+        int ret;
+
+        dev_dbg(dev, "%s: port=%d\n", __func__, info->port_id);
+
+        ret = snd_pcm_lib_malloc_pages(ss, params_buffer_bytes(hw_params));
+        if (ret < 0)
+                dev_err(dev, "snd_pcm_lib_malloc_pages() failed\n");
+
+        return ret;
+}
+
+static int siu_pcm_hw_free(struct snd_pcm_substream *ss)
+{
+        struct siu_info *info = siu_i2s_dai.private_data;
+        struct siu_port *port_info = siu_port_info(ss);
+        struct device *dev = ss->pcm->card->dev;
+        struct siu_stream *siu_stream;
+
+        if (ss->stream == SNDRV_PCM_STREAM_PLAYBACK)
+                siu_stream = &port_info->playback;
+        else
+                siu_stream = &port_info->capture;
+
+        dev_dbg(dev, "%s: port=%d\n", __func__, info->port_id);
+
+        return snd_pcm_lib_free_pages(ss);
+}
+
+static bool filter(struct dma_chan *chan, void *slave)
+{
+        struct sh_dmae_slave *param = slave;
+
+        pr_debug("%s: slave ID %d\n", __func__, param->slave_id);
+
+        if (unlikely(param->dma_dev != chan->device->dev))
+                return false;
+
+        chan->private = param;
+        return true;
+}
+
+static int siu_pcm_open(struct snd_pcm_substream *ss)
+{
+        /* Playback / Capture */
+        struct siu_info *info = siu_i2s_dai.private_data;
+        struct siu_port *port_info = siu_port_info(ss);
+        struct siu_stream *siu_stream;
+        u32 port = info->port_id;
+        struct siu_platform *pdata = siu_i2s_dai.dev->platform_data;
+        struct device *dev = ss->pcm->card->dev;
+        dma_cap_mask_t mask;
+        struct sh_dmae_slave *param;
+
+        dma_cap_zero(mask);
+        dma_cap_set(DMA_SLAVE, mask);
+
+        dev_dbg(dev, "%s, port=%d@%p\n", __func__, port, port_info);
+
+        if (ss->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+                siu_stream = &port_info->playback;
+                param = &siu_stream->param;
+                param->slave_id = port ? SHDMA_SLAVE_SIUB_TX :
+                        SHDMA_SLAVE_SIUA_TX;
+        } else {
+                siu_stream = &port_info->capture;
+                param = &siu_stream->param;
+                param->slave_id = port ? SHDMA_SLAVE_SIUB_RX :
+                        SHDMA_SLAVE_SIUA_RX;
+        }
+
+        param->dma_dev = pdata->dma_dev;
+        /* Get DMA channel */
+        siu_stream->chan = dma_request_channel(mask, filter, param);
+        if (!siu_stream->chan) {
+                dev_err(dev, "DMA channel allocation failed!\n");
+                return -EBUSY;
+        }
+
+        siu_stream->substream = ss;
+
+        return 0;
+}
+
+static int siu_pcm_close(struct snd_pcm_substream *ss)
+{
+        struct siu_info *info = siu_i2s_dai.private_data;
+        struct device *dev = ss->pcm->card->dev;
+        struct siu_port *port_info = siu_port_info(ss);
+        struct siu_stream *siu_stream;
+
+        dev_dbg(dev, "%s: port=%d\n", __func__, info->port_id);
+
+        if (ss->stream == SNDRV_PCM_STREAM_PLAYBACK)
+                siu_stream = &port_info->playback;
+        else
+                siu_stream = &port_info->capture;
+
+        dma_release_channel(siu_stream->chan);
+        siu_stream->chan = NULL;
+
+        siu_stream->substream = NULL;
+
+        return 0;
+}
+
+static int siu_pcm_prepare(struct snd_pcm_substream *ss)
+{
+        struct siu_info *info = siu_i2s_dai.private_data;
+        struct siu_port *port_info = siu_port_info(ss);
+        struct device *dev = ss->pcm->card->dev;
+        struct snd_pcm_runtime  *rt = ss->runtime;
+        struct siu_stream *siu_stream;
+        snd_pcm_sframes_t xfer_cnt;
+
+        if (ss->stream == SNDRV_PCM_STREAM_PLAYBACK)
+                siu_stream = &port_info->playback;
+        else
+                siu_stream = &port_info->capture;
+
+        rt = siu_stream->substream->runtime;
+
+        siu_stream->buf_bytes = snd_pcm_lib_buffer_bytes(ss);
+        siu_stream->period_bytes = snd_pcm_lib_period_bytes(ss);
+
+        dev_dbg(dev, "%s: port=%d, %d channels, period=%u bytes\n", __func__,
+                info->port_id, rt->channels, siu_stream->period_bytes);
+
+        /* We only support buffers that are multiples of the period */
+        if (siu_stream->buf_bytes % siu_stream->period_bytes) {
+                dev_err(dev, "%s() - buffer=%d not multiple of period=%d\n",
+                       __func__, siu_stream->buf_bytes,
+                       siu_stream->period_bytes);
+                return -EINVAL;
+        }
+
+        xfer_cnt = bytes_to_frames(rt, siu_stream->period_bytes);
+        if (!xfer_cnt || xfer_cnt > 0x1000000)
+                return -EINVAL;
+
+        siu_stream->format = rt->format;
+        siu_stream->xfer_cnt = xfer_cnt;
+
+        dev_dbg(dev, "port=%d buf=%lx buf_bytes=%d period_bytes=%d "
+                "format=%d channels=%d xfer_cnt=%d\n", info->port_id,
+                (unsigned long)rt->dma_addr, siu_stream->buf_bytes,
+                siu_stream->period_bytes,
+                siu_stream->format, rt->channels, (int)xfer_cnt);
+
+        return 0;
+}
+
+static int siu_pcm_trigger(struct snd_pcm_substream *ss, int cmd)
+{
+        struct siu_info *info = siu_i2s_dai.private_data;
+        struct device *dev = ss->pcm->card->dev;
+        struct siu_port *port_info = siu_port_info(ss);
+        int ret;
+
+        dev_dbg(dev, "%s: port=%d@%p, cmd=%d\n", __func__,
+                info->port_id, port_info, cmd);
+
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+                if (ss->stream == SNDRV_PCM_STREAM_PLAYBACK)
+                        ret = siu_pcm_stmwrite_start(port_info);
+                else
+                        ret = siu_pcm_stmread_start(port_info);
+
+                if (ret < 0)
+                        dev_warn(dev, "%s: start failed on port=%d\n",
+                                 __func__, info->port_id);
+
+                break;
+        case SNDRV_PCM_TRIGGER_STOP:
+                if (ss->stream == SNDRV_PCM_STREAM_PLAYBACK)
+                        siu_pcm_stmwrite_stop(port_info);
+                else
+                        siu_pcm_stmread_stop(port_info);
+                ret = 0;
+
+                break;
+        default:
+                dev_err(dev, "%s() unsupported cmd=%d\n", __func__, cmd);
+                ret = -EINVAL;
+        }
+
+        return ret;
+}
+
+/*
+ * So far only resolution of one period is supported, subject to extending the
+ * dmangine API
+ */
+static snd_pcm_uframes_t siu_pcm_pointer_dma(struct snd_pcm_substream *ss)
+{
+        struct device *dev = ss->pcm->card->dev;
+        struct siu_info *info = siu_i2s_dai.private_data;
+        u32 __iomem *base = info->reg;
+        struct siu_port *port_info = siu_port_info(ss);
+        struct snd_pcm_runtime *rt = ss->runtime;
+        size_t ptr;
+        struct siu_stream *siu_stream;
+
+        if (ss->stream == SNDRV_PCM_STREAM_PLAYBACK)
+                siu_stream = &port_info->playback;
+        else
+                siu_stream = &port_info->capture;
+
+        /*
+         * ptr is the offset into the buffer where the dma is currently at. We
+         * check if the dma buffer has just wrapped.
+         */
+        ptr = PERIOD_OFFSET(rt->dma_addr,
+                            siu_stream->cur_period,
+                            siu_stream->period_bytes) - rt->dma_addr;
+
+        dev_dbg(dev,
+                "%s: port=%d, events %x, FSTS %x, xferred %u/%u, cookie %d\n",
+                __func__, info->port_id, siu_read32(base + SIU_EVNTC),
+                siu_read32(base + SIU_SBFSTS), ptr, siu_stream->buf_bytes,
+                siu_stream->cookie);
+
+        if (ptr >= siu_stream->buf_bytes)
+                ptr = 0;
+
+        return bytes_to_frames(ss->runtime, ptr);
+}
+
+static int siu_pcm_new(struct snd_card *card, struct snd_soc_dai *dai,
+                       struct snd_pcm *pcm)
+{
+        /* card->dev == socdev->dev, see snd_soc_new_pcms() */
+        struct siu_info *info = siu_i2s_dai.private_data;
+        struct platform_device *pdev = to_platform_device(card->dev);
+        int ret;
+        int i;
+
+        /* pdev->id selects between SIUA and SIUB */
+        if (pdev->id < 0 || pdev->id >= SIU_PORT_NUM)
+                return -EINVAL;
+
+        info->port_id = pdev->id;
+
+        /*
+         * While the siu has 2 ports, only one port can be on at a time (only 1
+         * SPB). So far all the boards using the siu had only one of the ports
+         * wired to a codec. To simplify things, we only register one port with
+         * alsa. In case both ports are needed, it should be changed here
+         */
+        for (i = pdev->id; i < pdev->id + 1; i++) {
+                struct siu_port **port_info = &siu_ports[i];
+
+                ret = siu_init_port(i, port_info, card);
+                if (ret < 0)
+                        return ret;
+
+                ret = snd_pcm_lib_preallocate_pages_for_all(pcm,
+                                SNDRV_DMA_TYPE_DEV, NULL,
+                                SIU_BUFFER_BYTES_MAX, SIU_BUFFER_BYTES_MAX);
+                if (ret < 0) {
+                        dev_err(card->dev,
+                               "snd_pcm_lib_preallocate_pages_for_all() err=%d",
+                                ret);
+                        goto fail;
+                }
+
+                (*port_info)->pcm = pcm;
+
+                /* IO tasklets */
+                tasklet_init(&(*port_info)->playback.tasklet, siu_io_tasklet,
+                             (unsigned long)&(*port_info)->playback);
+                tasklet_init(&(*port_info)->capture.tasklet, siu_io_tasklet,
+                             (unsigned long)&(*port_info)->capture);
+        }
+
+        dev_info(card->dev, "SuperH SIU driver initialized.\n");
+        return 0;
+
+fail:
+        siu_free_port(siu_ports[pdev->id]);
+        dev_err(card->dev, "SIU: failed to initialize.\n");
+        return ret;
+}
+
+static void siu_pcm_free(struct snd_pcm *pcm)
+{
+        struct platform_device *pdev = to_platform_device(pcm->card->dev);
+        struct siu_port *port_info = siu_ports[pdev->id];
+
+        tasklet_kill(&port_info->capture.tasklet);
+        tasklet_kill(&port_info->playback.tasklet);
+
+        siu_free_port(port_info);
+        snd_pcm_lib_preallocate_free_for_all(pcm);
+
+        dev_dbg(pcm->card->dev, "%s\n", __func__);
+}
+
+static struct snd_pcm_ops siu_pcm_ops = {
+        .open           = siu_pcm_open,
+        .close          = siu_pcm_close,
+        .ioctl          = snd_pcm_lib_ioctl,
+        .hw_params      = siu_pcm_hw_params,
+        .hw_free        = siu_pcm_hw_free,
+        .prepare        = siu_pcm_prepare,
+        .trigger        = siu_pcm_trigger,
+        .pointer        = siu_pcm_pointer_dma,
+};
+
+struct snd_soc_platform siu_platform = {
+        .name           = "siu-audio",
+        .pcm_ops        = &siu_pcm_ops,
+        .pcm_new        = siu_pcm_new,
+        .pcm_free       = siu_pcm_free,
+};
+EXPORT_SYMBOL_GPL(siu_platform);
diff --git a/sound/soc/soc-cache.c b/sound/soc/soc-cache.c
index c8ceddc2a26c..5869dc3be781 100644
--- a/sound/soc/soc-cache.c
+++ b/sound/soc/soc-cache.c
@@ -15,6 +15,74 @@
 #include <linux/spi/spi.h>
 #include <sound/soc.h>
 
+static unsigned int snd_soc_4_12_read(struct snd_soc_codec *codec,
+                                     unsigned int reg)
+{
+        u16 *cache = codec->reg_cache;
+        if (reg >= codec->reg_cache_size)
+                return -1;
+        return cache[reg];
+}
+
+static int snd_soc_4_12_write(struct snd_soc_codec *codec, unsigned int reg,
+                             unsigned int value)
+{
+        u16 *cache = codec->reg_cache;
+        u8 data[2];
+        int ret;
+
+        BUG_ON(codec->volatile_register);
+
+        data[0] = (reg << 4) | ((value >> 8) & 0x000f);
+        data[1] = value & 0x00ff;
+
+        if (reg < codec->reg_cache_size)
+                cache[reg] = value;
+
+        if (codec->cache_only) {
+                codec->cache_sync = 1;
+                return 0;
+        }
+
+        ret = codec->hw_write(codec->control_data, data, 2);
+        if (ret == 2)
+                return 0;
+        if (ret < 0)
+                return ret;
+        else
+                return -EIO;
+}
+
+#if defined(CONFIG_SPI_MASTER)
+static int snd_soc_4_12_spi_write(void *control_data, const char *data,
+                                 int len)
+{
+        struct spi_device *spi = control_data;
+        struct spi_transfer t;
+        struct spi_message m;
+        u8 msg[2];
+
+        if (len <= 0)
+                return 0;
+
+        msg[0] = data[1];
+        msg[1] = data[0];
+
+        spi_message_init(&m);
+        memset(&t, 0, (sizeof t));
+
+        t.tx_buf = &msg[0];
+        t.len = len;
+
+        spi_message_add_tail(&t, &m);
+        spi_sync(spi, &m);
+
+        return len;
+}
+#else
+#define snd_soc_4_12_spi_write NULL
+#endif
+
 static unsigned int snd_soc_7_9_read(struct snd_soc_codec *codec,
                                      unsigned int reg)
 {
@@ -38,6 +106,12 @@ static int snd_soc_7_9_write(struct snd_soc_codec *codec, unsigned int reg,
 
         if (reg < codec->reg_cache_size)
                 cache[reg] = value;
+
+        if (codec->cache_only) {
+                codec->cache_sync = 1;
+                return 0;
+        }
+
         ret = codec->hw_write(codec->control_data, data, 2);
         if (ret == 2)
                 return 0;
@@ -77,6 +151,40 @@ static int snd_soc_7_9_spi_write(void *control_data, const char *data,
 #define snd_soc_7_9_spi_write NULL
 #endif
 
+static int snd_soc_8_8_write(struct snd_soc_codec *codec, unsigned int reg,
+                             unsigned int value)
+{
+        u8 *cache = codec->reg_cache;
+        u8 data[2];
+
+        BUG_ON(codec->volatile_register);
+
+        data[0] = reg & 0xff;
+        data[1] = value & 0xff;
+
+        if (reg < codec->reg_cache_size)
+                cache[reg] = value;
+
+        if (codec->cache_only) {
+                codec->cache_sync = 1;
+                return 0;
+        }
+
+        if (codec->hw_write(codec->control_data, data, 2) == 2)
+                return 0;
+        else
+                return -EIO;
+}
+
+static unsigned int snd_soc_8_8_read(struct snd_soc_codec *codec,
+                                     unsigned int reg)
+{
+        u8 *cache = codec->reg_cache;
+        if (reg >= codec->reg_cache_size)
+                return -1;
+        return cache[reg];
+}
+
 static int snd_soc_8_16_write(struct snd_soc_codec *codec, unsigned int reg,
                               unsigned int value)
 {
@@ -90,6 +198,11 @@ static int snd_soc_8_16_write(struct snd_soc_codec *codec, unsigned int reg,
         if (!snd_soc_codec_volatile_register(codec, reg))
                 reg_cache[reg] = value;
 
+        if (codec->cache_only) {
+                codec->cache_sync = 1;
+                return 0;
+        }
+
         if (codec->hw_write(codec->control_data, data, 3) == 3)
                 return 0;
         else
@@ -102,10 +215,14 @@ static unsigned int snd_soc_8_16_read(struct snd_soc_codec *codec,
         u16 *cache = codec->reg_cache;
 
         if (reg >= codec->reg_cache_size ||
-            snd_soc_codec_volatile_register(codec, reg))
+            snd_soc_codec_volatile_register(codec, reg)) {
+                if (codec->cache_only)
+                        return -EINVAL;
+
                 return codec->hw_read(codec, reg);
-        else
+        } else {
                 return cache[reg];
+        }
 }
 
 #if defined(CONFIG_I2C) || (defined(CONFIG_I2C_MODULE) && defined(MODULE))
@@ -142,6 +259,114 @@ static unsigned int snd_soc_8_16_read_i2c(struct snd_soc_codec *codec,
 #define snd_soc_8_16_read_i2c NULL
 #endif
 
+#if defined(CONFIG_I2C) || (defined(CONFIG_I2C_MODULE) && defined(MODULE))
+static unsigned int snd_soc_16_8_read_i2c(struct snd_soc_codec *codec,
+                                          unsigned int r)
+{
+        struct i2c_msg xfer[2];
+        u16 reg = r;
+        u8 data;
+        int ret;
+        struct i2c_client *client = codec->control_data;
+
+        /* Write register */
+        xfer[0].addr = client->addr;
+        xfer[0].flags = 0;
+        xfer[0].len = 2;
+        xfer[0].buf = (u8 *)&reg;
+
+        /* Read data */
+        xfer[1].addr = client->addr;
+        xfer[1].flags = I2C_M_RD;
+        xfer[1].len = 1;
+        xfer[1].buf = &data;
+
+        ret = i2c_transfer(client->adapter, xfer, 2);
+        if (ret != 2) {
+                dev_err(&client->dev, "i2c_transfer() returned %d\n", ret);
+                return 0;
+        }
+
+        return data;
+}
+#else
+#define snd_soc_16_8_read_i2c NULL
+#endif
+
+static unsigned int snd_soc_16_8_read(struct snd_soc_codec *codec,
+                                     unsigned int reg)
+{
+        u16 *cache = codec->reg_cache;
+
+        reg &= 0xff;
+        if (reg >= codec->reg_cache_size)
+                return -1;
+        return cache[reg];
+}
+
+static int snd_soc_16_8_write(struct snd_soc_codec *codec, unsigned int reg,
+                             unsigned int value)
+{
+        u16 *cache = codec->reg_cache;
+        u8 data[3];
+        int ret;
+
+        BUG_ON(codec->volatile_register);
+
+        data[0] = (reg >> 8) & 0xff;
+        data[1] = reg & 0xff;
+        data[2] = value;
+
+        reg &= 0xff;
+        if (reg < codec->reg_cache_size)
+                cache[reg] = value;
+
+        if (codec->cache_only) {
+                codec->cache_sync = 1;
+                return 0;
+        }
+
+        ret = codec->hw_write(codec->control_data, data, 3);
+        if (ret == 3)
+                return 0;
+        if (ret < 0)
+                return ret;
+        else
+                return -EIO;
+}
+
+#if defined(CONFIG_SPI_MASTER)
+static int snd_soc_16_8_spi_write(void *control_data, const char *data,
+                                 int len)
+{
+        struct spi_device *spi = control_data;
+        struct spi_transfer t;
+        struct spi_message m;
+        u8 msg[3];
+
+        if (len <= 0)
+                return 0;
+
+        msg[0] = data[0];
+        msg[1] = data[1];
+        msg[2] = data[2];
+
+        spi_message_init(&m);
+        memset(&t, 0, (sizeof t));
+
+        t.tx_buf = &msg[0];
+        t.len = len;
+
+        spi_message_add_tail(&t, &m);
+        spi_sync(spi, &m);
+
+        return len;
+}
+#else
+#define snd_soc_16_8_spi_write NULL
+#endif
+
+
 static struct {
         int addr_bits;
         int data_bits;
@@ -150,9 +375,31 @@ static struct {
         unsigned int (*read)(struct snd_soc_codec *, unsigned int);
         unsigned int (*i2c_read)(struct snd_soc_codec *, unsigned int);
 } io_types[] = {
-        { 7, 9, snd_soc_7_9_write, snd_soc_7_9_spi_write, snd_soc_7_9_read },
-        { 8, 16, snd_soc_8_16_write, NULL, snd_soc_8_16_read,
-          snd_soc_8_16_read_i2c },
+        {
+                .addr_bits = 4, .data_bits = 12,
+                .write = snd_soc_4_12_write, .read = snd_soc_4_12_read,
+                .spi_write = snd_soc_4_12_spi_write,
+        },
+        {
+                .addr_bits = 7, .data_bits = 9,
+                .write = snd_soc_7_9_write, .read = snd_soc_7_9_read,
+                .spi_write = snd_soc_7_9_spi_write,
+        },
+        {
+                .addr_bits = 8, .data_bits = 8,
+                .write = snd_soc_8_8_write, .read = snd_soc_8_8_read,
+        },
+        {
+                .addr_bits = 8, .data_bits = 16,
+                .write = snd_soc_8_16_write, .read = snd_soc_8_16_read,
+                .i2c_read = snd_soc_8_16_read_i2c,
+        },
+        {
+                .addr_bits = 16, .data_bits = 8,
+                .write = snd_soc_16_8_write, .read = snd_soc_16_8_read,
+                .i2c_read = snd_soc_16_8_read_i2c,
+                .spi_write = snd_soc_16_8_spi_write,
+        },
 };
 
 /**
diff --git a/sound/soc/soc-core.c b/sound/soc/soc-core.c
index 0a1b2f64bbee..ad7f9528d751 100644
--- a/sound/soc/soc-core.c
+++ b/sound/soc/soc-core.c
@@ -28,6 +28,7 @@
 #include <linux/bitops.h>
 #include <linux/debugfs.h>
 #include <linux/platform_device.h>
+#include <linux/slab.h>
 #include <sound/ac97_codec.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
@@ -37,7 +38,6 @@
 #include <sound/initval.h>
 
 static DEFINE_MUTEX(pcm_mutex);
-static DEFINE_MUTEX(io_mutex);
 static DECLARE_WAIT_QUEUE_HEAD(soc_pm_waitq);
 
 #ifdef CONFIG_DEBUG_FS
@@ -81,6 +81,196 @@ static int run_delayed_work(struct delayed_work *dwork)
         return ret;
 }
 
+/* codec register dump */
+static ssize_t soc_codec_reg_show(struct snd_soc_codec *codec, char *buf)
+{
+        int i, step = 1, count = 0;
+
+        if (!codec->reg_cache_size)
+                return 0;
+
+        if (codec->reg_cache_step)
+                step = codec->reg_cache_step;
+
+        count += sprintf(buf, "%s registers\n", codec->name);
+        for (i = 0; i < codec->reg_cache_size; i += step) {
+                if (codec->readable_register && !codec->readable_register(i))
+                        continue;
+
+                count += sprintf(buf + count, "%2x: ", i);
+                if (count >= PAGE_SIZE - 1)
+                        break;
+
+                if (codec->display_register)
+                        count += codec->display_register(codec, buf + count,
+                                                         PAGE_SIZE - count, i);
+                else
+                        count += snprintf(buf + count, PAGE_SIZE - count,
+                                          "%4x", codec->read(codec, i));
+
+                if (count >= PAGE_SIZE - 1)
+                        break;
+
+                count += snprintf(buf + count, PAGE_SIZE - count, "\n");
+                if (count >= PAGE_SIZE - 1)
+                        break;
+        }
+
+        /* Truncate count; min() would cause a warning */
+        if (count >= PAGE_SIZE)
+                count = PAGE_SIZE - 1;
+
+        return count;
+}
+static ssize_t codec_reg_show(struct device *dev,
+        struct device_attribute *attr, char *buf)
+{
+        struct snd_soc_device *devdata = dev_get_drvdata(dev);
+        return soc_codec_reg_show(devdata->card->codec, buf);
+}
+
+static DEVICE_ATTR(codec_reg, 0444, codec_reg_show, NULL);
+
+static ssize_t pmdown_time_show(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        struct snd_soc_device *socdev = dev_get_drvdata(dev);
+        struct snd_soc_card *card = socdev->card;
+
+        return sprintf(buf, "%ld\n", card->pmdown_time);
+}
+
+static ssize_t pmdown_time_set(struct device *dev,
+                               struct device_attribute *attr,
+                               const char *buf, size_t count)
+{
+        struct snd_soc_device *socdev = dev_get_drvdata(dev);
+        struct snd_soc_card *card = socdev->card;
+
+        strict_strtol(buf, 10, &card->pmdown_time);
+
+        return count;
+}
+
+static DEVICE_ATTR(pmdown_time, 0644, pmdown_time_show, pmdown_time_set);
+
+#ifdef CONFIG_DEBUG_FS
+static int codec_reg_open_file(struct inode *inode, struct file *file)
+{
+        file->private_data = inode->i_private;
+        return 0;
+}
+
+static ssize_t codec_reg_read_file(struct file *file, char __user *user_buf,
+                               size_t count, loff_t *ppos)
+{
+        ssize_t ret;
+        struct snd_soc_codec *codec = file->private_data;
+        char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
+        if (!buf)
+                return -ENOMEM;
+        ret = soc_codec_reg_show(codec, buf);
+        if (ret >= 0)
+                ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
+        kfree(buf);
+        return ret;
+}
+
+static ssize_t codec_reg_write_file(struct file *file,
+                const char __user *user_buf, size_t count, loff_t *ppos)
+{
+        char buf[32];
+        int buf_size;
+        char *start = buf;
+        unsigned long reg, value;
+        int step = 1;
+        struct snd_soc_codec *codec = file->private_data;
+
+        buf_size = min(count, (sizeof(buf)-1));
+        if (copy_from_user(buf, user_buf, buf_size))
+                return -EFAULT;
+        buf[buf_size] = 0;
+
+        if (codec->reg_cache_step)
+                step = codec->reg_cache_step;
+
+        while (*start == ' ')
+                start++;
+        reg = simple_strtoul(start, &start, 16);
+        if ((reg >= codec->reg_cache_size) || (reg % step))
+                return -EINVAL;
+        while (*start == ' ')
+                start++;
+        if (strict_strtoul(start, 16, &value))
+                return -EINVAL;
+        codec->write(codec, reg, value);
+        return buf_size;
+}
+
+static const struct file_operations codec_reg_fops = {
+        .open = codec_reg_open_file,
+        .read = codec_reg_read_file,
+        .write = codec_reg_write_file,
+};
+
+static void soc_init_codec_debugfs(struct snd_soc_codec *codec)
+{
+        char codec_root[128];
+
+        if (codec->dev)
+                snprintf(codec_root, sizeof(codec_root),
+                        "%s.%s", codec->name, dev_name(codec->dev));
+        else
+                snprintf(codec_root, sizeof(codec_root),
+                        "%s", codec->name);
+
+        codec->debugfs_codec_root = debugfs_create_dir(codec_root,
+                                                       debugfs_root);
+        if (!codec->debugfs_codec_root) {
+                printk(KERN_WARNING
+                       "ASoC: Failed to create codec debugfs directory\n");
+                return;
+        }
+
+        codec->debugfs_reg = debugfs_create_file("codec_reg", 0644,
+                                                 codec->debugfs_codec_root,
+                                                 codec, &codec_reg_fops);
+        if (!codec->debugfs_reg)
+                printk(KERN_WARNING
+                       "ASoC: Failed to create codec register debugfs file\n");
+
+        codec->debugfs_pop_time = debugfs_create_u32("dapm_pop_time", 0744,
+                                                     codec->debugfs_codec_root,
+                                                     &codec->pop_time);
+        if (!codec->debugfs_pop_time)
+                printk(KERN_WARNING
+                       "Failed to create pop time debugfs file\n");
+
+        codec->debugfs_dapm = debugfs_create_dir("dapm",
+                                                 codec->debugfs_codec_root);
+        if (!codec->debugfs_dapm)
+                printk(KERN_WARNING
+                       "Failed to create DAPM debugfs directory\n");
+
+        snd_soc_dapm_debugfs_init(codec);
+}
+
+static void soc_cleanup_codec_debugfs(struct snd_soc_codec *codec)
+{
+        debugfs_remove_recursive(codec->debugfs_codec_root);
+}
+
+#else
+
+static inline void soc_init_codec_debugfs(struct snd_soc_codec *codec)
+{
+}
+
+static inline void soc_cleanup_codec_debugfs(struct snd_soc_codec *codec)
+{
+}
+#endif
+
 #ifdef CONFIG_SND_SOC_AC97_BUS
 /* unregister ac97 codec */
 static int soc_ac97_dev_unregister(struct snd_soc_codec *codec)
@@ -238,24 +428,24 @@ static int soc_pcm_open(struct snd_pcm_substream *substream)
         if (!runtime->hw.rates) {
                 printk(KERN_ERR "asoc: %s <-> %s No matching rates\n",
                         codec_dai->name, cpu_dai->name);
-                goto machine_err;
+                goto config_err;
         }
         if (!runtime->hw.formats) {
                 printk(KERN_ERR "asoc: %s <-> %s No matching formats\n",
                         codec_dai->name, cpu_dai->name);
-                goto machine_err;
+                goto config_err;
         }
         if (!runtime->hw.channels_min || !runtime->hw.channels_max) {
                 printk(KERN_ERR "asoc: %s <-> %s No matching channels\n",
                         codec_dai->name, cpu_dai->name);
-                goto machine_err;
+                goto config_err;
         }
 
         /* Symmetry only applies if we've already got an active stream. */
         if (cpu_dai->active || codec_dai->active) {
                 ret = soc_pcm_apply_symmetry(substream);
                 if (ret != 0)
-                        goto machine_err;
+                        goto config_err;
         }
 
         pr_debug("asoc: %s <-> %s info:\n", codec_dai->name, cpu_dai->name);
@@ -275,10 +465,14 @@ static int soc_pcm_open(struct snd_pcm_substream *substream)
         mutex_unlock(&pcm_mutex);
         return 0;
 
-machine_err:
+config_err:
         if (machine->ops && machine->ops->shutdown)
                 machine->ops->shutdown(substream);
 
+machine_err:
+        if (codec_dai->ops->shutdown)
+                codec_dai->ops->shutdown(substream, codec_dai);
+
 codec_dai_err:
         if (platform->pcm_ops->close)
                 platform->pcm_ops->close(substream);
@@ -376,7 +570,7 @@ static int soc_codec_close(struct snd_pcm_substream *substream)
                 /* start delayed pop wq here for playback streams */
                 codec_dai->pop_wait = 1;
                 schedule_delayed_work(&card->delayed_work,
-                        msecs_to_jiffies(pmdown_time));
+                        msecs_to_jiffies(card->pmdown_time));
         } else {
                 /* capture streams can be powered down now */
                 snd_soc_dapm_stream_event(codec,
@@ -774,6 +968,12 @@ static int soc_resume(struct device *dev)
         struct snd_soc_card *card = socdev->card;
         struct snd_soc_dai *cpu_dai = card->dai_link[0].cpu_dai;
 
+        /* If the initialization of this soc device failed, there is no codec
+         * associated with it. Just bail out in this case.
+         */
+        if (!card->codec)
+                return 0;
+
         /* AC97 devices might have other drivers hanging off them so
          * need to resume immediately.  Other drivers don't have that
          * problem and may take a substantial amount of time to resume
@@ -790,45 +990,6 @@ static int soc_resume(struct device *dev)
 
         return 0;
 }
-
-/**
- * snd_soc_suspend_device: Notify core of device suspend
- *
- * @dev: Device being suspended.
- *
- * In order to ensure that the entire audio subsystem is suspended in a
- * coordinated fashion ASoC devices should suspend themselves when
- * called by ASoC.  When the standard kernel suspend process asks the
- * device to suspend it should call this function to initiate a suspend
- * of the entire ASoC card.
- *
- * \note Currently this function is stubbed out.
- */
-int snd_soc_suspend_device(struct device *dev)
-{
-        return 0;
-}
-EXPORT_SYMBOL_GPL(snd_soc_suspend_device);
-
-/**
- * snd_soc_resume_device: Notify core of device resume
- *
- * @dev: Device being resumed.
- *
- * In order to ensure that the entire audio subsystem is resumed in a
- * coordinated fashion ASoC devices should resume themselves when called
- * by ASoC.  When the standard kernel resume process asks the device
- * to resume it should call this function.  Once all the components of
- * the card have notified that they are ready to be resumed the card
- * will be resumed.
- *
- * \note Currently this function is stubbed out.
- */
-int snd_soc_resume_device(struct device *dev)
-{
-        return 0;
-}
-EXPORT_SYMBOL_GPL(snd_soc_resume_device);
 #else
 #define soc_suspend     NULL
 #define soc_resume      NULL
@@ -843,6 +1004,7 @@ static void snd_soc_instantiate_card(struct snd_soc_card *card)
                                                     struct platform_device,
                                                     dev);
         struct snd_soc_codec_device *codec_dev = card->socdev->codec_dev;
+        struct snd_soc_codec *codec;
         struct snd_soc_platform *platform;
         struct snd_soc_dai *dai;
         int i, found, ret, ac97;
@@ -911,6 +1073,8 @@ static void snd_soc_instantiate_card(struct snd_soc_card *card)
         dev_dbg(card->dev, "All components present, instantiating\n");
 
         /* Found everything, bring it up */
+        card->pmdown_time = pmdown_time;
+
         if (card->probe) {
                 ret = card->probe(pdev);
                 if (ret < 0)
@@ -931,6 +1095,7 @@ static void snd_soc_instantiate_card(struct snd_soc_card *card)
                 if (ret < 0)
                         goto cpu_dai_err;
         }
+        codec = card->codec;
 
         if (platform->probe) {
                 ret = platform->probe(pdev);
@@ -945,10 +1110,73 @@ static void snd_soc_instantiate_card(struct snd_soc_card *card)
         INIT_WORK(&card->deferred_resume_work, soc_resume_deferred);
 #endif
 
+        for (i = 0; i < card->num_links; i++) {
+                if (card->dai_link[i].init) {
+                        ret = card->dai_link[i].init(codec);
+                        if (ret < 0) {
+                                printk(KERN_ERR "asoc: failed to init %s\n",
+                                        card->dai_link[i].stream_name);
+                                continue;
+                        }
+                }
+                if (card->dai_link[i].codec_dai->ac97_control)
+                        ac97 = 1;
+        }
+
+        snprintf(codec->card->shortname, sizeof(codec->card->shortname),
+                 "%s",  card->name);
+        snprintf(codec->card->longname, sizeof(codec->card->longname),
+                 "%s (%s)", card->name, codec->name);
+
+        /* Make sure all DAPM widgets are instantiated */
+        snd_soc_dapm_new_widgets(codec);
+
+        ret = snd_card_register(codec->card);
+        if (ret < 0) {
+                printk(KERN_ERR "asoc: failed to register soundcard for %s\n",
+                                codec->name);
+                goto card_err;
+        }
+
+        mutex_lock(&codec->mutex);
+#ifdef CONFIG_SND_SOC_AC97_BUS
+        /* Only instantiate AC97 if not already done by the adaptor
+         * for the generic AC97 subsystem.
+         */
+        if (ac97 && strcmp(codec->name, "AC97") != 0) {
+                ret = soc_ac97_dev_register(codec);
+                if (ret < 0) {
+                        printk(KERN_ERR "asoc: AC97 device register failed\n");
+                        snd_card_free(codec->card);
+                        mutex_unlock(&codec->mutex);
+                        goto card_err;
+                }
+        }
+#endif
+
+        ret = snd_soc_dapm_sys_add(card->socdev->dev);
+        if (ret < 0)
+                printk(KERN_WARNING "asoc: failed to add dapm sysfs entries\n");
+
+        ret = device_create_file(card->socdev->dev, &dev_attr_pmdown_time);
+        if (ret < 0)
+                printk(KERN_WARNING "asoc: failed to add pmdown_time sysfs\n");
+
+        ret = device_create_file(card->socdev->dev, &dev_attr_codec_reg);
+        if (ret < 0)
+                printk(KERN_WARNING "asoc: failed to add codec sysfs files\n");
+
+        soc_init_codec_debugfs(codec);
+        mutex_unlock(&codec->mutex);
+
         card->instantiated = 1;
 
         return;
 
+card_err:
+        if (platform->remove)
+                platform->remove(pdev);
+
 platform_err:
         if (codec_dev->remove)
                 codec_dev->remove(pdev);
@@ -1048,7 +1276,7 @@ static int soc_poweroff(struct device *dev)
         return 0;
 }
 
-static struct dev_pm_ops soc_pm_ops = {
+static const struct dev_pm_ops soc_pm_ops = {
         .suspend = soc_suspend,
         .resume = soc_resume,
         .poweroff = soc_poweroff,
@@ -1088,8 +1316,8 @@ static int soc_new_pcm(struct snd_soc_device *socdev,
         codec_dai->codec = card->codec;
 
         /* check client and interface hw capabilities */
-        sprintf(new_name, "%s %s-%d", dai_link->stream_name, codec_dai->name,
-                num);
+        snprintf(new_name, sizeof(new_name), "%s %s-%d",
+                 dai_link->stream_name, codec_dai->name, num);
 
         if (codec_dai->playback.channels_min)
                 playback = 1;
@@ -1151,157 +1379,6 @@ int snd_soc_codec_volatile_register(struct snd_soc_codec *codec, int reg)
 }
 EXPORT_SYMBOL_GPL(snd_soc_codec_volatile_register);
 
-/* codec register dump */
-static ssize_t soc_codec_reg_show(struct snd_soc_codec *codec, char *buf)
-{
-        int i, step = 1, count = 0;
-
-        if (!codec->reg_cache_size)
-                return 0;
-
-        if (codec->reg_cache_step)
-                step = codec->reg_cache_step;
-
-        count += sprintf(buf, "%s registers\n", codec->name);
-        for (i = 0; i < codec->reg_cache_size; i += step) {
-                if (codec->readable_register && !codec->readable_register(i))
-                        continue;
-
-                count += sprintf(buf + count, "%2x: ", i);
-                if (count >= PAGE_SIZE - 1)
-                        break;
-
-                if (codec->display_register)
-                        count += codec->display_register(codec, buf + count,
-                                                         PAGE_SIZE - count, i);
-                else
-                        count += snprintf(buf + count, PAGE_SIZE - count,
-                                          "%4x", codec->read(codec, i));
-
-                if (count >= PAGE_SIZE - 1)
-                        break;
-
-                count += snprintf(buf + count, PAGE_SIZE - count, "\n");
-                if (count >= PAGE_SIZE - 1)
-                        break;
-        }
-
-        /* Truncate count; min() would cause a warning */
-        if (count >= PAGE_SIZE)
-                count = PAGE_SIZE - 1;
-
-        return count;
-}
-static ssize_t codec_reg_show(struct device *dev,
-        struct device_attribute *attr, char *buf)
-{
-        struct snd_soc_device *devdata = dev_get_drvdata(dev);
-        return soc_codec_reg_show(devdata->card->codec, buf);
-}
-
-static DEVICE_ATTR(codec_reg, 0444, codec_reg_show, NULL);
-
-#ifdef CONFIG_DEBUG_FS
-static int codec_reg_open_file(struct inode *inode, struct file *file)
-{
-        file->private_data = inode->i_private;
-        return 0;
-}
-
-static ssize_t codec_reg_read_file(struct file *file, char __user *user_buf,
-                               size_t count, loff_t *ppos)
-{
-        ssize_t ret;
-        struct snd_soc_codec *codec = file->private_data;
-        char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
-        if (!buf)
-                return -ENOMEM;
-        ret = soc_codec_reg_show(codec, buf);
-        if (ret >= 0)
-                ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
-        kfree(buf);
-        return ret;
-}
-
-static ssize_t codec_reg_write_file(struct file *file,
-                const char __user *user_buf, size_t count, loff_t *ppos)
-{
-        char buf[32];
-        int buf_size;
-        char *start = buf;
-        unsigned long reg, value;
-        int step = 1;
-        struct snd_soc_codec *codec = file->private_data;
-
-        buf_size = min(count, (sizeof(buf)-1));
-        if (copy_from_user(buf, user_buf, buf_size))
-                return -EFAULT;
-        buf[buf_size] = 0;
-
-        if (codec->reg_cache_step)
-                step = codec->reg_cache_step;
-
-        while (*start == ' ')
-                start++;
-        reg = simple_strtoul(start, &start, 16);
-        if ((reg >= codec->reg_cache_size) || (reg % step))
-                return -EINVAL;
-        while (*start == ' ')
-                start++;
-        if (strict_strtoul(start, 16, &value))
-                return -EINVAL;
-        codec->write(codec, reg, value);
-        return buf_size;
-}
-
-static const struct file_operations codec_reg_fops = {
-        .open = codec_reg_open_file,
-        .read = codec_reg_read_file,
-        .write = codec_reg_write_file,
-};
-
-static void soc_init_codec_debugfs(struct snd_soc_codec *codec)
-{
-        codec->debugfs_reg = debugfs_create_file("codec_reg", 0644,
-                                                 debugfs_root, codec,
-                                                 &codec_reg_fops);
-        if (!codec->debugfs_reg)
-                printk(KERN_WARNING
-                       "ASoC: Failed to create codec register debugfs file\n");
-
-        codec->debugfs_pop_time = debugfs_create_u32("dapm_pop_time", 0744,
-                                                     debugfs_root,
-                                                     &codec->pop_time);
-        if (!codec->debugfs_pop_time)
-                printk(KERN_WARNING
-                       "Failed to create pop time debugfs file\n");
-
-        codec->debugfs_dapm = debugfs_create_dir("dapm", debugfs_root);
-        if (!codec->debugfs_dapm)
-                printk(KERN_WARNING
-                       "Failed to create DAPM debugfs directory\n");
-
-        snd_soc_dapm_debugfs_init(codec);
-}
-
-static void soc_cleanup_codec_debugfs(struct snd_soc_codec *codec)
-{
-        debugfs_remove_recursive(codec->debugfs_dapm);
-        debugfs_remove(codec->debugfs_pop_time);
-        debugfs_remove(codec->debugfs_reg);
-}
-
-#else
-
-static inline void soc_init_codec_debugfs(struct snd_soc_codec *codec)
-{
-}
-
-static inline void soc_cleanup_codec_debugfs(struct snd_soc_codec *codec)
-{
-}
-#endif
-
 /**
  * snd_soc_new_ac97_codec - initailise AC97 device
  * @codec: audio codec
@@ -1331,6 +1408,7 @@ int snd_soc_new_ac97_codec(struct snd_soc_codec *codec,
 
         codec->ac97->bus->ops = ops;
         codec->ac97->num = num;
+        codec->dev = &codec->ac97->dev;
         mutex_unlock(&codec->mutex);
         return 0;
 }
@@ -1369,19 +1447,42 @@ int snd_soc_update_bits(struct snd_soc_codec *codec, unsigned short reg,
         int change;
         unsigned int old, new;
 
-        mutex_lock(&io_mutex);
         old = snd_soc_read(codec, reg);
         new = (old & ~mask) | value;
         change = old != new;
         if (change)
                 snd_soc_write(codec, reg, new);
 
-        mutex_unlock(&io_mutex);
         return change;
 }
 EXPORT_SYMBOL_GPL(snd_soc_update_bits);
 
 /**
+ * snd_soc_update_bits_locked - update codec register bits
+ * @codec: audio codec
+ * @reg: codec register
+ * @mask: register mask
+ * @value: new value
+ *
+ * Writes new register value, and takes the codec mutex.
+ *
+ * Returns 1 for change else 0.
+ */
+int snd_soc_update_bits_locked(struct snd_soc_codec *codec,
+                               unsigned short reg, unsigned int mask,
+                               unsigned int value)
+{
+        int change;
+
+        mutex_lock(&codec->mutex);
+        change = snd_soc_update_bits(codec, reg, mask, value);
+        mutex_unlock(&codec->mutex);
+
+        return change;
+}
+EXPORT_SYMBOL_GPL(snd_soc_update_bits_locked);
+
+/**
  * snd_soc_test_bits - test register for change
  * @codec: audio codec
  * @reg: codec register
@@ -1399,11 +1500,9 @@ int snd_soc_test_bits(struct snd_soc_codec *codec, unsigned short reg,
         int change;
         unsigned int old, new;
 
-        mutex_lock(&io_mutex);
         old = snd_soc_read(codec, reg);
         new = (old & ~mask) | value;
         change = old != new;
-        mutex_unlock(&io_mutex);
 
         return change;
 }
@@ -1450,89 +1549,17 @@ int snd_soc_new_pcms(struct snd_soc_device *socdev, int idx, const char *xid)
                         mutex_unlock(&codec->mutex);
                         return ret;
                 }
-        }
-
-        mutex_unlock(&codec->mutex);
-        return ret;
-}
-EXPORT_SYMBOL_GPL(snd_soc_new_pcms);
-
-/**
- * snd_soc_init_card - register sound card
- * @socdev: the SoC audio device
- *
- * Register a SoC sound card. Also registers an AC97 device if the
- * codec is AC97 for ad hoc devices.
- *
- * Returns 0 for success, else error.
- */
-int snd_soc_init_card(struct snd_soc_device *socdev)
-{
-        struct snd_soc_card *card = socdev->card;
-        struct snd_soc_codec *codec = card->codec;
-        int ret = 0, i, ac97 = 0, err = 0;
-
-        for (i = 0; i < card->num_links; i++) {
-                if (card->dai_link[i].init) {
-                        err = card->dai_link[i].init(codec);
-                        if (err < 0) {
-                                printk(KERN_ERR "asoc: failed to init %s\n",
-                                        card->dai_link[i].stream_name);
-                                continue;
-                        }
-                }
-                if (card->dai_link[i].codec_dai->ac97_control) {
-                        ac97 = 1;
+                /* Check for codec->ac97 to handle the ac97.c fun */
+                if (card->dai_link[i].codec_dai->ac97_control && codec->ac97) {
                         snd_ac97_dev_add_pdata(codec->ac97,
                                 card->dai_link[i].cpu_dai->ac97_pdata);
                 }
         }
-        snprintf(codec->card->shortname, sizeof(codec->card->shortname),
-                 "%s",  card->name);
-        snprintf(codec->card->longname, sizeof(codec->card->longname),
-                 "%s (%s)", card->name, codec->name);
-
-        /* Make sure all DAPM widgets are instantiated */
-        snd_soc_dapm_new_widgets(codec);
-
-        ret = snd_card_register(codec->card);
-        if (ret < 0) {
-                printk(KERN_ERR "asoc: failed to register soundcard for %s\n",
-                                codec->name);
-                goto out;
-        }
 
-        mutex_lock(&codec->mutex);
-#ifdef CONFIG_SND_SOC_AC97_BUS
-        /* Only instantiate AC97 if not already done by the adaptor
-         * for the generic AC97 subsystem.
-         */
-        if (ac97 && strcmp(codec->name, "AC97") != 0) {
-                ret = soc_ac97_dev_register(codec);
-                if (ret < 0) {
-                        printk(KERN_ERR "asoc: AC97 device register failed\n");
-                        snd_card_free(codec->card);
-                        mutex_unlock(&codec->mutex);
-                        goto out;
-                }
-        }
-#endif
-
-        err = snd_soc_dapm_sys_add(socdev->dev);
-        if (err < 0)
-                printk(KERN_WARNING "asoc: failed to add dapm sysfs entries\n");
-
-        err = device_create_file(socdev->dev, &dev_attr_codec_reg);
-        if (err < 0)
-                printk(KERN_WARNING "asoc: failed to add codec sysfs files\n");
-
-        soc_init_codec_debugfs(codec);
         mutex_unlock(&codec->mutex);
-
-out:
         return ret;
 }
-EXPORT_SYMBOL_GPL(snd_soc_init_card);
+EXPORT_SYMBOL_GPL(snd_soc_new_pcms);
 
 /**
  * snd_soc_free_pcms - free sound card and pcms
@@ -1734,7 +1761,7 @@ int snd_soc_put_enum_double(struct snd_kcontrol *kcontrol,
                 mask |= (bitmask - 1) << e->shift_r;
         }
 
-        return snd_soc_update_bits(codec, e->reg, mask, val);
+        return snd_soc_update_bits_locked(codec, e->reg, mask, val);
 }
 EXPORT_SYMBOL_GPL(snd_soc_put_enum_double);
 
@@ -1808,7 +1835,7 @@ int snd_soc_put_value_enum_double(struct snd_kcontrol *kcontrol,
                 mask |= e->mask << e->shift_r;
         }
 
-        return snd_soc_update_bits(codec, e->reg, mask, val);
+        return snd_soc_update_bits_locked(codec, e->reg, mask, val);
 }
 EXPORT_SYMBOL_GPL(snd_soc_put_value_enum_double);
 
@@ -1969,7 +1996,7 @@ int snd_soc_put_volsw(struct snd_kcontrol *kcontrol,
                 val_mask |= mask << rshift;
                 val |= val2 << rshift;
         }
-        return snd_soc_update_bits(codec, reg, val_mask, val);
+        return snd_soc_update_bits_locked(codec, reg, val_mask, val);
 }
 EXPORT_SYMBOL_GPL(snd_soc_put_volsw);
 
@@ -2075,11 +2102,11 @@ int snd_soc_put_volsw_2r(struct snd_kcontrol *kcontrol,
         val = val << shift;
         val2 = val2 << shift;
 
-        err = snd_soc_update_bits(codec, reg, val_mask, val);
+        err = snd_soc_update_bits_locked(codec, reg, val_mask, val);
         if (err < 0)
                 return err;
 
-        err = snd_soc_update_bits(codec, reg2, val_mask, val2);
+        err = snd_soc_update_bits_locked(codec, reg2, val_mask, val2);
         return err;
 }
 EXPORT_SYMBOL_GPL(snd_soc_put_volsw_2r);
@@ -2158,7 +2185,7 @@ int snd_soc_put_volsw_s8(struct snd_kcontrol *kcontrol,
         val = (ucontrol->value.integer.value[0]+min) & 0xff;
         val |= ((ucontrol->value.integer.value[1]+min) & 0xff) << 8;
 
-        return snd_soc_update_bits(codec, reg, 0xffff, val);
+        return snd_soc_update_bits_locked(codec, reg, 0xffff, val);
 }
 EXPORT_SYMBOL_GPL(snd_soc_put_volsw_s8);
 
@@ -2205,16 +2232,18 @@ EXPORT_SYMBOL_GPL(snd_soc_dai_set_clkdiv);
  * snd_soc_dai_set_pll - configure DAI PLL.
  * @dai: DAI
  * @pll_id: DAI specific PLL ID
+ * @source: DAI specific source for the PLL
  * @freq_in: PLL input clock frequency in Hz
  * @freq_out: requested PLL output clock frequency in Hz
  *
  * Configures and enables PLL to generate output clock based on input clock.
  */
-int snd_soc_dai_set_pll(struct snd_soc_dai *dai,
-        int pll_id, unsigned int freq_in, unsigned int freq_out)
+int snd_soc_dai_set_pll(struct snd_soc_dai *dai, int pll_id, int source,
+        unsigned int freq_in, unsigned int freq_out)
 {
         if (dai->ops && dai->ops->set_pll)
-                return dai->ops->set_pll(dai, pll_id, freq_in, freq_out);
+                return dai->ops->set_pll(dai, pll_id, source,
+                                         freq_in, freq_out);
         else
                 return -EINVAL;
 }
@@ -2259,6 +2288,30 @@ int snd_soc_dai_set_tdm_slot(struct snd_soc_dai *dai,
 EXPORT_SYMBOL_GPL(snd_soc_dai_set_tdm_slot);
 
 /**
+ * snd_soc_dai_set_channel_map - configure DAI audio channel map
+ * @dai: DAI
+ * @tx_num: how many TX channels
+ * @tx_slot: pointer to an array which imply the TX slot number channel
+ *           0~num-1 uses
+ * @rx_num: how many RX channels
+ * @rx_slot: pointer to an array which imply the RX slot number channel
+ *           0~num-1 uses
+ *
+ * configure the relationship between channel number and TDM slot number.
+ */
+int snd_soc_dai_set_channel_map(struct snd_soc_dai *dai,
+        unsigned int tx_num, unsigned int *tx_slot,
+        unsigned int rx_num, unsigned int *rx_slot)
+{
+        if (dai->ops && dai->ops->set_channel_map)
+                return dai->ops->set_channel_map(dai, tx_num, tx_slot,
+                        rx_num, rx_slot);
+        else
+                return -EINVAL;
+}
+EXPORT_SYMBOL_GPL(snd_soc_dai_set_channel_map);
+
+/**
  * snd_soc_dai_set_tristate - configure DAI system or master clock.
  * @dai: DAI
  * @tristate: tristate enable
diff --git a/sound/soc/soc-dapm.c b/sound/soc/soc-dapm.c
index 66d4c165f99b..7c28f401f436 100644
--- a/sound/soc/soc-dapm.c
+++ b/sound/soc/soc-dapm.c
@@ -38,19 +38,13 @@
 #include <linux/platform_device.h>
 #include <linux/jiffies.h>
 #include <linux/debugfs.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
 #include <sound/soc-dapm.h>
 #include <sound/initval.h>
 
-/* debug */
-#ifdef DEBUG
-#define dump_dapm(codec, action) dbg_dump_dapm(codec, action)
-#else
-#define dump_dapm(codec, action)
-#endif
-
 /* dapm power sequences - make this per codec in the future */
 static int dapm_up_seq[] = {
         [snd_soc_dapm_pre] = 0,
@@ -719,6 +713,10 @@ static int dapm_supply_check_power(struct snd_soc_dapm_widget *w)
 
         /* Check if one of our outputs is connected */
         list_for_each_entry(path, &w->sinks, list_source) {
+                if (path->connected &&
+                    !path->connected(path->source, path->sink))
+                        continue;
+
                 if (path->sink && path->sink->power_check &&
                     path->sink->power_check(path->sink)) {
                         power = 1;
@@ -735,6 +733,8 @@ static int dapm_seq_compare(struct snd_soc_dapm_widget *a,
                             struct snd_soc_dapm_widget *b,
                             int sort[])
 {
+        if (a->codec != b->codec)
+                return (unsigned long)a - (unsigned long)b;
         if (sort[a->id] != sort[b->id])
                 return sort[a->id] - sort[b->id];
         if (a->reg != b->reg)
@@ -1013,13 +1013,28 @@ static int dapm_power_widgets(struct snd_soc_codec *codec, int event)
                         sys_power = 0;
                         break;
                 case SND_SOC_DAPM_STREAM_NOP:
-                        sys_power = codec->bias_level != SND_SOC_BIAS_STANDBY;
+                        switch (codec->bias_level) {
+                                case SND_SOC_BIAS_STANDBY:
+                                case SND_SOC_BIAS_OFF:
+                                        sys_power = 0;
+                                        break;
+                                default:
+                                        sys_power = 1;
+                                        break;
+                        }
                         break;
                 default:
                         break;
                 }
         }
 
+        if (sys_power && codec->bias_level == SND_SOC_BIAS_OFF) {
+                ret = snd_soc_dapm_set_bias_level(socdev,
+                                                  SND_SOC_BIAS_STANDBY);
+                if (ret != 0)
+                        pr_err("Failed to turn on bias: %d\n", ret);
+        }
+
         /* If we're changing to all on or all off then prepare */
         if ((sys_power && codec->bias_level == SND_SOC_BIAS_STANDBY) ||
             (!sys_power && codec->bias_level == SND_SOC_BIAS_ON)) {
@@ -1043,6 +1058,14 @@ static int dapm_power_widgets(struct snd_soc_codec *codec, int event)
                         pr_err("Failed to apply standby bias: %d\n", ret);
         }
 
+        /* If we're in standby and can support bias off then do that */
+        if (codec->bias_level == SND_SOC_BIAS_STANDBY &&
+            codec->idle_bias_off) {
+                ret = snd_soc_dapm_set_bias_level(socdev, SND_SOC_BIAS_OFF);
+                if (ret != 0)
+                        pr_err("Failed to turn off bias: %d\n", ret);
+        }
+
         /* If we just powered up then move to active bias */
         if (codec->bias_level == SND_SOC_BIAS_PREPARE && sys_power) {
                 ret = snd_soc_dapm_set_bias_level(socdev,
@@ -1057,66 +1080,6 @@ static int dapm_power_widgets(struct snd_soc_codec *codec, int event)
         return 0;
 }
 
-#ifdef DEBUG
-static void dbg_dump_dapm(struct snd_soc_codec* codec, const char *action)
-{
-        struct snd_soc_dapm_widget *w;
-        struct snd_soc_dapm_path *p = NULL;
-        int in, out;
-
-        printk("DAPM %s %s\n", codec->name, action);
-
-        list_for_each_entry(w, &codec->dapm_widgets, list) {
-
-                /* only display widgets that effect routing */
-                switch (w->id) {
-                case snd_soc_dapm_pre:
-                case snd_soc_dapm_post:
-                case snd_soc_dapm_vmid:
-                        continue;
-                case snd_soc_dapm_mux:
-                case snd_soc_dapm_value_mux:
-                case snd_soc_dapm_output:
-                case snd_soc_dapm_input:
-                case snd_soc_dapm_switch:
-                case snd_soc_dapm_hp:
-                case snd_soc_dapm_mic:
-                case snd_soc_dapm_spk:
-                case snd_soc_dapm_line:
-                case snd_soc_dapm_micbias:
-                case snd_soc_dapm_dac:
-                case snd_soc_dapm_adc:
-                case snd_soc_dapm_pga:
-                case snd_soc_dapm_mixer:
-                case snd_soc_dapm_mixer_named_ctl:
-                case snd_soc_dapm_supply:
-                case snd_soc_dapm_aif_in:
-                case snd_soc_dapm_aif_out:
-                        if (w->name) {
-                                in = is_connected_input_ep(w);
-                                dapm_clear_walk(w->codec);
-                                out = is_connected_output_ep(w);
-                                dapm_clear_walk(w->codec);
-                                printk("%s: %s  in %d out %d\n", w->name,
-                                        w->power ? "On":"Off",in, out);
-
-                                list_for_each_entry(p, &w->sources, list_sink) {
-                                        if (p->connect)
-                                                printk(" in  %s %s\n", p->name ? p->name : "static",
-                                                        p->source->name);
-                                }
-                                list_for_each_entry(p, &w->sinks, list_source) {
-                                        if (p->connect)
-                                                printk(" out %s %s\n", p->name ? p->name : "static",
-                                                        p->sink->name);
-                                }
-                        }
-                break;
-                }
-        }
-}
-#endif
-
 #ifdef CONFIG_DEBUG_FS
 static int dapm_widget_power_open_file(struct inode *inode, struct file *file)
 {
@@ -1143,15 +1106,25 @@ static ssize_t dapm_widget_power_read_file(struct file *file,
         out = is_connected_output_ep(w);
         dapm_clear_walk(w->codec);
 
-        ret = snprintf(buf, PAGE_SIZE, "%s: %s  in %d out %d\n",
+        ret = snprintf(buf, PAGE_SIZE, "%s: %s  in %d out %d",
                        w->name, w->power ? "On" : "Off", in, out);
 
+        if (w->reg >= 0)
+                ret += snprintf(buf + ret, PAGE_SIZE - ret,
+                                " - R%d(0x%x) bit %d",
+                                w->reg, w->reg, w->shift);
+
+        ret += snprintf(buf + ret, PAGE_SIZE - ret, "\n");
+
         if (w->sname)
                 ret += snprintf(buf + ret, PAGE_SIZE - ret, " stream %s %s\n",
                                 w->sname,
                                 w->active ? "active" : "inactive");
 
         list_for_each_entry(p, &w->sources, list_sink) {
+                if (p->connected && !p->connected(w, p->sink))
+                        continue;
+
                 if (p->connect)
                         ret += snprintf(buf + ret, PAGE_SIZE - ret,
                                         " in  %s %s\n",
@@ -1159,6 +1132,9 @@ static ssize_t dapm_widget_power_read_file(struct file *file,
                                         p->source->name);
         }
         list_for_each_entry(p, &w->sinks, list_source) {
+                if (p->connected && !p->connected(w, p->sink))
+                        continue;
+
                 if (p->connect)
                         ret += snprintf(buf + ret, PAGE_SIZE - ret,
                                         " out %s %s\n",
@@ -1206,8 +1182,8 @@ void snd_soc_dapm_debugfs_init(struct snd_soc_codec *codec)
 
 /* test and update the power status of a mux widget */
 static int dapm_mux_update_power(struct snd_soc_dapm_widget *widget,
-                                 struct snd_kcontrol *kcontrol, int mask,
-                                 int mux, int val, struct soc_enum *e)
+                                 struct snd_kcontrol *kcontrol, int change,
+                                 int mux, struct soc_enum *e)
 {
         struct snd_soc_dapm_path *path;
         int found = 0;
@@ -1216,7 +1192,7 @@ static int dapm_mux_update_power(struct snd_soc_dapm_widget *widget,
             widget->id != snd_soc_dapm_value_mux)
                 return -ENODEV;
 
-        if (!snd_soc_test_bits(widget->codec, e->reg, mask, val))
+        if (!change)
                 return 0;
 
         /* find dapm widget path assoc with kcontrol */
@@ -1235,18 +1211,15 @@ static int dapm_mux_update_power(struct snd_soc_dapm_widget *widget,
                         path->connect = 0; /* old connection must be powered down */
         }
 
-        if (found) {
+        if (found)
                 dapm_power_widgets(widget->codec, SND_SOC_DAPM_STREAM_NOP);
-                dump_dapm(widget->codec, "mux power update");
-        }
 
         return 0;
 }
 
 /* test and update the power status of a mixer or switch widget */
 static int dapm_mixer_update_power(struct snd_soc_dapm_widget *widget,
-                                   struct snd_kcontrol *kcontrol, int reg,
-                                   int val_mask, int val, int invert)
+                                   struct snd_kcontrol *kcontrol, int connect)
 {
         struct snd_soc_dapm_path *path;
         int found = 0;
@@ -1256,9 +1229,6 @@ static int dapm_mixer_update_power(struct snd_soc_dapm_widget *widget,
             widget->id != snd_soc_dapm_switch)
                 return -ENODEV;
 
-        if (!snd_soc_test_bits(widget->codec, reg, val_mask, val))
-                return 0;
-
         /* find dapm widget path assoc with kcontrol */
         list_for_each_entry(path, &widget->codec->dapm_paths, list) {
                 if (path->kcontrol != kcontrol)
@@ -1266,19 +1236,12 @@ static int dapm_mixer_update_power(struct snd_soc_dapm_widget *widget,
 
                 /* found, now check type */
                 found = 1;
-                if (val)
-                        /* new connection */
-                        path->connect = invert ? 0:1;
-                else
-                        /* old connection must be powered down */
-                        path->connect = invert ? 1:0;
+                path->connect = connect;
                 break;
         }
 
-        if (found) {
+        if (found)
                 dapm_power_widgets(widget->codec, SND_SOC_DAPM_STREAM_NOP);
-                dump_dapm(widget->codec, "mixer power update");
-        }
 
         return 0;
 }
@@ -1394,17 +1357,18 @@ static int snd_soc_dapm_set_pin(struct snd_soc_codec *codec,
  */
 int snd_soc_dapm_sync(struct snd_soc_codec *codec)
 {
-        int ret = dapm_power_widgets(codec, SND_SOC_DAPM_STREAM_NOP);
-        dump_dapm(codec, "sync");
-        return ret;
+        return dapm_power_widgets(codec, SND_SOC_DAPM_STREAM_NOP);
 }
 EXPORT_SYMBOL_GPL(snd_soc_dapm_sync);
 
 static int snd_soc_dapm_add_route(struct snd_soc_codec *codec,
-        const char *sink, const char *control, const char *source)
+                                  const struct snd_soc_dapm_route *route)
 {
         struct snd_soc_dapm_path *path;
         struct snd_soc_dapm_widget *wsource = NULL, *wsink = NULL, *w;
+        const char *sink = route->sink;
+        const char *control = route->control;
+        const char *source = route->source;
         int ret = 0;
 
         /* find src and dest widgets */
@@ -1428,6 +1392,7 @@ static int snd_soc_dapm_add_route(struct snd_soc_codec *codec,
 
         path->source = wsource;
         path->sink = wsink;
+        path->connected = route->connected;
         INIT_LIST_HEAD(&path->list);
         INIT_LIST_HEAD(&path->list_source);
         INIT_LIST_HEAD(&path->list_sink);
@@ -1528,8 +1493,7 @@ int snd_soc_dapm_add_routes(struct snd_soc_codec *codec,
         int i, ret;
 
         for (i = 0; i < num; i++) {
-                ret = snd_soc_dapm_add_route(codec, route->sink,
-                                             route->control, route->source);
+                ret = snd_soc_dapm_add_route(codec, route);
                 if (ret < 0) {
                         printk(KERN_ERR "Failed to add route %s->%s\n",
                                route->source,
@@ -1675,6 +1639,7 @@ int snd_soc_dapm_put_volsw(struct snd_kcontrol *kcontrol,
         unsigned int mask = (1 << fls(max)) - 1;
         unsigned int invert = mc->invert;
         unsigned int val, val2, val_mask;
+        int connect;
         int ret;
 
         val = (ucontrol->value.integer.value[0] & mask);
@@ -1701,7 +1666,17 @@ int snd_soc_dapm_put_volsw(struct snd_kcontrol *kcontrol,
                 return 1;
         }
 
-        dapm_mixer_update_power(widget, kcontrol, reg, val_mask, val, invert);
+        if (snd_soc_test_bits(widget->codec, reg, val_mask, val)) {
+                if (val)
+                        /* new connection */
+                        connect = invert ? 0:1;
+                else
+                        /* old connection must be powered down */
+                        connect = invert ? 1:0;
+
+                dapm_mixer_update_power(widget, kcontrol, connect);
+        }
+
         if (widget->event) {
                 if (widget->event_flags & SND_SOC_DAPM_PRE_REG) {
                         ret = widget->event(widget, kcontrol,
@@ -1766,7 +1741,7 @@ int snd_soc_dapm_put_enum_double(struct snd_kcontrol *kcontrol,
 {
         struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
-        unsigned int val, mux;
+        unsigned int val, mux, change;
         unsigned int mask, bitmask;
         int ret = 0;
 
@@ -1786,20 +1761,21 @@ int snd_soc_dapm_put_enum_double(struct snd_kcontrol *kcontrol,
 
         mutex_lock(&widget->codec->mutex);
         widget->value = val;
-        dapm_mux_update_power(widget, kcontrol, mask, mux, val, e);
-        if (widget->event) {
-                if (widget->event_flags & SND_SOC_DAPM_PRE_REG) {
-                        ret = widget->event(widget,
-                                kcontrol, SND_SOC_DAPM_PRE_REG);
-                        if (ret < 0)
-                                goto out;
-                }
-                ret = snd_soc_update_bits(widget->codec, e->reg, mask, val);
-                if (widget->event_flags & SND_SOC_DAPM_POST_REG)
-                        ret = widget->event(widget,
-                                kcontrol, SND_SOC_DAPM_POST_REG);
-        } else
-                ret = snd_soc_update_bits(widget->codec, e->reg, mask, val);
+        change = snd_soc_test_bits(widget->codec, e->reg, mask, val);
+        dapm_mux_update_power(widget, kcontrol, change, mux, e);
+
+        if (widget->event_flags & SND_SOC_DAPM_PRE_REG) {
+                ret = widget->event(widget,
+                                    kcontrol, SND_SOC_DAPM_PRE_REG);
+                if (ret < 0)
+                        goto out;
+        }
+
+        ret = snd_soc_update_bits(widget->codec, e->reg, mask, val);
+
+        if (widget->event_flags & SND_SOC_DAPM_POST_REG)
+                ret = widget->event(widget,
+                                    kcontrol, SND_SOC_DAPM_POST_REG);
 
 out:
         mutex_unlock(&widget->codec->mutex);
@@ -1808,6 +1784,54 @@ out:
 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_enum_double);
 
 /**
+ * snd_soc_dapm_get_enum_virt - Get virtual DAPM mux
+ * @kcontrol: mixer control
+ * @ucontrol: control element information
+ *
+ * Returns 0 for success.
+ */
+int snd_soc_dapm_get_enum_virt(struct snd_kcontrol *kcontrol,
+                               struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
+
+        ucontrol->value.enumerated.item[0] = widget->value;
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(snd_soc_dapm_get_enum_virt);
+
+/**
+ * snd_soc_dapm_put_enum_virt - Set virtual DAPM mux
+ * @kcontrol: mixer control
+ * @ucontrol: control element information
+ *
+ * Returns 0 for success.
+ */
+int snd_soc_dapm_put_enum_virt(struct snd_kcontrol *kcontrol,
+                               struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
+        struct soc_enum *e =
+                (struct soc_enum *)kcontrol->private_value;
+        int change;
+        int ret = 0;
+
+        if (ucontrol->value.enumerated.item[0] >= e->max)
+                return -EINVAL;
+
+        mutex_lock(&widget->codec->mutex);
+
+        change = widget->value != ucontrol->value.enumerated.item[0];
+        widget->value = ucontrol->value.enumerated.item[0];
+        dapm_mux_update_power(widget, kcontrol, change, widget->value, e);
+
+        mutex_unlock(&widget->codec->mutex);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(snd_soc_dapm_put_enum_virt);
+
+/**
  * snd_soc_dapm_get_value_enum_double - dapm semi enumerated double mixer get
  *                                      callback
  * @kcontrol: mixer control
@@ -1865,7 +1889,7 @@ int snd_soc_dapm_put_value_enum_double(struct snd_kcontrol *kcontrol,
 {
         struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
-        unsigned int val, mux;
+        unsigned int val, mux, change;
         unsigned int mask;
         int ret = 0;
 
@@ -1883,20 +1907,21 @@ int snd_soc_dapm_put_value_enum_double(struct snd_kcontrol *kcontrol,
 
         mutex_lock(&widget->codec->mutex);
         widget->value = val;
-        dapm_mux_update_power(widget, kcontrol, mask, mux, val, e);
-        if (widget->event) {
-                if (widget->event_flags & SND_SOC_DAPM_PRE_REG) {
-                        ret = widget->event(widget,
-                                kcontrol, SND_SOC_DAPM_PRE_REG);
-                        if (ret < 0)
-                                goto out;
-                }
-                ret = snd_soc_update_bits(widget->codec, e->reg, mask, val);
-                if (widget->event_flags & SND_SOC_DAPM_POST_REG)
-                        ret = widget->event(widget,
-                                kcontrol, SND_SOC_DAPM_POST_REG);
-        } else
-                ret = snd_soc_update_bits(widget->codec, e->reg, mask, val);
+        change = snd_soc_test_bits(widget->codec, e->reg, mask, val);
+        dapm_mux_update_power(widget, kcontrol, change, mux, e);
+
+        if (widget->event_flags & SND_SOC_DAPM_PRE_REG) {
+                ret = widget->event(widget,
+                                    kcontrol, SND_SOC_DAPM_PRE_REG);
+                if (ret < 0)
+                        goto out;
+        }
+
+        ret = snd_soc_update_bits(widget->codec, e->reg, mask, val);
+
+        if (widget->event_flags & SND_SOC_DAPM_POST_REG)
+                ret = widget->event(widget,
+                                    kcontrol, SND_SOC_DAPM_POST_REG);
 
 out:
         mutex_unlock(&widget->codec->mutex);
@@ -2089,7 +2114,6 @@ int snd_soc_dapm_stream_event(struct snd_soc_codec *codec,
 
         dapm_power_widgets(codec, event);
         mutex_unlock(&codec->mutex);
-        dump_dapm(codec, __func__);
         return 0;
 }
 EXPORT_SYMBOL_GPL(snd_soc_dapm_stream_event);
diff --git a/sound/soc/soc-jack.c b/sound/soc/soc-jack.c
index 1d455ab79490..3c07a94c2e30 100644
--- a/sound/soc/soc-jack.c
+++ b/sound/soc/soc-jack.c
@@ -58,7 +58,7 @@ EXPORT_SYMBOL_GPL(snd_soc_jack_new);
  */
 void snd_soc_jack_report(struct snd_soc_jack *jack, int status, int mask)
 {
-        struct snd_soc_codec *codec = jack->card->codec;
+        struct snd_soc_codec *codec;
         struct snd_soc_jack_pin *pin;
         int enable;
         int oldstatus;
@@ -67,6 +67,7 @@ void snd_soc_jack_report(struct snd_soc_jack *jack, int status, int mask)
                 WARN_ON_ONCE(!jack);
                 return;
         }
+        codec = jack->card->codec;
 
         mutex_lock(&codec->mutex);
 
@@ -162,6 +163,9 @@ static void snd_soc_jack_gpio_detect(struct snd_soc_jack_gpio *gpio)
         else
                 report = 0;
 
+        if (gpio->jack_status_check)
+                report = gpio->jack_status_check();
+
         snd_soc_jack_report(jack, report, gpio->report);
 }
 
diff --git a/sound/soc/soc-utils.c b/sound/soc/soc-utils.c
new file mode 100644
index 000000000000..1d07b931f3d8
--- /dev/null
+++ b/sound/soc/soc-utils.c
@@ -0,0 +1,74 @@
+/*
+ * soc-util.c  --  ALSA SoC Audio Layer utility functions
+ *
+ * Copyright 2009 Wolfson Microelectronics PLC.
+ *
+ * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
+ *         Liam Girdwood <lrg@slimlogic.co.uk>
+ *         
+ *
+ *  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 the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ */
+
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/soc.h>
+
+int snd_soc_calc_frame_size(int sample_size, int channels, int tdm_slots)
+{
+        return sample_size * channels * tdm_slots;
+}
+EXPORT_SYMBOL_GPL(snd_soc_calc_frame_size);
+
+int snd_soc_params_to_frame_size(struct snd_pcm_hw_params *params)
+{
+        int sample_size;
+
+        switch (params_format(params)) {
+        case SNDRV_PCM_FORMAT_S16_LE:
+        case SNDRV_PCM_FORMAT_S16_BE:
+                sample_size = 16;
+                break;
+        case SNDRV_PCM_FORMAT_S20_3LE:
+        case SNDRV_PCM_FORMAT_S20_3BE:
+                sample_size = 20;
+                break;
+        case SNDRV_PCM_FORMAT_S24_LE:
+        case SNDRV_PCM_FORMAT_S24_BE:
+                sample_size = 24;
+                break;
+        case SNDRV_PCM_FORMAT_S32_LE:
+        case SNDRV_PCM_FORMAT_S32_BE:
+                sample_size = 32;
+                break;
+        default:
+                return -ENOTSUPP;
+        }
+
+        return snd_soc_calc_frame_size(sample_size, params_channels(params),
+                                       1);
+}
+EXPORT_SYMBOL_GPL(snd_soc_params_to_frame_size);
+
+int snd_soc_calc_bclk(int fs, int sample_size, int channels, int tdm_slots)
+{
+        return fs * snd_soc_calc_frame_size(sample_size, channels, tdm_slots);
+}
+EXPORT_SYMBOL_GPL(snd_soc_calc_bclk);
+
+int snd_soc_params_to_bclk(struct snd_pcm_hw_params *params)
+{
+        int ret;
+
+        ret = snd_soc_params_to_frame_size(params);
+
+        if (ret > 0)
+                return ret * params_rate(params);
+        else
+                return ret;
+}
+EXPORT_SYMBOL_GPL(snd_soc_params_to_bclk);
diff --git a/sound/soc/txx9/txx9aclc-ac97.c b/sound/soc/txx9/txx9aclc-ac97.c
index 0f83bdb9b16f..0ec20b68e8cb 100644
--- a/sound/soc/txx9/txx9aclc-ac97.c
+++ b/sound/soc/txx9/txx9aclc-ac97.c
@@ -16,6 +16,7 @@
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/io.h>
+#include <linux/gfp.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/soc.h>
@@ -253,3 +254,4 @@ module_exit(txx9aclc_ac97_exit);
 MODULE_AUTHOR("Atsushi Nemoto <anemo@mba.ocn.ne.jp>");
 MODULE_DESCRIPTION("TXx9 ACLC AC97 driver");
 MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:txx9aclc-ac97");
diff --git a/sound/soc/txx9/txx9aclc-generic.c b/sound/soc/txx9/txx9aclc-generic.c
index 3175de9a92cb..95b17f731aec 100644
--- a/sound/soc/txx9/txx9aclc-generic.c
+++ b/sound/soc/txx9/txx9aclc-generic.c
@@ -96,3 +96,4 @@ module_exit(txx9aclc_generic_exit);
 MODULE_AUTHOR("Atsushi Nemoto <anemo@mba.ocn.ne.jp>");
 MODULE_DESCRIPTION("Generic TXx9 ACLC ALSA SoC audio driver");
 MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:txx9aclc-generic");
diff --git a/sound/soc/txx9/txx9aclc.c b/sound/soc/txx9/txx9aclc.c
index efed64b8b026..49cc7ea9a518 100644
--- a/sound/soc/txx9/txx9aclc.c
+++ b/sound/soc/txx9/txx9aclc.c
@@ -15,6 +15,7 @@
 #include <linux/init.h>
 #include <linux/platform_device.h>
 #include <linux/scatterlist.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
diff --git a/sound/sound_core.c b/sound/sound_core.c
index 49c998186592..7c2d677a2df5 100644
--- a/sound/sound_core.c
+++ b/sound/sound_core.c
@@ -61,7 +61,7 @@ static void __exit cleanup_soundcore(void)
         class_destroy(sound_class);
 }
 
-module_init(init_soundcore);
+subsys_initcall(init_soundcore);
 module_exit(cleanup_soundcore);
 
 
@@ -353,7 +353,7 @@ static struct sound_unit *chains[SOUND_STEP];
  *      @dev: device pointer
  *
  *      Allocate a special sound device by minor number from the sound
- *      subsystem. The allocated number is returned on succes. On failure
+ *      subsystem. The allocated number is returned on success. On failure
  *      a negative error code is returned.
  */
  
diff --git a/sound/sound_firmware.c b/sound/sound_firmware.c
index 96deaefaa897..340a0bc5303e 100644
--- a/sound/sound_firmware.c
+++ b/sound/sound_firmware.c
@@ -2,7 +2,6 @@
 #include <linux/module.h>
 #include <linux/fs.h>
 #include <linux/mm.h>
-#include <linux/slab.h>
 #include <linux/sched.h>
 #include <asm/uaccess.h>
 #include "oss/sound_firmware.h"
diff --git a/sound/sparc/cs4231.c b/sound/sparc/cs4231.c
index 8d13d933087d..7dcc06512e86 100644
--- a/sound/sparc/cs4231.c
+++ b/sound/sparc/cs4231.c
@@ -10,7 +10,6 @@
 
 #include <linux/module.h>
 #include <linux/kernel.h>
-#include <linux/slab.h>
 #include <linux/delay.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
diff --git a/sound/sparc/dbri.c b/sound/sparc/dbri.c
index 1d2e51b3f918..2eab6ce48852 100644
--- a/sound/sparc/dbri.c
+++ b/sound/sparc/dbri.c
@@ -58,6 +58,7 @@
 #include <linux/irq.h>
 #include <linux/io.h>
 #include <linux/dma-mapping.h>
+#include <linux/gfp.h>
 
 #include <sound/core.h>
 #include <sound/pcm.h>
diff --git a/sound/synth/emux/emux_proc.c b/sound/synth/emux/emux_proc.c
index 687e6a13689e..58a32a10d115 100644
--- a/sound/synth/emux/emux_proc.c
+++ b/sound/synth/emux/emux_proc.c
@@ -19,7 +19,6 @@
  */
 
 #include <linux/wait.h>
-#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/emux_synth.h>
 #include <sound/info.h>
diff --git a/sound/synth/emux/soundfont.c b/sound/synth/emux/soundfont.c
index 63c8f45c0c22..67c91230c197 100644
--- a/sound/synth/emux/soundfont.c
+++ b/sound/synth/emux/soundfont.c
@@ -374,7 +374,7 @@ sf_zone_new(struct snd_sf_list *sflist, struct snd_soundfont *sf)
 
 
 /*
- * increment sample couter
+ * increment sample counter
  */
 static void
 set_sample_counter(struct snd_sf_list *sflist, struct snd_soundfont *sf,
diff --git a/sound/usb/Kconfig b/sound/usb/Kconfig
index 73525c048e7f..c570ae3e6d55 100644
--- a/sound/usb/Kconfig
+++ b/sound/usb/Kconfig
@@ -21,6 +21,18 @@ config SND_USB_AUDIO
           To compile this driver as a module, choose M here: the module
           will be called snd-usb-audio.
 
+config SND_USB_UA101
+        tristate "Edirol UA-101/UA-1000 driver (EXPERIMENTAL)"
+        depends on EXPERIMENTAL
+        select SND_PCM
+        select SND_RAWMIDI
+        help
+          Say Y here to include support for the Edirol UA-101 and UA-1000
+          audio/MIDI interfaces.
+
+          To compile this driver as a module, choose M here: the module
+          will be called snd-ua101.
+
 config SND_USB_USX2Y
         tristate "Tascam US-122, US-224 and US-428 USB driver"
         depends on X86 || PPC || ALPHA
diff --git a/sound/usb/Makefile b/sound/usb/Makefile
index abb288bfe35d..5bf64aef9558 100644
--- a/sound/usb/Makefile
+++ b/sound/usb/Makefile
@@ -4,9 +4,11 @@
 
 snd-usb-audio-objs := usbaudio.o usbmixer.o
 snd-usb-lib-objs := usbmidi.o
+snd-ua101-objs := ua101.o
 
 # Toplevel Module Dependency
 obj-$(CONFIG_SND_USB_AUDIO) += snd-usb-audio.o snd-usb-lib.o
+obj-$(CONFIG_SND_USB_UA101) += snd-ua101.o snd-usb-lib.o
 obj-$(CONFIG_SND_USB_USX2Y) += snd-usb-lib.o
 obj-$(CONFIG_SND_USB_US122L) += snd-usb-lib.o
 
diff --git a/sound/usb/caiaq/audio.c b/sound/usb/caiaq/audio.c
index 86b2c3b92df5..4328cad6c3a2 100644
--- a/sound/usb/caiaq/audio.c
+++ b/sound/usb/caiaq/audio.c
@@ -17,6 +17,7 @@
 */
 
 #include <linux/spinlock.h>
+#include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/usb.h>
 #include <sound/core.h>
diff --git a/sound/usb/caiaq/device.c b/sound/usb/caiaq/device.c
index a3f02dd97440..afc5aeb68005 100644
--- a/sound/usb/caiaq/device.c
+++ b/sound/usb/caiaq/device.c
@@ -23,6 +23,7 @@
 #include <linux/interrupt.h>
 #include <linux/module.h>
 #include <linux/init.h>
+#include <linux/gfp.h>
 #include <linux/usb.h>
 #include <sound/initval.h>
 #include <sound/core.h>
diff --git a/sound/usb/caiaq/midi.c b/sound/usb/caiaq/midi.c
index 538e8c00d31a..2f218c77fff2 100644
--- a/sound/usb/caiaq/midi.c
+++ b/sound/usb/caiaq/midi.c
@@ -17,6 +17,7 @@
 */
 
 #include <linux/usb.h>
+#include <linux/gfp.h>
 #include <sound/rawmidi.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
diff --git a/sound/usb/caiaq/midi.h b/sound/usb/caiaq/midi.h
index 9d16db027fc3..380f984babc9 100644
--- a/sound/usb/caiaq/midi.h
+++ b/sound/usb/caiaq/midi.h
@@ -3,6 +3,6 @@
 
 int snd_usb_caiaq_midi_init(struct snd_usb_caiaqdev *dev);
 void snd_usb_caiaq_midi_handle_input(struct snd_usb_caiaqdev *dev, int port, const char *buf, int len);
-void snd_usb_caiaq_midi_output_done(struct urb* urb);
+void snd_usb_caiaq_midi_output_done(struct urb *urb);
 
 #endif /* CAIAQ_MIDI_H */
diff --git a/sound/usb/ua101.c b/sound/usb/ua101.c
new file mode 100644
index 000000000000..3d458d3b9962
--- /dev/null
+++ b/sound/usb/ua101.c
@@ -0,0 +1,1387 @@
+/*
+ * Edirol UA-101/UA-1000 driver
+ * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
+ *
+ * This driver is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 2.
+ *
+ * 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 driver.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/usb.h>
+#include <linux/usb/audio.h>
+#include <sound/core.h>
+#include <sound/initval.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include "usbaudio.h"
+
+MODULE_DESCRIPTION("Edirol UA-101/1000 driver");
+MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>");
+MODULE_LICENSE("GPL v2");
+MODULE_SUPPORTED_DEVICE("{{Edirol,UA-101},{Edirol,UA-1000}}");
+
+/*
+ * Should not be lower than the minimum scheduling delay of the host
+ * controller.  Some Intel controllers need more than one frame; as long as
+ * that driver doesn't tell us about this, use 1.5 frames just to be sure.
+ */
+#define MIN_QUEUE_LENGTH        12
+/* Somewhat random. */
+#define MAX_QUEUE_LENGTH        30
+/*
+ * This magic value optimizes memory usage efficiency for the UA-101's packet
+ * sizes at all sample rates, taking into account the stupid cache pool sizes
+ * that usb_buffer_alloc() uses.
+ */
+#define DEFAULT_QUEUE_LENGTH    21
+
+#define MAX_PACKET_SIZE         672 /* hardware specific */
+#define MAX_MEMORY_BUFFERS      DIV_ROUND_UP(MAX_QUEUE_LENGTH, \
+                                             PAGE_SIZE / MAX_PACKET_SIZE)
+
+static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
+static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
+static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
+static unsigned int queue_length = 21;
+
+module_param_array(index, int, NULL, 0444);
+MODULE_PARM_DESC(index, "card index");
+module_param_array(id, charp, NULL, 0444);
+MODULE_PARM_DESC(id, "ID string");
+module_param_array(enable, bool, NULL, 0444);
+MODULE_PARM_DESC(enable, "enable card");
+module_param(queue_length, uint, 0644);
+MODULE_PARM_DESC(queue_length, "USB queue length in microframes, "
+                 __stringify(MIN_QUEUE_LENGTH)"-"__stringify(MAX_QUEUE_LENGTH));
+
+enum {
+        INTF_PLAYBACK,
+        INTF_CAPTURE,
+        INTF_MIDI,
+
+        INTF_COUNT
+};
+
+/* bits in struct ua101::states */
+enum {
+        USB_CAPTURE_RUNNING,
+        USB_PLAYBACK_RUNNING,
+        ALSA_CAPTURE_OPEN,
+        ALSA_PLAYBACK_OPEN,
+        ALSA_CAPTURE_RUNNING,
+        ALSA_PLAYBACK_RUNNING,
+        CAPTURE_URB_COMPLETED,
+        PLAYBACK_URB_COMPLETED,
+        DISCONNECTED,
+};
+
+struct ua101 {
+        struct usb_device *dev;
+        struct snd_card *card;
+        struct usb_interface *intf[INTF_COUNT];
+        int card_index;
+        struct snd_pcm *pcm;
+        struct list_head midi_list;
+        u64 format_bit;
+        unsigned int rate;
+        unsigned int packets_per_second;
+        spinlock_t lock;
+        struct mutex mutex;
+        unsigned long states;
+
+        /* FIFO to synchronize playback rate to capture rate */
+        unsigned int rate_feedback_start;
+        unsigned int rate_feedback_count;
+        u8 rate_feedback[MAX_QUEUE_LENGTH];
+
+        struct list_head ready_playback_urbs;
+        struct tasklet_struct playback_tasklet;
+        wait_queue_head_t alsa_capture_wait;
+        wait_queue_head_t rate_feedback_wait;
+        wait_queue_head_t alsa_playback_wait;
+        struct ua101_stream {
+                struct snd_pcm_substream *substream;
+                unsigned int usb_pipe;
+                unsigned int channels;
+                unsigned int frame_bytes;
+                unsigned int max_packet_bytes;
+                unsigned int period_pos;
+                unsigned int buffer_pos;
+                unsigned int queue_length;
+                struct ua101_urb {
+                        struct urb urb;
+                        struct usb_iso_packet_descriptor iso_frame_desc[1];
+                        struct list_head ready_list;
+                } *urbs[MAX_QUEUE_LENGTH];
+                struct {
+                        unsigned int size;
+                        void *addr;
+                        dma_addr_t dma;
+                } buffers[MAX_MEMORY_BUFFERS];
+        } capture, playback;
+};
+
+static DEFINE_MUTEX(devices_mutex);
+static unsigned int devices_used;
+static struct usb_driver ua101_driver;
+
+static void abort_alsa_playback(struct ua101 *ua);
+static void abort_alsa_capture(struct ua101 *ua);
+
+static const char *usb_error_string(int err)
+{
+        switch (err) {
+        case -ENODEV:
+                return "no device";
+        case -ENOENT:
+                return "endpoint not enabled";
+        case -EPIPE:
+                return "endpoint stalled";
+        case -ENOSPC:
+                return "not enough bandwidth";
+        case -ESHUTDOWN:
+                return "device disabled";
+        case -EHOSTUNREACH:
+                return "device suspended";
+        case -EINVAL:
+        case -EAGAIN:
+        case -EFBIG:
+        case -EMSGSIZE:
+                return "internal error";
+        default:
+                return "unknown error";
+        }
+}
+
+static void abort_usb_capture(struct ua101 *ua)
+{
+        if (test_and_clear_bit(USB_CAPTURE_RUNNING, &ua->states)) {
+                wake_up(&ua->alsa_capture_wait);
+                wake_up(&ua->rate_feedback_wait);
+        }
+}
+
+static void abort_usb_playback(struct ua101 *ua)
+{
+        if (test_and_clear_bit(USB_PLAYBACK_RUNNING, &ua->states))
+                wake_up(&ua->alsa_playback_wait);
+}
+
+static void playback_urb_complete(struct urb *usb_urb)
+{
+        struct ua101_urb *urb = (struct ua101_urb *)usb_urb;
+        struct ua101 *ua = urb->urb.context;
+        unsigned long flags;
+
+        if (unlikely(urb->urb.status == -ENOENT ||      /* unlinked */
+                     urb->urb.status == -ENODEV ||      /* device removed */
+                     urb->urb.status == -ECONNRESET ||  /* unlinked */
+                     urb->urb.status == -ESHUTDOWN)) {  /* device disabled */
+                abort_usb_playback(ua);
+                abort_alsa_playback(ua);
+                return;
+        }
+
+        if (test_bit(USB_PLAYBACK_RUNNING, &ua->states)) {
+                /* append URB to FIFO */
+                spin_lock_irqsave(&ua->lock, flags);
+                list_add_tail(&urb->ready_list, &ua->ready_playback_urbs);
+                if (ua->rate_feedback_count > 0)
+                        tasklet_schedule(&ua->playback_tasklet);
+                ua->playback.substream->runtime->delay -=
+                                urb->urb.iso_frame_desc[0].length /
+                                                ua->playback.frame_bytes;
+                spin_unlock_irqrestore(&ua->lock, flags);
+        }
+}
+
+static void first_playback_urb_complete(struct urb *urb)
+{
+        struct ua101 *ua = urb->context;
+
+        urb->complete = playback_urb_complete;
+        playback_urb_complete(urb);
+
+        set_bit(PLAYBACK_URB_COMPLETED, &ua->states);
+        wake_up(&ua->alsa_playback_wait);
+}
+
+/* copy data from the ALSA ring buffer into the URB buffer */
+static bool copy_playback_data(struct ua101_stream *stream, struct urb *urb,
+                               unsigned int frames)
+{
+        struct snd_pcm_runtime *runtime;
+        unsigned int frame_bytes, frames1;
+        const u8 *source;
+
+        runtime = stream->substream->runtime;
+        frame_bytes = stream->frame_bytes;
+        source = runtime->dma_area + stream->buffer_pos * frame_bytes;
+        if (stream->buffer_pos + frames <= runtime->buffer_size) {
+                memcpy(urb->transfer_buffer, source, frames * frame_bytes);
+        } else {
+                /* wrap around at end of ring buffer */
+                frames1 = runtime->buffer_size - stream->buffer_pos;
+                memcpy(urb->transfer_buffer, source, frames1 * frame_bytes);
+                memcpy(urb->transfer_buffer + frames1 * frame_bytes,
+                       runtime->dma_area, (frames - frames1) * frame_bytes);
+        }
+
+        stream->buffer_pos += frames;
+        if (stream->buffer_pos >= runtime->buffer_size)
+                stream->buffer_pos -= runtime->buffer_size;
+        stream->period_pos += frames;
+        if (stream->period_pos >= runtime->period_size) {
+                stream->period_pos -= runtime->period_size;
+                return true;
+        }
+        return false;
+}
+
+static inline void add_with_wraparound(struct ua101 *ua,
+                                       unsigned int *value, unsigned int add)
+{
+        *value += add;
+        if (*value >= ua->playback.queue_length)
+                *value -= ua->playback.queue_length;
+}
+
+static void playback_tasklet(unsigned long data)
+{
+        struct ua101 *ua = (void *)data;
+        unsigned long flags;
+        unsigned int frames;
+        struct ua101_urb *urb;
+        bool do_period_elapsed = false;
+        int err;
+
+        if (unlikely(!test_bit(USB_PLAYBACK_RUNNING, &ua->states)))
+                return;
+
+        /*
+         * Synchronizing the playback rate to the capture rate is done by using
+         * the same sequence of packet sizes for both streams.
+         * Submitting a playback URB therefore requires both a ready URB and
+         * the size of the corresponding capture packet, i.e., both playback
+         * and capture URBs must have been completed.  Since the USB core does
+         * not guarantee that playback and capture complete callbacks are
+         * called alternately, we use two FIFOs for packet sizes and read URBs;
+         * submitting playback URBs is possible as long as both FIFOs are
+         * nonempty.
+         */
+        spin_lock_irqsave(&ua->lock, flags);
+        while (ua->rate_feedback_count > 0 &&
+               !list_empty(&ua->ready_playback_urbs)) {
+                /* take packet size out of FIFO */
+                frames = ua->rate_feedback[ua->rate_feedback_start];
+                add_with_wraparound(ua, &ua->rate_feedback_start, 1);
+                ua->rate_feedback_count--;
+
+                /* take URB out of FIFO */
+                urb = list_first_entry(&ua->ready_playback_urbs,
+                                       struct ua101_urb, ready_list);
+                list_del(&urb->ready_list);
+
+                /* fill packet with data or silence */
+                urb->urb.iso_frame_desc[0].length =
+                        frames * ua->playback.frame_bytes;
+                if (test_bit(ALSA_PLAYBACK_RUNNING, &ua->states))
+                        do_period_elapsed |= copy_playback_data(&ua->playback,
+                                                                &urb->urb,
+                                                                frames);
+                else
+                        memset(urb->urb.transfer_buffer, 0,
+                               urb->urb.iso_frame_desc[0].length);
+
+                /* and off you go ... */
+                err = usb_submit_urb(&urb->urb, GFP_ATOMIC);
+                if (unlikely(err < 0)) {
+                        spin_unlock_irqrestore(&ua->lock, flags);
+                        abort_usb_playback(ua);
+                        abort_alsa_playback(ua);
+                        dev_err(&ua->dev->dev, "USB request error %d: %s\n",
+                                err, usb_error_string(err));
+                        return;
+                }
+                ua->playback.substream->runtime->delay += frames;
+        }
+        spin_unlock_irqrestore(&ua->lock, flags);
+        if (do_period_elapsed)
+                snd_pcm_period_elapsed(ua->playback.substream);
+}
+
+/* copy data from the URB buffer into the ALSA ring buffer */
+static bool copy_capture_data(struct ua101_stream *stream, struct urb *urb,
+                              unsigned int frames)
+{
+        struct snd_pcm_runtime *runtime;
+        unsigned int frame_bytes, frames1;
+        u8 *dest;
+
+        runtime = stream->substream->runtime;
+        frame_bytes = stream->frame_bytes;
+        dest = runtime->dma_area + stream->buffer_pos * frame_bytes;
+        if (stream->buffer_pos + frames <= runtime->buffer_size) {
+                memcpy(dest, urb->transfer_buffer, frames * frame_bytes);
+        } else {
+                /* wrap around at end of ring buffer */
+                frames1 = runtime->buffer_size - stream->buffer_pos;
+                memcpy(dest, urb->transfer_buffer, frames1 * frame_bytes);
+                memcpy(runtime->dma_area,
+                       urb->transfer_buffer + frames1 * frame_bytes,
+                       (frames - frames1) * frame_bytes);
+        }
+
+        stream->buffer_pos += frames;
+        if (stream->buffer_pos >= runtime->buffer_size)
+                stream->buffer_pos -= runtime->buffer_size;
+        stream->period_pos += frames;
+        if (stream->period_pos >= runtime->period_size) {
+                stream->period_pos -= runtime->period_size;
+                return true;
+        }
+        return false;
+}
+
+static void capture_urb_complete(struct urb *urb)
+{
+        struct ua101 *ua = urb->context;
+        struct ua101_stream *stream = &ua->capture;
+        unsigned long flags;
+        unsigned int frames, write_ptr;
+        bool do_period_elapsed;
+        int err;
+
+        if (unlikely(urb->status == -ENOENT ||          /* unlinked */
+                     urb->status == -ENODEV ||          /* device removed */
+                     urb->status == -ECONNRESET ||      /* unlinked */
+                     urb->status == -ESHUTDOWN))        /* device disabled */
+                goto stream_stopped;
+
+        if (urb->status >= 0 && urb->iso_frame_desc[0].status >= 0)
+                frames = urb->iso_frame_desc[0].actual_length /
+                        stream->frame_bytes;
+        else
+                frames = 0;
+
+        spin_lock_irqsave(&ua->lock, flags);
+
+        if (frames > 0 && test_bit(ALSA_CAPTURE_RUNNING, &ua->states))
+                do_period_elapsed = copy_capture_data(stream, urb, frames);
+        else
+                do_period_elapsed = false;
+
+        if (test_bit(USB_CAPTURE_RUNNING, &ua->states)) {
+                err = usb_submit_urb(urb, GFP_ATOMIC);
+                if (unlikely(err < 0)) {
+                        spin_unlock_irqrestore(&ua->lock, flags);
+                        dev_err(&ua->dev->dev, "USB request error %d: %s\n",
+                                err, usb_error_string(err));
+                        goto stream_stopped;
+                }
+
+                /* append packet size to FIFO */
+                write_ptr = ua->rate_feedback_start;
+                add_with_wraparound(ua, &write_ptr, ua->rate_feedback_count);
+                ua->rate_feedback[write_ptr] = frames;
+                if (ua->rate_feedback_count < ua->playback.queue_length) {
+                        ua->rate_feedback_count++;
+                        if (ua->rate_feedback_count ==
+                                                ua->playback.queue_length)
+                                wake_up(&ua->rate_feedback_wait);
+                } else {
+                        /*
+                         * Ring buffer overflow; this happens when the playback
+                         * stream is not running.  Throw away the oldest entry,
+                         * so that the playback stream, when it starts, sees
+                         * the most recent packet sizes.
+                         */
+                        add_with_wraparound(ua, &ua->rate_feedback_start, 1);
+                }
+                if (test_bit(USB_PLAYBACK_RUNNING, &ua->states) &&
+                    !list_empty(&ua->ready_playback_urbs))
+                        tasklet_schedule(&ua->playback_tasklet);
+        }
+
+        spin_unlock_irqrestore(&ua->lock, flags);
+
+        if (do_period_elapsed)
+                snd_pcm_period_elapsed(stream->substream);
+
+        return;
+
+stream_stopped:
+        abort_usb_playback(ua);
+        abort_usb_capture(ua);
+        abort_alsa_playback(ua);
+        abort_alsa_capture(ua);
+}
+
+static void first_capture_urb_complete(struct urb *urb)
+{
+        struct ua101 *ua = urb->context;
+
+        urb->complete = capture_urb_complete;
+        capture_urb_complete(urb);
+
+        set_bit(CAPTURE_URB_COMPLETED, &ua->states);
+        wake_up(&ua->alsa_capture_wait);
+}
+
+static int submit_stream_urbs(struct ua101 *ua, struct ua101_stream *stream)
+{
+        unsigned int i;
+
+        for (i = 0; i < stream->queue_length; ++i) {
+                int err = usb_submit_urb(&stream->urbs[i]->urb, GFP_KERNEL);
+                if (err < 0) {
+                        dev_err(&ua->dev->dev, "USB request error %d: %s\n",
+                                err, usb_error_string(err));
+                        return err;
+                }
+        }
+        return 0;
+}
+
+static void kill_stream_urbs(struct ua101_stream *stream)
+{
+        unsigned int i;
+
+        for (i = 0; i < stream->queue_length; ++i)
+                usb_kill_urb(&stream->urbs[i]->urb);
+}
+
+static int enable_iso_interface(struct ua101 *ua, unsigned int intf_index)
+{
+        struct usb_host_interface *alts;
+
+        alts = ua->intf[intf_index]->cur_altsetting;
+        if (alts->desc.bAlternateSetting != 1) {
+                int err = usb_set_interface(ua->dev,
+                                            alts->desc.bInterfaceNumber, 1);
+                if (err < 0) {
+                        dev_err(&ua->dev->dev,
+                                "cannot initialize interface; error %d: %s\n",
+                                err, usb_error_string(err));
+                        return err;
+                }
+        }
+        return 0;
+}
+
+static void disable_iso_interface(struct ua101 *ua, unsigned int intf_index)
+{
+        struct usb_host_interface *alts;
+
+        alts = ua->intf[intf_index]->cur_altsetting;
+        if (alts->desc.bAlternateSetting != 0) {
+                int err = usb_set_interface(ua->dev,
+                                            alts->desc.bInterfaceNumber, 0);
+                if (err < 0 && !test_bit(DISCONNECTED, &ua->states))
+                        dev_warn(&ua->dev->dev,
+                                 "interface reset failed; error %d: %s\n",
+                                 err, usb_error_string(err));
+        }
+}
+
+static void stop_usb_capture(struct ua101 *ua)
+{
+        clear_bit(USB_CAPTURE_RUNNING, &ua->states);
+
+        kill_stream_urbs(&ua->capture);
+
+        disable_iso_interface(ua, INTF_CAPTURE);
+}
+
+static int start_usb_capture(struct ua101 *ua)
+{
+        int err;
+
+        if (test_bit(DISCONNECTED, &ua->states))
+                return -ENODEV;
+
+        if (test_bit(USB_CAPTURE_RUNNING, &ua->states))
+                return 0;
+
+        kill_stream_urbs(&ua->capture);
+
+        err = enable_iso_interface(ua, INTF_CAPTURE);
+        if (err < 0)
+                return err;
+
+        clear_bit(CAPTURE_URB_COMPLETED, &ua->states);
+        ua->capture.urbs[0]->urb.complete = first_capture_urb_complete;
+        ua->rate_feedback_start = 0;
+        ua->rate_feedback_count = 0;
+
+        set_bit(USB_CAPTURE_RUNNING, &ua->states);
+        err = submit_stream_urbs(ua, &ua->capture);
+        if (err < 0)
+                stop_usb_capture(ua);
+        return err;
+}
+
+static void stop_usb_playback(struct ua101 *ua)
+{
+        clear_bit(USB_PLAYBACK_RUNNING, &ua->states);
+
+        kill_stream_urbs(&ua->playback);
+
+        tasklet_kill(&ua->playback_tasklet);
+
+        disable_iso_interface(ua, INTF_PLAYBACK);
+}
+
+static int start_usb_playback(struct ua101 *ua)
+{
+        unsigned int i, frames;
+        struct urb *urb;
+        int err = 0;
+
+        if (test_bit(DISCONNECTED, &ua->states))
+                return -ENODEV;
+
+        if (test_bit(USB_PLAYBACK_RUNNING, &ua->states))
+                return 0;
+
+        kill_stream_urbs(&ua->playback);
+        tasklet_kill(&ua->playback_tasklet);
+
+        err = enable_iso_interface(ua, INTF_PLAYBACK);
+        if (err < 0)
+                return err;
+
+        clear_bit(PLAYBACK_URB_COMPLETED, &ua->states);
+        ua->playback.urbs[0]->urb.complete =
+                first_playback_urb_complete;
+        spin_lock_irq(&ua->lock);
+        INIT_LIST_HEAD(&ua->ready_playback_urbs);
+        spin_unlock_irq(&ua->lock);
+
+        /*
+         * We submit the initial URBs all at once, so we have to wait for the
+         * packet size FIFO to be full.
+         */
+        wait_event(ua->rate_feedback_wait,
+                   ua->rate_feedback_count >= ua->playback.queue_length ||
+                   !test_bit(USB_CAPTURE_RUNNING, &ua->states) ||
+                   test_bit(DISCONNECTED, &ua->states));
+        if (test_bit(DISCONNECTED, &ua->states)) {
+                stop_usb_playback(ua);
+                return -ENODEV;
+        }
+        if (!test_bit(USB_CAPTURE_RUNNING, &ua->states)) {
+                stop_usb_playback(ua);
+                return -EIO;
+        }
+
+        for (i = 0; i < ua->playback.queue_length; ++i) {
+                /* all initial URBs contain silence */
+                spin_lock_irq(&ua->lock);
+                frames = ua->rate_feedback[ua->rate_feedback_start];
+                add_with_wraparound(ua, &ua->rate_feedback_start, 1);
+                ua->rate_feedback_count--;
+                spin_unlock_irq(&ua->lock);
+                urb = &ua->playback.urbs[i]->urb;
+                urb->iso_frame_desc[0].length =
+                        frames * ua->playback.frame_bytes;
+                memset(urb->transfer_buffer, 0,
+                       urb->iso_frame_desc[0].length);
+        }
+
+        set_bit(USB_PLAYBACK_RUNNING, &ua->states);
+        err = submit_stream_urbs(ua, &ua->playback);
+        if (err < 0)
+                stop_usb_playback(ua);
+        return err;
+}
+
+static void abort_alsa_capture(struct ua101 *ua)
+{
+        if (test_bit(ALSA_CAPTURE_RUNNING, &ua->states))
+                snd_pcm_stop(ua->capture.substream, SNDRV_PCM_STATE_XRUN);
+}
+
+static void abort_alsa_playback(struct ua101 *ua)
+{
+        if (test_bit(ALSA_PLAYBACK_RUNNING, &ua->states))
+                snd_pcm_stop(ua->playback.substream, SNDRV_PCM_STATE_XRUN);
+}
+
+static int set_stream_hw(struct ua101 *ua, struct snd_pcm_substream *substream,
+                         unsigned int channels)
+{
+        int err;
+
+        substream->runtime->hw.info =
+                SNDRV_PCM_INFO_MMAP |
+                SNDRV_PCM_INFO_MMAP_VALID |
+                SNDRV_PCM_INFO_BATCH |
+                SNDRV_PCM_INFO_INTERLEAVED |
+                SNDRV_PCM_INFO_BLOCK_TRANSFER |
+                SNDRV_PCM_INFO_FIFO_IN_FRAMES;
+        substream->runtime->hw.formats = ua->format_bit;
+        substream->runtime->hw.rates = snd_pcm_rate_to_rate_bit(ua->rate);
+        substream->runtime->hw.rate_min = ua->rate;
+        substream->runtime->hw.rate_max = ua->rate;
+        substream->runtime->hw.channels_min = channels;
+        substream->runtime->hw.channels_max = channels;
+        substream->runtime->hw.buffer_bytes_max = 45000 * 1024;
+        substream->runtime->hw.period_bytes_min = 1;
+        substream->runtime->hw.period_bytes_max = UINT_MAX;
+        substream->runtime->hw.periods_min = 2;
+        substream->runtime->hw.periods_max = UINT_MAX;
+        err = snd_pcm_hw_constraint_minmax(substream->runtime,
+                                           SNDRV_PCM_HW_PARAM_PERIOD_TIME,
+                                           1500000 / ua->packets_per_second,
+                                           8192000);
+        if (err < 0)
+                return err;
+        err = snd_pcm_hw_constraint_msbits(substream->runtime, 0, 32, 24);
+        return err;
+}
+
+static int capture_pcm_open(struct snd_pcm_substream *substream)
+{
+        struct ua101 *ua = substream->private_data;
+        int err;
+
+        ua->capture.substream = substream;
+        err = set_stream_hw(ua, substream, ua->capture.channels);
+        if (err < 0)
+                return err;
+        substream->runtime->hw.fifo_size =
+                DIV_ROUND_CLOSEST(ua->rate, ua->packets_per_second);
+        substream->runtime->delay = substream->runtime->hw.fifo_size;
+
+        mutex_lock(&ua->mutex);
+        err = start_usb_capture(ua);
+        if (err >= 0)
+                set_bit(ALSA_CAPTURE_OPEN, &ua->states);
+        mutex_unlock(&ua->mutex);
+        return err;
+}
+
+static int playback_pcm_open(struct snd_pcm_substream *substream)
+{
+        struct ua101 *ua = substream->private_data;
+        int err;
+
+        ua->playback.substream = substream;
+        err = set_stream_hw(ua, substream, ua->playback.channels);
+        if (err < 0)
+                return err;
+        substream->runtime->hw.fifo_size =
+                DIV_ROUND_CLOSEST(ua->rate * ua->playback.queue_length,
+                                  ua->packets_per_second);
+
+        mutex_lock(&ua->mutex);
+        err = start_usb_capture(ua);
+        if (err < 0)
+                goto error;
+        err = start_usb_playback(ua);
+        if (err < 0) {
+                if (!test_bit(ALSA_CAPTURE_OPEN, &ua->states))
+                        stop_usb_capture(ua);
+                goto error;
+        }
+        set_bit(ALSA_PLAYBACK_OPEN, &ua->states);
+error:
+        mutex_unlock(&ua->mutex);
+        return err;
+}
+
+static int capture_pcm_close(struct snd_pcm_substream *substream)
+{
+        struct ua101 *ua = substream->private_data;
+
+        mutex_lock(&ua->mutex);
+        clear_bit(ALSA_CAPTURE_OPEN, &ua->states);
+        if (!test_bit(ALSA_PLAYBACK_OPEN, &ua->states))
+                stop_usb_capture(ua);
+        mutex_unlock(&ua->mutex);
+        return 0;
+}
+
+static int playback_pcm_close(struct snd_pcm_substream *substream)
+{
+        struct ua101 *ua = substream->private_data;
+
+        mutex_lock(&ua->mutex);
+        stop_usb_playback(ua);
+        clear_bit(ALSA_PLAYBACK_OPEN, &ua->states);
+        if (!test_bit(ALSA_CAPTURE_OPEN, &ua->states))
+                stop_usb_capture(ua);
+        mutex_unlock(&ua->mutex);
+        return 0;
+}
+
+static int capture_pcm_hw_params(struct snd_pcm_substream *substream,
+                                 struct snd_pcm_hw_params *hw_params)
+{
+        struct ua101 *ua = substream->private_data;
+        int err;
+
+        mutex_lock(&ua->mutex);
+        err = start_usb_capture(ua);
+        mutex_unlock(&ua->mutex);
+        if (err < 0)
+                return err;
+
+        return snd_pcm_lib_alloc_vmalloc_buffer(substream,
+                                                params_buffer_bytes(hw_params));
+}
+
+static int playback_pcm_hw_params(struct snd_pcm_substream *substream,
+                                  struct snd_pcm_hw_params *hw_params)
+{
+        struct ua101 *ua = substream->private_data;
+        int err;
+
+        mutex_lock(&ua->mutex);
+        err = start_usb_capture(ua);
+        if (err >= 0)
+                err = start_usb_playback(ua);
+        mutex_unlock(&ua->mutex);
+        if (err < 0)
+                return err;
+
+        return snd_pcm_lib_alloc_vmalloc_buffer(substream,
+                                                params_buffer_bytes(hw_params));
+}
+
+static int ua101_pcm_hw_free(struct snd_pcm_substream *substream)
+{
+        return snd_pcm_lib_free_vmalloc_buffer(substream);
+}
+
+static int capture_pcm_prepare(struct snd_pcm_substream *substream)
+{
+        struct ua101 *ua = substream->private_data;
+        int err;
+
+        mutex_lock(&ua->mutex);
+        err = start_usb_capture(ua);
+        mutex_unlock(&ua->mutex);
+        if (err < 0)
+                return err;
+
+        /*
+         * The EHCI driver schedules the first packet of an iso stream at 10 ms
+         * in the future, i.e., no data is actually captured for that long.
+         * Take the wait here so that the stream is known to be actually
+         * running when the start trigger has been called.
+         */
+        wait_event(ua->alsa_capture_wait,
+                   test_bit(CAPTURE_URB_COMPLETED, &ua->states) ||
+                   !test_bit(USB_CAPTURE_RUNNING, &ua->states));
+        if (test_bit(DISCONNECTED, &ua->states))
+                return -ENODEV;
+        if (!test_bit(USB_CAPTURE_RUNNING, &ua->states))
+                return -EIO;
+
+        ua->capture.period_pos = 0;
+        ua->capture.buffer_pos = 0;
+        return 0;
+}
+
+static int playback_pcm_prepare(struct snd_pcm_substream *substream)
+{
+        struct ua101 *ua = substream->private_data;
+        int err;
+
+        mutex_lock(&ua->mutex);
+        err = start_usb_capture(ua);
+        if (err >= 0)
+                err = start_usb_playback(ua);
+        mutex_unlock(&ua->mutex);
+        if (err < 0)
+                return err;
+
+        /* see the comment in capture_pcm_prepare() */
+        wait_event(ua->alsa_playback_wait,
+                   test_bit(PLAYBACK_URB_COMPLETED, &ua->states) ||
+                   !test_bit(USB_PLAYBACK_RUNNING, &ua->states));
+        if (test_bit(DISCONNECTED, &ua->states))
+                return -ENODEV;
+        if (!test_bit(USB_PLAYBACK_RUNNING, &ua->states))
+                return -EIO;
+
+        substream->runtime->delay = 0;
+        ua->playback.period_pos = 0;
+        ua->playback.buffer_pos = 0;
+        return 0;
+}
+
+static int capture_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
+{
+        struct ua101 *ua = substream->private_data;
+
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+                if (!test_bit(USB_CAPTURE_RUNNING, &ua->states))
+                        return -EIO;
+                set_bit(ALSA_CAPTURE_RUNNING, &ua->states);
+                return 0;
+        case SNDRV_PCM_TRIGGER_STOP:
+                clear_bit(ALSA_CAPTURE_RUNNING, &ua->states);
+                return 0;
+        default:
+                return -EINVAL;
+        }
+}
+
+static int playback_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
+{
+        struct ua101 *ua = substream->private_data;
+
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+                if (!test_bit(USB_PLAYBACK_RUNNING, &ua->states))
+                        return -EIO;
+                set_bit(ALSA_PLAYBACK_RUNNING, &ua->states);
+                return 0;
+        case SNDRV_PCM_TRIGGER_STOP:
+                clear_bit(ALSA_PLAYBACK_RUNNING, &ua->states);
+                return 0;
+        default:
+                return -EINVAL;
+        }
+}
+
+static inline snd_pcm_uframes_t ua101_pcm_pointer(struct ua101 *ua,
+                                                  struct ua101_stream *stream)
+{
+        unsigned long flags;
+        unsigned int pos;
+
+        spin_lock_irqsave(&ua->lock, flags);
+        pos = stream->buffer_pos;
+        spin_unlock_irqrestore(&ua->lock, flags);
+        return pos;
+}
+
+static snd_pcm_uframes_t capture_pcm_pointer(struct snd_pcm_substream *subs)
+{
+        struct ua101 *ua = subs->private_data;
+
+        return ua101_pcm_pointer(ua, &ua->capture);
+}
+
+static snd_pcm_uframes_t playback_pcm_pointer(struct snd_pcm_substream *subs)
+{
+        struct ua101 *ua = subs->private_data;
+
+        return ua101_pcm_pointer(ua, &ua->playback);
+}
+
+static struct snd_pcm_ops capture_pcm_ops = {
+        .open = capture_pcm_open,
+        .close = capture_pcm_close,
+        .ioctl = snd_pcm_lib_ioctl,
+        .hw_params = capture_pcm_hw_params,
+        .hw_free = ua101_pcm_hw_free,
+        .prepare = capture_pcm_prepare,
+        .trigger = capture_pcm_trigger,
+        .pointer = capture_pcm_pointer,
+        .page = snd_pcm_lib_get_vmalloc_page,
+        .mmap = snd_pcm_lib_mmap_vmalloc,
+};
+
+static struct snd_pcm_ops playback_pcm_ops = {
+        .open = playback_pcm_open,
+        .close = playback_pcm_close,
+        .ioctl = snd_pcm_lib_ioctl,
+        .hw_params = playback_pcm_hw_params,
+        .hw_free = ua101_pcm_hw_free,
+        .prepare = playback_pcm_prepare,
+        .trigger = playback_pcm_trigger,
+        .pointer = playback_pcm_pointer,
+        .page = snd_pcm_lib_get_vmalloc_page,
+        .mmap = snd_pcm_lib_mmap_vmalloc,
+};
+
+static const struct uac_format_type_i_discrete_descriptor *
+find_format_descriptor(struct usb_interface *interface)
+{
+        struct usb_host_interface *alt;
+        u8 *extra;
+        int extralen;
+
+        if (interface->num_altsetting != 2) {
+                dev_err(&interface->dev, "invalid num_altsetting\n");
+                return NULL;
+        }
+
+        alt = &interface->altsetting[0];
+        if (alt->desc.bNumEndpoints != 0) {
+                dev_err(&interface->dev, "invalid bNumEndpoints\n");
+                return NULL;
+        }
+
+        alt = &interface->altsetting[1];
+        if (alt->desc.bNumEndpoints != 1) {
+                dev_err(&interface->dev, "invalid bNumEndpoints\n");
+                return NULL;
+        }
+
+        extra = alt->extra;
+        extralen = alt->extralen;
+        while (extralen >= sizeof(struct usb_descriptor_header)) {
+                struct uac_format_type_i_discrete_descriptor *desc;
+
+                desc = (struct uac_format_type_i_discrete_descriptor *)extra;
+                if (desc->bLength > extralen) {
+                        dev_err(&interface->dev, "descriptor overflow\n");
+                        return NULL;
+                }
+                if (desc->bLength == UAC_FORMAT_TYPE_I_DISCRETE_DESC_SIZE(1) &&
+                    desc->bDescriptorType == USB_DT_CS_INTERFACE &&
+                    desc->bDescriptorSubtype == UAC_FORMAT_TYPE) {
+                        if (desc->bFormatType != UAC_FORMAT_TYPE_I_PCM ||
+                            desc->bSamFreqType != 1) {
+                                dev_err(&interface->dev,
+                                        "invalid format type\n");
+                                return NULL;
+                        }
+                        return desc;
+                }
+                extralen -= desc->bLength;
+                extra += desc->bLength;
+        }
+        dev_err(&interface->dev, "sample format descriptor not found\n");
+        return NULL;
+}
+
+static int detect_usb_format(struct ua101 *ua)
+{
+        const struct uac_format_type_i_discrete_descriptor *fmt_capture;
+        const struct uac_format_type_i_discrete_descriptor *fmt_playback;
+        const struct usb_endpoint_descriptor *epd;
+        unsigned int rate2;
+
+        fmt_capture = find_format_descriptor(ua->intf[INTF_CAPTURE]);
+        fmt_playback = find_format_descriptor(ua->intf[INTF_PLAYBACK]);
+        if (!fmt_capture || !fmt_playback)
+                return -ENXIO;
+
+        switch (fmt_capture->bSubframeSize) {
+        case 3:
+                ua->format_bit = SNDRV_PCM_FMTBIT_S24_3LE;
+                break;
+        case 4:
+                ua->format_bit = SNDRV_PCM_FMTBIT_S32_LE;
+                break;
+        default:
+                dev_err(&ua->dev->dev, "sample width is not 24 or 32 bits\n");
+                return -ENXIO;
+        }
+        if (fmt_capture->bSubframeSize != fmt_playback->bSubframeSize) {
+                dev_err(&ua->dev->dev,
+                        "playback/capture sample widths do not match\n");
+                return -ENXIO;
+        }
+
+        if (fmt_capture->bBitResolution != 24 ||
+            fmt_playback->bBitResolution != 24) {
+                dev_err(&ua->dev->dev, "sample width is not 24 bits\n");
+                return -ENXIO;
+        }
+
+        ua->rate = combine_triple(fmt_capture->tSamFreq[0]);
+        rate2 = combine_triple(fmt_playback->tSamFreq[0]);
+        if (ua->rate != rate2) {
+                dev_err(&ua->dev->dev,
+                        "playback/capture rates do not match: %u/%u\n",
+                        rate2, ua->rate);
+                return -ENXIO;
+        }
+
+        switch (ua->dev->speed) {
+        case USB_SPEED_FULL:
+                ua->packets_per_second = 1000;
+                break;
+        case USB_SPEED_HIGH:
+                ua->packets_per_second = 8000;
+                break;
+        default:
+                dev_err(&ua->dev->dev, "unknown device speed\n");
+                return -ENXIO;
+        }
+
+        ua->capture.channels = fmt_capture->bNrChannels;
+        ua->playback.channels = fmt_playback->bNrChannels;
+        ua->capture.frame_bytes =
+                fmt_capture->bSubframeSize * ua->capture.channels;
+        ua->playback.frame_bytes =
+                fmt_playback->bSubframeSize * ua->playback.channels;
+
+        epd = &ua->intf[INTF_CAPTURE]->altsetting[1].endpoint[0].desc;
+        if (!usb_endpoint_is_isoc_in(epd)) {
+                dev_err(&ua->dev->dev, "invalid capture endpoint\n");
+                return -ENXIO;
+        }
+        ua->capture.usb_pipe = usb_rcvisocpipe(ua->dev, usb_endpoint_num(epd));
+        ua->capture.max_packet_bytes = le16_to_cpu(epd->wMaxPacketSize);
+
+        epd = &ua->intf[INTF_PLAYBACK]->altsetting[1].endpoint[0].desc;
+        if (!usb_endpoint_is_isoc_out(epd)) {
+                dev_err(&ua->dev->dev, "invalid playback endpoint\n");
+                return -ENXIO;
+        }
+        ua->playback.usb_pipe = usb_sndisocpipe(ua->dev, usb_endpoint_num(epd));
+        ua->playback.max_packet_bytes = le16_to_cpu(epd->wMaxPacketSize);
+        return 0;
+}
+
+static int alloc_stream_buffers(struct ua101 *ua, struct ua101_stream *stream)
+{
+        unsigned int remaining_packets, packets, packets_per_page, i;
+        size_t size;
+
+        stream->queue_length = queue_length;
+        stream->queue_length = max(stream->queue_length,
+                                   (unsigned int)MIN_QUEUE_LENGTH);
+        stream->queue_length = min(stream->queue_length,
+                                   (unsigned int)MAX_QUEUE_LENGTH);
+
+        /*
+         * The cache pool sizes used by usb_buffer_alloc() (128, 512, 2048) are
+         * quite bad when used with the packet sizes of this device (e.g. 280,
+         * 520, 624).  Therefore, we allocate and subdivide entire pages, using
+         * a smaller buffer only for the last chunk.
+         */
+        remaining_packets = stream->queue_length;
+        packets_per_page = PAGE_SIZE / stream->max_packet_bytes;
+        for (i = 0; i < ARRAY_SIZE(stream->buffers); ++i) {
+                packets = min(remaining_packets, packets_per_page);
+                size = packets * stream->max_packet_bytes;
+                stream->buffers[i].addr =
+                        usb_buffer_alloc(ua->dev, size, GFP_KERNEL,
+                                         &stream->buffers[i].dma);
+                if (!stream->buffers[i].addr)
+                        return -ENOMEM;
+                stream->buffers[i].size = size;
+                remaining_packets -= packets;
+                if (!remaining_packets)
+                        break;
+        }
+        if (remaining_packets) {
+                dev_err(&ua->dev->dev, "too many packets\n");
+                return -ENXIO;
+        }
+        return 0;
+}
+
+static void free_stream_buffers(struct ua101 *ua, struct ua101_stream *stream)
+{
+        unsigned int i;
+
+        for (i = 0; i < ARRAY_SIZE(stream->buffers); ++i)
+                usb_buffer_free(ua->dev,
+                                stream->buffers[i].size,
+                                stream->buffers[i].addr,
+                                stream->buffers[i].dma);
+}
+
+static int alloc_stream_urbs(struct ua101 *ua, struct ua101_stream *stream,
+                             void (*urb_complete)(struct urb *))
+{
+        unsigned max_packet_size = stream->max_packet_bytes;
+        struct ua101_urb *urb;
+        unsigned int b, u = 0;
+
+        for (b = 0; b < ARRAY_SIZE(stream->buffers); ++b) {
+                unsigned int size = stream->buffers[b].size;
+                u8 *addr = stream->buffers[b].addr;
+                dma_addr_t dma = stream->buffers[b].dma;
+
+                while (size >= max_packet_size) {
+                        if (u >= stream->queue_length)
+                                goto bufsize_error;
+                        urb = kmalloc(sizeof(*urb), GFP_KERNEL);
+                        if (!urb)
+                                return -ENOMEM;
+                        usb_init_urb(&urb->urb);
+                        urb->urb.dev = ua->dev;
+                        urb->urb.pipe = stream->usb_pipe;
+                        urb->urb.transfer_flags = URB_ISO_ASAP |
+                                        URB_NO_TRANSFER_DMA_MAP;
+                        urb->urb.transfer_buffer = addr;
+                        urb->urb.transfer_dma = dma;
+                        urb->urb.transfer_buffer_length = max_packet_size;
+                        urb->urb.number_of_packets = 1;
+                        urb->urb.interval = 1;
+                        urb->urb.context = ua;
+                        urb->urb.complete = urb_complete;
+                        urb->urb.iso_frame_desc[0].offset = 0;
+                        urb->urb.iso_frame_desc[0].length = max_packet_size;
+                        stream->urbs[u++] = urb;
+                        size -= max_packet_size;
+                        addr += max_packet_size;
+                        dma += max_packet_size;
+                }
+        }
+        if (u == stream->queue_length)
+                return 0;
+bufsize_error:
+        dev_err(&ua->dev->dev, "internal buffer size error\n");
+        return -ENXIO;
+}
+
+static void free_stream_urbs(struct ua101_stream *stream)
+{
+        unsigned int i;
+
+        for (i = 0; i < stream->queue_length; ++i)
+                kfree(stream->urbs[i]);
+}
+
+static void free_usb_related_resources(struct ua101 *ua,
+                                       struct usb_interface *interface)
+{
+        unsigned int i;
+
+        free_stream_urbs(&ua->capture);
+        free_stream_urbs(&ua->playback);
+        free_stream_buffers(ua, &ua->capture);
+        free_stream_buffers(ua, &ua->playback);
+
+        for (i = 0; i < ARRAY_SIZE(ua->intf); ++i)
+                if (ua->intf[i]) {
+                        usb_set_intfdata(ua->intf[i], NULL);
+                        if (ua->intf[i] != interface)
+                                usb_driver_release_interface(&ua101_driver,
+                                                             ua->intf[i]);
+                }
+}
+
+static void ua101_card_free(struct snd_card *card)
+{
+        struct ua101 *ua = card->private_data;
+
+        mutex_destroy(&ua->mutex);
+}
+
+static int ua101_probe(struct usb_interface *interface,
+                       const struct usb_device_id *usb_id)
+{
+        static const struct snd_usb_midi_endpoint_info midi_ep = {
+                .out_cables = 0x0001,
+                .in_cables = 0x0001
+        };
+        static const struct snd_usb_audio_quirk midi_quirk = {
+                .type = QUIRK_MIDI_FIXED_ENDPOINT,
+                .data = &midi_ep
+        };
+        static const int intf_numbers[2][3] = {
+                {       /* UA-101 */
+                        [INTF_PLAYBACK] = 0,
+                        [INTF_CAPTURE] = 1,
+                        [INTF_MIDI] = 2,
+                },
+                {       /* UA-1000 */
+                        [INTF_CAPTURE] = 1,
+                        [INTF_PLAYBACK] = 2,
+                        [INTF_MIDI] = 3,
+                },
+        };
+        struct snd_card *card;
+        struct ua101 *ua;
+        unsigned int card_index, i;
+        int is_ua1000;
+        const char *name;
+        char usb_path[32];
+        int err;
+
+        is_ua1000 = usb_id->idProduct == 0x0044;
+
+        if (interface->altsetting->desc.bInterfaceNumber !=
+            intf_numbers[is_ua1000][0])
+                return -ENODEV;
+
+        mutex_lock(&devices_mutex);
+
+        for (card_index = 0; card_index < SNDRV_CARDS; ++card_index)
+                if (enable[card_index] && !(devices_used & (1 << card_index)))
+                        break;
+        if (card_index >= SNDRV_CARDS) {
+                mutex_unlock(&devices_mutex);
+                return -ENOENT;
+        }
+        err = snd_card_create(index[card_index], id[card_index], THIS_MODULE,
+                              sizeof(*ua), &card);
+        if (err < 0) {
+                mutex_unlock(&devices_mutex);
+                return err;
+        }
+        card->private_free = ua101_card_free;
+        ua = card->private_data;
+        ua->dev = interface_to_usbdev(interface);
+        ua->card = card;
+        ua->card_index = card_index;
+        INIT_LIST_HEAD(&ua->midi_list);
+        spin_lock_init(&ua->lock);
+        mutex_init(&ua->mutex);
+        INIT_LIST_HEAD(&ua->ready_playback_urbs);
+        tasklet_init(&ua->playback_tasklet,
+                     playback_tasklet, (unsigned long)ua);
+        init_waitqueue_head(&ua->alsa_capture_wait);
+        init_waitqueue_head(&ua->rate_feedback_wait);
+        init_waitqueue_head(&ua->alsa_playback_wait);
+
+        ua->intf[0] = interface;
+        for (i = 1; i < ARRAY_SIZE(ua->intf); ++i) {
+                ua->intf[i] = usb_ifnum_to_if(ua->dev,
+                                              intf_numbers[is_ua1000][i]);
+                if (!ua->intf[i]) {
+                        dev_err(&ua->dev->dev, "interface %u not found\n",
+                                intf_numbers[is_ua1000][i]);
+                        err = -ENXIO;
+                        goto probe_error;
+                }
+                err = usb_driver_claim_interface(&ua101_driver,
+                                                 ua->intf[i], ua);
+                if (err < 0) {
+                        ua->intf[i] = NULL;
+                        err = -EBUSY;
+                        goto probe_error;
+                }
+        }
+
+        snd_card_set_dev(card, &interface->dev);
+
+        err = detect_usb_format(ua);
+        if (err < 0)
+                goto probe_error;
+
+        name = usb_id->idProduct == 0x0044 ? "UA-1000" : "UA-101";
+        strcpy(card->driver, "UA-101");
+        strcpy(card->shortname, name);
+        usb_make_path(ua->dev, usb_path, sizeof(usb_path));
+        snprintf(ua->card->longname, sizeof(ua->card->longname),
+                 "EDIROL %s (serial %s), %u Hz at %s, %s speed", name,
+                 ua->dev->serial ? ua->dev->serial : "?", ua->rate, usb_path,
+                 ua->dev->speed == USB_SPEED_HIGH ? "high" : "full");
+
+        err = alloc_stream_buffers(ua, &ua->capture);
+        if (err < 0)
+                goto probe_error;
+        err = alloc_stream_buffers(ua, &ua->playback);
+        if (err < 0)
+                goto probe_error;
+
+        err = alloc_stream_urbs(ua, &ua->capture, capture_urb_complete);
+        if (err < 0)
+                goto probe_error;
+        err = alloc_stream_urbs(ua, &ua->playback, playback_urb_complete);
+        if (err < 0)
+                goto probe_error;
+
+        err = snd_pcm_new(card, name, 0, 1, 1, &ua->pcm);
+        if (err < 0)
+                goto probe_error;
+        ua->pcm->private_data = ua;
+        strcpy(ua->pcm->name, name);
+        snd_pcm_set_ops(ua->pcm, SNDRV_PCM_STREAM_PLAYBACK, &playback_pcm_ops);
+        snd_pcm_set_ops(ua->pcm, SNDRV_PCM_STREAM_CAPTURE, &capture_pcm_ops);
+
+        err = snd_usbmidi_create(card, ua->intf[INTF_MIDI],
+                                 &ua->midi_list, &midi_quirk);
+        if (err < 0)
+                goto probe_error;
+
+        err = snd_card_register(card);
+        if (err < 0)
+                goto probe_error;
+
+        usb_set_intfdata(interface, ua);
+        devices_used |= 1 << card_index;
+
+        mutex_unlock(&devices_mutex);
+        return 0;
+
+probe_error:
+        free_usb_related_resources(ua, interface);
+        snd_card_free(card);
+        mutex_unlock(&devices_mutex);
+        return err;
+}
+
+static void ua101_disconnect(struct usb_interface *interface)
+{
+        struct ua101 *ua = usb_get_intfdata(interface);
+        struct list_head *midi;
+
+        if (!ua)
+                return;
+
+        mutex_lock(&devices_mutex);
+
+        set_bit(DISCONNECTED, &ua->states);
+        wake_up(&ua->rate_feedback_wait);
+
+        /* make sure that userspace cannot create new requests */
+        snd_card_disconnect(ua->card);
+
+        /* make sure that there are no pending USB requests */
+        __list_for_each(midi, &ua->midi_list)
+                snd_usbmidi_disconnect(midi);
+        abort_alsa_playback(ua);
+        abort_alsa_capture(ua);
+        mutex_lock(&ua->mutex);
+        stop_usb_playback(ua);
+        stop_usb_capture(ua);
+        mutex_unlock(&ua->mutex);
+
+        free_usb_related_resources(ua, interface);
+
+        devices_used &= ~(1 << ua->card_index);
+
+        snd_card_free_when_closed(ua->card);
+
+        mutex_unlock(&devices_mutex);
+}
+
+static struct usb_device_id ua101_ids[] = {
+        { USB_DEVICE(0x0582, 0x0044) }, /* UA-1000 high speed */
+        { USB_DEVICE(0x0582, 0x007d) }, /* UA-101 high speed */
+        { USB_DEVICE(0x0582, 0x008d) }, /* UA-101 full speed */
+        { }
+};
+MODULE_DEVICE_TABLE(usb, ua101_ids);
+
+static struct usb_driver ua101_driver = {
+        .name = "snd-ua101",
+        .id_table = ua101_ids,
+        .probe = ua101_probe,
+        .disconnect = ua101_disconnect,
+#if 0
+        .suspend = ua101_suspend,
+        .resume = ua101_resume,
+#endif
+};
+
+static int __init alsa_card_ua101_init(void)
+{
+        return usb_register(&ua101_driver);
+}
+
+static void __exit alsa_card_ua101_exit(void)
+{
+        usb_deregister(&ua101_driver);
+        mutex_destroy(&devices_mutex);
+}
+
+module_init(alsa_card_ua101_init);
+module_exit(alsa_card_ua101_exit);
diff --git a/sound/usb/usbaudio.c b/sound/usb/usbaudio.c
index 8db0374e10d5..11b0826b8fe6 100644
--- a/sound/usb/usbaudio.c
+++ b/sound/usb/usbaudio.c
@@ -44,9 +44,11 @@
 #include <linux/slab.h>
 #include <linux/string.h>
 #include <linux/usb.h>
-#include <linux/vmalloc.h>
 #include <linux/moduleparam.h>
 #include <linux/mutex.h>
+#include <linux/usb/audio.h>
+#include <linux/usb/ch9.h>
+
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/pcm.h>
@@ -170,11 +172,12 @@ struct snd_usb_substream {
         unsigned int curpacksize;       /* current packet size in bytes (for capture) */
         unsigned int curframesize;      /* current packet size in frames (for capture) */
         unsigned int fill_max: 1;       /* fill max packet size always */
+        unsigned int txfr_quirk:1;      /* allow sub-frame alignment */
         unsigned int fmt_type;          /* USB audio format type (1-3) */
 
         unsigned int running: 1;        /* running status */
 
-        unsigned int hwptr_done;                        /* processed frame position in the buffer */
+        unsigned int hwptr_done;        /* processed byte position in the buffer */
         unsigned int transfer_done;             /* processed frames since last period update */
         unsigned long active_mask;      /* bitmask of active urbs */
         unsigned long unlink_mask;      /* bitmask of unlinked urbs */
@@ -343,7 +346,7 @@ static int retire_capture_urb(struct snd_usb_substream *subs,
         unsigned long flags;
         unsigned char *cp;
         int i;
-        unsigned int stride, len, oldptr;
+        unsigned int stride, frames, bytes, oldptr;
         int period_elapsed = 0;
 
         stride = runtime->frame_bits >> 3;
@@ -354,29 +357,39 @@ static int retire_capture_urb(struct snd_usb_substream *subs,
                         snd_printd(KERN_ERR "frame %d active: %d\n", i, urb->iso_frame_desc[i].status);
                         // continue;
                 }
-                len = urb->iso_frame_desc[i].actual_length / stride;
-                if (! len)
-                        continue;
+                bytes = urb->iso_frame_desc[i].actual_length;
+                frames = bytes / stride;
+                if (!subs->txfr_quirk)
+                        bytes = frames * stride;
+                if (bytes % (runtime->sample_bits >> 3) != 0) {
+#ifdef CONFIG_SND_DEBUG_VERBOSE
+                        int oldbytes = bytes;
+#endif
+                        bytes = frames * stride;
+                        snd_printdd(KERN_ERR "Corrected urb data len. %d->%d\n",
+                                                        oldbytes, bytes);
+                }
                 /* update the current pointer */
                 spin_lock_irqsave(&subs->lock, flags);
                 oldptr = subs->hwptr_done;
-                subs->hwptr_done += len;
-                if (subs->hwptr_done >= runtime->buffer_size)
-                        subs->hwptr_done -= runtime->buffer_size;
-                subs->transfer_done += len;
+                subs->hwptr_done += bytes;
+                if (subs->hwptr_done >= runtime->buffer_size * stride)
+                        subs->hwptr_done -= runtime->buffer_size * stride;
+                frames = (bytes + (oldptr % stride)) / stride;
+                subs->transfer_done += frames;
                 if (subs->transfer_done >= runtime->period_size) {
                         subs->transfer_done -= runtime->period_size;
                         period_elapsed = 1;
                 }
                 spin_unlock_irqrestore(&subs->lock, flags);
                 /* copy a data chunk */
-                if (oldptr + len > runtime->buffer_size) {
-                        unsigned int cnt = runtime->buffer_size - oldptr;
-                        unsigned int blen = cnt * stride;
-                        memcpy(runtime->dma_area + oldptr * stride, cp, blen);
-                        memcpy(runtime->dma_area, cp + blen, len * stride - blen);
+                if (oldptr + bytes > runtime->buffer_size * stride) {
+                        unsigned int bytes1 =
+                                        runtime->buffer_size * stride - oldptr;
+                        memcpy(runtime->dma_area + oldptr, cp, bytes1);
+                        memcpy(runtime->dma_area, cp + bytes1, bytes - bytes1);
                 } else {
-                        memcpy(runtime->dma_area + oldptr * stride, cp, len * stride);
+                        memcpy(runtime->dma_area + oldptr, cp, bytes);
                 }
         }
         if (period_elapsed)
@@ -563,34 +576,34 @@ static int prepare_playback_urb(struct snd_usb_substream *subs,
                                 struct snd_pcm_runtime *runtime,
                                 struct urb *urb)
 {
-        int i, stride, offs;
-        unsigned int counts;
+        int i, stride;
+        unsigned int counts, frames, bytes;
         unsigned long flags;
         int period_elapsed = 0;
         struct snd_urb_ctx *ctx = urb->context;
 
         stride = runtime->frame_bits >> 3;
 
-        offs = 0;
+        frames = 0;
         urb->dev = ctx->subs->dev; /* we need to set this at each time */
         urb->number_of_packets = 0;
         spin_lock_irqsave(&subs->lock, flags);
         for (i = 0; i < ctx->packets; i++) {
                 counts = snd_usb_audio_next_packet_size(subs);
                 /* set up descriptor */
-                urb->iso_frame_desc[i].offset = offs * stride;
+                urb->iso_frame_desc[i].offset = frames * stride;
                 urb->iso_frame_desc[i].length = counts * stride;
-                offs += counts;
+                frames += counts;
                 urb->number_of_packets++;
                 subs->transfer_done += counts;
                 if (subs->transfer_done >= runtime->period_size) {
                         subs->transfer_done -= runtime->period_size;
                         period_elapsed = 1;
-                        if (subs->fmt_type == USB_FORMAT_TYPE_II) {
+                        if (subs->fmt_type == UAC_FORMAT_TYPE_II) {
                                 if (subs->transfer_done > 0) {
                                         /* FIXME: fill-max mode is not
                                          * supported yet */
-                                        offs -= subs->transfer_done;
+                                        frames -= subs->transfer_done;
                                         counts -= subs->transfer_done;
                                         urb->iso_frame_desc[i].length =
                                                 counts * stride;
@@ -600,7 +613,7 @@ static int prepare_playback_urb(struct snd_usb_substream *subs,
                                 if (i < ctx->packets) {
                                         /* add a transfer delimiter */
                                         urb->iso_frame_desc[i].offset =
-                                                offs * stride;
+                                                frames * stride;
                                         urb->iso_frame_desc[i].length = 0;
                                         urb->number_of_packets++;
                                 }
@@ -610,26 +623,25 @@ static int prepare_playback_urb(struct snd_usb_substream *subs,
                 if (period_elapsed) /* finish at the period boundary */
                         break;
         }
-        if (subs->hwptr_done + offs > runtime->buffer_size) {
+        bytes = frames * stride;
+        if (subs->hwptr_done + bytes > runtime->buffer_size * stride) {
                 /* err, the transferred area goes over buffer boundary. */
-                unsigned int len = runtime->buffer_size - subs->hwptr_done;
+                unsigned int bytes1 =
+                        runtime->buffer_size * stride - subs->hwptr_done;
                 memcpy(urb->transfer_buffer,
-                       runtime->dma_area + subs->hwptr_done * stride,
-                       len * stride);
-                memcpy(urb->transfer_buffer + len * stride,
-                       runtime->dma_area,
-                       (offs - len) * stride);
+                       runtime->dma_area + subs->hwptr_done, bytes1);
+                memcpy(urb->transfer_buffer + bytes1,
+                       runtime->dma_area, bytes - bytes1);
         } else {
                 memcpy(urb->transfer_buffer,
-                       runtime->dma_area + subs->hwptr_done * stride,
-                       offs * stride);
+                       runtime->dma_area + subs->hwptr_done, bytes);
         }
-        subs->hwptr_done += offs;
-        if (subs->hwptr_done >= runtime->buffer_size)
-                subs->hwptr_done -= runtime->buffer_size;
-        runtime->delay += offs;
+        subs->hwptr_done += bytes;
+        if (subs->hwptr_done >= runtime->buffer_size * stride)
+                subs->hwptr_done -= runtime->buffer_size * stride;
+        runtime->delay += frames;
         spin_unlock_irqrestore(&subs->lock, flags);
-        urb->transfer_buffer_length = offs * stride;
+        urb->transfer_buffer_length = bytes;
         if (period_elapsed)
                 snd_pcm_period_elapsed(subs->pcm_substream);
         return 0;
@@ -735,41 +747,6 @@ static void snd_complete_sync_urb(struct urb *urb)
 }
 
 
-/* get the physical page pointer at the given offset */
-static struct page *snd_pcm_get_vmalloc_page(struct snd_pcm_substream *subs,
-                                             unsigned long offset)
-{
-        void *pageptr = subs->runtime->dma_area + offset;
-        return vmalloc_to_page(pageptr);
-}
-
-/* allocate virtual buffer; may be called more than once */
-static int snd_pcm_alloc_vmalloc_buffer(struct snd_pcm_substream *subs, size_t size)
-{
-        struct snd_pcm_runtime *runtime = subs->runtime;
-        if (runtime->dma_area) {
-                if (runtime->dma_bytes >= size)
-                        return 0; /* already large enough */
-                vfree(runtime->dma_area);
-        }
-        runtime->dma_area = vmalloc(size);
-        if (!runtime->dma_area)
-                return -ENOMEM;
-        runtime->dma_bytes = size;
-        return 0;
-}
-
-/* free virtual buffer; may be called more than once */
-static int snd_pcm_free_vmalloc_buffer(struct snd_pcm_substream *subs)
-{
-        struct snd_pcm_runtime *runtime = subs->runtime;
-
-        vfree(runtime->dma_area);
-        runtime->dma_area = NULL;
-        return 0;
-}
-
-
 /*
  * unlink active urbs.
  */
@@ -937,18 +914,18 @@ static int wait_clear_urbs(struct snd_usb_substream *subs)
 
 
 /*
- * return the current pcm pointer.  just return the hwptr_done value.
+ * return the current pcm pointer.  just based on the hwptr_done value.
  */
 static snd_pcm_uframes_t snd_usb_pcm_pointer(struct snd_pcm_substream *substream)
 {
         struct snd_usb_substream *subs;
-        snd_pcm_uframes_t hwptr_done;
+        unsigned int hwptr_done;
         
         subs = (struct snd_usb_substream *)substream->runtime->private_data;
         spin_lock(&subs->lock);
         hwptr_done = subs->hwptr_done;
         spin_unlock(&subs->lock);
-        return hwptr_done;
+        return hwptr_done / (substream->runtime->frame_bits >> 3);
 }
 
 
@@ -1130,7 +1107,7 @@ static int init_substream_urbs(struct snd_usb_substream *subs, unsigned int peri
                 u->packets = (i + 1) * total_packs / subs->nurbs
                         - i * total_packs / subs->nurbs;
                 u->buffer_size = maxsize * u->packets;
-                if (subs->fmt_type == USB_FORMAT_TYPE_II)
+                if (subs->fmt_type == UAC_FORMAT_TYPE_II)
                         u->packets++; /* for transfer delimiter */
                 u->urb = usb_alloc_urb(u->packets, GFP_KERNEL);
                 if (!u->urb)
@@ -1206,7 +1183,7 @@ static struct audioformat *find_format(struct snd_usb_substream *subs, unsigned
                         if (i >= fp->nr_rates)
                                 continue;
                 }
-                attr = fp->ep_attr & EP_ATTR_MASK;
+                attr = fp->ep_attr & USB_ENDPOINT_SYNCTYPE;
                 if (! found) {
                         found = fp;
                         cur_attr = attr;
@@ -1218,14 +1195,14 @@ static struct audioformat *find_format(struct snd_usb_substream *subs, unsigned
                  * M-audio audiophile USB.
                  */
                 if (attr != cur_attr) {
-                        if ((attr == EP_ATTR_ASYNC &&
+                        if ((attr == USB_ENDPOINT_SYNC_ASYNC &&
                              subs->direction == SNDRV_PCM_STREAM_PLAYBACK) ||
-                            (attr == EP_ATTR_ADAPTIVE &&
+                            (attr == USB_ENDPOINT_SYNC_ADAPTIVE &&
                              subs->direction == SNDRV_PCM_STREAM_CAPTURE))
                                 continue;
-                        if ((cur_attr == EP_ATTR_ASYNC &&
+                        if ((cur_attr == USB_ENDPOINT_SYNC_ASYNC &&
                              subs->direction == SNDRV_PCM_STREAM_PLAYBACK) ||
-                            (cur_attr == EP_ATTR_ADAPTIVE &&
+                            (cur_attr == USB_ENDPOINT_SYNC_ADAPTIVE &&
                              subs->direction == SNDRV_PCM_STREAM_CAPTURE)) {
                                 found = fp;
                                 cur_attr = attr;
@@ -1255,11 +1232,11 @@ static int init_usb_pitch(struct usb_device *dev, int iface,
 
         ep = get_endpoint(alts, 0)->bEndpointAddress;
         /* if endpoint has pitch control, enable it */
-        if (fmt->attributes & EP_CS_ATTR_PITCH_CONTROL) {
+        if (fmt->attributes & UAC_EP_CS_ATTR_PITCH_CONTROL) {
                 data[0] = 1;
-                if ((err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR,
+                if ((err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC_SET_CUR,
                                            USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
-                                           PITCH_CONTROL << 8, ep, data, 1, 1000)) < 0) {
+                                           UAC_EP_CS_ATTR_PITCH_CONTROL << 8, ep, data, 1, 1000)) < 0) {
                         snd_printk(KERN_ERR "%d:%d:%d: cannot set enable PITCH\n",
                                    dev->devnum, iface, ep);
                         return err;
@@ -1278,21 +1255,21 @@ static int init_usb_sample_rate(struct usb_device *dev, int iface,
 
         ep = get_endpoint(alts, 0)->bEndpointAddress;
         /* if endpoint has sampling rate control, set it */
-        if (fmt->attributes & EP_CS_ATTR_SAMPLE_RATE) {
+        if (fmt->attributes & UAC_EP_CS_ATTR_SAMPLE_RATE) {
                 int crate;
                 data[0] = rate;
                 data[1] = rate >> 8;
                 data[2] = rate >> 16;
-                if ((err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR,
+                if ((err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC_SET_CUR,
                                            USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
-                                           SAMPLING_FREQ_CONTROL << 8, ep, data, 3, 1000)) < 0) {
+                                           UAC_EP_CS_ATTR_SAMPLE_RATE << 8, ep, data, 3, 1000)) < 0) {
                         snd_printk(KERN_ERR "%d:%d:%d: cannot set freq %d to ep %#x\n",
                                    dev->devnum, iface, fmt->altsetting, rate, ep);
                         return err;
                 }
-                if ((err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR,
+                if ((err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC_GET_CUR,
                                            USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_IN,
-                                           SAMPLING_FREQ_CONTROL << 8, ep, data, 3, 1000)) < 0) {
+                                           UAC_EP_CS_ATTR_SAMPLE_RATE << 8, ep, data, 3, 1000)) < 0) {
                         snd_printk(KERN_WARNING "%d:%d:%d: cannot get freq at ep %#x\n",
                                    dev->devnum, iface, fmt->altsetting, ep);
                         return 0; /* some devices don't support reading */
@@ -1307,6 +1284,47 @@ static int init_usb_sample_rate(struct usb_device *dev, int iface,
 }
 
 /*
+ * For E-Mu 0404USB/0202USB/TrackerPre sample rate should be set for device,
+ * not for interface.
+ */
+static void set_format_emu_quirk(struct snd_usb_substream *subs,
+                                 struct audioformat *fmt)
+{
+        unsigned char emu_samplerate_id = 0;
+
+        /* When capture is active
+         * sample rate shouldn't be changed
+         * by playback substream
+         */
+        if (subs->direction == SNDRV_PCM_STREAM_PLAYBACK) {
+                if (subs->stream->substream[SNDRV_PCM_STREAM_CAPTURE].interface != -1)
+                        return;
+        }
+
+        switch (fmt->rate_min) {
+        case 48000:
+                emu_samplerate_id = EMU_QUIRK_SR_48000HZ;
+                break;
+        case 88200:
+                emu_samplerate_id = EMU_QUIRK_SR_88200HZ;
+                break;
+        case 96000:
+                emu_samplerate_id = EMU_QUIRK_SR_96000HZ;
+                break;
+        case 176400:
+                emu_samplerate_id = EMU_QUIRK_SR_176400HZ;
+                break;
+        case 192000:
+                emu_samplerate_id = EMU_QUIRK_SR_192000HZ;
+                break;
+        default:
+                emu_samplerate_id = EMU_QUIRK_SR_44100HZ;
+                break;
+        }
+        snd_emuusb_set_samplerate(subs->stream->chip, emu_samplerate_id);
+}
+
+/*
  * find a matching format and set up the interface
  */
 static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt)
@@ -1369,9 +1387,9 @@ static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt)
          * descriptors which fool us.  if it has only one EP,
          * assume it as adaptive-out or sync-in.
          */
-        attr = fmt->ep_attr & EP_ATTR_MASK;
-        if (((is_playback && attr == EP_ATTR_ASYNC) ||
-             (! is_playback && attr == EP_ATTR_ADAPTIVE)) &&
+        attr = fmt->ep_attr & USB_ENDPOINT_SYNCTYPE;
+        if (((is_playback && attr == USB_ENDPOINT_SYNC_ASYNC) ||
+             (! is_playback && attr == USB_ENDPOINT_SYNC_ADAPTIVE)) &&
             altsd->bNumEndpoints >= 2) {
                 /* check sync-pipe endpoint */
                 /* ... and check descriptor size before accessing bSynchAddress
@@ -1411,7 +1429,7 @@ static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt)
         }
 
         /* always fill max packet size */
-        if (fmt->attributes & EP_CS_ATTR_FILL_MAX)
+        if (fmt->attributes & UAC_EP_CS_ATTR_FILL_MAX)
                 subs->fill_max = 1;
 
         if ((err = init_usb_pitch(dev, subs->interface, alts, fmt)) < 0)
@@ -1419,6 +1437,14 @@ static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt)
 
         subs->cur_audiofmt = fmt;
 
+        switch (subs->stream->chip->usb_id) {
+        case USB_ID(0x041e, 0x3f02): /* E-Mu 0202 USB */
+        case USB_ID(0x041e, 0x3f04): /* E-Mu 0404 USB */
+        case USB_ID(0x041e, 0x3f0a): /* E-Mu Tracker Pre */
+                set_format_emu_quirk(subs, fmt);
+                break;
+        }
+
 #if 0
         printk(KERN_DEBUG
                "setting done: format = %d, rate = %d..%d, channels = %d\n",
@@ -1449,8 +1475,8 @@ static int snd_usb_hw_params(struct snd_pcm_substream *substream,
         unsigned int channels, rate, format;
         int ret, changed;
 
-        ret = snd_pcm_alloc_vmalloc_buffer(substream,
-                                           params_buffer_bytes(hw_params));
+        ret = snd_pcm_lib_alloc_vmalloc_buffer(substream,
+                                               params_buffer_bytes(hw_params));
         if (ret < 0)
                 return ret;
 
@@ -1507,7 +1533,7 @@ static int snd_usb_hw_free(struct snd_pcm_substream *substream)
         subs->period_bytes = 0;
         if (!subs->stream->chip->shutdown)
                 release_substream_urbs(subs, 0);
-        return snd_pcm_free_vmalloc_buffer(substream);
+        return snd_pcm_lib_free_vmalloc_buffer(substream);
 }
 
 /*
@@ -1861,7 +1887,7 @@ static int setup_hw_info(struct snd_pcm_runtime *runtime, struct snd_usb_substre
                         runtime->hw.channels_min = fp->channels;
                 if (runtime->hw.channels_max < fp->channels)
                         runtime->hw.channels_max = fp->channels;
-                if (fp->fmt_type == USB_FORMAT_TYPE_II && fp->frame_size > 0) {
+                if (fp->fmt_type == UAC_FORMAT_TYPE_II && fp->frame_size > 0) {
                         /* FIXME: there might be more than one audio formats... */
                         runtime->hw.period_bytes_min = runtime->hw.period_bytes_max =
                                 fp->frame_size;
@@ -1936,7 +1962,7 @@ static int snd_usb_pcm_close(struct snd_pcm_substream *substream, int direction)
         struct snd_usb_stream *as = snd_pcm_substream_chip(substream);
         struct snd_usb_substream *subs = &as->substream[direction];
 
-        if (subs->interface >= 0) {
+        if (!as->chip->shutdown && subs->interface >= 0) {
                 usb_set_interface(subs->dev, subs->interface, 0);
                 subs->interface = -1;
         }
@@ -1973,7 +1999,8 @@ static struct snd_pcm_ops snd_usb_playback_ops = {
         .prepare =      snd_usb_pcm_prepare,
         .trigger =      snd_usb_pcm_playback_trigger,
         .pointer =      snd_usb_pcm_pointer,
-        .page =         snd_pcm_get_vmalloc_page,
+        .page =         snd_pcm_lib_get_vmalloc_page,
+        .mmap =         snd_pcm_lib_mmap_vmalloc,
 };
 
 static struct snd_pcm_ops snd_usb_capture_ops = {
@@ -1985,7 +2012,8 @@ static struct snd_pcm_ops snd_usb_capture_ops = {
         .prepare =      snd_usb_pcm_prepare,
         .trigger =      snd_usb_pcm_capture_trigger,
         .pointer =      snd_usb_pcm_pointer,
-        .page =         snd_pcm_get_vmalloc_page,
+        .page =         snd_pcm_lib_get_vmalloc_page,
+        .mmap =         snd_pcm_lib_mmap_vmalloc,
 };
 
 
@@ -2093,7 +2121,7 @@ static struct usb_device_id usb_audio_ids [] = {
 #include "usbquirks.h"
     { .match_flags = (USB_DEVICE_ID_MATCH_INT_CLASS | USB_DEVICE_ID_MATCH_INT_SUBCLASS),
       .bInterfaceClass = USB_CLASS_AUDIO,
-      .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL },
+      .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL },
     { }                                         /* Terminating entry */
 };
 
@@ -2132,7 +2160,7 @@ static void proc_dump_substream_formats(struct snd_usb_substream *subs, struct s
                 snd_iprintf(buffer, "    Endpoint: %d %s (%s)\n",
                             fp->endpoint & USB_ENDPOINT_NUMBER_MASK,
                             fp->endpoint & USB_DIR_IN ? "IN" : "OUT",
-                            sync_types[(fp->ep_attr & EP_ATTR_MASK) >> 2]);
+                            sync_types[(fp->ep_attr & USB_ENDPOINT_SYNCTYPE) >> 2]);
                 if (fp->rates & SNDRV_PCM_RATE_CONTINUOUS) {
                         snd_iprintf(buffer, "    Rates: %d - %d (continuous)\n",
                                     fp->rate_min, fp->rate_max);
@@ -2227,6 +2255,7 @@ static void init_substream(struct snd_usb_stream *as, int stream, struct audiofo
         subs->stream = as;
         subs->direction = stream;
         subs->dev = as->chip->dev;
+        subs->txfr_quirk = as->chip->txfr_quirk;
         if (snd_usb_get_speed(subs->dev) == USB_SPEED_FULL) {
                 subs->ops = audio_urb_ops[stream];
         } else {
@@ -2394,29 +2423,67 @@ static int is_big_endian_format(struct snd_usb_audio *chip, struct audioformat *
  * @format: the format tag (wFormatTag)
  * @fmt: the format type descriptor
  */
-static int parse_audio_format_i_type(struct snd_usb_audio *chip, struct audioformat *fp,
-                                     int format, unsigned char *fmt)
+static int parse_audio_format_i_type(struct snd_usb_audio *chip,
+                                     struct audioformat *fp,
+                                     int format, void *_fmt,
+                                     int protocol)
 {
-        int pcm_format;
+        int pcm_format, i;
         int sample_width, sample_bytes;
 
+        switch (protocol) {
+        case UAC_VERSION_1: {
+                struct uac_format_type_i_discrete_descriptor *fmt = _fmt;
+                sample_width = fmt->bBitResolution;
+                sample_bytes = fmt->bSubframeSize;
+                break;
+        }
+
+        case UAC_VERSION_2: {
+                struct uac_format_type_i_ext_descriptor *fmt = _fmt;
+                sample_width = fmt->bBitResolution;
+                sample_bytes = fmt->bSubslotSize;
+
+                /*
+                 * FIXME
+                 * USB audio class v2 devices specify a bitmap of possible
+                 * audio formats rather than one fix value. For now, we just
+                 * pick one of them and report that as the only possible
+                 * value for this setting.
+                 * The bit allocation map is in fact compatible to the
+                 * wFormatTag of the v1 AS streaming descriptors, which is why
+                 * we can simply map the matrix.
+                 */
+
+                for (i = 0; i < 5; i++)
+                        if (format & (1UL << i)) {
+                                format = i + 1;
+                                break;
+                        }
+
+                break;
+        }
+
+        default:
+                return -EINVAL;
+        }
+
         /* FIXME: correct endianess and sign? */
         pcm_format = -1;
-        sample_width = fmt[6];
-        sample_bytes = fmt[5];
+
         switch (format) {
-        case 0: /* some devices don't define this correctly... */
+        case UAC_FORMAT_TYPE_I_UNDEFINED: /* some devices don't define this correctly... */
                 snd_printdd(KERN_INFO "%d:%u:%d : format type 0 is detected, processed as PCM\n",
                             chip->dev->devnum, fp->iface, fp->altsetting);
                 /* fall-through */
-        case USB_AUDIO_FORMAT_PCM:
+        case UAC_FORMAT_TYPE_I_PCM:
                 if (sample_width > sample_bytes * 8) {
                         snd_printk(KERN_INFO "%d:%u:%d : sample bitwidth %d in over sample bytes %d\n",
                                    chip->dev->devnum, fp->iface, fp->altsetting,
                                    sample_width, sample_bytes);
                 }
                 /* check the format byte size */
-                switch (fmt[5]) {
+                switch (sample_bytes) {
                 case 1:
                         pcm_format = SNDRV_PCM_FORMAT_S8;
                         break;
@@ -2437,12 +2504,12 @@ static int parse_audio_format_i_type(struct snd_usb_audio *chip, struct audiofor
                         break;
                 default:
                         snd_printk(KERN_INFO "%d:%u:%d : unsupported sample bitwidth %d in %d bytes\n",
-                                   chip->dev->devnum, fp->iface,
-                                   fp->altsetting, sample_width, sample_bytes);
+                                   chip->dev->devnum, fp->iface, fp->altsetting,
+                                   sample_width, sample_bytes);
                         break;
                 }
                 break;
-        case USB_AUDIO_FORMAT_PCM8:
+        case UAC_FORMAT_TYPE_I_PCM8:
                 pcm_format = SNDRV_PCM_FORMAT_U8;
 
                 /* Dallas DS4201 workaround: it advertises U8 format, but really
@@ -2450,13 +2517,13 @@ static int parse_audio_format_i_type(struct snd_usb_audio *chip, struct audiofor
                 if (chip->usb_id == USB_ID(0x04fa, 0x4201))
                         pcm_format = SNDRV_PCM_FORMAT_S8;
                 break;
-        case USB_AUDIO_FORMAT_IEEE_FLOAT:
+        case UAC_FORMAT_TYPE_I_IEEE_FLOAT:
                 pcm_format = SNDRV_PCM_FORMAT_FLOAT_LE;
                 break;
-        case USB_AUDIO_FORMAT_ALAW:
+        case UAC_FORMAT_TYPE_I_ALAW:
                 pcm_format = SNDRV_PCM_FORMAT_A_LAW;
                 break;
-        case USB_AUDIO_FORMAT_MU_LAW:
+        case UAC_FORMAT_TYPE_I_MULAW:
                 pcm_format = SNDRV_PCM_FORMAT_MU_LAW;
                 break;
         default:
@@ -2470,7 +2537,7 @@ static int parse_audio_format_i_type(struct snd_usb_audio *chip, struct audiofor
 
 /*
  * parse the format descriptor and stores the possible sample rates
- * on the audioformat table.
+ * on the audioformat table (audio class v1).
  *
  * @dev: usb device
  * @fp: audioformat record
@@ -2478,13 +2545,13 @@ static int parse_audio_format_i_type(struct snd_usb_audio *chip, struct audiofor
  * @offset: the start offset of descriptor pointing the rate type
  *          (7 for type I and II, 8 for type II)
  */
-static int parse_audio_format_rates(struct snd_usb_audio *chip, struct audioformat *fp,
-                                    unsigned char *fmt, int offset)
+static int parse_audio_format_rates_v1(struct snd_usb_audio *chip, struct audioformat *fp,
+                                       unsigned char *fmt, int offset)
 {
         int nr_rates = fmt[offset];
 
         if (fmt[0] < offset + 1 + 3 * (nr_rates ? nr_rates : 2)) {
-                snd_printk(KERN_ERR "%d:%u:%d : invalid FORMAT_TYPE desc\n",
+                snd_printk(KERN_ERR "%d:%u:%d : invalid UAC_FORMAT_TYPE desc\n",
                                    chip->dev->devnum, fp->iface, fp->altsetting);
                 return -1;
         }
@@ -2513,6 +2580,9 @@ static int parse_audio_format_rates(struct snd_usb_audio *chip, struct audioform
                              chip->usb_id == USB_ID(0x0d8c, 0x0102)) &&
                             fp->altsetting == 5 && fp->maxpacksize == 392)
                                 rate = 96000;
+                        /* Creative VF0470 Live Cam reports 16 kHz instead of 8kHz */
+                        if (rate == 16000 && chip->usb_id == USB_ID(0x041e, 0x4068))
+                                rate = 8000;
                         fp->rate_table[fp->nr_rates] = rate;
                         if (!fp->rate_min || rate < fp->rate_min)
                                 fp->rate_min = rate;
@@ -2535,14 +2605,87 @@ static int parse_audio_format_rates(struct snd_usb_audio *chip, struct audioform
 }
 
 /*
+ * parse the format descriptor and stores the possible sample rates
+ * on the audioformat table (audio class v2).
+ */
+static int parse_audio_format_rates_v2(struct snd_usb_audio *chip,
+                                       struct audioformat *fp,
+                                       struct usb_host_interface *iface)
+{
+        struct usb_device *dev = chip->dev;
+        unsigned char tmp[2], *data;
+        int i, nr_rates, data_size, ret = 0;
+
+        /* get the number of sample rates first by only fetching 2 bytes */
+        ret = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_RANGE,
+                               USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN,
+                               0x0100, chip->clock_id << 8, tmp, sizeof(tmp), 1000);
+
+        if (ret < 0) {
+                snd_printk(KERN_ERR "unable to retrieve number of sample rates\n");
+                goto err;
+        }
+
+        nr_rates = (tmp[1] << 8) | tmp[0];
+        data_size = 2 + 12 * nr_rates;
+        data = kzalloc(data_size, GFP_KERNEL);
+        if (!data) {
+                ret = -ENOMEM;
+                goto err;
+        }
+
+        /* now get the full information */
+        ret = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_RANGE,
+                               USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN,
+                               0x0100, chip->clock_id << 8, data, data_size, 1000);
+
+        if (ret < 0) {
+                snd_printk(KERN_ERR "unable to retrieve sample rate range\n");
+                ret = -EINVAL;
+                goto err_free;
+        }
+
+        fp->rate_table = kmalloc(sizeof(int) * nr_rates, GFP_KERNEL);
+        if (!fp->rate_table) {
+                ret = -ENOMEM;
+                goto err_free;
+        }
+
+        fp->nr_rates = 0;
+        fp->rate_min = fp->rate_max = 0;
+
+        for (i = 0; i < nr_rates; i++) {
+                int rate = combine_quad(&data[2 + 12 * i]);
+
+                fp->rate_table[fp->nr_rates] = rate;
+                if (!fp->rate_min || rate < fp->rate_min)
+                        fp->rate_min = rate;
+                if (!fp->rate_max || rate > fp->rate_max)
+                        fp->rate_max = rate;
+                fp->rates |= snd_pcm_rate_to_rate_bit(rate);
+                fp->nr_rates++;
+        }
+
+err_free:
+        kfree(data);
+err:
+        return ret;
+}
+
+/*
  * parse the format type I and III descriptors
  */
-static int parse_audio_format_i(struct snd_usb_audio *chip, struct audioformat *fp,
-                                int format, unsigned char *fmt)
+static int parse_audio_format_i(struct snd_usb_audio *chip,
+                                struct audioformat *fp,
+                                int format, void *_fmt,
+                                struct usb_host_interface *iface)
 {
-        int pcm_format;
+        struct usb_interface_descriptor *altsd = get_iface_desc(iface);
+        struct uac_format_type_i_discrete_descriptor *fmt = _fmt;
+        int protocol = altsd->bInterfaceProtocol;
+        int pcm_format, ret;
 
-        if (fmt[3] == USB_FORMAT_TYPE_III) {
+        if (fmt->bFormatType == UAC_FORMAT_TYPE_III) {
                 /* FIXME: the format type is really IECxxx
                  *        but we give normal PCM format to get the existing
                  *        apps working...
@@ -2560,34 +2703,57 @@ static int parse_audio_format_i(struct snd_usb_audio *chip, struct audioformat *
                         pcm_format = SNDRV_PCM_FORMAT_S16_LE;
                 }
         } else {
-                pcm_format = parse_audio_format_i_type(chip, fp, format, fmt);
+                pcm_format = parse_audio_format_i_type(chip, fp, format, fmt, protocol);
                 if (pcm_format < 0)
                         return -1;
         }
+
         fp->format = pcm_format;
-        fp->channels = fmt[4];
+
+        /* gather possible sample rates */
+        /* audio class v1 reports possible sample rates as part of the
+         * proprietary class specific descriptor.
+         * audio class v2 uses class specific EP0 range requests for that.
+         */
+        switch (protocol) {
+        case UAC_VERSION_1:
+                fp->channels = fmt->bNrChannels;
+                ret = parse_audio_format_rates_v1(chip, fp, _fmt, 7);
+                break;
+        case UAC_VERSION_2:
+                /* fp->channels is already set in this case */
+                ret = parse_audio_format_rates_v2(chip, fp, iface);
+                break;
+        }
+
         if (fp->channels < 1) {
                 snd_printk(KERN_ERR "%d:%u:%d : invalid channels %d\n",
                            chip->dev->devnum, fp->iface, fp->altsetting, fp->channels);
                 return -1;
         }
-        return parse_audio_format_rates(chip, fp, fmt, 7);
+
+        return ret;
 }
 
 /*
- * prase the format type II descriptor
+ * parse the format type II descriptor
  */
-static int parse_audio_format_ii(struct snd_usb_audio *chip, struct audioformat *fp,
-                                 int format, unsigned char *fmt)
+static int parse_audio_format_ii(struct snd_usb_audio *chip,
+                                 struct audioformat *fp,
+                                 int format, void *_fmt,
+                                 struct usb_host_interface *iface)
 {
-        int brate, framesize;
+        int brate, framesize, ret;
+        struct usb_interface_descriptor *altsd = get_iface_desc(iface);
+        int protocol = altsd->bInterfaceProtocol;
+
         switch (format) {
-        case USB_AUDIO_FORMAT_AC3:
+        case UAC_FORMAT_TYPE_II_AC3:
                 /* FIXME: there is no AC3 format defined yet */
                 // fp->format = SNDRV_PCM_FORMAT_AC3;
                 fp->format = SNDRV_PCM_FORMAT_U8; /* temporarily hack to receive byte streams */
                 break;
-        case USB_AUDIO_FORMAT_MPEG:
+        case UAC_FORMAT_TYPE_II_MPEG:
                 fp->format = SNDRV_PCM_FORMAT_MPEG;
                 break;
         default:
@@ -2596,26 +2762,46 @@ static int parse_audio_format_ii(struct snd_usb_audio *chip, struct audioformat
                 fp->format = SNDRV_PCM_FORMAT_MPEG;
                 break;
         }
+
         fp->channels = 1;
-        brate = combine_word(&fmt[4]);  /* fmt[4,5] : wMaxBitRate (in kbps) */
-        framesize = combine_word(&fmt[6]); /* fmt[6,7]: wSamplesPerFrame */
-        snd_printd(KERN_INFO "found format II with max.bitrate = %d, frame size=%d\n", brate, framesize);
-        fp->frame_size = framesize;
-        return parse_audio_format_rates(chip, fp, fmt, 8); /* fmt[8..] sample rates */
+
+        switch (protocol) {
+        case UAC_VERSION_1: {
+                struct uac_format_type_ii_discrete_descriptor *fmt = _fmt;
+                brate = le16_to_cpu(fmt->wMaxBitRate);
+                framesize = le16_to_cpu(fmt->wSamplesPerFrame);
+                snd_printd(KERN_INFO "found format II with max.bitrate = %d, frame size=%d\n", brate, framesize);
+                fp->frame_size = framesize;
+                ret = parse_audio_format_rates_v1(chip, fp, _fmt, 8); /* fmt[8..] sample rates */
+                break;
+        }
+        case UAC_VERSION_2: {
+                struct uac_format_type_ii_ext_descriptor *fmt = _fmt;
+                brate = le16_to_cpu(fmt->wMaxBitRate);
+                framesize = le16_to_cpu(fmt->wSamplesPerFrame);
+                snd_printd(KERN_INFO "found format II with max.bitrate = %d, frame size=%d\n", brate, framesize);
+                fp->frame_size = framesize;
+                ret = parse_audio_format_rates_v2(chip, fp, iface);
+                break;
+        }
+        }
+
+        return ret;
 }
 
 static int parse_audio_format(struct snd_usb_audio *chip, struct audioformat *fp,
-                              int format, unsigned char *fmt, int stream)
+                              int format, unsigned char *fmt, int stream,
+                              struct usb_host_interface *iface)
 {
         int err;
 
         switch (fmt[3]) {
-        case USB_FORMAT_TYPE_I:
-        case USB_FORMAT_TYPE_III:
-                err = parse_audio_format_i(chip, fp, format, fmt);
+        case UAC_FORMAT_TYPE_I:
+        case UAC_FORMAT_TYPE_III:
+                err = parse_audio_format_i(chip, fp, format, fmt, iface);
                 break;
-        case USB_FORMAT_TYPE_II:
-                err = parse_audio_format_ii(chip, fp, format, fmt);
+        case UAC_FORMAT_TYPE_II:
+                err = parse_audio_format_ii(chip, fp, format, fmt, iface);
                 break;
         default:
                 snd_printd(KERN_INFO "%d:%u:%d : format type %d is not supported yet\n",
@@ -2633,7 +2819,7 @@ static int parse_audio_format(struct snd_usb_audio *chip, struct audioformat *fp
         if (chip->usb_id == USB_ID(0x041e, 0x3000) ||
             chip->usb_id == USB_ID(0x041e, 0x3020) ||
             chip->usb_id == USB_ID(0x041e, 0x3061)) {
-                if (fmt[3] == USB_FORMAT_TYPE_I &&
+                if (fmt[3] == UAC_FORMAT_TYPE_I &&
                     fp->rates != SNDRV_PCM_RATE_48000 &&
                     fp->rates != SNDRV_PCM_RATE_96000)
                         return -1;
@@ -2662,10 +2848,10 @@ static int parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
         struct usb_host_interface *alts;
         struct usb_interface_descriptor *altsd;
         int i, altno, err, stream;
-        int format;
+        int format = 0, num_channels = 0;
         struct audioformat *fp = NULL;
         unsigned char *fmt, *csep;
-        int num;
+        int num, protocol;
 
         dev = chip->dev;
 
@@ -2684,10 +2870,11 @@ static int parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
         for (i = 0; i < num; i++) {
                 alts = &iface->altsetting[i];
                 altsd = get_iface_desc(alts);
+                protocol = altsd->bInterfaceProtocol;
                 /* skip invalid one */
                 if ((altsd->bInterfaceClass != USB_CLASS_AUDIO &&
                      altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC) ||
-                    (altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIO_STREAMING &&
+                    (altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIOSTREAMING &&
                      altsd->bInterfaceSubClass != USB_SUBCLASS_VENDOR_SPEC) ||
                     altsd->bNumEndpoints < 1 ||
                     le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize) == 0)
@@ -2708,30 +2895,65 @@ static int parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
                         continue;
 
                 /* get audio formats */
-                fmt = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, AS_GENERAL);
-                if (!fmt) {
-                        snd_printk(KERN_ERR "%d:%u:%d : AS_GENERAL descriptor not found\n",
-                                   dev->devnum, iface_no, altno);
-                        continue;
+                switch (protocol) {
+                case UAC_VERSION_1: {
+                        struct uac_as_header_descriptor_v1 *as =
+                                snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_AS_GENERAL);
+
+                        if (!as) {
+                                snd_printk(KERN_ERR "%d:%u:%d : UAC_AS_GENERAL descriptor not found\n",
+                                           dev->devnum, iface_no, altno);
+                                continue;
+                        }
+
+                        if (as->bLength < sizeof(*as)) {
+                                snd_printk(KERN_ERR "%d:%u:%d : invalid UAC_AS_GENERAL desc\n",
+                                           dev->devnum, iface_no, altno);
+                                continue;
+                        }
+
+                        format = le16_to_cpu(as->wFormatTag); /* remember the format value */
+                        break;
                 }
 
-                if (fmt[0] < 7) {
-                        snd_printk(KERN_ERR "%d:%u:%d : invalid AS_GENERAL desc\n",
-                                   dev->devnum, iface_no, altno);
-                        continue;
+                case UAC_VERSION_2: {
+                        struct uac_as_header_descriptor_v2 *as =
+                                snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_AS_GENERAL);
+
+                        if (!as) {
+                                snd_printk(KERN_ERR "%d:%u:%d : UAC_AS_GENERAL descriptor not found\n",
+                                           dev->devnum, iface_no, altno);
+                                continue;
+                        }
+
+                        if (as->bLength < sizeof(*as)) {
+                                snd_printk(KERN_ERR "%d:%u:%d : invalid UAC_AS_GENERAL desc\n",
+                                           dev->devnum, iface_no, altno);
+                                continue;
+                        }
+
+                        num_channels = as->bNrChannels;
+                        format = le32_to_cpu(as->bmFormats);
+
+                        break;
                 }
 
-                format = (fmt[6] << 8) | fmt[5]; /* remember the format value */
+                default:
+                        snd_printk(KERN_ERR "%d:%u:%d : unknown interface protocol %04x\n",
+                                   dev->devnum, iface_no, altno, protocol);
+                        continue;
+                }
 
                 /* get format type */
-                fmt = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, FORMAT_TYPE);
+                fmt = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_FORMAT_TYPE);
                 if (!fmt) {
-                        snd_printk(KERN_ERR "%d:%u:%d : no FORMAT_TYPE desc\n",
+                        snd_printk(KERN_ERR "%d:%u:%d : no UAC_FORMAT_TYPE desc\n",
                                    dev->devnum, iface_no, altno);
                         continue;
                 }
-                if (fmt[0] < 8) {
-                        snd_printk(KERN_ERR "%d:%u:%d : invalid FORMAT_TYPE desc\n",
+                if (((protocol == UAC_VERSION_1) && (fmt[0] < 8)) ||
+                    ((protocol == UAC_VERSION_2) && (fmt[0] != 6))) {
+                        snd_printk(KERN_ERR "%d:%u:%d : invalid UAC_FORMAT_TYPE desc\n",
                                    dev->devnum, iface_no, altno);
                         continue;
                 }
@@ -2744,6 +2966,7 @@ static int parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
                 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 &&
+                    protocol == UAC_VERSION_1 &&
                     le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize) ==
                                                         fp->maxpacksize * 2)
                         continue;
@@ -2752,7 +2975,7 @@ static int parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
                 /* Creamware Noah has this descriptor after the 2nd endpoint */
                 if (!csep && altsd->bNumEndpoints >= 2)
                         csep = snd_usb_find_desc(alts->endpoint[1].extra, alts->endpoint[1].extralen, NULL, USB_DT_CS_ENDPOINT);
-                if (!csep || csep[0] < 7 || csep[2] != EP_GENERAL) {
+                if (!csep || csep[0] < 7 || csep[2] != UAC_EP_GENERAL) {
                         snd_printk(KERN_WARNING "%d:%u:%d : no or invalid"
                                    " class specific endpoint descriptor\n",
                                    dev->devnum, iface_no, altno);
@@ -2772,6 +2995,8 @@ static int parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
                 fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
                 fp->datainterval = parse_datainterval(chip, alts);
                 fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
+                /* num_channels is only set for v2 interfaces */
+                fp->channels = num_channels;
                 if (snd_usb_get_speed(dev) == USB_SPEED_HIGH)
                         fp->maxpacksize = (((fp->maxpacksize >> 11) & 3) + 1)
                                         * (fp->maxpacksize & 0x7ff);
@@ -2784,12 +3009,12 @@ static int parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
                         /* Optoplay sets the sample rate attribute although
                          * it seems not supporting it in fact.
                          */
-                        fp->attributes &= ~EP_CS_ATTR_SAMPLE_RATE;
+                        fp->attributes &= ~UAC_EP_CS_ATTR_SAMPLE_RATE;
                         break;
                 case USB_ID(0x041e, 0x3020): /* Creative SB Audigy 2 NX */
                 case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
                         /* doesn't set the sample rate attribute, but supports it */
-                        fp->attributes |= EP_CS_ATTR_SAMPLE_RATE;
+                        fp->attributes |= UAC_EP_CS_ATTR_SAMPLE_RATE;
                         break;
                 case USB_ID(0x047f, 0x0ca1): /* plantronics headset */
                 case USB_ID(0x077d, 0x07af): /* Griffin iMic (note that there is
@@ -2798,16 +3023,16 @@ static int parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
                  * plantronics headset and Griffin iMic have set adaptive-in
                  * although it's really not...
                  */
-                        fp->ep_attr &= ~EP_ATTR_MASK;
+                        fp->ep_attr &= ~USB_ENDPOINT_SYNCTYPE;
                         if (stream == SNDRV_PCM_STREAM_PLAYBACK)
-                                fp->ep_attr |= EP_ATTR_ADAPTIVE;
+                                fp->ep_attr |= USB_ENDPOINT_SYNC_ADAPTIVE;
                         else
-                                fp->ep_attr |= EP_ATTR_SYNC;
+                                fp->ep_attr |= USB_ENDPOINT_SYNC_SYNC;
                         break;
                 }
 
                 /* ok, let's parse further... */
-                if (parse_audio_format(chip, fp, format, fmt, stream) < 0) {
+                if (parse_audio_format(chip, fp, format, fmt, stream, alts) < 0) {
                         kfree(fp->rate_table);
                         kfree(fp);
                         continue;
@@ -2849,6 +3074,65 @@ static void snd_usb_stream_disconnect(struct list_head *head)
         }
 }
 
+static int snd_usb_create_stream(struct snd_usb_audio *chip, int ctrlif, int interface)
+{
+        struct usb_device *dev = chip->dev;
+        struct usb_host_interface *alts;
+        struct usb_interface_descriptor *altsd;
+        struct usb_interface *iface = usb_ifnum_to_if(dev, interface);
+
+        if (!iface) {
+                snd_printk(KERN_ERR "%d:%u:%d : does not exist\n",
+                           dev->devnum, ctrlif, interface);
+                return -EINVAL;
+        }
+
+        if (usb_interface_claimed(iface)) {
+                snd_printdd(KERN_INFO "%d:%d:%d: skipping, already claimed\n",
+                                                dev->devnum, ctrlif, interface);
+                return -EINVAL;
+        }
+
+        alts = &iface->altsetting[0];
+        altsd = get_iface_desc(alts);
+        if ((altsd->bInterfaceClass == USB_CLASS_AUDIO ||
+             altsd->bInterfaceClass == USB_CLASS_VENDOR_SPEC) &&
+            altsd->bInterfaceSubClass == USB_SUBCLASS_MIDISTREAMING) {
+                int err = snd_usbmidi_create(chip->card, iface,
+                                             &chip->midi_list, NULL);
+                if (err < 0) {
+                        snd_printk(KERN_ERR "%d:%u:%d: cannot create sequencer device\n",
+                                                dev->devnum, ctrlif, interface);
+                        return -EINVAL;
+                }
+                usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L);
+
+                return 0;
+        }
+
+        if ((altsd->bInterfaceClass != USB_CLASS_AUDIO &&
+             altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC) ||
+            altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIOSTREAMING) {
+                snd_printdd(KERN_ERR "%d:%u:%d: skipping non-supported interface %d\n",
+                                        dev->devnum, ctrlif, interface, altsd->bInterfaceClass);
+                /* skip non-supported classes */
+                return -EINVAL;
+        }
+
+        if (snd_usb_get_speed(dev) == USB_SPEED_LOW) {
+                snd_printk(KERN_ERR "low speed audio streaming not supported\n");
+                return -EINVAL;
+        }
+
+        if (! parse_audio_endpoints(chip, interface)) {
+                usb_set_interface(dev, interface, 0); /* reset the current interface */
+                usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L);
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
 /*
  * parse audio control descriptor and create pcm/midi streams
  */
@@ -2856,65 +3140,81 @@ static int snd_usb_create_streams(struct snd_usb_audio *chip, int ctrlif)
 {
         struct usb_device *dev = chip->dev;
         struct usb_host_interface *host_iface;
-        struct usb_interface *iface;
-        unsigned char *p1;
-        int i, j;
+        struct usb_interface_descriptor *altsd;
+        void *control_header;
+        int i, protocol;
 
         /* find audiocontrol interface */
         host_iface = &usb_ifnum_to_if(dev, ctrlif)->altsetting[0];
-        if (!(p1 = snd_usb_find_csint_desc(host_iface->extra, host_iface->extralen, NULL, HEADER))) {
-                snd_printk(KERN_ERR "cannot find HEADER\n");
-                return -EINVAL;
-        }
-        if (! p1[7] || p1[0] < 8 + p1[7]) {
-                snd_printk(KERN_ERR "invalid HEADER\n");
+        control_header = snd_usb_find_csint_desc(host_iface->extra,
+                                                 host_iface->extralen,
+                                                 NULL, UAC_HEADER);
+        altsd = get_iface_desc(host_iface);
+        protocol = altsd->bInterfaceProtocol;
+
+        if (!control_header) {
+                snd_printk(KERN_ERR "cannot find UAC_HEADER\n");
                 return -EINVAL;
         }
 
-        /*
-         * parse all USB audio streaming interfaces
-         */
-        for (i = 0; i < p1[7]; i++) {
-                struct usb_host_interface *alts;
-                struct usb_interface_descriptor *altsd;
-                j = p1[8 + i];
-                iface = usb_ifnum_to_if(dev, j);
-                if (!iface) {
-                        snd_printk(KERN_ERR "%d:%u:%d : does not exist\n",
-                                   dev->devnum, ctrlif, j);
-                        continue;
-                }
-                if (usb_interface_claimed(iface)) {
-                        snd_printdd(KERN_INFO "%d:%d:%d: skipping, already claimed\n", dev->devnum, ctrlif, j);
-                        continue;
+        switch (protocol) {
+        case UAC_VERSION_1: {
+                struct uac_ac_header_descriptor_v1 *h1 = control_header;
+
+                if (!h1->bInCollection) {
+                        snd_printk(KERN_INFO "skipping empty audio interface (v1)\n");
+                        return -EINVAL;
                 }
-                alts = &iface->altsetting[0];
-                altsd = get_iface_desc(alts);
-                if ((altsd->bInterfaceClass == USB_CLASS_AUDIO ||
-                     altsd->bInterfaceClass == USB_CLASS_VENDOR_SPEC) &&
-                    altsd->bInterfaceSubClass == USB_SUBCLASS_MIDI_STREAMING) {
-                        if (snd_usb_create_midi_interface(chip, iface, NULL) < 0) {
-                                snd_printk(KERN_ERR "%d:%u:%d: cannot create sequencer device\n", dev->devnum, ctrlif, j);
-                                continue;
-                        }
-                        usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L);
-                        continue;
+
+                if (h1->bLength < sizeof(*h1) + h1->bInCollection) {
+                        snd_printk(KERN_ERR "invalid UAC_HEADER (v1)\n");
+                        return -EINVAL;
                 }
-                if ((altsd->bInterfaceClass != USB_CLASS_AUDIO &&
-                     altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC) ||
-                    altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIO_STREAMING) {
-                        snd_printdd(KERN_ERR "%d:%u:%d: skipping non-supported interface %d\n", dev->devnum, ctrlif, j, altsd->bInterfaceClass);
-                        /* skip non-supported classes */
-                        continue;
+
+                for (i = 0; i < h1->bInCollection; i++)
+                        snd_usb_create_stream(chip, ctrlif, h1->baInterfaceNr[i]);
+
+                break;
+        }
+
+        case UAC_VERSION_2: {
+                struct uac_clock_source_descriptor *cs;
+                struct usb_interface_assoc_descriptor *assoc =
+                        usb_ifnum_to_if(dev, ctrlif)->intf_assoc;
+
+                if (!assoc) {
+                        snd_printk(KERN_ERR "Audio class v2 interfaces need an interface association\n");
+                        return -EINVAL;
                 }
-                if (snd_usb_get_speed(dev) == USB_SPEED_LOW) {
-                        snd_printk(KERN_ERR "low speed audio streaming not supported\n");
-                        continue;
+
+                /* FIXME: for now, we expect there is at least one clock source
+                 * descriptor and we always take the first one.
+                 * We should properly support devices with multiple clock sources,
+                 * clock selectors and sample rate conversion units. */
+
+                cs = snd_usb_find_csint_desc(host_iface->extra, host_iface->extralen,
+                                                NULL, UAC_CLOCK_SOURCE);
+
+                if (!cs) {
+                        snd_printk(KERN_ERR "CLOCK_SOURCE descriptor not found\n");
+                        return -EINVAL;
                 }
-                if (! parse_audio_endpoints(chip, j)) {
-                        usb_set_interface(dev, j, 0); /* reset the current interface */
-                        usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L);
+
+                chip->clock_id = cs->bClockID;
+
+                for (i = 0; i < assoc->bInterfaceCount; i++) {
+                        int intf = assoc->bFirstInterface + i;
+
+                        if (intf != ctrlif)
+                                snd_usb_create_stream(chip, ctrlif, intf);
                 }
+
+                break;
+        }
+
+        default:
+                snd_printk(KERN_ERR "unknown protocol version 0x%02x\n", protocol);
+                return -EINVAL;
         }
 
         return 0;
@@ -3005,7 +3305,7 @@ static int create_uaxx_quirk(struct snd_usb_audio *chip,
         static const struct audioformat ua_format = {
                 .format = SNDRV_PCM_FORMAT_S24_3LE,
                 .channels = 2,
-                .fmt_type = USB_FORMAT_TYPE_I,
+                .fmt_type = UAC_FORMAT_TYPE_I,
                 .altsetting = 1,
                 .altset_idx = 1,
                 .rates = SNDRV_PCM_RATE_CONTINUOUS,
@@ -3038,12 +3338,11 @@ static int create_uaxx_quirk(struct snd_usb_audio *chip,
                         .type = QUIRK_MIDI_FIXED_ENDPOINT,
                         .data = &uaxx_ep
                 };
-                if (chip->usb_id == USB_ID(0x0582, 0x002b))
-                        return snd_usb_create_midi_interface(chip, iface,
-                                                             &ua700_quirk);
-                else
-                        return snd_usb_create_midi_interface(chip, iface,
-                                                             &uaxx_quirk);
+                const struct snd_usb_audio_quirk *quirk =
+                        chip->usb_id == USB_ID(0x0582, 0x002b)
+                        ? &ua700_quirk : &uaxx_quirk;
+                return snd_usbmidi_create(chip->card, iface,
+                                          &chip->midi_list, quirk);
         }
 
         if (altsd->bNumEndpoints != 1)
@@ -3089,111 +3388,6 @@ static int create_uaxx_quirk(struct snd_usb_audio *chip,
         return 0;
 }
 
-/*
- * Create a stream for an Edirol UA-1000 interface.
- */
-static int create_ua1000_quirk(struct snd_usb_audio *chip,
-                               struct usb_interface *iface,
-                               const struct snd_usb_audio_quirk *quirk)
-{
-        static const struct audioformat ua1000_format = {
-                .format = SNDRV_PCM_FORMAT_S32_LE,
-                .fmt_type = USB_FORMAT_TYPE_I,
-                .altsetting = 1,
-                .altset_idx = 1,
-                .attributes = 0,
-                .rates = SNDRV_PCM_RATE_CONTINUOUS,
-        };
-        struct usb_host_interface *alts;
-        struct usb_interface_descriptor *altsd;
-        struct audioformat *fp;
-        int stream, err;
-
-        if (iface->num_altsetting != 2)
-                return -ENXIO;
-        alts = &iface->altsetting[1];
-        altsd = get_iface_desc(alts);
-        if (alts->extralen != 11 || alts->extra[1] != USB_DT_CS_INTERFACE ||
-            altsd->bNumEndpoints != 1)
-                return -ENXIO;
-
-        fp = kmemdup(&ua1000_format, sizeof(*fp), GFP_KERNEL);
-        if (!fp)
-                return -ENOMEM;
-
-        fp->channels = alts->extra[4];
-        fp->iface = altsd->bInterfaceNumber;
-        fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
-        fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
-        fp->datainterval = parse_datainterval(chip, alts);
-        fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
-        fp->rate_max = fp->rate_min = combine_triple(&alts->extra[8]);
-
-        stream = (fp->endpoint & USB_DIR_IN)
-                ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
-        err = add_audio_endpoint(chip, stream, fp);
-        if (err < 0) {
-                kfree(fp);
-                return err;
-        }
-        /* FIXME: playback must be synchronized to capture */
-        usb_set_interface(chip->dev, fp->iface, 0);
-        return 0;
-}
-
-/*
- * Create a stream for an Edirol UA-101 interface.
- * Copy, paste and modify from Edirol UA-1000
- */
-static int create_ua101_quirk(struct snd_usb_audio *chip,
-                               struct usb_interface *iface,
-                               const struct snd_usb_audio_quirk *quirk)
-{
-        static const struct audioformat ua101_format = {
-                .format = SNDRV_PCM_FORMAT_S32_LE,
-                .fmt_type = USB_FORMAT_TYPE_I,
-                .altsetting = 1,
-                .altset_idx = 1,
-                .attributes = 0,
-                .rates = SNDRV_PCM_RATE_CONTINUOUS,
-        };
-        struct usb_host_interface *alts;
-        struct usb_interface_descriptor *altsd;
-        struct audioformat *fp;
-        int stream, err;
-
-        if (iface->num_altsetting != 2)
-                return -ENXIO;
-        alts = &iface->altsetting[1];
-        altsd = get_iface_desc(alts);
-        if (alts->extralen != 18 || alts->extra[1] != USB_DT_CS_INTERFACE ||
-            altsd->bNumEndpoints != 1)
-                return -ENXIO;
-
-        fp = kmemdup(&ua101_format, sizeof(*fp), GFP_KERNEL);
-        if (!fp)
-                return -ENOMEM;
-
-        fp->channels = alts->extra[11];
-        fp->iface = altsd->bInterfaceNumber;
-        fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
-        fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
-        fp->datainterval = parse_datainterval(chip, alts);
-        fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
-        fp->rate_max = fp->rate_min = combine_triple(&alts->extra[15]);
-
-        stream = (fp->endpoint & USB_DIR_IN)
-                ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
-        err = add_audio_endpoint(chip, stream, fp);
-        if (err < 0) {
-                kfree(fp);
-                return err;
-        }
-        /* FIXME: playback must be synchronized to capture */
-        usb_set_interface(chip->dev, fp->iface, 0);
-        return 0;
-}
-
 static int snd_usb_create_quirk(struct snd_usb_audio *chip,
                                 struct usb_interface *iface,
                                 const struct snd_usb_audio_quirk *quirk);
@@ -3231,6 +3425,18 @@ static int ignore_interface_quirk(struct snd_usb_audio *chip,
         return 0;
 }
 
+/*
+ * Allow alignment on audio sub-slot (channel samples) rather than
+ * on audio slots (audio frames)
+ */
+static int create_align_transfer_quirk(struct snd_usb_audio *chip,
+                                  struct usb_interface *iface,
+                                  const struct snd_usb_audio_quirk *quirk)
+{
+        chip->txfr_quirk = 1;
+        return 1;       /* Continue with creating streams and mixer */
+}
+
 
 /*
  * boot quirks
@@ -3326,6 +3532,32 @@ static int snd_usb_cm6206_boot_quirk(struct usb_device *dev)
 }
 
 /*
+ * This call will put the synth in "USB send" mode, i.e it will send MIDI
+ * messages through USB (this is disabled at startup). The synth will
+ * acknowledge by sending a sysex on endpoint 0x85 and by displaying a USB
+ * sign on its LCD. Values here are chosen based on sniffing USB traffic
+ * under Windows.
+ */
+static int snd_usb_accessmusic_boot_quirk(struct usb_device *dev)
+{
+        int err, actual_length;
+
+        /* "midi send" enable */
+        static const u8 seq[] = { 0x4e, 0x73, 0x52, 0x01 };
+
+        void *buf = kmemdup(seq, ARRAY_SIZE(seq), GFP_KERNEL);
+        if (!buf)
+                return -ENOMEM;
+        err = usb_interrupt_msg(dev, usb_sndintpipe(dev, 0x05), buf,
+                        ARRAY_SIZE(seq), &actual_length, 1000);
+        kfree(buf);
+        if (err < 0)
+                return err;
+
+        return 0;
+}
+
+/*
  * Setup quirks
  */
 #define AUDIOPHILE_SET                  0x01 /* if set, parse device_setup */
@@ -3370,6 +3602,13 @@ static int audiophile_skip_setting_quirk(struct snd_usb_audio *chip,
         return 0; /* keep this altsetting */
 }
 
+static int create_any_midi_quirk(struct snd_usb_audio *chip,
+                                 struct usb_interface *intf,
+                                 const struct snd_usb_audio_quirk *quirk)
+{
+        return snd_usbmidi_create(chip->card, intf, &chip->midi_list, quirk);
+}
+
 /*
  * audio-interface quirks
  *
@@ -3387,19 +3626,18 @@ static int snd_usb_create_quirk(struct snd_usb_audio *chip,
         static const quirk_func_t quirk_funcs[] = {
                 [QUIRK_IGNORE_INTERFACE] = ignore_interface_quirk,
                 [QUIRK_COMPOSITE] = create_composite_quirk,
-                [QUIRK_MIDI_STANDARD_INTERFACE] = snd_usb_create_midi_interface,
-                [QUIRK_MIDI_FIXED_ENDPOINT] = snd_usb_create_midi_interface,
-                [QUIRK_MIDI_YAMAHA] = snd_usb_create_midi_interface,
-                [QUIRK_MIDI_MIDIMAN] = snd_usb_create_midi_interface,
-                [QUIRK_MIDI_NOVATION] = snd_usb_create_midi_interface,
-                [QUIRK_MIDI_FASTLANE] = snd_usb_create_midi_interface,
-                [QUIRK_MIDI_EMAGIC] = snd_usb_create_midi_interface,
-                [QUIRK_MIDI_CME] = snd_usb_create_midi_interface,
+                [QUIRK_MIDI_STANDARD_INTERFACE] = create_any_midi_quirk,
+                [QUIRK_MIDI_FIXED_ENDPOINT] = create_any_midi_quirk,
+                [QUIRK_MIDI_YAMAHA] = create_any_midi_quirk,
+                [QUIRK_MIDI_MIDIMAN] = create_any_midi_quirk,
+                [QUIRK_MIDI_NOVATION] = create_any_midi_quirk,
+                [QUIRK_MIDI_FASTLANE] = create_any_midi_quirk,
+                [QUIRK_MIDI_EMAGIC] = create_any_midi_quirk,
+                [QUIRK_MIDI_CME] = create_any_midi_quirk,
                 [QUIRK_AUDIO_STANDARD_INTERFACE] = create_standard_audio_quirk,
                 [QUIRK_AUDIO_FIXED_ENDPOINT] = create_fixed_stream_quirk,
-                [QUIRK_AUDIO_EDIROL_UA1000] = create_ua1000_quirk,
-                [QUIRK_AUDIO_EDIROL_UA101] = create_ua101_quirk,
-                [QUIRK_AUDIO_EDIROL_UAXX] = create_uaxx_quirk
+                [QUIRK_AUDIO_EDIROL_UAXX] = create_uaxx_quirk,
+                [QUIRK_AUDIO_ALIGN_TRANSFER] = create_align_transfer_quirk
         };
 
         if (quirk->type < QUIRK_TYPE_COUNT) {
@@ -3588,7 +3826,6 @@ static void *snd_usb_audio_probe(struct usb_device *dev,
         ifnum = get_iface_desc(alts)->bInterfaceNumber;
         id = USB_ID(le16_to_cpu(dev->descriptor.idVendor),
                     le16_to_cpu(dev->descriptor.idProduct));
-
         if (quirk && quirk->ifnum >= 0 && ifnum != quirk->ifnum)
                 goto __err_val;
 
@@ -3616,6 +3853,12 @@ static void *snd_usb_audio_probe(struct usb_device *dev,
                         goto __err_val;
         }
 
+        /* Access Music VirusTI Desktop */
+        if (id == USB_ID(0x133e, 0x0815)) {
+                if (snd_usb_accessmusic_boot_quirk(dev) < 0)
+                        goto __err_val;
+        }
+
         /*
          * found a config.  now register to ALSA
          */
@@ -3653,6 +3896,7 @@ static void *snd_usb_audio_probe(struct usb_device *dev,
                 }
         }
 
+        chip->txfr_quirk = 0;
         err = 1; /* continue */
         if (quirk && quirk->ifnum != QUIRK_NO_INTERFACE) {
                 /* need some special handlings */
diff --git a/sound/usb/usbaudio.h b/sound/usb/usbaudio.h
index e9a3a9dca15c..42c299cbf63a 100644
--- a/sound/usb/usbaudio.h
+++ b/sound/usb/usbaudio.h
@@ -21,93 +21,6 @@
  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  */
 
-
-/*
- */
-
-#define USB_SUBCLASS_AUDIO_CONTROL      0x01
-#define USB_SUBCLASS_AUDIO_STREAMING    0x02
-#define USB_SUBCLASS_MIDI_STREAMING     0x03
-#define USB_SUBCLASS_VENDOR_SPEC        0xff
-
-#define HEADER                          0x01
-#define INPUT_TERMINAL                  0x02
-#define OUTPUT_TERMINAL                 0x03
-#define MIXER_UNIT                      0x04
-#define SELECTOR_UNIT                   0x05
-#define FEATURE_UNIT                    0x06
-#define PROCESSING_UNIT                 0x07
-#define EXTENSION_UNIT                  0x08
-
-#define AS_GENERAL                      0x01
-#define FORMAT_TYPE                     0x02
-#define FORMAT_SPECIFIC                 0x03
-
-#define EP_GENERAL                      0x01
-
-#define MS_GENERAL                      0x01
-#define MIDI_IN_JACK                    0x02
-#define MIDI_OUT_JACK                   0x03
-
-/* endpoint attributes */
-#define EP_ATTR_MASK                    0x0c
-#define EP_ATTR_ASYNC                   0x04
-#define EP_ATTR_ADAPTIVE                0x08
-#define EP_ATTR_SYNC                    0x0c
-
-/* cs endpoint attributes */
-#define EP_CS_ATTR_SAMPLE_RATE          0x01
-#define EP_CS_ATTR_PITCH_CONTROL        0x02
-#define EP_CS_ATTR_FILL_MAX             0x80
-
-/* Audio Class specific Request Codes */
-
-#define SET_CUR    0x01
-#define GET_CUR    0x81
-#define SET_MIN    0x02
-#define GET_MIN    0x82
-#define SET_MAX    0x03
-#define GET_MAX    0x83
-#define SET_RES    0x04
-#define GET_RES    0x84
-#define SET_MEM    0x05
-#define GET_MEM    0x85
-#define GET_STAT   0xff
-
-/* Terminal Control Selectors */
-
-#define COPY_PROTECT_CONTROL       0x01
-
-/* Endpoint Control Selectors */
-
-#define SAMPLING_FREQ_CONTROL      0x01
-#define PITCH_CONTROL              0x02
-
-/* Format Types */
-#define USB_FORMAT_TYPE_I       0x01
-#define USB_FORMAT_TYPE_II      0x02
-#define USB_FORMAT_TYPE_III     0x03
-
-/* type I */
-#define USB_AUDIO_FORMAT_PCM    0x01
-#define USB_AUDIO_FORMAT_PCM8   0x02
-#define USB_AUDIO_FORMAT_IEEE_FLOAT     0x03
-#define USB_AUDIO_FORMAT_ALAW   0x04
-#define USB_AUDIO_FORMAT_MU_LAW 0x05
-
-/* type II */
-#define USB_AUDIO_FORMAT_MPEG   0x1001
-#define USB_AUDIO_FORMAT_AC3    0x1002
-
-/* type III */
-#define USB_AUDIO_FORMAT_IEC1937_AC3    0x2001
-#define USB_AUDIO_FORMAT_IEC1937_MPEG1_LAYER1   0x2002
-#define USB_AUDIO_FORMAT_IEC1937_MPEG2_NOEXT    0x2003
-#define USB_AUDIO_FORMAT_IEC1937_MPEG2_EXT      0x2004
-#define USB_AUDIO_FORMAT_IEC1937_MPEG2_LAYER1_LS        0x2005
-#define USB_AUDIO_FORMAT_IEC1937_MPEG2_LAYER23_LS       0x2006
-
-
 /* maximum number of endpoints per interface */
 #define MIDI_MAX_ENDPOINTS 2
 
@@ -125,14 +38,17 @@ struct snd_usb_audio {
         struct snd_card *card;
         u32 usb_id;
         int shutdown;
+        unsigned int txfr_quirk:1; /* Subframe boundaries on transfers */
         int num_interfaces;
         int num_suspended_intf;
 
+        /* for audio class v2 */
+        int clock_id;
+
         struct list_head pcm_list;      /* list of pcm streams */
         int pcm_devs;
 
         struct list_head midi_list;     /* list of midi interfaces */
-        int next_midi_device;
 
         struct list_head mixer_list;    /* list of mixer interfaces */
 };
@@ -159,9 +75,8 @@ enum quirk_type {
         QUIRK_MIDI_US122L,
         QUIRK_AUDIO_STANDARD_INTERFACE,
         QUIRK_AUDIO_FIXED_ENDPOINT,
-        QUIRK_AUDIO_EDIROL_UA1000,
-        QUIRK_AUDIO_EDIROL_UA101,
         QUIRK_AUDIO_EDIROL_UAXX,
+        QUIRK_AUDIO_ALIGN_TRANSFER,
 
         QUIRK_TYPE_COUNT
 };
@@ -196,7 +111,7 @@ struct snd_usb_midi_endpoint_info {
 
 /* for QUIRK_AUDIO/MIDI_STANDARD_INTERFACE, data is NULL */
 
-/* for QUIRK_AUDIO_EDIROL_UA700_UA25/UA1000, data is NULL */
+/* for QUIRK_AUDIO_EDIROL_UAXX, data is NULL */
 
 /* for QUIRK_IGNORE_INTERFACE, data is NULL */
 
@@ -210,6 +125,16 @@ struct snd_usb_midi_endpoint_info {
 /*
  */
 
+/*E-mu USB samplerate control quirk*/
+enum {
+        EMU_QUIRK_SR_44100HZ = 0,
+        EMU_QUIRK_SR_48000HZ,
+        EMU_QUIRK_SR_88200HZ,
+        EMU_QUIRK_SR_96000HZ,
+        EMU_QUIRK_SR_176400HZ,
+        EMU_QUIRK_SR_192000HZ
+};
+
 #define combine_word(s)    ((*(s)) | ((unsigned int)(s)[1] << 8))
 #define combine_triple(s)  (combine_word(s) | ((unsigned int)(s)[2] << 16))
 #define combine_quad(s)    (combine_triple(s) | ((unsigned int)(s)[3] << 24))
@@ -227,12 +152,17 @@ int snd_usb_create_mixer(struct snd_usb_audio *chip, int ctrlif,
                          int ignore_error);
 void snd_usb_mixer_disconnect(struct list_head *p);
 
-int snd_usb_create_midi_interface(struct snd_usb_audio *chip, struct usb_interface *iface,
-                                  const struct snd_usb_audio_quirk *quirk);
+int snd_usbmidi_create(struct snd_card *card,
+                       struct usb_interface *iface,
+                       struct list_head *midi_list,
+                       const struct snd_usb_audio_quirk *quirk);
 void snd_usbmidi_input_stop(struct list_head* p);
 void snd_usbmidi_input_start(struct list_head* p);
 void snd_usbmidi_disconnect(struct list_head *p);
 
+void snd_emuusb_set_samplerate(struct snd_usb_audio *chip,
+                        unsigned char samplerate_id);
+
 /*
  * retrieve usb_interface descriptor from the host interface
  * (conditional for compatibility with the older API)
diff --git a/sound/usb/usbmidi.c b/sound/usb/usbmidi.c
index 0eff19ceb7e1..9e28b20cb2ce 100644
--- a/sound/usb/usbmidi.c
+++ b/sound/usb/usbmidi.c
@@ -1,7 +1,7 @@
 /*
  * usbmidi.c - ALSA USB MIDI driver
  *
- * Copyright (c) 2002-2007 Clemens Ladisch
+ * Copyright (c) 2002-2009 Clemens Ladisch
  * All rights reserved.
  *
  * Based on the OSS usb-midi driver by NAGANO Daisuke,
@@ -46,7 +46,10 @@
 #include <linux/timer.h>
 #include <linux/usb.h>
 #include <linux/wait.h>
+#include <linux/usb/audio.h>
+
 #include <sound/core.h>
+#include <sound/control.h>
 #include <sound/rawmidi.h>
 #include <sound/asequencer.h>
 #include "usbaudio.h"
@@ -101,7 +104,8 @@ struct usb_protocol_ops {
 };
 
 struct snd_usb_midi {
-        struct snd_usb_audio *chip;
+        struct usb_device *dev;
+        struct snd_card *card;
         struct usb_interface *iface;
         const struct snd_usb_audio_quirk *quirk;
         struct snd_rawmidi *rmidi;
@@ -109,13 +113,19 @@ struct snd_usb_midi {
         struct list_head list;
         struct timer_list error_timer;
         spinlock_t disc_lock;
+        struct mutex mutex;
+        u32 usb_id;
+        int next_midi_device;
 
         struct snd_usb_midi_endpoint {
                 struct snd_usb_midi_out_endpoint *out;
                 struct snd_usb_midi_in_endpoint *in;
         } endpoints[MIDI_MAX_ENDPOINTS];
         unsigned long input_triggered;
+        unsigned int opened;
         unsigned char disconnected;
+
+        struct snd_kcontrol *roland_load_ctl;
 };
 
 struct snd_usb_midi_out_endpoint {
@@ -255,7 +265,7 @@ static void snd_usbmidi_in_urb_complete(struct urb* urb)
                 }
         }
 
-        urb->dev = ep->umidi->chip->dev;
+        urb->dev = ep->umidi->dev;
         snd_usbmidi_submit_urb(urb, GFP_ATOMIC);
 }
 
@@ -296,7 +306,7 @@ static void snd_usbmidi_do_output(struct snd_usb_midi_out_endpoint* ep)
         unsigned long flags;
 
         spin_lock_irqsave(&ep->buffer_lock, flags);
-        if (ep->umidi->chip->shutdown) {
+        if (ep->umidi->disconnected) {
                 spin_unlock_irqrestore(&ep->buffer_lock, flags);
                 return;
         }
@@ -312,7 +322,7 @@ static void snd_usbmidi_do_output(struct snd_usb_midi_out_endpoint* ep)
 
                         dump_urb("sending", urb->transfer_buffer,
                                  urb->transfer_buffer_length);
-                        urb->dev = ep->umidi->chip->dev;
+                        urb->dev = ep->umidi->dev;
                         if (snd_usbmidi_submit_urb(urb, GFP_ATOMIC) < 0)
                                 break;
                         ep->active_urbs |= 1 << urb_index;
@@ -349,7 +359,7 @@ static void snd_usbmidi_error_timer(unsigned long data)
                 if (in && in->error_resubmit) {
                         in->error_resubmit = 0;
                         for (j = 0; j < INPUT_URBS; ++j) {
-                                in->urbs[j]->dev = umidi->chip->dev;
+                                in->urbs[j]->dev = umidi->dev;
                                 snd_usbmidi_submit_urb(in->urbs[j], GFP_ATOMIC);
                         }
                 }
@@ -369,7 +379,7 @@ static int send_bulk_static_data(struct snd_usb_midi_out_endpoint* ep,
                 return -ENOMEM;
         dump_urb("sending", buf, len);
         if (ep->urbs[0].urb)
-                err = usb_bulk_msg(ep->umidi->chip->dev, ep->urbs[0].urb->pipe,
+                err = usb_bulk_msg(ep->umidi->dev, ep->urbs[0].urb->pipe,
                                    buf, len, NULL, 250);
         kfree(buf);
         return err;
@@ -724,8 +734,7 @@ static void snd_usbmidi_us122l_output(struct snd_usb_midi_out_endpoint *ep,
 
         if (!ep->ports[0].active)
                 return;
-        count = snd_usb_get_speed(ep->umidi->chip->dev) == USB_SPEED_HIGH
-                ? 1 : 2;
+        count = snd_usb_get_speed(ep->umidi->dev) == USB_SPEED_HIGH ? 1 : 2;
         count = snd_rawmidi_transmit(ep->ports[0].substream,
                                      urb->transfer_buffer,
                                      count);
@@ -879,6 +888,50 @@ static struct usb_protocol_ops snd_usbmidi_emagic_ops = {
 };
 
 
+static void update_roland_altsetting(struct snd_usb_midi* umidi)
+{
+        struct usb_interface *intf;
+        struct usb_host_interface *hostif;
+        struct usb_interface_descriptor *intfd;
+        int is_light_load;
+
+        intf = umidi->iface;
+        is_light_load = intf->cur_altsetting != intf->altsetting;
+        if (umidi->roland_load_ctl->private_value == is_light_load)
+                return;
+        hostif = &intf->altsetting[umidi->roland_load_ctl->private_value];
+        intfd = get_iface_desc(hostif);
+        snd_usbmidi_input_stop(&umidi->list);
+        usb_set_interface(umidi->dev, intfd->bInterfaceNumber,
+                          intfd->bAlternateSetting);
+        snd_usbmidi_input_start(&umidi->list);
+}
+
+static void substream_open(struct snd_rawmidi_substream *substream, int open)
+{
+        struct snd_usb_midi* umidi = substream->rmidi->private_data;
+        struct snd_kcontrol *ctl;
+
+        mutex_lock(&umidi->mutex);
+        if (open) {
+                if (umidi->opened++ == 0 && umidi->roland_load_ctl) {
+                        ctl = umidi->roland_load_ctl;
+                        ctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
+                        snd_ctl_notify(umidi->card,
+                                       SNDRV_CTL_EVENT_MASK_INFO, &ctl->id);
+                        update_roland_altsetting(umidi);
+                }
+        } else {
+                if (--umidi->opened == 0 && umidi->roland_load_ctl) {
+                        ctl = umidi->roland_load_ctl;
+                        ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
+                        snd_ctl_notify(umidi->card,
+                                       SNDRV_CTL_EVENT_MASK_INFO, &ctl->id);
+                }
+        }
+        mutex_unlock(&umidi->mutex);
+}
+
 static int snd_usbmidi_output_open(struct snd_rawmidi_substream *substream)
 {
         struct snd_usb_midi* umidi = substream->rmidi->private_data;
@@ -898,11 +951,13 @@ static int snd_usbmidi_output_open(struct snd_rawmidi_substream *substream)
         }
         substream->runtime->private_data = port;
         port->state = STATE_UNKNOWN;
+        substream_open(substream, 1);
         return 0;
 }
 
 static int snd_usbmidi_output_close(struct snd_rawmidi_substream *substream)
 {
+        substream_open(substream, 0);
         return 0;
 }
 
@@ -912,7 +967,7 @@ static void snd_usbmidi_output_trigger(struct snd_rawmidi_substream *substream,
 
         port->active = up;
         if (up) {
-                if (port->ep->umidi->chip->shutdown) {
+                if (port->ep->umidi->disconnected) {
                         /* gobble up remaining bytes to prevent wait in
                          * snd_rawmidi_drain_output */
                         while (!snd_rawmidi_transmit_empty(substream))
@@ -931,6 +986,8 @@ static void snd_usbmidi_output_drain(struct snd_rawmidi_substream *substream)
         DEFINE_WAIT(wait);
         long timeout = msecs_to_jiffies(50);
 
+        if (ep->umidi->disconnected)
+                return;
         /*
          * 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.
@@ -954,11 +1011,13 @@ static void snd_usbmidi_output_drain(struct snd_rawmidi_substream *substream)
 
 static int snd_usbmidi_input_open(struct snd_rawmidi_substream *substream)
 {
+        substream_open(substream, 1);
         return 0;
 }
 
 static int snd_usbmidi_input_close(struct snd_rawmidi_substream *substream)
 {
+        substream_open(substream, 0);
         return 0;
 }
 
@@ -988,7 +1047,7 @@ static struct snd_rawmidi_ops snd_usbmidi_input_ops = {
 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,
+        usb_buffer_free(umidi->dev, buffer_length,
                         urb->transfer_buffer, urb->transfer_dma);
         usb_free_urb(urb);
 }
@@ -1035,24 +1094,24 @@ static int snd_usbmidi_in_endpoint_create(struct snd_usb_midi* umidi,
                 }
         }
         if (ep_info->in_interval)
-                pipe = usb_rcvintpipe(umidi->chip->dev, ep_info->in_ep);
+                pipe = usb_rcvintpipe(umidi->dev, ep_info->in_ep);
         else
-                pipe = usb_rcvbulkpipe(umidi->chip->dev, ep_info->in_ep);
-        length = usb_maxpacket(umidi->chip->dev, pipe, 0);
+                pipe = usb_rcvbulkpipe(umidi->dev, ep_info->in_ep);
+        length = usb_maxpacket(umidi->dev, pipe, 0);
         for (i = 0; i < INPUT_URBS; ++i) {
-                buffer = usb_buffer_alloc(umidi->chip->dev, length, GFP_KERNEL,
+                buffer = usb_buffer_alloc(umidi->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,
+                        usb_fill_int_urb(ep->urbs[i], umidi->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,
+                        usb_fill_bulk_urb(ep->urbs[i], umidi->dev,
                                           pipe, buffer, length,
                                           snd_usbmidi_in_urb_complete, ep);
                 ep->urbs[i]->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
@@ -1062,27 +1121,25 @@ static int snd_usbmidi_in_endpoint_create(struct snd_usb_midi* umidi,
         return 0;
 }
 
-static unsigned int snd_usbmidi_count_bits(unsigned int x)
-{
-        unsigned int bits;
-
-        for (bits = 0; x; ++bits)
-                x &= x - 1;
-        return bits;
-}
-
 /*
  * Frees an output endpoint.
  * May be called when ep hasn't been initialized completely.
  */
-static void snd_usbmidi_out_endpoint_delete(struct snd_usb_midi_out_endpoint* ep)
+static void snd_usbmidi_out_endpoint_clear(struct snd_usb_midi_out_endpoint *ep)
 {
         unsigned int i;
 
         for (i = 0; i < OUTPUT_URBS; ++i)
-                if (ep->urbs[i].urb)
+                if (ep->urbs[i].urb) {
                         free_urb_and_buffer(ep->umidi, ep->urbs[i].urb,
                                             ep->max_transfer);
+                        ep->urbs[i].urb = NULL;
+                }
+}
+
+static void snd_usbmidi_out_endpoint_delete(struct snd_usb_midi_out_endpoint *ep)
+{
+        snd_usbmidi_out_endpoint_clear(ep);
         kfree(ep);
 }
 
@@ -1113,15 +1170,27 @@ static int snd_usbmidi_out_endpoint_create(struct snd_usb_midi* umidi,
                 ep->urbs[i].ep = ep;
         }
         if (ep_info->out_interval)
-                pipe = usb_sndintpipe(umidi->chip->dev, ep_info->out_ep);
+                pipe = usb_sndintpipe(umidi->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 */
+                pipe = usb_sndbulkpipe(umidi->dev, ep_info->out_ep);
+        switch (umidi->usb_id) {
+        default:
+                ep->max_transfer = usb_maxpacket(umidi->dev, pipe, 1);
+                break;
+                /*
+                 * Various chips declare a packet size larger than 4 bytes, but
+                 * do not actually work with larger packets:
+                 */
+        case USB_ID(0x0a92, 0x1020): /* ESI M4U */
+        case USB_ID(0x1430, 0x474b): /* RedOctane GH MIDI INTERFACE */
+        case USB_ID(0x15ca, 0x0101): /* Textech USB Midi Cable */
+        case USB_ID(0x15ca, 0x1806): /* Textech USB Midi Cable */
+        case USB_ID(0x1a86, 0x752d): /* QinHeng CH345 "USB2.0-MIDI" */
                 ep->max_transfer = 4;
-        else
-                ep->max_transfer = usb_maxpacket(umidi->chip->dev, pipe, 1);
+                break;
+        }
         for (i = 0; i < OUTPUT_URBS; ++i) {
-                buffer = usb_buffer_alloc(umidi->chip->dev,
+                buffer = usb_buffer_alloc(umidi->dev,
                                           ep->max_transfer, GFP_KERNEL,
                                           &ep->urbs[i].urb->transfer_dma);
                 if (!buffer) {
@@ -1129,12 +1198,12 @@ static int snd_usbmidi_out_endpoint_create(struct snd_usb_midi* umidi,
                         return -ENOMEM;
                 }
                 if (ep_info->out_interval)
-                        usb_fill_int_urb(ep->urbs[i].urb, umidi->chip->dev,
+                        usb_fill_int_urb(ep->urbs[i].urb, umidi->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,
+                        usb_fill_bulk_urb(ep->urbs[i].urb, umidi->dev,
                                           pipe, buffer, ep->max_transfer,
                                           snd_usbmidi_out_urb_complete,
                                           &ep->urbs[i]);
@@ -1172,6 +1241,7 @@ static void snd_usbmidi_free(struct snd_usb_midi* umidi)
                 if (ep->in)
                         snd_usbmidi_in_endpoint_delete(ep->in);
         }
+        mutex_destroy(&umidi->mutex);
         kfree(umidi);
 }
 
@@ -1201,15 +1271,18 @@ void snd_usbmidi_disconnect(struct list_head* p)
                                 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);
+                        ep->out->active_urbs = 0;
+                        if (ep->out->drain_urbs) {
+                                ep->out->drain_urbs = 0;
+                                wake_up(&ep->out->drain_wait);
+                        }
                 }
                 if (ep->in)
                         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);
-                        ep->out = NULL;
-                }
+                if (ep->out)
+                        snd_usbmidi_out_endpoint_clear(ep->out);
                 if (ep->in) {
                         snd_usbmidi_in_endpoint_delete(ep->in);
                         ep->in = NULL;
@@ -1360,6 +1433,12 @@ static struct port_info {
         EXTERNAL_PORT(0x086a, 0x0001, 8, "%s Broadcast"),
         EXTERNAL_PORT(0x086a, 0x0002, 8, "%s Broadcast"),
         EXTERNAL_PORT(0x086a, 0x0003, 4, "%s Broadcast"),
+        /* Access Music Virus TI */
+        EXTERNAL_PORT(0x133e, 0x0815, 0, "%s MIDI"),
+        PORT_INFO(0x133e, 0x0815, 1, "%s Synth", 0,
+                SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC |
+                SNDRV_SEQ_PORT_TYPE_HARDWARE |
+                SNDRV_SEQ_PORT_TYPE_SYNTHESIZER),
 };
 
 static struct port_info *find_port_info(struct snd_usb_midi* umidi, int number)
@@ -1367,7 +1446,7 @@ static struct port_info *find_port_info(struct snd_usb_midi* umidi, int number)
         int i;
 
         for (i = 0; i < ARRAY_SIZE(snd_usbmidi_port_info); ++i) {
-                if (snd_usbmidi_port_info[i].id == umidi->chip->usb_id &&
+                if (snd_usbmidi_port_info[i].id == umidi->usb_id &&
                     snd_usbmidi_port_info[i].port == number)
                         return &snd_usbmidi_port_info[i];
         }
@@ -1405,7 +1484,7 @@ static void snd_usbmidi_init_substream(struct snd_usb_midi* umidi,
         port_info = find_port_info(umidi, number);
         name_format = port_info ? port_info->name : "%s MIDI %d";
         snprintf(substream->name, sizeof(substream->name),
-                 name_format, umidi->chip->card->shortname, number + 1);
+                 name_format, umidi->card->shortname, number + 1);
 
         *rsubstream = substream;
 }
@@ -1475,7 +1554,7 @@ static int snd_usbmidi_get_ms_info(struct snd_usb_midi* umidi,
         if (hostif->extralen >= 7 &&
             ms_header->bLength >= 7 &&
             ms_header->bDescriptorType == USB_DT_CS_INTERFACE &&
-            ms_header->bDescriptorSubtype == HEADER)
+            ms_header->bDescriptorSubtype == UAC_HEADER)
                 snd_printdd(KERN_INFO "MIDIStreaming version %02x.%02x\n",
                             ms_header->bcdMSC[1], ms_header->bcdMSC[0]);
         else
@@ -1491,7 +1570,7 @@ static int snd_usbmidi_get_ms_info(struct snd_usb_midi* umidi,
                 if (hostep->extralen < 4 ||
                     ms_ep->bLength < 4 ||
                     ms_ep->bDescriptorType != USB_DT_CS_ENDPOINT ||
-                    ms_ep->bDescriptorSubtype != MS_GENERAL)
+                    ms_ep->bDescriptorSubtype != UAC_MS_GENERAL)
                         continue;
                 if (usb_endpoint_dir_out(ep)) {
                         if (endpoints[epidx].out_ep) {
@@ -1503,7 +1582,7 @@ static int snd_usbmidi_get_ms_info(struct snd_usb_midi* umidi,
                         endpoints[epidx].out_ep = usb_endpoint_num(ep);
                         if (usb_endpoint_xfer_int(ep))
                                 endpoints[epidx].out_interval = ep->bInterval;
-                        else if (snd_usb_get_speed(umidi->chip->dev) == USB_SPEED_LOW)
+                        else if (snd_usb_get_speed(umidi->dev) == USB_SPEED_LOW)
                                 /*
                                  * Low speed bulk transfers don't exist, so
                                  * force interrupt transfers for devices like
@@ -1523,7 +1602,7 @@ static int snd_usbmidi_get_ms_info(struct snd_usb_midi* umidi,
                         endpoints[epidx].in_ep = usb_endpoint_num(ep);
                         if (usb_endpoint_xfer_int(ep))
                                 endpoints[epidx].in_interval = ep->bInterval;
-                        else if (snd_usb_get_speed(umidi->chip->dev) == USB_SPEED_LOW)
+                        else if (snd_usb_get_speed(umidi->dev) == USB_SPEED_LOW)
                                 endpoints[epidx].in_interval = 1;
                         endpoints[epidx].in_cables = (1 << ms_ep->bNumEmbMIDIJack) - 1;
                         snd_printdd(KERN_INFO "EP %02X: %d jack(s)\n",
@@ -1533,6 +1612,52 @@ static int snd_usbmidi_get_ms_info(struct snd_usb_midi* umidi,
         return 0;
 }
 
+static int roland_load_info(struct snd_kcontrol *kcontrol,
+                            struct snd_ctl_elem_info *info)
+{
+        static const char *const names[] = { "High Load", "Light Load" };
+
+        info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        info->count = 1;
+        info->value.enumerated.items = 2;
+        if (info->value.enumerated.item > 1)
+                info->value.enumerated.item = 1;
+        strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
+        return 0;
+}
+
+static int roland_load_get(struct snd_kcontrol *kcontrol,
+                           struct snd_ctl_elem_value *value)
+{
+        value->value.enumerated.item[0] = kcontrol->private_value;
+        return 0;
+}
+
+static int roland_load_put(struct snd_kcontrol *kcontrol,
+                           struct snd_ctl_elem_value *value)
+{
+        struct snd_usb_midi* umidi = kcontrol->private_data;
+        int changed;
+
+        if (value->value.enumerated.item[0] > 1)
+                return -EINVAL;
+        mutex_lock(&umidi->mutex);
+        changed = value->value.enumerated.item[0] != kcontrol->private_value;
+        if (changed)
+                kcontrol->private_value = value->value.enumerated.item[0];
+        mutex_unlock(&umidi->mutex);
+        return changed;
+}
+
+static struct snd_kcontrol_new roland_load_ctl = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name = "MIDI Input Mode",
+        .info = roland_load_info,
+        .get = roland_load_get,
+        .put = roland_load_put,
+        .private_value = 1,
+};
+
 /*
  * On Roland devices, use the second alternate setting to be able to use
  * the interrupt input endpoint.
@@ -1556,8 +1681,12 @@ static void snd_usbmidi_switch_roland_altsetting(struct snd_usb_midi* umidi)
 
         snd_printdd(KERN_INFO "switching to altsetting %d with int ep\n",
                     intfd->bAlternateSetting);
-        usb_set_interface(umidi->chip->dev, intfd->bInterfaceNumber,
+        usb_set_interface(umidi->dev, intfd->bInterfaceNumber,
                           intfd->bAlternateSetting);
+
+        umidi->roland_load_ctl = snd_ctl_new1(&roland_load_ctl, umidi);
+        if (snd_ctl_add(umidi->card, umidi->roland_load_ctl) < 0)
+                umidi->roland_load_ctl = NULL;
 }
 
 /*
@@ -1573,7 +1702,7 @@ static int snd_usbmidi_detect_endpoints(struct snd_usb_midi* umidi,
         struct usb_endpoint_descriptor* epd;
         int i, out_eps = 0, in_eps = 0;
 
-        if (USB_ID_VENDOR(umidi->chip->usb_id) == 0x0582)
+        if (USB_ID_VENDOR(umidi->usb_id) == 0x0582)
                 snd_usbmidi_switch_roland_altsetting(umidi);
 
         if (endpoint[0].out_ep || endpoint[0].in_ep)
@@ -1653,9 +1782,9 @@ static int snd_usbmidi_detect_yamaha(struct snd_usb_midi* umidi,
              cs_desc < hostif->extra + hostif->extralen && cs_desc[0] >= 2;
              cs_desc += cs_desc[0]) {
                 if (cs_desc[1] == USB_DT_CS_INTERFACE) {
-                        if (cs_desc[2] == MIDI_IN_JACK)
+                        if (cs_desc[2] == UAC_MIDI_IN_JACK)
                                 endpoint->in_cables = (endpoint->in_cables << 1) | 1;
-                        else if (cs_desc[2] == MIDI_OUT_JACK)
+                        else if (cs_desc[2] == UAC_MIDI_OUT_JACK)
                                 endpoint->out_cables = (endpoint->out_cables << 1) | 1;
                 }
         }
@@ -1760,12 +1889,12 @@ static int snd_usbmidi_create_rawmidi(struct snd_usb_midi* umidi,
         struct snd_rawmidi *rmidi;
         int err;
 
-        err = snd_rawmidi_new(umidi->chip->card, "USB MIDI",
-                              umidi->chip->next_midi_device++,
+        err = snd_rawmidi_new(umidi->card, "USB MIDI",
+                              umidi->next_midi_device++,
                               out_ports, in_ports, &rmidi);
         if (err < 0)
                 return err;
-        strcpy(rmidi->name, umidi->chip->card->shortname);
+        strcpy(rmidi->name, umidi->card->shortname);
         rmidi->info_flags = SNDRV_RAWMIDI_INFO_OUTPUT |
                             SNDRV_RAWMIDI_INFO_INPUT |
                             SNDRV_RAWMIDI_INFO_DUPLEX;
@@ -1804,7 +1933,7 @@ static void snd_usbmidi_input_start_ep(struct snd_usb_midi_in_endpoint* ep)
                 return;
         for (i = 0; i < INPUT_URBS; ++i) {
                 struct urb* urb = ep->urbs[i];
-                urb->dev = ep->umidi->chip->dev;
+                urb->dev = ep->umidi->dev;
                 snd_usbmidi_submit_urb(urb, GFP_KERNEL);
         }
 }
@@ -1825,9 +1954,10 @@ void snd_usbmidi_input_start(struct list_head* p)
 /*
  * Creates and registers everything needed for a MIDI streaming interface.
  */
-int snd_usb_create_midi_interface(struct snd_usb_audio* chip,
-                                  struct usb_interface* iface,
-                                  const struct snd_usb_audio_quirk* quirk)
+int snd_usbmidi_create(struct snd_card *card,
+                       struct usb_interface* iface,
+                       struct list_head *midi_list,
+                       const struct snd_usb_audio_quirk* quirk)
 {
         struct snd_usb_midi* umidi;
         struct snd_usb_midi_endpoint_info endpoints[MIDI_MAX_ENDPOINTS];
@@ -1837,12 +1967,16 @@ int snd_usb_create_midi_interface(struct snd_usb_audio* chip,
         umidi = kzalloc(sizeof(*umidi), GFP_KERNEL);
         if (!umidi)
                 return -ENOMEM;
-        umidi->chip = chip;
+        umidi->dev = interface_to_usbdev(iface);
+        umidi->card = card;
         umidi->iface = iface;
         umidi->quirk = quirk;
         umidi->usb_protocol_ops = &snd_usbmidi_standard_ops;
         init_timer(&umidi->error_timer);
         spin_lock_init(&umidi->disc_lock);
+        mutex_init(&umidi->mutex);
+        umidi->usb_id = USB_ID(le16_to_cpu(umidi->dev->descriptor.idVendor),
+                               le16_to_cpu(umidi->dev->descriptor.idProduct));
         umidi->error_timer.function = snd_usbmidi_error_timer;
         umidi->error_timer.data = (unsigned long)umidi;
 
@@ -1851,7 +1985,7 @@ int snd_usb_create_midi_interface(struct snd_usb_audio* chip,
         switch (quirk ? quirk->type : QUIRK_MIDI_STANDARD_INTERFACE) {
         case QUIRK_MIDI_STANDARD_INTERFACE:
                 err = snd_usbmidi_get_ms_info(umidi, endpoints);
-                if (chip->usb_id == USB_ID(0x0763, 0x0150)) /* M-Audio Uno */
+                if (umidi->usb_id == USB_ID(0x0763, 0x0150)) /* M-Audio Uno */
                         umidi->usb_protocol_ops =
                                 &snd_usbmidi_maudio_broken_running_status_ops;
                 break;
@@ -1887,7 +2021,7 @@ int snd_usb_create_midi_interface(struct snd_usb_audio* chip,
                  * interface 0, so we have to make sure that the USB core looks
                  * again at interface 0 by calling usb_set_interface() on it.
                  */
-                usb_set_interface(umidi->chip->dev, 0, 0);
+                usb_set_interface(umidi->dev, 0, 0);
                 err = snd_usbmidi_detect_per_port_endpoints(umidi, endpoints);
                 break;
         case QUIRK_MIDI_EMAGIC:
@@ -1914,8 +2048,8 @@ int snd_usb_create_midi_interface(struct snd_usb_audio* chip,
         out_ports = 0;
         in_ports = 0;
         for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) {
-                out_ports += snd_usbmidi_count_bits(endpoints[i].out_cables);
-                in_ports += snd_usbmidi_count_bits(endpoints[i].in_cables);
+                out_ports += hweight16(endpoints[i].out_cables);
+                in_ports += hweight16(endpoints[i].in_cables);
         }
         err = snd_usbmidi_create_rawmidi(umidi, out_ports, in_ports);
         if (err < 0) {
@@ -1933,14 +2067,14 @@ int snd_usb_create_midi_interface(struct snd_usb_audio* chip,
                 return err;
         }
 
-        list_add(&umidi->list, &umidi->chip->midi_list);
+        list_add_tail(&umidi->list, midi_list);
 
         for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i)
                 snd_usbmidi_input_start_ep(umidi->endpoints[i].in);
         return 0;
 }
 
-EXPORT_SYMBOL(snd_usb_create_midi_interface);
+EXPORT_SYMBOL(snd_usbmidi_create);
 EXPORT_SYMBOL(snd_usbmidi_input_stop);
 EXPORT_SYMBOL(snd_usbmidi_input_start);
 EXPORT_SYMBOL(snd_usbmidi_disconnect);
diff --git a/sound/usb/usbmixer.c b/sound/usb/usbmixer.c
index c998220b99c6..8e8f871b74ca 100644
--- a/sound/usb/usbmixer.c
+++ b/sound/usb/usbmixer.c
@@ -32,6 +32,8 @@
 #include <linux/slab.h>
 #include <linux/string.h>
 #include <linux/usb.h>
+#include <linux/usb/audio.h>
+
 #include <sound/core.h>
 #include <sound/control.h>
 #include <sound/hwdep.h>
@@ -69,13 +71,16 @@ static const struct rc_config {
         { USB_ID(0x041e, 0x3048), 2, 2, 6, 6,  2,  0x6e91 }, /* Toshiba SB0500 */
 };
 
+#define MAX_ID_ELEMS    256
+
 struct usb_mixer_interface {
         struct snd_usb_audio *chip;
         unsigned int ctrlif;
         struct list_head list;
         unsigned int ignore_ctl_error;
         struct urb *urb;
-        struct usb_mixer_elem_info **id_elems; /* array[256], indexed by unit id */
+        /* array[MAX_ID_ELEMS], indexed by unit id */
+        struct usb_mixer_elem_info **id_elems;
 
         /* Sound Blaster remote control stuff */
         const struct rc_config *rc_cfg;
@@ -105,7 +110,7 @@ struct mixer_build {
         struct usb_mixer_interface *mixer;
         unsigned char *buffer;
         unsigned int buflen;
-        DECLARE_BITMAP(unitbitmap, 256);
+        DECLARE_BITMAP(unitbitmap, MAX_ID_ELEMS);
         struct usb_audio_term oterm;
         const struct usbmix_name_map *map;
         const struct usbmix_selector_map *selector_map;
@@ -123,6 +128,7 @@ struct usb_mixer_elem_info {
         int channels;
         int val_type;
         int min, max, res;
+        int dBmin, dBmax;
         int cached;
         int cache_val[MAX_CHANNELS];
         u8 initialized;
@@ -186,6 +192,21 @@ enum {
         USB_PROC_DCR_RELEASE = 6,
 };
 
+/*E-mu 0202(0404) eXtension Unit(XU) control*/
+enum {
+        USB_XU_CLOCK_RATE               = 0xe301,
+        USB_XU_CLOCK_SOURCE             = 0xe302,
+        USB_XU_DIGITAL_IO_STATUS        = 0xe303,
+        USB_XU_DEVICE_OPTIONS           = 0xe304,
+        USB_XU_DIRECT_MONITORING        = 0xe305,
+        USB_XU_METERING                 = 0xe306
+};
+enum {
+        USB_XU_CLOCK_SOURCE_SELECTOR = 0x02,    /* clock source*/
+        USB_XU_CLOCK_RATE_SELECTOR = 0x03,      /* clock rate */
+        USB_XU_DIGITAL_FORMAT_SELECTOR = 0x01,  /* the spdif format */
+        USB_XU_SOFT_LIMIT_SELECTOR = 0x03       /* soft limiter */
+};
 
 /*
  * manual mapping of mixer names
@@ -194,42 +215,50 @@ enum {
  */
 #include "usbmixer_maps.c"
 
-/* get the mapped name if the unit matches */
-static int check_mapped_name(struct mixer_build *state, int unitid, int control, char *buf, int buflen)
+static const struct usbmix_name_map *
+find_map(struct mixer_build *state, int unitid, int control)
 {
-        const struct usbmix_name_map *p;
+        const struct usbmix_name_map *p = state->map;
 
-        if (! state->map)
-                return 0;
+        if (!p)
+                return NULL;
 
         for (p = state->map; p->id; p++) {
-                if (p->id == unitid && p->name &&
-                    (! control || ! p->control || control == p->control)) {
-                        buflen--;
-                        return strlcpy(buf, p->name, buflen);
-                }
+                if (p->id == unitid &&
+                    (!control || !p->control || control == p->control))
+                        return p;
         }
-        return 0;
+        return NULL;
 }
 
-/* check whether the control should be ignored */
-static int check_ignored_ctl(struct mixer_build *state, int unitid, int control)
+/* get the mapped name if the unit matches */
+static int
+check_mapped_name(const struct usbmix_name_map *p, char *buf, int buflen)
 {
-        const struct usbmix_name_map *p;
+        if (!p || !p->name)
+                return 0;
+
+        buflen--;
+        return strlcpy(buf, p->name, buflen);
+}
 
-        if (! state->map)
+/* check whether the control should be ignored */
+static inline int
+check_ignored_ctl(const struct usbmix_name_map *p)
+{
+        if (!p || p->name || p->dB)
                 return 0;
-        for (p = state->map; p->id; p++) {
-                if (p->id == unitid && ! p->name &&
-                    (! control || ! p->control || control == p->control)) {
-                        /*
-                        printk(KERN_DEBUG "ignored control %d:%d\n",
-                               unitid, control);
-                        */
-                        return 1;
-                }
+        return 1;
+}
+
+/* dB mapping */
+static inline void check_mapped_dB(const struct usbmix_name_map *p,
+                                   struct usb_mixer_elem_info *cval)
+{
+        if (p && p->dB) {
+                cval->dBmin = p->dB->min;
+                cval->dBmax = p->dB->max;
         }
-        return 0;
 }
 
 /* get the mapped selector source name */
@@ -257,7 +286,7 @@ static void *find_audio_control_unit(struct mixer_build *state, unsigned char un
         p = NULL;
         while ((p = snd_usb_find_desc(state->buffer, state->buflen, p,
                                       USB_DT_CS_INTERFACE)) != NULL) {
-                if (p[0] >= 4 && p[2] >= INPUT_TERMINAL && p[2] <= EXTENSION_UNIT && p[3] == unit)
+                if (p[0] >= 4 && p[2] >= UAC_INPUT_TERMINAL && p[2] <= UAC_EXTENSION_UNIT_V1 && p[3] == unit)
                         return p;
         }
         return NULL;
@@ -378,14 +407,14 @@ static int get_ctl_value(struct usb_mixer_elem_info *cval, int request, int vali
 
 static int get_cur_ctl_value(struct usb_mixer_elem_info *cval, int validx, int *value)
 {
-        return get_ctl_value(cval, GET_CUR, validx, value);
+        return get_ctl_value(cval, UAC_GET_CUR, validx, value);
 }
 
 /* channel = 0: master, 1 = first channel */
 static inline int get_cur_mix_raw(struct usb_mixer_elem_info *cval,
                                   int channel, int *value)
 {
-        return get_ctl_value(cval, GET_CUR, (cval->control << 8) | channel, value);
+        return get_ctl_value(cval, UAC_GET_CUR, (cval->control << 8) | channel, value);
 }
 
 static int get_cur_mix_value(struct usb_mixer_elem_info *cval,
@@ -439,14 +468,14 @@ static int set_ctl_value(struct usb_mixer_elem_info *cval, int request, int vali
 
 static int set_cur_ctl_value(struct usb_mixer_elem_info *cval, int validx, int value)
 {
-        return set_ctl_value(cval, SET_CUR, validx, value);
+        return set_ctl_value(cval, UAC_SET_CUR, validx, value);
 }
 
 static int set_cur_mix_value(struct usb_mixer_elem_info *cval, int channel,
                              int index, int value)
 {
         int err;
-        err = set_ctl_value(cval, SET_CUR, (cval->control << 8) | channel,
+        err = set_ctl_value(cval, UAC_SET_CUR, (cval->control << 8) | channel,
                             value);
         if (err < 0)
                 return err;
@@ -466,20 +495,8 @@ static int mixer_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
 
         if (size < sizeof(scale))
                 return -ENOMEM;
-        /* USB descriptions contain the dB scale in 1/256 dB unit
-         * 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->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;
-        }
+        scale[2] = cval->dBmin;
+        scale[3] = cval->dBmax;
         if (copy_to_user(_tlv, scale, sizeof(scale)))
                 return -EFAULT;
         return 0;
@@ -588,13 +605,13 @@ static int get_term_name(struct mixer_build *state, struct usb_audio_term *iterm
                 if (term_only)
                         return 0;
                 switch (iterm->type >> 16) {
-                case SELECTOR_UNIT:
+                case UAC_SELECTOR_UNIT:
                         strcpy(name, "Selector"); return 8;
-                case PROCESSING_UNIT:
+                case UAC_PROCESSING_UNIT_V1:
                         strcpy(name, "Process Unit"); return 12;
-                case EXTENSION_UNIT:
+                case UAC_EXTENSION_UNIT_V1:
                         strcpy(name, "Ext Unit"); return 8;
-                case MIXER_UNIT:
+                case UAC_MIXER_UNIT:
                         strcpy(name, "Mixer"); return 5;
                 default:
                         return sprintf(name, "Unit %d", iterm->id);
@@ -633,22 +650,22 @@ static int check_input_term(struct mixer_build *state, int id, struct usb_audio_
         while ((p1 = find_audio_control_unit(state, id)) != NULL) {
                 term->id = id;
                 switch (p1[2]) {
-                case INPUT_TERMINAL:
+                case UAC_INPUT_TERMINAL:
                         term->type = combine_word(p1 + 4);
                         term->channels = p1[7];
                         term->chconfig = combine_word(p1 + 8);
                         term->name = p1[11];
                         return 0;
-                case FEATURE_UNIT:
+                case UAC_FEATURE_UNIT:
                         id = p1[4];
                         break; /* continue to parse */
-                case MIXER_UNIT:
+                case UAC_MIXER_UNIT:
                         term->type = p1[2] << 16; /* virtual type */
                         term->channels = p1[5 + p1[4]];
                         term->chconfig = combine_word(p1 + 6 + p1[4]);
                         term->name = p1[p1[0] - 1];
                         return 0;
-                case SELECTOR_UNIT:
+                case UAC_SELECTOR_UNIT:
                         /* call recursively to retrieve the channel info */
                         if (check_input_term(state, p1[5], term) < 0)
                                 return -ENODEV;
@@ -656,8 +673,8 @@ static int check_input_term(struct mixer_build *state, int id, struct usb_audio_
                         term->id = id;
                         term->name = p1[9 + p1[0] - 1];
                         return 0;
-                case PROCESSING_UNIT:
-                case EXTENSION_UNIT:
+                case UAC_PROCESSING_UNIT_V1:
+                case UAC_EXTENSION_UNIT_V1:
                         if (p1[6] == 1) {
                                 id = p1[7];
                                 break; /* continue to parse */
@@ -720,6 +737,7 @@ static int get_min_max(struct usb_mixer_elem_info *cval, int default_min)
         cval->min = default_min;
         cval->max = cval->min + 1;
         cval->res = 1;
+        cval->dBmin = cval->dBmax = 0;
 
         if (cval->val_type == USB_MIXER_BOOLEAN ||
             cval->val_type == USB_MIXER_INV_BOOLEAN) {
@@ -734,23 +752,23 @@ static int get_min_max(struct usb_mixer_elem_info *cval, int default_min)
                                         break;
                                 }
                 }
-                if (get_ctl_value(cval, GET_MAX, (cval->control << 8) | minchn, &cval->max) < 0 ||
-                    get_ctl_value(cval, GET_MIN, (cval->control << 8) | minchn, &cval->min) < 0) {
+                if (get_ctl_value(cval, UAC_GET_MAX, (cval->control << 8) | minchn, &cval->max) < 0 ||
+                    get_ctl_value(cval, UAC_GET_MIN, (cval->control << 8) | minchn, &cval->min) < 0) {
                         snd_printd(KERN_ERR "%d:%d: cannot get min/max values for control %d (id %d)\n",
                                    cval->id, cval->mixer->ctrlif, cval->control, cval->id);
                         return -EINVAL;
                 }
-                if (get_ctl_value(cval, GET_RES, (cval->control << 8) | minchn, &cval->res) < 0) {
+                if (get_ctl_value(cval, UAC_GET_RES, (cval->control << 8) | minchn, &cval->res) < 0) {
                         cval->res = 1;
                 } else {
                         int last_valid_res = cval->res;
 
                         while (cval->res > 1) {
-                                if (set_ctl_value(cval, SET_RES, (cval->control << 8) | minchn, cval->res / 2) < 0)
+                                if (set_ctl_value(cval, UAC_SET_RES, (cval->control << 8) | minchn, cval->res / 2) < 0)
                                         break;
                                 cval->res /= 2;
                         }
-                        if (get_ctl_value(cval, GET_RES, (cval->control << 8) | minchn, &cval->res) < 0)
+                        if (get_ctl_value(cval, UAC_GET_RES, (cval->control << 8) | minchn, &cval->res) < 0)
                                 cval->res = last_valid_res;
                 }
                 if (cval->res == 0)
@@ -787,6 +805,24 @@ static int get_min_max(struct usb_mixer_elem_info *cval, int default_min)
 
                 cval->initialized = 1;
         }
+
+        /* USB descriptions contain the dB scale in 1/256 dB unit
+         * while ALSA TLV contains in 1/100 dB unit
+         */
+        cval->dBmin = (convert_signed_value(cval, cval->min) * 100) / 256;
+        cval->dBmax = (convert_signed_value(cval, cval->max) * 100) / 256;
+        if (cval->dBmin > cval->dBmax) {
+                /* something is wrong; assume it's either from/to 0dB */
+                if (cval->dBmin < 0)
+                        cval->dBmax = 0;
+                else if (cval->dBmin > 0)
+                        cval->dBmin = 0;
+                if (cval->dBmin > cval->dBmax) {
+                        /* totally crap, return an error */
+                        return -EINVAL;
+                }
+        }
+
         return 0;
 }
 
@@ -912,6 +948,7 @@ static void build_feature_ctl(struct mixer_build *state, unsigned char *desc,
         int nameid = desc[desc[0] - 1];
         struct snd_kcontrol *kctl;
         struct usb_mixer_elem_info *cval;
+        const struct usbmix_name_map *map;
 
         control++; /* change from zero-based to 1-based value */
 
@@ -920,7 +957,8 @@ static void build_feature_ctl(struct mixer_build *state, unsigned char *desc,
                 return;
         }
 
-        if (check_ignored_ctl(state, unitid, control))
+        map = find_map(state, unitid, control);
+        if (check_ignored_ctl(map))
                 return;
 
         cval = kzalloc(sizeof(*cval), GFP_KERNEL);
@@ -954,10 +992,11 @@ static void build_feature_ctl(struct mixer_build *state, unsigned char *desc,
         }
         kctl->private_free = usb_mixer_elem_free;
 
-        len = check_mapped_name(state, unitid, control, kctl->id.name, sizeof(kctl->id.name));
+        len = check_mapped_name(map, kctl->id.name, sizeof(kctl->id.name));
         mapped_name = len != 0;
         if (! len && nameid)
-                len = snd_usb_copy_string_desc(state, nameid, kctl->id.name, sizeof(kctl->id.name));
+                len = snd_usb_copy_string_desc(state, nameid,
+                                kctl->id.name, sizeof(kctl->id.name));
 
         switch (control) {
         case USB_FEATURE_MUTE:
@@ -995,6 +1034,7 @@ static void build_feature_ctl(struct mixer_build *state, unsigned char *desc,
                         kctl->vd[0].access |= 
                                 SNDRV_CTL_ELEM_ACCESS_TLV_READ |
                                 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
+                        check_mapped_dB(map, cval);
                 }
                 break;
 
@@ -1048,29 +1088,30 @@ static void build_feature_ctl(struct mixer_build *state, unsigned char *desc,
  *
  * most of controlls are defined here.
  */
-static int parse_audio_feature_unit(struct mixer_build *state, int unitid, unsigned char *ftr)
+static int parse_audio_feature_unit(struct mixer_build *state, int unitid, void *_ftr)
 {
         int channels, i, j;
         struct usb_audio_term iterm;
         unsigned int master_bits, first_ch_bits;
         int err, csize;
+        struct uac_feature_unit_descriptor *ftr = _ftr;
 
-        if (ftr[0] < 7 || ! (csize = ftr[5]) || ftr[0] < 7 + csize) {
-                snd_printk(KERN_ERR "usbaudio: unit %u: invalid FEATURE_UNIT descriptor\n", unitid);
+        if (ftr->bLength < 7 || ! (csize = ftr->bControlSize) || ftr->bLength < 7 + csize) {
+                snd_printk(KERN_ERR "usbaudio: unit %u: invalid UAC_FEATURE_UNIT descriptor\n", unitid);
                 return -EINVAL;
         }
 
         /* parse the source unit */
-        if ((err = parse_audio_unit(state, ftr[4])) < 0)
+        if ((err = parse_audio_unit(state, ftr->bSourceID)) < 0)
                 return err;
 
         /* determine the input source type and name */
-        if (check_input_term(state, ftr[4], &iterm) < 0)
+        if (check_input_term(state, ftr->bSourceID, &iterm) < 0)
                 return -EINVAL;
 
-        channels = (ftr[0] - 7) / csize - 1;
+        channels = (ftr->bLength - 7) / csize - 1;
 
-        master_bits = snd_usb_combine_bytes(ftr + 6, csize);
+        master_bits = snd_usb_combine_bytes(ftr->controls, csize);
         /* master configuration quirks */
         switch (state->chip->usb_id) {
         case USB_ID(0x08bb, 0x2702):
@@ -1081,21 +1122,21 @@ static int parse_audio_feature_unit(struct mixer_build *state, int unitid, unsig
                 break;
         }
         if (channels > 0)
-                first_ch_bits = snd_usb_combine_bytes(ftr + 6 + csize, csize);
+                first_ch_bits = snd_usb_combine_bytes(ftr->controls + csize, csize);
         else
                 first_ch_bits = 0;
         /* check all control types */
         for (i = 0; i < 10; i++) {
                 unsigned int ch_bits = 0;
                 for (j = 0; j < channels; j++) {
-                        unsigned int mask = snd_usb_combine_bytes(ftr + 6 + csize * (j+1), csize);
+                        unsigned int mask = snd_usb_combine_bytes(ftr->controls + csize * (j+1), csize);
                         if (mask & (1 << i))
                                 ch_bits |= (1 << j);
                 }
                 if (ch_bits & 1) /* the first channel must be set (for ease of programming) */
-                        build_feature_ctl(state, ftr, ch_bits, i, &iterm, unitid);
+                        build_feature_ctl(state, _ftr, ch_bits, i, &iterm, unitid);
                 if (master_bits & (1 << i))
-                        build_feature_ctl(state, ftr, 0, i, &iterm, unitid);
+                        build_feature_ctl(state, _ftr, 0, i, &iterm, unitid);
         }
 
         return 0;
@@ -1122,8 +1163,10 @@ static void build_mixer_unit_ctl(struct mixer_build *state, unsigned char *desc,
         unsigned int num_outs = desc[5 + input_pins];
         unsigned int i, len;
         struct snd_kcontrol *kctl;
+        const struct usbmix_name_map *map;
 
-        if (check_ignored_ctl(state, unitid, 0))
+        map = find_map(state, unitid, 0);
+        if (check_ignored_ctl(map))
                 return;
 
         cval = kzalloc(sizeof(*cval), GFP_KERNEL);
@@ -1152,7 +1195,7 @@ static void build_mixer_unit_ctl(struct mixer_build *state, unsigned char *desc,
         }
         kctl->private_free = usb_mixer_elem_free;
 
-        len = check_mapped_name(state, unitid, 0, kctl->id.name, sizeof(kctl->id.name));
+        len = check_mapped_name(map, kctl->id.name, sizeof(kctl->id.name));
         if (! len)
                 len = get_term_name(state, iterm, kctl->id.name, sizeof(kctl->id.name), 0);
         if (! len)
@@ -1330,7 +1373,32 @@ static struct procunit_info procunits[] = {
         { USB_PROC_DCR, "DCR", dcr_proc_info },
         { 0 },
 };
-
+/*
+ * predefined data for extension units
+ */
+static struct procunit_value_info clock_rate_xu_info[] = {
+       { USB_XU_CLOCK_RATE_SELECTOR, "Selector", USB_MIXER_U8, 0 },
+       { 0 }
+};
+static struct procunit_value_info clock_source_xu_info[] = {
+        { USB_XU_CLOCK_SOURCE_SELECTOR, "External", USB_MIXER_BOOLEAN },
+        { 0 }
+};
+static struct procunit_value_info spdif_format_xu_info[] = {
+        { USB_XU_DIGITAL_FORMAT_SELECTOR, "SPDIF/AC3", USB_MIXER_BOOLEAN },
+        { 0 }
+};
+static struct procunit_value_info soft_limit_xu_info[] = {
+        { USB_XU_SOFT_LIMIT_SELECTOR, " ", USB_MIXER_BOOLEAN },
+        { 0 }
+};
+static struct procunit_info extunits[] = {
+        { USB_XU_CLOCK_RATE, "Clock rate", clock_rate_xu_info },
+        { USB_XU_CLOCK_SOURCE, "DigitalIn CLK source", clock_source_xu_info },
+        { USB_XU_DIGITAL_IO_STATUS, "DigitalOut format:", spdif_format_xu_info },
+        { USB_XU_DEVICE_OPTIONS, "AnalogueIn Soft Limit", soft_limit_xu_info },
+        { 0 }
+};
 /*
  * build a processing/extension unit
  */
@@ -1342,6 +1410,7 @@ static int build_audio_procunit(struct mixer_build *state, int unitid, unsigned
         int i, err, nameid, type, len;
         struct procunit_info *info;
         struct procunit_value_info *valinfo;
+        const struct usbmix_name_map *map;
         static struct procunit_value_info default_value_info[] = {
                 { 0x01, "Switch", USB_MIXER_BOOLEAN },
                 { 0 }
@@ -1371,7 +1440,8 @@ static int build_audio_procunit(struct mixer_build *state, int unitid, unsigned
                 /* FIXME: bitmap might be longer than 8bit */
                 if (! (dsc[12 + num_ins] & (1 << (valinfo->control - 1))))
                         continue;
-                if (check_ignored_ctl(state, unitid, valinfo->control))
+                map = find_map(state, unitid, valinfo->control);
+                if (check_ignored_ctl(map))
                         continue;
                 cval = kzalloc(sizeof(*cval), GFP_KERNEL);
                 if (! cval) {
@@ -1391,8 +1461,18 @@ static int build_audio_procunit(struct mixer_build *state, int unitid, unsigned
                         cval->max = dsc[15];
                         cval->res = 1;
                         cval->initialized = 1;
-                } else
-                        get_min_max(cval, valinfo->min_value);
+                } else {
+                        if (type == USB_XU_CLOCK_RATE) {
+                                /* E-Mu USB 0404/0202/TrackerPre
+                                 * samplerate control quirk
+                                 */
+                                cval->min = 0;
+                                cval->max = 5;
+                                cval->res = 1;
+                                cval->initialized = 1;
+                        } else
+                                get_min_max(cval, valinfo->min_value);
+                }
 
                 kctl = snd_ctl_new1(&mixer_procunit_ctl, cval);
                 if (! kctl) {
@@ -1402,8 +1482,9 @@ static int build_audio_procunit(struct mixer_build *state, int unitid, unsigned
                 }
                 kctl->private_free = usb_mixer_elem_free;
 
-                if (check_mapped_name(state, unitid, cval->control, kctl->id.name, sizeof(kctl->id.name)))
-                        ;
+                if (check_mapped_name(map, kctl->id.name,
+                                                sizeof(kctl->id.name)))
+                        /* nothing */ ;
                 else if (info->name)
                         strlcpy(kctl->id.name, info->name, sizeof(kctl->id.name));
                 else {
@@ -1433,7 +1514,7 @@ static int parse_audio_processing_unit(struct mixer_build *state, int unitid, un
 
 static int parse_audio_extension_unit(struct mixer_build *state, int unitid, unsigned char *desc)
 {
-        return build_audio_procunit(state, unitid, desc, NULL, "Extension Unit");
+        return build_audio_procunit(state, unitid, desc, extunits, "Extension Unit");
 }
 
 
@@ -1542,6 +1623,7 @@ static int parse_audio_selector_unit(struct mixer_build *state, int unitid, unsi
         int err;
         struct usb_mixer_elem_info *cval;
         struct snd_kcontrol *kctl;
+        const struct usbmix_name_map *map;
         char **namelist;
 
         if (! num_ins || desc[0] < 5 + num_ins) {
@@ -1557,7 +1639,8 @@ static int parse_audio_selector_unit(struct mixer_build *state, int unitid, unsi
         if (num_ins == 1) /* only one ? nonsense! */
                 return 0;
 
-        if (check_ignored_ctl(state, unitid, 0))
+        map = find_map(state, unitid, 0);
+        if (check_ignored_ctl(map))
                 return 0;
 
         cval = kzalloc(sizeof(*cval), GFP_KERNEL);
@@ -1612,7 +1695,7 @@ static int parse_audio_selector_unit(struct mixer_build *state, int unitid, unsi
         kctl->private_free = usb_mixer_selector_elem_free;
 
         nameid = desc[desc[0] - 1];
-        len = check_mapped_name(state, unitid, 0, kctl->id.name, sizeof(kctl->id.name));
+        len = check_mapped_name(map, kctl->id.name, sizeof(kctl->id.name));
         if (len)
                 ;
         else if (nameid)
@@ -1656,17 +1739,17 @@ static int parse_audio_unit(struct mixer_build *state, int unitid)
         }
 
         switch (p1[2]) {
-        case INPUT_TERMINAL:
+        case UAC_INPUT_TERMINAL:
                 return 0; /* NOP */
-        case MIXER_UNIT:
+        case UAC_MIXER_UNIT:
                 return parse_audio_mixer_unit(state, unitid, p1);
-        case SELECTOR_UNIT:
+        case UAC_SELECTOR_UNIT:
                 return parse_audio_selector_unit(state, unitid, p1);
-        case FEATURE_UNIT:
+        case UAC_FEATURE_UNIT:
                 return parse_audio_feature_unit(state, unitid, p1);
-        case PROCESSING_UNIT:
+        case UAC_PROCESSING_UNIT_V1:
                 return parse_audio_processing_unit(state, unitid, p1);
-        case EXTENSION_UNIT:
+        case UAC_EXTENSION_UNIT_V1:
                 return parse_audio_extension_unit(state, unitid, p1);
         default:
                 snd_printk(KERN_ERR "usbaudio: unit %u: unexpected type 0x%02x\n", unitid, p1[2]);
@@ -1696,11 +1779,11 @@ static int snd_usb_mixer_dev_free(struct snd_device *device)
 /*
  * create mixer controls
  *
- * walk through all OUTPUT_TERMINAL descriptors to search for mixers
+ * walk through all UAC_OUTPUT_TERMINAL descriptors to search for mixers
  */
 static int snd_usb_mixer_controls(struct usb_mixer_interface *mixer)
 {
-        unsigned char *desc;
+        struct uac_output_terminal_descriptor_v1 *desc;
         struct mixer_build state;
         int err;
         const struct usbmix_ctl_map *map;
@@ -1724,14 +1807,14 @@ static int snd_usb_mixer_controls(struct usb_mixer_interface *mixer)
         }
 
         desc = NULL;
-        while ((desc = snd_usb_find_csint_desc(hostif->extra, hostif->extralen, desc, OUTPUT_TERMINAL)) != NULL) {
-                if (desc[0] < 9)
+        while ((desc = snd_usb_find_csint_desc(hostif->extra, hostif->extralen, desc, UAC_OUTPUT_TERMINAL)) != NULL) {
+                if (desc->bLength < 9)
                         continue; /* invalid descriptor? */
-                set_bit(desc[3], state.unitbitmap);  /* mark terminal ID as visited */
-                state.oterm.id = desc[3];
-                state.oterm.type = combine_word(&desc[4]);
-                state.oterm.name = desc[8];
-                err = parse_audio_unit(&state, desc[7]);
+                set_bit(desc->bTerminalID, state.unitbitmap);  /* mark terminal ID as visited */
+                state.oterm.id = desc->bTerminalID;
+                state.oterm.type = le16_to_cpu(desc->wTerminalType);
+                state.oterm.name = desc->iTerminal;
+                err = parse_audio_unit(&state, desc->bSourceID);
                 if (err < 0)
                         return err;
         }
@@ -1748,6 +1831,46 @@ static void snd_usb_mixer_notify_id(struct usb_mixer_interface *mixer,
                                info->elem_id);
 }
 
+static void snd_usb_mixer_dump_cval(struct snd_info_buffer *buffer,
+                                    int unitid,
+                                    struct usb_mixer_elem_info *cval)
+{
+        static char *val_types[] = {"BOOLEAN", "INV_BOOLEAN",
+                                    "S8", "U8", "S16", "U16"};
+        snd_iprintf(buffer, "  Unit: %i\n", unitid);
+        if (cval->elem_id)
+                snd_iprintf(buffer, "    Control: name=\"%s\", index=%i\n",
+                                cval->elem_id->name, cval->elem_id->index);
+        snd_iprintf(buffer, "    Info: id=%i, control=%i, cmask=0x%x, "
+                            "channels=%i, type=\"%s\"\n", cval->id,
+                            cval->control, cval->cmask, cval->channels,
+                            val_types[cval->val_type]);
+        snd_iprintf(buffer, "    Volume: min=%i, max=%i, dBmin=%i, dBmax=%i\n",
+                            cval->min, cval->max, cval->dBmin, cval->dBmax);
+}
+
+static void snd_usb_mixer_proc_read(struct snd_info_entry *entry,
+                                    struct snd_info_buffer *buffer)
+{
+        struct snd_usb_audio *chip = entry->private_data;
+        struct usb_mixer_interface *mixer;
+        struct usb_mixer_elem_info *cval;
+        int unitid;
+
+        list_for_each_entry(mixer, &chip->mixer_list, list) {
+                snd_iprintf(buffer,
+                        "USB Mixer: usb_id=0x%08x, ctrlif=%i, ctlerr=%i\n",
+                                chip->usb_id, mixer->ctrlif,
+                                mixer->ignore_ctl_error);
+                snd_iprintf(buffer, "Card: %s\n", chip->card->longname);
+                for (unitid = 0; unitid < MAX_ID_ELEMS; unitid++) {
+                        for (cval = mixer->id_elems[unitid]; cval;
+                                                cval = cval->next_id_elem)
+                                snd_usb_mixer_dump_cval(buffer, unitid, cval);
+                }
+        }
+}
+
 static void snd_usb_mixer_memory_change(struct usb_mixer_interface *mixer,
                                         int unitid)
 {
@@ -1924,7 +2047,7 @@ static int snd_usb_soundblaster_remote_init(struct usb_mixer_interface *mixer)
         }
         mixer->rc_setup_packet->bRequestType =
                 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE;
-        mixer->rc_setup_packet->bRequest = GET_MEM;
+        mixer->rc_setup_packet->bRequest = UAC_GET_MEM;
         mixer->rc_setup_packet->wValue = cpu_to_le16(0);
         mixer->rc_setup_packet->wIndex = cpu_to_le16(0);
         mixer->rc_setup_packet->wLength = cpu_to_le16(len);
@@ -2047,7 +2170,7 @@ static void snd_audigy2nx_proc_read(struct snd_info_entry *entry,
                 snd_iprintf(buffer, "%s: ", jacks[i].name);
                 err = snd_usb_ctl_msg(mixer->chip->dev,
                                       usb_rcvctrlpipe(mixer->chip->dev, 0),
-                                      GET_MEM, USB_DIR_IN | USB_TYPE_CLASS |
+                                      UAC_GET_MEM, USB_DIR_IN | USB_TYPE_CLASS |
                                       USB_RECIP_INTERFACE, 0,
                                       jacks[i].unitid << 8, buf, 3, 100);
                 if (err == 3 && (buf[0] == 3 || buf[0] == 6))
@@ -2109,6 +2232,24 @@ static int snd_xonar_u1_controls_create(struct usb_mixer_interface *mixer)
         return 0;
 }
 
+void snd_emuusb_set_samplerate(struct snd_usb_audio *chip,
+                               unsigned char samplerate_id)
+{
+        struct usb_mixer_interface *mixer;
+        struct usb_mixer_elem_info *cval;
+        int unitid = 12; /* SamleRate ExtensionUnit ID */
+
+        list_for_each_entry(mixer, &chip->mixer_list, list) {
+                cval = mixer->id_elems[unitid];
+                if (cval) {
+                        set_cur_ctl_value(cval, cval->control << 8,
+                                          samplerate_id);
+                        snd_usb_mixer_notify_id(mixer, unitid);
+                }
+                break;
+        }
+}
+
 int snd_usb_create_mixer(struct snd_usb_audio *chip, int ctrlif,
                          int ignore_error)
 {
@@ -2116,7 +2257,9 @@ int snd_usb_create_mixer(struct snd_usb_audio *chip, int ctrlif,
                 .dev_free = snd_usb_mixer_dev_free
         };
         struct usb_mixer_interface *mixer;
-        int err;
+        struct snd_info_entry *entry;
+        struct usb_host_interface *host_iface;
+        int err, protocol;
 
         strcpy(chip->card->mixername, "USB Mixer");
 
@@ -2126,12 +2269,23 @@ int snd_usb_create_mixer(struct snd_usb_audio *chip, int ctrlif,
         mixer->chip = chip;
         mixer->ctrlif = ctrlif;
         mixer->ignore_ctl_error = ignore_error;
-        mixer->id_elems = kcalloc(256, sizeof(*mixer->id_elems), GFP_KERNEL);
+        mixer->id_elems = kcalloc(MAX_ID_ELEMS, sizeof(*mixer->id_elems),
+                                  GFP_KERNEL);
         if (!mixer->id_elems) {
                 kfree(mixer);
                 return -ENOMEM;
         }
 
+        host_iface = &usb_ifnum_to_if(chip->dev, ctrlif)->altsetting[0];
+        protocol = host_iface->desc.bInterfaceProtocol;
+
+        /* FIXME! */
+        if (protocol != UAC_VERSION_1) {
+                snd_printk(KERN_WARNING "mixer interface protocol 0x%02x not yet supported\n",
+                                        protocol);
+                return 0;
+        }
+
         if ((err = snd_usb_mixer_controls(mixer)) < 0 ||
             (err = snd_usb_mixer_status_create(mixer)) < 0)
                 goto _error;
@@ -2142,8 +2296,6 @@ int snd_usb_create_mixer(struct snd_usb_audio *chip, int ctrlif,
         if (mixer->chip->usb_id == USB_ID(0x041e, 0x3020) ||
             mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
             mixer->chip->usb_id == USB_ID(0x041e, 0x3048)) {
-                struct snd_info_entry *entry;
-
                 if ((err = snd_audigy2nx_controls_create(mixer)) < 0)
                         goto _error;
                 if (!snd_card_proc_new(chip->card, "audigy2nx", &entry))
@@ -2161,6 +2313,11 @@ int snd_usb_create_mixer(struct snd_usb_audio *chip, int ctrlif,
         err = snd_device_new(chip->card, SNDRV_DEV_LOWLEVEL, mixer, &dev_ops);
         if (err < 0)
                 goto _error;
+
+        if (list_empty(&chip->mixer_list) &&
+            !snd_card_proc_new(chip->card, "usbmixer", &entry))
+                snd_info_set_text_ops(entry, chip, snd_usb_mixer_proc_read);
+
         list_add(&mixer->list, &chip->mixer_list);
         return 0;
 
diff --git a/sound/usb/usbmixer_maps.c b/sound/usb/usbmixer_maps.c
index 3e5d66cf1f5a..79e903a60862 100644
--- a/sound/usb/usbmixer_maps.c
+++ b/sound/usb/usbmixer_maps.c
@@ -19,11 +19,16 @@
  *
  */
 
+struct usbmix_dB_map {
+        u32 min;
+        u32 max;
+};
 
 struct usbmix_name_map {
         int id;
         const char *name;
         int control;
+        struct usbmix_dB_map *dB;
 };
 
 struct usbmix_selector_map {
@@ -72,7 +77,7 @@ static struct usbmix_name_map extigy_map[] = {
         { 8, "Line Playback" }, /* FU */
         /* 9: IT mic */
         { 10, "Mic Playback" }, /* FU */
-        { 11, "Capture Input Source" }, /* SU */
+        { 11, "Capture Source" }, /* SU */
         { 12, "Capture" }, /* FU */
         /* 13: OT pcm capture */
         /* 14: MU (w/o controls) */
@@ -102,6 +107,9 @@ static struct usbmix_name_map extigy_map[] = {
  * e.g. no Master and fake PCM volume
  *                      Pavel Mihaylov <bin@bash.info>
  */
+static struct usbmix_dB_map mp3plus_dB_1 = {-4781, 0};  /* just guess */
+static struct usbmix_dB_map mp3plus_dB_2 = {-1781, 618}; /* just guess */
+
 static struct usbmix_name_map mp3plus_map[] = {
         /* 1: IT pcm */
         /* 2: IT mic */
@@ -110,16 +118,19 @@ static struct usbmix_name_map mp3plus_map[] = {
         /* 5: OT digital out */
         /* 6: OT speaker */
         /* 7: OT pcm capture */
-        { 8, "Capture Input Source" }, /* FU, default PCM Capture Source */
+        { 8, "Capture Source" }, /* FU, default PCM Capture Source */
                 /* (Mic, Input 1 = Line input, Input 2 = Optical input) */
         { 9, "Master Playback" }, /* FU, default Speaker 1 */
         /* { 10, "Mic Capture", 1 }, */ /* FU, Mic Capture */
-        /* { 10, "Mic Capture", 2 }, */ /* FU, Mic Capture */
+        { 10, /* "Mic Capture", */ NULL, 2, .dB = &mp3plus_dB_2 },
+                /* FU, Mic Capture */
         { 10, "Mic Boost", 7 }, /* FU, default Auto Gain Input */
-        { 11, "Line Capture" }, /* FU, default PCM Capture */
+        { 11, "Line Capture", .dB = &mp3plus_dB_2 },
+                /* FU, default PCM Capture */
         { 12, "Digital In Playback" }, /* FU, default PCM 1 */
-        /* { 13, "Mic Playback" }, */ /* FU, default Mic Playback */
-        { 14, "Line Playback" }, /* FU, default Speaker */
+        { 13, /* "Mic Playback", */ .dB = &mp3plus_dB_1 },
+                /* FU, default Mic Playback */
+        { 14, "Line Playback", .dB = &mp3plus_dB_1 }, /* FU, default Speaker */
         /* 15: MU */
         { 0 } /* terminator */
 };
@@ -277,6 +288,22 @@ static struct usbmix_name_map scratch_live_map[] = {
         { 0 } /* terminator */
 };
 
+/* "Gamesurround Muse Pocket LT" looks same like "Sound Blaster MP3+"
+ *  most importand difference is SU[8], it should be set to "Capture Source"
+ *  to make alsamixer and PA working properly.
+ *  FIXME: or mp3plus_map should use "Capture Source" too,
+ *  so this maps can be merget
+ */
+static struct usbmix_name_map hercules_usb51_map[] = {
+        { 8, "Capture Source" },        /* SU, default "PCM Capture Source" */
+        { 9, "Master Playback" },       /* FU, default "Speaker Playback" */
+        { 10, "Mic Boost", 7 },         /* FU, default "Auto Gain Input" */
+        { 11, "Line Capture" },         /* FU, default "PCM Capture" */
+        { 13, "Mic Bypass Playback" },  /* FU, default "Mic Playback" */
+        { 14, "Line Bypass Playback" }, /* FU, default "Line Playback" */
+        { 0 }                           /* terminator */
+};
+
 /*
  * Control map entries
  */
@@ -316,6 +343,13 @@ static struct usbmix_ctl_map usbmix_ctl_maps[] = {
                 .ignore_ctl_error = 1,
         },
         {
+                /* Hercules Gamesurround Muse Pocket LT
+                 * (USB 5.1 Channel Audio Adapter)
+                 */
+                .id = USB_ID(0x06f8, 0xc000),
+                .map = hercules_usb51_map,
+        },
+        {
                 .id = USB_ID(0x08bb, 0x2702),
                 .map = linex_map,
                 .ignore_ctl_error = 1,
diff --git a/sound/usb/usbquirks.h b/sound/usb/usbquirks.h
index f6f201eb24ce..2b426c1fd0e8 100644
--- a/sound/usb/usbquirks.h
+++ b/sound/usb/usbquirks.h
@@ -91,7 +91,7 @@
         .idVendor = 0x046d,
         .idProduct = 0x0850,
         .bInterfaceClass = USB_CLASS_AUDIO,
-        .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL
+        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 },
 {
         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
@@ -100,7 +100,7 @@
         .idVendor = 0x046d,
         .idProduct = 0x08ae,
         .bInterfaceClass = USB_CLASS_AUDIO,
-        .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL
+        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 },
 {
         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
@@ -109,7 +109,7 @@
         .idVendor = 0x046d,
         .idProduct = 0x08c6,
         .bInterfaceClass = USB_CLASS_AUDIO,
-        .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL
+        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 },
 {
         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
@@ -118,7 +118,7 @@
         .idVendor = 0x046d,
         .idProduct = 0x08f0,
         .bInterfaceClass = USB_CLASS_AUDIO,
-        .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL
+        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 },
 {
         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
@@ -127,7 +127,7 @@
         .idVendor = 0x046d,
         .idProduct = 0x08f5,
         .bInterfaceClass = USB_CLASS_AUDIO,
-        .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL
+        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 },
 {
         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
@@ -136,7 +136,7 @@
         .idVendor = 0x046d,
         .idProduct = 0x08f6,
         .bInterfaceClass = USB_CLASS_AUDIO,
-        .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL
+        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 },
 {
         USB_DEVICE(0x046d, 0x0990),
@@ -301,7 +301,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
                                         .iface = 1,
                                         .altsetting = 1,
                                         .altset_idx = 1,
-                                        .attributes = EP_CS_ATTR_FILL_MAX,
+                                        .attributes = UAC_EP_CS_ATTR_FILL_MAX,
                                         .endpoint = 0x81,
                                         .ep_attr = 0x05,
                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
@@ -1016,36 +1016,6 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         }
 },
 {
-        USB_DEVICE(0x0582, 0x0044),
-        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
-                .vendor_name = "Roland",
-                .product_name = "UA-1000",
-                .ifnum = QUIRK_ANY_INTERFACE,
-                .type = QUIRK_COMPOSITE,
-                .data = (const struct snd_usb_audio_quirk[]) {
-                        {
-                                .ifnum = 1,
-                                .type = QUIRK_AUDIO_EDIROL_UA1000
-                        },
-                        {
-                                .ifnum = 2,
-                                .type = QUIRK_AUDIO_EDIROL_UA1000
-                        },
-                        {
-                                .ifnum = 3,
-                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
-                                .data = & (const struct snd_usb_midi_endpoint_info) {
-                                        .out_cables = 0x0003,
-                                        .in_cables  = 0x0003
-                                }
-                        },
-                        {
-                                .ifnum = -1
-                        }
-                }
-        }
-},
-{
         /* has ID 0x0049 when not in "Advanced Driver" mode */
         USB_DEVICE(0x0582, 0x0047),
         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
@@ -1266,37 +1236,6 @@ YAMAHA_DEVICE(0x7010, "UB99"),
                 }
         }
 },
-/* Roland UA-101 in High-Speed Mode only */
-{
-        USB_DEVICE(0x0582, 0x007d),
-        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
-                .vendor_name = "Roland",
-                .product_name = "UA-101",
-                .ifnum = QUIRK_ANY_INTERFACE,
-                .type = QUIRK_COMPOSITE,
-                .data = (const struct snd_usb_audio_quirk[]) {
-                        {
-                                .ifnum = 0,
-                                .type = QUIRK_AUDIO_EDIROL_UA101
-                        },
-                        {
-                                .ifnum = 1,
-                                .type = QUIRK_AUDIO_EDIROL_UA101
-                        },
-                        {
-                                .ifnum = 2,
-                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
-                                .data = & (const struct snd_usb_midi_endpoint_info) {
-                                        .out_cables = 0x0001,
-                                        .in_cables  = 0x0001
-                                }
-                        },
-                        {
-                                .ifnum = -1
-                        }
-                }
-        }
-},
 {
         /* has ID 0x0081 when not in "Advanced Driver" mode */
         USB_DEVICE(0x0582, 0x0080),
@@ -1563,6 +1502,29 @@ YAMAHA_DEVICE(0x7010, "UB99"),
                 }
         }
 },
+{
+        /* has ID 0x00ea when not in Advanced Driver mode */
+        USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e9),
+        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
+                /* .vendor_name = "Roland", */
+                /* .product_name = "UA-1G", */
+                .ifnum = QUIRK_ANY_INTERFACE,
+                .type = QUIRK_COMPOSITE,
+                .data = (const struct snd_usb_audio_quirk[]) {
+                        {
+                                .ifnum = 0,
+                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
+                        },
+                        {
+                                .ifnum = 1,
+                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
+                        },
+                        {
+                                .ifnum = -1
+                        }
+                }
+        }
+},
 
 /* Guillemot devices */
 {
@@ -2050,6 +2012,33 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         }
 },
 
+/* Access Music devices */
+{
+        /* VirusTI Desktop */
+        USB_DEVICE_VENDOR_SPEC(0x133e, 0x0815),
+        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
+                .ifnum = QUIRK_ANY_INTERFACE,
+                .type = QUIRK_COMPOSITE,
+                .data = &(const struct snd_usb_audio_quirk[]) {
+                        {
+                                .ifnum = 3,
+                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
+                                .data = &(const struct snd_usb_midi_endpoint_info) {
+                                        .out_cables = 0x0003,
+                                        .in_cables  = 0x0003
+                                }
+                        },
+                        {
+                                .ifnum = 4,
+                                .type = QUIRK_IGNORE_INTERFACE
+                        },
+                        {
+                                .ifnum = -1
+                        }
+                }
+        }
+},
+
 /* */
 {
         /* aka. Serato Scratch Live DJ Box */
@@ -2082,6 +2071,165 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         }
 },
 
+/* Hauppauge HVR-950Q and HVR-850 */
+{
+        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7200),
+        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
+                       USB_DEVICE_ID_MATCH_INT_CLASS |
+                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
+        .bInterfaceClass = USB_CLASS_AUDIO,
+        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
+        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
+                .vendor_name = "Hauppauge",
+                .product_name = "HVR-950Q",
+                .ifnum = QUIRK_ANY_INTERFACE,
+                .type = QUIRK_AUDIO_ALIGN_TRANSFER,
+        }
+},
+{
+        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7201),
+        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
+                       USB_DEVICE_ID_MATCH_INT_CLASS |
+                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
+        .bInterfaceClass = USB_CLASS_AUDIO,
+        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
+        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
+                .vendor_name = "Hauppauge",
+                .product_name = "HVR-950Q",
+                .ifnum = QUIRK_ANY_INTERFACE,
+                .type = QUIRK_AUDIO_ALIGN_TRANSFER,
+        }
+},
+{
+        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7202),
+        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
+                       USB_DEVICE_ID_MATCH_INT_CLASS |
+                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
+        .bInterfaceClass = USB_CLASS_AUDIO,
+        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
+        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
+                .vendor_name = "Hauppauge",
+                .product_name = "HVR-950Q",
+                .ifnum = QUIRK_ANY_INTERFACE,
+                .type = QUIRK_AUDIO_ALIGN_TRANSFER,
+        }
+},
+{
+        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7203),
+        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
+                       USB_DEVICE_ID_MATCH_INT_CLASS |
+                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
+        .bInterfaceClass = USB_CLASS_AUDIO,
+        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
+        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
+                .vendor_name = "Hauppauge",
+                .product_name = "HVR-950Q",
+                .ifnum = QUIRK_ANY_INTERFACE,
+                .type = QUIRK_AUDIO_ALIGN_TRANSFER,
+        }
+},
+{
+        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7204),
+        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
+                       USB_DEVICE_ID_MATCH_INT_CLASS |
+                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
+        .bInterfaceClass = USB_CLASS_AUDIO,
+        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
+        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
+                .vendor_name = "Hauppauge",
+                .product_name = "HVR-950Q",
+                .ifnum = QUIRK_ANY_INTERFACE,
+                .type = QUIRK_AUDIO_ALIGN_TRANSFER,
+        }
+},
+{
+        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7205),
+        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
+                       USB_DEVICE_ID_MATCH_INT_CLASS |
+                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
+        .bInterfaceClass = USB_CLASS_AUDIO,
+        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
+        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
+                .vendor_name = "Hauppauge",
+                .product_name = "HVR-950Q",
+                .ifnum = QUIRK_ANY_INTERFACE,
+                .type = QUIRK_AUDIO_ALIGN_TRANSFER,
+        }
+},
+{
+        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7250),
+        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
+                       USB_DEVICE_ID_MATCH_INT_CLASS |
+                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
+        .bInterfaceClass = USB_CLASS_AUDIO,
+        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
+        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
+                .vendor_name = "Hauppauge",
+                .product_name = "HVR-950Q",
+                .ifnum = QUIRK_ANY_INTERFACE,
+                .type = QUIRK_AUDIO_ALIGN_TRANSFER,
+        }
+},
+{
+        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7230),
+        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
+                       USB_DEVICE_ID_MATCH_INT_CLASS |
+                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
+        .bInterfaceClass = USB_CLASS_AUDIO,
+        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
+        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
+                .vendor_name = "Hauppauge",
+                .product_name = "HVR-850",
+                .ifnum = QUIRK_ANY_INTERFACE,
+                .type = QUIRK_AUDIO_ALIGN_TRANSFER,
+        }
+},
+
+/* Digidesign Mbox */
+{
+        /* Thanks to Clemens Ladisch <clemens@ladisch.de> */
+        USB_DEVICE(0x0dba, 0x1000),
+        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
+                .vendor_name = "Digidesign",
+                .product_name = "MBox",
+                .ifnum = QUIRK_ANY_INTERFACE,
+                .type = QUIRK_COMPOSITE,
+                .data = (const struct snd_usb_audio_quirk[]){
+                        {
+                                .ifnum = 0,
+                                .type = QUIRK_IGNORE_INTERFACE,
+                        },
+                        {
+                                .ifnum = 1,
+                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
+                                .data = &(const struct audioformat) {
+                                        .format = SNDRV_PCM_FORMAT_S24_3BE,
+                                        .channels = 2,
+                                        .iface = 1,
+                                        .altsetting = 1,
+                                        .altset_idx = 1,
+                                        .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
+                                        .endpoint = 0x02,
+                                        .ep_attr = 0x01,
+                                        .maxpacksize = 0x130,
+                                        .rates = SNDRV_PCM_RATE_44100 |
+                                                 SNDRV_PCM_RATE_48000,
+                                        .rate_min = 44100,
+                                        .rate_max = 48000,
+                                        .nr_rates = 2,
+                                        .rate_table = (unsigned int[]) {
+                                                44100, 48000
+                                        }
+                                }
+                        },
+                        {
+                                .ifnum = -1
+                        }
+                }
+
+        }
+},
+
 {
         /*
          * Some USB MIDI devices don't have an audio control interface,
@@ -2090,7 +2238,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
         .bInterfaceClass = USB_CLASS_AUDIO,
-        .bInterfaceSubClass = USB_SUBCLASS_MIDI_STREAMING,
+        .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING,
         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
                 .ifnum = QUIRK_ANY_INTERFACE,
                 .type = QUIRK_MIDI_STANDARD_INTERFACE
diff --git a/sound/usb/usx2y/us122l.c b/sound/usb/usx2y/us122l.c
index 99f33766cd51..9ca9a13a78da 100644
--- a/sound/usb/usx2y/us122l.c
+++ b/sound/usb/usx2y/us122l.c
@@ -16,6 +16,9 @@
  * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include <linux/slab.h>
+#include <linux/usb.h>
+#include <linux/usb/audio.h>
 #include <sound/core.h>
 #include <sound/hwdep.h>
 #include <sound/pcm.h>
@@ -59,11 +62,33 @@ static int us122l_create_usbmidi(struct snd_card *card)
                 .type = QUIRK_MIDI_US122L,
                 .data = &quirk_data
         };
-        struct usb_device *dev = US122L(card)->chip.dev;
+        struct usb_device *dev = US122L(card)->dev;
         struct usb_interface *iface = usb_ifnum_to_if(dev, 1);
 
-        return snd_usb_create_midi_interface(&US122L(card)->chip,
-                                             iface, &quirk);
+        return snd_usbmidi_create(card, iface,
+                                  &US122L(card)->midi_list, &quirk);
+}
+
+static int us144_create_usbmidi(struct snd_card *card)
+{
+        static struct snd_usb_midi_endpoint_info quirk_data = {
+                .out_ep = 4,
+                .in_ep = 3,
+                .out_cables =   0x001,
+                .in_cables =    0x001
+        };
+        static struct snd_usb_audio_quirk quirk = {
+                .vendor_name =  "US144",
+                .product_name = NAME_ALLCAPS,
+                .ifnum =        0,
+                .type = QUIRK_MIDI_US122L,
+                .data = &quirk_data
+        };
+        struct usb_device *dev = US122L(card)->dev;
+        struct usb_interface *iface = usb_ifnum_to_if(dev, 0);
+
+        return snd_usbmidi_create(card, iface,
+                                  &US122L(card)->midi_list, &quirk);
 }
 
 /*
@@ -171,7 +196,13 @@ static int usb_stream_hwdep_open(struct snd_hwdep *hw, struct file *file)
 
         if (!us122l->first)
                 us122l->first = file;
-        iface = usb_ifnum_to_if(us122l->chip.dev, 1);
+
+        if (us122l->dev->descriptor.idProduct == USB_ID_US144 ||
+            us122l->dev->descriptor.idProduct == USB_ID_US144MKII) {
+                iface = usb_ifnum_to_if(us122l->dev, 0);
+                usb_autopm_get_interface(iface);
+        }
+        iface = usb_ifnum_to_if(us122l->dev, 1);
         usb_autopm_get_interface(iface);
         return 0;
 }
@@ -179,8 +210,15 @@ static int usb_stream_hwdep_open(struct snd_hwdep *hw, struct file *file)
 static int usb_stream_hwdep_release(struct snd_hwdep *hw, struct file *file)
 {
         struct us122l   *us122l = hw->private_data;
-        struct usb_interface *iface = usb_ifnum_to_if(us122l->chip.dev, 1);
+        struct usb_interface *iface;
         snd_printdd(KERN_DEBUG "%p %p\n", hw, file);
+
+        if (us122l->dev->descriptor.idProduct == USB_ID_US144 ||
+            us122l->dev->descriptor.idProduct == USB_ID_US144MKII) {
+                iface = usb_ifnum_to_if(us122l->dev, 0);
+                usb_autopm_put_interface(iface);
+        }
+        iface = usb_ifnum_to_if(us122l->dev, 1);
         usb_autopm_put_interface(iface);
         if (us122l->first == file)
                 us122l->first = NULL;
@@ -264,7 +302,7 @@ static unsigned int usb_stream_hwdep_poll(struct snd_hwdep *hw,
 static void us122l_stop(struct us122l *us122l)
 {
         struct list_head *p;
-        list_for_each(p, &us122l->chip.midi_list)
+        list_for_each(p, &us122l->midi_list)
                 snd_usbmidi_input_stop(p);
 
         usb_stream_stop(&us122l->sk);
@@ -280,9 +318,9 @@ static int us122l_set_sample_rate(struct usb_device *dev, int rate)
         data[0] = rate;
         data[1] = rate >> 8;
         data[2] = rate >> 16;
-        err = us122l_ctl_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR,
+        err = us122l_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC_SET_CUR,
                              USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
-                             SAMPLING_FREQ_CONTROL << 8, ep, data, 3, 1000);
+                             UAC_EP_CS_ATTR_SAMPLE_RATE << 8, ep, data, 3, 1000);
         if (err < 0)
                 snd_printk(KERN_ERR "%d: cannot set freq %d to ep 0x%x\n",
                            dev->devnum, rate, ep);
@@ -297,7 +335,7 @@ static bool us122l_start(struct us122l *us122l,
         unsigned use_packsize = 0;
         bool success = false;
 
-        if (us122l->chip.dev->speed == USB_SPEED_HIGH) {
+        if (us122l->dev->speed == USB_SPEED_HIGH) {
                 /* The us-122l's descriptor defaults to iso max_packsize 78,
                    which isn't needed for samplerates <= 48000.
                    Lets save some memory:
@@ -314,11 +352,11 @@ static bool us122l_start(struct us122l *us122l,
                         break;
                 }
         }
-        if (!usb_stream_new(&us122l->sk, us122l->chip.dev, 1, 2,
+        if (!usb_stream_new(&us122l->sk, us122l->dev, 1, 2,
                             rate, use_packsize, period_frames, 6))
                 goto out;
 
-        err = us122l_set_sample_rate(us122l->chip.dev, rate);
+        err = us122l_set_sample_rate(us122l->dev, rate);
         if (err < 0) {
                 us122l_stop(us122l);
                 snd_printk(KERN_ERR "us122l_set_sample_rate error \n");
@@ -330,7 +368,7 @@ static bool us122l_start(struct us122l *us122l,
                 snd_printk(KERN_ERR "us122l_start error %i \n", err);
                 goto out;
         }
-        list_for_each(p, &us122l->chip.midi_list)
+        list_for_each(p, &us122l->midi_list)
                 snd_usbmidi_input_start(p);
         success = true;
 out:
@@ -357,7 +395,7 @@ static int usb_stream_hwdep_ioctl(struct snd_hwdep *hw, struct file *file,
                 err = -ENXIO;
                 goto free;
         }
-        high_speed = us122l->chip.dev->speed == USB_SPEED_HIGH;
+        high_speed = us122l->dev->speed == USB_SPEED_HIGH;
         if ((cfg->sample_rate != 44100 && cfg->sample_rate != 48000  &&
              (!high_speed ||
               (cfg->sample_rate != 88200 && cfg->sample_rate != 96000))) ||
@@ -417,7 +455,7 @@ static int usb_stream_hwdep_new(struct snd_card *card)
 {
         int err;
         struct snd_hwdep *hw;
-        struct usb_device *dev = US122L(card)->chip.dev;
+        struct usb_device *dev = US122L(card)->dev;
 
         err = snd_hwdep_new(card, SND_USB_STREAM_ID, 0, &hw);
         if (err < 0)
@@ -443,19 +481,31 @@ static bool us122l_create_card(struct snd_card *card)
         int err;
         struct us122l *us122l = US122L(card);
 
-        err = usb_set_interface(us122l->chip.dev, 1, 1);
+        if (us122l->dev->descriptor.idProduct == USB_ID_US144 ||
+            us122l->dev->descriptor.idProduct == USB_ID_US144MKII) {
+                err = usb_set_interface(us122l->dev, 0, 1);
+                if (err) {
+                        snd_printk(KERN_ERR "usb_set_interface error \n");
+                        return false;
+                }
+        }
+        err = usb_set_interface(us122l->dev, 1, 1);
         if (err) {
                 snd_printk(KERN_ERR "usb_set_interface error \n");
                 return false;
         }
 
-        pt_info_set(us122l->chip.dev, 0x11);
-        pt_info_set(us122l->chip.dev, 0x10);
+        pt_info_set(us122l->dev, 0x11);
+        pt_info_set(us122l->dev, 0x10);
 
         if (!us122l_start(us122l, 44100, 256))
                 return false;
 
-        err = us122l_create_usbmidi(card);
+        if (us122l->dev->descriptor.idProduct == USB_ID_US144 ||
+            us122l->dev->descriptor.idProduct == USB_ID_US144MKII)
+                err = us144_create_usbmidi(card);
+        else
+                err = us122l_create_usbmidi(card);
         if (err < 0) {
                 snd_printk(KERN_ERR "us122l_create_usbmidi error %i \n", err);
                 us122l_stop(us122l);
@@ -465,7 +515,7 @@ static bool us122l_create_card(struct snd_card *card)
         if (err < 0) {
 /* release the midi resources */
                 struct list_head *p;
-                list_for_each(p, &us122l->chip.midi_list)
+                list_for_each(p, &us122l->midi_list)
                         snd_usbmidi_disconnect(p);
 
                 us122l_stop(us122l);
@@ -477,7 +527,7 @@ static bool us122l_create_card(struct snd_card *card)
 static void snd_us122l_free(struct snd_card *card)
 {
         struct us122l   *us122l = US122L(card);
-        int             index = us122l->chip.index;
+        int             index = us122l->card_index;
         if (index >= 0  &&  index < SNDRV_CARDS)
                 snd_us122l_card_used[index] = 0;
 }
@@ -497,13 +547,12 @@ static int usx2y_create_card(struct usb_device *device, struct snd_card **cardp)
                               sizeof(struct us122l), &card);
         if (err < 0)
                 return err;
-        snd_us122l_card_used[US122L(card)->chip.index = dev] = 1;
+        snd_us122l_card_used[US122L(card)->card_index = dev] = 1;
         card->private_free = snd_us122l_free;
-        US122L(card)->chip.dev = device;
-        US122L(card)->chip.card = card;
+        US122L(card)->dev = device;
         mutex_init(&US122L(card)->mutex);
         init_waitqueue_head(&US122L(card)->sk.sleep);
-        INIT_LIST_HEAD(&US122L(card)->chip.midi_list);
+        INIT_LIST_HEAD(&US122L(card)->midi_list);
         strcpy(card->driver, "USB "NAME_ALLCAPS"");
         sprintf(card->shortname, "TASCAM "NAME_ALLCAPS"");
         sprintf(card->longname, "%s (%x:%x if %d at %03d/%03d)",
@@ -511,8 +560,8 @@ static int usx2y_create_card(struct usb_device *device, struct snd_card **cardp)
                 le16_to_cpu(device->descriptor.idVendor),
                 le16_to_cpu(device->descriptor.idProduct),
                 0,
-                US122L(card)->chip.dev->bus->busnum,
-                US122L(card)->chip.dev->devnum
+                US122L(card)->dev->bus->busnum,
+                US122L(card)->dev->devnum
                 );
         *cardp = card;
         return 0;
@@ -542,6 +591,7 @@ static int us122l_usb_probe(struct usb_interface *intf,
                 return err;
         }
 
+        usb_get_intf(usb_ifnum_to_if(device, 0));
         usb_get_dev(device);
         *cardp = card;
         return 0;
@@ -550,9 +600,17 @@ static int us122l_usb_probe(struct usb_interface *intf,
 static int snd_us122l_probe(struct usb_interface *intf,
                             const struct usb_device_id *id)
 {
+        struct usb_device *device = interface_to_usbdev(intf);
         struct snd_card *card;
         int err;
 
+        if ((device->descriptor.idProduct == USB_ID_US144 ||
+             device->descriptor.idProduct == USB_ID_US144MKII)
+                && device->speed == USB_SPEED_HIGH) {
+                snd_printk(KERN_ERR "disable ehci-hcd to run US-144 \n");
+                return -ENODEV;
+        }
+
         snd_printdd(KERN_DEBUG"%p:%i\n",
                     intf, intf->cur_altsetting->desc.bInterfaceNumber);
         if (intf->cur_altsetting->desc.bInterfaceNumber != 1)
@@ -584,15 +642,15 @@ static void snd_us122l_disconnect(struct usb_interface *intf)
         mutex_lock(&us122l->mutex);
         us122l_stop(us122l);
         mutex_unlock(&us122l->mutex);
-        us122l->chip.shutdown = 1;
 
 /* release the midi resources */
-        list_for_each(p, &us122l->chip.midi_list) {
+        list_for_each(p, &us122l->midi_list) {
                 snd_usbmidi_disconnect(p);
         }
 
-        usb_put_intf(intf);
-        usb_put_dev(us122l->chip.dev);
+        usb_put_intf(usb_ifnum_to_if(us122l->dev, 0));
+        usb_put_intf(usb_ifnum_to_if(us122l->dev, 1));
+        usb_put_dev(us122l->dev);
 
         while (atomic_read(&us122l->mmap_count))
                 msleep(500);
@@ -615,7 +673,7 @@ static int snd_us122l_suspend(struct usb_interface *intf, pm_message_t message)
         if (!us122l)
                 return 0;
 
-        list_for_each(p, &us122l->chip.midi_list)
+        list_for_each(p, &us122l->midi_list)
                 snd_usbmidi_input_stop(p);
 
         mutex_lock(&us122l->mutex);
@@ -642,16 +700,24 @@ static int snd_us122l_resume(struct usb_interface *intf)
 
         mutex_lock(&us122l->mutex);
         /* needed, doesn't restart without: */
-        err = usb_set_interface(us122l->chip.dev, 1, 1);
+        if (us122l->dev->descriptor.idProduct == USB_ID_US144 ||
+            us122l->dev->descriptor.idProduct == USB_ID_US144MKII) {
+                err = usb_set_interface(us122l->dev, 0, 1);
+                if (err) {
+                        snd_printk(KERN_ERR "usb_set_interface error \n");
+                        goto unlock;
+                }
+        }
+        err = usb_set_interface(us122l->dev, 1, 1);
         if (err) {
                 snd_printk(KERN_ERR "usb_set_interface error \n");
                 goto unlock;
         }
 
-        pt_info_set(us122l->chip.dev, 0x11);
-        pt_info_set(us122l->chip.dev, 0x10);
+        pt_info_set(us122l->dev, 0x11);
+        pt_info_set(us122l->dev, 0x10);
 
-        err = us122l_set_sample_rate(us122l->chip.dev,
+        err = us122l_set_sample_rate(us122l->dev,
                                      us122l->sk.s->cfg.sample_rate);
         if (err < 0) {
                 snd_printk(KERN_ERR "us122l_set_sample_rate error \n");
@@ -661,7 +727,7 @@ static int snd_us122l_resume(struct usb_interface *intf)
         if (err)
                 goto unlock;
 
-        list_for_each(p, &us122l->chip.midi_list)
+        list_for_each(p, &us122l->midi_list)
                 snd_usbmidi_input_start(p);
 unlock:
         mutex_unlock(&us122l->mutex);
@@ -675,11 +741,21 @@ static struct usb_device_id snd_us122l_usb_id_table[] = {
                 .idVendor =     0x0644,
                 .idProduct =    USB_ID_US122L
         },
-/*      { */            /* US-144 maybe works when @USB1.1. Untested. */
-/*              .match_flags =  USB_DEVICE_ID_MATCH_DEVICE, */
-/*              .idVendor =     0x0644, */
-/*              .idProduct =    USB_ID_US144 */
-/*      }, */
+        {       /* US-144 only works at USB1.1! Disable module ehci-hcd. */
+                .match_flags =  USB_DEVICE_ID_MATCH_DEVICE,
+                .idVendor =     0x0644,
+                .idProduct =    USB_ID_US144
+        },
+        {
+                .match_flags =  USB_DEVICE_ID_MATCH_DEVICE,
+                .idVendor =     0x0644,
+                .idProduct =    USB_ID_US122MKII
+        },
+        {
+                .match_flags =  USB_DEVICE_ID_MATCH_DEVICE,
+                .idVendor =     0x0644,
+                .idProduct =    USB_ID_US144MKII
+        },
         { /* terminator */ }
 };
 
diff --git a/sound/usb/usx2y/us122l.h b/sound/usb/usx2y/us122l.h
index 3d10c4b2a0f5..f263b3f96c86 100644
--- a/sound/usb/usx2y/us122l.h
+++ b/sound/usb/usx2y/us122l.h
@@ -3,7 +3,8 @@
 
 
 struct us122l {
-        struct snd_usb_audio    chip;
+        struct usb_device       *dev;
+        int                     card_index;
         int                     stride;
         struct usb_stream_kernel sk;
 
@@ -12,6 +13,7 @@ struct us122l {
         unsigned                second_periods_polled;
         struct file             *master;
         struct file             *slave;
+        struct list_head        midi_list;
 
         atomic_t                mmap_count;
 };
@@ -23,5 +25,7 @@ struct us122l {
 
 #define USB_ID_US122L 0x800E
 #define USB_ID_US144 0x800F
+#define USB_ID_US122MKII 0x8021
+#define USB_ID_US144MKII 0x8020
 
 #endif
diff --git a/sound/usb/usx2y/usX2Yhwdep.c b/sound/usb/usx2y/usX2Yhwdep.c
index 52e04b2f35d3..04aafb43a13c 100644
--- a/sound/usb/usx2y/usX2Yhwdep.c
+++ b/sound/usb/usx2y/usX2Yhwdep.c
@@ -21,6 +21,7 @@
  */
 
 #include <linux/interrupt.h>
+#include <linux/slab.h>
 #include <linux/usb.h>
 #include <sound/core.h>
 #include <sound/memalloc.h>
@@ -114,7 +115,7 @@ static int snd_usX2Y_hwdep_dsp_status(struct snd_hwdep *hw,
         struct usX2Ydev *us428 = hw->private_data;
         int id = -1;
 
-        switch (le16_to_cpu(us428->chip.dev->descriptor.idProduct)) {
+        switch (le16_to_cpu(us428->dev->descriptor.idProduct)) {
         case USB_ID_US122:
                 id = USX2Y_TYPE_122;
                 break;
@@ -164,14 +165,14 @@ static int usX2Y_create_usbmidi(struct snd_card *card)
                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
                 .data = &quirk_data_2
         };
-        struct usb_device *dev = usX2Y(card)->chip.dev;
+        struct usb_device *dev = usX2Y(card)->dev;
         struct usb_interface *iface = usb_ifnum_to_if(dev, 0);
         struct snd_usb_audio_quirk *quirk =
                 le16_to_cpu(dev->descriptor.idProduct) == USB_ID_US428 ?
                 &quirk_2 : &quirk_1;
 
         snd_printdd("usX2Y_create_usbmidi \n");
-        return snd_usb_create_midi_interface(&usX2Y(card)->chip, iface, quirk);
+        return snd_usbmidi_create(card, iface, &usX2Y(card)->midi_list, quirk);
 }
 
 static int usX2Y_create_alsa_devices(struct snd_card *card)
@@ -202,7 +203,7 @@ static int snd_usX2Y_hwdep_dsp_load(struct snd_hwdep *hw,
         snd_printdd( "dsp_load %s\n", dsp->name);
 
         if (access_ok(VERIFY_READ, dsp->image, dsp->length)) {
-                struct usb_device* dev = priv->chip.dev;
+                struct usb_device* dev = priv->dev;
                 char *buf;
 
                 buf = memdup_user(dsp->image, dsp->length);
diff --git a/sound/usb/usx2y/usb_stream.c b/sound/usb/usx2y/usb_stream.c
index 12ae0340adc0..c400ade3ff08 100644
--- a/sound/usb/usx2y/usb_stream.c
+++ b/sound/usb/usx2y/usb_stream.c
@@ -17,6 +17,7 @@
  */
 
 #include <linux/usb.h>
+#include <linux/gfp.h>
 
 #include "usb_stream.h"
 
diff --git a/sound/usb/usx2y/usbusx2y.c b/sound/usb/usx2y/usbusx2y.c
index cb4bb8373ca2..cbd37f2c76d0 100644
--- a/sound/usb/usx2y/usbusx2y.c
+++ b/sound/usb/usx2y/usbusx2y.c
@@ -133,6 +133,7 @@
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
+#include <linux/slab.h>
 #include <linux/interrupt.h>
 #include <linux/usb.h>
 #include <sound/core.h>
@@ -239,8 +240,8 @@ static void i_usX2Y_In04Int(struct urb *urb)
                                 for (j = 0; j < URBS_AsyncSeq  &&  !err; ++j)
                                         if (0 == usX2Y->AS04.urb[j]->status) {
                                                 struct us428_p4out *p4out = us428ctls->p4out + send;    // FIXME if more than 1 p4out is new, 1 gets lost.
-                                                usb_fill_bulk_urb(usX2Y->AS04.urb[j], usX2Y->chip.dev,
-                                                                  usb_sndbulkpipe(usX2Y->chip.dev, 0x04), &p4out->val.vol, 
+                                                usb_fill_bulk_urb(usX2Y->AS04.urb[j], usX2Y->dev,
+                                                                  usb_sndbulkpipe(usX2Y->dev, 0x04), &p4out->val.vol,
                                                                   p4out->type == eLT_Light ? sizeof(struct us428_lights) : 5,
                                                                   i_usX2Y_Out04Int, usX2Y);
                                                 err = usb_submit_urb(usX2Y->AS04.urb[j], GFP_ATOMIC);
@@ -253,7 +254,7 @@ static void i_usX2Y_In04Int(struct urb *urb)
         if (err)
                 snd_printk(KERN_ERR "In04Int() usb_submit_urb err=%i\n", err);
 
-        urb->dev = usX2Y->chip.dev;
+        urb->dev = usX2Y->dev;
         usb_submit_urb(urb, GFP_ATOMIC);
 }
 
@@ -273,8 +274,8 @@ int usX2Y_AsyncSeq04_init(struct usX2Ydev *usX2Y)
                                 err = -ENOMEM;
                                 break;
                         }
-                        usb_fill_bulk_urb(      usX2Y->AS04.urb[i], usX2Y->chip.dev,
-                                                usb_sndbulkpipe(usX2Y->chip.dev, 0x04),
+                        usb_fill_bulk_urb(      usX2Y->AS04.urb[i], usX2Y->dev,
+                                                usb_sndbulkpipe(usX2Y->dev, 0x04),
                                                 usX2Y->AS04.buffer + URB_DataLen_AsyncSeq*i, 0,
                                                 i_usX2Y_Out04Int, usX2Y
                                 );
@@ -293,7 +294,7 @@ int usX2Y_In04_init(struct usX2Ydev *usX2Y)
         }
          
         init_waitqueue_head(&usX2Y->In04WaitQueue);
-        usb_fill_int_urb(usX2Y->In04urb, usX2Y->chip.dev, usb_rcvintpipe(usX2Y->chip.dev, 0x4),
+        usb_fill_int_urb(usX2Y->In04urb, usX2Y->dev, usb_rcvintpipe(usX2Y->dev, 0x4),
                          usX2Y->In04Buf, 21,
                          i_usX2Y_In04Int, usX2Y,
                          10);
@@ -348,13 +349,12 @@ static int usX2Y_create_card(struct usb_device *device, struct snd_card **cardp)
                               sizeof(struct usX2Ydev), &card);
         if (err < 0)
                 return err;
-        snd_usX2Y_card_used[usX2Y(card)->chip.index = dev] = 1;
+        snd_usX2Y_card_used[usX2Y(card)->card_index = dev] = 1;
         card->private_free = snd_usX2Y_card_private_free;
-        usX2Y(card)->chip.dev = device;
-        usX2Y(card)->chip.card = card;
+        usX2Y(card)->dev = device;
         init_waitqueue_head(&usX2Y(card)->prepare_wait_queue);
         mutex_init(&usX2Y(card)->prepare_mutex);
-        INIT_LIST_HEAD(&usX2Y(card)->chip.midi_list);
+        INIT_LIST_HEAD(&usX2Y(card)->midi_list);
         strcpy(card->driver, "USB "NAME_ALLCAPS"");
         sprintf(card->shortname, "TASCAM "NAME_ALLCAPS"");
         sprintf(card->longname, "%s (%x:%x if %d at %03d/%03d)",
@@ -362,7 +362,7 @@ static int usX2Y_create_card(struct usb_device *device, struct snd_card **cardp)
                 le16_to_cpu(device->descriptor.idVendor),
                 le16_to_cpu(device->descriptor.idProduct),
                 0,//us428(card)->usbmidi.ifnum,
-                usX2Y(card)->chip.dev->bus->busnum, usX2Y(card)->chip.dev->devnum
+                usX2Y(card)->dev->bus->busnum, usX2Y(card)->dev->devnum
                 );
         *cardp = card;
         return 0;
@@ -432,8 +432,8 @@ static void snd_usX2Y_card_private_free(struct snd_card *card)
         usb_free_urb(usX2Y(card)->In04urb);
         if (usX2Y(card)->us428ctls_sharedmem)
                 snd_free_pages(usX2Y(card)->us428ctls_sharedmem, sizeof(*usX2Y(card)->us428ctls_sharedmem));
-        if (usX2Y(card)->chip.index >= 0  &&  usX2Y(card)->chip.index < SNDRV_CARDS)
-                snd_usX2Y_card_used[usX2Y(card)->chip.index] = 0;
+        if (usX2Y(card)->card_index >= 0  &&  usX2Y(card)->card_index < SNDRV_CARDS)
+                snd_usX2Y_card_used[usX2Y(card)->card_index] = 0;
 }
 
 /*
@@ -445,13 +445,12 @@ static void usX2Y_usb_disconnect(struct usb_device *device, void* ptr)
                 struct snd_card *card = ptr;
                 struct usX2Ydev *usX2Y = usX2Y(card);
                 struct list_head *p;
-                usX2Y->chip.shutdown = 1;
                 usX2Y->chip_status = USX2Y_STAT_CHIP_HUP;
                 usX2Y_unlinkSeq(&usX2Y->AS04);
                 usb_kill_urb(usX2Y->In04urb);
                 snd_card_disconnect(card);
                 /* release the midi resources */
-                list_for_each(p, &usX2Y->chip.midi_list) {
+                list_for_each(p, &usX2Y->midi_list) {
                         snd_usbmidi_disconnect(p);
                 }
                 if (usX2Y->us428ctls_sharedmem) 
diff --git a/sound/usb/usx2y/usbusx2y.h b/sound/usb/usx2y/usbusx2y.h
index 456b5fdbc339..1d174cea352b 100644
--- a/sound/usb/usx2y/usbusx2y.h
+++ b/sound/usb/usx2y/usbusx2y.h
@@ -22,7 +22,8 @@ struct snd_usX2Y_urbSeq {
 #include "usx2yhwdeppcm.h"
 
 struct usX2Ydev {
-        struct snd_usb_audio    chip;
+        struct usb_device       *dev;
+        int                     card_index;
         int                     stride;
         struct urb              *In04urb;
         void                    *In04Buf;
@@ -42,6 +43,9 @@ struct usX2Ydev {
         struct snd_usX2Y_substream      *subs[4];
         struct snd_usX2Y_substream      * volatile  prepare_subs;
         wait_queue_head_t       prepare_wait_queue;
+        struct list_head        midi_list;
+        struct list_head        pcm_list;
+        int                     pcm_devs;
 };
 
 
diff --git a/sound/usb/usx2y/usbusx2yaudio.c b/sound/usb/usx2y/usbusx2yaudio.c
index 9efd27f6b52f..5d37d1ccf813 100644
--- a/sound/usb/usx2y/usbusx2yaudio.c
+++ b/sound/usb/usx2y/usbusx2yaudio.c
@@ -32,6 +32,7 @@
 
 
 #include <linux/interrupt.h>
+#include <linux/slab.h>
 #include <linux/usb.h>
 #include <sound/core.h>
 #include <sound/info.h>
@@ -199,7 +200,7 @@ static int usX2Y_urb_submit(struct snd_usX2Y_substream *subs, struct urb *urb, i
                 return -ENODEV;
         urb->start_frame = (frame + NRURBS * nr_of_packs());  // let hcd do rollover sanity checks
         urb->hcpriv = NULL;
-        urb->dev = subs->usX2Y->chip.dev; /* we need to set this at each time */
+        urb->dev = subs->usX2Y->dev; /* we need to set this at each time */
         if ((err = usb_submit_urb(urb, GFP_ATOMIC)) < 0) {
                 snd_printk(KERN_ERR "usb_submit_urb() returned %i\n", err);
                 return err;
@@ -300,7 +301,7 @@ static void usX2Y_error_sequence(struct usX2Ydev *usX2Y,
 "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),
+                   usb_get_current_frame_number(usX2Y->dev),
                    subs->endpoint, usb_pipein(urb->pipe) ? "in" : "out",
                    usX2Y->wait_iso_frame, urb->start_frame, usX2Y->wait_iso_frame);
         usX2Y_clients_stop(usX2Y);
@@ -313,7 +314,7 @@ static void i_usX2Y_urb_complete(struct urb *urb)
 
         if (unlikely(atomic_read(&subs->state) < state_PREPARED)) {
                 snd_printdd("hcd_frame=%i ep=%i%s status=%i start_frame=%i\n",
-                            usb_get_current_frame_number(usX2Y->chip.dev),
+                            usb_get_current_frame_number(usX2Y->dev),
                             subs->endpoint, usb_pipein(urb->pipe) ? "in" : "out",
                             urb->status, urb->start_frame);
                 return;
@@ -424,7 +425,7 @@ static int usX2Y_urbs_allocate(struct snd_usX2Y_substream *subs)
         int i;
         unsigned int pipe;
         int is_playback = subs == subs->usX2Y->subs[SNDRV_PCM_STREAM_PLAYBACK];
-        struct usb_device *dev = subs->usX2Y->chip.dev;
+        struct usb_device *dev = subs->usX2Y->dev;
 
         pipe = is_playback ? usb_sndisocpipe(dev, subs->endpoint) :
                         usb_rcvisocpipe(dev, subs->endpoint);
@@ -500,7 +501,7 @@ static int usX2Y_urbs_start(struct snd_usX2Y_substream *subs)
                         unsigned long pack;
                         if (0 == i)
                                 atomic_set(&subs->state, state_STARTING3);
-                        urb->dev = usX2Y->chip.dev;
+                        urb->dev = usX2Y->dev;
                         urb->transfer_flags = URB_ISO_ASAP;
                         for (pack = 0; pack < nr_of_packs(); pack++) {
                                 urb->iso_frame_desc[pack].offset = subs->maxpacksize * pack;
@@ -692,7 +693,7 @@ static int usX2Y_rate_set(struct usX2Ydev *usX2Y, int rate)
                         }
                         ((char*)(usbdata + i))[0] = ra[i].c1;
                         ((char*)(usbdata + i))[1] = ra[i].c2;
-                        usb_fill_bulk_urb(us->urb[i], usX2Y->chip.dev, usb_sndbulkpipe(usX2Y->chip.dev, 4),
+                        usb_fill_bulk_urb(us->urb[i], usX2Y->dev, usb_sndbulkpipe(usX2Y->dev, 4),
                                           usbdata + i, 2, i_usX2Y_04Int, usX2Y);
 #ifdef OLD_USB
                         us->urb[i]->transfer_flags = USB_QUEUE_BULK;
@@ -740,17 +741,17 @@ static int usX2Y_format_set(struct usX2Ydev *usX2Y, snd_pcm_format_t format)
                 alternate = 1;
                 usX2Y->stride = 4;
         }
-        list_for_each(p, &usX2Y->chip.midi_list) {
+        list_for_each(p, &usX2Y->midi_list) {
                 snd_usbmidi_input_stop(p);
         }
         usb_kill_urb(usX2Y->In04urb);
-        if ((err = usb_set_interface(usX2Y->chip.dev, 0, alternate))) {
+        if ((err = usb_set_interface(usX2Y->dev, 0, alternate))) {
                 snd_printk(KERN_ERR "usb_set_interface error \n");
                 return err;
         }
-        usX2Y->In04urb->dev = usX2Y->chip.dev;
+        usX2Y->In04urb->dev = usX2Y->dev;
         err = usb_submit_urb(usX2Y->In04urb, GFP_KERNEL);
-        list_for_each(p, &usX2Y->chip.midi_list) {
+        list_for_each(p, &usX2Y->midi_list) {
                 snd_usbmidi_input_start(p);
         }
         usX2Y->format = format;
@@ -955,7 +956,7 @@ static int usX2Y_audio_stream_new(struct snd_card *card, int playback_endpoint,
         struct snd_pcm *pcm;
         int err, i;
         struct snd_usX2Y_substream **usX2Y_substream =
-                usX2Y(card)->subs + 2 * usX2Y(card)->chip.pcm_devs;
+                usX2Y(card)->subs + 2 * usX2Y(card)->pcm_devs;
 
         for (i = playback_endpoint ? SNDRV_PCM_STREAM_PLAYBACK : SNDRV_PCM_STREAM_CAPTURE;
              i <= SNDRV_PCM_STREAM_CAPTURE; ++i) {
@@ -971,7 +972,7 @@ static int usX2Y_audio_stream_new(struct snd_card *card, int playback_endpoint,
                 usX2Y_substream[SNDRV_PCM_STREAM_PLAYBACK]->endpoint = playback_endpoint;
         usX2Y_substream[SNDRV_PCM_STREAM_CAPTURE]->endpoint = capture_endpoint;
 
-        err = snd_pcm_new(card, NAME_ALLCAPS" Audio", usX2Y(card)->chip.pcm_devs,
+        err = snd_pcm_new(card, NAME_ALLCAPS" Audio", usX2Y(card)->pcm_devs,
                           playback_endpoint ? 1 : 0, 1,
                           &pcm);
         if (err < 0) {
@@ -987,7 +988,7 @@ static int usX2Y_audio_stream_new(struct snd_card *card, int playback_endpoint,
         pcm->private_free = snd_usX2Y_pcm_private_free;
         pcm->info_flags = 0;
 
-        sprintf(pcm->name, NAME_ALLCAPS" Audio #%d", usX2Y(card)->chip.pcm_devs);
+        sprintf(pcm->name, NAME_ALLCAPS" Audio #%d", usX2Y(card)->pcm_devs);
 
         if ((playback_endpoint &&
              0 > (err = snd_pcm_lib_preallocate_pages(pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream,
@@ -1001,7 +1002,7 @@ static int usX2Y_audio_stream_new(struct snd_card *card, int playback_endpoint,
                 snd_usX2Y_pcm_private_free(pcm);
                 return err;
         }
-        usX2Y(card)->chip.pcm_devs++;
+        usX2Y(card)->pcm_devs++;
 
         return 0;
 }
@@ -1013,14 +1014,14 @@ int usX2Y_audio_create(struct snd_card *card)
 {
         int err = 0;
         
-        INIT_LIST_HEAD(&usX2Y(card)->chip.pcm_list);
+        INIT_LIST_HEAD(&usX2Y(card)->pcm_list);
 
         if (0 > (err = usX2Y_audio_stream_new(card, 0xA, 0x8)))
                 return err;
-        if (le16_to_cpu(usX2Y(card)->chip.dev->descriptor.idProduct) == USB_ID_US428)
+        if (le16_to_cpu(usX2Y(card)->dev->descriptor.idProduct) == USB_ID_US428)
              if (0 > (err = usX2Y_audio_stream_new(card, 0, 0xA)))
                      return err;
-        if (le16_to_cpu(usX2Y(card)->chip.dev->descriptor.idProduct) != USB_ID_US122)
+        if (le16_to_cpu(usX2Y(card)->dev->descriptor.idProduct) != USB_ID_US122)
                 err = usX2Y_rate_set(usX2Y(card), 44100);       // Lets us428 recognize output-volume settings, disturbs us122.
         return err;
 }
diff --git a/sound/usb/usx2y/usx2yhwdeppcm.c b/sound/usb/usx2y/usx2yhwdeppcm.c
index 4b2304c2e02d..2a528e56afd5 100644
--- a/sound/usb/usx2y/usx2yhwdeppcm.c
+++ b/sound/usb/usx2y/usx2yhwdeppcm.c
@@ -51,6 +51,7 @@
 */
 
 #include <linux/delay.h>
+#include <linux/gfp.h>
 #include "usbusx2yaudio.c"
 
 #if defined(USX2Y_NRPACKS_VARIABLE) || (!defined(USX2Y_NRPACKS_VARIABLE) &&  USX2Y_NRPACKS == 1)
@@ -234,7 +235,7 @@ static void i_usX2Y_usbpcm_urb_complete(struct urb *urb)
 
         if (unlikely(atomic_read(&subs->state) < state_PREPARED)) {
                 snd_printdd("hcd_frame=%i ep=%i%s status=%i start_frame=%i\n",
-                            usb_get_current_frame_number(usX2Y->chip.dev),
+                            usb_get_current_frame_number(usX2Y->dev),
                             subs->endpoint, usb_pipein(urb->pipe) ? "in" : "out",
                             urb->status, urb->start_frame);
                 return;
@@ -318,7 +319,7 @@ static int usX2Y_usbpcm_urbs_allocate(struct snd_usX2Y_substream *subs)
         int i;
         unsigned int pipe;
         int is_playback = subs == subs->usX2Y->subs[SNDRV_PCM_STREAM_PLAYBACK];
-        struct usb_device *dev = subs->usX2Y->chip.dev;
+        struct usb_device *dev = subs->usX2Y->dev;
 
         pipe = is_playback ? usb_sndisocpipe(dev, subs->endpoint) :
                         usb_rcvisocpipe(dev, subs->endpoint);
@@ -441,7 +442,7 @@ static int usX2Y_usbpcm_urbs_start(struct snd_usX2Y_substream *subs)
                                         unsigned long pack;
                                         if (0 == u)
                                                 atomic_set(&subs->state, state_STARTING3);
-                                        urb->dev = usX2Y->chip.dev;
+                                        urb->dev = usX2Y->dev;
                                         urb->transfer_flags = URB_ISO_ASAP;
                                         for (pack = 0; pack < nr_of_packs(); pack++) {
                                                 urb->iso_frame_desc[pack].offset = subs->maxpacksize * (pack + u * nr_of_packs());
@@ -741,7 +742,7 @@ int usX2Y_hwdep_pcm_new(struct snd_card *card)
         int err;
         struct snd_hwdep *hw;
         struct snd_pcm *pcm;
-        struct usb_device *dev = usX2Y(card)->chip.dev;
+        struct usb_device *dev = usX2Y(card)->dev;
         if (1 != nr_of_packs())
                 return 0;