Merge branch 'topic/asoc' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound-2.6 into upstream/wm8711

62 files changed, 19847 insertions, 1736 deletions

diff --git a/sound/soc/codecs/Kconfig b/sound/soc/codecs/Kconfig
index 663840e67766..a5cfa78eb166 100644
--- a/sound/soc/codecs/Kconfig
+++ b/sound/soc/codecs/Kconfig
@@ -12,13 +12,18 @@ config SND_SOC_ALL_CODECS
         tristate "Build all ASoC CODEC drivers"
         select SND_SOC_L3
         select SND_SOC_AC97_CODEC if SND_SOC_AC97_BUS
+        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_AD73311 if I2C
         select SND_SOC_AK4104 if SPI_MASTER
         select SND_SOC_AK4535 if I2C
         select SND_SOC_CS4270 if I2C
+        select SND_SOC_MAX9877 if I2C
         select SND_SOC_PCM3008
+        select SND_SOC_SPDIF
         select SND_SOC_SSM2602 if I2C
+        select SND_SOC_STAC9766 if SND_SOC_AC97_BUS
         select SND_SOC_TLV320AIC23 if I2C
         select SND_SOC_TLV320AIC26 if SPI_MASTER
         select SND_SOC_TLV320AIC3X if I2C
@@ -28,16 +33,25 @@ config SND_SOC_ALL_CODECS
         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 I2C
         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
         select SND_SOC_WM8753 if SND_SOC_I2C_AND_SPI
+        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_WM8940 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_WM8988 if SND_SOC_I2C_AND_SPI
         select SND_SOC_WM8990 if I2C
+        select SND_SOC_WM8993 if I2C
+        select SND_SOC_WM9081 if I2C
         select SND_SOC_WM9705 if SND_SOC_AC97_BUS
         select SND_SOC_WM9712 if SND_SOC_AC97_BUS
         select SND_SOC_WM9713 if SND_SOC_AC97_BUS
@@ -52,11 +66,21 @@ config SND_SOC_ALL_CODECS
 
           If unsure select "N".
 
+config SND_SOC_WM_HUBS
+        tristate
+        default y if SND_SOC_WM8993=y
+        default m if SND_SOC_WM8993=m
 
 config SND_SOC_AC97_CODEC
         tristate
         select SND_AC97_CODEC
 
+config SND_SOC_AD1836
+        tristate
+
+config SND_SOC_AD1938
+        tristate
+
 config SND_SOC_AD1980
         tristate
 
@@ -81,15 +105,24 @@ config SND_SOC_CS4270_VD33_ERRATA
         bool
         depends on SND_SOC_CS4270
 
+config SND_SOC_CX20442
+        tristate
+
 config SND_SOC_L3
        tristate
 
 config SND_SOC_PCM3008
        tristate
 
+config SND_SOC_SPDIF
+        tristate
+
 config SND_SOC_SSM2602
         tristate
 
+config SND_SOC_STAC9766
+        tristate
+
 config SND_SOC_TLV320AIC23
         tristate
 
@@ -118,6 +151,9 @@ config SND_SOC_WM8400
 config SND_SOC_WM8510
         tristate
 
+config SND_SOC_WM8523
+        tristate
+
 config SND_SOC_WM8580
         tristate
 
@@ -136,18 +172,42 @@ config SND_SOC_WM8750
 config SND_SOC_WM8753
         tristate
 
+config SND_SOC_WM8776
+        tristate
+
 config SND_SOC_WM8900
         tristate
 
 config SND_SOC_WM8903
         tristate
 
+config SND_SOC_WM8940
+        tristate
+
+config SND_SOC_WM8960
+        tristate
+
+config SND_SOC_WM8961
+        tristate
+
 config SND_SOC_WM8971
         tristate
 
+config SND_SOC_WM8974
+        tristate
+
+config SND_SOC_WM8988
+        tristate
+
 config SND_SOC_WM8990
         tristate
 
+config SND_SOC_WM8993
+        tristate
+
+config SND_SOC_WM9081
+        tristate
+
 config SND_SOC_WM9705
         tristate
 
@@ -156,3 +216,7 @@ config SND_SOC_WM9712
 
 config SND_SOC_WM9713
         tristate
+
+# Amp
+config SND_SOC_MAX9877
+        tristate
diff --git a/sound/soc/codecs/Makefile b/sound/soc/codecs/Makefile
index 19950e998b6b..711d8f5887de 100644
--- a/sound/soc/codecs/Makefile
+++ b/sound/soc/codecs/Makefile
@@ -1,12 +1,17 @@
 snd-soc-ac97-objs := ac97.o
+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-ak4104-objs := ak4104.o
 snd-soc-ak4535-objs := ak4535.o
 snd-soc-cs4270-objs := cs4270.o
+snd-soc-cx20442-objs := cx20442.o
 snd-soc-l3-objs := l3.o
 snd-soc-pcm3008-objs := pcm3008.o
+snd-soc-spdif-objs := spdif_transciever.o
 snd-soc-ssm2602-objs := ssm2602.o
+snd-soc-stac9766-objs := stac9766.o
 snd-soc-tlv320aic23-objs := tlv320aic23.o
 snd-soc-tlv320aic26-objs := tlv320aic26.o
 snd-soc-tlv320aic3x-objs := tlv320aic3x.o
@@ -16,29 +21,47 @@ snd-soc-uda1380-objs := uda1380.o
 snd-soc-wm8350-objs := wm8350.o
 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-wm8728-objs := wm8728.o
 snd-soc-wm8731-objs := wm8731.o
 snd-soc-wm8750-objs := wm8750.o
 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-wm8940-objs := wm8940.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-wm8988-objs := wm8988.o
 snd-soc-wm8990-objs := wm8990.o
+snd-soc-wm8993-objs := wm8993.o
+snd-soc-wm9081-objs := wm9081.o
 snd-soc-wm9705-objs := wm9705.o
 snd-soc-wm9712-objs := wm9712.o
 snd-soc-wm9713-objs := wm9713.o
+snd-soc-wm-hubs-objs := wm_hubs.o
+
+# Amp
+snd-soc-max9877-objs := max9877.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_AK4104)    += snd-soc-ak4104.o
 obj-$(CONFIG_SND_SOC_AK4535)    += snd-soc-ak4535.o
 obj-$(CONFIG_SND_SOC_CS4270)    += snd-soc-cs4270.o
+obj-$(CONFIG_SND_SOC_CX20442)   += snd-soc-cx20442.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
 obj-$(CONFIG_SND_SOC_SSM2602)   += snd-soc-ssm2602.o
+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
@@ -48,16 +71,29 @@ obj-$(CONFIG_SND_SOC_UDA1380)	+= snd-soc-uda1380.o
 obj-$(CONFIG_SND_SOC_WM8350)    += snd-soc-wm8350.o
 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_WM8728)    += snd-soc-wm8728.o
 obj-$(CONFIG_SND_SOC_WM8731)    += snd-soc-wm8731.o
 obj-$(CONFIG_SND_SOC_WM8750)    += snd-soc-wm8750.o
 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_WM8940)    += snd-soc-wm8940.o
+obj-$(CONFIG_SND_SOC_WM8960)    += snd-soc-wm8960.o
+obj-$(CONFIG_SND_SOC_WM8961)    += snd-soc-wm8961.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_WM9081)    += snd-soc-wm9081.o
 obj-$(CONFIG_SND_SOC_WM9705)    += snd-soc-wm9705.o
 obj-$(CONFIG_SND_SOC_WM9712)    += snd-soc-wm9712.o
 obj-$(CONFIG_SND_SOC_WM9713)    += snd-soc-wm9713.o
+obj-$(CONFIG_SND_SOC_WM_HUBS)   += snd-soc-wm-hubs.o
+
+# Amp
+obj-$(CONFIG_SND_SOC_MAX9877)   += snd-soc-max9877.o
diff --git a/sound/soc/codecs/ac97.c b/sound/soc/codecs/ac97.c
index b0d4af145b87..932299bb5d1e 100644
--- a/sound/soc/codecs/ac97.c
+++ b/sound/soc/codecs/ac97.c
@@ -53,13 +53,13 @@ struct snd_soc_dai ac97_dai = {
                 .channels_min = 1,
                 .channels_max = 2,
                 .rates = STD_AC97_RATES,
-                .formats = SNDRV_PCM_FMTBIT_S16_LE,},
+                .formats = SND_SOC_STD_AC97_FMTS,},
         .capture = {
                 .stream_name = "AC97 Capture",
                 .channels_min = 1,
                 .channels_max = 2,
                 .rates = STD_AC97_RATES,
-                .formats = SNDRV_PCM_FMTBIT_S16_LE,},
+                .formats = SND_SOC_STD_AC97_FMTS,},
         .ops = &ac97_dai_ops,
 };
 EXPORT_SYMBOL_GPL(ac97_dai);
diff --git a/sound/soc/codecs/ad1836.c b/sound/soc/codecs/ad1836.c
new file mode 100644
index 000000000000..3612bb92df90
--- /dev/null
+++ b/sound/soc/codecs/ad1836.c
@@ -0,0 +1,446 @@
+/*
+ * File:         sound/soc/codecs/ad1836.c
+ * Author:       Barry Song <Barry.Song@analog.com>
+ *
+ * Created:      Aug 04 2009
+ * Description:  Driver for AD1836 sound chip
+ *
+ * Modified:
+ *               Copyright 2009 Analog Devices Inc.
+ *
+ * Bugs:         Enter bugs at http://blackfin.uclinux.org/
+ *
+ * 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/module.h>
+#include <linux/version.h>
+#include <linux/kernel.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 <sound/tlv.h>
+#include <sound/soc-dapm.h>
+#include <linux/spi/spi.h>
+#include "ad1836.h"
+
+/* codec private data */
+struct ad1836_priv {
+        struct snd_soc_codec codec;
+        u16 reg_cache[AD1836_NUM_REGS];
+};
+
+static struct snd_soc_codec *ad1836_codec;
+struct snd_soc_codec_device soc_codec_dev_ad1836;
+static int ad1836_register(struct ad1836_priv *ad1836);
+static void ad1836_unregister(struct ad1836_priv *ad1836);
+
+/*
+ * AD1836 volume/mute/de-emphasis etc. controls
+ */
+static const char *ad1836_deemp[] = {"None", "44.1kHz", "32kHz", "48kHz"};
+
+static const struct soc_enum ad1836_deemp_enum =
+        SOC_ENUM_SINGLE(AD1836_DAC_CTRL1, 8, 4, ad1836_deemp);
+
+static const struct snd_kcontrol_new ad1836_snd_controls[] = {
+        /* DAC volume control */
+        SOC_DOUBLE_R("DAC1 Volume", AD1836_DAC_L1_VOL,
+                        AD1836_DAC_R1_VOL, 0, 0x3FF, 0),
+        SOC_DOUBLE_R("DAC2 Volume", AD1836_DAC_L2_VOL,
+                        AD1836_DAC_R2_VOL, 0, 0x3FF, 0),
+        SOC_DOUBLE_R("DAC3 Volume", AD1836_DAC_L3_VOL,
+                        AD1836_DAC_R3_VOL, 0, 0x3FF, 0),
+
+        /* ADC switch control */
+        SOC_DOUBLE("ADC1 Switch", AD1836_ADC_CTRL2, AD1836_ADCL1_MUTE,
+                AD1836_ADCR1_MUTE, 1, 1),
+        SOC_DOUBLE("ADC2 Switch", AD1836_ADC_CTRL2, AD1836_ADCL2_MUTE,
+                AD1836_ADCR2_MUTE, 1, 1),
+
+        /* DAC switch control */
+        SOC_DOUBLE("DAC1 Switch", AD1836_DAC_CTRL2, AD1836_DACL1_MUTE,
+                AD1836_DACR1_MUTE, 1, 1),
+        SOC_DOUBLE("DAC2 Switch", AD1836_DAC_CTRL2, AD1836_DACL2_MUTE,
+                AD1836_DACR2_MUTE, 1, 1),
+        SOC_DOUBLE("DAC3 Switch", AD1836_DAC_CTRL2, AD1836_DACL3_MUTE,
+                AD1836_DACR3_MUTE, 1, 1),
+
+        /* ADC high-pass filter */
+        SOC_SINGLE("ADC High Pass Filter Switch", AD1836_ADC_CTRL1,
+                        AD1836_ADC_HIGHPASS_FILTER, 1, 0),
+
+        /* DAC de-emphasis */
+        SOC_ENUM("Playback Deemphasis", ad1836_deemp_enum),
+};
+
+static const struct snd_soc_dapm_widget ad1836_dapm_widgets[] = {
+        SND_SOC_DAPM_DAC("DAC", "Playback", AD1836_DAC_CTRL1,
+                                AD1836_DAC_POWERDOWN, 1),
+        SND_SOC_DAPM_ADC("ADC", "Capture", SND_SOC_NOPM, 0, 0),
+        SND_SOC_DAPM_SUPPLY("ADC_PWR", AD1836_ADC_CTRL1,
+                                AD1836_ADC_POWERDOWN, 1, NULL, 0),
+        SND_SOC_DAPM_OUTPUT("DAC1OUT"),
+        SND_SOC_DAPM_OUTPUT("DAC2OUT"),
+        SND_SOC_DAPM_OUTPUT("DAC3OUT"),
+        SND_SOC_DAPM_INPUT("ADC1IN"),
+        SND_SOC_DAPM_INPUT("ADC2IN"),
+};
+
+static const struct snd_soc_dapm_route audio_paths[] = {
+        { "DAC", NULL, "ADC_PWR" },
+        { "ADC", NULL, "ADC_PWR" },
+        { "DAC1OUT", "DAC1 Switch", "DAC" },
+        { "DAC2OUT", "DAC2 Switch", "DAC" },
+        { "DAC3OUT", "DAC3 Switch", "DAC" },
+        { "ADC", "ADC1 Switch", "ADC1IN" },
+        { "ADC", "ADC2 Switch", "ADC2IN" },
+};
+
+/*
+ * DAI ops entries
+ */
+
+static int ad1836_set_dai_fmt(struct snd_soc_dai *codec_dai,
+                unsigned int fmt)
+{
+        switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
+        /* at present, we support adc aux mode to interface with
+         * blackfin sport tdm mode
+         */
+        case SND_SOC_DAIFMT_DSP_A:
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
+        case SND_SOC_DAIFMT_IB_IF:
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
+        /* ALCLK,ABCLK are both output, AD1836 can only be master */
+        case SND_SOC_DAIFMT_CBM_CFM:
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int ad1836_hw_params(struct snd_pcm_substream *substream,
+                struct snd_pcm_hw_params *params,
+                struct snd_soc_dai *dai)
+{
+        int word_len = 0;
+
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_device *socdev = rtd->socdev;
+        struct snd_soc_codec *codec = socdev->card->codec;
+
+        /* bit size */
+        switch (params_format(params)) {
+        case SNDRV_PCM_FORMAT_S16_LE:
+                word_len = 3;
+                break;
+        case SNDRV_PCM_FORMAT_S20_3LE:
+                word_len = 1;
+                break;
+        case SNDRV_PCM_FORMAT_S24_LE:
+        case SNDRV_PCM_FORMAT_S32_LE:
+                word_len = 0;
+                break;
+        }
+
+        snd_soc_update_bits(codec, AD1836_DAC_CTRL1,
+                AD1836_DAC_WORD_LEN_MASK, word_len);
+
+        snd_soc_update_bits(codec, AD1836_ADC_CTRL2,
+                AD1836_ADC_WORD_LEN_MASK, word_len);
+
+        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)
+{
+        u16 *reg_cache = codec->reg_cache;
+        int ret = 0;
+
+        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;
+        }
+
+        return ret;
+}
+
+/*
+ * read from the ad1836 register space cache
+ */
+static unsigned int ad1836_read_reg_cache(struct snd_soc_codec *codec,
+                                          unsigned int reg)
+{
+        u16 *reg_cache = codec->reg_cache;
+
+        if (reg >= codec->reg_cache_size)
+                return -EINVAL;
+
+        return reg_cache[reg];
+}
+
+static int __devinit ad1836_spi_probe(struct spi_device *spi)
+{
+        struct snd_soc_codec *codec;
+        struct ad1836_priv *ad1836;
+
+        ad1836 = kzalloc(sizeof(struct ad1836_priv), GFP_KERNEL);
+        if (ad1836 == NULL)
+                return -ENOMEM;
+
+        codec = &ad1836->codec;
+        codec->control_data = spi;
+        codec->dev = &spi->dev;
+
+        dev_set_drvdata(&spi->dev, ad1836);
+
+        return ad1836_register(ad1836);
+}
+
+static int __devexit ad1836_spi_remove(struct spi_device *spi)
+{
+        struct ad1836_priv *ad1836 = dev_get_drvdata(&spi->dev);
+
+        ad1836_unregister(ad1836);
+        return 0;
+}
+
+static struct spi_driver ad1836_spi_driver = {
+        .driver = {
+                .name   = "ad1836-spi",
+                .bus    = &spi_bus_type,
+                .owner  = THIS_MODULE,
+        },
+        .probe          = ad1836_spi_probe,
+        .remove         = __devexit_p(ad1836_spi_remove),
+};
+
+static struct snd_soc_dai_ops ad1836_dai_ops = {
+        .hw_params = ad1836_hw_params,
+        .set_fmt = ad1836_set_dai_fmt,
+};
+
+/* codec DAI instance */
+struct snd_soc_dai ad1836_dai = {
+        .name = "AD1836",
+        .playback = {
+                .stream_name = "Playback",
+                .channels_min = 2,
+                .channels_max = 6,
+                .rates = SNDRV_PCM_RATE_48000,
+                .formats = SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S16_LE |
+                        SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S24_LE,
+        },
+        .capture = {
+                .stream_name = "Capture",
+                .channels_min = 2,
+                .channels_max = 4,
+                .rates = SNDRV_PCM_RATE_48000,
+                .formats = SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S16_LE |
+                        SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S24_LE,
+        },
+        .ops = &ad1836_dai_ops,
+};
+EXPORT_SYMBOL_GPL(ad1836_dai);
+
+static int ad1836_register(struct ad1836_priv *ad1836)
+{
+        int ret;
+        struct snd_soc_codec *codec = &ad1836->codec;
+
+        if (ad1836_codec) {
+                dev_err(codec->dev, "Another ad1836 is registered\n");
+                return -EINVAL;
+        }
+
+        mutex_init(&codec->mutex);
+        INIT_LIST_HEAD(&codec->dapm_widgets);
+        INIT_LIST_HEAD(&codec->dapm_paths);
+        codec->private_data = ad1836;
+        codec->reg_cache = ad1836->reg_cache;
+        codec->reg_cache_size = AD1836_NUM_REGS;
+        codec->name = "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;
+
+        /* default setting for ad1836 */
+        /* de-emphasis: 48kHz, power-on dac */
+        codec->write(codec, AD1836_DAC_CTRL1, 0x300);
+        /* unmute dac channels */
+        codec->write(codec, AD1836_DAC_CTRL2, 0x0);
+        /* high-pass filter enable, power-on adc */
+        codec->write(codec, AD1836_ADC_CTRL1, 0x100);
+        /* unmute adc channles, adc aux mode */
+        codec->write(codec, AD1836_ADC_CTRL2, 0x180);
+        /* left/right diff:PGA/MUX */
+        codec->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);
+
+        ret = snd_soc_register_codec(codec);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to register codec: %d\n", ret);
+                kfree(ad1836);
+                return ret;
+        }
+
+        ret = snd_soc_register_dai(&ad1836_dai);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to register DAI: %d\n", ret);
+                snd_soc_unregister_codec(codec);
+                kfree(ad1836);
+                return ret;
+        }
+
+        return 0;
+}
+
+static void ad1836_unregister(struct ad1836_priv *ad1836)
+{
+        snd_soc_unregister_dai(&ad1836_dai);
+        snd_soc_unregister_codec(&ad1836->codec);
+        kfree(ad1836);
+        ad1836_codec = NULL;
+}
+
+static int ad1836_probe(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec;
+        int ret = 0;
+
+        if (ad1836_codec == NULL) {
+                dev_err(&pdev->dev, "Codec device not registered\n");
+                return -ENODEV;
+        }
+
+        socdev->card->codec = ad1836_codec;
+        codec = ad1836_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, ad1836_snd_controls,
+                             ARRAY_SIZE(ad1836_snd_controls));
+        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;
+}
+
+/* power down chip */
+static int ad1836_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_ad1836 = {
+        .probe =        ad1836_probe,
+        .remove =       ad1836_remove,
+};
+EXPORT_SYMBOL_GPL(soc_codec_dev_ad1836);
+
+static int __init ad1836_init(void)
+{
+        int ret;
+
+        ret = spi_register_driver(&ad1836_spi_driver);
+        if (ret != 0) {
+                printk(KERN_ERR "Failed to register ad1836 SPI driver: %d\n",
+                                ret);
+        }
+
+        return ret;
+}
+module_init(ad1836_init);
+
+static void __exit ad1836_exit(void)
+{
+        spi_unregister_driver(&ad1836_spi_driver);
+}
+module_exit(ad1836_exit);
+
+MODULE_DESCRIPTION("ASoC ad1836 driver");
+MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/codecs/ad1836.h b/sound/soc/codecs/ad1836.h
new file mode 100644
index 000000000000..7660ee6973c0
--- /dev/null
+++ b/sound/soc/codecs/ad1836.h
@@ -0,0 +1,64 @@
+/*
+ * File:         sound/soc/codecs/ad1836.h
+ * Based on:
+ * Author:       Barry Song <Barry.Song@analog.com>
+ *
+ * Created:      Aug 04, 2009
+ * Description:  definitions for AD1836 registers
+ *
+ * Modified:
+ *
+ * Bugs:         Enter bugs at http://blackfin.uclinux.org/
+ *
+ * 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 __AD1836_H__
+#define __AD1836_H__
+
+#define AD1836_DAC_CTRL1               0
+#define AD1836_DAC_POWERDOWN           2
+#define AD1836_DAC_SERFMT_MASK         0xE0
+#define AD1836_DAC_SERFMT_PCK256       (0x4 << 5)
+#define AD1836_DAC_SERFMT_PCK128       (0x5 << 5)
+#define AD1836_DAC_WORD_LEN_MASK       0x18
+
+#define AD1836_DAC_CTRL2               1
+#define AD1836_DACL1_MUTE              0
+#define AD1836_DACR1_MUTE              1
+#define AD1836_DACL2_MUTE              2
+#define AD1836_DACR2_MUTE              3
+#define AD1836_DACL3_MUTE              4
+#define AD1836_DACR3_MUTE              5
+
+#define AD1836_DAC_L1_VOL              2
+#define AD1836_DAC_R1_VOL              3
+#define AD1836_DAC_L2_VOL              4
+#define AD1836_DAC_R2_VOL              5
+#define AD1836_DAC_L3_VOL              6
+#define AD1836_DAC_R3_VOL              7
+
+#define AD1836_ADC_CTRL1               12
+#define AD1836_ADC_POWERDOWN           7
+#define AD1836_ADC_HIGHPASS_FILTER     8
+
+#define AD1836_ADC_CTRL2               13
+#define AD1836_ADCL1_MUTE               0
+#define AD1836_ADCR1_MUTE               1
+#define AD1836_ADCL2_MUTE               2
+#define AD1836_ADCR2_MUTE               3
+#define AD1836_ADC_WORD_LEN_MASK       0x30
+#define AD1836_ADC_SERFMT_MASK         (7 << 6)
+#define AD1836_ADC_SERFMT_PCK256       (0x4 << 6)
+#define AD1836_ADC_SERFMT_PCK128       (0x5 << 6)
+
+#define AD1836_ADC_CTRL3               14
+
+#define AD1836_NUM_REGS                16
+
+extern struct snd_soc_dai ad1836_dai;
+extern struct snd_soc_codec_device soc_codec_dev_ad1836;
+#endif
diff --git a/sound/soc/codecs/ad1938.c b/sound/soc/codecs/ad1938.c
new file mode 100644
index 000000000000..e62b27701a49
--- /dev/null
+++ b/sound/soc/codecs/ad1938.c
@@ -0,0 +1,682 @@
+/*
+ * File:         sound/soc/codecs/ad1938.c
+ * Author:       Barry Song <Barry.Song@analog.com>
+ *
+ * Created:      June 04 2009
+ * Description:  Driver for AD1938 sound chip
+ *
+ * Modified:
+ *               Copyright 2009 Analog Devices Inc.
+ *
+ * Bugs:         Enter bugs at http://blackfin.uclinux.org/
+ *
+ * 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, see the file COPYING, or 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/version.h>
+#include <linux/kernel.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 <sound/tlv.h>
+#include <sound/soc-dapm.h>
+#include <linux/spi/spi.h>
+#include "ad1938.h"
+
+/* codec private data */
+struct ad1938_priv {
+        struct snd_soc_codec codec;
+        u8 reg_cache[AD1938_NUM_REGS];
+};
+
+static struct snd_soc_codec *ad1938_codec;
+struct snd_soc_codec_device soc_codec_dev_ad1938;
+static int ad1938_register(struct ad1938_priv *ad1938);
+static void ad1938_unregister(struct ad1938_priv *ad1938);
+
+/*
+ * AD1938 volume/mute/de-emphasis etc. controls
+ */
+static const char *ad1938_deemp[] = {"None", "48kHz", "44.1kHz", "32kHz"};
+
+static const struct soc_enum ad1938_deemp_enum =
+        SOC_ENUM_SINGLE(AD1938_DAC_CTRL2, 1, 4, ad1938_deemp);
+
+static const struct snd_kcontrol_new ad1938_snd_controls[] = {
+        /* DAC volume control */
+        SOC_DOUBLE_R("DAC1  Volume", AD1938_DAC_L1_VOL,
+                        AD1938_DAC_R1_VOL, 0, 0xFF, 1),
+        SOC_DOUBLE_R("DAC2  Volume", AD1938_DAC_L2_VOL,
+                        AD1938_DAC_R2_VOL, 0, 0xFF, 1),
+        SOC_DOUBLE_R("DAC3  Volume", AD1938_DAC_L3_VOL,
+                        AD1938_DAC_R3_VOL, 0, 0xFF, 1),
+        SOC_DOUBLE_R("DAC4  Volume", AD1938_DAC_L4_VOL,
+                        AD1938_DAC_R4_VOL, 0, 0xFF, 1),
+
+        /* ADC switch control */
+        SOC_DOUBLE("ADC1 Switch", AD1938_ADC_CTRL0, AD1938_ADCL1_MUTE,
+                AD1938_ADCR1_MUTE, 1, 1),
+        SOC_DOUBLE("ADC2 Switch", AD1938_ADC_CTRL0, AD1938_ADCL2_MUTE,
+                AD1938_ADCR2_MUTE, 1, 1),
+
+        /* DAC switch control */
+        SOC_DOUBLE("DAC1 Switch", AD1938_DAC_CHNL_MUTE, AD1938_DACL1_MUTE,
+                AD1938_DACR1_MUTE, 1, 1),
+        SOC_DOUBLE("DAC2 Switch", AD1938_DAC_CHNL_MUTE, AD1938_DACL2_MUTE,
+                AD1938_DACR2_MUTE, 1, 1),
+        SOC_DOUBLE("DAC3 Switch", AD1938_DAC_CHNL_MUTE, AD1938_DACL3_MUTE,
+                AD1938_DACR3_MUTE, 1, 1),
+        SOC_DOUBLE("DAC4 Switch", AD1938_DAC_CHNL_MUTE, AD1938_DACL4_MUTE,
+                AD1938_DACR4_MUTE, 1, 1),
+
+        /* ADC high-pass filter */
+        SOC_SINGLE("ADC High Pass Filter Switch", AD1938_ADC_CTRL0,
+                        AD1938_ADC_HIGHPASS_FILTER, 1, 0),
+
+        /* DAC de-emphasis */
+        SOC_ENUM("Playback Deemphasis", ad1938_deemp_enum),
+};
+
+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("ADC_PWR", AD1938_ADC_CTRL0, 0, 1, NULL, 0),
+        SND_SOC_DAPM_OUTPUT("DAC1OUT"),
+        SND_SOC_DAPM_OUTPUT("DAC2OUT"),
+        SND_SOC_DAPM_OUTPUT("DAC3OUT"),
+        SND_SOC_DAPM_OUTPUT("DAC4OUT"),
+        SND_SOC_DAPM_INPUT("ADC1IN"),
+        SND_SOC_DAPM_INPUT("ADC2IN"),
+};
+
+static const struct snd_soc_dapm_route audio_paths[] = {
+        { "DAC", NULL, "ADC_PWR" },
+        { "ADC", NULL, "ADC_PWR" },
+        { "DAC1OUT", "DAC1 Switch", "DAC" },
+        { "DAC2OUT", "DAC2 Switch", "DAC" },
+        { "DAC3OUT", "DAC3 Switch", "DAC" },
+        { "DAC4OUT", "DAC4 Switch", "DAC" },
+        { "ADC", "ADC1 Switch", "ADC1IN" },
+        { "ADC", "ADC2 Switch", "ADC2IN" },
+};
+
+/*
+ * DAI ops entries
+ */
+
+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 = (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);
+
+        return 0;
+}
+
+static int ad1938_set_tdm_slot(struct snd_soc_dai *dai, unsigned int tx_mask,
+                               unsigned int 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);
+
+        dac_reg &= ~AD1938_DAC_CHAN_MASK;
+        adc_reg &= ~AD1938_ADC_CHAN_MASK;
+
+        switch (slots) {
+        case 2:
+                dac_reg |= AD1938_DAC_2_CHANNELS << AD1938_DAC_CHAN_SHFT;
+                adc_reg |= AD1938_ADC_2_CHANNELS << AD1938_ADC_CHAN_SHFT;
+                break;
+        case 4:
+                dac_reg |= AD1938_DAC_4_CHANNELS << AD1938_DAC_CHAN_SHFT;
+                adc_reg |= AD1938_ADC_4_CHANNELS << AD1938_ADC_CHAN_SHFT;
+                break;
+        case 8:
+                dac_reg |= AD1938_DAC_8_CHANNELS << AD1938_DAC_CHAN_SHFT;
+                adc_reg |= AD1938_ADC_8_CHANNELS << AD1938_ADC_CHAN_SHFT;
+                break;
+        case 16:
+                dac_reg |= AD1938_DAC_16_CHANNELS << AD1938_DAC_CHAN_SHFT;
+                adc_reg |= AD1938_ADC_16_CHANNELS << AD1938_ADC_CHAN_SHFT;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        codec->write(codec, AD1938_DAC_CTRL1, dac_reg);
+        codec->write(codec, AD1938_ADC_CTRL2, adc_reg);
+
+        return 0;
+}
+
+static int ad1938_set_dai_fmt(struct snd_soc_dai *codec_dai,
+                unsigned int fmt)
+{
+        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);
+
+        /* 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)
+         */
+        switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
+        case SND_SOC_DAIFMT_I2S:
+                adc_reg &= ~AD1938_ADC_SERFMT_MASK;
+                adc_reg |= AD1938_ADC_SERFMT_TDM;
+                break;
+        case SND_SOC_DAIFMT_DSP_A:
+                adc_reg &= ~AD1938_ADC_SERFMT_MASK;
+                adc_reg |= AD1938_ADC_SERFMT_AUX;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
+        case SND_SOC_DAIFMT_NB_NF: /* normal bit clock + frame */
+                adc_reg &= ~AD1938_ADC_LEFT_HIGH;
+                adc_reg &= ~AD1938_ADC_BCLK_INV;
+                dac_reg &= ~AD1938_DAC_LEFT_HIGH;
+                dac_reg &= ~AD1938_DAC_BCLK_INV;
+                break;
+        case SND_SOC_DAIFMT_NB_IF: /* normal bclk + invert frm */
+                adc_reg |= AD1938_ADC_LEFT_HIGH;
+                adc_reg &= ~AD1938_ADC_BCLK_INV;
+                dac_reg |= AD1938_DAC_LEFT_HIGH;
+                dac_reg &= ~AD1938_DAC_BCLK_INV;
+                break;
+        case SND_SOC_DAIFMT_IB_NF: /* invert bclk + normal frm */
+                adc_reg &= ~AD1938_ADC_LEFT_HIGH;
+                adc_reg |= AD1938_ADC_BCLK_INV;
+                dac_reg &= ~AD1938_DAC_LEFT_HIGH;
+                dac_reg |= AD1938_DAC_BCLK_INV;
+                break;
+
+        case SND_SOC_DAIFMT_IB_IF: /* invert bclk + frm */
+                adc_reg |= AD1938_ADC_LEFT_HIGH;
+                adc_reg |= AD1938_ADC_BCLK_INV;
+                dac_reg |= AD1938_DAC_LEFT_HIGH;
+                dac_reg |= AD1938_DAC_BCLK_INV;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
+        case SND_SOC_DAIFMT_CBM_CFM: /* codec clk & frm master */
+                adc_reg |= AD1938_ADC_LCR_MASTER;
+                adc_reg |= AD1938_ADC_BCLK_MASTER;
+                dac_reg |= AD1938_DAC_LCR_MASTER;
+                dac_reg |= AD1938_DAC_BCLK_MASTER;
+                break;
+        case SND_SOC_DAIFMT_CBS_CFM: /* codec clk slave & frm master */
+                adc_reg |= AD1938_ADC_LCR_MASTER;
+                adc_reg &= ~AD1938_ADC_BCLK_MASTER;
+                dac_reg |= AD1938_DAC_LCR_MASTER;
+                dac_reg &= ~AD1938_DAC_BCLK_MASTER;
+                break;
+        case SND_SOC_DAIFMT_CBM_CFS: /* codec clk master & frame slave */
+                adc_reg &= ~AD1938_ADC_LCR_MASTER;
+                adc_reg |= AD1938_ADC_BCLK_MASTER;
+                dac_reg &= ~AD1938_DAC_LCR_MASTER;
+                dac_reg |= AD1938_DAC_BCLK_MASTER;
+                break;
+        case SND_SOC_DAIFMT_CBS_CFS: /* codec clk & frm slave */
+                adc_reg &= ~AD1938_ADC_LCR_MASTER;
+                adc_reg &= ~AD1938_ADC_BCLK_MASTER;
+                dac_reg &= ~AD1938_DAC_LCR_MASTER;
+                dac_reg &= ~AD1938_DAC_BCLK_MASTER;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        codec->write(codec, AD1938_ADC_CTRL2, adc_reg);
+        codec->write(codec, AD1938_DAC_CTRL1, dac_reg);
+
+        return 0;
+}
+
+static int ad1938_hw_params(struct snd_pcm_substream *substream,
+                struct snd_pcm_hw_params *params,
+                struct snd_soc_dai *dai)
+{
+        int word_len = 0, reg = 0;
+
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_device *socdev = rtd->socdev;
+        struct snd_soc_codec *codec = socdev->card->codec;
+
+        /* bit size */
+        switch (params_format(params)) {
+        case SNDRV_PCM_FORMAT_S16_LE:
+                word_len = 3;
+                break;
+        case SNDRV_PCM_FORMAT_S20_3LE:
+                word_len = 1;
+                break;
+        case SNDRV_PCM_FORMAT_S24_LE:
+        case SNDRV_PCM_FORMAT_S32_LE:
+                word_len = 0;
+                break;
+        }
+
+        reg = codec->read(codec, AD1938_DAC_CTRL2);
+        reg = (reg & (~AD1938_DAC_WORD_LEN_MASK)) | word_len;
+        codec->write(codec, AD1938_DAC_CTRL2, reg);
+
+        reg = codec->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;
+        }
+
+        return 0;
+}
+
+static int __devinit ad1938_spi_probe(struct spi_device *spi)
+{
+        struct snd_soc_codec *codec;
+        struct ad1938_priv *ad1938;
+
+        ad1938 = kzalloc(sizeof(struct ad1938_priv), GFP_KERNEL);
+        if (ad1938 == NULL)
+                return -ENOMEM;
+
+        codec = &ad1938->codec;
+        codec->control_data = spi;
+        codec->dev = &spi->dev;
+
+        dev_set_drvdata(&spi->dev, ad1938);
+
+        return ad1938_register(ad1938);
+}
+
+static int __devexit ad1938_spi_remove(struct spi_device *spi)
+{
+        struct ad1938_priv *ad1938 = dev_get_drvdata(&spi->dev);
+
+        ad1938_unregister(ad1938);
+        return 0;
+}
+
+static struct spi_driver ad1938_spi_driver = {
+        .driver = {
+                .name   = "ad1938",
+                .bus    = &spi_bus_type,
+                .owner  = THIS_MODULE,
+        },
+        .probe          = ad1938_spi_probe,
+        .remove         = __devexit_p(ad1938_spi_remove),
+};
+
+static struct snd_soc_dai_ops ad1938_dai_ops = {
+        .hw_params = ad1938_hw_params,
+        .digital_mute = ad1938_mute,
+        .set_tdm_slot = ad1938_set_tdm_slot,
+        .set_fmt = ad1938_set_dai_fmt,
+};
+
+/* codec DAI instance */
+struct snd_soc_dai ad1938_dai = {
+        .name = "AD1938",
+        .playback = {
+                .stream_name = "Playback",
+                .channels_min = 2,
+                .channels_max = 8,
+                .rates = SNDRV_PCM_RATE_48000,
+                .formats = SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S16_LE |
+                        SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S24_LE,
+        },
+        .capture = {
+                .stream_name = "Capture",
+                .channels_min = 2,
+                .channels_max = 4,
+                .rates = SNDRV_PCM_RATE_48000,
+                .formats = SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S16_LE |
+                        SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S24_LE,
+        },
+        .ops = &ad1938_dai_ops,
+};
+EXPORT_SYMBOL_GPL(ad1938_dai);
+
+static int ad1938_register(struct ad1938_priv *ad1938)
+{
+        int ret;
+        struct snd_soc_codec *codec = &ad1938->codec;
+
+        if (ad1938_codec) {
+                dev_err(codec->dev, "Another ad1938 is registered\n");
+                return -EINVAL;
+        }
+
+        mutex_init(&codec->mutex);
+        INIT_LIST_HEAD(&codec->dapm_widgets);
+        INIT_LIST_HEAD(&codec->dapm_paths);
+        codec->private_data = ad1938;
+        codec->reg_cache = ad1938->reg_cache;
+        codec->reg_cache_size = AD1938_NUM_REGS;
+        codec->name = "AD1938";
+        codec->owner = THIS_MODULE;
+        codec->dai = &ad1938_dai;
+        codec->num_dai = 1;
+        codec->write = ad1938_write_reg;
+        codec->read = ad1938_read_reg_cache;
+        INIT_LIST_HEAD(&codec->dapm_widgets);
+        INIT_LIST_HEAD(&codec->dapm_paths);
+
+        ad1938_dai.dev = codec->dev;
+        ad1938_codec = codec;
+
+        /* default setting for ad1938 */
+
+        /* unmute dac channels */
+        codec->write(codec, AD1938_DAC_CHNL_MUTE, 0x0);
+        /* de-emphasis: 48kHz, powedown dac */
+        codec->write(codec, AD1938_DAC_CTRL2, 0x1A);
+        /* powerdown dac, dac in tdm mode */
+        codec->write(codec, AD1938_DAC_CTRL0, 0x41);
+        /* high-pass filter enable */
+        codec->write(codec, AD1938_ADC_CTRL0, 0x3);
+        /* sata delay=1, adc aux mode */
+        codec->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);
+
+        ret = snd_soc_register_codec(codec);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to register codec: %d\n", ret);
+                kfree(ad1938);
+                return ret;
+        }
+
+        ret = snd_soc_register_dai(&ad1938_dai);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to register DAI: %d\n", ret);
+                snd_soc_unregister_codec(codec);
+                kfree(ad1938);
+                return ret;
+        }
+
+        return 0;
+}
+
+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);
+        ad1938_codec = NULL;
+}
+
+static int ad1938_probe(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec;
+        int ret = 0;
+
+        if (ad1938_codec == NULL) {
+                dev_err(&pdev->dev, "Codec device not registered\n");
+                return -ENODEV;
+        }
+
+        socdev->card->codec = ad1938_codec;
+        codec = ad1938_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, ad1938_snd_controls,
+                             ARRAY_SIZE(ad1938_snd_controls));
+        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;
+}
+
+/* power down chip */
+static int ad1938_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;
+}
+
+#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);
+
+static int __init ad1938_init(void)
+{
+        int ret;
+
+        ret = spi_register_driver(&ad1938_spi_driver);
+        if (ret != 0) {
+                printk(KERN_ERR "Failed to register ad1938 SPI driver: %d\n",
+                                ret);
+        }
+
+        return ret;
+}
+module_init(ad1938_init);
+
+static void __exit ad1938_exit(void)
+{
+        spi_unregister_driver(&ad1938_spi_driver);
+}
+module_exit(ad1938_exit);
+
+MODULE_DESCRIPTION("ASoC ad1938 driver");
+MODULE_AUTHOR("Barry Song ");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/codecs/ad1938.h b/sound/soc/codecs/ad1938.h
new file mode 100644
index 000000000000..fe3c48cd2d5b
--- /dev/null
+++ b/sound/soc/codecs/ad1938.h
@@ -0,0 +1,100 @@
+/*
+ * File:         sound/soc/codecs/ad1836.h
+ * Based on:
+ * Author:       Barry Song <Barry.Song@analog.com>
+ *
+ * Created:      May 25, 2009
+ * Description:  definitions for AD1938 registers
+ *
+ * Modified:
+ *
+ * Bugs:         Enter bugs at http://blackfin.uclinux.org/
+ *
+ * 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, see the file COPYING, or write
+ * to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef __AD1938_H__
+#define __AD1938_H__
+
+#define AD1938_PLL_CLK_CTRL0    0
+#define AD1938_PLL_POWERDOWN           0x01
+#define AD1938_PLL_CLK_CTRL1    1
+#define AD1938_DAC_CTRL0        2
+#define AD1938_DAC_POWERDOWN           0x01
+#define AD1938_DAC_SERFMT_MASK          0xC0
+#define AD1938_DAC_SERFMT_STEREO        (0 << 6)
+#define AD1938_DAC_SERFMT_TDM           (1 << 6)
+#define AD1938_DAC_CTRL1        3
+#define AD1938_DAC_2_CHANNELS   0
+#define AD1938_DAC_4_CHANNELS   1
+#define AD1938_DAC_8_CHANNELS   2
+#define AD1938_DAC_16_CHANNELS  3
+#define AD1938_DAC_CHAN_SHFT    1
+#define AD1938_DAC_CHAN_MASK    (3 << AD1938_DAC_CHAN_SHFT)
+#define AD1938_DAC_LCR_MASTER   (1 << 4)
+#define AD1938_DAC_BCLK_MASTER  (1 << 5)
+#define AD1938_DAC_LEFT_HIGH    (1 << 3)
+#define AD1938_DAC_BCLK_INV     (1 << 7)
+#define AD1938_DAC_CTRL2        4
+#define AD1938_DAC_WORD_LEN_MASK        0xC
+#define AD1938_DAC_MASTER_MUTE  1
+#define AD1938_DAC_CHNL_MUTE    5
+#define AD1938_DACL1_MUTE       0
+#define AD1938_DACR1_MUTE       1
+#define AD1938_DACL2_MUTE       2
+#define AD1938_DACR2_MUTE       3
+#define AD1938_DACL3_MUTE       4
+#define AD1938_DACR3_MUTE       5
+#define AD1938_DACL4_MUTE       6
+#define AD1938_DACR4_MUTE       7
+#define AD1938_DAC_L1_VOL       6
+#define AD1938_DAC_R1_VOL       7
+#define AD1938_DAC_L2_VOL       8
+#define AD1938_DAC_R2_VOL       9
+#define AD1938_DAC_L3_VOL       10
+#define AD1938_DAC_R3_VOL       11
+#define AD1938_DAC_L4_VOL       12
+#define AD1938_DAC_R4_VOL       13
+#define AD1938_ADC_CTRL0        14
+#define AD1938_ADC_POWERDOWN           0x01
+#define AD1938_ADC_HIGHPASS_FILTER      1
+#define AD1938_ADCL1_MUTE               2
+#define AD1938_ADCR1_MUTE               3
+#define AD1938_ADCL2_MUTE               4
+#define AD1938_ADCR2_MUTE               5
+#define AD1938_ADC_CTRL1        15
+#define AD1938_ADC_SERFMT_MASK          0x60
+#define AD1938_ADC_SERFMT_STEREO        (0 << 5)
+#define AD1938_ADC_SERFMT_TDM           (1 << 2)
+#define AD1938_ADC_SERFMT_AUX           (2 << 5)
+#define AD1938_ADC_WORD_LEN_MASK        0x3
+#define AD1938_ADC_CTRL2        16
+#define AD1938_ADC_2_CHANNELS   0
+#define AD1938_ADC_4_CHANNELS   1
+#define AD1938_ADC_8_CHANNELS   2
+#define AD1938_ADC_16_CHANNELS  3
+#define AD1938_ADC_CHAN_SHFT    4
+#define AD1938_ADC_CHAN_MASK    (3 << AD1938_ADC_CHAN_SHFT)
+#define AD1938_ADC_LCR_MASTER   (1 << 3)
+#define AD1938_ADC_BCLK_MASTER  (1 << 6)
+#define AD1938_ADC_LEFT_HIGH    (1 << 2)
+#define AD1938_ADC_BCLK_INV     (1 << 1)
+
+#define AD1938_NUM_REGS          17
+
+extern struct snd_soc_dai ad1938_dai;
+extern struct snd_soc_codec_device soc_codec_dev_ad1938;
+#endif
diff --git a/sound/soc/codecs/ad1980.c b/sound/soc/codecs/ad1980.c
index ddb3b08ac23c..d7440a982d22 100644
--- a/sound/soc/codecs/ad1980.c
+++ b/sound/soc/codecs/ad1980.c
@@ -137,13 +137,13 @@ struct snd_soc_dai ad1980_dai = {
                 .channels_min = 2,
                 .channels_max = 6,
                 .rates = SNDRV_PCM_RATE_48000,
-                .formats = SNDRV_PCM_FMTBIT_S16_LE, },
+                .formats = SND_SOC_STD_AC97_FMTS, },
         .capture = {
                 .stream_name = "Capture",
                 .channels_min = 2,
                 .channels_max = 2,
                 .rates = SNDRV_PCM_RATE_48000,
-                .formats = SNDRV_PCM_FMTBIT_S16_LE, },
+                .formats = SND_SOC_STD_AC97_FMTS, },
 };
 EXPORT_SYMBOL_GPL(ad1980_dai);
 
diff --git a/sound/soc/codecs/ak4535.c b/sound/soc/codecs/ak4535.c
index dd3380202766..0abec0d29a96 100644
--- a/sound/soc/codecs/ak4535.c
+++ b/sound/soc/codecs/ak4535.c
@@ -59,21 +59,6 @@ static inline unsigned int ak4535_read_reg_cache(struct snd_soc_codec *codec,
         return cache[reg];
 }
 
-static inline unsigned int ak4535_read(struct snd_soc_codec *codec,
-        unsigned int reg)
-{
-        u8 data;
-        data = reg;
-
-        if (codec->hw_write(codec->control_data, &data, 1) != 1)
-                return -EIO;
-
-        if (codec->hw_read(codec->control_data, &data, 1) != 1)
-                return -EIO;
-
-        return data;
-};
-
 /*
  * write ak4535 register cache
  */
@@ -635,7 +620,6 @@ static int ak4535_probe(struct platform_device *pdev)
 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
         if (setup->i2c_address) {
                 codec->hw_write = (hw_write_t)i2c_master_send;
-                codec->hw_read = (hw_read_t)i2c_master_recv;
                 ret = ak4535_add_i2c_device(pdev, setup);
         }
 #endif
diff --git a/sound/soc/codecs/cs4270.c b/sound/soc/codecs/cs4270.c
index 7fa09a387622..ca1e24a8f12a 100644
--- a/sound/soc/codecs/cs4270.c
+++ b/sound/soc/codecs/cs4270.c
@@ -18,7 +18,7 @@
  * - The machine driver's 'startup' function must call
  *   cs4270_set_dai_sysclk() with the value of MCLK.
  * - Only I2S and left-justified modes are supported
- * - Power management is not supported
+ * - Power management is supported
  */
 
 #include <linux/module.h>
@@ -27,6 +27,7 @@
 #include <sound/soc.h>
 #include <sound/initval.h>
 #include <linux/i2c.h>
+#include <linux/delay.h>
 
 #include "cs4270.h"
 
@@ -56,6 +57,7 @@
 #define CS4270_FIRSTREG 0x01
 #define CS4270_LASTREG  0x08
 #define CS4270_NUMREGS  (CS4270_LASTREG - CS4270_FIRSTREG + 1)
+#define CS4270_I2C_INCR 0x80
 
 /* Bit masks for the CS4270 registers */
 #define CS4270_CHIPID_ID        0xF0
@@ -64,6 +66,8 @@
 #define CS4270_PWRCTL_PDN_ADC   0x20
 #define CS4270_PWRCTL_PDN_DAC   0x02
 #define CS4270_PWRCTL_PDN       0x01
+#define CS4270_PWRCTL_PDN_ALL   \
+        (CS4270_PWRCTL_PDN_ADC | CS4270_PWRCTL_PDN_DAC | CS4270_PWRCTL_PDN)
 #define CS4270_MODE_SPEED_MASK  0x30
 #define CS4270_MODE_1X          0x00
 #define CS4270_MODE_2X          0x10
@@ -109,6 +113,7 @@ struct cs4270_private {
         unsigned int mclk; /* Input frequency of the MCLK pin */
         unsigned int mode; /* The mode (I2S or left-justified) */
         unsigned int slave_mode;
+        unsigned int manual_mute;
 };
 
 /**
@@ -295,7 +300,7 @@ static int cs4270_fill_cache(struct snd_soc_codec *codec)
         s32 length;
 
         length = i2c_smbus_read_i2c_block_data(i2c_client,
-                CS4270_FIRSTREG | 0x80, CS4270_NUMREGS, cache);
+                CS4270_FIRSTREG | CS4270_I2C_INCR, CS4270_NUMREGS, cache);
 
         if (length != CS4270_NUMREGS) {
                 dev_err(codec->dev, "i2c read failure, addr=0x%x\n",
@@ -453,7 +458,7 @@ static int cs4270_hw_params(struct snd_pcm_substream *substream,
 }
 
 /**
- * cs4270_mute - enable/disable the CS4270 external mute
+ * cs4270_dai_mute - enable/disable the CS4270 external mute
  * @dai: the SOC DAI
  * @mute: 0 = disable mute, 1 = enable mute
  *
@@ -462,21 +467,52 @@ static int cs4270_hw_params(struct snd_pcm_substream *substream,
  * board does not have the MUTEA or MUTEB pins connected to such circuitry,
  * then this function will do nothing.
  */
-static int cs4270_mute(struct snd_soc_dai *dai, int mute)
+static int cs4270_dai_mute(struct snd_soc_dai *dai, int mute)
 {
         struct snd_soc_codec *codec = dai->codec;
+        struct cs4270_private *cs4270 = codec->private_data;
         int reg6;
 
         reg6 = snd_soc_read(codec, CS4270_MUTE);
 
         if (mute)
                 reg6 |= CS4270_MUTE_DAC_A | CS4270_MUTE_DAC_B;
-        else
+        else {
                 reg6 &= ~(CS4270_MUTE_DAC_A | CS4270_MUTE_DAC_B);
+                reg6 |= cs4270->manual_mute;
+        }
 
         return snd_soc_write(codec, CS4270_MUTE, reg6);
 }
 
+/**
+ * cs4270_soc_put_mute - put callback for the 'Master Playback switch'
+ *                       alsa control.
+ * @kcontrol: mixer control
+ * @ucontrol: control element information
+ *
+ * This function basically passes the arguments on to the generic
+ * snd_soc_put_volsw() function and saves the mute information in
+ * our private data structure. This is because we want to prevent
+ * cs4270_dai_mute() neglecting the user's decision to manually
+ * mute the codec's output.
+ *
+ * Returns 0 for success.
+ */
+static int cs4270_soc_put_mute(struct snd_kcontrol *kcontrol,
+                                struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct cs4270_private *cs4270 = codec->private_data;
+        int left = !ucontrol->value.integer.value[0];
+        int right = !ucontrol->value.integer.value[1];
+
+        cs4270->manual_mute = (left ? CS4270_MUTE_DAC_A : 0) |
+                              (right ? CS4270_MUTE_DAC_B : 0);
+
+        return snd_soc_put_volsw(kcontrol, ucontrol);
+}
+
 /* A list of non-DAPM controls that the CS4270 supports */
 static const struct snd_kcontrol_new cs4270_snd_controls[] = {
         SOC_DOUBLE_R("Master Playback Volume",
@@ -486,7 +522,9 @@ static const struct snd_kcontrol_new cs4270_snd_controls[] = {
         SOC_SINGLE("Zero Cross Switch", CS4270_TRANS, 5, 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, 0)
+        SOC_DOUBLE("Master Capture Switch", CS4270_MUTE, 3, 4, 1, 1),
+        SOC_DOUBLE_EXT("Master Playback Switch", CS4270_MUTE, 0, 1, 1, 1,
+                snd_soc_get_volsw, cs4270_soc_put_mute),
 };
 
 /*
@@ -506,7 +544,7 @@ static struct snd_soc_dai_ops cs4270_dai_ops = {
         .hw_params      = cs4270_hw_params,
         .set_sysclk     = cs4270_set_dai_sysclk,
         .set_fmt        = cs4270_set_dai_fmt,
-        .digital_mute   = cs4270_mute,
+        .digital_mute   = cs4270_dai_mute,
 };
 
 struct snd_soc_dai cs4270_dai = {
@@ -753,6 +791,74 @@ static struct i2c_device_id cs4270_id[] = {
 };
 MODULE_DEVICE_TABLE(i2c, cs4270_id);
 
+#ifdef CONFIG_PM
+
+/* This suspend/resume implementation can handle both - a simple standby
+ * where the codec remains powered, and a full suspend, where the voltage
+ * domain the codec is connected to is teared down and/or any other hardware
+ * reset condition is asserted.
+ *
+ * The codec's own power saving features are enabled in the suspend callback,
+ * and all registers are written back to the hardware when resuming.
+ */
+
+static int cs4270_i2c_suspend(struct i2c_client *client, 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);
+}
+
+static int cs4270_i2c_resume(struct i2c_client *client)
+{
+        struct cs4270_private *cs4270 = i2c_get_clientdata(client);
+        struct snd_soc_codec *codec = &cs4270->codec;
+
+        return snd_soc_resume_device(codec->dev);
+}
+
+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;
+
+        return snd_soc_write(codec, CS4270_PWRCTL, reg);
+}
+
+static int cs4270_soc_resume(struct platform_device *pdev)
+{
+        struct snd_soc_codec *codec = cs4270_codec;
+        struct i2c_client *i2c_client = codec->control_data;
+        int reg;
+
+        /* In case the device was put to hard reset during sleep, we need to
+         * wait 500ns here before any I2C communication. */
+        ndelay(500);
+
+        /* first restore the entire register cache ... */
+        for (reg = CS4270_FIRSTREG; reg <= CS4270_LASTREG; reg++) {
+                u8 val = snd_soc_read(codec, reg);
+
+                if (i2c_smbus_write_byte_data(i2c_client, reg, val)) {
+                        dev_err(codec->dev, "i2c write failed\n");
+                        return -EIO;
+                }
+        }
+
+        /* ... then disable the power-down bits */
+        reg = snd_soc_read(codec, CS4270_PWRCTL);
+        reg &= ~CS4270_PWRCTL_PDN_ALL;
+
+        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 */
+
 /*
  * cs4270_i2c_driver - I2C device identification
  *
@@ -767,6 +873,8 @@ 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,
 };
 
 /*
@@ -777,7 +885,9 @@ static struct i2c_driver cs4270_i2c_driver = {
  */
 struct snd_soc_codec_device soc_codec_device_cs4270 = {
         .probe =        cs4270_probe,
-        .remove =       cs4270_remove
+        .remove =       cs4270_remove,
+        .suspend =      cs4270_soc_suspend,
+        .resume =       cs4270_soc_resume,
 };
 EXPORT_SYMBOL_GPL(soc_codec_device_cs4270);
 
diff --git a/sound/soc/codecs/cx20442.c b/sound/soc/codecs/cx20442.c
new file mode 100644
index 000000000000..38eac9c866e1
--- /dev/null
+++ b/sound/soc/codecs/cx20442.c
@@ -0,0 +1,501 @@
+/*
+ * cx20442.c  --  CX20442 ALSA Soc Audio driver
+ *
+ * Copyright 2009 Janusz Krzysztofik <jkrzyszt@tis.icnet.pl>
+ *
+ * Initially based on sound/soc/codecs/wm8400.c
+ * Copyright 2008, 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 as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ */
+
+#include <linux/tty.h>
+
+#include <sound/core.h>
+#include <sound/initval.h>
+#include <sound/soc-dapm.h>
+
+#include "cx20442.h"
+
+
+struct cx20442_priv {
+        struct snd_soc_codec codec;
+        u8 reg_cache[1];
+};
+
+#define CX20442_PM              0x0
+
+#define CX20442_TELIN           0
+#define CX20442_TELOUT          1
+#define CX20442_MIC             2
+#define CX20442_SPKOUT          3
+#define CX20442_AGC             4
+
+static const struct snd_soc_dapm_widget cx20442_dapm_widgets[] = {
+        SND_SOC_DAPM_OUTPUT("TELOUT"),
+        SND_SOC_DAPM_OUTPUT("SPKOUT"),
+        SND_SOC_DAPM_OUTPUT("AGCOUT"),
+
+        SND_SOC_DAPM_MIXER("SPKOUT Mixer", SND_SOC_NOPM, 0, 0, NULL, 0),
+
+        SND_SOC_DAPM_PGA("TELOUT Amp", CX20442_PM, CX20442_TELOUT, 0, NULL, 0),
+        SND_SOC_DAPM_PGA("SPKOUT Amp", CX20442_PM, CX20442_SPKOUT, 0, NULL, 0),
+        SND_SOC_DAPM_PGA("SPKOUT AGC", CX20442_PM, CX20442_AGC, 0, NULL, 0),
+
+        SND_SOC_DAPM_DAC("DAC", "Playback", SND_SOC_NOPM, 0, 0),
+        SND_SOC_DAPM_ADC("ADC", "Capture", SND_SOC_NOPM, 0, 0),
+
+        SND_SOC_DAPM_MIXER("Input Mixer", SND_SOC_NOPM, 0, 0, NULL, 0),
+
+        SND_SOC_DAPM_MICBIAS("TELIN Bias", CX20442_PM, CX20442_TELIN, 0),
+        SND_SOC_DAPM_MICBIAS("MIC Bias", CX20442_PM, CX20442_MIC, 0),
+
+        SND_SOC_DAPM_PGA("MIC AGC", CX20442_PM, CX20442_AGC, 0, NULL, 0),
+
+        SND_SOC_DAPM_INPUT("TELIN"),
+        SND_SOC_DAPM_INPUT("MIC"),
+        SND_SOC_DAPM_INPUT("AGCIN"),
+};
+
+static const struct snd_soc_dapm_route cx20442_audio_map[] = {
+        {"TELOUT", NULL, "TELOUT Amp"},
+
+        {"SPKOUT", NULL, "SPKOUT Mixer"},
+        {"SPKOUT Mixer", NULL, "SPKOUT Amp"},
+
+        {"TELOUT Amp", NULL, "DAC"},
+        {"SPKOUT Amp", NULL, "DAC"},
+
+        {"SPKOUT Mixer", NULL, "SPKOUT AGC"},
+        {"SPKOUT AGC", NULL, "AGCIN"},
+
+        {"AGCOUT", NULL, "MIC AGC"},
+        {"MIC AGC", NULL, "MIC"},
+
+        {"MIC Bias", NULL, "MIC"},
+        {"Input Mixer", NULL, "MIC Bias"},
+
+        {"TELIN Bias", NULL, "TELIN"},
+        {"Input Mixer", NULL, "TELIN Bias"},
+
+        {"ADC", NULL, "Input Mixer"},
+};
+
+static int cx20442_add_widgets(struct snd_soc_codec *codec)
+{
+        snd_soc_dapm_new_controls(codec, cx20442_dapm_widgets,
+                                  ARRAY_SIZE(cx20442_dapm_widgets));
+
+        snd_soc_dapm_add_routes(codec, cx20442_audio_map,
+                                ARRAY_SIZE(cx20442_audio_map));
+
+        snd_soc_dapm_new_widgets(codec);
+        return 0;
+}
+
+static unsigned int cx20442_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];
+}
+
+enum v253_vls {
+        V253_VLS_NONE = 0,
+        V253_VLS_T,
+        V253_VLS_L,
+        V253_VLS_LT,
+        V253_VLS_S,
+        V253_VLS_ST,
+        V253_VLS_M,
+        V253_VLS_MST,
+        V253_VLS_S1,
+        V253_VLS_S1T,
+        V253_VLS_MS1T,
+        V253_VLS_M1,
+        V253_VLS_M1ST,
+        V253_VLS_M1S1T,
+        V253_VLS_H,
+        V253_VLS_HT,
+        V253_VLS_MS,
+        V253_VLS_MS1,
+        V253_VLS_M1S,
+        V253_VLS_M1S1,
+        V253_VLS_TEST,
+};
+
+static int cx20442_pm_to_v253_vls(u8 value)
+{
+        switch (value & ~(1 << CX20442_AGC)) {
+        case 0:
+                return V253_VLS_T;
+        case (1 << CX20442_SPKOUT):
+        case (1 << CX20442_MIC):
+        case (1 << CX20442_SPKOUT) | (1 << CX20442_MIC):
+                return V253_VLS_M1S1;
+        case (1 << CX20442_TELOUT):
+        case (1 << CX20442_TELIN):
+        case (1 << CX20442_TELOUT) | (1 << CX20442_TELIN):
+                return V253_VLS_L;
+        case (1 << CX20442_TELOUT) | (1 << CX20442_MIC):
+                return V253_VLS_NONE;
+        }
+        return -EINVAL;
+}
+static int cx20442_pm_to_v253_vsp(u8 value)
+{
+        switch (value & ~(1 << CX20442_AGC)) {
+        case (1 << CX20442_SPKOUT):
+        case (1 << CX20442_MIC):
+        case (1 << CX20442_SPKOUT) | (1 << CX20442_MIC):
+                return (bool)(value & (1 << CX20442_AGC));
+        }
+        return (value & (1 << CX20442_AGC)) ? -EINVAL : 0;
+}
+
+static int cx20442_write(struct snd_soc_codec *codec, unsigned int reg,
+                                                        unsigned int value)
+{
+        u8 *reg_cache = codec->reg_cache;
+        int vls, vsp, old, len;
+        char buf[18];
+
+        if (reg >= codec->reg_cache_size)
+                return -EINVAL;
+
+        /* hw_write and control_data pointers required for talking to the modem
+         * are expected to be set by the line discipline initialization code */
+        if (!codec->hw_write || !codec->control_data)
+                return -EIO;
+
+        old = reg_cache[reg];
+        reg_cache[reg] = value;
+
+        vls = cx20442_pm_to_v253_vls(value);
+        if (vls < 0)
+                return vls;
+
+        vsp = cx20442_pm_to_v253_vsp(value);
+        if (vsp < 0)
+                return vsp;
+
+        if ((vls == V253_VLS_T) ||
+                        (vls == cx20442_pm_to_v253_vls(old))) {
+                if (vsp == cx20442_pm_to_v253_vsp(old))
+                        return 0;
+                len = snprintf(buf, ARRAY_SIZE(buf), "at+vsp=%d\r", vsp);
+        } else if (vsp == cx20442_pm_to_v253_vsp(old))
+                len = snprintf(buf, ARRAY_SIZE(buf), "at+vls=%d\r", vls);
+        else
+                len = snprintf(buf, ARRAY_SIZE(buf),
+                                        "at+vls=%d;+vsp=%d\r", vls, vsp);
+
+        if (unlikely(len > (ARRAY_SIZE(buf) - 1)))
+                return -ENOMEM;
+
+        dev_dbg(codec->dev, "%s: %s\n", __func__, buf);
+        if (codec->hw_write(codec->control_data, buf, len) != len)
+                return -EIO;
+
+        return 0;
+}
+
+
+/* Moved up here as line discipline referres it during initialization */
+static struct snd_soc_codec *cx20442_codec;
+
+
+/*
+ * Line discpline related code
+ *
+ * Any of the callback functions below can be used in two ways:
+ * 1) registerd by a machine driver as one of line discipline operations,
+ * 2) called from a machine's provided line discipline callback function
+ *    in case when extra machine specific code must be run as well.
+ */
+
+/* Modem init: echo off, digital speaker off, quiet off, voice mode */
+static const char *v253_init = "ate0m0q0+fclass=8\r";
+
+/* Line discipline .open() */
+static int v253_open(struct tty_struct *tty)
+{
+        struct snd_soc_codec *codec = cx20442_codec;
+        int ret, len = strlen(v253_init);
+
+        /* Doesn't make sense without write callback */
+        if (!tty->ops->write)
+                return -EINVAL;
+
+        /* Pass the codec structure address for use by other ldisc callbacks */
+        tty->disc_data = codec;
+
+        if (tty->ops->write(tty, v253_init, len) != len) {
+                ret = -EIO;
+                goto err;
+        }
+        /* Actual setup will be performed after the modem responds. */
+        return 0;
+err:
+        tty->disc_data = NULL;
+        return ret;
+}
+
+/* Line discipline .close() */
+static void v253_close(struct tty_struct *tty)
+{
+        struct snd_soc_codec *codec = tty->disc_data;
+
+        tty->disc_data = NULL;
+
+        if (!codec)
+                return;
+
+        /* Prevent the codec driver from further accessing the modem */
+        codec->hw_write = NULL;
+        codec->control_data = NULL;
+        codec->pop_time = 0;
+}
+
+/* Line discipline .hangup() */
+static int v253_hangup(struct tty_struct *tty)
+{
+        v253_close(tty);
+        return 0;
+}
+
+/* Line discipline .receive_buf() */
+static void v253_receive(struct tty_struct *tty,
+                                const unsigned char *cp, char *fp, int count)
+{
+        struct snd_soc_codec *codec = tty->disc_data;
+
+        if (!codec)
+                return;
+
+        if (!codec->control_data) {
+                /* First modem response, complete setup procedure */
+
+                /* Set up codec driver access to modem controls */
+                codec->control_data = tty;
+                codec->hw_write = (hw_write_t)tty->ops->write;
+                codec->pop_time = 1;
+        }
+}
+
+/* Line discipline .write_wakeup() */
+static void v253_wakeup(struct tty_struct *tty)
+{
+}
+
+struct tty_ldisc_ops v253_ops = {
+        .magic = TTY_LDISC_MAGIC,
+        .name = "cx20442",
+        .owner = THIS_MODULE,
+        .open = v253_open,
+        .close = v253_close,
+        .hangup = v253_hangup,
+        .receive_buf = v253_receive,
+        .write_wakeup = v253_wakeup,
+};
+EXPORT_SYMBOL_GPL(v253_ops);
+
+
+/*
+ * Codec DAI
+ */
+
+struct snd_soc_dai cx20442_dai = {
+        .name = "CX20442",
+        .playback = {
+                .stream_name = "Playback",
+                .channels_min = 1,
+                .channels_max = 1,
+                .rates = SNDRV_PCM_RATE_8000,
+                .formats = SNDRV_PCM_FMTBIT_S16_LE,
+        },
+        .capture = {
+                .stream_name = "Capture",
+                .channels_min = 1,
+                .channels_max = 1,
+                .rates = SNDRV_PCM_RATE_8000,
+                .formats = SNDRV_PCM_FMTBIT_S16_LE,
+        },
+};
+EXPORT_SYMBOL_GPL(cx20442_dai);
+
+static int cx20442_codec_probe(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec;
+        int ret;
+
+        if (!cx20442_codec) {
+                dev_err(&pdev->dev, "cx20442 not yet discovered\n");
+                return -ENODEV;
+        }
+        codec = cx20442_codec;
+
+        socdev->card->codec = codec;
+
+        /* register pcms */
+        ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "failed to create pcms\n");
+                goto pcm_err;
+        }
+
+        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;
+}
+
+/* power down chip */
+static int cx20442_codec_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 cx20442_codec_dev = {
+        .probe =        cx20442_codec_probe,
+        .remove =       cx20442_codec_remove,
+};
+EXPORT_SYMBOL_GPL(cx20442_codec_dev);
+
+static int cx20442_register(struct cx20442_priv *cx20442)
+{
+        struct snd_soc_codec *codec = &cx20442->codec;
+        int ret;
+
+        mutex_init(&codec->mutex);
+        INIT_LIST_HEAD(&codec->dapm_widgets);
+        INIT_LIST_HEAD(&codec->dapm_paths);
+
+        codec->name = "CX20442";
+        codec->owner = THIS_MODULE;
+        codec->private_data = cx20442;
+
+        codec->dai = &cx20442_dai;
+        codec->num_dai = 1;
+
+        codec->reg_cache = &cx20442->reg_cache;
+        codec->reg_cache_size = ARRAY_SIZE(cx20442->reg_cache);
+        codec->read = cx20442_read_reg_cache;
+        codec->write = cx20442_write;
+
+        codec->bias_level = SND_SOC_BIAS_OFF;
+
+        cx20442_dai.dev = codec->dev;
+
+        cx20442_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(&cx20442_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:
+        cx20442_codec = NULL;
+        kfree(cx20442);
+        return ret;
+}
+
+static void cx20442_unregister(struct cx20442_priv *cx20442)
+{
+        snd_soc_unregister_dai(&cx20442_dai);
+        snd_soc_unregister_codec(&cx20442->codec);
+
+        cx20442_codec = NULL;
+        kfree(cx20442);
+}
+
+static int cx20442_platform_probe(struct platform_device *pdev)
+{
+        struct cx20442_priv *cx20442;
+        struct snd_soc_codec *codec;
+
+        cx20442 = kzalloc(sizeof(struct cx20442_priv), GFP_KERNEL);
+        if (cx20442 == NULL)
+                return -ENOMEM;
+
+        codec = &cx20442->codec;
+
+        codec->control_data = NULL;
+        codec->hw_write = NULL;
+        codec->pop_time = 0;
+
+        codec->dev = &pdev->dev;
+        platform_set_drvdata(pdev, cx20442);
+
+        return cx20442_register(cx20442);
+}
+
+static int __exit cx20442_platform_remove(struct platform_device *pdev)
+{
+        struct cx20442_priv *cx20442 = platform_get_drvdata(pdev);
+
+        cx20442_unregister(cx20442);
+        return 0;
+}
+
+static struct platform_driver cx20442_platform_driver = {
+        .driver = {
+                .name = "cx20442",
+                .owner = THIS_MODULE,
+                },
+        .probe = cx20442_platform_probe,
+        .remove = __exit_p(cx20442_platform_remove),
+};
+
+static int __init cx20442_init(void)
+{
+        return platform_driver_register(&cx20442_platform_driver);
+}
+module_init(cx20442_init);
+
+static void __exit cx20442_exit(void)
+{
+        platform_driver_unregister(&cx20442_platform_driver);
+}
+module_exit(cx20442_exit);
+
+MODULE_DESCRIPTION("ASoC CX20442-11 voice modem codec driver");
+MODULE_AUTHOR("Janusz Krzysztofik");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:cx20442");
diff --git a/sound/soc/codecs/cx20442.h b/sound/soc/codecs/cx20442.h
new file mode 100644
index 000000000000..688a5eb62e17
--- /dev/null
+++ b/sound/soc/codecs/cx20442.h
@@ -0,0 +1,20 @@
+/*
+ * cx20442.h  --  audio driver for CX20442
+ *
+ * Copyright 2009 Janusz Krzysztofik <jkrzyszt@tis.icnet.pl>
+ *
+ *  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 _CX20442_CODEC_H
+#define _CX20442_CODEC_H
+
+extern struct snd_soc_dai cx20442_dai;
+extern struct snd_soc_codec_device cx20442_codec_dev;
+extern struct tty_ldisc_ops v253_ops;
+
+#endif
diff --git a/sound/soc/codecs/max9877.c b/sound/soc/codecs/max9877.c
new file mode 100644
index 000000000000..9e7e964a5fa3
--- /dev/null
+++ b/sound/soc/codecs/max9877.c
@@ -0,0 +1,308 @@
+/*
+ * max9877.c  --  amp driver for max9877
+ *
+ * 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 <sound/soc.h>
+#include <sound/tlv.h>
+
+#include "max9877.h"
+
+static struct i2c_client *i2c;
+
+static u8 max9877_regs[5] = { 0x40, 0x00, 0x00, 0x00, 0x49 };
+
+static void max9877_write_regs(void)
+{
+        unsigned int i;
+        u8 data[6];
+
+        data[0] = MAX9877_INPUT_MODE;
+        for (i = 0; i < ARRAY_SIZE(max9877_regs); i++)
+                data[i + 1] = max9877_regs[i];
+
+        if (i2c_master_send(i2c, data, 6) != 6)
+                dev_err(&i2c->dev, "i2c write failed\n");
+}
+
+static int max9877_get_reg(struct snd_kcontrol *kcontrol,
+                struct snd_ctl_elem_value *ucontrol)
+{
+        struct soc_mixer_control *mc =
+                (struct soc_mixer_control *)kcontrol->private_value;
+        unsigned int reg = mc->reg;
+        unsigned int shift = mc->shift;
+        unsigned int mask = mc->max;
+        unsigned int invert = mc->invert;
+
+        ucontrol->value.integer.value[0] = (max9877_regs[reg] >> shift) & mask;
+
+        if (invert)
+                ucontrol->value.integer.value[0] =
+                        mask - ucontrol->value.integer.value[0];
+
+        return 0;
+}
+
+static int max9877_set_reg(struct snd_kcontrol *kcontrol,
+                struct snd_ctl_elem_value *ucontrol)
+{
+        struct soc_mixer_control *mc =
+                (struct soc_mixer_control *)kcontrol->private_value;
+        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);
+
+        if (invert)
+                val = mask - val;
+
+        if (((max9877_regs[reg] >> shift) & mask) == val)
+                return 0;
+
+        max9877_regs[reg] &= ~(mask << shift);
+        max9877_regs[reg] |= val << shift;
+        max9877_write_regs();
+
+        return 1;
+}
+
+static int max9877_get_2reg(struct snd_kcontrol *kcontrol,
+                struct snd_ctl_elem_value *ucontrol)
+{
+        struct soc_mixer_control *mc =
+                (struct soc_mixer_control *)kcontrol->private_value;
+        unsigned int reg = mc->reg;
+        unsigned int reg2 = mc->rreg;
+        unsigned int shift = mc->shift;
+        unsigned int mask = mc->max;
+
+        ucontrol->value.integer.value[0] = (max9877_regs[reg] >> shift) & mask;
+        ucontrol->value.integer.value[1] = (max9877_regs[reg2] >> shift) & mask;
+
+        return 0;
+}
+
+static int max9877_set_2reg(struct snd_kcontrol *kcontrol,
+                struct snd_ctl_elem_value *ucontrol)
+{
+        struct soc_mixer_control *mc =
+                (struct soc_mixer_control *)kcontrol->private_value;
+        unsigned int reg = mc->reg;
+        unsigned int reg2 = mc->rreg;
+        unsigned int shift = mc->shift;
+        unsigned int mask = mc->max;
+        unsigned int val = (ucontrol->value.integer.value[0] & mask);
+        unsigned int val2 = (ucontrol->value.integer.value[1] & mask);
+        unsigned int change = 1;
+
+        if (((max9877_regs[reg] >> shift) & mask) == val)
+                change = 0;
+
+        if (((max9877_regs[reg2] >> shift) & mask) == val2)
+                change = 0;
+
+        if (change) {
+                max9877_regs[reg] &= ~(mask << shift);
+                max9877_regs[reg] |= val << shift;
+                max9877_regs[reg2] &= ~(mask << shift);
+                max9877_regs[reg2] |= val2 << shift;
+                max9877_write_regs();
+        }
+
+        return change;
+}
+
+static int max9877_get_out_mode(struct snd_kcontrol *kcontrol,
+                struct snd_ctl_elem_value *ucontrol)
+{
+        u8 value = max9877_regs[MAX9877_OUTPUT_MODE] & MAX9877_OUTMODE_MASK;
+
+        if (value)
+                value -= 1;
+
+        ucontrol->value.integer.value[0] = value;
+        return 0;
+}
+
+static int max9877_set_out_mode(struct snd_kcontrol *kcontrol,
+                struct snd_ctl_elem_value *ucontrol)
+{
+        u8 value = ucontrol->value.integer.value[0];
+
+        value += 1;
+
+        if ((max9877_regs[MAX9877_OUTPUT_MODE] & MAX9877_OUTMODE_MASK) == value)
+                return 0;
+
+        max9877_regs[MAX9877_OUTPUT_MODE] &= ~MAX9877_OUTMODE_MASK;
+        max9877_regs[MAX9877_OUTPUT_MODE] |= value;
+        max9877_write_regs();
+        return 1;
+}
+
+static int max9877_get_osc_mode(struct snd_kcontrol *kcontrol,
+                struct snd_ctl_elem_value *ucontrol)
+{
+        u8 value = (max9877_regs[MAX9877_OUTPUT_MODE] & MAX9877_OSC_MASK);
+
+        value = value >> MAX9877_OSC_OFFSET;
+
+        ucontrol->value.integer.value[0] = value;
+        return 0;
+}
+
+static int max9877_set_osc_mode(struct snd_kcontrol *kcontrol,
+                struct snd_ctl_elem_value *ucontrol)
+{
+        u8 value = ucontrol->value.integer.value[0];
+
+        value = value << MAX9877_OSC_OFFSET;
+        if ((max9877_regs[MAX9877_OUTPUT_MODE] & MAX9877_OSC_MASK) == value)
+                return 0;
+
+        max9877_regs[MAX9877_OUTPUT_MODE] &= ~MAX9877_OSC_MASK;
+        max9877_regs[MAX9877_OUTPUT_MODE] |= value;
+        max9877_write_regs();
+        return 1;
+}
+
+static const unsigned int max9877_pgain_tlv[] = {
+        TLV_DB_RANGE_HEAD(2),
+        0, 1, TLV_DB_SCALE_ITEM(0, 900, 0),
+        2, 2, TLV_DB_SCALE_ITEM(2000, 0, 0),
+};
+
+static const unsigned int max9877_output_tlv[] = {
+        TLV_DB_RANGE_HEAD(4),
+        0, 7, TLV_DB_SCALE_ITEM(-7900, 400, 1),
+        8, 15, TLV_DB_SCALE_ITEM(-4700, 300, 0),
+        16, 23, TLV_DB_SCALE_ITEM(-2300, 200, 0),
+        24, 31, TLV_DB_SCALE_ITEM(-700, 100, 0),
+};
+
+static const char *max9877_out_mode[] = {
+        "INA -> SPK",
+        "INA -> HP",
+        "INA -> SPK and HP",
+        "INB -> SPK",
+        "INB -> HP",
+        "INB -> SPK and HP",
+        "INA + INB -> SPK",
+        "INA + INB -> HP",
+        "INA + INB -> SPK and HP",
+};
+
+static const char *max9877_osc_mode[] = {
+        "1176KHz",
+        "1100KHz",
+        "700KHz",
+};
+
+static const struct soc_enum max9877_enum[] = {
+        SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(max9877_out_mode), max9877_out_mode),
+        SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(max9877_osc_mode), max9877_osc_mode),
+};
+
+static const struct snd_kcontrol_new max9877_controls[] = {
+        SOC_SINGLE_EXT_TLV("MAX9877 PGAINA Playback Volume",
+                        MAX9877_INPUT_MODE, 0, 2, 0,
+                        max9877_get_reg, max9877_set_reg, max9877_pgain_tlv),
+        SOC_SINGLE_EXT_TLV("MAX9877 PGAINB Playback Volume",
+                        MAX9877_INPUT_MODE, 2, 2, 0,
+                        max9877_get_reg, max9877_set_reg, max9877_pgain_tlv),
+        SOC_SINGLE_EXT_TLV("MAX9877 Amp Speaker Playback Volume",
+                        MAX9877_SPK_VOLUME, 0, 31, 0,
+                        max9877_get_reg, max9877_set_reg, max9877_output_tlv),
+        SOC_DOUBLE_R_EXT_TLV("MAX9877 Amp HP Playback Volume",
+                        MAX9877_HPL_VOLUME, MAX9877_HPR_VOLUME, 0, 31, 0,
+                        max9877_get_2reg, max9877_set_2reg, max9877_output_tlv),
+        SOC_SINGLE_EXT("MAX9877 INB Stereo Switch",
+                        MAX9877_INPUT_MODE, 4, 1, 1,
+                        max9877_get_reg, max9877_set_reg),
+        SOC_SINGLE_EXT("MAX9877 INA Stereo Switch",
+                        MAX9877_INPUT_MODE, 5, 1, 1,
+                        max9877_get_reg, max9877_set_reg),
+        SOC_SINGLE_EXT("MAX9877 Zero-crossing detection Switch",
+                        MAX9877_INPUT_MODE, 6, 1, 0,
+                        max9877_get_reg, max9877_set_reg),
+        SOC_SINGLE_EXT("MAX9877 Bypass Mode Switch",
+                        MAX9877_OUTPUT_MODE, 6, 1, 0,
+                        max9877_get_reg, max9877_set_reg),
+        SOC_SINGLE_EXT("MAX9877 Shutdown Mode Switch",
+                        MAX9877_OUTPUT_MODE, 7, 1, 1,
+                        max9877_get_reg, max9877_set_reg),
+        SOC_ENUM_EXT("MAX9877 Output Mode", max9877_enum[0],
+                        max9877_get_out_mode, max9877_set_out_mode),
+        SOC_ENUM_EXT("MAX9877 Oscillator Mode", max9877_enum[1],
+                        max9877_get_osc_mode, max9877_set_osc_mode),
+};
+
+/* This function is called from ASoC machine driver */
+int max9877_add_controls(struct snd_soc_codec *codec)
+{
+        return snd_soc_add_controls(codec, max9877_controls,
+                        ARRAY_SIZE(max9877_controls));
+}
+EXPORT_SYMBOL_GPL(max9877_add_controls);
+
+static int __devinit max9877_i2c_probe(struct i2c_client *client,
+                const struct i2c_device_id *id)
+{
+        i2c = client;
+
+        max9877_write_regs();
+
+        return 0;
+}
+
+static __devexit int max9877_i2c_remove(struct i2c_client *client)
+{
+        i2c = NULL;
+
+        return 0;
+}
+
+static const struct i2c_device_id max9877_i2c_id[] = {
+        { "max9877", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, max9877_i2c_id);
+
+static struct i2c_driver max9877_i2c_driver = {
+        .driver = {
+                .name = "max9877",
+                .owner = THIS_MODULE,
+        },
+        .probe = max9877_i2c_probe,
+        .remove = __devexit_p(max9877_i2c_remove),
+        .id_table = max9877_i2c_id,
+};
+
+static int __init max9877_init(void)
+{
+        return i2c_add_driver(&max9877_i2c_driver);
+}
+module_init(max9877_init);
+
+static void __exit max9877_exit(void)
+{
+        i2c_del_driver(&max9877_i2c_driver);
+}
+module_exit(max9877_exit);
+
+MODULE_DESCRIPTION("ASoC MAX9877 amp driver");
+MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/codecs/max9877.h b/sound/soc/codecs/max9877.h
new file mode 100644
index 000000000000..6da72290ac58
--- /dev/null
+++ b/sound/soc/codecs/max9877.h
@@ -0,0 +1,37 @@
+/*
+ * max9877.h  --  amp driver for max9877
+ *
+ * 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 _MAX9877_H
+#define _MAX9877_H
+
+#define MAX9877_INPUT_MODE              0x00
+#define MAX9877_SPK_VOLUME              0x01
+#define MAX9877_HPL_VOLUME              0x02
+#define MAX9877_HPR_VOLUME              0x03
+#define MAX9877_OUTPUT_MODE             0x04
+
+/* MAX9877_INPUT_MODE */
+#define MAX9877_INB                     (1 << 4)
+#define MAX9877_INA                     (1 << 5)
+#define MAX9877_ZCD                     (1 << 6)
+
+/* MAX9877_OUTPUT_MODE */
+#define MAX9877_OUTMODE_MASK            (15 << 0)
+#define MAX9877_OSC_MASK                (3 << 4)
+#define MAX9877_OSC_OFFSET              4
+#define MAX9877_BYPASS                  (1 << 6)
+#define MAX9877_SHDN                    (1 << 7)
+
+extern int max9877_add_controls(struct snd_soc_codec *codec);
+
+#endif
diff --git a/sound/soc/codecs/spdif_transciever.c b/sound/soc/codecs/spdif_transciever.c
new file mode 100644
index 000000000000..a63191141052
--- /dev/null
+++ b/sound/soc/codecs/spdif_transciever.c
@@ -0,0 +1,74 @@
+/*
+ * ALSA SoC SPDIF DIT driver
+ *
+ *  This driver is used by controllers which can operate in DIT (SPDI/F) where
+ *  no codec is needed.  This file provides stub codec that can be used
+ *  in these configurations. TI DaVinci Audio controller uses this driver.
+ *
+ * Author:      Steve Chen,  <schen@mvista.com>
+ * Copyright:   (C) 2009 MontaVista Software, Inc., <source@mvista.com>
+ * Copyright:   (C) 2009  Texas Instruments, India
+ *
+ * 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 <sound/soc.h>
+#include <sound/pcm.h>
+
+#include "spdif_transciever.h"
+
+MODULE_LICENSE("GPL");
+
+#define STUB_RATES      SNDRV_PCM_RATE_8000_96000
+#define STUB_FORMATS    SNDRV_PCM_FMTBIT_S16_LE
+
+struct snd_soc_dai dit_stub_dai = {
+        .name           = "DIT",
+        .playback       = {
+                .stream_name    = "Playback",
+                .channels_min   = 1,
+                .channels_max   = 384,
+                .rates          = STUB_RATES,
+                .formats        = STUB_FORMATS,
+        },
+};
+EXPORT_SYMBOL_GPL(dit_stub_dai);
+
+static int spdif_dit_probe(struct platform_device *pdev)
+{
+        dit_stub_dai.dev = &pdev->dev;
+        return snd_soc_register_dai(&dit_stub_dai);
+}
+
+static int spdif_dit_remove(struct platform_device *pdev)
+{
+        snd_soc_unregister_dai(&dit_stub_dai);
+        return 0;
+}
+
+static struct platform_driver spdif_dit_driver = {
+        .probe          = spdif_dit_probe,
+        .remove         = spdif_dit_remove,
+        .driver         = {
+                .name   = "spdif-dit",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init dit_modinit(void)
+{
+        return platform_driver_register(&spdif_dit_driver);
+}
+
+static void __exit dit_exit(void)
+{
+        platform_driver_unregister(&spdif_dit_driver);
+}
+
+module_init(dit_modinit);
+module_exit(dit_exit);
+
diff --git a/sound/soc/codecs/spdif_transciever.h b/sound/soc/codecs/spdif_transciever.h
new file mode 100644
index 000000000000..296f2eb6c4ef
--- /dev/null
+++ b/sound/soc/codecs/spdif_transciever.h
@@ -0,0 +1,17 @@
+/*
+ * ALSA SoC DIT/DIR driver header
+ *
+ * Author:      Steve Chen,  <schen@mvista.com>
+ * Copyright:   (C) 2008 MontaVista Software, Inc., <source@mvista.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 CODEC_STUBS_H
+#define CODEC_STUBS_H
+
+extern struct snd_soc_dai dit_stub_dai;
+
+#endif /* CODEC_STUBS_H */
diff --git a/sound/soc/codecs/ssm2602.c b/sound/soc/codecs/ssm2602.c
index 87f606c76822..c550750c79c0 100644
--- a/sound/soc/codecs/ssm2602.c
+++ b/sound/soc/codecs/ssm2602.c
@@ -336,15 +336,17 @@ static int ssm2602_startup(struct snd_pcm_substream *substream,
                         master_runtime->sample_bits,
                         master_runtime->rate);
 
-                snd_pcm_hw_constraint_minmax(substream->runtime,
-                                             SNDRV_PCM_HW_PARAM_RATE,
-                                             master_runtime->rate,
-                                             master_runtime->rate);
-
-                snd_pcm_hw_constraint_minmax(substream->runtime,
-                                             SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
-                                             master_runtime->sample_bits,
-                                             master_runtime->sample_bits);
+                if (master_runtime->rate != 0)
+                        snd_pcm_hw_constraint_minmax(substream->runtime,
+                                                     SNDRV_PCM_HW_PARAM_RATE,
+                                                     master_runtime->rate,
+                                                     master_runtime->rate);
+
+                if (master_runtime->sample_bits != 0)
+                        snd_pcm_hw_constraint_minmax(substream->runtime,
+                                                     SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
+                                                     master_runtime->sample_bits,
+                                                     master_runtime->sample_bits);
 
                 ssm2602->slave_substream = substream;
         } else
@@ -372,6 +374,7 @@ static void ssm2602_shutdown(struct snd_pcm_substream *substream,
         struct snd_soc_device *socdev = rtd->socdev;
         struct snd_soc_codec *codec = socdev->card->codec;
         struct ssm2602_priv *ssm2602 = codec->private_data;
+
         /* deactivate */
         if (!codec->active)
                 ssm2602_write(codec, SSM2602_ACTIVE, 0);
@@ -497,11 +500,9 @@ static int ssm2602_set_bias_level(struct snd_soc_codec *codec,
         return 0;
 }
 
-#define SSM2602_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 SSM2602_RATES (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_32000 |\
+                SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |\
+                SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000)
 
 #define SSM2602_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
                 SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32_LE)
diff --git a/sound/soc/codecs/stac9766.c b/sound/soc/codecs/stac9766.c
new file mode 100644
index 000000000000..befc6488c39a
--- /dev/null
+++ b/sound/soc/codecs/stac9766.c
@@ -0,0 +1,463 @@
+/*
+ * stac9766.c  --  ALSA SoC STAC9766 codec support
+ *
+ * Copyright 2009 Jon Smirl, Digispeaker
+ * Author: Jon Smirl <jonsmirl@gmail.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.
+ *
+ *  Features:-
+ *
+ *   o Support for AC97 Codec, S/PDIF
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/device.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/ac97_codec.h>
+#include <sound/initval.h>
+#include <sound/pcm_params.h>
+#include <sound/soc.h>
+#include <sound/tlv.h>
+#include <sound/soc-of-simple.h>
+
+#include "stac9766.h"
+
+#define STAC9766_VERSION "0.10"
+
+/*
+ * STAC9766 register cache
+ */
+static const u16 stac9766_reg[] = {
+        0x6A90, 0x8000, 0x8000, 0x8000, /* 6 */
+        0x0000, 0x0000, 0x8008, 0x8008, /* e */
+        0x8808, 0x8808, 0x8808, 0x8808, /* 16 */
+        0x8808, 0x0000, 0x8000, 0x0000, /* 1e */
+        0x0000, 0x0000, 0x0000, 0x000f, /* 26 */
+        0x0a05, 0x0400, 0xbb80, 0x0000, /* 2e */
+        0x0000, 0xbb80, 0x0000, 0x0000, /* 36 */
+        0x0000, 0x2000, 0x0000, 0x0100, /* 3e */
+        0x0000, 0x0000, 0x0080, 0x0000, /* 46 */
+        0x0000, 0x0000, 0x0003, 0xffff, /* 4e */
+        0x0000, 0x0000, 0x0000, 0x0000, /* 56 */
+        0x4000, 0x0000, 0x0000, 0x0000, /* 5e */
+        0x1201, 0xFFFF, 0xFFFF, 0x0000, /* 66 */
+        0x0000, 0x0000, 0x0000, 0x0000, /* 6e */
+        0x0000, 0x0000, 0x0000, 0x0006, /* 76 */
+        0x0000, 0x0000, 0x0000, 0x0000, /* 7e */
+};
+
+static const char *stac9766_record_mux[] = {"Mic", "CD", "Video", "AUX",
+                        "Line", "Stereo Mix", "Mono Mix", "Phone"};
+static const char *stac9766_mono_mux[] = {"Mix", "Mic"};
+static const char *stac9766_mic_mux[] = {"Mic1", "Mic2"};
+static const char *stac9766_SPDIF_mux[] = {"PCM", "ADC Record"};
+static const char *stac9766_popbypass_mux[] = {"Normal", "Bypass Mixer"};
+static const char *stac9766_record_all_mux[] = {"All analog",
+        "Analog plus DAC"};
+static const char *stac9766_boost1[] = {"0dB", "10dB"};
+static const char *stac9766_boost2[] = {"0dB", "20dB"};
+static const char *stac9766_stereo_mic[] = {"Off", "On"};
+
+static const struct soc_enum stac9766_record_enum =
+        SOC_ENUM_DOUBLE(AC97_REC_SEL, 8, 0, 8, stac9766_record_mux);
+static const struct soc_enum stac9766_mono_enum =
+        SOC_ENUM_SINGLE(AC97_GENERAL_PURPOSE, 9, 2, stac9766_mono_mux);
+static const struct soc_enum stac9766_mic_enum =
+        SOC_ENUM_SINGLE(AC97_GENERAL_PURPOSE, 8, 2, stac9766_mic_mux);
+static const struct soc_enum stac9766_SPDIF_enum =
+        SOC_ENUM_SINGLE(AC97_STAC_DA_CONTROL, 1, 2, stac9766_SPDIF_mux);
+static const struct soc_enum stac9766_popbypass_enum =
+        SOC_ENUM_SINGLE(AC97_GENERAL_PURPOSE, 15, 2, stac9766_popbypass_mux);
+static const struct soc_enum stac9766_record_all_enum =
+        SOC_ENUM_SINGLE(AC97_STAC_ANALOG_SPECIAL, 12, 2,
+                        stac9766_record_all_mux);
+static const struct soc_enum stac9766_boost1_enum =
+        SOC_ENUM_SINGLE(AC97_MIC, 6, 2, stac9766_boost1); /* 0/10dB */
+static const struct soc_enum stac9766_boost2_enum =
+        SOC_ENUM_SINGLE(AC97_STAC_ANALOG_SPECIAL, 2, 2, stac9766_boost2); /* 0/20dB */
+static const struct soc_enum stac9766_stereo_mic_enum =
+        SOC_ENUM_SINGLE(AC97_STAC_STEREO_MIC, 2, 1, stac9766_stereo_mic);
+
+static const DECLARE_TLV_DB_LINEAR(master_tlv, -4600, 0);
+static const DECLARE_TLV_DB_LINEAR(record_tlv, 0, 2250);
+static const DECLARE_TLV_DB_LINEAR(beep_tlv, -4500, 0);
+static const DECLARE_TLV_DB_LINEAR(mix_tlv, -3450, 1200);
+
+static const struct snd_kcontrol_new stac9766_snd_ac97_controls[] = {
+        SOC_DOUBLE_TLV("Speaker Volume", AC97_MASTER, 8, 0, 31, 1, master_tlv),
+        SOC_SINGLE("Speaker Switch", AC97_MASTER, 15, 1, 1),
+        SOC_DOUBLE_TLV("Headphone Volume", AC97_HEADPHONE, 8, 0, 31, 1,
+                       master_tlv),
+        SOC_SINGLE("Headphone Switch", AC97_HEADPHONE, 15, 1, 1),
+        SOC_SINGLE_TLV("Mono Out Volume", AC97_MASTER_MONO, 0, 31, 1,
+                       master_tlv),
+        SOC_SINGLE("Mono Out Switch", AC97_MASTER_MONO, 15, 1, 1),
+
+        SOC_DOUBLE_TLV("Record Volume", AC97_REC_GAIN, 8, 0, 15, 0, record_tlv),
+        SOC_SINGLE("Record Switch", AC97_REC_GAIN, 15, 1, 1),
+
+
+        SOC_SINGLE_TLV("Beep Volume", AC97_PC_BEEP, 1, 15, 1, beep_tlv),
+        SOC_SINGLE("Beep Switch", AC97_PC_BEEP, 15, 1, 1),
+        SOC_SINGLE("Beep Frequency", AC97_PC_BEEP, 5, 127, 1),
+        SOC_SINGLE_TLV("Phone Volume", AC97_PHONE, 0, 31, 1, mix_tlv),
+        SOC_SINGLE("Phone Switch", AC97_PHONE, 15, 1, 1),
+
+        SOC_ENUM("Mic Boost1", stac9766_boost1_enum),
+        SOC_ENUM("Mic Boost2", stac9766_boost2_enum),
+        SOC_SINGLE_TLV("Mic Volume", AC97_MIC, 0, 31, 1, mix_tlv),
+        SOC_SINGLE("Mic Switch", AC97_MIC, 15, 1, 1),
+        SOC_ENUM("Stereo Mic", stac9766_stereo_mic_enum),
+
+        SOC_DOUBLE_TLV("Line Volume", AC97_LINE, 8, 0, 31, 1, mix_tlv),
+        SOC_SINGLE("Line Switch", AC97_LINE, 15, 1, 1),
+        SOC_DOUBLE_TLV("CD Volume", AC97_CD, 8, 0, 31, 1, mix_tlv),
+        SOC_SINGLE("CD Switch", AC97_CD, 15, 1, 1),
+        SOC_DOUBLE_TLV("AUX Volume", AC97_AUX, 8, 0, 31, 1, mix_tlv),
+        SOC_SINGLE("AUX Switch", AC97_AUX, 15, 1, 1),
+        SOC_DOUBLE_TLV("Video Volume", AC97_VIDEO, 8, 0, 31, 1, mix_tlv),
+        SOC_SINGLE("Video Switch", AC97_VIDEO, 15, 1, 1),
+
+        SOC_DOUBLE_TLV("DAC Volume", AC97_PCM, 8, 0, 31, 1, mix_tlv),
+        SOC_SINGLE("DAC Switch", AC97_PCM, 15, 1, 1),
+        SOC_SINGLE("Loopback Test Switch", AC97_GENERAL_PURPOSE, 7, 1, 0),
+        SOC_SINGLE("3D Volume", AC97_3D_CONTROL, 3, 2, 1),
+        SOC_SINGLE("3D Switch", AC97_GENERAL_PURPOSE, 13, 1, 0),
+
+        SOC_ENUM("SPDIF Mux", stac9766_SPDIF_enum),
+        SOC_ENUM("Mic1/2 Mux", stac9766_mic_enum),
+        SOC_ENUM("Record All Mux", stac9766_record_all_enum),
+        SOC_ENUM("Record Mux", stac9766_record_enum),
+        SOC_ENUM("Mono Mux", stac9766_mono_enum),
+        SOC_ENUM("Pop Bypass Mux", stac9766_popbypass_enum),
+};
+
+static int stac9766_ac97_write(struct snd_soc_codec *codec, unsigned int reg,
+                               unsigned int val)
+{
+        u16 *cache = codec->reg_cache;
+
+        if (reg > AC97_STAC_PAGE0) {
+                stac9766_ac97_write(codec, AC97_INT_PAGING, 0);
+                soc_ac97_ops.write(codec->ac97, reg, val);
+                stac9766_ac97_write(codec, AC97_INT_PAGING, 1);
+                return 0;
+        }
+        if (reg / 2 >= ARRAY_SIZE(stac9766_reg))
+                return -EIO;
+
+        soc_ac97_ops.write(codec->ac97, reg, val);
+        cache[reg / 2] = val;
+        return 0;
+}
+
+static unsigned int stac9766_ac97_read(struct snd_soc_codec *codec,
+                                       unsigned int reg)
+{
+        u16 val = 0, *cache = codec->reg_cache;
+
+        if (reg > AC97_STAC_PAGE0) {
+                stac9766_ac97_write(codec, AC97_INT_PAGING, 0);
+                val = soc_ac97_ops.read(codec->ac97, reg - AC97_STAC_PAGE0);
+                stac9766_ac97_write(codec, AC97_INT_PAGING, 1);
+                return val;
+        }
+        if (reg / 2 >= ARRAY_SIZE(stac9766_reg))
+                return -EIO;
+
+        if (reg == AC97_RESET || reg == AC97_GPIO_STATUS ||
+                reg == AC97_INT_PAGING || reg == AC97_VENDOR_ID1 ||
+                reg == AC97_VENDOR_ID2) {
+
+                val = soc_ac97_ops.read(codec->ac97, reg);
+                return val;
+        }
+        return cache[reg / 2];
+}
+
+static int ac97_analog_prepare(struct snd_pcm_substream *substream,
+                               struct snd_soc_dai *dai)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        unsigned short reg, vra;
+
+        vra = stac9766_ac97_read(codec, AC97_EXTENDED_STATUS);
+
+        vra |= 0x1; /* enable variable rate audio */
+
+        stac9766_ac97_write(codec, AC97_EXTENDED_STATUS, vra);
+
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+                reg = AC97_PCM_FRONT_DAC_RATE;
+        else
+                reg = AC97_PCM_LR_ADC_RATE;
+
+        return stac9766_ac97_write(codec, reg, runtime->rate);
+}
+
+static int ac97_digital_prepare(struct snd_pcm_substream *substream,
+                                struct snd_soc_dai *dai)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        unsigned short reg, vra;
+
+        stac9766_ac97_write(codec, AC97_SPDIF, 0x2002);
+
+        vra = stac9766_ac97_read(codec, AC97_EXTENDED_STATUS);
+        vra |= 0x5; /* Enable VRA and SPDIF out */
+
+        stac9766_ac97_write(codec, AC97_EXTENDED_STATUS, vra);
+
+        reg = AC97_PCM_FRONT_DAC_RATE;
+
+        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)
+{
+        switch (level) {
+        case SND_SOC_BIAS_ON: /* full On */
+        case SND_SOC_BIAS_PREPARE: /* partial On */
+        case SND_SOC_BIAS_STANDBY: /* Off, with power */
+                stac9766_ac97_write(codec, AC97_POWERDOWN, 0x0000);
+                break;
+        case SND_SOC_BIAS_OFF: /* Off, without power */
+                /* disable everything including AC link */
+                stac9766_ac97_write(codec, AC97_POWERDOWN, 0xffff);
+                break;
+        }
+        codec->bias_level = level;
+        return 0;
+}
+
+static int stac9766_reset(struct snd_soc_codec *codec, int try_warm)
+{
+        if (try_warm && soc_ac97_ops.warm_reset) {
+                soc_ac97_ops.warm_reset(codec->ac97);
+                if (stac9766_ac97_read(codec, 0) == stac9766_reg[0])
+                        return 1;
+        }
+
+        soc_ac97_ops.reset(codec->ac97);
+        if (soc_ac97_ops.warm_reset)
+                soc_ac97_ops.warm_reset(codec->ac97);
+        if (stac9766_ac97_read(codec, 0) != stac9766_reg[0])
+                return -EIO;
+        return 0;
+}
+
+static int stac9766_codec_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;
+
+        stac9766_set_bias_level(codec, SND_SOC_BIAS_OFF);
+        return 0;
+}
+
+static int stac9766_codec_resume(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec = socdev->card->codec;
+        u16 id, reset;
+
+        reset = 0;
+        /* give the codec an AC97 warm reset to start the link */
+reset:
+        if (reset > 5) {
+                printk(KERN_ERR "stac9766 failed to resume");
+                return -EIO;
+        }
+        codec->ac97->bus->ops->warm_reset(codec->ac97);
+        id = soc_ac97_ops.read(codec->ac97, AC97_VENDOR_ID2);
+        if (id != 0x4c13) {
+                stac9766_reset(codec, 0);
+                reset++;
+                goto reset;
+        }
+        stac9766_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+
+        if (codec->suspend_bias_level == SND_SOC_BIAS_ON)
+                stac9766_set_bias_level(codec, SND_SOC_BIAS_ON);
+
+        return 0;
+}
+
+static struct snd_soc_dai_ops stac9766_dai_ops_analog = {
+        .prepare = ac97_analog_prepare,
+};
+
+static struct snd_soc_dai_ops stac9766_dai_ops_digital = {
+        .prepare = ac97_digital_prepare,
+        .trigger = ac97_digital_trigger,
+};
+
+struct snd_soc_dai stac9766_dai[] = {
+{
+        .name = "stac9766 analog",
+        .id = 0,
+        .ac97_control = 1,
+
+        /* stream cababilities */
+        .playback = {
+                .stream_name = "stac9766 analog",
+                .channels_min = 1,
+                .channels_max = 2,
+                .rates = SNDRV_PCM_RATE_8000_48000,
+                .formats = SND_SOC_STD_AC97_FMTS,
+        },
+        .capture = {
+                .stream_name = "stac9766 analog",
+                .channels_min = 1,
+                .channels_max = 2,
+                .rates = SNDRV_PCM_RATE_8000_48000,
+                .formats = SND_SOC_STD_AC97_FMTS,
+        },
+        /* alsa ops */
+        .ops = &stac9766_dai_ops_analog,
+},
+{
+        .name = "stac9766 IEC958",
+        .id = 1,
+        .ac97_control = 1,
+
+        /* stream cababilities */
+        .playback = {
+                .stream_name = "stac9766 IEC958",
+                .channels_min = 1,
+                .channels_max = 2,
+                .rates = SNDRV_PCM_RATE_32000 | \
+                        SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000,
+                .formats = SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE,
+        },
+        /* alsa ops */
+        .ops = &stac9766_dai_ops_digital,
+}
+};
+EXPORT_SYMBOL_GPL(stac9766_dai);
+
+static int stac9766_codec_probe(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec;
+        int ret = 0;
+
+        printk(KERN_INFO "STAC9766 SoC Audio Codec %s\n", STAC9766_VERSION);
+
+        socdev->card->codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
+        if (socdev->card->codec == NULL)
+                return -ENOMEM;
+        codec = socdev->card->codec;
+        mutex_init(&codec->mutex);
+
+        codec->reg_cache = kmemdup(stac9766_reg, sizeof(stac9766_reg),
+                                   GFP_KERNEL);
+        if (codec->reg_cache == NULL) {
+                ret = -ENOMEM;
+                goto cache_err;
+        }
+        codec->reg_cache_size = sizeof(stac9766_reg);
+        codec->reg_cache_step = 2;
+
+        codec->name = "STAC9766";
+        codec->owner = THIS_MODULE;
+        codec->dai = stac9766_dai;
+        codec->num_dai = ARRAY_SIZE(stac9766_dai);
+        codec->write = stac9766_ac97_write;
+        codec->read = stac9766_ac97_read;
+        codec->set_bias_level = stac9766_set_bias_level;
+        INIT_LIST_HEAD(&codec->dapm_widgets);
+        INIT_LIST_HEAD(&codec->dapm_paths);
+
+        ret = snd_soc_new_ac97_codec(codec, &soc_ac97_ops, 0);
+        if (ret < 0)
+                goto codec_err;
+
+        /* register pcms */
+        ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
+        if (ret < 0)
+                goto pcm_err;
+
+        /* do a cold reset for the controller and then try
+         * a warm reset followed by an optional cold reset for codec */
+        stac9766_reset(codec, 0);
+        ret = stac9766_reset(codec, 1);
+        if (ret < 0) {
+                printk(KERN_ERR "Failed to reset STAC9766: AC97 link error\n");
+                goto reset_err;
+        }
+
+        stac9766_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+
+        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:
+        snd_soc_free_pcms(socdev);
+pcm_err:
+        snd_soc_free_ac97_codec(codec);
+codec_err:
+        kfree(codec->private_data);
+cache_err:
+        kfree(socdev->card->codec);
+        socdev->card->codec = NULL;
+        return ret;
+}
+
+static int stac9766_codec_remove(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec = socdev->card->codec;
+
+        if (codec == NULL)
+                return 0;
+
+        snd_soc_free_pcms(socdev);
+        snd_soc_free_ac97_codec(codec);
+        kfree(codec->reg_cache);
+        kfree(codec);
+        return 0;
+}
+
+struct snd_soc_codec_device soc_codec_dev_stac9766 = {
+        .probe = stac9766_codec_probe,
+        .remove = stac9766_codec_remove,
+        .suspend = stac9766_codec_suspend,
+        .resume = stac9766_codec_resume,
+};
+EXPORT_SYMBOL_GPL(soc_codec_dev_stac9766);
+
+MODULE_DESCRIPTION("ASoC stac9766 driver");
+MODULE_AUTHOR("Jon Smirl <jonsmirl@gmail.com>");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/codecs/stac9766.h b/sound/soc/codecs/stac9766.h
new file mode 100644
index 000000000000..65642eb8393e
--- /dev/null
+++ b/sound/soc/codecs/stac9766.h
@@ -0,0 +1,21 @@
+/*
+ * stac9766.h  --  STAC9766 Soc Audio driver
+ */
+
+#ifndef _STAC9766_H
+#define _STAC9766_H
+
+#define AC97_STAC_PAGE0 0x1000
+#define AC97_STAC_DA_CONTROL (AC97_STAC_PAGE0 | 0x6A)
+#define AC97_STAC_ANALOG_SPECIAL (AC97_STAC_PAGE0 | 0x6E)
+#define AC97_STAC_STEREO_MIC 0x78
+
+/* STAC9766 DAI ID's */
+#define STAC9766_DAI_AC97_ANALOG                0
+#define STAC9766_DAI_AC97_DIGITAL               1
+
+extern struct snd_soc_dai stac9766_dai[];
+extern struct snd_soc_codec_device soc_codec_dev_stac9766;
+
+
+#endif
diff --git a/sound/soc/codecs/tlv320aic23.c b/sound/soc/codecs/tlv320aic23.c
index c3f4afb5d017..0b8dcb5cd729 100644
--- a/sound/soc/codecs/tlv320aic23.c
+++ b/sound/soc/codecs/tlv320aic23.c
@@ -86,7 +86,7 @@ static int tlv320aic23_write(struct snd_soc_codec *codec, unsigned int reg,
          */
 
         if ((reg < 0 || reg > 9) && (reg != 15)) {
-                printk(KERN_WARNING "%s Invalid register R%d\n", __func__, reg);
+                printk(KERN_WARNING "%s Invalid register R%u\n", __func__, reg);
                 return -1;
         }
 
@@ -98,7 +98,7 @@ static int tlv320aic23_write(struct snd_soc_codec *codec, unsigned int reg,
         if (codec->hw_write(codec->control_data, data, 2) == 2)
                 return 0;
 
-        printk(KERN_ERR "%s cannot write %03x to register R%d\n", __func__,
+        printk(KERN_ERR "%s cannot write %03x to register R%u\n", __func__,
                value, reg);
 
         return -EIO;
@@ -273,14 +273,14 @@ static const unsigned short sr_valid_mask[] = {
  * Every divisor is a factor of 11*12
  */
 #define SR_MULT (11*12)
-#define A(x) (x) ? (SR_MULT/x) : 0
+#define A(x) (SR_MULT/x)
 static const unsigned char sr_adc_mult_table[] = {
-        A(2), A(2), A(12), A(12),  A(0), A(0), A(3), A(1),
-        A(2), A(2), A(11), A(11),  A(0), A(0), A(0), A(1)
+        A(2), A(2), A(12), A(12),  0, 0, A(3), A(1),
+        A(2), A(2), A(11), A(11),  0, 0, 0, A(1)
 };
 static const unsigned char sr_dac_mult_table[] = {
-        A(2), A(12), A(2), A(12),  A(0), A(0), A(3), A(1),
-        A(2), A(11), A(2), A(11),  A(0), A(0), A(0), A(1)
+        A(2), A(12), A(2), A(12),  0, 0, A(3), A(1),
+        A(2), A(11), A(2), A(11),  0, 0, 0, A(1)
 };
 
 static unsigned get_score(int adc, int adc_l, int adc_h, int need_adc,
@@ -523,6 +523,8 @@ static int tlv320aic23_set_dai_fmt(struct snd_soc_dai *codec_dai,
         case SND_SOC_DAIFMT_I2S:
                 iface_reg |= TLV320AIC23_FOR_I2S;
                 break;
+        case SND_SOC_DAIFMT_DSP_A:
+                iface_reg |= TLV320AIC23_LRP_ON;
         case SND_SOC_DAIFMT_DSP_B:
                 iface_reg |= TLV320AIC23_FOR_DSP;
                 break;
diff --git a/sound/soc/codecs/tlv320aic3x.c b/sound/soc/codecs/tlv320aic3x.c
index ab099f482487..126b15b18aeb 100644
--- a/sound/soc/codecs/tlv320aic3x.c
+++ b/sound/soc/codecs/tlv320aic3x.c
@@ -145,8 +145,8 @@ static int aic3x_read(struct snd_soc_codec *codec, unsigned int reg,
                       u8 *value)
 {
         *value = reg & 0xff;
-        if (codec->hw_read(codec->control_data, value, 1) != 1)
-                return -EIO;
+
+        value[0] = i2c_smbus_read_byte_data(codec->control_data, value[0]);
 
         aic3x_write_reg_cache(codec, reg, *value);
         return 0;
@@ -767,6 +767,7 @@ static int aic3x_hw_params(struct snd_pcm_substream *substream,
         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 reg;
 
         /* select data word length */
         data =
@@ -801,8 +802,16 @@ static int aic3x_hw_params(struct snd_pcm_substream *substream,
                 pll_q &= 0xf;
                 aic3x_write(codec, AIC3X_PLL_PROGA_REG, pll_q << PLLQ_SHIFT);
                 aic3x_write(codec, AIC3X_GPIOB_REG, CODEC_CLKIN_CLKDIV);
-        } else
+                /* disable PLL if it is bypassed */
+                reg = aic3x_read_reg_cache(codec, AIC3X_PLL_PROGA_REG);
+                aic3x_write(codec, AIC3X_PLL_PROGA_REG, reg & ~PLL_ENABLE);
+
+        } else {
                 aic3x_write(codec, AIC3X_GPIOB_REG, CODEC_CLKIN_PLLDIV);
+                /* enable PLL when it is used */
+                reg = aic3x_read_reg_cache(codec, AIC3X_PLL_PROGA_REG);
+                aic3x_write(codec, AIC3X_PLL_PROGA_REG, reg | PLL_ENABLE);
+        }
 
         /* Route Left DAC to left channel input and
          * right DAC to right channel input */
@@ -1316,12 +1325,6 @@ static struct i2c_driver aic3x_i2c_driver = {
         .id_table = aic3x_i2c_id,
 };
 
-static int aic3x_i2c_read(struct i2c_client *client, u8 *value, int len)
-{
-        value[0] = i2c_smbus_read_byte_data(client, value[0]);
-        return (len == 1);
-}
-
 static int aic3x_add_i2c_device(struct platform_device *pdev,
                                  const struct aic3x_setup_data *setup)
 {
@@ -1394,7 +1397,6 @@ static int aic3x_probe(struct platform_device *pdev)
 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
         if (setup->i2c_address) {
                 codec->hw_write = (hw_write_t) i2c_master_send;
-                codec->hw_read = (hw_read_t) aic3x_i2c_read;
                 ret = aic3x_add_i2c_device(pdev, setup);
         }
 #else
diff --git a/sound/soc/codecs/twl4030.c b/sound/soc/codecs/twl4030.c
index df7c8c281d2f..4df7c6c61c76 100644
--- a/sound/soc/codecs/twl4030.c
+++ b/sound/soc/codecs/twl4030.c
@@ -115,6 +115,7 @@ static const u8 twl4030_reg[TWL4030_CACHEREGNUM] = {
         0x00, /* REG_VIBRA_PWM_SET      (0x47)  */
         0x00, /* REG_ANAMIC_GAIN        (0x48)  */
         0x00, /* REG_MISC_SET_2         (0x49)  */
+        0x00, /* REG_SW_SHADOW          (0x4A)  - Shadow, non HW register */
 };
 
 /* codec private data */
@@ -125,6 +126,17 @@ struct twl4030_priv {
 
         struct snd_pcm_substream *master_substream;
         struct snd_pcm_substream *slave_substream;
+
+        unsigned int configured;
+        unsigned int rate;
+        unsigned int sample_bits;
+        unsigned int channels;
+
+        unsigned int sysclk;
+
+        /* Headset output state handling */
+        unsigned int hsl_enabled;
+        unsigned int hsr_enabled;
 };
 
 /*
@@ -161,7 +173,11 @@ static int twl4030_write(struct snd_soc_codec *codec,
                         unsigned int reg, unsigned int value)
 {
         twl4030_write_reg_cache(codec, reg, value);
-        return twl4030_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE, value, reg);
+        if (likely(reg < TWL4030_REG_SW_SHADOW))
+                return twl4030_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE, value,
+                                            reg);
+        else
+                return 0;
 }
 
 static void twl4030_codec_enable(struct snd_soc_codec *codec, int enable)
@@ -188,6 +204,7 @@ static void twl4030_codec_enable(struct snd_soc_codec *codec, int enable)
 
 static void twl4030_init_chip(struct snd_soc_codec *codec)
 {
+        u8 *cache = codec->reg_cache;
         int i;
 
         /* clear CODECPDZ prior to setting register defaults */
@@ -195,7 +212,7 @@ 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, twl4030_reg[i]);
+                twl4030_write(codec, i, cache[i]);
 
 }
 
@@ -208,55 +225,11 @@ static void twl4030_codec_mute(struct snd_soc_codec *codec, int mute)
                 return;
 
         if (mute) {
-                /* Bypass the reg_cache and mute the volumes
-                 * Headset mute is done in it's own event handler
-                 * Things to mute:  Earpiece, PreDrivL/R, CarkitL/R
-                 */
-                reg_val = twl4030_read_reg_cache(codec, TWL4030_REG_EAR_CTL);
-                twl4030_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE,
-                                        reg_val & (~TWL4030_EAR_GAIN),
-                                        TWL4030_REG_EAR_CTL);
-
-                reg_val = twl4030_read_reg_cache(codec, TWL4030_REG_PREDL_CTL);
-                twl4030_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE,
-                                        reg_val & (~TWL4030_PREDL_GAIN),
-                                        TWL4030_REG_PREDL_CTL);
-                reg_val = twl4030_read_reg_cache(codec, TWL4030_REG_PREDR_CTL);
-                twl4030_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE,
-                                        reg_val & (~TWL4030_PREDR_GAIN),
-                                        TWL4030_REG_PREDL_CTL);
-
-                reg_val = twl4030_read_reg_cache(codec, TWL4030_REG_PRECKL_CTL);
-                twl4030_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE,
-                                        reg_val & (~TWL4030_PRECKL_GAIN),
-                                        TWL4030_REG_PRECKL_CTL);
-                reg_val = twl4030_read_reg_cache(codec, TWL4030_REG_PRECKR_CTL);
-                twl4030_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE,
-                                        reg_val & (~TWL4030_PRECKL_GAIN),
-                                        TWL4030_REG_PRECKR_CTL);
-
                 /* 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 {
-                /* Restore the volumes
-                 * Headset mute is done in it's own event handler
-                 * Things to restore:  Earpiece, PreDrivL/R, CarkitL/R
-                 */
-                twl4030_write(codec, TWL4030_REG_EAR_CTL,
-                        twl4030_read_reg_cache(codec, TWL4030_REG_EAR_CTL));
-
-                twl4030_write(codec, TWL4030_REG_PREDL_CTL,
-                        twl4030_read_reg_cache(codec, TWL4030_REG_PREDL_CTL));
-                twl4030_write(codec, TWL4030_REG_PREDR_CTL,
-                        twl4030_read_reg_cache(codec, TWL4030_REG_PREDR_CTL));
-
-                twl4030_write(codec, TWL4030_REG_PRECKL_CTL,
-                        twl4030_read_reg_cache(codec, TWL4030_REG_PRECKL_CTL));
-                twl4030_write(codec, TWL4030_REG_PRECKR_CTL,
-                        twl4030_read_reg_cache(codec, TWL4030_REG_PRECKR_CTL));
-
                 /* Enable PLL */
                 reg_val = twl4030_read_reg_cache(codec, TWL4030_REG_APLL_CTL);
                 reg_val |= TWL4030_APLL_EN;
@@ -316,104 +289,60 @@ static void twl4030_power_down(struct snd_soc_codec *codec)
 }
 
 /* Earpiece */
-static const char *twl4030_earpiece_texts[] =
-                {"Off", "DACL1", "DACL2", "DACR1"};
-
-static const unsigned int twl4030_earpiece_values[] =
-                {0x0, 0x1, 0x2, 0x4};
-
-static const struct soc_enum twl4030_earpiece_enum =
-        SOC_VALUE_ENUM_SINGLE(TWL4030_REG_EAR_CTL, 1, 0x7,
-                        ARRAY_SIZE(twl4030_earpiece_texts),
-                        twl4030_earpiece_texts,
-                        twl4030_earpiece_values);
-
-static const struct snd_kcontrol_new twl4030_dapm_earpiece_control =
-SOC_DAPM_VALUE_ENUM("Route", twl4030_earpiece_enum);
+static const struct snd_kcontrol_new twl4030_dapm_earpiece_controls[] = {
+        SOC_DAPM_SINGLE("Voice", TWL4030_REG_EAR_CTL, 0, 1, 0),
+        SOC_DAPM_SINGLE("AudioL1", TWL4030_REG_EAR_CTL, 1, 1, 0),
+        SOC_DAPM_SINGLE("AudioL2", TWL4030_REG_EAR_CTL, 2, 1, 0),
+        SOC_DAPM_SINGLE("AudioR1", TWL4030_REG_EAR_CTL, 3, 1, 0),
+};
 
 /* PreDrive Left */
-static const char *twl4030_predrivel_texts[] =
-                {"Off", "DACL1", "DACL2", "DACR2"};
-
-static const unsigned int twl4030_predrivel_values[] =
-                {0x0, 0x1, 0x2, 0x4};
-
-static const struct soc_enum twl4030_predrivel_enum =
-        SOC_VALUE_ENUM_SINGLE(TWL4030_REG_PREDL_CTL, 1, 0x7,
-                        ARRAY_SIZE(twl4030_predrivel_texts),
-                        twl4030_predrivel_texts,
-                        twl4030_predrivel_values);
-
-static const struct snd_kcontrol_new twl4030_dapm_predrivel_control =
-SOC_DAPM_VALUE_ENUM("Route", twl4030_predrivel_enum);
+static const struct snd_kcontrol_new twl4030_dapm_predrivel_controls[] = {
+        SOC_DAPM_SINGLE("Voice", TWL4030_REG_PREDL_CTL, 0, 1, 0),
+        SOC_DAPM_SINGLE("AudioL1", TWL4030_REG_PREDL_CTL, 1, 1, 0),
+        SOC_DAPM_SINGLE("AudioL2", TWL4030_REG_PREDL_CTL, 2, 1, 0),
+        SOC_DAPM_SINGLE("AudioR2", TWL4030_REG_PREDL_CTL, 3, 1, 0),
+};
 
 /* PreDrive Right */
-static const char *twl4030_predriver_texts[] =
-                {"Off", "DACR1", "DACR2", "DACL2"};
-
-static const unsigned int twl4030_predriver_values[] =
-                {0x0, 0x1, 0x2, 0x4};
-
-static const struct soc_enum twl4030_predriver_enum =
-        SOC_VALUE_ENUM_SINGLE(TWL4030_REG_PREDR_CTL, 1, 0x7,
-                        ARRAY_SIZE(twl4030_predriver_texts),
-                        twl4030_predriver_texts,
-                        twl4030_predriver_values);
-
-static const struct snd_kcontrol_new twl4030_dapm_predriver_control =
-SOC_DAPM_VALUE_ENUM("Route", twl4030_predriver_enum);
+static const struct snd_kcontrol_new twl4030_dapm_predriver_controls[] = {
+        SOC_DAPM_SINGLE("Voice", TWL4030_REG_PREDR_CTL, 0, 1, 0),
+        SOC_DAPM_SINGLE("AudioR1", TWL4030_REG_PREDR_CTL, 1, 1, 0),
+        SOC_DAPM_SINGLE("AudioR2", TWL4030_REG_PREDR_CTL, 2, 1, 0),
+        SOC_DAPM_SINGLE("AudioL2", TWL4030_REG_PREDR_CTL, 3, 1, 0),
+};
 
 /* Headset Left */
-static const char *twl4030_hsol_texts[] =
-                {"Off", "DACL1", "DACL2"};
-
-static const struct soc_enum twl4030_hsol_enum =
-        SOC_ENUM_SINGLE(TWL4030_REG_HS_SEL, 1,
-                        ARRAY_SIZE(twl4030_hsol_texts),
-                        twl4030_hsol_texts);
-
-static const struct snd_kcontrol_new twl4030_dapm_hsol_control =
-SOC_DAPM_ENUM("Route", twl4030_hsol_enum);
+static const struct snd_kcontrol_new twl4030_dapm_hsol_controls[] = {
+        SOC_DAPM_SINGLE("Voice", TWL4030_REG_HS_SEL, 0, 1, 0),
+        SOC_DAPM_SINGLE("AudioL1", TWL4030_REG_HS_SEL, 1, 1, 0),
+        SOC_DAPM_SINGLE("AudioL2", TWL4030_REG_HS_SEL, 2, 1, 0),
+};
 
 /* Headset Right */
-static const char *twl4030_hsor_texts[] =
-                {"Off", "DACR1", "DACR2"};
-
-static const struct soc_enum twl4030_hsor_enum =
-        SOC_ENUM_SINGLE(TWL4030_REG_HS_SEL, 4,
-                        ARRAY_SIZE(twl4030_hsor_texts),
-                        twl4030_hsor_texts);
-
-static const struct snd_kcontrol_new twl4030_dapm_hsor_control =
-SOC_DAPM_ENUM("Route", twl4030_hsor_enum);
+static const struct snd_kcontrol_new twl4030_dapm_hsor_controls[] = {
+        SOC_DAPM_SINGLE("Voice", TWL4030_REG_HS_SEL, 3, 1, 0),
+        SOC_DAPM_SINGLE("AudioR1", TWL4030_REG_HS_SEL, 4, 1, 0),
+        SOC_DAPM_SINGLE("AudioR2", TWL4030_REG_HS_SEL, 5, 1, 0),
+};
 
 /* Carkit Left */
-static const char *twl4030_carkitl_texts[] =
-                {"Off", "DACL1", "DACL2"};
-
-static const struct soc_enum twl4030_carkitl_enum =
-        SOC_ENUM_SINGLE(TWL4030_REG_PRECKL_CTL, 1,
-                        ARRAY_SIZE(twl4030_carkitl_texts),
-                        twl4030_carkitl_texts);
-
-static const struct snd_kcontrol_new twl4030_dapm_carkitl_control =
-SOC_DAPM_ENUM("Route", twl4030_carkitl_enum);
+static const struct snd_kcontrol_new twl4030_dapm_carkitl_controls[] = {
+        SOC_DAPM_SINGLE("Voice", TWL4030_REG_PRECKL_CTL, 0, 1, 0),
+        SOC_DAPM_SINGLE("AudioL1", TWL4030_REG_PRECKL_CTL, 1, 1, 0),
+        SOC_DAPM_SINGLE("AudioL2", TWL4030_REG_PRECKL_CTL, 2, 1, 0),
+};
 
 /* Carkit Right */
-static const char *twl4030_carkitr_texts[] =
-                {"Off", "DACR1", "DACR2"};
-
-static const struct soc_enum twl4030_carkitr_enum =
-        SOC_ENUM_SINGLE(TWL4030_REG_PRECKR_CTL, 1,
-                        ARRAY_SIZE(twl4030_carkitr_texts),
-                        twl4030_carkitr_texts);
-
-static const struct snd_kcontrol_new twl4030_dapm_carkitr_control =
-SOC_DAPM_ENUM("Route", twl4030_carkitr_enum);
+static const struct snd_kcontrol_new twl4030_dapm_carkitr_controls[] = {
+        SOC_DAPM_SINGLE("Voice", TWL4030_REG_PRECKR_CTL, 0, 1, 0),
+        SOC_DAPM_SINGLE("AudioR1", TWL4030_REG_PRECKR_CTL, 1, 1, 0),
+        SOC_DAPM_SINGLE("AudioR2", TWL4030_REG_PRECKR_CTL, 2, 1, 0),
+};
 
 /* Handsfree Left */
 static const char *twl4030_handsfreel_texts[] =
-                {"Voice", "DACL1", "DACL2", "DACR2"};
+                {"Voice", "AudioL1", "AudioL2", "AudioR2"};
 
 static const struct soc_enum twl4030_handsfreel_enum =
         SOC_ENUM_SINGLE(TWL4030_REG_HFL_CTL, 0,
@@ -423,9 +352,13 @@ static const struct soc_enum twl4030_handsfreel_enum =
 static const struct snd_kcontrol_new twl4030_dapm_handsfreel_control =
 SOC_DAPM_ENUM("Route", twl4030_handsfreel_enum);
 
+/* Handsfree Left virtual mute */
+static const struct snd_kcontrol_new twl4030_dapm_handsfreelmute_control =
+        SOC_DAPM_SINGLE("Switch", TWL4030_REG_SW_SHADOW, 0, 1, 0);
+
 /* Handsfree Right */
 static const char *twl4030_handsfreer_texts[] =
-                {"Voice", "DACR1", "DACR2", "DACL2"};
+                {"Voice", "AudioR1", "AudioR2", "AudioL2"};
 
 static const struct soc_enum twl4030_handsfreer_enum =
         SOC_ENUM_SINGLE(TWL4030_REG_HFR_CTL, 0,
@@ -435,37 +368,52 @@ static const struct soc_enum twl4030_handsfreer_enum =
 static const struct snd_kcontrol_new twl4030_dapm_handsfreer_control =
 SOC_DAPM_ENUM("Route", twl4030_handsfreer_enum);
 
-/* Left analog microphone selection */
-static const char *twl4030_analoglmic_texts[] =
-                {"Off", "Main mic", "Headset mic", "AUXL", "Carkit mic"};
+/* Handsfree Right virtual mute */
+static const struct snd_kcontrol_new twl4030_dapm_handsfreermute_control =
+        SOC_DAPM_SINGLE("Switch", TWL4030_REG_SW_SHADOW, 1, 1, 0);
 
-static const unsigned int twl4030_analoglmic_values[] =
-                {0x0, 0x1, 0x2, 0x4, 0x8};
+/* Vibra */
+/* Vibra audio path selection */
+static const char *twl4030_vibra_texts[] =
+                {"AudioL1", "AudioR1", "AudioL2", "AudioR2"};
 
-static const struct soc_enum twl4030_analoglmic_enum =
-        SOC_VALUE_ENUM_SINGLE(TWL4030_REG_ANAMICL, 0, 0xf,
-                        ARRAY_SIZE(twl4030_analoglmic_texts),
-                        twl4030_analoglmic_texts,
-                        twl4030_analoglmic_values);
+static const struct soc_enum twl4030_vibra_enum =
+        SOC_ENUM_SINGLE(TWL4030_REG_VIBRA_CTL, 2,
+                        ARRAY_SIZE(twl4030_vibra_texts),
+                        twl4030_vibra_texts);
 
-static const struct snd_kcontrol_new twl4030_dapm_analoglmic_control =
-SOC_DAPM_VALUE_ENUM("Route", twl4030_analoglmic_enum);
+static const struct snd_kcontrol_new twl4030_dapm_vibra_control =
+SOC_DAPM_ENUM("Route", twl4030_vibra_enum);
 
-/* Right analog microphone selection */
-static const char *twl4030_analogrmic_texts[] =
-                {"Off", "Sub mic", "AUXR"};
+/* Vibra path selection: local vibrator (PWM) or audio driven */
+static const char *twl4030_vibrapath_texts[] =
+                {"Local vibrator", "Audio"};
 
-static const unsigned int twl4030_analogrmic_values[] =
-                {0x0, 0x1, 0x4};
+static const struct soc_enum twl4030_vibrapath_enum =
+        SOC_ENUM_SINGLE(TWL4030_REG_VIBRA_CTL, 4,
+                        ARRAY_SIZE(twl4030_vibrapath_texts),
+                        twl4030_vibrapath_texts);
 
-static const struct soc_enum twl4030_analogrmic_enum =
-        SOC_VALUE_ENUM_SINGLE(TWL4030_REG_ANAMICR, 0, 0x5,
-                        ARRAY_SIZE(twl4030_analogrmic_texts),
-                        twl4030_analogrmic_texts,
-                        twl4030_analogrmic_values);
+static const struct snd_kcontrol_new twl4030_dapm_vibrapath_control =
+SOC_DAPM_ENUM("Route", twl4030_vibrapath_enum);
 
-static const struct snd_kcontrol_new twl4030_dapm_analogrmic_control =
-SOC_DAPM_VALUE_ENUM("Route", twl4030_analogrmic_enum);
+/* Left analog microphone selection */
+static const struct snd_kcontrol_new twl4030_dapm_analoglmic_controls[] = {
+        SOC_DAPM_SINGLE("Main Mic Capture Switch",
+                        TWL4030_REG_ANAMICL, 0, 1, 0),
+        SOC_DAPM_SINGLE("Headset Mic Capture Switch",
+                        TWL4030_REG_ANAMICL, 1, 1, 0),
+        SOC_DAPM_SINGLE("AUXL Capture Switch",
+                        TWL4030_REG_ANAMICL, 2, 1, 0),
+        SOC_DAPM_SINGLE("Carkit Mic Capture Switch",
+                        TWL4030_REG_ANAMICL, 3, 1, 0),
+};
+
+/* Right analog microphone selection */
+static const struct snd_kcontrol_new twl4030_dapm_analogrmic_controls[] = {
+        SOC_DAPM_SINGLE("Sub Mic Capture Switch", TWL4030_REG_ANAMICR, 0, 1, 0),
+        SOC_DAPM_SINGLE("AUXR Capture Switch", TWL4030_REG_ANAMICR, 2, 1, 0),
+};
 
 /* TX1 L/R Analog/Digital microphone selection */
 static const char *twl4030_micpathtx1_texts[] =
@@ -507,6 +455,10 @@ static const struct snd_kcontrol_new twl4030_dapm_abypassr2_control =
 static const struct snd_kcontrol_new twl4030_dapm_abypassl2_control =
         SOC_DAPM_SINGLE("Switch", TWL4030_REG_ARXL2_APGA_CTL, 2, 1, 0);
 
+/* Analog bypass for Voice */
+static const struct snd_kcontrol_new twl4030_dapm_abypassv_control =
+        SOC_DAPM_SINGLE("Switch", TWL4030_REG_VDL_APGA_CTL, 2, 1, 0);
+
 /* Digital bypass gain, 0 mutes the bypass */
 static const unsigned int twl4030_dapm_dbypass_tlv[] = {
         TLV_DB_RANGE_HEAD(2),
@@ -526,6 +478,18 @@ static const struct snd_kcontrol_new twl4030_dapm_dbypassr_control =
                         TWL4030_REG_ATX2ARXPGA, 0, 7, 0,
                         twl4030_dapm_dbypass_tlv);
 
+/*
+ * Voice Sidetone GAIN volume control:
+ * from -51 to -10 dB in 1 dB steps (mute instead of -51 dB)
+ */
+static DECLARE_TLV_DB_SCALE(twl4030_dapm_dbypassv_tlv, -5100, 100, 1);
+
+/* Digital bypass voice: sidetone (VUL -> VDL)*/
+static const struct snd_kcontrol_new twl4030_dapm_dbypassv_control =
+        SOC_DAPM_SINGLE_TLV("Volume",
+                        TWL4030_REG_VSTPGA, 0, 0x29, 0,
+                        twl4030_dapm_dbypassv_tlv);
+
 static int micpath_event(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
@@ -556,63 +520,205 @@ static int micpath_event(struct snd_soc_dapm_widget *w,
         return 0;
 }
 
-static int handsfree_event(struct snd_soc_dapm_widget *w,
-                struct snd_kcontrol *kcontrol, int event)
+/*
+ * Output PGA builder:
+ * Handle the muting and unmuting of the given output (turning off the
+ * amplifier associated with the output pin)
+ * On mute bypass the reg_cache and mute the volume
+ * On unmute: restore the register content
+ * Outputs handled in this way:  Earpiece, PreDrivL/R, CarkitL/R
+ */
+#define TWL4030_OUTPUT_PGA(pin_name, reg, mask)                         \
+static int pin_name##pga_event(struct snd_soc_dapm_widget *w,           \
+                struct snd_kcontrol *kcontrol, int event)               \
+{                                                                       \
+        u8 reg_val;                                                     \
+                                                                        \
+        switch (event) {                                                \
+        case SND_SOC_DAPM_POST_PMU:                                     \
+                twl4030_write(w->codec, reg,                            \
+                        twl4030_read_reg_cache(w->codec, reg));         \
+                break;                                                  \
+        case SND_SOC_DAPM_POST_PMD:                                     \
+                reg_val = twl4030_read_reg_cache(w->codec, reg);        \
+                twl4030_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE,        \
+                                        reg_val & (~mask),              \
+                                        reg);                           \
+                break;                                                  \
+        }                                                               \
+        return 0;                                                       \
+}
+
+TWL4030_OUTPUT_PGA(earpiece, TWL4030_REG_EAR_CTL, TWL4030_EAR_GAIN);
+TWL4030_OUTPUT_PGA(predrivel, TWL4030_REG_PREDL_CTL, TWL4030_PREDL_GAIN);
+TWL4030_OUTPUT_PGA(predriver, TWL4030_REG_PREDR_CTL, TWL4030_PREDR_GAIN);
+TWL4030_OUTPUT_PGA(carkitl, TWL4030_REG_PRECKL_CTL, TWL4030_PRECKL_GAIN);
+TWL4030_OUTPUT_PGA(carkitr, TWL4030_REG_PRECKR_CTL, TWL4030_PRECKR_GAIN);
+
+static void handsfree_ramp(struct snd_soc_codec *codec, int reg, int ramp)
 {
-        struct soc_enum *e = (struct soc_enum *)w->kcontrols->private_value;
         unsigned char hs_ctl;
 
-        hs_ctl = twl4030_read_reg_cache(w->codec, e->reg);
+        hs_ctl = twl4030_read_reg_cache(codec, reg);
 
-        if (hs_ctl & TWL4030_HF_CTL_REF_EN) {
+        if (ramp) {
+                /* HF ramp-up */
+                hs_ctl |= TWL4030_HF_CTL_REF_EN;
+                twl4030_write(codec, reg, hs_ctl);
+                udelay(10);
                 hs_ctl |= TWL4030_HF_CTL_RAMP_EN;
-                twl4030_write(w->codec, e->reg, hs_ctl);
+                twl4030_write(codec, reg, hs_ctl);
+                udelay(40);
                 hs_ctl |= TWL4030_HF_CTL_LOOP_EN;
-                twl4030_write(w->codec, e->reg, hs_ctl);
                 hs_ctl |= TWL4030_HF_CTL_HB_EN;
-                twl4030_write(w->codec, e->reg, hs_ctl);
+                twl4030_write(codec, reg, hs_ctl);
         } else {
-                hs_ctl &= ~(TWL4030_HF_CTL_RAMP_EN | TWL4030_HF_CTL_LOOP_EN
-                                | TWL4030_HF_CTL_HB_EN);
-                twl4030_write(w->codec, e->reg, hs_ctl);
+                /* HF ramp-down */
+                hs_ctl &= ~TWL4030_HF_CTL_LOOP_EN;
+                hs_ctl &= ~TWL4030_HF_CTL_HB_EN;
+                twl4030_write(codec, reg, hs_ctl);
+                hs_ctl &= ~TWL4030_HF_CTL_RAMP_EN;
+                twl4030_write(codec, reg, hs_ctl);
+                udelay(40);
+                hs_ctl &= ~TWL4030_HF_CTL_REF_EN;
+                twl4030_write(codec, reg, hs_ctl);
         }
+}
 
+static int handsfreelpga_event(struct snd_soc_dapm_widget *w,
+                struct snd_kcontrol *kcontrol, int event)
+{
+        switch (event) {
+        case SND_SOC_DAPM_POST_PMU:
+                handsfree_ramp(w->codec, TWL4030_REG_HFL_CTL, 1);
+                break;
+        case SND_SOC_DAPM_POST_PMD:
+                handsfree_ramp(w->codec, TWL4030_REG_HFL_CTL, 0);
+                break;
+        }
         return 0;
 }
 
-static int headsetl_event(struct snd_soc_dapm_widget *w,
+static int handsfreerpga_event(struct snd_soc_dapm_widget *w,
                 struct snd_kcontrol *kcontrol, int event)
 {
-        unsigned char hs_gain, hs_pop;
-
-        /* Save the current volume */
-        hs_gain = twl4030_read_reg_cache(w->codec, TWL4030_REG_HS_GAIN_SET);
-        hs_pop = twl4030_read_reg_cache(w->codec, TWL4030_REG_HS_POPN_SET);
-
         switch (event) {
         case SND_SOC_DAPM_POST_PMU:
-                /* Do the anti-pop/bias ramp enable according to the TRM */
-                hs_pop |= TWL4030_VMID_EN;
-                twl4030_write(w->codec, TWL4030_REG_HS_POPN_SET, hs_pop);
-                /* Is this needed? Can we just use whatever gain here? */
-                twl4030_write(w->codec, TWL4030_REG_HS_GAIN_SET,
-                                (hs_gain & (~0x0f)) | 0x0a);
-                hs_pop |= TWL4030_RAMP_EN;
-                twl4030_write(w->codec, TWL4030_REG_HS_POPN_SET, hs_pop);
-
-                /* Restore the original volume */
-                twl4030_write(w->codec, TWL4030_REG_HS_GAIN_SET, hs_gain);
+                handsfree_ramp(w->codec, TWL4030_REG_HFR_CTL, 1);
                 break;
         case SND_SOC_DAPM_POST_PMD:
-                /* Do the anti-pop/bias ramp disable according to the TRM */
+                handsfree_ramp(w->codec, TWL4030_REG_HFR_CTL, 0);
+                break;
+        }
+        return 0;
+}
+
+static void headset_ramp(struct snd_soc_codec *codec, int ramp)
+{
+        struct snd_soc_device *socdev = codec->socdev;
+        struct twl4030_setup_data *setup = socdev->codec_data;
+
+        unsigned char hs_gain, hs_pop;
+        struct twl4030_priv *twl4030 = codec->private_data;
+        /* Base values for ramp delay calculation: 2^19 - 2^26 */
+        unsigned int ramp_base[] = {524288, 1048576, 2097152, 4194304,
+                                    8388608, 16777216, 33554432, 67108864};
+
+        hs_gain = twl4030_read_reg_cache(codec, TWL4030_REG_HS_GAIN_SET);
+        hs_pop = twl4030_read_reg_cache(codec, TWL4030_REG_HS_POPN_SET);
+
+        /* Enable external mute control, this dramatically reduces
+         * the pop-noise */
+        if (setup && setup->hs_extmute) {
+                if (setup->set_hs_extmute) {
+                        setup->set_hs_extmute(1);
+                } else {
+                        hs_pop |= TWL4030_EXTMUTE;
+                        twl4030_write(codec, TWL4030_REG_HS_POPN_SET, hs_pop);
+                }
+        }
+
+        if (ramp) {
+                /* Headset ramp-up according to the TRM */
+                hs_pop |= TWL4030_VMID_EN;
+                twl4030_write(codec, TWL4030_REG_HS_POPN_SET, hs_pop);
+                twl4030_write(codec, TWL4030_REG_HS_GAIN_SET, hs_gain);
+                hs_pop |= TWL4030_RAMP_EN;
+                twl4030_write(codec, TWL4030_REG_HS_POPN_SET, hs_pop);
+                /* Wait ramp delay time + 1, so the VMID can settle */
+                mdelay((ramp_base[(hs_pop & TWL4030_RAMP_DELAY) >> 2] /
+                        twl4030->sysclk) + 1);
+        } else {
+                /* Headset ramp-down _not_ according to
+                 * the TRM, but in a way that it is working */
                 hs_pop &= ~TWL4030_RAMP_EN;
-                twl4030_write(w->codec, TWL4030_REG_HS_POPN_SET, hs_pop);
+                twl4030_write(codec, TWL4030_REG_HS_POPN_SET, hs_pop);
+                /* Wait ramp delay time + 1, so the VMID can settle */
+                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,
                                         hs_gain & (~0x0f),
                                         TWL4030_REG_HS_GAIN_SET);
+
                 hs_pop &= ~TWL4030_VMID_EN;
-                twl4030_write(w->codec, TWL4030_REG_HS_POPN_SET, hs_pop);
+                twl4030_write(codec, TWL4030_REG_HS_POPN_SET, hs_pop);
+        }
+
+        /* Disable external mute */
+        if (setup && setup->hs_extmute) {
+                if (setup->set_hs_extmute) {
+                        setup->set_hs_extmute(0);
+                } else {
+                        hs_pop &= ~TWL4030_EXTMUTE;
+                        twl4030_write(codec, TWL4030_REG_HS_POPN_SET, hs_pop);
+                }
+        }
+}
+
+static int headsetlpga_event(struct snd_soc_dapm_widget *w,
+                struct snd_kcontrol *kcontrol, int event)
+{
+        struct twl4030_priv *twl4030 = w->codec->private_data;
+
+        switch (event) {
+        case SND_SOC_DAPM_POST_PMU:
+                /* Do the ramp-up only once */
+                if (!twl4030->hsr_enabled)
+                        headset_ramp(w->codec, 1);
+
+                twl4030->hsl_enabled = 1;
+                break;
+        case SND_SOC_DAPM_POST_PMD:
+                /* Do the ramp-down only if both headsetL/R is disabled */
+                if (!twl4030->hsr_enabled)
+                        headset_ramp(w->codec, 0);
+
+                twl4030->hsl_enabled = 0;
+                break;
+        }
+        return 0;
+}
+
+static int headsetrpga_event(struct snd_soc_dapm_widget *w,
+                struct snd_kcontrol *kcontrol, int event)
+{
+        struct twl4030_priv *twl4030 = w->codec->private_data;
+
+        switch (event) {
+        case SND_SOC_DAPM_POST_PMU:
+                /* Do the ramp-up only once */
+                if (!twl4030->hsl_enabled)
+                        headset_ramp(w->codec, 1);
+
+                twl4030->hsr_enabled = 1;
+                break;
+        case SND_SOC_DAPM_POST_PMD:
+                /* Do the ramp-down only if both headsetL/R is disabled */
+                if (!twl4030->hsl_enabled)
+                        headset_ramp(w->codec, 0);
+
+                twl4030->hsr_enabled = 0;
                 break;
         }
         return 0;
@@ -624,11 +730,23 @@ static int bypass_event(struct snd_soc_dapm_widget *w,
         struct soc_mixer_control *m =
                 (struct soc_mixer_control *)w->kcontrols->private_value;
         struct twl4030_priv *twl4030 = w->codec->private_data;
-        unsigned char reg;
+        unsigned char reg, misc;
 
         reg = twl4030_read_reg_cache(w->codec, m->reg);
 
-        if (m->reg <= TWL4030_REG_ARXR2_APGA_CTL) {
+        /*
+         * 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 |=
@@ -636,14 +754,28 @@ static int bypass_event(struct snd_soc_dapm_widget *w,
                 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 ? 5 : 4));
+                        twl4030->bypass_state |= (1 << (m->shift ? 7 : 6));
                 else
-                        twl4030->bypass_state &= ~(1 << (m->shift ? 5 : 4));
+                        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);
@@ -810,6 +942,48 @@ static int snd_soc_put_volsw_r2_twl4030(struct snd_kcontrol *kcontrol,
         return err;
 }
 
+/* Codec operation modes */
+static const char *twl4030_op_modes_texts[] = {
+        "Option 2 (voice/audio)", "Option 1 (audio)"
+};
+
+static const struct soc_enum twl4030_op_modes_enum =
+        SOC_ENUM_SINGLE(TWL4030_REG_CODEC_MODE, 0,
+                        ARRAY_SIZE(twl4030_op_modes_texts),
+                        twl4030_op_modes_texts);
+
+static int snd_soc_put_twl4030_opmode_enum_double(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct twl4030_priv *twl4030 = codec->private_data;
+        struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
+        unsigned short val;
+        unsigned short mask, bitmask;
+
+        if (twl4030->configured) {
+                printk(KERN_ERR "twl4030 operation mode cannot be "
+                        "changed on-the-fly\n");
+                return -EBUSY;
+        }
+
+        for (bitmask = 1; bitmask < e->max; bitmask <<= 1)
+                ;
+        if (ucontrol->value.enumerated.item[0] > e->max - 1)
+                return -EINVAL;
+
+        val = ucontrol->value.enumerated.item[0] << e->shift_l;
+        mask = (bitmask - 1) << e->shift_l;
+        if (e->shift_l != e->shift_r) {
+                if (ucontrol->value.enumerated.item[1] > e->max - 1)
+                        return -EINVAL;
+                val |= ucontrol->value.enumerated.item[1] << e->shift_r;
+                mask |= (bitmask - 1) << e->shift_r;
+        }
+
+        return snd_soc_update_bits(codec, e->reg, mask, val);
+}
+
 /*
  * FGAIN volume control:
  * from -62 to 0 dB in 1 dB steps (mute instead of -63 dB)
@@ -824,6 +998,12 @@ static DECLARE_TLV_DB_SCALE(digital_fine_tlv, -6300, 100, 1);
 static DECLARE_TLV_DB_SCALE(digital_coarse_tlv, 0, 600, 0);
 
 /*
+ * Voice Downlink GAIN volume control:
+ * from -37 to 12 dB in 1 dB steps (mute instead of -37 dB)
+ */
+static DECLARE_TLV_DB_SCALE(digital_voice_downlink_tlv, -3700, 100, 1);
+
+/*
  * Analog playback gain
  * -24 dB to 12 dB in 2 dB steps
  */
@@ -853,6 +1033,16 @@ static DECLARE_TLV_DB_SCALE(digital_capture_tlv, 0, 100, 0);
  */
 static DECLARE_TLV_DB_SCALE(input_gain_tlv, 0, 600, 0);
 
+/* AVADC clock priority */
+static const char *twl4030_avadc_clk_priority_texts[] = {
+        "Voice high priority", "HiFi high priority"
+};
+
+static const struct soc_enum twl4030_avadc_clk_priority_enum =
+        SOC_ENUM_SINGLE(TWL4030_REG_AVADC_CTL, 2,
+                        ARRAY_SIZE(twl4030_avadc_clk_priority_texts),
+                        twl4030_avadc_clk_priority_texts);
+
 static const char *twl4030_rampdelay_texts[] = {
         "27/20/14 ms", "55/40/27 ms", "109/81/55 ms", "218/161/109 ms",
         "437/323/218 ms", "874/645/437 ms", "1748/1291/874 ms",
@@ -864,7 +1054,32 @@ static const struct soc_enum twl4030_rampdelay_enum =
                         ARRAY_SIZE(twl4030_rampdelay_texts),
                         twl4030_rampdelay_texts);
 
+/* Vibra H-bridge direction mode */
+static const char *twl4030_vibradirmode_texts[] = {
+        "Vibra H-bridge direction", "Audio data MSB",
+};
+
+static const struct soc_enum twl4030_vibradirmode_enum =
+        SOC_ENUM_SINGLE(TWL4030_REG_VIBRA_CTL, 5,
+                        ARRAY_SIZE(twl4030_vibradirmode_texts),
+                        twl4030_vibradirmode_texts);
+
+/* Vibra H-bridge direction */
+static const char *twl4030_vibradir_texts[] = {
+        "Positive polarity", "Negative polarity",
+};
+
+static const struct soc_enum twl4030_vibradir_enum =
+        SOC_ENUM_SINGLE(TWL4030_REG_VIBRA_CTL, 1,
+                        ARRAY_SIZE(twl4030_vibradir_texts),
+                        twl4030_vibradir_texts);
+
 static const struct snd_kcontrol_new twl4030_snd_controls[] = {
+        /* Codec operation mode control */
+        SOC_ENUM_EXT("Codec Operation Mode", twl4030_op_modes_enum,
+                snd_soc_get_enum_double,
+                snd_soc_put_twl4030_opmode_enum_double),
+
         /* Common playback gain controls */
         SOC_DOUBLE_R_TLV("DAC1 Digital Fine Playback Volume",
                 TWL4030_REG_ARXL1PGA, TWL4030_REG_ARXR1PGA,
@@ -893,6 +1108,16 @@ static const struct snd_kcontrol_new twl4030_snd_controls[] = {
                 TWL4030_REG_ARXL2_APGA_CTL, TWL4030_REG_ARXR2_APGA_CTL,
                 1, 1, 0),
 
+        /* Common voice downlink gain controls */
+        SOC_SINGLE_TLV("DAC Voice Digital Downlink Volume",
+                TWL4030_REG_VRXPGA, 0, 0x31, 0, digital_voice_downlink_tlv),
+
+        SOC_SINGLE_TLV("DAC Voice Analog Downlink Volume",
+                TWL4030_REG_VDL_APGA_CTL, 3, 0x12, 1, analog_tlv),
+
+        SOC_SINGLE("DAC Voice Analog Downlink Switch",
+                TWL4030_REG_VDL_APGA_CTL, 1, 1, 0),
+
         /* Separate output gain controls */
         SOC_DOUBLE_R_TLV_TWL4030("PreDriv Playback Volume",
                 TWL4030_REG_PREDL_CTL, TWL4030_REG_PREDR_CTL,
@@ -919,7 +1144,12 @@ static const struct snd_kcontrol_new twl4030_snd_controls[] = {
         SOC_DOUBLE_TLV("Analog Capture Volume", TWL4030_REG_ANAMIC_GAIN,
                 0, 3, 5, 0, input_gain_tlv),
 
+        SOC_ENUM("AVADC Clock Priority", twl4030_avadc_clk_priority_enum),
+
         SOC_ENUM("HS ramp delay", twl4030_rampdelay_enum),
+
+        SOC_ENUM("Vibra H-bridge mode", twl4030_vibradirmode_enum),
+        SOC_ENUM("Vibra H-bridge direction", twl4030_vibradir_enum),
 };
 
 static const struct snd_soc_dapm_widget twl4030_dapm_widgets[] = {
@@ -947,26 +1177,19 @@ static const struct snd_soc_dapm_widget twl4030_dapm_widgets[] = {
         SND_SOC_DAPM_OUTPUT("CARKITR"),
         SND_SOC_DAPM_OUTPUT("HFL"),
         SND_SOC_DAPM_OUTPUT("HFR"),
+        SND_SOC_DAPM_OUTPUT("VIBRA"),
 
         /* DACs */
-        SND_SOC_DAPM_DAC("DAC Right1", "Right Front Playback",
+        SND_SOC_DAPM_DAC("DAC Right1", "Right Front HiFi Playback",
                         SND_SOC_NOPM, 0, 0),
-        SND_SOC_DAPM_DAC("DAC Left1", "Left Front Playback",
+        SND_SOC_DAPM_DAC("DAC Left1", "Left Front HiFi Playback",
                         SND_SOC_NOPM, 0, 0),
-        SND_SOC_DAPM_DAC("DAC Right2", "Right Rear Playback",
+        SND_SOC_DAPM_DAC("DAC Right2", "Right Rear HiFi Playback",
                         SND_SOC_NOPM, 0, 0),
-        SND_SOC_DAPM_DAC("DAC Left2", "Left Rear Playback",
+        SND_SOC_DAPM_DAC("DAC Left2", "Left Rear HiFi Playback",
+                        SND_SOC_NOPM, 0, 0),
+        SND_SOC_DAPM_DAC("DAC Voice", "Voice Playback",
                         SND_SOC_NOPM, 0, 0),
-
-        /* Analog PGAs */
-        SND_SOC_DAPM_PGA("ARXR1_APGA", TWL4030_REG_ARXR1_APGA_CTL,
-                        0, 0, NULL, 0),
-        SND_SOC_DAPM_PGA("ARXL1_APGA", TWL4030_REG_ARXL1_APGA_CTL,
-                        0, 0, NULL, 0),
-        SND_SOC_DAPM_PGA("ARXR2_APGA", TWL4030_REG_ARXR2_APGA_CTL,
-                        0, 0, NULL, 0),
-        SND_SOC_DAPM_PGA("ARXL2_APGA", TWL4030_REG_ARXL2_APGA_CTL,
-                        0, 0, NULL, 0),
 
         /* Analog bypasses */
         SND_SOC_DAPM_SWITCH_E("Right1 Analog Loopback", SND_SOC_NOPM, 0, 0,
@@ -981,6 +1204,9 @@ static const struct snd_soc_dapm_widget twl4030_dapm_widgets[] = {
         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),
 
         /* Digital bypasses */
         SND_SOC_DAPM_SWITCH_E("Left Digital Loopback", SND_SOC_NOPM, 0, 0,
@@ -989,43 +1215,103 @@ static const struct snd_soc_dapm_widget twl4030_dapm_widgets[] = {
         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_MIXER("Analog R1 Playback Mixer", TWL4030_REG_AVDAC_CTL,
-                        0, 0, NULL, 0),
-        SND_SOC_DAPM_MIXER("Analog L1 Playback Mixer", TWL4030_REG_AVDAC_CTL,
-                        1, 0, NULL, 0),
-        SND_SOC_DAPM_MIXER("Analog R2 Playback Mixer", TWL4030_REG_AVDAC_CTL,
-                        2, 0, NULL, 0),
-        SND_SOC_DAPM_MIXER("Analog L2 Playback Mixer", TWL4030_REG_AVDAC_CTL,
-                        3, 0, NULL, 0),
-
-        /* Output MUX controls */
+        /* Digital mixers, power control for the physical DACs */
+        SND_SOC_DAPM_MIXER("Digital R1 Playback Mixer",
+                        TWL4030_REG_AVDAC_CTL, 0, 0, NULL, 0),
+        SND_SOC_DAPM_MIXER("Digital L1 Playback Mixer",
+                        TWL4030_REG_AVDAC_CTL, 1, 0, NULL, 0),
+        SND_SOC_DAPM_MIXER("Digital R2 Playback Mixer",
+                        TWL4030_REG_AVDAC_CTL, 2, 0, NULL, 0),
+        SND_SOC_DAPM_MIXER("Digital L2 Playback Mixer",
+                        TWL4030_REG_AVDAC_CTL, 3, 0, NULL, 0),
+        SND_SOC_DAPM_MIXER("Digital Voice Playback Mixer",
+                        TWL4030_REG_AVDAC_CTL, 4, 0, NULL, 0),
+
+        /* Analog mixers, power control for the physical PGAs */
+        SND_SOC_DAPM_MIXER("Analog R1 Playback Mixer",
+                        TWL4030_REG_ARXR1_APGA_CTL, 0, 0, NULL, 0),
+        SND_SOC_DAPM_MIXER("Analog L1 Playback Mixer",
+                        TWL4030_REG_ARXL1_APGA_CTL, 0, 0, NULL, 0),
+        SND_SOC_DAPM_MIXER("Analog R2 Playback Mixer",
+                        TWL4030_REG_ARXR2_APGA_CTL, 0, 0, NULL, 0),
+        SND_SOC_DAPM_MIXER("Analog L2 Playback Mixer",
+                        TWL4030_REG_ARXL2_APGA_CTL, 0, 0, NULL, 0),
+        SND_SOC_DAPM_MIXER("Analog Voice Playback Mixer",
+                        TWL4030_REG_VDL_APGA_CTL, 0, 0, NULL, 0),
+
+        /* Output MIXER controls */
         /* Earpiece */
-        SND_SOC_DAPM_VALUE_MUX("Earpiece Mux", SND_SOC_NOPM, 0, 0,
-                &twl4030_dapm_earpiece_control),
+        SND_SOC_DAPM_MIXER("Earpiece Mixer", SND_SOC_NOPM, 0, 0,
+                        &twl4030_dapm_earpiece_controls[0],
+                        ARRAY_SIZE(twl4030_dapm_earpiece_controls)),
+        SND_SOC_DAPM_PGA_E("Earpiece PGA", SND_SOC_NOPM,
+                        0, 0, NULL, 0, earpiecepga_event,
+                        SND_SOC_DAPM_POST_PMU|SND_SOC_DAPM_POST_PMD),
         /* PreDrivL/R */
-        SND_SOC_DAPM_VALUE_MUX("PredriveL Mux", SND_SOC_NOPM, 0, 0,
-                &twl4030_dapm_predrivel_control),
-        SND_SOC_DAPM_VALUE_MUX("PredriveR Mux", SND_SOC_NOPM, 0, 0,
-                &twl4030_dapm_predriver_control),
+        SND_SOC_DAPM_MIXER("PredriveL Mixer", SND_SOC_NOPM, 0, 0,
+                        &twl4030_dapm_predrivel_controls[0],
+                        ARRAY_SIZE(twl4030_dapm_predrivel_controls)),
+        SND_SOC_DAPM_PGA_E("PredriveL PGA", SND_SOC_NOPM,
+                        0, 0, NULL, 0, predrivelpga_event,
+                        SND_SOC_DAPM_POST_PMU|SND_SOC_DAPM_POST_PMD),
+        SND_SOC_DAPM_MIXER("PredriveR Mixer", SND_SOC_NOPM, 0, 0,
+                        &twl4030_dapm_predriver_controls[0],
+                        ARRAY_SIZE(twl4030_dapm_predriver_controls)),
+        SND_SOC_DAPM_PGA_E("PredriveR PGA", SND_SOC_NOPM,
+                        0, 0, NULL, 0, predriverpga_event,
+                        SND_SOC_DAPM_POST_PMU|SND_SOC_DAPM_POST_PMD),
         /* HeadsetL/R */
-        SND_SOC_DAPM_MUX_E("HeadsetL Mux", SND_SOC_NOPM, 0, 0,
-                &twl4030_dapm_hsol_control, headsetl_event,
-                SND_SOC_DAPM_POST_PMU|SND_SOC_DAPM_POST_PMD),
-        SND_SOC_DAPM_MUX("HeadsetR Mux", SND_SOC_NOPM, 0, 0,
-                &twl4030_dapm_hsor_control),
+        SND_SOC_DAPM_MIXER("HeadsetL Mixer", SND_SOC_NOPM, 0, 0,
+                        &twl4030_dapm_hsol_controls[0],
+                        ARRAY_SIZE(twl4030_dapm_hsol_controls)),
+        SND_SOC_DAPM_PGA_E("HeadsetL PGA", SND_SOC_NOPM,
+                        0, 0, NULL, 0, headsetlpga_event,
+                        SND_SOC_DAPM_POST_PMU|SND_SOC_DAPM_POST_PMD),
+        SND_SOC_DAPM_MIXER("HeadsetR Mixer", SND_SOC_NOPM, 0, 0,
+                        &twl4030_dapm_hsor_controls[0],
+                        ARRAY_SIZE(twl4030_dapm_hsor_controls)),
+        SND_SOC_DAPM_PGA_E("HeadsetR PGA", SND_SOC_NOPM,
+                        0, 0, NULL, 0, headsetrpga_event,
+                        SND_SOC_DAPM_POST_PMU|SND_SOC_DAPM_POST_PMD),
         /* CarkitL/R */
-        SND_SOC_DAPM_MUX("CarkitL Mux", SND_SOC_NOPM, 0, 0,
-                &twl4030_dapm_carkitl_control),
-        SND_SOC_DAPM_MUX("CarkitR Mux", SND_SOC_NOPM, 0, 0,
-                &twl4030_dapm_carkitr_control),
+        SND_SOC_DAPM_MIXER("CarkitL Mixer", SND_SOC_NOPM, 0, 0,
+                        &twl4030_dapm_carkitl_controls[0],
+                        ARRAY_SIZE(twl4030_dapm_carkitl_controls)),
+        SND_SOC_DAPM_PGA_E("CarkitL PGA", SND_SOC_NOPM,
+                        0, 0, NULL, 0, carkitlpga_event,
+                        SND_SOC_DAPM_POST_PMU|SND_SOC_DAPM_POST_PMD),
+        SND_SOC_DAPM_MIXER("CarkitR Mixer", SND_SOC_NOPM, 0, 0,
+                        &twl4030_dapm_carkitr_controls[0],
+                        ARRAY_SIZE(twl4030_dapm_carkitr_controls)),
+        SND_SOC_DAPM_PGA_E("CarkitR PGA", SND_SOC_NOPM,
+                        0, 0, NULL, 0, carkitrpga_event,
+                        SND_SOC_DAPM_POST_PMU|SND_SOC_DAPM_POST_PMD),
+
+        /* Output MUX controls */
         /* HandsfreeL/R */
-        SND_SOC_DAPM_MUX_E("HandsfreeL Mux", TWL4030_REG_HFL_CTL, 5, 0,
-                &twl4030_dapm_handsfreel_control, handsfree_event,
-                SND_SOC_DAPM_POST_PMU|SND_SOC_DAPM_POST_PMD),
-        SND_SOC_DAPM_MUX_E("HandsfreeR Mux", TWL4030_REG_HFR_CTL, 5, 0,
-                &twl4030_dapm_handsfreer_control, handsfree_event,
-                SND_SOC_DAPM_POST_PMU|SND_SOC_DAPM_POST_PMD),
+        SND_SOC_DAPM_MUX("HandsfreeL Mux", SND_SOC_NOPM, 0, 0,
+                &twl4030_dapm_handsfreel_control),
+        SND_SOC_DAPM_SWITCH("HandsfreeL", SND_SOC_NOPM, 0, 0,
+                        &twl4030_dapm_handsfreelmute_control),
+        SND_SOC_DAPM_PGA_E("HandsfreeL PGA", SND_SOC_NOPM,
+                        0, 0, NULL, 0, handsfreelpga_event,
+                        SND_SOC_DAPM_POST_PMU|SND_SOC_DAPM_POST_PMD),
+        SND_SOC_DAPM_MUX("HandsfreeR Mux", SND_SOC_NOPM, 5, 0,
+                &twl4030_dapm_handsfreer_control),
+        SND_SOC_DAPM_SWITCH("HandsfreeR", SND_SOC_NOPM, 0, 0,
+                        &twl4030_dapm_handsfreermute_control),
+        SND_SOC_DAPM_PGA_E("HandsfreeR PGA", SND_SOC_NOPM,
+                        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("Vibra Route", SND_SOC_NOPM, 0, 0,
+                &twl4030_dapm_vibrapath_control),
 
         /* Introducing four virtual ADC, since TWL4030 have four channel for
            capture */
@@ -1050,11 +1336,15 @@ static const struct snd_soc_dapm_widget twl4030_dapm_widgets[] = {
                 SND_SOC_DAPM_POST_PMU|SND_SOC_DAPM_POST_PMD|
                 SND_SOC_DAPM_POST_REG),
 
-        /* Analog input muxes with switch for the capture amplifiers */
-        SND_SOC_DAPM_VALUE_MUX("Analog Left Capture Route",
-                TWL4030_REG_ANAMICL, 4, 0, &twl4030_dapm_analoglmic_control),
-        SND_SOC_DAPM_VALUE_MUX("Analog Right Capture Route",
-                TWL4030_REG_ANAMICR, 4, 0, &twl4030_dapm_analogrmic_control),
+        /* Analog input mixers for the capture amplifiers */
+        SND_SOC_DAPM_MIXER("Analog Left",
+                TWL4030_REG_ANAMICL, 4, 0,
+                &twl4030_dapm_analoglmic_controls[0],
+                ARRAY_SIZE(twl4030_dapm_analoglmic_controls)),
+        SND_SOC_DAPM_MIXER("Analog Right",
+                TWL4030_REG_ANAMICR, 4, 0,
+                &twl4030_dapm_analogrmic_controls[0],
+                ARRAY_SIZE(twl4030_dapm_analogrmic_controls)),
 
         SND_SOC_DAPM_PGA("ADC Physical Left",
                 TWL4030_REG_AVADC_CTL, 3, 0, NULL, 0),
@@ -1073,74 +1363,103 @@ static const struct snd_soc_dapm_widget twl4030_dapm_widgets[] = {
 };
 
 static const struct snd_soc_dapm_route intercon[] = {
-        {"Analog L1 Playback Mixer", NULL, "DAC Left1"},
-        {"Analog R1 Playback Mixer", NULL, "DAC Right1"},
-        {"Analog L2 Playback Mixer", NULL, "DAC Left2"},
-        {"Analog R2 Playback Mixer", NULL, "DAC Right2"},
-
-        {"ARXL1_APGA", NULL, "Analog L1 Playback Mixer"},
-        {"ARXR1_APGA", NULL, "Analog R1 Playback Mixer"},
-        {"ARXL2_APGA", NULL, "Analog L2 Playback Mixer"},
-        {"ARXR2_APGA", NULL, "Analog R2 Playback Mixer"},
+        {"Digital L1 Playback Mixer", NULL, "DAC Left1"},
+        {"Digital R1 Playback Mixer", NULL, "DAC Right1"},
+        {"Digital L2 Playback Mixer", NULL, "DAC Left2"},
+        {"Digital R2 Playback Mixer", NULL, "DAC Right2"},
+        {"Digital Voice Playback Mixer", NULL, "DAC Voice"},
+
+        {"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"},
+        {"Analog R2 Playback Mixer", NULL, "Digital R2 Playback Mixer"},
+        {"Analog Voice Playback Mixer", NULL, "Digital Voice Playback Mixer"},
 
         /* Internal playback routings */
         /* Earpiece */
-        {"Earpiece Mux", "DACL1", "ARXL1_APGA"},
-        {"Earpiece Mux", "DACL2", "ARXL2_APGA"},
-        {"Earpiece Mux", "DACR1", "ARXR1_APGA"},
+        {"Earpiece Mixer", "Voice", "Analog Voice Playback Mixer"},
+        {"Earpiece Mixer", "AudioL1", "Analog L1 Playback Mixer"},
+        {"Earpiece Mixer", "AudioL2", "Analog L2 Playback Mixer"},
+        {"Earpiece Mixer", "AudioR1", "Analog R1 Playback Mixer"},
+        {"Earpiece PGA", NULL, "Earpiece Mixer"},
         /* PreDrivL */
-        {"PredriveL Mux", "DACL1", "ARXL1_APGA"},
-        {"PredriveL Mux", "DACL2", "ARXL2_APGA"},
-        {"PredriveL Mux", "DACR2", "ARXR2_APGA"},
+        {"PredriveL Mixer", "Voice", "Analog Voice Playback Mixer"},
+        {"PredriveL Mixer", "AudioL1", "Analog L1 Playback Mixer"},
+        {"PredriveL Mixer", "AudioL2", "Analog L2 Playback Mixer"},
+        {"PredriveL Mixer", "AudioR2", "Analog R2 Playback Mixer"},
+        {"PredriveL PGA", NULL, "PredriveL Mixer"},
         /* PreDrivR */
-        {"PredriveR Mux", "DACR1", "ARXR1_APGA"},
-        {"PredriveR Mux", "DACR2", "ARXR2_APGA"},
-        {"PredriveR Mux", "DACL2", "ARXL2_APGA"},
+        {"PredriveR Mixer", "Voice", "Analog Voice Playback Mixer"},
+        {"PredriveR Mixer", "AudioR1", "Analog R1 Playback Mixer"},
+        {"PredriveR Mixer", "AudioR2", "Analog R2 Playback Mixer"},
+        {"PredriveR Mixer", "AudioL2", "Analog L2 Playback Mixer"},
+        {"PredriveR PGA", NULL, "PredriveR Mixer"},
         /* HeadsetL */
-        {"HeadsetL Mux", "DACL1", "ARXL1_APGA"},
-        {"HeadsetL Mux", "DACL2", "ARXL2_APGA"},
+        {"HeadsetL Mixer", "Voice", "Analog Voice Playback Mixer"},
+        {"HeadsetL Mixer", "AudioL1", "Analog L1 Playback Mixer"},
+        {"HeadsetL Mixer", "AudioL2", "Analog L2 Playback Mixer"},
+        {"HeadsetL PGA", NULL, "HeadsetL Mixer"},
         /* HeadsetR */
-        {"HeadsetR Mux", "DACR1", "ARXR1_APGA"},
-        {"HeadsetR Mux", "DACR2", "ARXR2_APGA"},
+        {"HeadsetR Mixer", "Voice", "Analog Voice Playback Mixer"},
+        {"HeadsetR Mixer", "AudioR1", "Analog R1 Playback Mixer"},
+        {"HeadsetR Mixer", "AudioR2", "Analog R2 Playback Mixer"},
+        {"HeadsetR PGA", NULL, "HeadsetR Mixer"},
         /* CarkitL */
-        {"CarkitL Mux", "DACL1", "ARXL1_APGA"},
-        {"CarkitL Mux", "DACL2", "ARXL2_APGA"},
+        {"CarkitL Mixer", "Voice", "Analog Voice Playback Mixer"},
+        {"CarkitL Mixer", "AudioL1", "Analog L1 Playback Mixer"},
+        {"CarkitL Mixer", "AudioL2", "Analog L2 Playback Mixer"},
+        {"CarkitL PGA", NULL, "CarkitL Mixer"},
         /* CarkitR */
-        {"CarkitR Mux", "DACR1", "ARXR1_APGA"},
-        {"CarkitR Mux", "DACR2", "ARXR2_APGA"},
+        {"CarkitR Mixer", "Voice", "Analog Voice Playback Mixer"},
+        {"CarkitR Mixer", "AudioR1", "Analog R1 Playback Mixer"},
+        {"CarkitR Mixer", "AudioR2", "Analog R2 Playback Mixer"},
+        {"CarkitR PGA", NULL, "CarkitR Mixer"},
         /* HandsfreeL */
-        {"HandsfreeL Mux", "DACL1", "ARXL1_APGA"},
-        {"HandsfreeL Mux", "DACL2", "ARXL2_APGA"},
-        {"HandsfreeL Mux", "DACR2", "ARXR2_APGA"},
+        {"HandsfreeL Mux", "Voice", "Analog Voice Playback Mixer"},
+        {"HandsfreeL Mux", "AudioL1", "Analog L1 Playback Mixer"},
+        {"HandsfreeL Mux", "AudioL2", "Analog L2 Playback Mixer"},
+        {"HandsfreeL Mux", "AudioR2", "Analog R2 Playback Mixer"},
+        {"HandsfreeL", "Switch", "HandsfreeL Mux"},
+        {"HandsfreeL PGA", NULL, "HandsfreeL"},
         /* HandsfreeR */
-        {"HandsfreeR Mux", "DACR1", "ARXR1_APGA"},
-        {"HandsfreeR Mux", "DACR2", "ARXR2_APGA"},
-        {"HandsfreeR Mux", "DACL2", "ARXL2_APGA"},
+        {"HandsfreeR Mux", "Voice", "Analog Voice Playback Mixer"},
+        {"HandsfreeR Mux", "AudioR1", "Analog R1 Playback Mixer"},
+        {"HandsfreeR Mux", "AudioR2", "Analog R2 Playback Mixer"},
+        {"HandsfreeR Mux", "AudioL2", "Analog L2 Playback Mixer"},
+        {"HandsfreeR", "Switch", "HandsfreeR Mux"},
+        {"HandsfreeR PGA", NULL, "HandsfreeR"},
+        /* Vibra */
+        {"Vibra Mux", "AudioL1", "DAC Left1"},
+        {"Vibra Mux", "AudioR1", "DAC Right1"},
+        {"Vibra Mux", "AudioL2", "DAC Left2"},
+        {"Vibra Mux", "AudioR2", "DAC Right2"},
 
         /* outputs */
-        {"OUTL", NULL, "ARXL2_APGA"},
-        {"OUTR", NULL, "ARXR2_APGA"},
-        {"EARPIECE", NULL, "Earpiece Mux"},
-        {"PREDRIVEL", NULL, "PredriveL Mux"},
-        {"PREDRIVER", NULL, "PredriveR Mux"},
-        {"HSOL", NULL, "HeadsetL Mux"},
-        {"HSOR", NULL, "HeadsetR Mux"},
-        {"CARKITL", NULL, "CarkitL Mux"},
-        {"CARKITR", NULL, "CarkitR Mux"},
-        {"HFL", NULL, "HandsfreeL Mux"},
-        {"HFR", NULL, "HandsfreeR Mux"},
+        {"OUTL", NULL, "Analog L2 Playback Mixer"},
+        {"OUTR", NULL, "Analog R2 Playback Mixer"},
+        {"EARPIECE", NULL, "Earpiece PGA"},
+        {"PREDRIVEL", NULL, "PredriveL PGA"},
+        {"PREDRIVER", NULL, "PredriveR PGA"},
+        {"HSOL", NULL, "HeadsetL PGA"},
+        {"HSOR", NULL, "HeadsetR PGA"},
+        {"CARKITL", NULL, "CarkitL PGA"},
+        {"CARKITR", NULL, "CarkitR PGA"},
+        {"HFL", NULL, "HandsfreeL PGA"},
+        {"HFR", NULL, "HandsfreeR PGA"},
+        {"Vibra Route", "Audio", "Vibra Mux"},
+        {"VIBRA", NULL, "Vibra Route"},
 
         /* Capture path */
-        {"Analog Left Capture Route", "Main mic", "MAINMIC"},
-        {"Analog Left Capture Route", "Headset mic", "HSMIC"},
-        {"Analog Left Capture Route", "AUXL", "AUXL"},
-        {"Analog Left Capture Route", "Carkit mic", "CARKITMIC"},
+        {"Analog Left", "Main Mic Capture Switch", "MAINMIC"},
+        {"Analog Left", "Headset Mic Capture Switch", "HSMIC"},
+        {"Analog Left", "AUXL Capture Switch", "AUXL"},
+        {"Analog Left", "Carkit Mic Capture Switch", "CARKITMIC"},
 
-        {"Analog Right Capture Route", "Sub mic", "SUBMIC"},
-        {"Analog Right Capture Route", "AUXR", "AUXR"},
+        {"Analog Right", "Sub Mic Capture Switch", "SUBMIC"},
+        {"Analog Right", "AUXR Capture Switch", "AUXR"},
 
-        {"ADC Physical Left", NULL, "Analog Left Capture Route"},
-        {"ADC Physical Right", NULL, "Analog Right Capture Route"},
+        {"ADC Physical Left", NULL, "Analog Left"},
+        {"ADC Physical Right", NULL, "Analog Right"},
 
         {"Digimic0 Enable", NULL, "DIGIMIC0"},
         {"Digimic1 Enable", NULL, "DIGIMIC1"},
@@ -1164,22 +1483,26 @@ static const struct snd_soc_dapm_route intercon[] = {
         {"ADC Virtual Right2", NULL, "TX2 Capture Route"},
 
         /* Analog bypass routes */
-        {"Right1 Analog Loopback", "Switch", "Analog Right Capture Route"},
-        {"Left1 Analog Loopback", "Switch", "Analog Left Capture Route"},
-        {"Right2 Analog Loopback", "Switch", "Analog Right Capture Route"},
-        {"Left2 Analog Loopback", "Switch", "Analog Left Capture Route"},
+        {"Right1 Analog Loopback", "Switch", "Analog Right"},
+        {"Left1 Analog Loopback", "Switch", "Analog Left"},
+        {"Right2 Analog Loopback", "Switch", "Analog Right"},
+        {"Left2 Analog Loopback", "Switch", "Analog Left"},
+        {"Voice Analog Loopback", "Switch", "Analog Left"},
 
         {"Analog R1 Playback Mixer", NULL, "Right1 Analog Loopback"},
         {"Analog L1 Playback Mixer", NULL, "Left1 Analog Loopback"},
         {"Analog R2 Playback Mixer", NULL, "Right2 Analog Loopback"},
         {"Analog L2 Playback Mixer", NULL, "Left2 Analog Loopback"},
+        {"Analog Voice Playback Mixer", NULL, "Voice Analog Loopback"},
 
         /* Digital bypass routes */
         {"Right Digital Loopback", "Volume", "TX1 Capture Route"},
         {"Left Digital Loopback", "Volume", "TX1 Capture Route"},
+        {"Voice Digital Loopback", "Volume", "TX2 Capture Route"},
 
-        {"Analog R2 Playback Mixer", NULL, "Right Digital Loopback"},
-        {"Analog L2 Playback Mixer", NULL, "Left Digital Loopback"},
+        {"Digital R2 Playback Mixer", NULL, "Right Digital Loopback"},
+        {"Digital L2 Playback Mixer", NULL, "Left Digital Loopback"},
+        {"Digital Voice Playback Mixer", NULL, "Voice Digital Loopback"},
 
 };
 
@@ -1226,6 +1549,58 @@ static int twl4030_set_bias_level(struct snd_soc_codec *codec,
         return 0;
 }
 
+static void twl4030_constraints(struct twl4030_priv *twl4030,
+                                struct snd_pcm_substream *mst_substream)
+{
+        struct snd_pcm_substream *slv_substream;
+
+        /* Pick the stream, which need to be constrained */
+        if (mst_substream == twl4030->master_substream)
+                slv_substream = twl4030->slave_substream;
+        else if (mst_substream == twl4030->slave_substream)
+                slv_substream = twl4030->master_substream;
+        else /* This should not happen.. */
+                return;
+
+        /* Set the constraints according to the already configured stream */
+        snd_pcm_hw_constraint_minmax(slv_substream->runtime,
+                                SNDRV_PCM_HW_PARAM_RATE,
+                                twl4030->rate,
+                                twl4030->rate);
+
+        snd_pcm_hw_constraint_minmax(slv_substream->runtime,
+                                SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
+                                twl4030->sample_bits,
+                                twl4030->sample_bits);
+
+        snd_pcm_hw_constraint_minmax(slv_substream->runtime,
+                                SNDRV_PCM_HW_PARAM_CHANNELS,
+                                twl4030->channels,
+                                twl4030->channels);
+}
+
+/* In case of 4 channel mode, the RX1 L/R for playback and the TX2 L/R for
+ * capture has to be enabled/disabled. */
+static void twl4030_tdm_enable(struct snd_soc_codec *codec, int direction,
+                                int enable)
+{
+        u8 reg, mask;
+
+        reg = twl4030_read_reg_cache(codec, TWL4030_REG_OPTION);
+
+        if (direction == SNDRV_PCM_STREAM_PLAYBACK)
+                mask = TWL4030_ARXL1_VRX_EN | TWL4030_ARXR1_EN;
+        else
+                mask = TWL4030_ATXL2_VTXL_EN | TWL4030_ATXR2_VTXR_EN;
+
+        if (enable)
+                reg |= mask;
+        else
+                reg &= ~mask;
+
+        twl4030_write(codec, TWL4030_REG_OPTION, reg);
+}
+
 static int twl4030_startup(struct snd_pcm_substream *substream,
                            struct snd_soc_dai *dai)
 {
@@ -1234,26 +1609,25 @@ static int twl4030_startup(struct snd_pcm_substream *substream,
         struct snd_soc_codec *codec = socdev->card->codec;
         struct twl4030_priv *twl4030 = codec->private_data;
 
-        /* If we already have a playback or capture going then constrain
-         * this substream to match it.
-         */
         if (twl4030->master_substream) {
-                struct snd_pcm_runtime *master_runtime;
-                master_runtime = twl4030->master_substream->runtime;
-
-                snd_pcm_hw_constraint_minmax(substream->runtime,
-                                             SNDRV_PCM_HW_PARAM_RATE,
-                                             master_runtime->rate,
-                                             master_runtime->rate);
-
-                snd_pcm_hw_constraint_minmax(substream->runtime,
-                                             SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
-                                             master_runtime->sample_bits,
-                                             master_runtime->sample_bits);
-
                 twl4030->slave_substream = substream;
-        } else
+                /* The DAI has one configuration for playback and capture, so
+                 * if the DAI has been already configured then constrain this
+                 * substream to match it. */
+                if (twl4030->configured)
+                        twl4030_constraints(twl4030, twl4030->master_substream);
+        } else {
+                if (!(twl4030_read_reg_cache(codec, TWL4030_REG_CODEC_MODE) &
+                        TWL4030_OPTION_1)) {
+                        /* In option2 4 channel is not supported, set the
+                         * constraint for the first stream for channels, the
+                         * second stream will 'inherit' this cosntraint */
+                        snd_pcm_hw_constraint_minmax(substream->runtime,
+                                                SNDRV_PCM_HW_PARAM_CHANNELS,
+                                                2, 2);
+                }
                 twl4030->master_substream = substream;
+        }
 
         return 0;
 }
@@ -1270,6 +1644,17 @@ static void twl4030_shutdown(struct snd_pcm_substream *substream,
                 twl4030->master_substream = twl4030->slave_substream;
 
         twl4030->slave_substream = NULL;
+
+        /* If all streams are closed, or the remaining stream has not yet
+         * been configured than set the DAI as not configured. */
+        if (!twl4030->master_substream)
+                twl4030->configured = 0;
+         else if (!twl4030->master_substream->runtime->channels)
+                twl4030->configured = 0;
+
+         /* If the closing substream had 4 channel, do the necessary cleanup */
+        if (substream->runtime->channels == 4)
+                twl4030_tdm_enable(codec, substream->stream, 0);
 }
 
 static int twl4030_hw_params(struct snd_pcm_substream *substream,
@@ -1282,8 +1667,22 @@ static int twl4030_hw_params(struct snd_pcm_substream *substream,
         struct twl4030_priv *twl4030 = codec->private_data;
         u8 mode, old_mode, format, old_format;
 
-        if (substream == twl4030->slave_substream)
-                /* Ignoring hw_params for slave substream */
+         /* If the substream has 4 channel, do the necessary setup */
+        if (params_channels(params) == 4) {
+                format = twl4030_read_reg_cache(codec, TWL4030_REG_AUDIO_IF);
+                mode = twl4030_read_reg_cache(codec, TWL4030_REG_CODEC_MODE);
+
+                /* Safety check: are we in the correct operating mode and
+                 * the interface is in TDM mode? */
+                if ((mode & TWL4030_OPTION_1) &&
+                    ((format & TWL4030_AIF_FORMAT) == TWL4030_AIF_FORMAT_TDM))
+                        twl4030_tdm_enable(codec, substream->stream, 1);
+                else
+                        return -EINVAL;
+        }
+
+        if (twl4030->configured)
+                /* Ignoring hw_params for already configured DAI */
                 return 0;
 
         /* bit rate */
@@ -1363,6 +1762,21 @@ static int twl4030_hw_params(struct snd_pcm_substream *substream,
                 /* set CODECPDZ afterwards */
                 twl4030_codec_enable(codec, 1);
         }
+
+        /* Store the important parameters for the DAI configuration and set
+         * the DAI as configured */
+        twl4030->configured = 1;
+        twl4030->rate = params_rate(params);
+        twl4030->sample_bits = hw_param_interval(params,
+                                        SNDRV_PCM_HW_PARAM_SAMPLE_BITS)->min;
+        twl4030->channels = params_channels(params);
+
+        /* If both playback and capture streams are open, and one of them
+         * is setting the hw parameters right now (since we are here), set
+         * constraints to the other stream to match the current one. */
+        if (twl4030->slave_substream)
+                twl4030_constraints(twl4030, substream);
+
         return 0;
 }
 
@@ -1370,17 +1784,21 @@ static int twl4030_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 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",
@@ -1424,6 +1842,9 @@ static int twl4030_set_dai_fmt(struct snd_soc_dai *codec_dai,
         case SND_SOC_DAIFMT_I2S:
                 format |= TWL4030_AIF_FORMAT_CODEC;
                 break;
+        case SND_SOC_DAIFMT_DSP_A:
+                format |= TWL4030_AIF_FORMAT_TDM;
+                break;
         default:
                 return -EINVAL;
         }
@@ -1443,6 +1864,206 @@ static int twl4030_set_dai_fmt(struct snd_soc_dai *codec_dai,
         return 0;
 }
 
+static int twl4030_set_tristate(struct snd_soc_dai *dai, int tristate)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        u8 reg = twl4030_read_reg_cache(codec, TWL4030_REG_AUDIO_IF);
+
+        if (tristate)
+                reg |= TWL4030_AIF_TRI_EN;
+        else
+                reg &= ~TWL4030_AIF_TRI_EN;
+
+        return twl4030_write(codec, TWL4030_REG_AUDIO_IF, reg);
+}
+
+/* In case of voice mode, the RX1 L(VRX) for downlink and the TX2 L/R
+ * (VTXL, VTXR) for uplink has to be enabled/disabled. */
+static void twl4030_voice_enable(struct snd_soc_codec *codec, int direction,
+                                int enable)
+{
+        u8 reg, mask;
+
+        reg = twl4030_read_reg_cache(codec, TWL4030_REG_OPTION);
+
+        if (direction == SNDRV_PCM_STREAM_PLAYBACK)
+                mask = TWL4030_ARXL1_VRX_EN;
+        else
+                mask = TWL4030_ATXL2_VTXL_EN | TWL4030_ATXR2_VTXR_EN;
+
+        if (enable)
+                reg |= mask;
+        else
+                reg &= ~mask;
+
+        twl4030_write(codec, TWL4030_REG_OPTION, reg);
+}
+
+static int twl4030_voice_startup(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;
+        u8 infreq;
+        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");
+                return -EINVAL;
+        }
+
+        /* If the codec mode is not option2, the voice PCM interface is not
+         * avilable.
+         */
+        mode = twl4030_read_reg_cache(codec, TWL4030_REG_CODEC_MODE)
+                & TWL4030_OPT_MODE;
+
+        if (mode != TWL4030_OPTION_2) {
+                printk(KERN_ERR "TWL4030 voice startup: "
+                        "the codec mode is not option2\n");
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static void twl4030_voice_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;
+
+        /* Enable voice digital filters */
+        twl4030_voice_enable(codec, substream->stream, 0);
+}
+
+static int twl4030_voice_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;
+        u8 old_mode, mode;
+
+        /* Enable voice digital filters */
+        twl4030_voice_enable(codec, substream->stream, 1);
+
+        /* bit rate */
+        old_mode = twl4030_read_reg_cache(codec, TWL4030_REG_CODEC_MODE)
+                & ~(TWL4030_CODECPDZ);
+        mode = old_mode;
+
+        switch (params_rate(params)) {
+        case 8000:
+                mode &= ~(TWL4030_SEL_16K);
+                break;
+        case 16000:
+                mode |= TWL4030_SEL_16K;
+                break;
+        default:
+                printk(KERN_ERR "TWL4030 voice hw params: unknown rate %d\n",
+                        params_rate(params));
+                return -EINVAL;
+        }
+
+        if (mode != old_mode) {
+                /* change rate and set CODECPDZ */
+                twl4030_codec_enable(codec, 0);
+                twl4030_write(codec, TWL4030_REG_CODEC_MODE, mode);
+                twl4030_codec_enable(codec, 1);
+        }
+
+        return 0;
+}
+
+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;
+
+        switch (freq) {
+        case 26000000:
+                infreq = TWL4030_APLL_INFREQ_26000KHZ;
+                break;
+        default:
+                printk(KERN_ERR "TWL4030 voice set sysclk: unknown rate %d\n",
+                        freq);
+                return -EINVAL;
+        }
+
+        infreq |= TWL4030_APLL_EN;
+        twl4030_write(codec, TWL4030_REG_APLL_CTL, infreq);
+
+        return 0;
+}
+
+static int twl4030_voice_set_dai_fmt(struct snd_soc_dai *codec_dai,
+                unsigned int fmt)
+{
+        struct snd_soc_codec *codec = codec_dai->codec;
+        u8 old_format, format;
+
+        /* get format */
+        old_format = twl4030_read_reg_cache(codec, TWL4030_REG_VOICE_IF);
+        format = old_format;
+
+        /* set master/slave audio interface */
+        switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
+        case SND_SOC_DAIFMT_CBM_CFM:
+                format &= ~(TWL4030_VIF_SLAVE_EN);
+                break;
+        case SND_SOC_DAIFMT_CBS_CFS:
+                format |= TWL4030_VIF_SLAVE_EN;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        /* clock inversion */
+        switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
+        case SND_SOC_DAIFMT_IB_NF:
+                format &= ~(TWL4030_VIF_FORMAT);
+                break;
+        case SND_SOC_DAIFMT_NB_IF:
+                format |= TWL4030_VIF_FORMAT;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        if (format != old_format) {
+                /* change format and set CODECPDZ */
+                twl4030_codec_enable(codec, 0);
+                twl4030_write(codec, TWL4030_REG_VOICE_IF, format);
+                twl4030_codec_enable(codec, 1);
+        }
+
+        return 0;
+}
+
+static int twl4030_voice_set_tristate(struct snd_soc_dai *dai, int tristate)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        u8 reg = twl4030_read_reg_cache(codec, TWL4030_REG_VOICE_IF);
+
+        if (tristate)
+                reg |= TWL4030_VIF_TRI_EN;
+        else
+                reg &= ~TWL4030_VIF_TRI_EN;
+
+        return twl4030_write(codec, TWL4030_REG_VOICE_IF, reg);
+}
+
 #define TWL4030_RATES    (SNDRV_PCM_RATE_8000_48000)
 #define TWL4030_FORMATS  (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FORMAT_S24_LE)
 
@@ -1452,23 +2073,51 @@ static struct snd_soc_dai_ops twl4030_dai_ops = {
         .hw_params      = twl4030_hw_params,
         .set_sysclk     = twl4030_set_dai_sysclk,
         .set_fmt        = twl4030_set_dai_fmt,
+        .set_tristate   = twl4030_set_tristate,
+};
+
+static struct snd_soc_dai_ops twl4030_dai_voice_ops = {
+        .startup        = twl4030_voice_startup,
+        .shutdown       = twl4030_voice_shutdown,
+        .hw_params      = twl4030_voice_hw_params,
+        .set_sysclk     = twl4030_voice_set_dai_sysclk,
+        .set_fmt        = twl4030_voice_set_dai_fmt,
+        .set_tristate   = twl4030_voice_set_tristate,
 };
 
-struct snd_soc_dai twl4030_dai = {
+struct snd_soc_dai twl4030_dai[] = {
+{
         .name = "twl4030",
         .playback = {
-                .stream_name = "Playback",
+                .stream_name = "HiFi Playback",
                 .channels_min = 2,
-                .channels_max = 2,
+                .channels_max = 4,
                 .rates = TWL4030_RATES | SNDRV_PCM_RATE_96000,
                 .formats = TWL4030_FORMATS,},
         .capture = {
                 .stream_name = "Capture",
                 .channels_min = 2,
-                .channels_max = 2,
+                .channels_max = 4,
                 .rates = TWL4030_RATES,
                 .formats = TWL4030_FORMATS,},
         .ops = &twl4030_dai_ops,
+},
+{
+        .name = "twl4030 Voice",
+        .playback = {
+                .stream_name = "Voice Playback",
+                .channels_min = 1,
+                .channels_max = 1,
+                .rates = SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_16000,
+                .formats = SNDRV_PCM_FMTBIT_S16_LE,},
+        .capture = {
+                .stream_name = "Capture",
+                .channels_min = 1,
+                .channels_max = 2,
+                .rates = SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_16000,
+                .formats = SNDRV_PCM_FMTBIT_S16_LE,},
+        .ops = &twl4030_dai_voice_ops,
+},
 };
 EXPORT_SYMBOL_GPL(twl4030_dai);
 
@@ -1500,6 +2149,8 @@ static int twl4030_resume(struct platform_device *pdev)
 static int twl4030_init(struct snd_soc_device *socdev)
 {
         struct snd_soc_codec *codec = socdev->card->codec;
+        struct twl4030_setup_data *setup = socdev->codec_data;
+        struct twl4030_priv *twl4030 = codec->private_data;
         int ret = 0;
 
         printk(KERN_INFO "TWL4030 Audio Codec init \n");
@@ -1509,14 +2160,31 @@ static int twl4030_init(struct snd_soc_device *socdev)
         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 = 1;
+        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;
 
+        /* 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;
+
+                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) {
@@ -1604,13 +2272,13 @@ EXPORT_SYMBOL_GPL(soc_codec_dev_twl4030);
 
 static int __init twl4030_modinit(void)
 {
-        return snd_soc_register_dai(&twl4030_dai);
+        return snd_soc_register_dais(&twl4030_dai[0], ARRAY_SIZE(twl4030_dai));
 }
 module_init(twl4030_modinit);
 
 static void __exit twl4030_exit(void)
 {
-        snd_soc_unregister_dai(&twl4030_dai);
+        snd_soc_unregister_dais(&twl4030_dai[0], ARRAY_SIZE(twl4030_dai));
 }
 module_exit(twl4030_exit);
 
diff --git a/sound/soc/codecs/twl4030.h b/sound/soc/codecs/twl4030.h
index cb63765db1df..2b4bfa23f985 100644
--- a/sound/soc/codecs/twl4030.h
+++ b/sound/soc/codecs/twl4030.h
@@ -92,8 +92,9 @@
 #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
 
-#define TWL4030_CACHEREGNUM     (TWL4030_REG_MISC_SET_2 + 1)
+#define TWL4030_CACHEREGNUM     (TWL4030_REG_SW_SHADOW + 1)
 
 /* Bitfield Definitions */
 
@@ -110,9 +111,22 @@
 #define TWL4030_APLL_RATE_44100         0x90
 #define TWL4030_APLL_RATE_48000         0xA0
 #define TWL4030_APLL_RATE_96000         0xE0
-#define TWL4030_SEL_16K                 0x04
+#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 */
 
@@ -171,6 +185,17 @@
 #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
 
@@ -236,7 +261,21 @@
 #define TWL4030_SMOOTH_ANAVOL_EN        0x02
 #define TWL4030_DIGMIC_LR_SWAP_EN       0x01
 
-extern struct snd_soc_dai twl4030_dai;
+/* TWL4030_REG_SW_SHADOW (0x4A) Fields */
+#define TWL4030_HFL_EN                  0x01
+#define TWL4030_HFR_EN                  0x02
+
+#define TWL4030_DAI_HIFI                0
+#define TWL4030_DAI_VOICE               1
+
+extern struct snd_soc_dai twl4030_dai[2];
 extern struct snd_soc_codec_device soc_codec_dev_twl4030;
 
+struct twl4030_setup_data {
+        unsigned int ramp_delay_value;
+        unsigned int sysclk;
+        unsigned int hs_extmute:1;
+        void (*set_hs_extmute)(int mute);
+};
+
 #endif  /* End of __TWL4030_AUDIO_H__ */
diff --git a/sound/soc/codecs/uda134x.c b/sound/soc/codecs/uda134x.c
index ddefb8f80145..c33b92edbded 100644
--- a/sound/soc/codecs/uda134x.c
+++ b/sound/soc/codecs/uda134x.c
@@ -101,7 +101,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: %d",
+                printk(KERN_ERR "%s unkown register: reg: %u",
                        __func__, reg);
                 return -EINVAL;
         }
@@ -163,7 +163,7 @@ static int uda134x_mute(struct snd_soc_dai *dai, int mute)
         else
                 mute_reg &= ~(1<<2);
 
-        uda134x_write(codec, UDA134X_DATA010, mute_reg & ~(1<<2));
+        uda134x_write(codec, UDA134X_DATA010, mute_reg);
 
         return 0;
 }
@@ -296,7 +296,7 @@ static int uda134x_set_dai_sysclk(struct snd_soc_dai *codec_dai,
         struct snd_soc_codec *codec = codec_dai->codec;
         struct uda134x_priv *uda134x = codec->private_data;
 
-        pr_debug("%s clk_id: %d, freq: %d, dir: %d\n", __func__,
+        pr_debug("%s clk_id: %d, freq: %u, dir: %d\n", __func__,
                  clk_id, freq, dir);
 
         /* Anything between 256fs*8Khz and 512fs*48Khz should be acceptable
diff --git a/sound/soc/codecs/uda1380.c b/sound/soc/codecs/uda1380.c
index 5b21594e0e58..92ec03442154 100644
--- a/sound/soc/codecs/uda1380.c
+++ b/sound/soc/codecs/uda1380.c
@@ -5,9 +5,7 @@
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
- * Copyright (c) 2007 Philipp Zabel <philipp.zabel@gmail.com>
- * Improved support for DAPM and audio routing/mixing capabilities,
- * added TLV support.
+ * Copyright (c) 2007-2009 Philipp Zabel <philipp.zabel@gmail.com>
  *
  * Modified by Richard Purdie <richard@openedhand.com> to fit into SoC
  * codec model.
@@ -19,26 +17,32 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/types.h>
-#include <linux/string.h>
 #include <linux/slab.h>
 #include <linux/errno.h>
-#include <linux/ioctl.h>
+#include <linux/gpio.h>
 #include <linux/delay.h>
 #include <linux/i2c.h>
 #include <linux/workqueue.h>
 #include <sound/core.h>
 #include <sound/control.h>
 #include <sound/initval.h>
-#include <sound/info.h>
 #include <sound/soc.h>
 #include <sound/soc-dapm.h>
 #include <sound/tlv.h>
+#include <sound/uda1380.h>
 
 #include "uda1380.h"
 
-static struct work_struct uda1380_work;
 static struct snd_soc_codec *uda1380_codec;
 
+/* codec private data */
+struct uda1380_priv {
+        struct snd_soc_codec codec;
+        u16 reg_cache[UDA1380_CACHEREGNUM];
+        unsigned int dac_clk;
+        struct work_struct work;
+};
+
 /*
  * uda1380 register cache
  */
@@ -473,6 +477,7 @@ static int uda1380_trigger(struct snd_pcm_substream *substream, int cmd,
         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 uda1380_priv *uda1380 = codec->private_data;
         int mixer = uda1380_read_reg_cache(codec, UDA1380_MIXER);
 
         switch (cmd) {
@@ -480,13 +485,13 @@ static int uda1380_trigger(struct snd_pcm_substream *substream, int cmd,
         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
                 uda1380_write_reg_cache(codec, UDA1380_MIXER,
                                         mixer & ~R14_SILENCE);
-                schedule_work(&uda1380_work);
+                schedule_work(&uda1380->work);
                 break;
         case SNDRV_PCM_TRIGGER_STOP:
         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
                 uda1380_write_reg_cache(codec, UDA1380_MIXER,
                                         mixer | R14_SILENCE);
-                schedule_work(&uda1380_work);
+                schedule_work(&uda1380->work);
                 break;
         }
         return 0;
@@ -670,44 +675,33 @@ static int uda1380_resume(struct platform_device *pdev)
         return 0;
 }
 
-/*
- * initialise the UDA1380 driver
- * register mixer and dsp interfaces with the kernel
- */
-static int uda1380_init(struct snd_soc_device *socdev, int dac_clk)
+static int uda1380_probe(struct platform_device *pdev)
 {
-        struct snd_soc_codec *codec = socdev->card->codec;
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec;
+        struct uda1380_platform_data *pdata;
         int ret = 0;
 
-        codec->name = "UDA1380";
-        codec->owner = THIS_MODULE;
-        codec->read = uda1380_read_reg_cache;
-        codec->write = uda1380_write;
-        codec->set_bias_level = uda1380_set_bias_level;
-        codec->dai = uda1380_dai;
-        codec->num_dai = ARRAY_SIZE(uda1380_dai);
-        codec->reg_cache = kmemdup(uda1380_reg, sizeof(uda1380_reg),
-                                   GFP_KERNEL);
-        if (codec->reg_cache == NULL)
-                return -ENOMEM;
-        codec->reg_cache_size = ARRAY_SIZE(uda1380_reg);
-        codec->reg_cache_step = 1;
-        uda1380_reset(codec);
+        if (uda1380_codec == NULL) {
+                dev_err(&pdev->dev, "Codec device not registered\n");
+                return -ENODEV;
+        }
 
-        uda1380_codec = codec;
-        INIT_WORK(&uda1380_work, uda1380_flush_work);
+        socdev->card->codec = uda1380_codec;
+        codec = uda1380_codec;
+        pdata = codec->dev->platform_data;
 
         /* register pcms */
         ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
         if (ret < 0) {
-                pr_err("uda1380: failed to create pcms\n");
+                dev_err(codec->dev, "failed to create pcms: %d\n", ret);
                 goto pcm_err;
         }
 
         /* power on device */
         uda1380_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
         /* set clock input */
-        switch (dac_clk) {
+        switch (pdata->dac_clk) {
         case UDA1380_DAC_CLK_SYSCLK:
                 uda1380_write(codec, UDA1380_CLK, 0);
                 break;
@@ -716,13 +710,12 @@ static int uda1380_init(struct snd_soc_device *socdev, int dac_clk)
                 break;
         }
 
-        /* uda1380 init */
         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) {
-                pr_err("uda1380: failed to register card\n");
+                dev_err(codec->dev, "failed to register card: %d\n", ret);
                 goto card_err;
         }
 
@@ -732,165 +725,201 @@ card_err:
         snd_soc_free_pcms(socdev);
         snd_soc_dapm_free(socdev);
 pcm_err:
-        kfree(codec->reg_cache);
         return ret;
 }
 
-static struct snd_soc_device *uda1380_socdev;
-
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
-
-static int uda1380_i2c_probe(struct i2c_client *i2c,
-                             const struct i2c_device_id *id)
+/* power down chip */
+static int uda1380_remove(struct platform_device *pdev)
 {
-        struct snd_soc_device *socdev = uda1380_socdev;
-        struct uda1380_setup_data *setup = socdev->codec_data;
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
         struct snd_soc_codec *codec = socdev->card->codec;
-        int ret;
-
-        i2c_set_clientdata(i2c, codec);
-        codec->control_data = i2c;
 
-        ret = uda1380_init(socdev, setup->dac_clk);
-        if (ret < 0)
-                pr_err("uda1380: failed to initialise UDA1380\n");
+        if (codec->control_data)
+                uda1380_set_bias_level(codec, SND_SOC_BIAS_OFF);
 
-        return ret;
-}
+        snd_soc_free_pcms(socdev);
+        snd_soc_dapm_free(socdev);
 
-static int uda1380_i2c_remove(struct i2c_client *client)
-{
-        struct snd_soc_codec *codec = i2c_get_clientdata(client);
-        kfree(codec->reg_cache);
         return 0;
 }
 
-static const struct i2c_device_id uda1380_i2c_id[] = {
-        { "uda1380", 0 },
-        { }
-};
-MODULE_DEVICE_TABLE(i2c, uda1380_i2c_id);
-
-static struct i2c_driver uda1380_i2c_driver = {
-        .driver = {
-                .name =  "UDA1380 I2C Codec",
-                .owner = THIS_MODULE,
-        },
-        .probe =    uda1380_i2c_probe,
-        .remove =   uda1380_i2c_remove,
-        .id_table = uda1380_i2c_id,
+struct snd_soc_codec_device soc_codec_dev_uda1380 = {
+        .probe =        uda1380_probe,
+        .remove =       uda1380_remove,
+        .suspend =      uda1380_suspend,
+        .resume =       uda1380_resume,
 };
+EXPORT_SYMBOL_GPL(soc_codec_dev_uda1380);
 
-static int uda1380_add_i2c_device(struct platform_device *pdev,
-                                  const struct uda1380_setup_data *setup)
+static int uda1380_register(struct uda1380_priv *uda1380)
 {
-        struct i2c_board_info info;
-        struct i2c_adapter *adapter;
-        struct i2c_client *client;
-        int ret;
+        int ret, i;
+        struct snd_soc_codec *codec = &uda1380->codec;
+        struct uda1380_platform_data *pdata = codec->dev->platform_data;
 
-        ret = i2c_add_driver(&uda1380_i2c_driver);
-        if (ret != 0) {
-                dev_err(&pdev->dev, "can't add i2c driver\n");
-                return ret;
+        if (uda1380_codec) {
+                dev_err(codec->dev, "Another UDA1380 is registered\n");
+                return -EINVAL;
+        }
+
+        if (!pdata || !pdata->gpio_power || !pdata->gpio_reset)
+                return -EINVAL;
+
+        ret = gpio_request(pdata->gpio_power, "uda1380 power");
+        if (ret)
+                goto err_out;
+        ret = gpio_request(pdata->gpio_reset, "uda1380 reset");
+        if (ret)
+                goto err_gpio;
+
+        gpio_direction_output(pdata->gpio_power, 1);
+
+        /* we may need to have the clock running here - pH5 */
+        gpio_direction_output(pdata->gpio_reset, 1);
+        udelay(5);
+        gpio_set_value(pdata->gpio_reset, 0);
+
+        mutex_init(&codec->mutex);
+        INIT_LIST_HEAD(&codec->dapm_widgets);
+        INIT_LIST_HEAD(&codec->dapm_paths);
+
+        codec->private_data = uda1380;
+        codec->name = "UDA1380";
+        codec->owner = THIS_MODULE;
+        codec->read = uda1380_read_reg_cache;
+        codec->write = uda1380_write;
+        codec->bias_level = SND_SOC_BIAS_OFF;
+        codec->set_bias_level = uda1380_set_bias_level;
+        codec->dai = uda1380_dai;
+        codec->num_dai = ARRAY_SIZE(uda1380_dai);
+        codec->reg_cache_size = ARRAY_SIZE(uda1380_reg);
+        codec->reg_cache = &uda1380->reg_cache;
+        codec->reg_cache_step = 1;
+
+        memcpy(codec->reg_cache, uda1380_reg, sizeof(uda1380_reg));
+
+        ret = uda1380_reset(codec);
+        if (ret < 0) {
+                dev_err(codec->dev, "Failed to issue reset\n");
+                goto err_reset;
         }
 
-        memset(&info, 0, sizeof(struct i2c_board_info));
-        info.addr = setup->i2c_address;
-        strlcpy(info.type, "uda1380", I2C_NAME_SIZE);
+        INIT_WORK(&uda1380->work, uda1380_flush_work);
+
+        for (i = 0; i < ARRAY_SIZE(uda1380_dai); i++)
+                uda1380_dai[i].dev = codec->dev;
 
-        adapter = i2c_get_adapter(setup->i2c_bus);
-        if (!adapter) {
-                dev_err(&pdev->dev, "can't get i2c adapter %d\n",
-                        setup->i2c_bus);
-                goto err_driver;
+        uda1380_codec = codec;
+
+        ret = snd_soc_register_codec(codec);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to register codec: %d\n", ret);
+                goto err_reset;
         }
 
-        client = i2c_new_device(adapter, &info);
-        i2c_put_adapter(adapter);
-        if (!client) {
-                dev_err(&pdev->dev, "can't add i2c device at 0x%x\n",
-                        (unsigned int)info.addr);
-                goto err_driver;
+        ret = snd_soc_register_dais(uda1380_dai, ARRAY_SIZE(uda1380_dai));
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to register DAIs: %d\n", ret);
+                goto err_dai;
         }
 
         return 0;
 
-err_driver:
-        i2c_del_driver(&uda1380_i2c_driver);
-        return -ENODEV;
+err_dai:
+        snd_soc_unregister_codec(codec);
+err_reset:
+        gpio_set_value(pdata->gpio_power, 0);
+        gpio_free(pdata->gpio_reset);
+err_gpio:
+        gpio_free(pdata->gpio_power);
+err_out:
+        return ret;
 }
-#endif
 
-static int uda1380_probe(struct platform_device *pdev)
+static void uda1380_unregister(struct uda1380_priv *uda1380)
 {
-        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
-        struct uda1380_setup_data *setup;
+        struct snd_soc_codec *codec = &uda1380->codec;
+        struct uda1380_platform_data *pdata = codec->dev->platform_data;
+
+        snd_soc_unregister_dais(uda1380_dai, ARRAY_SIZE(uda1380_dai));
+        snd_soc_unregister_codec(&uda1380->codec);
+
+        gpio_set_value(pdata->gpio_power, 0);
+        gpio_free(pdata->gpio_reset);
+        gpio_free(pdata->gpio_power);
+
+        kfree(uda1380);
+        uda1380_codec = NULL;
+}
+
+#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+static __devinit int uda1380_i2c_probe(struct i2c_client *i2c,
+                                      const struct i2c_device_id *id)
+{
+        struct uda1380_priv *uda1380;
         struct snd_soc_codec *codec;
         int ret;
 
-        setup = socdev->codec_data;
-        codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
-        if (codec == NULL)
+        uda1380 = kzalloc(sizeof(struct uda1380_priv), GFP_KERNEL);
+        if (uda1380 == NULL)
                 return -ENOMEM;
 
-        socdev->card->codec = codec;
-        mutex_init(&codec->mutex);
-        INIT_LIST_HEAD(&codec->dapm_widgets);
-        INIT_LIST_HEAD(&codec->dapm_paths);
+        codec = &uda1380->codec;
+        codec->hw_write = (hw_write_t)i2c_master_send;
 
-        uda1380_socdev = socdev;
-        ret = -ENODEV;
+        i2c_set_clientdata(i2c, uda1380);
+        codec->control_data = i2c;
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
-        if (setup->i2c_address) {
-                codec->hw_write = (hw_write_t)i2c_master_send;
-                ret = uda1380_add_i2c_device(pdev, setup);
-        }
-#endif
+        codec->dev = &i2c->dev;
 
+        ret = uda1380_register(uda1380);
         if (ret != 0)
-                kfree(codec);
+                kfree(uda1380);
+
         return ret;
 }
 
-/* power down chip */
-static int uda1380_remove(struct platform_device *pdev)
+static int __devexit uda1380_i2c_remove(struct i2c_client *i2c)
 {
-        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
-        struct snd_soc_codec *codec = socdev->card->codec;
-
-        if (codec->control_data)
-                uda1380_set_bias_level(codec, SND_SOC_BIAS_OFF);
-
-        snd_soc_free_pcms(socdev);
-        snd_soc_dapm_free(socdev);
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
-        i2c_unregister_device(codec->control_data);
-        i2c_del_driver(&uda1380_i2c_driver);
-#endif
-        kfree(codec);
-
+        struct uda1380_priv *uda1380 = i2c_get_clientdata(i2c);
+        uda1380_unregister(uda1380);
         return 0;
 }
 
-struct snd_soc_codec_device soc_codec_dev_uda1380 = {
-        .probe =        uda1380_probe,
-        .remove =       uda1380_remove,
-        .suspend =      uda1380_suspend,
-        .resume =       uda1380_resume,
+static const struct i2c_device_id uda1380_i2c_id[] = {
+        { "uda1380", 0 },
+        { }
 };
-EXPORT_SYMBOL_GPL(soc_codec_dev_uda1380);
+MODULE_DEVICE_TABLE(i2c, uda1380_i2c_id);
+
+static struct i2c_driver uda1380_i2c_driver = {
+        .driver = {
+                .name =  "UDA1380 I2C Codec",
+                .owner = THIS_MODULE,
+        },
+        .probe =    uda1380_i2c_probe,
+        .remove =   __devexit_p(uda1380_i2c_remove),
+        .id_table = uda1380_i2c_id,
+};
+#endif
 
 static int __init uda1380_modinit(void)
 {
-        return snd_soc_register_dais(uda1380_dai, ARRAY_SIZE(uda1380_dai));
+        int ret;
+#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+        ret = i2c_add_driver(&uda1380_i2c_driver);
+        if (ret != 0)
+                pr_err("Failed to register UDA1380 I2C driver: %d\n", ret);
+#endif
+        return 0;
 }
 module_init(uda1380_modinit);
 
 static void __exit uda1380_exit(void)
 {
-        snd_soc_unregister_dais(uda1380_dai, ARRAY_SIZE(uda1380_dai));
+#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+        i2c_del_driver(&uda1380_i2c_driver);
+#endif
 }
 module_exit(uda1380_exit);
 
diff --git a/sound/soc/codecs/uda1380.h b/sound/soc/codecs/uda1380.h
index c55c17a52a12..9cefa8a54770 100644
--- a/sound/soc/codecs/uda1380.h
+++ b/sound/soc/codecs/uda1380.h
@@ -72,14 +72,6 @@
 #define R22_SKIP_DCFIL  0x0002
 #define R23_AGC_EN      0x0001
 
-struct uda1380_setup_data {
-        int            i2c_bus;
-        unsigned short i2c_address;
-        int            dac_clk;
-#define UDA1380_DAC_CLK_SYSCLK 0
-#define UDA1380_DAC_CLK_WSPLL  1
-};
-
 #define UDA1380_DAI_DUPLEX      0 /* playback and capture on single DAI */
 #define UDA1380_DAI_PLAYBACK    1 /* playback DAI */
 #define UDA1380_DAI_CAPTURE     2 /* capture DAI */
diff --git a/sound/soc/codecs/wm8350.c b/sound/soc/codecs/wm8350.c
index 0275321ff8ab..4ded0e3a35e0 100644
--- a/sound/soc/codecs/wm8350.c
+++ b/sound/soc/codecs/wm8350.c
@@ -406,7 +406,6 @@ static const char *wm8350_deemp[] = { "None", "32kHz", "44.1kHz", "48kHz" };
 static const char *wm8350_pol[] = { "Normal", "Inv R", "Inv L", "Inv L & R" };
 static const char *wm8350_dacmutem[] = { "Normal", "Soft" };
 static const char *wm8350_dacmutes[] = { "Fast", "Slow" };
-static const char *wm8350_dacfilter[] = { "Normal", "Sloping" };
 static const char *wm8350_adcfilter[] = { "None", "High Pass" };
 static const char *wm8350_adchp[] = { "44.1kHz", "8kHz", "16kHz", "32kHz" };
 static const char *wm8350_lr[] = { "Left", "Right" };
@@ -416,7 +415,6 @@ static const struct soc_enum wm8350_enum[] = {
         SOC_ENUM_SINGLE(WM8350_DAC_CONTROL, 0, 4, wm8350_pol),
         SOC_ENUM_SINGLE(WM8350_DAC_MUTE_VOLUME, 14, 2, wm8350_dacmutem),
         SOC_ENUM_SINGLE(WM8350_DAC_MUTE_VOLUME, 13, 2, wm8350_dacmutes),
-        SOC_ENUM_SINGLE(WM8350_DAC_MUTE_VOLUME, 12, 2, wm8350_dacfilter),
         SOC_ENUM_SINGLE(WM8350_ADC_CONTROL, 15, 2, wm8350_adcfilter),
         SOC_ENUM_SINGLE(WM8350_ADC_CONTROL, 8, 4, wm8350_adchp),
         SOC_ENUM_SINGLE(WM8350_ADC_CONTROL, 0, 4, wm8350_pol),
@@ -444,10 +442,9 @@ static const struct snd_kcontrol_new wm8350_snd_controls[] = {
                                 0, 255, 0, dac_pcm_tlv),
         SOC_ENUM("Playback PCM Mute Function", wm8350_enum[2]),
         SOC_ENUM("Playback PCM Mute Speed", wm8350_enum[3]),
-        SOC_ENUM("Playback PCM Filter", wm8350_enum[4]),
-        SOC_ENUM("Capture PCM Filter", wm8350_enum[5]),
-        SOC_ENUM("Capture PCM HP Filter", wm8350_enum[6]),
-        SOC_ENUM("Capture ADC Inversion", wm8350_enum[7]),
+        SOC_ENUM("Capture PCM Filter", wm8350_enum[4]),
+        SOC_ENUM("Capture PCM HP Filter", wm8350_enum[5]),
+        SOC_ENUM("Capture ADC Inversion", wm8350_enum[6]),
         SOC_WM8350_DOUBLE_R_TLV("Capture PCM Volume",
                                 WM8350_ADC_DIGITAL_VOLUME_L,
                                 WM8350_ADC_DIGITAL_VOLUME_R,
@@ -993,6 +990,7 @@ static int wm8350_pcm_hw_params(struct snd_pcm_substream *substream,
                                 struct snd_soc_dai *codec_dai)
 {
         struct snd_soc_codec *codec = codec_dai->codec;
+        struct wm8350 *wm8350 = codec->control_data;
         u16 iface = wm8350_codec_read(codec, WM8350_AI_FORMATING) &
             ~WM8350_AIF_WL_MASK;
 
@@ -1012,6 +1010,19 @@ static int wm8350_pcm_hw_params(struct snd_pcm_substream *substream,
         }
 
         wm8350_codec_write(codec, WM8350_AI_FORMATING, iface);
+
+        /* The sloping stopband filter is recommended for use with
+         * lower sample rates to improve performance.
+         */
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+                if (params_rate(params) < 24000)
+                        wm8350_set_bits(wm8350, WM8350_DAC_MUTE_VOLUME,
+                                        WM8350_DAC_SB_FILT);
+                else
+                        wm8350_clear_bits(wm8350, WM8350_DAC_MUTE_VOLUME,
+                                          WM8350_DAC_SB_FILT);
+        }
+
         return 0;
 }
 
@@ -1108,7 +1119,7 @@ static int wm8350_set_fll(struct snd_soc_dai *codec_dai,
         if (ret < 0)
                 return ret;
         dev_dbg(wm8350->dev,
-                "FLL in %d FLL out %d N 0x%x K 0x%x div %d ratio %d",
+                "FLL in %u FLL out %u N 0x%x K 0x%x div %d ratio %d",
                 freq_in, freq_out, fll_div.n, fll_div.k, fll_div.div,
                 fll_div.ratio);
 
@@ -1660,6 +1671,21 @@ 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",
@@ -1667,6 +1693,8 @@ 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/wm8350.h b/sound/soc/codecs/wm8350.h
index d11bd9288cf9..d088eb4b88bb 100644
--- a/sound/soc/codecs/wm8350.h
+++ b/sound/soc/codecs/wm8350.h
@@ -13,6 +13,7 @@
 #define _WM8350_H
 
 #include <sound/soc.h>
+#include <linux/mfd/wm8350/audio.h>
 
 extern struct snd_soc_dai wm8350_dai;
 extern struct snd_soc_codec_device soc_codec_dev_wm8350;
diff --git a/sound/soc/codecs/wm8400.c b/sound/soc/codecs/wm8400.c
index 510efa604008..b9ef4d915221 100644
--- a/sound/soc/codecs/wm8400.c
+++ b/sound/soc/codecs/wm8400.c
@@ -954,7 +954,7 @@ static int fll_factors(struct wm8400_priv *wm8400, struct fll_factors *factors,
                 factors->outdiv *= 2;
                 if (factors->outdiv > 32) {
                         dev_err(wm8400->wm8400->dev,
-                                "Unsupported FLL output frequency %dHz\n",
+                                "Unsupported FLL output frequency %uHz\n",
                                 Fout);
                         return -EINVAL;
                 }
@@ -1003,7 +1003,7 @@ static int fll_factors(struct wm8400_priv *wm8400, struct fll_factors *factors,
         factors->k = K / 10;
 
         dev_dbg(wm8400->wm8400->dev,
-                "FLL: Fref=%d Fout=%d N=%x K=%x, FRATIO=%x OUTDIV=%x\n",
+                "FLL: Fref=%u Fout=%u N=%x K=%x, FRATIO=%x OUTDIV=%x\n",
                 Fref, Fout,
                 factors->n, factors->k, factors->fratio, factors->outdiv);
 
@@ -1022,10 +1022,15 @@ static int wm8400_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id,
         if (freq_in == wm8400->fll_in && freq_out == wm8400->fll_out)
                 return 0;
 
-        if (freq_out != 0) {
+        if (freq_out) {
                 ret = fll_factors(wm8400, &factors, freq_in, freq_out);
                 if (ret != 0)
                         return ret;
+        } else {
+                /* Bodge GCC 4.4.0 uninitialised variable warning - it
+                 * doesn't seem capable of working out that we exit if
+                 * freq_out is 0 before any of the uses. */
+                memset(&factors, 0, sizeof(factors));
         }
 
         wm8400->fll_out = freq_out;
@@ -1040,7 +1045,7 @@ static int wm8400_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id,
         reg &= ~WM8400_FLL_OSC_ENA;
         wm8400_write(codec, WM8400_FLL_CONTROL_1, reg);
 
-        if (freq_out == 0)
+        if (!freq_out)
                 return 0;
 
         reg &= ~(WM8400_FLL_REF_FREQ | WM8400_FLL_FRATIO_MASK);
@@ -1473,8 +1478,8 @@ static int wm8400_codec_probe(struct platform_device *dev)
 
         codec = &priv->codec;
         codec->private_data = priv;
-        codec->control_data = dev->dev.driver_data;
-        priv->wm8400 = dev->dev.driver_data;
+        codec->control_data = dev_get_drvdata(&dev->dev);
+        priv->wm8400 = dev_get_drvdata(&dev->dev);
 
         ret = regulator_bulk_get(priv->wm8400->dev,
                                  ARRAY_SIZE(power), &power[0]);
@@ -1553,6 +1558,21 @@ 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",
@@ -1560,6 +1580,8 @@ 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 6a4cea09c45d..060d5d06ba95 100644
--- a/sound/soc/codecs/wm8510.c
+++ b/sound/soc/codecs/wm8510.c
@@ -58,55 +58,7 @@ static const u16 wm8510_reg[WM8510_CACHEREGNUM] = {
 #define WM8510_POWER1_BIASEN  0x08
 #define WM8510_POWER1_BUFIOEN 0x10
 
-/*
- * read wm8510 register cache
- */
-static inline unsigned int wm8510_read_reg_cache(struct snd_soc_codec *codec,
-        unsigned int reg)
-{
-        u16 *cache = codec->reg_cache;
-        if (reg == WM8510_RESET)
-                return 0;
-        if (reg >= WM8510_CACHEREGNUM)
-                return -1;
-        return cache[reg];
-}
-
-/*
- * write wm8510 register cache
- */
-static inline void wm8510_write_reg_cache(struct snd_soc_codec *codec,
-        u16 reg, unsigned int value)
-{
-        u16 *cache = codec->reg_cache;
-        if (reg >= WM8510_CACHEREGNUM)
-                return;
-        cache[reg] = value;
-}
-
-/*
- * write to the WM8510 register space
- */
-static int wm8510_write(struct snd_soc_codec *codec, unsigned int reg,
-        unsigned int value)
-{
-        u8 data[2];
-
-        /* data is
-         *   D15..D9 WM8510 register offset
-         *   D8...D0 register data
-         */
-        data[0] = (reg << 1) | ((value >> 8) & 0x0001);
-        data[1] = value & 0x00ff;
-
-        wm8510_write_reg_cache(codec, reg, value);
-        if (codec->hw_write(codec->control_data, data, 2) == 2)
-                return 0;
-        else
-                return -EIO;
-}
-
-#define wm8510_reset(c) wm8510_write(c, WM8510_RESET, 0)
+#define wm8510_reset(c) snd_soc_write(c, WM8510_RESET, 0)
 
 static const char *wm8510_companding[] = { "Off", "NC", "u-law", "A-law" };
 static const char *wm8510_deemp[] = { "None", "32kHz", "44.1kHz", "48kHz" };
@@ -298,7 +250,7 @@ static void pll_factors(unsigned int target, unsigned int source)
 
         if ((Ndiv < 6) || (Ndiv > 12))
                 printk(KERN_WARNING
-                        "WM8510 N value %d outwith recommended range!d\n",
+                        "WM8510 N value %u outwith recommended range!d\n",
                         Ndiv);
 
         pll_div.n = Ndiv;
@@ -327,27 +279,27 @@ static int wm8510_set_dai_pll(struct snd_soc_dai *codec_dai,
 
         if (freq_in == 0 || freq_out == 0) {
                 /* Clock CODEC directly from MCLK */
-                reg = wm8510_read_reg_cache(codec, WM8510_CLOCK);
-                wm8510_write(codec, WM8510_CLOCK, reg & 0x0ff);
+                reg = snd_soc_read(codec, WM8510_CLOCK);
+                snd_soc_write(codec, WM8510_CLOCK, reg & 0x0ff);
 
                 /* Turn off PLL */
-                reg = wm8510_read_reg_cache(codec, WM8510_POWER1);
-                wm8510_write(codec, WM8510_POWER1, reg & 0x1df);
+                reg = snd_soc_read(codec, WM8510_POWER1);
+                snd_soc_write(codec, WM8510_POWER1, reg & 0x1df);
                 return 0;
         }
 
         pll_factors(freq_out*4, freq_in);
 
-        wm8510_write(codec, WM8510_PLLN, (pll_div.pre_div << 4) | pll_div.n);
-        wm8510_write(codec, WM8510_PLLK1, pll_div.k >> 18);
-        wm8510_write(codec, WM8510_PLLK2, (pll_div.k >> 9) & 0x1ff);
-        wm8510_write(codec, WM8510_PLLK3, pll_div.k & 0x1ff);
-        reg = wm8510_read_reg_cache(codec, WM8510_POWER1);
-        wm8510_write(codec, WM8510_POWER1, reg | 0x020);
+        snd_soc_write(codec, WM8510_PLLN, (pll_div.pre_div << 4) | pll_div.n);
+        snd_soc_write(codec, WM8510_PLLK1, pll_div.k >> 18);
+        snd_soc_write(codec, WM8510_PLLK2, (pll_div.k >> 9) & 0x1ff);
+        snd_soc_write(codec, WM8510_PLLK3, pll_div.k & 0x1ff);
+        reg = snd_soc_read(codec, WM8510_POWER1);
+        snd_soc_write(codec, WM8510_POWER1, reg | 0x020);
 
         /* Run CODEC from PLL instead of MCLK */
-        reg = wm8510_read_reg_cache(codec, WM8510_CLOCK);
-        wm8510_write(codec, WM8510_CLOCK, reg | 0x100);
+        reg = snd_soc_read(codec, WM8510_CLOCK);
+        snd_soc_write(codec, WM8510_CLOCK, reg | 0x100);
 
         return 0;
 }
@@ -363,24 +315,24 @@ static int wm8510_set_dai_clkdiv(struct snd_soc_dai *codec_dai,
 
         switch (div_id) {
         case WM8510_OPCLKDIV:
-                reg = wm8510_read_reg_cache(codec, WM8510_GPIO) & 0x1cf;
-                wm8510_write(codec, WM8510_GPIO, reg | div);
+                reg = snd_soc_read(codec, WM8510_GPIO) & 0x1cf;
+                snd_soc_write(codec, WM8510_GPIO, reg | div);
                 break;
         case WM8510_MCLKDIV:
-                reg = wm8510_read_reg_cache(codec, WM8510_CLOCK) & 0x11f;
-                wm8510_write(codec, WM8510_CLOCK, reg | div);
+                reg = snd_soc_read(codec, WM8510_CLOCK) & 0x11f;
+                snd_soc_write(codec, WM8510_CLOCK, reg | div);
                 break;
         case WM8510_ADCCLK:
-                reg = wm8510_read_reg_cache(codec, WM8510_ADC) & 0x1f7;
-                wm8510_write(codec, WM8510_ADC, reg | div);
+                reg = snd_soc_read(codec, WM8510_ADC) & 0x1f7;
+                snd_soc_write(codec, WM8510_ADC, reg | div);
                 break;
         case WM8510_DACCLK:
-                reg = wm8510_read_reg_cache(codec, WM8510_DAC) & 0x1f7;
-                wm8510_write(codec, WM8510_DAC, reg | div);
+                reg = snd_soc_read(codec, WM8510_DAC) & 0x1f7;
+                snd_soc_write(codec, WM8510_DAC, reg | div);
                 break;
         case WM8510_BCLKDIV:
-                reg = wm8510_read_reg_cache(codec, WM8510_CLOCK) & 0x1e3;
-                wm8510_write(codec, WM8510_CLOCK, reg | div);
+                reg = snd_soc_read(codec, WM8510_CLOCK) & 0x1e3;
+                snd_soc_write(codec, WM8510_CLOCK, reg | div);
                 break;
         default:
                 return -EINVAL;
@@ -394,7 +346,7 @@ static int wm8510_set_dai_fmt(struct snd_soc_dai *codec_dai,
 {
         struct snd_soc_codec *codec = codec_dai->codec;
         u16 iface = 0;
-        u16 clk = wm8510_read_reg_cache(codec, WM8510_CLOCK) & 0x1fe;
+        u16 clk = snd_soc_read(codec, WM8510_CLOCK) & 0x1fe;
 
         /* set master/slave audio interface */
         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
@@ -441,8 +393,8 @@ static int wm8510_set_dai_fmt(struct snd_soc_dai *codec_dai,
                 return -EINVAL;
         }
 
-        wm8510_write(codec, WM8510_IFACE, iface);
-        wm8510_write(codec, WM8510_CLOCK, clk);
+        snd_soc_write(codec, WM8510_IFACE, iface);
+        snd_soc_write(codec, WM8510_CLOCK, clk);
         return 0;
 }
 
@@ -453,8 +405,8 @@ static int wm8510_pcm_hw_params(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;
-        u16 iface = wm8510_read_reg_cache(codec, WM8510_IFACE) & 0x19f;
-        u16 adn = wm8510_read_reg_cache(codec, WM8510_ADD) & 0x1f1;
+        u16 iface = snd_soc_read(codec, WM8510_IFACE) & 0x19f;
+        u16 adn = snd_soc_read(codec, WM8510_ADD) & 0x1f1;
 
         /* bit size */
         switch (params_format(params)) {
@@ -493,20 +445,20 @@ static int wm8510_pcm_hw_params(struct snd_pcm_substream *substream,
                 break;
         }
 
-        wm8510_write(codec, WM8510_IFACE, iface);
-        wm8510_write(codec, WM8510_ADD, adn);
+        snd_soc_write(codec, WM8510_IFACE, iface);
+        snd_soc_write(codec, WM8510_ADD, adn);
         return 0;
 }
 
 static int wm8510_mute(struct snd_soc_dai *dai, int mute)
 {
         struct snd_soc_codec *codec = dai->codec;
-        u16 mute_reg = wm8510_read_reg_cache(codec, WM8510_DAC) & 0xffbf;
+        u16 mute_reg = snd_soc_read(codec, WM8510_DAC) & 0xffbf;
 
         if (mute)
-                wm8510_write(codec, WM8510_DAC, mute_reg | 0x40);
+                snd_soc_write(codec, WM8510_DAC, mute_reg | 0x40);
         else
-                wm8510_write(codec, WM8510_DAC, mute_reg);
+                snd_soc_write(codec, WM8510_DAC, mute_reg);
         return 0;
 }
 
@@ -514,13 +466,13 @@ static int wm8510_mute(struct snd_soc_dai *dai, int mute)
 static int wm8510_set_bias_level(struct snd_soc_codec *codec,
         enum snd_soc_bias_level level)
 {
-        u16 power1 = wm8510_read_reg_cache(codec, WM8510_POWER1) & ~0x3;
+        u16 power1 = snd_soc_read(codec, WM8510_POWER1) & ~0x3;
 
         switch (level) {
         case SND_SOC_BIAS_ON:
         case SND_SOC_BIAS_PREPARE:
                 power1 |= 0x1;  /* VMID 50k */
-                wm8510_write(codec, WM8510_POWER1, power1);
+                snd_soc_write(codec, WM8510_POWER1, power1);
                 break;
 
         case SND_SOC_BIAS_STANDBY:
@@ -528,18 +480,18 @@ static int wm8510_set_bias_level(struct snd_soc_codec *codec,
 
                 if (codec->bias_level == SND_SOC_BIAS_OFF) {
                         /* Initial cap charge at VMID 5k */
-                        wm8510_write(codec, WM8510_POWER1, power1 | 0x3);
+                        snd_soc_write(codec, WM8510_POWER1, power1 | 0x3);
                         mdelay(100);
                 }
 
                 power1 |= 0x2;  /* VMID 500k */
-                wm8510_write(codec, WM8510_POWER1, power1);
+                snd_soc_write(codec, WM8510_POWER1, power1);
                 break;
 
         case SND_SOC_BIAS_OFF:
-                wm8510_write(codec, WM8510_POWER1, 0);
-                wm8510_write(codec, WM8510_POWER2, 0);
-                wm8510_write(codec, WM8510_POWER3, 0);
+                snd_soc_write(codec, WM8510_POWER1, 0);
+                snd_soc_write(codec, WM8510_POWER2, 0);
+                snd_soc_write(codec, WM8510_POWER3, 0);
                 break;
         }
 
@@ -577,6 +529,7 @@ struct snd_soc_dai wm8510_dai = {
                 .rates = WM8510_RATES,
                 .formats = WM8510_FORMATS,},
         .ops = &wm8510_dai_ops,
+        .symmetric_rates = 1,
 };
 EXPORT_SYMBOL_GPL(wm8510_dai);
 
@@ -612,15 +565,14 @@ static int wm8510_resume(struct platform_device *pdev)
  * initialise the WM8510 driver
  * register the mixer and dsp interfaces with the kernel
  */
-static int wm8510_init(struct snd_soc_device *socdev)
+static int wm8510_init(struct snd_soc_device *socdev,
+                       enum snd_soc_control_type control)
 {
         struct snd_soc_codec *codec = socdev->card->codec;
         int ret = 0;
 
         codec->name = "WM8510";
         codec->owner = THIS_MODULE;
-        codec->read = wm8510_read_reg_cache;
-        codec->write = wm8510_write;
         codec->set_bias_level = wm8510_set_bias_level;
         codec->dai = &wm8510_dai;
         codec->num_dai = 1;
@@ -630,13 +582,20 @@ static int wm8510_init(struct snd_soc_device *socdev)
         if (codec->reg_cache == NULL)
                 return -ENOMEM;
 
+        ret = snd_soc_codec_set_cache_io(codec, 7, 9, control);
+        if (ret < 0) {
+                printk(KERN_ERR "wm8510: failed to set cache I/O: %d\n",
+                       ret);
+                goto err;
+        }
+
         wm8510_reset(codec);
 
         /* register pcms */
         ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
         if (ret < 0) {
                 printk(KERN_ERR "wm8510: failed to create pcms\n");
-                goto pcm_err;
+                goto err;
         }
 
         /* power on device */
@@ -655,7 +614,7 @@ static int wm8510_init(struct snd_soc_device *socdev)
 card_err:
         snd_soc_free_pcms(socdev);
         snd_soc_dapm_free(socdev);
-pcm_err:
+err:
         kfree(codec->reg_cache);
         return ret;
 }
@@ -678,7 +637,7 @@ static int wm8510_i2c_probe(struct i2c_client *i2c,
         i2c_set_clientdata(i2c, codec);
         codec->control_data = i2c;
 
-        ret = wm8510_init(socdev);
+        ret = wm8510_init(socdev, SND_SOC_I2C);
         if (ret < 0)
                 pr_err("failed to initialise WM8510\n");
 
@@ -758,7 +717,7 @@ static int __devinit wm8510_spi_probe(struct spi_device *spi)
 
         codec->control_data = spi;
 
-        ret = wm8510_init(socdev);
+        ret = wm8510_init(socdev, SND_SOC_SPI);
         if (ret < 0)
                 dev_err(&spi->dev, "failed to initialise WM8510\n");
 
@@ -779,30 +738,6 @@ static struct spi_driver wm8510_spi_driver = {
         .probe          = wm8510_spi_probe,
         .remove         = __devexit_p(wm8510_spi_remove),
 };
-
-static int wm8510_spi_write(struct spi_device *spi, const char *data, int len)
-{
-        struct spi_transfer t;
-        struct spi_message m;
-        u8 msg[2];
-
-        if (len <= 0)
-                return 0;
-
-        msg[0] = data[0];
-        msg[1] = data[1];
-
-        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;
-}
 #endif /* CONFIG_SPI_MASTER */
 
 static int wm8510_probe(struct platform_device *pdev)
@@ -827,13 +762,11 @@ static int wm8510_probe(struct platform_device *pdev)
         wm8510_socdev = socdev;
 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
         if (setup->i2c_address) {
-                codec->hw_write = (hw_write_t)i2c_master_send;
                 ret = wm8510_add_i2c_device(pdev, setup);
         }
 #endif
 #if defined(CONFIG_SPI_MASTER)
         if (setup->spi) {
-                codec->hw_write = (hw_write_t)wm8510_spi_write;
                 ret = spi_register_driver(&wm8510_spi_driver);
                 if (ret != 0)
                         printk(KERN_ERR "can't add spi driver");
diff --git a/sound/soc/codecs/wm8523.c b/sound/soc/codecs/wm8523.c
new file mode 100644
index 000000000000..25870a4652fb
--- /dev/null
+++ b/sound/soc/codecs/wm8523.c
@@ -0,0 +1,699 @@
+/*
+ * wm8523.c  --  WM8523 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 <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 "wm8523.h"
+
+static struct snd_soc_codec *wm8523_codec;
+struct snd_soc_codec_device soc_codec_dev_wm8523;
+
+#define WM8523_NUM_SUPPLIES 2
+static const char *wm8523_supply_names[WM8523_NUM_SUPPLIES] = {
+        "AVDD",
+        "LINEVDD",
+};
+
+#define WM8523_NUM_RATES 7
+
+/* codec private data */
+struct wm8523_priv {
+        struct snd_soc_codec codec;
+        u16 reg_cache[WM8523_REGISTER_COUNT];
+        struct regulator_bulk_data supplies[WM8523_NUM_SUPPLIES];
+        unsigned int sysclk;
+        unsigned int rate_constraint_list[WM8523_NUM_RATES];
+        struct snd_pcm_hw_constraint_list rate_constraint;
+};
+
+static const u16 wm8523_reg[WM8523_REGISTER_COUNT] = {
+        0x8523,     /* R0 - DEVICE_ID */
+        0x0001,     /* R1 - REVISION */
+        0x0000,     /* R2 - PSCTRL1 */
+        0x1812,     /* R3 - AIF_CTRL1 */
+        0x0000,     /* R4 - AIF_CTRL2 */
+        0x0001,     /* R5 - DAC_CTRL3 */
+        0x0190,     /* R6 - DAC_GAINL */
+        0x0190,     /* R7 - DAC_GAINR */
+        0x0000,     /* R8 - ZERO_DETECT */
+};
+
+static int wm8523_volatile_register(unsigned int reg)
+{
+        switch (reg) {
+        case WM8523_DEVICE_ID:
+        case WM8523_REVISION:
+                return 1;
+        default:
+                return 0;
+        }
+}
+
+static int wm8523_reset(struct snd_soc_codec *codec)
+{
+        return snd_soc_write(codec, WM8523_DEVICE_ID, 0);
+}
+
+static const DECLARE_TLV_DB_SCALE(dac_tlv, -10000, 25, 0);
+
+static const char *wm8523_zd_count_text[] = {
+        "1024",
+        "2048",
+};
+
+static const struct soc_enum wm8523_zc_count =
+        SOC_ENUM_SINGLE(WM8523_ZERO_DETECT, 0, 2, wm8523_zd_count_text);
+
+static const struct snd_kcontrol_new wm8523_snd_controls[] = {
+SOC_DOUBLE_R_TLV("Playback Volume", WM8523_DAC_GAINL, WM8523_DAC_GAINR,
+                 0, 448, 0, dac_tlv),
+SOC_SINGLE("ZC Switch", WM8523_DAC_CTRL3, 4, 1, 0),
+SOC_SINGLE("Playback Deemphasis Switch", WM8523_AIF_CTRL1, 8, 1, 0),
+SOC_DOUBLE("Playback Switch", WM8523_DAC_CTRL3, 2, 3, 1, 1),
+SOC_SINGLE("Volume Ramp Up Switch", WM8523_DAC_CTRL3, 1, 1, 0),
+SOC_SINGLE("Volume Ramp Down Switch", WM8523_DAC_CTRL3, 0, 1, 0),
+SOC_ENUM("Zero Detect Count", wm8523_zc_count),
+};
+
+static const struct snd_soc_dapm_widget wm8523_dapm_widgets[] = {
+SND_SOC_DAPM_DAC("DAC", "Playback", SND_SOC_NOPM, 0, 0),
+SND_SOC_DAPM_OUTPUT("LINEVOUTL"),
+SND_SOC_DAPM_OUTPUT("LINEVOUTR"),
+};
+
+static const struct snd_soc_dapm_route intercon[] = {
+        { "LINEVOUTL", NULL, "DAC" },
+        { "LINEVOUTR", NULL, "DAC" },
+};
+
+static int wm8523_add_widgets(struct snd_soc_codec *codec)
+{
+        snd_soc_dapm_new_controls(codec, wm8523_dapm_widgets,
+                                  ARRAY_SIZE(wm8523_dapm_widgets));
+
+        snd_soc_dapm_add_routes(codec, intercon, ARRAY_SIZE(intercon));
+
+        snd_soc_dapm_new_widgets(codec);
+        return 0;
+}
+
+static struct {
+        int value;
+        int ratio;
+} lrclk_ratios[WM8523_NUM_RATES] = {
+        { 1, 128 },
+        { 2, 192 },
+        { 3, 256 },
+        { 4, 384 },
+        { 5, 512 },
+        { 6, 768 },
+        { 7, 1152 },
+};
+
+static int wm8523_startup(struct snd_pcm_substream *substream,
+                          struct snd_soc_dai *dai)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        struct wm8523_priv *wm8523 = codec->private_data;
+
+        /* The set of sample rates that can be supported depends on the
+         * MCLK supplied to the CODEC - enforce this.
+         */
+        if (!wm8523->sysclk) {
+                dev_err(codec->dev,
+                        "No MCLK configured, call set_sysclk() on init\n");
+                return -EINVAL;
+        }
+
+        return 0;
+        snd_pcm_hw_constraint_list(substream->runtime, 0,
+                                   SNDRV_PCM_HW_PARAM_RATE,
+                                   &wm8523->rate_constraint);
+
+        return 0;
+}
+
+static int wm8523_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 wm8523_priv *wm8523 = codec->private_data;
+        int i;
+        u16 aifctrl1 = snd_soc_read(codec, WM8523_AIF_CTRL1);
+        u16 aifctrl2 = snd_soc_read(codec, WM8523_AIF_CTRL2);
+
+        /* Find a supported LRCLK ratio */
+        for (i = 0; i < ARRAY_SIZE(lrclk_ratios); i++) {
+                if (wm8523->sysclk / params_rate(params) ==
+                    lrclk_ratios[i].ratio)
+                        break;
+        }
+
+        /* Should never happen, should be handled by constraints */
+        if (i == ARRAY_SIZE(lrclk_ratios)) {
+                dev_err(codec->dev, "MCLK/fs ratio %d unsupported\n",
+                        wm8523->sysclk / params_rate(params));
+                return -EINVAL;
+        }
+
+        aifctrl2 &= ~WM8523_SR_MASK;
+        aifctrl2 |= lrclk_ratios[i].value;
+
+        aifctrl1 &= ~WM8523_WL_MASK;
+        switch (params_format(params)) {
+        case SNDRV_PCM_FORMAT_S16_LE:
+                break;
+        case SNDRV_PCM_FORMAT_S20_3LE:
+                aifctrl1 |= 0x8;
+                break;
+        case SNDRV_PCM_FORMAT_S24_LE:
+                aifctrl1 |= 0x10;
+                break;
+        case SNDRV_PCM_FORMAT_S32_LE:
+                aifctrl1 |= 0x18;
+                break;
+        }
+
+        snd_soc_write(codec, WM8523_AIF_CTRL1, aifctrl1);
+        snd_soc_write(codec, WM8523_AIF_CTRL2, aifctrl2);
+
+        return 0;
+}
+
+static int wm8523_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 wm8523_priv *wm8523 = codec->private_data;
+        unsigned int val;
+        int i;
+
+        wm8523->sysclk = freq;
+
+        wm8523->rate_constraint.count = 0;
+        for (i = 0; i < ARRAY_SIZE(lrclk_ratios); i++) {
+                val = freq / lrclk_ratios[i].ratio;
+                /* Check that it's a standard rate since core can't
+                 * cope with others and having the odd rates confuses
+                 * constraint matching.
+                 */
+                switch (val) {
+                case 8000:
+                case 11025:
+                case 16000:
+                case 22050:
+                case 32000:
+                case 44100:
+                case 48000:
+                case 64000:
+                case 88200:
+                case 96000:
+                case 176400:
+                case 192000:
+                        dev_dbg(codec->dev, "Supported sample rate: %dHz\n",
+                                val);
+                        wm8523->rate_constraint_list[i] = val;
+                        wm8523->rate_constraint.count++;
+                        break;
+                default:
+                        dev_dbg(codec->dev, "Skipping sample rate: %dHz\n",
+                                val);
+                }
+        }
+
+        /* Need at least one supported rate... */
+        if (wm8523->rate_constraint.count == 0)
+                return -EINVAL;
+
+        return 0;
+}
+
+
+static int wm8523_set_dai_fmt(struct snd_soc_dai *codec_dai,
+                unsigned int fmt)
+{
+        struct snd_soc_codec *codec = codec_dai->codec;
+        u16 aifctrl1 = snd_soc_read(codec, WM8523_AIF_CTRL1);
+
+        aifctrl1 &= ~(WM8523_BCLK_INV_MASK | WM8523_LRCLK_INV_MASK |
+                      WM8523_FMT_MASK | WM8523_AIF_MSTR_MASK);
+
+        switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
+        case SND_SOC_DAIFMT_CBM_CFM:
+                aifctrl1 |= WM8523_AIF_MSTR;
+                break;
+        case SND_SOC_DAIFMT_CBS_CFS:
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
+        case SND_SOC_DAIFMT_I2S:
+                aifctrl1 |= 0x0002;
+                break;
+        case SND_SOC_DAIFMT_RIGHT_J:
+                break;
+        case SND_SOC_DAIFMT_LEFT_J:
+                aifctrl1 |= 0x0001;
+                break;
+        case SND_SOC_DAIFMT_DSP_A:
+                aifctrl1 |= 0x0003;
+                break;
+        case SND_SOC_DAIFMT_DSP_B:
+                aifctrl1 |= 0x0023;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
+        case SND_SOC_DAIFMT_NB_NF:
+                break;
+        case SND_SOC_DAIFMT_IB_IF:
+                aifctrl1 |= WM8523_BCLK_INV | WM8523_LRCLK_INV;
+                break;
+        case SND_SOC_DAIFMT_IB_NF:
+                aifctrl1 |= WM8523_BCLK_INV;
+                break;
+        case SND_SOC_DAIFMT_NB_IF:
+                aifctrl1 |= WM8523_LRCLK_INV;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        snd_soc_write(codec, WM8523_AIF_CTRL1, aifctrl1);
+
+        return 0;
+}
+
+static int wm8523_set_bias_level(struct snd_soc_codec *codec,
+                                 enum snd_soc_bias_level level)
+{
+        struct wm8523_priv *wm8523 = codec->private_data;
+        int ret, i;
+
+        switch (level) {
+        case SND_SOC_BIAS_ON:
+                break;
+
+        case SND_SOC_BIAS_PREPARE:
+                /* Full power on */
+                snd_soc_update_bits(codec, WM8523_PSCTRL1,
+                                    WM8523_SYS_ENA_MASK, 3);
+                break;
+
+        case SND_SOC_BIAS_STANDBY:
+                if (codec->bias_level == SND_SOC_BIAS_OFF) {
+                        ret = regulator_bulk_enable(ARRAY_SIZE(wm8523->supplies),
+                                                    wm8523->supplies);
+                        if (ret != 0) {
+                                dev_err(codec->dev,
+                                        "Failed to enable supplies: %d\n",
+                                        ret);
+                                return ret;
+                        }
+
+                        /* Initial power up */
+                        snd_soc_update_bits(codec, WM8523_PSCTRL1,
+                                            WM8523_SYS_ENA_MASK, 1);
+
+                        /* Sync back default/cached values */
+                        for (i = WM8523_AIF_CTRL1;
+                             i < WM8523_MAX_REGISTER; i++)
+                                snd_soc_write(codec, i, wm8523->reg_cache[i]);
+
+
+                        msleep(100);
+                }
+
+                /* Power up to mute */
+                snd_soc_update_bits(codec, WM8523_PSCTRL1,
+                                    WM8523_SYS_ENA_MASK, 2);
+
+                break;
+
+        case SND_SOC_BIAS_OFF:
+                /* The chip runs through the power down sequence for us. */
+                snd_soc_update_bits(codec, WM8523_PSCTRL1,
+                                    WM8523_SYS_ENA_MASK, 0);
+                msleep(100);
+
+                regulator_bulk_disable(ARRAY_SIZE(wm8523->supplies),
+                                       wm8523->supplies);
+                break;
+        }
+        codec->bias_level = level;
+        return 0;
+}
+
+#define WM8523_RATES SNDRV_PCM_RATE_8000_192000
+
+#define WM8523_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 wm8523_dai_ops = {
+        .startup        = wm8523_startup,
+        .hw_params      = wm8523_hw_params,
+        .set_sysclk     = wm8523_set_dai_sysclk,
+        .set_fmt        = wm8523_set_dai_fmt,
+};
+
+struct snd_soc_dai wm8523_dai = {
+        .name = "WM8523",
+        .playback = {
+                .stream_name = "Playback",
+                .channels_min = 2,  /* Mono modes not yet supported */
+                .channels_max = 2,
+                .rates = WM8523_RATES,
+                .formats = WM8523_FORMATS,
+        },
+        .ops = &wm8523_dai_ops,
+};
+EXPORT_SYMBOL_GPL(wm8523_dai);
+
+#ifdef CONFIG_PM
+static int wm8523_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;
+
+        wm8523_set_bias_level(codec, SND_SOC_BIAS_OFF);
+        return 0;
+}
+
+static int wm8523_resume(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec = socdev->card->codec;
+
+        wm8523_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+
+        return 0;
+}
+#else
+#define wm8523_suspend NULL
+#define wm8523_resume NULL
+#endif
+
+static int wm8523_probe(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec;
+        int ret = 0;
+
+        if (wm8523_codec == NULL) {
+                dev_err(&pdev->dev, "Codec device not registered\n");
+                return -ENODEV;
+        }
+
+        socdev->card->codec = wm8523_codec;
+        codec = wm8523_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, 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;
+}
+
+static int wm8523_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_wm8523 = {
+        .probe =        wm8523_probe,
+        .remove =       wm8523_remove,
+        .suspend =      wm8523_suspend,
+        .resume =       wm8523_resume,
+};
+EXPORT_SYMBOL_GPL(soc_codec_dev_wm8523);
+
+static int wm8523_register(struct wm8523_priv *wm8523,
+                           enum snd_soc_control_type control)
+{
+        int ret;
+        struct snd_soc_codec *codec = &wm8523->codec;
+        int i;
+
+        if (wm8523_codec) {
+                dev_err(codec->dev, "Another WM8523 is registered\n");
+                return -EINVAL;
+        }
+
+        mutex_init(&codec->mutex);
+        INIT_LIST_HEAD(&codec->dapm_widgets);
+        INIT_LIST_HEAD(&codec->dapm_paths);
+
+        codec->private_data = wm8523;
+        codec->name = "WM8523";
+        codec->owner = THIS_MODULE;
+        codec->bias_level = SND_SOC_BIAS_OFF;
+        codec->set_bias_level = wm8523_set_bias_level;
+        codec->dai = &wm8523_dai;
+        codec->num_dai = 1;
+        codec->reg_cache_size = WM8523_REGISTER_COUNT;
+        codec->reg_cache = &wm8523->reg_cache;
+        codec->volatile_register = wm8523_volatile_register;
+
+        wm8523->rate_constraint.list = &wm8523->rate_constraint_list[0];
+        wm8523->rate_constraint.count =
+                ARRAY_SIZE(wm8523->rate_constraint_list);
+
+        memcpy(codec->reg_cache, wm8523_reg, sizeof(wm8523_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(wm8523->supplies); i++)
+                wm8523->supplies[i].supply = wm8523_supply_names[i];
+
+        ret = regulator_bulk_get(codec->dev, ARRAY_SIZE(wm8523->supplies),
+                                 wm8523->supplies);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to request supplies: %d\n", ret);
+                goto err;
+        }
+
+        ret = regulator_bulk_enable(ARRAY_SIZE(wm8523->supplies),
+                                    wm8523->supplies);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to enable supplies: %d\n", ret);
+                goto err_get;
+        }
+
+        ret = snd_soc_read(codec, WM8523_DEVICE_ID);
+        if (ret < 0) {
+                dev_err(codec->dev, "Failed to read ID register\n");
+                goto err_enable;
+        }
+        if (ret != wm8523_reg[WM8523_DEVICE_ID]) {
+                dev_err(codec->dev, "Device is not a WM8523, ID is %x\n", ret);
+                ret = -EINVAL;
+                goto err_enable;
+        }
+
+        ret = snd_soc_read(codec, WM8523_REVISION);
+        if (ret < 0) {
+                dev_err(codec->dev, "Failed to read revision register\n");
+                goto err_enable;
+        }
+        dev_info(codec->dev, "revision %c\n",
+                 (ret & WM8523_CHIP_REV_MASK) + 'A');
+
+        ret = wm8523_reset(codec);
+        if (ret < 0) {
+                dev_err(codec->dev, "Failed to issue reset\n");
+                goto err_enable;
+        }
+
+        wm8523_dai.dev = codec->dev;
+
+        /* Change some default settings - latch VU and enable ZC */
+        wm8523->reg_cache[WM8523_DAC_GAINR] |= WM8523_DACR_VU;
+        wm8523->reg_cache[WM8523_DAC_CTRL3] |= WM8523_ZC;
+
+        wm8523_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+
+        /* Bias level configuration will have done an extra enable */
+        regulator_bulk_disable(ARRAY_SIZE(wm8523->supplies), wm8523->supplies);
+
+        wm8523_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(&wm8523_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(wm8523->supplies), wm8523->supplies);
+err_get:
+        regulator_bulk_free(ARRAY_SIZE(wm8523->supplies), wm8523->supplies);
+err:
+        kfree(wm8523);
+        return ret;
+}
+
+static void wm8523_unregister(struct wm8523_priv *wm8523)
+{
+        wm8523_set_bias_level(&wm8523->codec, SND_SOC_BIAS_OFF);
+        regulator_bulk_free(ARRAY_SIZE(wm8523->supplies), wm8523->supplies);
+        snd_soc_unregister_dai(&wm8523_dai);
+        snd_soc_unregister_codec(&wm8523->codec);
+        kfree(wm8523);
+        wm8523_codec = NULL;
+}
+
+#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+static __devinit int wm8523_i2c_probe(struct i2c_client *i2c,
+                                      const struct i2c_device_id *id)
+{
+        struct wm8523_priv *wm8523;
+        struct snd_soc_codec *codec;
+
+        wm8523 = kzalloc(sizeof(struct wm8523_priv), GFP_KERNEL);
+        if (wm8523 == NULL)
+                return -ENOMEM;
+
+        codec = &wm8523->codec;
+        codec->hw_write = (hw_write_t)i2c_master_send;
+
+        i2c_set_clientdata(i2c, wm8523);
+        codec->control_data = i2c;
+
+        codec->dev = &i2c->dev;
+
+        return wm8523_register(wm8523, SND_SOC_I2C);
+}
+
+static __devexit int wm8523_i2c_remove(struct i2c_client *client)
+{
+        struct wm8523_priv *wm8523 = i2c_get_clientdata(client);
+        wm8523_unregister(wm8523);
+        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 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, wm8523_i2c_id);
+
+static struct i2c_driver wm8523_i2c_driver = {
+        .driver = {
+                .name = "WM8523",
+                .owner = THIS_MODULE,
+        },
+        .probe =    wm8523_i2c_probe,
+        .remove =   __devexit_p(wm8523_i2c_remove),
+        .suspend =  wm8523_i2c_suspend,
+        .resume =   wm8523_i2c_resume,
+        .id_table = wm8523_i2c_id,
+};
+#endif
+
+static int __init wm8523_modinit(void)
+{
+        int ret;
+#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+        ret = i2c_add_driver(&wm8523_i2c_driver);
+        if (ret != 0) {
+                printk(KERN_ERR "Failed to register WM8523 I2C driver: %d\n",
+                       ret);
+        }
+#endif
+        return 0;
+}
+module_init(wm8523_modinit);
+
+static void __exit wm8523_exit(void)
+{
+#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+        i2c_del_driver(&wm8523_i2c_driver);
+#endif
+}
+module_exit(wm8523_exit);
+
+MODULE_DESCRIPTION("ASoC WM8523 driver");
+MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/codecs/wm8523.h b/sound/soc/codecs/wm8523.h
new file mode 100644
index 000000000000..1aa9ce3e1357
--- /dev/null
+++ b/sound/soc/codecs/wm8523.h
@@ -0,0 +1,160 @@
+/*
+ * wm8523.h  --  WM8423 ASoC driver
+ *
+ * Copyright 2009 Wolfson Microelectronics, plc
+ *
+ * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
+ *
+ * Based on wm8753.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 _WM8523_H
+#define _WM8523_H
+
+/*
+ * Register values.
+ */
+#define WM8523_DEVICE_ID                        0x00
+#define WM8523_REVISION                         0x01
+#define WM8523_PSCTRL1                          0x02
+#define WM8523_AIF_CTRL1                        0x03
+#define WM8523_AIF_CTRL2                        0x04
+#define WM8523_DAC_CTRL3                        0x05
+#define WM8523_DAC_GAINL                        0x06
+#define WM8523_DAC_GAINR                        0x07
+#define WM8523_ZERO_DETECT                      0x08
+
+#define WM8523_REGISTER_COUNT                   9
+#define WM8523_MAX_REGISTER                     0x08
+
+/*
+ * Field Definitions.
+ */
+
+/*
+ * R0 (0x00) - DEVICE_ID
+ */
+#define WM8523_CHIP_ID_MASK                     0xFFFF  /* CHIP_ID - [15:0] */
+#define WM8523_CHIP_ID_SHIFT                         0  /* CHIP_ID - [15:0] */
+#define WM8523_CHIP_ID_WIDTH                        16  /* CHIP_ID - [15:0] */
+
+/*
+ * R1 (0x01) - REVISION
+ */
+#define WM8523_CHIP_REV_MASK                    0x0007  /* CHIP_REV - [2:0] */
+#define WM8523_CHIP_REV_SHIFT                        0  /* CHIP_REV - [2:0] */
+#define WM8523_CHIP_REV_WIDTH                        3  /* CHIP_REV - [2:0] */
+
+/*
+ * R2 (0x02) - PSCTRL1
+ */
+#define WM8523_SYS_ENA_MASK                     0x0003  /* SYS_ENA - [1:0] */
+#define WM8523_SYS_ENA_SHIFT                         0  /* SYS_ENA - [1:0] */
+#define WM8523_SYS_ENA_WIDTH                         2  /* SYS_ENA - [1:0] */
+
+/*
+ * R3 (0x03) - AIF_CTRL1
+ */
+#define WM8523_TDM_MODE_MASK                    0x1800  /* TDM_MODE - [12:11] */
+#define WM8523_TDM_MODE_SHIFT                       11  /* TDM_MODE - [12:11] */
+#define WM8523_TDM_MODE_WIDTH                        2  /* TDM_MODE - [12:11] */
+#define WM8523_TDM_SLOT_MASK                    0x0600  /* TDM_SLOT - [10:9] */
+#define WM8523_TDM_SLOT_SHIFT                        9  /* TDM_SLOT - [10:9] */
+#define WM8523_TDM_SLOT_WIDTH                        2  /* TDM_SLOT - [10:9] */
+#define WM8523_DEEMPH                           0x0100  /* DEEMPH  */
+#define WM8523_DEEMPH_MASK                      0x0100  /* DEEMPH  */
+#define WM8523_DEEMPH_SHIFT                          8  /* DEEMPH  */
+#define WM8523_DEEMPH_WIDTH                          1  /* DEEMPH  */
+#define WM8523_AIF_MSTR                         0x0080  /* AIF_MSTR  */
+#define WM8523_AIF_MSTR_MASK                    0x0080  /* AIF_MSTR  */
+#define WM8523_AIF_MSTR_SHIFT                        7  /* AIF_MSTR  */
+#define WM8523_AIF_MSTR_WIDTH                        1  /* AIF_MSTR  */
+#define WM8523_LRCLK_INV                        0x0040  /* LRCLK_INV  */
+#define WM8523_LRCLK_INV_MASK                   0x0040  /* LRCLK_INV  */
+#define WM8523_LRCLK_INV_SHIFT                       6  /* LRCLK_INV  */
+#define WM8523_LRCLK_INV_WIDTH                       1  /* LRCLK_INV  */
+#define WM8523_BCLK_INV                         0x0020  /* BCLK_INV  */
+#define WM8523_BCLK_INV_MASK                    0x0020  /* BCLK_INV  */
+#define WM8523_BCLK_INV_SHIFT                        5  /* BCLK_INV  */
+#define WM8523_BCLK_INV_WIDTH                        1  /* BCLK_INV  */
+#define WM8523_WL_MASK                          0x0018  /* WL - [4:3] */
+#define WM8523_WL_SHIFT                              3  /* WL - [4:3] */
+#define WM8523_WL_WIDTH                              2  /* WL - [4:3] */
+#define WM8523_FMT_MASK                         0x0007  /* FMT - [2:0] */
+#define WM8523_FMT_SHIFT                             0  /* FMT - [2:0] */
+#define WM8523_FMT_WIDTH                             3  /* FMT - [2:0] */
+
+/*
+ * R4 (0x04) - AIF_CTRL2
+ */
+#define WM8523_DAC_OP_MUX_MASK                  0x00C0  /* DAC_OP_MUX - [7:6] */
+#define WM8523_DAC_OP_MUX_SHIFT                      6  /* DAC_OP_MUX - [7:6] */
+#define WM8523_DAC_OP_MUX_WIDTH                      2  /* DAC_OP_MUX - [7:6] */
+#define WM8523_BCLKDIV_MASK                     0x0038  /* BCLKDIV - [5:3] */
+#define WM8523_BCLKDIV_SHIFT                         3  /* BCLKDIV - [5:3] */
+#define WM8523_BCLKDIV_WIDTH                         3  /* BCLKDIV - [5:3] */
+#define WM8523_SR_MASK                          0x0007  /* SR - [2:0] */
+#define WM8523_SR_SHIFT                              0  /* SR - [2:0] */
+#define WM8523_SR_WIDTH                              3  /* SR - [2:0] */
+
+/*
+ * R5 (0x05) - DAC_CTRL3
+ */
+#define WM8523_ZC                               0x0010  /* ZC  */
+#define WM8523_ZC_MASK                          0x0010  /* ZC  */
+#define WM8523_ZC_SHIFT                              4  /* ZC  */
+#define WM8523_ZC_WIDTH                              1  /* ZC  */
+#define WM8523_DACR                             0x0008  /* DACR  */
+#define WM8523_DACR_MASK                        0x0008  /* DACR  */
+#define WM8523_DACR_SHIFT                            3  /* DACR  */
+#define WM8523_DACR_WIDTH                            1  /* DACR  */
+#define WM8523_DACL                             0x0004  /* DACL  */
+#define WM8523_DACL_MASK                        0x0004  /* DACL  */
+#define WM8523_DACL_SHIFT                            2  /* DACL  */
+#define WM8523_DACL_WIDTH                            1  /* DACL  */
+#define WM8523_VOL_UP_RAMP                      0x0002  /* VOL_UP_RAMP  */
+#define WM8523_VOL_UP_RAMP_MASK                 0x0002  /* VOL_UP_RAMP  */
+#define WM8523_VOL_UP_RAMP_SHIFT                     1  /* VOL_UP_RAMP  */
+#define WM8523_VOL_UP_RAMP_WIDTH                     1  /* VOL_UP_RAMP  */
+#define WM8523_VOL_DOWN_RAMP                    0x0001  /* VOL_DOWN_RAMP  */
+#define WM8523_VOL_DOWN_RAMP_MASK               0x0001  /* VOL_DOWN_RAMP  */
+#define WM8523_VOL_DOWN_RAMP_SHIFT                   0  /* VOL_DOWN_RAMP  */
+#define WM8523_VOL_DOWN_RAMP_WIDTH                   1  /* VOL_DOWN_RAMP  */
+
+/*
+ * R6 (0x06) - DAC_GAINL
+ */
+#define WM8523_DACL_VU                          0x0200  /* DACL_VU  */
+#define WM8523_DACL_VU_MASK                     0x0200  /* DACL_VU  */
+#define WM8523_DACL_VU_SHIFT                         9  /* DACL_VU  */
+#define WM8523_DACL_VU_WIDTH                         1  /* DACL_VU  */
+#define WM8523_DACL_VOL_MASK                    0x01FF  /* DACL_VOL - [8:0] */
+#define WM8523_DACL_VOL_SHIFT                        0  /* DACL_VOL - [8:0] */
+#define WM8523_DACL_VOL_WIDTH                        9  /* DACL_VOL - [8:0] */
+
+/*
+ * R7 (0x07) - DAC_GAINR
+ */
+#define WM8523_DACR_VU                          0x0200  /* DACR_VU  */
+#define WM8523_DACR_VU_MASK                     0x0200  /* DACR_VU  */
+#define WM8523_DACR_VU_SHIFT                         9  /* DACR_VU  */
+#define WM8523_DACR_VU_WIDTH                         1  /* DACR_VU  */
+#define WM8523_DACR_VOL_MASK                    0x01FF  /* DACR_VOL - [8:0] */
+#define WM8523_DACR_VOL_SHIFT                        0  /* DACR_VOL - [8:0] */
+#define WM8523_DACR_VOL_WIDTH                        9  /* DACR_VOL - [8:0] */
+
+/*
+ * R8 (0x08) - ZERO_DETECT
+ */
+#define WM8523_ZD_COUNT_MASK                    0x0003  /* ZD_COUNT - [1:0] */
+#define WM8523_ZD_COUNT_SHIFT                        0  /* ZD_COUNT - [1:0] */
+#define WM8523_ZD_COUNT_WIDTH                        2  /* ZD_COUNT - [1:0] */
+
+extern struct snd_soc_dai wm8523_dai;
+extern struct snd_soc_codec_device soc_codec_dev_wm8523;
+
+#endif
diff --git a/sound/soc/codecs/wm8580.c b/sound/soc/codecs/wm8580.c
index 9f6be3d31ac0..d5473473a1e3 100644
--- a/sound/soc/codecs/wm8580.c
+++ b/sound/soc/codecs/wm8580.c
@@ -24,6 +24,8 @@
 #include <linux/pm.h>
 #include <linux/i2c.h>
 #include <linux/platform_device.h>
+#include <linux/regulator/consumer.h>
+
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
@@ -187,82 +189,22 @@ struct pll_state {
         unsigned int out;
 };
 
+#define WM8580_NUM_SUPPLIES 3
+static const char *wm8580_supply_names[WM8580_NUM_SUPPLIES] = {
+        "AVDD",
+        "DVDD",
+        "PVDD",
+};
+
 /* codec private data */
 struct wm8580_priv {
         struct snd_soc_codec codec;
+        struct regulator_bulk_data supplies[WM8580_NUM_SUPPLIES];
         u16 reg_cache[WM8580_MAX_REGISTER + 1];
         struct pll_state a;
         struct pll_state b;
 };
 
-
-/*
- * read wm8580 register cache
- */
-static inline unsigned int wm8580_read_reg_cache(struct snd_soc_codec *codec,
-        unsigned int reg)
-{
-        u16 *cache = codec->reg_cache;
-        BUG_ON(reg >= ARRAY_SIZE(wm8580_reg));
-        return cache[reg];
-}
-
-/*
- * write wm8580 register cache
- */
-static inline void wm8580_write_reg_cache(struct snd_soc_codec *codec,
-        unsigned int reg, unsigned int value)
-{
-        u16 *cache = codec->reg_cache;
-
-        cache[reg] = value;
-}
-
-/*
- * write to the WM8580 register space
- */
-static int wm8580_write(struct snd_soc_codec *codec, unsigned int reg,
-        unsigned int value)
-{
-        u8 data[2];
-
-        BUG_ON(reg >= ARRAY_SIZE(wm8580_reg));
-
-        /* Registers are 9 bits wide */
-        value &= 0x1ff;
-
-        switch (reg) {
-        case WM8580_RESET:
-                /* Uncached */
-                break;
-        default:
-                if (value == wm8580_read_reg_cache(codec, reg))
-                        return 0;
-        }
-
-        /* data is
-         *   D15..D9 WM8580 register offset
-         *   D8...D0 register data
-         */
-        data[0] = (reg << 1) | ((value >> 8) & 0x0001);
-        data[1] = value & 0x00ff;
-
-        wm8580_write_reg_cache(codec, reg, value);
-        if (codec->hw_write(codec->control_data, data, 2) == 2)
-                return 0;
-        else
-                return -EIO;
-}
-
-static inline unsigned int wm8580_read(struct snd_soc_codec *codec,
-                                       unsigned int reg)
-{
-        switch (reg) {
-        default:
-                return wm8580_read_reg_cache(codec, reg);
-        }
-}
-
 static const DECLARE_TLV_DB_SCALE(dac_tlv, -12750, 50, 1);
 
 static int wm8580_out_vu(struct snd_kcontrol *kcontrol,
@@ -271,25 +213,22 @@ static int wm8580_out_vu(struct snd_kcontrol *kcontrol,
         struct soc_mixer_control *mc =
                 (struct soc_mixer_control *)kcontrol->private_value;
         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+        u16 *reg_cache = codec->reg_cache;
         unsigned int reg = mc->reg;
         unsigned int reg2 = mc->rreg;
         int ret;
-        u16 val;
 
         /* Clear the register cache so we write without VU set */
-        wm8580_write_reg_cache(codec, reg, 0);
-        wm8580_write_reg_cache(codec, reg2, 0);
+        reg_cache[reg] = 0;
+        reg_cache[reg2] = 0;
 
         ret = snd_soc_put_volsw_2r(kcontrol, ucontrol);
         if (ret < 0)
                 return ret;
 
         /* Now write again with the volume update bit set */
-        val = wm8580_read_reg_cache(codec, reg);
-        wm8580_write(codec, reg, val | 0x0100);
-
-        val = wm8580_read_reg_cache(codec, reg2);
-        wm8580_write(codec, reg2, val | 0x0100);
+        snd_soc_update_bits(codec, reg, 0x100, 0x100);
+        snd_soc_update_bits(codec, reg2, 0x100, 0x100);
 
         return 0;
 }
@@ -415,7 +354,7 @@ static int pll_factors(struct _pll_div *pll_div, unsigned int target,
         unsigned int K, Ndiv, Nmod;
         int i;
 
-        pr_debug("wm8580: PLL %dHz->%dHz\n", source, target);
+        pr_debug("wm8580: PLL %uHz->%uHz\n", source, target);
 
         /* Scale the output frequency up; the PLL should run in the
          * region of 90-100MHz.
@@ -447,7 +386,7 @@ static int pll_factors(struct _pll_div *pll_div, unsigned int target,
 
         if ((Ndiv < 5) || (Ndiv > 13)) {
                 printk(KERN_ERR
-                        "WM8580 N=%d outside supported range\n", Ndiv);
+                        "WM8580 N=%u outside supported range\n", Ndiv);
                 return -EINVAL;
         }
 
@@ -512,27 +451,27 @@ static int wm8580_set_dai_pll(struct snd_soc_dai *codec_dai,
         /* Always disable the PLL - it is not safe to leave it running
          * while reprogramming it.
          */
-        reg = wm8580_read(codec, WM8580_PWRDN2);
-        wm8580_write(codec, WM8580_PWRDN2, reg | pwr_mask);
+        reg = snd_soc_read(codec, WM8580_PWRDN2);
+        snd_soc_write(codec, WM8580_PWRDN2, reg | pwr_mask);
 
         if (!freq_in || !freq_out)
                 return 0;
 
-        wm8580_write(codec, WM8580_PLLA1 + offset, pll_div.k & 0x1ff);
-        wm8580_write(codec, WM8580_PLLA2 + offset, (pll_div.k >> 9) & 0xff);
-        wm8580_write(codec, WM8580_PLLA3 + offset,
+        snd_soc_write(codec, WM8580_PLLA1 + offset, pll_div.k & 0x1ff);
+        snd_soc_write(codec, WM8580_PLLA2 + offset, (pll_div.k >> 9) & 0xff);
+        snd_soc_write(codec, WM8580_PLLA3 + offset,
                      (pll_div.k >> 18 & 0xf) | (pll_div.n << 4));
 
-        reg = wm8580_read(codec, WM8580_PLLA4 + offset);
+        reg = snd_soc_read(codec, WM8580_PLLA4 + offset);
         reg &= ~0x3f;
         reg |= pll_div.prescale | pll_div.postscale << 1 |
                 pll_div.freqmode << 3;
 
-        wm8580_write(codec, WM8580_PLLA4 + offset, reg);
+        snd_soc_write(codec, WM8580_PLLA4 + offset, reg);
 
         /* All done, turn it on */
-        reg = wm8580_read(codec, WM8580_PWRDN2);
-        wm8580_write(codec, WM8580_PWRDN2, reg & ~pwr_mask);
+        reg = snd_soc_read(codec, WM8580_PWRDN2);
+        snd_soc_write(codec, WM8580_PWRDN2, reg & ~pwr_mask);
 
         return 0;
 }
@@ -547,7 +486,7 @@ static int wm8580_paif_hw_params(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;
-        u16 paifb = wm8580_read(codec, WM8580_PAIF3 + dai->id);
+        u16 paifb = snd_soc_read(codec, WM8580_PAIF3 + dai->id);
 
         paifb &= ~WM8580_AIF_LENGTH_MASK;
         /* bit size */
@@ -567,7 +506,7 @@ static int wm8580_paif_hw_params(struct snd_pcm_substream *substream,
                 return -EINVAL;
         }
 
-        wm8580_write(codec, WM8580_PAIF3 + dai->id, paifb);
+        snd_soc_write(codec, WM8580_PAIF3 + dai->id, paifb);
         return 0;
 }
 
@@ -579,8 +518,8 @@ static int wm8580_set_paif_dai_fmt(struct snd_soc_dai *codec_dai,
         unsigned int aifb;
         int can_invert_lrclk;
 
-        aifa = wm8580_read(codec, WM8580_PAIF1 + codec_dai->id);
-        aifb = wm8580_read(codec, WM8580_PAIF3 + codec_dai->id);
+        aifa = snd_soc_read(codec, WM8580_PAIF1 + codec_dai->id);
+        aifb = snd_soc_read(codec, WM8580_PAIF3 + codec_dai->id);
 
         aifb &= ~(WM8580_AIF_FMT_MASK | WM8580_AIF_LRP | WM8580_AIF_BCP);
 
@@ -646,8 +585,8 @@ static int wm8580_set_paif_dai_fmt(struct snd_soc_dai *codec_dai,
                 return -EINVAL;
         }
 
-        wm8580_write(codec, WM8580_PAIF1 + codec_dai->id, aifa);
-        wm8580_write(codec, WM8580_PAIF3 + codec_dai->id, aifb);
+        snd_soc_write(codec, WM8580_PAIF1 + codec_dai->id, aifa);
+        snd_soc_write(codec, WM8580_PAIF3 + codec_dai->id, aifb);
 
         return 0;
 }
@@ -660,7 +599,7 @@ static int wm8580_set_dai_clkdiv(struct snd_soc_dai *codec_dai,
 
         switch (div_id) {
         case WM8580_MCLK:
-                reg = wm8580_read(codec, WM8580_PLLB4);
+                reg = snd_soc_read(codec, WM8580_PLLB4);
                 reg &= ~WM8580_PLLB4_MCLKOUTSRC_MASK;
 
                 switch (div) {
@@ -682,11 +621,11 @@ static int wm8580_set_dai_clkdiv(struct snd_soc_dai *codec_dai,
                 default:
                         return -EINVAL;
                 }
-                wm8580_write(codec, WM8580_PLLB4, reg);
+                snd_soc_write(codec, WM8580_PLLB4, reg);
                 break;
 
         case WM8580_DAC_CLKSEL:
-                reg = wm8580_read(codec, WM8580_CLKSEL);
+                reg = snd_soc_read(codec, WM8580_CLKSEL);
                 reg &= ~WM8580_CLKSEL_DAC_CLKSEL_MASK;
 
                 switch (div) {
@@ -704,11 +643,11 @@ static int wm8580_set_dai_clkdiv(struct snd_soc_dai *codec_dai,
                 default:
                         return -EINVAL;
                 }
-                wm8580_write(codec, WM8580_CLKSEL, reg);
+                snd_soc_write(codec, WM8580_CLKSEL, reg);
                 break;
 
         case WM8580_CLKOUTSRC:
-                reg = wm8580_read(codec, WM8580_PLLB4);
+                reg = snd_soc_read(codec, WM8580_PLLB4);
                 reg &= ~WM8580_PLLB4_CLKOUTSRC_MASK;
 
                 switch (div) {
@@ -730,7 +669,7 @@ static int wm8580_set_dai_clkdiv(struct snd_soc_dai *codec_dai,
                 default:
                         return -EINVAL;
                 }
-                wm8580_write(codec, WM8580_PLLB4, reg);
+                snd_soc_write(codec, WM8580_PLLB4, reg);
                 break;
 
         default:
@@ -745,14 +684,14 @@ static int wm8580_digital_mute(struct snd_soc_dai *codec_dai, int mute)
         struct snd_soc_codec *codec = codec_dai->codec;
         unsigned int reg;
 
-        reg = wm8580_read(codec, WM8580_DAC_CONTROL5);
+        reg = snd_soc_read(codec, WM8580_DAC_CONTROL5);
 
         if (mute)
                 reg |= WM8580_DAC_CONTROL5_MUTEALL;
         else
                 reg &= ~WM8580_DAC_CONTROL5_MUTEALL;
 
-        wm8580_write(codec, WM8580_DAC_CONTROL5, reg);
+        snd_soc_write(codec, WM8580_DAC_CONTROL5, reg);
 
         return 0;
 }
@@ -769,20 +708,20 @@ static int wm8580_set_bias_level(struct snd_soc_codec *codec,
         case SND_SOC_BIAS_STANDBY:
                 if (codec->bias_level == SND_SOC_BIAS_OFF) {
                         /* Power up and get individual control of the DACs */
-                        reg = wm8580_read(codec, WM8580_PWRDN1);
+                        reg = snd_soc_read(codec, WM8580_PWRDN1);
                         reg &= ~(WM8580_PWRDN1_PWDN | WM8580_PWRDN1_ALLDACPD);
-                        wm8580_write(codec, WM8580_PWRDN1, reg);
+                        snd_soc_write(codec, WM8580_PWRDN1, reg);
 
                         /* Make VMID high impedence */
-                        reg = wm8580_read(codec,  WM8580_ADC_CONTROL1);
+                        reg = snd_soc_read(codec,  WM8580_ADC_CONTROL1);
                         reg &= ~0x100;
-                        wm8580_write(codec, WM8580_ADC_CONTROL1, reg);
+                        snd_soc_write(codec, WM8580_ADC_CONTROL1, reg);
                 }
                 break;
 
         case SND_SOC_BIAS_OFF:
-                reg = wm8580_read(codec, WM8580_PWRDN1);
-                wm8580_write(codec, WM8580_PWRDN1, reg | WM8580_PWRDN1_PWDN);
+                reg = snd_soc_read(codec, WM8580_PWRDN1);
+                snd_soc_write(codec, WM8580_PWRDN1, reg | WM8580_PWRDN1_PWDN);
                 break;
         }
         codec->bias_level = level;
@@ -893,7 +832,8 @@ struct snd_soc_codec_device soc_codec_dev_wm8580 = {
 };
 EXPORT_SYMBOL_GPL(soc_codec_dev_wm8580);
 
-static int wm8580_register(struct wm8580_priv *wm8580)
+static int wm8580_register(struct wm8580_priv *wm8580,
+                           enum snd_soc_control_type control)
 {
         int ret, i;
         struct snd_soc_codec *codec = &wm8580->codec;
@@ -911,8 +851,6 @@ static int wm8580_register(struct wm8580_priv *wm8580)
         codec->private_data = wm8580;
         codec->name = "WM8580";
         codec->owner = THIS_MODULE;
-        codec->read = wm8580_read_reg_cache;
-        codec->write = wm8580_write;
         codec->bias_level = SND_SOC_BIAS_OFF;
         codec->set_bias_level = wm8580_set_bias_level;
         codec->dai = wm8580_dai;
@@ -922,11 +860,34 @@ static int wm8580_register(struct wm8580_priv *wm8580)
 
         memcpy(codec->reg_cache, wm8580_reg, sizeof(wm8580_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(wm8580->supplies); i++)
+                wm8580->supplies[i].supply = wm8580_supply_names[i];
+
+        ret = regulator_bulk_get(codec->dev, ARRAY_SIZE(wm8580->supplies),
+                                 wm8580->supplies);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to request supplies: %d\n", ret);
+                goto err;
+        }
+
+        ret = regulator_bulk_enable(ARRAY_SIZE(wm8580->supplies),
+                                    wm8580->supplies);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to enable supplies: %d\n", ret);
+                goto err_regulator_get;
+        }
+
         /* Get the codec into a known state */
-        ret = wm8580_write(codec, WM8580_RESET, 0);
+        ret = snd_soc_write(codec, WM8580_RESET, 0);
         if (ret != 0) {
                 dev_err(codec->dev, "Failed to reset codec: %d\n", ret);
-                goto err;
+                goto err_regulator_enable;
         }
 
         for (i = 0; i < ARRAY_SIZE(wm8580_dai); i++)
@@ -939,7 +900,7 @@ static int wm8580_register(struct wm8580_priv *wm8580)
         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_dais(wm8580_dai, ARRAY_SIZE(wm8580_dai));
@@ -952,6 +913,10 @@ static int wm8580_register(struct wm8580_priv *wm8580)
 
 err_codec:
         snd_soc_unregister_codec(codec);
+err_regulator_enable:
+        regulator_bulk_disable(ARRAY_SIZE(wm8580->supplies), wm8580->supplies);
+err_regulator_get:
+        regulator_bulk_free(ARRAY_SIZE(wm8580->supplies), wm8580->supplies);
 err:
         kfree(wm8580);
         return ret;
@@ -962,6 +927,8 @@ static void wm8580_unregister(struct wm8580_priv *wm8580)
         wm8580_set_bias_level(&wm8580->codec, SND_SOC_BIAS_OFF);
         snd_soc_unregister_dais(wm8580_dai, ARRAY_SIZE(wm8580_dai));
         snd_soc_unregister_codec(&wm8580->codec);
+        regulator_bulk_disable(ARRAY_SIZE(wm8580->supplies), wm8580->supplies);
+        regulator_bulk_free(ARRAY_SIZE(wm8580->supplies), wm8580->supplies);
         kfree(wm8580);
         wm8580_codec = NULL;
 }
@@ -978,14 +945,13 @@ static int wm8580_i2c_probe(struct i2c_client *i2c,
                 return -ENOMEM;
 
         codec = &wm8580->codec;
-        codec->hw_write = (hw_write_t)i2c_master_send;
 
         i2c_set_clientdata(i2c, wm8580);
         codec->control_data = i2c;
 
         codec->dev = &i2c->dev;
 
-        return wm8580_register(wm8580);
+        return wm8580_register(wm8580, SND_SOC_I2C);
 }
 
 static int wm8580_i2c_remove(struct i2c_client *client)
@@ -995,6 +961,21 @@ 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 },
         { }
@@ -1008,6 +989,8 @@ 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/wm8728.c b/sound/soc/codecs/wm8728.c
index e7ff2121ede9..16e969a762c3 100644
--- a/sound/soc/codecs/wm8728.c
+++ b/sound/soc/codecs/wm8728.c
@@ -43,45 +43,6 @@ static const u16 wm8728_reg_defaults[] = {
         0x100,
 };
 
-static inline unsigned int wm8728_read_reg_cache(struct snd_soc_codec *codec,
-        unsigned int reg)
-{
-        u16 *cache = codec->reg_cache;
-        BUG_ON(reg >= ARRAY_SIZE(wm8728_reg_defaults));
-        return cache[reg];
-}
-
-static inline void wm8728_write_reg_cache(struct snd_soc_codec *codec,
-        u16 reg, unsigned int value)
-{
-        u16 *cache = codec->reg_cache;
-        BUG_ON(reg >= ARRAY_SIZE(wm8728_reg_defaults));
-        cache[reg] = value;
-}
-
-/*
- * write to the WM8728 register space
- */
-static int wm8728_write(struct snd_soc_codec *codec, unsigned int reg,
-        unsigned int value)
-{
-        u8 data[2];
-
-        /* data is
-         *   D15..D9 WM8728 register offset
-         *   D8...D0 register data
-         */
-        data[0] = (reg << 1) | ((value >> 8) & 0x0001);
-        data[1] = value & 0x00ff;
-
-        wm8728_write_reg_cache(codec, reg, value);
-
-        if (codec->hw_write(codec->control_data, data, 2) == 2)
-                return 0;
-        else
-                return -EIO;
-}
-
 static const DECLARE_TLV_DB_SCALE(wm8728_tlv, -12750, 50, 1);
 
 static const struct snd_kcontrol_new wm8728_snd_controls[] = {
@@ -121,12 +82,12 @@ static int wm8728_add_widgets(struct snd_soc_codec *codec)
 static int wm8728_mute(struct snd_soc_dai *dai, int mute)
 {
         struct snd_soc_codec *codec = dai->codec;
-        u16 mute_reg = wm8728_read_reg_cache(codec, WM8728_DACCTL);
+        u16 mute_reg = snd_soc_read(codec, WM8728_DACCTL);
 
         if (mute)
-                wm8728_write(codec, WM8728_DACCTL, mute_reg | 1);
+                snd_soc_write(codec, WM8728_DACCTL, mute_reg | 1);
         else
-                wm8728_write(codec, WM8728_DACCTL, mute_reg & ~1);
+                snd_soc_write(codec, WM8728_DACCTL, mute_reg & ~1);
 
         return 0;
 }
@@ -138,7 +99,7 @@ static int wm8728_hw_params(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;
-        u16 dac = wm8728_read_reg_cache(codec, WM8728_DACCTL);
+        u16 dac = snd_soc_read(codec, WM8728_DACCTL);
 
         dac &= ~0x18;
 
@@ -155,7 +116,7 @@ static int wm8728_hw_params(struct snd_pcm_substream *substream,
                 return -EINVAL;
         }
 
-        wm8728_write(codec, WM8728_DACCTL, dac);
+        snd_soc_write(codec, WM8728_DACCTL, dac);
 
         return 0;
 }
@@ -164,7 +125,7 @@ static int wm8728_set_dai_fmt(struct snd_soc_dai *codec_dai,
                 unsigned int fmt)
 {
         struct snd_soc_codec *codec = codec_dai->codec;
-        u16 iface = wm8728_read_reg_cache(codec, WM8728_IFCTL);
+        u16 iface = snd_soc_read(codec, WM8728_IFCTL);
 
         /* Currently only I2S is supported by the driver, though the
          * hardware is more flexible.
@@ -204,7 +165,7 @@ static int wm8728_set_dai_fmt(struct snd_soc_dai *codec_dai,
                 return -EINVAL;
         }
 
-        wm8728_write(codec, WM8728_IFCTL, iface);
+        snd_soc_write(codec, WM8728_IFCTL, iface);
         return 0;
 }
 
@@ -220,19 +181,19 @@ static int wm8728_set_bias_level(struct snd_soc_codec *codec,
         case SND_SOC_BIAS_STANDBY:
                 if (codec->bias_level == SND_SOC_BIAS_OFF) {
                         /* Power everything up... */
-                        reg = wm8728_read_reg_cache(codec, WM8728_DACCTL);
-                        wm8728_write(codec, WM8728_DACCTL, reg & ~0x4);
+                        reg = snd_soc_read(codec, WM8728_DACCTL);
+                        snd_soc_write(codec, WM8728_DACCTL, reg & ~0x4);
 
                         /* ..then sync in the register cache. */
                         for (i = 0; i < ARRAY_SIZE(wm8728_reg_defaults); i++)
-                                wm8728_write(codec, i,
-                                             wm8728_read_reg_cache(codec, i));
+                                snd_soc_write(codec, i,
+                                             snd_soc_read(codec, i));
                 }
                 break;
 
         case SND_SOC_BIAS_OFF:
-                reg = wm8728_read_reg_cache(codec, WM8728_DACCTL);
-                wm8728_write(codec, WM8728_DACCTL, reg | 0x4);
+                reg = snd_soc_read(codec, WM8728_DACCTL);
+                snd_soc_write(codec, WM8728_DACCTL, reg | 0x4);
                 break;
         }
         codec->bias_level = level;
@@ -287,15 +248,14 @@ static int wm8728_resume(struct platform_device *pdev)
  * initialise the WM8728 driver
  * register the mixer and dsp interfaces with the kernel
  */
-static int wm8728_init(struct snd_soc_device *socdev)
+static int wm8728_init(struct snd_soc_device *socdev,
+                       enum snd_soc_control_type control)
 {
         struct snd_soc_codec *codec = socdev->card->codec;
         int ret = 0;
 
         codec->name = "WM8728";
         codec->owner = THIS_MODULE;
-        codec->read = wm8728_read_reg_cache;
-        codec->write = wm8728_write;
         codec->set_bias_level = wm8728_set_bias_level;
         codec->dai = &wm8728_dai;
         codec->num_dai = 1;
@@ -307,11 +267,18 @@ static int wm8728_init(struct snd_soc_device *socdev)
         if (codec->reg_cache == NULL)
                 return -ENOMEM;
 
+        ret = snd_soc_codec_set_cache_io(codec, 7, 9, control);
+        if (ret < 0) {
+                printk(KERN_ERR "wm8728: failed to configure cache I/O: %d\n",
+                       ret);
+                goto err;
+        }
+
         /* register pcms */
         ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
         if (ret < 0) {
                 printk(KERN_ERR "wm8728: failed to create pcms\n");
-                goto pcm_err;
+                goto err;
         }
 
         /* power on device */
@@ -331,7 +298,7 @@ static int wm8728_init(struct snd_soc_device *socdev)
 card_err:
         snd_soc_free_pcms(socdev);
         snd_soc_dapm_free(socdev);
-pcm_err:
+err:
         kfree(codec->reg_cache);
         return ret;
 }
@@ -357,7 +324,7 @@ static int wm8728_i2c_probe(struct i2c_client *i2c,
         i2c_set_clientdata(i2c, codec);
         codec->control_data = i2c;
 
-        ret = wm8728_init(socdev);
+        ret = wm8728_init(socdev, SND_SOC_I2C);
         if (ret < 0)
                 pr_err("failed to initialise WM8728\n");
 
@@ -437,7 +404,7 @@ static int __devinit wm8728_spi_probe(struct spi_device *spi)
 
         codec->control_data = spi;
 
-        ret = wm8728_init(socdev);
+        ret = wm8728_init(socdev, SND_SOC_SPI);
         if (ret < 0)
                 dev_err(&spi->dev, "failed to initialise WM8728\n");
 
@@ -458,30 +425,6 @@ static struct spi_driver wm8728_spi_driver = {
         .probe          = wm8728_spi_probe,
         .remove         = __devexit_p(wm8728_spi_remove),
 };
-
-static int wm8728_spi_write(struct spi_device *spi, const char *data, int len)
-{
-        struct spi_transfer t;
-        struct spi_message m;
-        u8 msg[2];
-
-        if (len <= 0)
-                return 0;
-
-        msg[0] = data[0];
-        msg[1] = data[1];
-
-        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;
-}
 #endif /* CONFIG_SPI_MASTER */
 
 static int wm8728_probe(struct platform_device *pdev)
@@ -506,13 +449,11 @@ static int wm8728_probe(struct platform_device *pdev)
 
 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
         if (setup->i2c_address) {
-                codec->hw_write = (hw_write_t)i2c_master_send;
                 ret = wm8728_add_i2c_device(pdev, setup);
         }
 #endif
 #if defined(CONFIG_SPI_MASTER)
         if (setup->spi) {
-                codec->hw_write = (hw_write_t)wm8728_spi_write;
                 ret = spi_register_driver(&wm8728_spi_driver);
                 if (ret != 0)
                         printk(KERN_ERR "can't add spi driver");
diff --git a/sound/soc/codecs/wm8731.c b/sound/soc/codecs/wm8731.c
index e043e3f60008..d3fd4f28d96e 100644
--- a/sound/soc/codecs/wm8731.c
+++ b/sound/soc/codecs/wm8731.c
@@ -26,6 +26,7 @@
 #include <sound/soc.h>
 #include <sound/soc-dapm.h>
 #include <sound/initval.h>
+#include <sound/tlv.h>
 
 #include "wm8731.h"
 
@@ -39,9 +40,6 @@ struct wm8731_priv {
         unsigned int sysclk;
 };
 
-#ifdef CONFIG_SPI_MASTER
-static int wm8731_spi_write(struct spi_device *spi, const char *data, int len);
-#endif
 
 /*
  * wm8731 register cache
@@ -50,60 +48,12 @@ static int wm8731_spi_write(struct spi_device *spi, const char *data, int len);
  * There is no point in caching the reset register
  */
 static const u16 wm8731_reg[WM8731_CACHEREGNUM] = {
-    0x0097, 0x0097, 0x0079, 0x0079,
-    0x000a, 0x0008, 0x009f, 0x000a,
-    0x0000, 0x0000
+        0x0097, 0x0097, 0x0079, 0x0079,
+        0x000a, 0x0008, 0x009f, 0x000a,
+        0x0000, 0x0000
 };
 
-/*
- * read wm8731 register cache
- */
-static inline unsigned int wm8731_read_reg_cache(struct snd_soc_codec *codec,
-        unsigned int reg)
-{
-        u16 *cache = codec->reg_cache;
-        if (reg == WM8731_RESET)
-                return 0;
-        if (reg >= WM8731_CACHEREGNUM)
-                return -1;
-        return cache[reg];
-}
-
-/*
- * write wm8731 register cache
- */
-static inline void wm8731_write_reg_cache(struct snd_soc_codec *codec,
-        u16 reg, unsigned int value)
-{
-        u16 *cache = codec->reg_cache;
-        if (reg >= WM8731_CACHEREGNUM)
-                return;
-        cache[reg] = value;
-}
-
-/*
- * write to the WM8731 register space
- */
-static int wm8731_write(struct snd_soc_codec *codec, unsigned int reg,
-        unsigned int value)
-{
-        u8 data[2];
-
-        /* data is
-         *   D15..D9 WM8731 register offset
-         *   D8...D0 register data
-         */
-        data[0] = (reg << 1) | ((value >> 8) & 0x0001);
-        data[1] = value & 0x00ff;
-
-        wm8731_write_reg_cache(codec, reg, value);
-        if (codec->hw_write(codec->control_data, data, 2) == 2)
-                return 0;
-        else
-                return -EIO;
-}
-
-#define wm8731_reset(c) wm8731_write(c, WM8731_RESET, 0)
+#define wm8731_reset(c) snd_soc_write(c, WM8731_RESET, 0)
 
 static const char *wm8731_input_select[] = {"Line In", "Mic"};
 static const char *wm8731_deemph[] = {"None", "32Khz", "44.1Khz", "48Khz"};
@@ -113,20 +63,26 @@ static const struct soc_enum wm8731_enum[] = {
         SOC_ENUM_SINGLE(WM8731_APDIGI, 1, 4, wm8731_deemph),
 };
 
+static const DECLARE_TLV_DB_SCALE(in_tlv, -3450, 150, 0);
+static const DECLARE_TLV_DB_SCALE(sidetone_tlv, -1500, 300, 0);
+static const DECLARE_TLV_DB_SCALE(out_tlv, -12100, 100, 1);
+
 static const struct snd_kcontrol_new wm8731_snd_controls[] = {
 
-SOC_DOUBLE_R("Master Playback Volume", WM8731_LOUT1V, WM8731_ROUT1V,
-        0, 127, 0),
+SOC_DOUBLE_R_TLV("Master Playback Volume", WM8731_LOUT1V, WM8731_ROUT1V,
+                 0, 127, 0, out_tlv),
 SOC_DOUBLE_R("Master Playback ZC Switch", WM8731_LOUT1V, WM8731_ROUT1V,
         7, 1, 0),
 
-SOC_DOUBLE_R("Capture Volume", WM8731_LINVOL, WM8731_RINVOL, 0, 31, 0),
+SOC_DOUBLE_R_TLV("Capture Volume", WM8731_LINVOL, WM8731_RINVOL, 0, 31, 0,
+                 in_tlv),
 SOC_DOUBLE_R("Line Capture Switch", WM8731_LINVOL, WM8731_RINVOL, 7, 1, 1),
 
 SOC_SINGLE("Mic Boost (+20dB)", WM8731_APANA, 0, 1, 0),
-SOC_SINGLE("Capture Mic Switch", WM8731_APANA, 1, 1, 1),
+SOC_SINGLE("Mic Capture Switch", WM8731_APANA, 1, 1, 1),
 
-SOC_SINGLE("Sidetone Playback Volume", WM8731_APANA, 6, 3, 1),
+SOC_SINGLE_TLV("Sidetone Playback Volume", WM8731_APANA, 6, 3, 1,
+               sidetone_tlv),
 
 SOC_SINGLE("ADC High Pass Filter Switch", WM8731_APDIGI, 0, 1, 1),
 SOC_SINGLE("Store DC Offset Switch", WM8731_APDIGI, 4, 1, 0),
@@ -260,12 +216,12 @@ static int wm8731_hw_params(struct snd_pcm_substream *substream,
         struct snd_soc_device *socdev = rtd->socdev;
         struct snd_soc_codec *codec = socdev->card->codec;
         struct wm8731_priv *wm8731 = codec->private_data;
-        u16 iface = wm8731_read_reg_cache(codec, WM8731_IFACE) & 0xfff3;
+        u16 iface = snd_soc_read(codec, WM8731_IFACE) & 0xfff3;
         int i = get_coeff(wm8731->sysclk, params_rate(params));
         u16 srate = (coeff_div[i].sr << 2) |
                 (coeff_div[i].bosr << 1) | coeff_div[i].usb;
 
-        wm8731_write(codec, WM8731_SRATE, srate);
+        snd_soc_write(codec, WM8731_SRATE, srate);
 
         /* bit size */
         switch (params_format(params)) {
@@ -279,7 +235,7 @@ static int wm8731_hw_params(struct snd_pcm_substream *substream,
                 break;
         }
 
-        wm8731_write(codec, WM8731_IFACE, iface);
+        snd_soc_write(codec, WM8731_IFACE, iface);
         return 0;
 }
 
@@ -291,7 +247,7 @@ static int wm8731_pcm_prepare(struct snd_pcm_substream *substream,
         struct snd_soc_codec *codec = socdev->card->codec;
 
         /* set active */
-        wm8731_write(codec, WM8731_ACTIVE, 0x0001);
+        snd_soc_write(codec, WM8731_ACTIVE, 0x0001);
 
         return 0;
 }
@@ -306,19 +262,19 @@ static void wm8731_shutdown(struct snd_pcm_substream *substream,
         /* deactivate */
         if (!codec->active) {
                 udelay(50);
-                wm8731_write(codec, WM8731_ACTIVE, 0x0);
+                snd_soc_write(codec, WM8731_ACTIVE, 0x0);
         }
 }
 
 static int wm8731_mute(struct snd_soc_dai *dai, int mute)
 {
         struct snd_soc_codec *codec = dai->codec;
-        u16 mute_reg = wm8731_read_reg_cache(codec, WM8731_APDIGI) & 0xfff7;
+        u16 mute_reg = snd_soc_read(codec, WM8731_APDIGI) & 0xfff7;
 
         if (mute)
-                wm8731_write(codec, WM8731_APDIGI, mute_reg | 0x8);
+                snd_soc_write(codec, WM8731_APDIGI, mute_reg | 0x8);
         else
-                wm8731_write(codec, WM8731_APDIGI, mute_reg);
+                snd_soc_write(codec, WM8731_APDIGI, mute_reg);
         return 0;
 }
 
@@ -396,7 +352,7 @@ static int wm8731_set_dai_fmt(struct snd_soc_dai *codec_dai,
         }
 
         /* set iface */
-        wm8731_write(codec, WM8731_IFACE, iface);
+        snd_soc_write(codec, WM8731_IFACE, iface);
         return 0;
 }
 
@@ -412,12 +368,12 @@ static int wm8731_set_bias_level(struct snd_soc_codec *codec,
                 break;
         case SND_SOC_BIAS_STANDBY:
                 /* Clear PWROFF, gate CLKOUT, everything else as-is */
-                reg = wm8731_read_reg_cache(codec, WM8731_PWR) & 0xff7f;
-                wm8731_write(codec, WM8731_PWR, reg | 0x0040);
+                reg = snd_soc_read(codec, WM8731_PWR) & 0xff7f;
+                snd_soc_write(codec, WM8731_PWR, reg | 0x0040);
                 break;
         case SND_SOC_BIAS_OFF:
-                wm8731_write(codec, WM8731_ACTIVE, 0x0);
-                wm8731_write(codec, WM8731_PWR, 0xffff);
+                snd_soc_write(codec, WM8731_ACTIVE, 0x0);
+                snd_soc_write(codec, WM8731_PWR, 0xffff);
                 break;
         }
         codec->bias_level = level;
@@ -457,15 +413,17 @@ struct snd_soc_dai wm8731_dai = {
                 .rates = WM8731_RATES,
                 .formats = WM8731_FORMATS,},
         .ops = &wm8731_dai_ops,
+        .symmetric_rates = 1,
 };
 EXPORT_SYMBOL_GPL(wm8731_dai);
 
+#ifdef CONFIG_PM
 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;
 
-        wm8731_write(codec, WM8731_ACTIVE, 0x0);
+        snd_soc_write(codec, WM8731_ACTIVE, 0x0);
         wm8731_set_bias_level(codec, SND_SOC_BIAS_OFF);
         return 0;
 }
@@ -488,6 +446,10 @@ static int wm8731_resume(struct platform_device *pdev)
         wm8731_set_bias_level(codec, codec->suspend_bias_level);
         return 0;
 }
+#else
+#define wm8731_suspend NULL
+#define wm8731_resume NULL
+#endif
 
 static int wm8731_probe(struct platform_device *pdev)
 {
@@ -547,15 +509,16 @@ struct snd_soc_codec_device soc_codec_dev_wm8731 = {
 };
 EXPORT_SYMBOL_GPL(soc_codec_dev_wm8731);
 
-static int wm8731_register(struct wm8731_priv *wm8731)
+static int wm8731_register(struct wm8731_priv *wm8731,
+                           enum snd_soc_control_type control)
 {
         int ret;
         struct snd_soc_codec *codec = &wm8731->codec;
-        u16 reg;
 
         if (wm8731_codec) {
                 dev_err(codec->dev, "Another WM8731 is registered\n");
-                return -EINVAL;
+                ret = -EINVAL;
+                goto err;
         }
 
         mutex_init(&codec->mutex);
@@ -565,8 +528,6 @@ static int wm8731_register(struct wm8731_priv *wm8731)
         codec->private_data = wm8731;
         codec->name = "WM8731";
         codec->owner = THIS_MODULE;
-        codec->read = wm8731_read_reg_cache;
-        codec->write = wm8731_write;
         codec->bias_level = SND_SOC_BIAS_OFF;
         codec->set_bias_level = wm8731_set_bias_level;
         codec->dai = &wm8731_dai;
@@ -576,10 +537,16 @@ static int wm8731_register(struct wm8731_priv *wm8731)
 
         memcpy(codec->reg_cache, wm8731_reg, sizeof(wm8731_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 = wm8731_reset(codec);
         if (ret < 0) {
-                dev_err(codec->dev, "Failed to issue reset\n");
-                return ret;
+                dev_err(codec->dev, "Failed to issue reset: %d\n", ret);
+                goto err;
         }
 
         wm8731_dai.dev = codec->dev;
@@ -587,35 +554,36 @@ static int wm8731_register(struct wm8731_priv *wm8731)
         wm8731_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
 
         /* Latch the update bits */
-        reg = wm8731_read_reg_cache(codec, WM8731_LOUT1V);
-        wm8731_write(codec, WM8731_LOUT1V, reg & ~0x0100);
-        reg = wm8731_read_reg_cache(codec, WM8731_ROUT1V);
-        wm8731_write(codec, WM8731_ROUT1V, reg & ~0x0100);
-        reg = wm8731_read_reg_cache(codec, WM8731_LINVOL);
-        wm8731_write(codec, WM8731_LINVOL, reg & ~0x0100);
-        reg = wm8731_read_reg_cache(codec, WM8731_RINVOL);
-        wm8731_write(codec, WM8731_RINVOL, reg & ~0x0100);
+        snd_soc_update_bits(codec, WM8731_LOUT1V, 0x100, 0);
+        snd_soc_update_bits(codec, WM8731_ROUT1V, 0x100, 0);
+        snd_soc_update_bits(codec, WM8731_LINVOL, 0x100, 0);
+        snd_soc_update_bits(codec, WM8731_RINVOL, 0x100, 0);
 
         /* Disable bypass path by default */
-        reg = wm8731_read_reg_cache(codec, WM8731_APANA);
-        wm8731_write(codec, WM8731_APANA, reg & ~0x4);
+        snd_soc_update_bits(codec, WM8731_APANA, 0x4, 0);
 
         wm8731_codec = codec;
 
         ret = snd_soc_register_codec(codec);
         if (ret != 0) {
                 dev_err(codec->dev, "Failed to register codec: %d\n", ret);
-                return ret;
+                goto err;
         }
 
         ret = snd_soc_register_dai(&wm8731_dai);
         if (ret != 0) {
                 dev_err(codec->dev, "Failed to register DAI: %d\n", ret);
                 snd_soc_unregister_codec(codec);
-                return ret;
+                goto err_codec;
         }
 
         return 0;
+
+err_codec:
+        snd_soc_unregister_codec(codec);
+err:
+        kfree(wm8731);
+        return ret;
 }
 
 static void wm8731_unregister(struct wm8731_priv *wm8731)
@@ -628,30 +596,6 @@ static void wm8731_unregister(struct wm8731_priv *wm8731)
 }
 
 #if defined(CONFIG_SPI_MASTER)
-static int wm8731_spi_write(struct spi_device *spi, const char *data, int len)
-{
-        struct spi_transfer t;
-        struct spi_message m;
-        u8 msg[2];
-
-        if (len <= 0)
-                return 0;
-
-        msg[0] = data[0];
-        msg[1] = data[1];
-
-        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;
-}
-
 static int __devinit wm8731_spi_probe(struct spi_device *spi)
 {
         struct snd_soc_codec *codec;
@@ -663,23 +607,37 @@ static int __devinit wm8731_spi_probe(struct spi_device *spi)
 
         codec = &wm8731->codec;
         codec->control_data = spi;
-        codec->hw_write = (hw_write_t)wm8731_spi_write;
         codec->dev = &spi->dev;
 
-        spi->dev.driver_data = wm8731;
+        dev_set_drvdata(&spi->dev, wm8731);
 
-        return wm8731_register(wm8731);
+        return wm8731_register(wm8731, SND_SOC_SPI);
 }
 
 static int __devexit wm8731_spi_remove(struct spi_device *spi)
 {
-        struct wm8731_priv *wm8731 = spi->dev.driver_data;
+        struct wm8731_priv *wm8731 = dev_get_drvdata(&spi->dev);
 
         wm8731_unregister(wm8731);
 
         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",
@@ -687,6 +645,8 @@ 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 */
@@ -703,14 +663,13 @@ static __devinit int wm8731_i2c_probe(struct i2c_client *i2c,
                 return -ENOMEM;
 
         codec = &wm8731->codec;
-        codec->hw_write = (hw_write_t)i2c_master_send;
 
         i2c_set_clientdata(i2c, wm8731);
         codec->control_data = i2c;
 
         codec->dev = &i2c->dev;
 
-        return wm8731_register(wm8731);
+        return wm8731_register(wm8731, SND_SOC_I2C);
 }
 
 static __devexit int wm8731_i2c_remove(struct i2c_client *client)
@@ -720,6 +679,21 @@ 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 },
         { }
@@ -733,6 +707,8 @@ 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 b64509b01a49..4ba1e7e93fb4 100644
--- a/sound/soc/codecs/wm8750.c
+++ b/sound/soc/codecs/wm8750.c
@@ -55,50 +55,7 @@ static const u16 wm8750_reg[] = {
         0x0079, 0x0079, 0x0079,          /* 40 */
 };
 
-/*
- * read wm8750 register cache
- */
-static inline unsigned int wm8750_read_reg_cache(struct snd_soc_codec *codec,
-        unsigned int reg)
-{
-        u16 *cache = codec->reg_cache;
-        if (reg > WM8750_CACHE_REGNUM)
-                return -1;
-        return cache[reg];
-}
-
-/*
- * write wm8750 register cache
- */
-static inline void wm8750_write_reg_cache(struct snd_soc_codec *codec,
-        unsigned int reg, unsigned int value)
-{
-        u16 *cache = codec->reg_cache;
-        if (reg > WM8750_CACHE_REGNUM)
-                return;
-        cache[reg] = value;
-}
-
-static int wm8750_write(struct snd_soc_codec *codec, unsigned int reg,
-        unsigned int value)
-{
-        u8 data[2];
-
-        /* data is
-         *   D15..D9 WM8753 register offset
-         *   D8...D0 register data
-         */
-        data[0] = (reg << 1) | ((value >> 8) & 0x0001);
-        data[1] = value & 0x00ff;
-
-        wm8750_write_reg_cache(codec, reg, value);
-        if (codec->hw_write(codec->control_data, data, 2) == 2)
-                return 0;
-        else
-                return -EIO;
-}
-
-#define wm8750_reset(c) wm8750_write(c, WM8750_RESET, 0)
+#define wm8750_reset(c) snd_soc_write(c, WM8750_RESET, 0)
 
 /*
  * WM8750 Controls
@@ -594,7 +551,7 @@ static int wm8750_set_dai_fmt(struct snd_soc_dai *codec_dai,
                 return -EINVAL;
         }
 
-        wm8750_write(codec, WM8750_IFACE, iface);
+        snd_soc_write(codec, WM8750_IFACE, iface);
         return 0;
 }
 
@@ -606,8 +563,8 @@ static int wm8750_pcm_hw_params(struct snd_pcm_substream *substream,
         struct snd_soc_device *socdev = rtd->socdev;
         struct snd_soc_codec *codec = socdev->card->codec;
         struct wm8750_priv *wm8750 = codec->private_data;
-        u16 iface = wm8750_read_reg_cache(codec, WM8750_IFACE) & 0x1f3;
-        u16 srate = wm8750_read_reg_cache(codec, WM8750_SRATE) & 0x1c0;
+        u16 iface = snd_soc_read(codec, WM8750_IFACE) & 0x1f3;
+        u16 srate = snd_soc_read(codec, WM8750_SRATE) & 0x1c0;
         int coeff = get_coeff(wm8750->sysclk, params_rate(params));
 
         /* bit size */
@@ -626,9 +583,9 @@ static int wm8750_pcm_hw_params(struct snd_pcm_substream *substream,
         }
 
         /* set iface & srate */
-        wm8750_write(codec, WM8750_IFACE, iface);
+        snd_soc_write(codec, WM8750_IFACE, iface);
         if (coeff >= 0)
-                wm8750_write(codec, WM8750_SRATE, srate |
+                snd_soc_write(codec, WM8750_SRATE, srate |
                         (coeff_div[coeff].sr << 1) | coeff_div[coeff].usb);
 
         return 0;
@@ -637,35 +594,35 @@ static int wm8750_pcm_hw_params(struct snd_pcm_substream *substream,
 static int wm8750_mute(struct snd_soc_dai *dai, int mute)
 {
         struct snd_soc_codec *codec = dai->codec;
-        u16 mute_reg = wm8750_read_reg_cache(codec, WM8750_ADCDAC) & 0xfff7;
+        u16 mute_reg = snd_soc_read(codec, WM8750_ADCDAC) & 0xfff7;
 
         if (mute)
-                wm8750_write(codec, WM8750_ADCDAC, mute_reg | 0x8);
+                snd_soc_write(codec, WM8750_ADCDAC, mute_reg | 0x8);
         else
-                wm8750_write(codec, WM8750_ADCDAC, mute_reg);
+                snd_soc_write(codec, WM8750_ADCDAC, mute_reg);
         return 0;
 }
 
 static int wm8750_set_bias_level(struct snd_soc_codec *codec,
                                  enum snd_soc_bias_level level)
 {
-        u16 pwr_reg = wm8750_read_reg_cache(codec, WM8750_PWR1) & 0xfe3e;
+        u16 pwr_reg = snd_soc_read(codec, WM8750_PWR1) & 0xfe3e;
 
         switch (level) {
         case SND_SOC_BIAS_ON:
                 /* set vmid to 50k and unmute dac */
-                wm8750_write(codec, WM8750_PWR1, pwr_reg | 0x00c0);
+                snd_soc_write(codec, WM8750_PWR1, pwr_reg | 0x00c0);
                 break;
         case SND_SOC_BIAS_PREPARE:
                 /* set vmid to 5k for quick power up */
-                wm8750_write(codec, WM8750_PWR1, pwr_reg | 0x01c1);
+                snd_soc_write(codec, WM8750_PWR1, pwr_reg | 0x01c1);
                 break;
         case SND_SOC_BIAS_STANDBY:
                 /* mute dac and set vmid to 500k, enable VREF */
-                wm8750_write(codec, WM8750_PWR1, pwr_reg | 0x0141);
+                snd_soc_write(codec, WM8750_PWR1, pwr_reg | 0x0141);
                 break;
         case SND_SOC_BIAS_OFF:
-                wm8750_write(codec, WM8750_PWR1, 0x0001);
+                snd_soc_write(codec, WM8750_PWR1, 0x0001);
                 break;
         }
         codec->bias_level = level;
@@ -754,15 +711,14 @@ static int wm8750_resume(struct platform_device *pdev)
  * initialise the WM8750 driver
  * register the mixer and dsp interfaces with the kernel
  */
-static int wm8750_init(struct snd_soc_device *socdev)
+static int wm8750_init(struct snd_soc_device *socdev,
+                       enum snd_soc_control_type control)
 {
         struct snd_soc_codec *codec = socdev->card->codec;
         int reg, ret = 0;
 
         codec->name = "WM8750";
         codec->owner = THIS_MODULE;
-        codec->read = wm8750_read_reg_cache;
-        codec->write = wm8750_write;
         codec->set_bias_level = wm8750_set_bias_level;
         codec->dai = &wm8750_dai;
         codec->num_dai = 1;
@@ -771,13 +727,23 @@ static int wm8750_init(struct snd_soc_device *socdev)
         if (codec->reg_cache == NULL)
                 return -ENOMEM;
 
-        wm8750_reset(codec);
+        ret = snd_soc_codec_set_cache_io(codec, 7, 9, control);
+        if (ret < 0) {
+                printk(KERN_ERR "wm8750: failed to set cache I/O: %d\n", ret);
+                goto err;
+        }
+
+        ret = wm8750_reset(codec);
+        if (ret < 0) {
+                printk(KERN_ERR "wm8750: failed to reset: %d\n", ret);
+                goto err;
+        }
 
         /* register pcms */
         ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
         if (ret < 0) {
                 printk(KERN_ERR "wm8750: failed to create pcms\n");
-                goto pcm_err;
+                goto err;
         }
 
         /* charge output caps */
@@ -786,22 +752,22 @@ static int wm8750_init(struct snd_soc_device *socdev)
         schedule_delayed_work(&codec->delayed_work, msecs_to_jiffies(1000));
 
         /* set the update bits */
-        reg = wm8750_read_reg_cache(codec, WM8750_LDAC);
-        wm8750_write(codec, WM8750_LDAC, reg | 0x0100);
-        reg = wm8750_read_reg_cache(codec, WM8750_RDAC);
-        wm8750_write(codec, WM8750_RDAC, reg | 0x0100);
-        reg = wm8750_read_reg_cache(codec, WM8750_LOUT1V);
-        wm8750_write(codec, WM8750_LOUT1V, reg | 0x0100);
-        reg = wm8750_read_reg_cache(codec, WM8750_ROUT1V);
-        wm8750_write(codec, WM8750_ROUT1V, reg | 0x0100);
-        reg = wm8750_read_reg_cache(codec, WM8750_LOUT2V);
-        wm8750_write(codec, WM8750_LOUT2V, reg | 0x0100);
-        reg = wm8750_read_reg_cache(codec, WM8750_ROUT2V);
-        wm8750_write(codec, WM8750_ROUT2V, reg | 0x0100);
-        reg = wm8750_read_reg_cache(codec, WM8750_LINVOL);
-        wm8750_write(codec, WM8750_LINVOL, reg | 0x0100);
-        reg = wm8750_read_reg_cache(codec, WM8750_RINVOL);
-        wm8750_write(codec, WM8750_RINVOL, reg | 0x0100);
+        reg = snd_soc_read(codec, WM8750_LDAC);
+        snd_soc_write(codec, WM8750_LDAC, reg | 0x0100);
+        reg = snd_soc_read(codec, WM8750_RDAC);
+        snd_soc_write(codec, WM8750_RDAC, reg | 0x0100);
+        reg = snd_soc_read(codec, WM8750_LOUT1V);
+        snd_soc_write(codec, WM8750_LOUT1V, reg | 0x0100);
+        reg = snd_soc_read(codec, WM8750_ROUT1V);
+        snd_soc_write(codec, WM8750_ROUT1V, reg | 0x0100);
+        reg = snd_soc_read(codec, WM8750_LOUT2V);
+        snd_soc_write(codec, WM8750_LOUT2V, reg | 0x0100);
+        reg = snd_soc_read(codec, WM8750_ROUT2V);
+        snd_soc_write(codec, WM8750_ROUT2V, reg | 0x0100);
+        reg = snd_soc_read(codec, WM8750_LINVOL);
+        snd_soc_write(codec, WM8750_LINVOL, reg | 0x0100);
+        reg = snd_soc_read(codec, WM8750_RINVOL);
+        snd_soc_write(codec, WM8750_RINVOL, reg | 0x0100);
 
         snd_soc_add_controls(codec, wm8750_snd_controls,
                                 ARRAY_SIZE(wm8750_snd_controls));
@@ -816,7 +782,7 @@ static int wm8750_init(struct snd_soc_device *socdev)
 card_err:
         snd_soc_free_pcms(socdev);
         snd_soc_dapm_free(socdev);
-pcm_err:
+err:
         kfree(codec->reg_cache);
         return ret;
 }
@@ -844,7 +810,7 @@ static int wm8750_i2c_probe(struct i2c_client *i2c,
         i2c_set_clientdata(i2c, codec);
         codec->control_data = i2c;
 
-        ret = wm8750_init(socdev);
+        ret = wm8750_init(socdev, SND_SOC_I2C);
         if (ret < 0)
                 pr_err("failed to initialise WM8750\n");
 
@@ -924,7 +890,7 @@ static int __devinit wm8750_spi_probe(struct spi_device *spi)
 
         codec->control_data = spi;
 
-        ret = wm8750_init(socdev);
+        ret = wm8750_init(socdev, SND_SOC_SPI);
         if (ret < 0)
                 dev_err(&spi->dev, "failed to initialise WM8750\n");
 
@@ -945,30 +911,6 @@ static struct spi_driver wm8750_spi_driver = {
         .probe          = wm8750_spi_probe,
         .remove         = __devexit_p(wm8750_spi_remove),
 };
-
-static int wm8750_spi_write(struct spi_device *spi, const char *data, int len)
-{
-        struct spi_transfer t;
-        struct spi_message m;
-        u8 msg[2];
-
-        if (len <= 0)
-                return 0;
-
-        msg[0] = data[0];
-        msg[1] = data[1];
-
-        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;
-}
 #endif
 
 static int wm8750_probe(struct platform_device *pdev)
@@ -1002,13 +944,11 @@ static int wm8750_probe(struct platform_device *pdev)
 
 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
         if (setup->i2c_address) {
-                codec->hw_write = (hw_write_t)i2c_master_send;
                 ret = wm8750_add_i2c_device(pdev, setup);
         }
 #endif
 #if defined(CONFIG_SPI_MASTER)
         if (setup->spi) {
-                codec->hw_write = (hw_write_t)wm8750_spi_write;
                 ret = spi_register_driver(&wm8750_spi_driver);
                 if (ret != 0)
                         printk(KERN_ERR "can't add spi driver");
diff --git a/sound/soc/codecs/wm8753.c b/sound/soc/codecs/wm8753.c
index a6e8f3f7f052..d80d414cfbbd 100644
--- a/sound/soc/codecs/wm8753.c
+++ b/sound/soc/codecs/wm8753.c
@@ -79,7 +79,7 @@ static const u16 wm8753_reg[] = {
         0x0097, 0x0097, 0x0000, 0x0004,
         0x0000, 0x0083, 0x0024, 0x01ba,
         0x0000, 0x0083, 0x0024, 0x01ba,
-        0x0000, 0x0000
+        0x0000, 0x0000, 0x0000
 };
 
 /* codec private data */
@@ -703,7 +703,7 @@ static void pll_factors(struct _pll_div *pll_div, unsigned int target,
 
         if ((Ndiv < 6) || (Ndiv > 12))
                 printk(KERN_WARNING
-                        "wm8753: unsupported N = %d\n", Ndiv);
+                        "wm8753: unsupported N = %u\n", Ndiv);
 
         pll_div->n = Ndiv;
         Nmod = target % source;
@@ -1660,11 +1660,11 @@ static int wm8753_register(struct wm8753_priv *wm8753)
         codec->set_bias_level = wm8753_set_bias_level;
         codec->dai = wm8753_dai;
         codec->num_dai = 2;
-        codec->reg_cache_size = ARRAY_SIZE(wm8753->reg_cache);
+        codec->reg_cache_size = ARRAY_SIZE(wm8753->reg_cache) + 1;
         codec->reg_cache = &wm8753->reg_cache;
         codec->private_data = wm8753;
 
-        memcpy(codec->reg_cache, wm8753_reg, sizeof(codec->reg_cache));
+        memcpy(codec->reg_cache, wm8753_reg, sizeof(wm8753->reg_cache));
         INIT_DELAYED_WORK(&codec->delayed_work, wm8753_work);
 
         ret = wm8753_reset(codec);
@@ -1766,6 +1766,21 @@ 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 },
         { }
@@ -1779,6 +1794,8 @@ 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
@@ -1822,18 +1839,34 @@ static int __devinit wm8753_spi_probe(struct spi_device *spi)
         codec->hw_write = (hw_write_t)wm8753_spi_write;
         codec->dev = &spi->dev;
 
-        spi->dev.driver_data = wm8753;
+        dev_set_drvdata(&spi->dev, wm8753);
 
         return wm8753_register(wm8753);
 }
 
 static int __devexit wm8753_spi_remove(struct spi_device *spi)
 {
-        struct wm8753_priv *wm8753 = spi->dev.driver_data;
+        struct wm8753_priv *wm8753 = dev_get_drvdata(&spi->dev);
         wm8753_unregister(wm8753);
         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",
@@ -1842,6 +1875,8 @@ 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
new file mode 100644
index 000000000000..a9829aa26e53
--- /dev/null
+++ b/sound/soc/codecs/wm8776.c
@@ -0,0 +1,744 @@
+/*
+ * wm8776.c  --  WM8776 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.
+ *
+ * TODO: Input ALC/limiter support
+ */
+
+#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 <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 "wm8776.h"
+
+static struct snd_soc_codec *wm8776_codec;
+struct snd_soc_codec_device soc_codec_dev_wm8776;
+
+/* codec private data */
+struct wm8776_priv {
+        struct snd_soc_codec codec;
+        u16 reg_cache[WM8776_CACHEREGNUM];
+        int sysclk[2];
+};
+
+#ifdef CONFIG_SPI_MASTER
+static int wm8776_spi_write(struct spi_device *spi, const char *data, int len);
+#endif
+
+static const u16 wm8776_reg[WM8776_CACHEREGNUM] = {
+        0x79, 0x79, 0x79, 0xff, 0xff,  /* 4 */
+        0xff, 0x00, 0x90, 0x00, 0x00,  /* 9 */
+        0x22, 0x22, 0x22, 0x08, 0xcf,  /* 14 */
+        0xcf, 0x7b, 0x00, 0x32, 0x00,  /* 19 */
+        0xa6, 0x01, 0x01
+};
+
+static int wm8776_reset(struct snd_soc_codec *codec)
+{
+        return snd_soc_write(codec, WM8776_RESET, 0);
+}
+
+static const DECLARE_TLV_DB_SCALE(hp_tlv, -12100, 100, 1);
+static const DECLARE_TLV_DB_SCALE(dac_tlv, -12750, 50, 1);
+static const DECLARE_TLV_DB_SCALE(adc_tlv, -10350, 50, 1);
+
+static const struct snd_kcontrol_new wm8776_snd_controls[] = {
+SOC_DOUBLE_R_TLV("Headphone Playback Volume", WM8776_HPLVOL, WM8776_HPRVOL,
+                 0, 127, 0, hp_tlv),
+SOC_DOUBLE_R_TLV("Digital Playback Volume", WM8776_DACLVOL, WM8776_DACRVOL,
+                 0, 255, 0, dac_tlv),
+SOC_SINGLE("Digital Playback ZC Switch", WM8776_DACCTRL1, 0, 1, 0),
+
+SOC_SINGLE("Deemphasis Switch", WM8776_DACCTRL2, 0, 1, 0),
+
+SOC_DOUBLE_R_TLV("Capture Volume", WM8776_ADCLVOL, WM8776_ADCRVOL,
+                 0, 255, 0, adc_tlv),
+SOC_DOUBLE("Capture Switch", WM8776_ADCMUX, 7, 6, 1, 1),
+SOC_DOUBLE_R("Capture ZC Switch", WM8776_ADCLVOL, WM8776_ADCRVOL, 8, 1, 0),
+SOC_SINGLE("Capture HPF Switch", WM8776_ADCIFCTRL, 8, 1, 1),
+};
+
+static const struct snd_kcontrol_new inmix_controls[] = {
+SOC_DAPM_SINGLE("AIN1 Switch", WM8776_ADCMUX, 0, 1, 0),
+SOC_DAPM_SINGLE("AIN2 Switch", WM8776_ADCMUX, 1, 1, 0),
+SOC_DAPM_SINGLE("AIN3 Switch", WM8776_ADCMUX, 2, 1, 0),
+SOC_DAPM_SINGLE("AIN4 Switch", WM8776_ADCMUX, 3, 1, 0),
+SOC_DAPM_SINGLE("AIN5 Switch", WM8776_ADCMUX, 4, 1, 0),
+};
+
+static const struct snd_kcontrol_new outmix_controls[] = {
+SOC_DAPM_SINGLE("DAC Switch", WM8776_OUTMUX, 0, 1, 0),
+SOC_DAPM_SINGLE("AUX Switch", WM8776_OUTMUX, 1, 1, 0),
+SOC_DAPM_SINGLE("Bypass Switch", WM8776_OUTMUX, 2, 1, 0),
+};
+
+static const struct snd_soc_dapm_widget wm8776_dapm_widgets[] = {
+SND_SOC_DAPM_INPUT("AUX"),
+SND_SOC_DAPM_INPUT("AUX"),
+
+SND_SOC_DAPM_INPUT("AIN1"),
+SND_SOC_DAPM_INPUT("AIN2"),
+SND_SOC_DAPM_INPUT("AIN3"),
+SND_SOC_DAPM_INPUT("AIN4"),
+SND_SOC_DAPM_INPUT("AIN5"),
+
+SND_SOC_DAPM_MIXER("Input Mixer", WM8776_PWRDOWN, 6, 1,
+                   inmix_controls, ARRAY_SIZE(inmix_controls)),
+
+SND_SOC_DAPM_ADC("ADC", "Capture", WM8776_PWRDOWN, 1, 1),
+SND_SOC_DAPM_DAC("DAC", "Playback", WM8776_PWRDOWN, 2, 1),
+
+SND_SOC_DAPM_MIXER("Output Mixer", SND_SOC_NOPM, 0, 0,
+                   outmix_controls, ARRAY_SIZE(outmix_controls)),
+
+SND_SOC_DAPM_PGA("Headphone PGA", WM8776_PWRDOWN, 3, 1, NULL, 0),
+
+SND_SOC_DAPM_OUTPUT("VOUT"),
+
+SND_SOC_DAPM_OUTPUT("HPOUTL"),
+SND_SOC_DAPM_OUTPUT("HPOUTR"),
+};
+
+static const struct snd_soc_dapm_route routes[] = {
+        { "Input Mixer", "AIN1 Switch", "AIN1" },
+        { "Input Mixer", "AIN2 Switch", "AIN2" },
+        { "Input Mixer", "AIN3 Switch", "AIN3" },
+        { "Input Mixer", "AIN4 Switch", "AIN4" },
+        { "Input Mixer", "AIN5 Switch", "AIN5" },
+
+        { "ADC", NULL, "Input Mixer" },
+
+        { "Output Mixer", "DAC Switch", "DAC" },
+        { "Output Mixer", "AUX Switch", "AUX" },
+        { "Output Mixer", "Bypass Switch", "Input Mixer" },
+
+        { "VOUT", NULL, "Output Mixer" },
+
+        { "Headphone PGA", NULL, "Output Mixer" },
+
+        { "HPOUTL", NULL, "Headphone PGA" },
+        { "HPOUTR", NULL, "Headphone PGA" },
+};
+
+static int wm8776_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        int reg, iface, master;
+
+        switch (dai->id) {
+        case WM8776_DAI_DAC:
+                reg = WM8776_DACIFCTRL;
+                master = 0x80;
+                break;
+        case WM8776_DAI_ADC:
+                reg = WM8776_ADCIFCTRL;
+                master = 0x100;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        iface = 0;
+
+        switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
+        case SND_SOC_DAIFMT_CBM_CFM:
+                break;
+        case SND_SOC_DAIFMT_CBS_CFS:
+                master = 0;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        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;
+                /* FIXME: CHECK A/B */
+        case SND_SOC_DAIFMT_DSP_A:
+                iface |= 0x0003;
+                break;
+        case SND_SOC_DAIFMT_DSP_B:
+                iface |= 0x0007;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
+        case SND_SOC_DAIFMT_NB_NF:
+                break;
+        case SND_SOC_DAIFMT_IB_IF:
+                iface |= 0x00c;
+                break;
+        case SND_SOC_DAIFMT_IB_NF:
+                iface |= 0x008;
+                break;
+        case SND_SOC_DAIFMT_NB_IF:
+                iface |= 0x004;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        /* Finally, write out the values */
+        snd_soc_update_bits(codec, reg, 0xf, iface);
+        snd_soc_update_bits(codec, WM8776_MSTRCTRL, 0x180, master);
+
+        return 0;
+}
+
+static int mclk_ratios[] = {
+        128,
+        192,
+        256,
+        384,
+        512,
+        768,
+};
+
+static int wm8776_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 wm8776_priv *wm8776 = codec->private_data;
+        int iface_reg, iface;
+        int ratio_shift, master;
+        int i;
+
+        iface = 0;
+
+        switch (dai->id) {
+        case WM8776_DAI_DAC:
+                iface_reg = WM8776_DACIFCTRL;
+                master = 0x80;
+                ratio_shift = 4;
+                break;
+        case WM8776_DAI_ADC:
+                iface_reg = WM8776_ADCIFCTRL;
+                master = 0x100;
+                ratio_shift = 0;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+
+        /* Set word length */
+        switch (params_format(params)) {
+        case SNDRV_PCM_FORMAT_S16_LE:
+                break;
+        case SNDRV_PCM_FORMAT_S20_3LE:
+                iface |= 0x10;
+                break;
+        case SNDRV_PCM_FORMAT_S24_LE:
+                iface |= 0x20;
+                break;
+        case SNDRV_PCM_FORMAT_S32_LE:
+                iface |= 0x30;
+                break;
+        }
+
+        /* Only need to set MCLK/LRCLK ratio if we're master */
+        if (snd_soc_read(codec, WM8776_MSTRCTRL) & master) {
+                for (i = 0; i < ARRAY_SIZE(mclk_ratios); i++) {
+                        if (wm8776->sysclk[dai->id] / params_rate(params)
+                            == mclk_ratios[i])
+                                break;
+                }
+
+                if (i == ARRAY_SIZE(mclk_ratios)) {
+                        dev_err(codec->dev,
+                                "Unable to configure MCLK ratio %d/%d\n",
+                                wm8776->sysclk[dai->id], params_rate(params));
+                        return -EINVAL;
+                }
+
+                dev_dbg(codec->dev, "MCLK is %dfs\n", mclk_ratios[i]);
+
+                snd_soc_update_bits(codec, WM8776_MSTRCTRL,
+                                    0x7 << ratio_shift, i << ratio_shift);
+        } else {
+                dev_dbg(codec->dev, "DAI in slave mode\n");
+        }
+
+        snd_soc_update_bits(codec, iface_reg, 0x30, iface);
+
+        return 0;
+}
+
+static int wm8776_mute(struct snd_soc_dai *dai, int mute)
+{
+        struct snd_soc_codec *codec = dai->codec;
+
+        return snd_soc_write(codec, WM8776_DACMUTE, !!mute);
+}
+
+static int wm8776_set_sysclk(struct snd_soc_dai *dai,
+                             int clk_id, unsigned int freq, int dir)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        struct wm8776_priv *wm8776 = codec->private_data;
+
+        BUG_ON(dai->id >= ARRAY_SIZE(wm8776->sysclk));
+
+        wm8776->sysclk[dai->id] = freq;
+
+        return 0;
+}
+
+static int wm8776_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:
+                break;
+        case SND_SOC_BIAS_STANDBY:
+                if (codec->bias_level == SND_SOC_BIAS_OFF) {
+                        /* Disable the global powerdown; DAPM does the rest */
+                        snd_soc_update_bits(codec, WM8776_PWRDOWN, 1, 0);
+                }
+
+                break;
+        case SND_SOC_BIAS_OFF:
+                snd_soc_update_bits(codec, WM8776_PWRDOWN, 1, 1);
+                break;
+        }
+
+        codec->bias_level = level;
+        return 0;
+}
+
+#define WM8776_RATES (SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 |\
+                      SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_88200 |\
+                      SNDRV_PCM_RATE_96000)
+
+
+#define WM8776_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 wm8776_dac_ops = {
+        .digital_mute   = wm8776_mute,
+        .hw_params      = wm8776_hw_params,
+        .set_fmt        = wm8776_set_fmt,
+        .set_sysclk     = wm8776_set_sysclk,
+};
+
+static struct snd_soc_dai_ops wm8776_adc_ops = {
+        .hw_params      = wm8776_hw_params,
+        .set_fmt        = wm8776_set_fmt,
+        .set_sysclk     = wm8776_set_sysclk,
+};
+
+struct snd_soc_dai wm8776_dai[] = {
+        {
+                .name = "WM8776 Playback",
+                .id = WM8776_DAI_DAC,
+                .playback = {
+                        .stream_name = "Playback",
+                        .channels_min = 2,
+                        .channels_max = 2,
+                        .rates = WM8776_RATES,
+                        .formats = WM8776_FORMATS,
+                },
+                .ops = &wm8776_dac_ops,
+        },
+        {
+                .name = "WM8776 Capture",
+                .id = WM8776_DAI_ADC,
+                .capture = {
+                        .stream_name = "Capture",
+                        .channels_min = 2,
+                        .channels_max = 2,
+                        .rates = WM8776_RATES,
+                        .formats = WM8776_FORMATS,
+                },
+                .ops = &wm8776_adc_ops,
+        },
+};
+EXPORT_SYMBOL_GPL(wm8776_dai);
+
+#ifdef CONFIG_PM
+static int wm8776_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;
+
+        wm8776_set_bias_level(codec, SND_SOC_BIAS_OFF);
+
+        return 0;
+}
+
+static int wm8776_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(wm8776_reg); i++) {
+                data[0] = (i << 1) | ((cache[i] >> 8) & 0x0001);
+                data[1] = cache[i] & 0x00ff;
+                codec->hw_write(codec->control_data, data, 2);
+        }
+
+        wm8776_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+
+        return 0;
+}
+#else
+#define wm8776_suspend NULL
+#define wm8776_resume NULL
+#endif
+
+static int wm8776_probe(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec;
+        int ret = 0;
+
+        if (wm8776_codec == NULL) {
+                dev_err(&pdev->dev, "Codec device not registered\n");
+                return -ENODEV;
+        }
+
+        socdev->card->codec = wm8776_codec;
+        codec = wm8776_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, wm8776_snd_controls,
+                             ARRAY_SIZE(wm8776_snd_controls));
+        snd_soc_dapm_new_controls(codec, wm8776_dapm_widgets,
+                                  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;
+}
+
+/* power down chip */
+static int wm8776_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_wm8776 = {
+        .probe =        wm8776_probe,
+        .remove =       wm8776_remove,
+        .suspend =      wm8776_suspend,
+        .resume =       wm8776_resume,
+};
+EXPORT_SYMBOL_GPL(soc_codec_dev_wm8776);
+
+static int wm8776_register(struct wm8776_priv *wm8776,
+                           enum snd_soc_control_type control)
+{
+        int ret, i;
+        struct snd_soc_codec *codec = &wm8776->codec;
+
+        if (wm8776_codec) {
+                dev_err(codec->dev, "Another WM8776 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 = wm8776;
+        codec->name = "WM8776";
+        codec->owner = THIS_MODULE;
+        codec->bias_level = SND_SOC_BIAS_OFF;
+        codec->set_bias_level = wm8776_set_bias_level;
+        codec->dai = wm8776_dai;
+        codec->num_dai = ARRAY_SIZE(wm8776_dai);
+        codec->reg_cache_size = WM8776_CACHEREGNUM;
+        codec->reg_cache = &wm8776->reg_cache;
+
+        memcpy(codec->reg_cache, wm8776_reg, sizeof(wm8776_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(wm8776_dai); i++)
+                wm8776_dai[i].dev = codec->dev;
+
+        ret = wm8776_reset(codec);
+        if (ret < 0) {
+                dev_err(codec->dev, "Failed to issue reset: %d\n", ret);
+                goto err;
+        }
+
+        wm8776_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+
+        /* Latch the update bits; right channel only since we always
+         * update both. */
+        snd_soc_update_bits(codec, WM8776_HPRVOL, 0x100, 0x100);
+        snd_soc_update_bits(codec, WM8776_DACRVOL, 0x100, 0x100);
+
+        wm8776_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_dais(wm8776_dai, ARRAY_SIZE(wm8776_dai));
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to register DAIs: %d\n", ret);
+                goto err_codec;
+        }
+
+        return 0;
+
+err_codec:
+        snd_soc_unregister_codec(codec);
+err:
+        kfree(wm8776);
+        return ret;
+}
+
+static void wm8776_unregister(struct wm8776_priv *wm8776)
+{
+        wm8776_set_bias_level(&wm8776->codec, SND_SOC_BIAS_OFF);
+        snd_soc_unregister_dais(wm8776_dai, ARRAY_SIZE(wm8776_dai));
+        snd_soc_unregister_codec(&wm8776->codec);
+        kfree(wm8776);
+        wm8776_codec = NULL;
+}
+
+#if defined(CONFIG_SPI_MASTER)
+static int wm8776_spi_write(struct spi_device *spi, const char *data, int len)
+{
+        struct spi_transfer t;
+        struct spi_message m;
+        u8 msg[2];
+
+        if (len <= 0)
+                return 0;
+
+        msg[0] = data[0];
+        msg[1] = data[1];
+
+        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;
+}
+
+static int __devinit wm8776_spi_probe(struct spi_device *spi)
+{
+        struct snd_soc_codec *codec;
+        struct wm8776_priv *wm8776;
+
+        wm8776 = kzalloc(sizeof(struct wm8776_priv), GFP_KERNEL);
+        if (wm8776 == NULL)
+                return -ENOMEM;
+
+        codec = &wm8776->codec;
+        codec->control_data = spi;
+        codec->hw_write = (hw_write_t)wm8776_spi_write;
+        codec->dev = &spi->dev;
+
+        dev_set_drvdata(&spi->dev, wm8776);
+
+        return wm8776_register(wm8776, SND_SOC_SPI);
+}
+
+static int __devexit wm8776_spi_remove(struct spi_device *spi)
+{
+        struct wm8776_priv *wm8776 = dev_get_drvdata(&spi->dev);
+
+        wm8776_unregister(wm8776);
+
+        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",
+                .bus    = &spi_bus_type,
+                .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 */
+
+#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+static __devinit int wm8776_i2c_probe(struct i2c_client *i2c,
+                                      const struct i2c_device_id *id)
+{
+        struct wm8776_priv *wm8776;
+        struct snd_soc_codec *codec;
+
+        wm8776 = kzalloc(sizeof(struct wm8776_priv), GFP_KERNEL);
+        if (wm8776 == NULL)
+                return -ENOMEM;
+
+        codec = &wm8776->codec;
+        codec->hw_write = (hw_write_t)i2c_master_send;
+
+        i2c_set_clientdata(i2c, wm8776);
+        codec->control_data = i2c;
+
+        codec->dev = &i2c->dev;
+
+        return wm8776_register(wm8776, SND_SOC_I2C);
+}
+
+static __devexit int wm8776_i2c_remove(struct i2c_client *client)
+{
+        struct wm8776_priv *wm8776 = i2c_get_clientdata(client);
+        wm8776_unregister(wm8776);
+        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 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, wm8776_i2c_id);
+
+static struct i2c_driver wm8776_i2c_driver = {
+        .driver = {
+                .name = "wm8776",
+                .owner = THIS_MODULE,
+        },
+        .probe =    wm8776_i2c_probe,
+        .remove =   __devexit_p(wm8776_i2c_remove),
+        .suspend =  wm8776_i2c_suspend,
+        .resume =   wm8776_i2c_resume,
+        .id_table = wm8776_i2c_id,
+};
+#endif
+
+static int __init wm8776_modinit(void)
+{
+        int ret;
+#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+        ret = i2c_add_driver(&wm8776_i2c_driver);
+        if (ret != 0) {
+                printk(KERN_ERR "Failed to register WM8776 I2C driver: %d\n",
+                       ret);
+        }
+#endif
+#if defined(CONFIG_SPI_MASTER)
+        ret = spi_register_driver(&wm8776_spi_driver);
+        if (ret != 0) {
+                printk(KERN_ERR "Failed to register WM8776 SPI driver: %d\n",
+                       ret);
+        }
+#endif
+        return 0;
+}
+module_init(wm8776_modinit);
+
+static void __exit wm8776_exit(void)
+{
+#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+        i2c_del_driver(&wm8776_i2c_driver);
+#endif
+#if defined(CONFIG_SPI_MASTER)
+        spi_unregister_driver(&wm8776_spi_driver);
+#endif
+}
+module_exit(wm8776_exit);
+
+MODULE_DESCRIPTION("ASoC WM8776 driver");
+MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/codecs/wm8776.h b/sound/soc/codecs/wm8776.h
new file mode 100644
index 000000000000..6606d25d2d83
--- /dev/null
+++ b/sound/soc/codecs/wm8776.h
@@ -0,0 +1,51 @@
+/*
+ * 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.
+ */
+
+#ifndef _WM8776_H
+#define _WM8776_H
+
+/* Registers */
+
+#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
+
+#define WM8776_CACHEREGNUM 0x17
+
+#define WM8776_DAI_DAC 0
+#define WM8776_DAI_ADC 1
+
+extern struct snd_soc_dai wm8776_dai[];
+extern struct snd_soc_codec_device soc_codec_dev_wm8776;
+
+#endif
diff --git a/sound/soc/codecs/wm8900.c b/sound/soc/codecs/wm8900.c
index 46c5ea1ff921..5e9c855c0036 100644
--- a/sound/soc/codecs/wm8900.c
+++ b/sound/soc/codecs/wm8900.c
@@ -116,6 +116,7 @@
 #define WM8900_REG_CLOCKING2_DAC_CLKDIV 0x1c
 
 #define WM8900_REG_DACCTRL_MUTE          0x004
+#define WM8900_REG_DACCTRL_DAC_SB_FILT   0x100
 #define WM8900_REG_DACCTRL_AIF_LRCLKRATE 0x400
 
 #define WM8900_REG_AUDIO3_ADCLRC_DIR    0x0800
@@ -182,111 +183,20 @@ static const u16 wm8900_reg_defaults[WM8900_MAXREG] = {
         /* Remaining registers all zero */
 };
 
-/*
- * read wm8900 register cache
- */
-static inline unsigned int wm8900_read_reg_cache(struct snd_soc_codec *codec,
-        unsigned int reg)
-{
-        u16 *cache = codec->reg_cache;
-
-        BUG_ON(reg >= WM8900_MAXREG);
-
-        if (reg == WM8900_REG_ID)
-                return 0;
-
-        return cache[reg];
-}
-
-/*
- * write wm8900 register cache
- */
-static inline void wm8900_write_reg_cache(struct snd_soc_codec *codec,
-        u16 reg, unsigned int value)
-{
-        u16 *cache = codec->reg_cache;
-
-        BUG_ON(reg >= WM8900_MAXREG);
-
-        cache[reg] = value;
-}
-
-/*
- * write to the WM8900 register space
- */
-static int wm8900_write(struct snd_soc_codec *codec, unsigned int reg,
-                        unsigned int value)
-{
-        u8 data[3];
-
-        if (value == wm8900_read_reg_cache(codec, reg))
-                return 0;
-
-        /* data is
-         *   D15..D9 WM8900 register offset
-         *   D8...D0 register data
-         */
-        data[0] = reg;
-        data[1] = value >> 8;
-        data[2] = value & 0x00ff;
-
-        wm8900_write_reg_cache(codec, reg, value);
-        if (codec->hw_write(codec->control_data, data, 3) == 3)
-                return 0;
-        else
-                return -EIO;
-}
-
-/*
- * Read from the wm8900.
- */
-static unsigned int wm8900_chip_read(struct snd_soc_codec *codec, u8 reg)
-{
-        struct i2c_msg xfer[2];
-        u16 data;
-        int ret;
-        struct i2c_client *client = codec->control_data;
-
-        BUG_ON(reg != WM8900_REG_ID && reg != WM8900_REG_POWER1);
-
-        /* Write register */
-        xfer[0].addr = client->addr;
-        xfer[0].flags = 0;
-        xfer[0].len = 1;
-        xfer[0].buf = &reg;
-
-        /* Read data */
-        xfer[1].addr = client->addr;
-        xfer[1].flags = I2C_M_RD;
-        xfer[1].len = 2;
-        xfer[1].buf = (u8 *)&data;
-
-        ret = i2c_transfer(client->adapter, xfer, 2);
-        if (ret != 2) {
-                printk(KERN_CRIT "i2c_transfer returned %d\n", ret);
-                return 0;
-        }
-
-        return (data >> 8) | ((data & 0xff) << 8);
-}
-
-/*
- * Read from the WM8900 register space.  Most registers can't be read
- * and are therefore supplied from cache.
- */
-static unsigned int wm8900_read(struct snd_soc_codec *codec, unsigned int reg)
+static int wm8900_volatile_register(unsigned int reg)
 {
         switch (reg) {
         case WM8900_REG_ID:
-                return wm8900_chip_read(codec, reg);
+        case WM8900_REG_POWER1:
+                return 1;
         default:
-                return wm8900_read_reg_cache(codec, reg);
+                return 0;
         }
 }
 
 static void wm8900_reset(struct snd_soc_codec *codec)
 {
-        wm8900_write(codec, WM8900_REG_RESET, 0);
+        snd_soc_write(codec, WM8900_REG_RESET, 0);
 
         memcpy(codec->reg_cache, wm8900_reg_defaults,
                sizeof(codec->reg_cache));
@@ -296,14 +206,14 @@ static int wm8900_hp_event(struct snd_soc_dapm_widget *w,
                            struct snd_kcontrol *kcontrol, int event)
 {
         struct snd_soc_codec *codec = w->codec;
-        u16 hpctl1 = wm8900_read(codec, WM8900_REG_HPCTL1);
+        u16 hpctl1 = snd_soc_read(codec, WM8900_REG_HPCTL1);
 
         switch (event) {
         case SND_SOC_DAPM_PRE_PMU:
                 /* Clamp headphone outputs */
                 hpctl1 = WM8900_REG_HPCTL1_HP_CLAMP_IP |
                         WM8900_REG_HPCTL1_HP_CLAMP_OP;
-                wm8900_write(codec, WM8900_REG_HPCTL1, hpctl1);
+                snd_soc_write(codec, WM8900_REG_HPCTL1, hpctl1);
                 break;
 
         case SND_SOC_DAPM_POST_PMU:
@@ -312,41 +222,41 @@ static int wm8900_hp_event(struct snd_soc_dapm_widget *w,
                 hpctl1 |= WM8900_REG_HPCTL1_HP_SHORT |
                         WM8900_REG_HPCTL1_HP_SHORT2 |
                         WM8900_REG_HPCTL1_HP_IPSTAGE_ENA;
-                wm8900_write(codec, WM8900_REG_HPCTL1, hpctl1);
+                snd_soc_write(codec, WM8900_REG_HPCTL1, hpctl1);
 
                 msleep(400);
 
                 /* Enable the output stage */
                 hpctl1 &= ~WM8900_REG_HPCTL1_HP_CLAMP_OP;
                 hpctl1 |= WM8900_REG_HPCTL1_HP_OPSTAGE_ENA;
-                wm8900_write(codec, WM8900_REG_HPCTL1, hpctl1);
+                snd_soc_write(codec, WM8900_REG_HPCTL1, hpctl1);
 
                 /* Remove the shorts */
                 hpctl1 &= ~WM8900_REG_HPCTL1_HP_SHORT2;
-                wm8900_write(codec, WM8900_REG_HPCTL1, hpctl1);
+                snd_soc_write(codec, WM8900_REG_HPCTL1, hpctl1);
                 hpctl1 &= ~WM8900_REG_HPCTL1_HP_SHORT;
-                wm8900_write(codec, WM8900_REG_HPCTL1, hpctl1);
+                snd_soc_write(codec, WM8900_REG_HPCTL1, hpctl1);
                 break;
 
         case SND_SOC_DAPM_PRE_PMD:
                 /* Short the output */
                 hpctl1 |= WM8900_REG_HPCTL1_HP_SHORT;
-                wm8900_write(codec, WM8900_REG_HPCTL1, hpctl1);
+                snd_soc_write(codec, WM8900_REG_HPCTL1, hpctl1);
 
                 /* Disable the output stage */
                 hpctl1 &= ~WM8900_REG_HPCTL1_HP_OPSTAGE_ENA;
-                wm8900_write(codec, WM8900_REG_HPCTL1, hpctl1);
+                snd_soc_write(codec, WM8900_REG_HPCTL1, hpctl1);
 
                 /* Clamp the outputs and power down input */
                 hpctl1 |= WM8900_REG_HPCTL1_HP_CLAMP_IP |
                         WM8900_REG_HPCTL1_HP_CLAMP_OP;
                 hpctl1 &= ~WM8900_REG_HPCTL1_HP_IPSTAGE_ENA;
-                wm8900_write(codec, WM8900_REG_HPCTL1, hpctl1);
+                snd_soc_write(codec, WM8900_REG_HPCTL1, hpctl1);
                 break;
 
         case SND_SOC_DAPM_POST_PMD:
                 /* Disable everything */
-                wm8900_write(codec, WM8900_REG_HPCTL1, 0);
+                snd_soc_write(codec, WM8900_REG_HPCTL1, 0);
                 break;
 
         default:
@@ -439,7 +349,6 @@ SOC_SINGLE("DAC Soft Mute Switch", WM8900_REG_DACCTRL, 6, 1, 1),
 SOC_ENUM("DAC Mute Rate", dac_mute_rate),
 SOC_SINGLE("DAC Mono Switch", WM8900_REG_DACCTRL, 9, 1, 0),
 SOC_ENUM("DAC Deemphasis", dac_deemphasis),
-SOC_SINGLE("DAC Sloping Stopband Filter Switch", WM8900_REG_DACCTRL, 8, 1, 0),
 SOC_SINGLE("DAC Sigma-Delta Modulator Clock Switch", WM8900_REG_DACCTRL,
            12, 1, 0),
 
@@ -723,7 +632,7 @@ static int wm8900_hw_params(struct snd_pcm_substream *substream,
         struct snd_soc_codec *codec = socdev->card->codec;
         u16 reg;
 
-        reg = wm8900_read(codec, WM8900_REG_AUDIO1) & ~0x60;
+        reg = snd_soc_read(codec, WM8900_REG_AUDIO1) & ~0x60;
 
         switch (params_format(params)) {
         case SNDRV_PCM_FORMAT_S16_LE:
@@ -741,7 +650,18 @@ static int wm8900_hw_params(struct snd_pcm_substream *substream,
                 return -EINVAL;
         }
 
-        wm8900_write(codec, WM8900_REG_AUDIO1, reg);
+        snd_soc_write(codec, WM8900_REG_AUDIO1, reg);
+
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+                reg = snd_soc_read(codec, WM8900_REG_DACCTRL);
+
+                if (params_rate(params) <= 24000)
+                        reg |= WM8900_REG_DACCTRL_DAC_SB_FILT;
+                else
+                        reg &= ~WM8900_REG_DACCTRL_DAC_SB_FILT;
+
+                snd_soc_write(codec, WM8900_REG_DACCTRL, reg);
+        }
 
         return 0;
 }
@@ -778,11 +698,11 @@ static int fll_factors(struct _fll_div *fll_div, unsigned int Fref,
         }
 
         if (target > 100000000)
-                printk(KERN_WARNING "wm8900: FLL rate %d out of range, Fref=%d"
-                       " Fout=%d\n", target, Fref, Fout);
+                printk(KERN_WARNING "wm8900: FLL rate %u out of range, Fref=%u"
+                       " Fout=%u\n", target, Fref, Fout);
         if (div > 32) {
                 printk(KERN_ERR "wm8900: Invalid FLL division rate %u, "
-                       "Fref=%d, Fout=%d, target=%d\n",
+                       "Fref=%u, Fout=%u, target=%u\n",
                        div, Fref, Fout, target);
                 return -EINVAL;
         }
@@ -834,18 +754,18 @@ static int wm8900_set_fll(struct snd_soc_codec *codec,
                 return 0;
 
         /* The digital side should be disabled during any change. */
-        reg = wm8900_read(codec, WM8900_REG_POWER1);
-        wm8900_write(codec, WM8900_REG_POWER1,
+        reg = snd_soc_read(codec, WM8900_REG_POWER1);
+        snd_soc_write(codec, WM8900_REG_POWER1,
                      reg & (~WM8900_REG_POWER1_FLL_ENA));
 
         /* Disable the FLL? */
         if (!freq_in || !freq_out) {
-                reg = wm8900_read(codec, WM8900_REG_CLOCKING1);
-                wm8900_write(codec, WM8900_REG_CLOCKING1,
+                reg = snd_soc_read(codec, WM8900_REG_CLOCKING1);
+                snd_soc_write(codec, WM8900_REG_CLOCKING1,
                              reg & (~WM8900_REG_CLOCKING1_MCLK_SRC));
 
-                reg = wm8900_read(codec, WM8900_REG_FLLCTL1);
-                wm8900_write(codec, WM8900_REG_FLLCTL1,
+                reg = snd_soc_read(codec, WM8900_REG_FLLCTL1);
+                snd_soc_write(codec, WM8900_REG_FLLCTL1,
                              reg & (~WM8900_REG_FLLCTL1_OSC_ENA));
 
                 wm8900->fll_in = freq_in;
@@ -862,33 +782,33 @@ static int wm8900_set_fll(struct snd_soc_codec *codec,
 
         /* The osclilator *MUST* be enabled before we enable the
          * digital circuit. */
-        wm8900_write(codec, WM8900_REG_FLLCTL1,
+        snd_soc_write(codec, WM8900_REG_FLLCTL1,
                      fll_div.fll_ratio | WM8900_REG_FLLCTL1_OSC_ENA);
 
-        wm8900_write(codec, WM8900_REG_FLLCTL4, fll_div.n >> 5);
-        wm8900_write(codec, WM8900_REG_FLLCTL5,
+        snd_soc_write(codec, WM8900_REG_FLLCTL4, fll_div.n >> 5);
+        snd_soc_write(codec, WM8900_REG_FLLCTL5,
                      (fll_div.fllclk_div << 6) | (fll_div.n & 0x1f));
 
         if (fll_div.k) {
-                wm8900_write(codec, WM8900_REG_FLLCTL2,
+                snd_soc_write(codec, WM8900_REG_FLLCTL2,
                              (fll_div.k >> 8) | 0x100);
-                wm8900_write(codec, WM8900_REG_FLLCTL3, fll_div.k & 0xff);
+                snd_soc_write(codec, WM8900_REG_FLLCTL3, fll_div.k & 0xff);
         } else
-                wm8900_write(codec, WM8900_REG_FLLCTL2, 0);
+                snd_soc_write(codec, WM8900_REG_FLLCTL2, 0);
 
         if (fll_div.fll_slow_lock_ref)
-                wm8900_write(codec, WM8900_REG_FLLCTL6,
+                snd_soc_write(codec, WM8900_REG_FLLCTL6,
                              WM8900_REG_FLLCTL6_FLL_SLOW_LOCK_REF);
         else
-                wm8900_write(codec, WM8900_REG_FLLCTL6, 0);
+                snd_soc_write(codec, WM8900_REG_FLLCTL6, 0);
 
-        reg = wm8900_read(codec, WM8900_REG_POWER1);
-        wm8900_write(codec, WM8900_REG_POWER1,
+        reg = snd_soc_read(codec, WM8900_REG_POWER1);
+        snd_soc_write(codec, WM8900_REG_POWER1,
                      reg | WM8900_REG_POWER1_FLL_ENA);
 
 reenable:
-        reg = wm8900_read(codec, WM8900_REG_CLOCKING1);
-        wm8900_write(codec, WM8900_REG_CLOCKING1,
+        reg = snd_soc_read(codec, WM8900_REG_CLOCKING1);
+        snd_soc_write(codec, WM8900_REG_CLOCKING1,
                      reg | WM8900_REG_CLOCKING1_MCLK_SRC);
 
         return 0;
@@ -908,38 +828,38 @@ static int wm8900_set_dai_clkdiv(struct snd_soc_dai *codec_dai,
 
         switch (div_id) {
         case WM8900_BCLK_DIV:
-                reg = wm8900_read(codec, WM8900_REG_CLOCKING1);
-                wm8900_write(codec, WM8900_REG_CLOCKING1,
+                reg = snd_soc_read(codec, WM8900_REG_CLOCKING1);
+                snd_soc_write(codec, WM8900_REG_CLOCKING1,
                              div | (reg & WM8900_REG_CLOCKING1_BCLK_MASK));
                 break;
         case WM8900_OPCLK_DIV:
-                reg = wm8900_read(codec, WM8900_REG_CLOCKING1);
-                wm8900_write(codec, WM8900_REG_CLOCKING1,
+                reg = snd_soc_read(codec, WM8900_REG_CLOCKING1);
+                snd_soc_write(codec, WM8900_REG_CLOCKING1,
                              div | (reg & WM8900_REG_CLOCKING1_OPCLK_MASK));
                 break;
         case WM8900_DAC_LRCLK:
-                reg = wm8900_read(codec, WM8900_REG_AUDIO4);
-                wm8900_write(codec, WM8900_REG_AUDIO4,
+                reg = snd_soc_read(codec, WM8900_REG_AUDIO4);
+                snd_soc_write(codec, WM8900_REG_AUDIO4,
                              div | (reg & WM8900_LRC_MASK));
                 break;
         case WM8900_ADC_LRCLK:
-                reg = wm8900_read(codec, WM8900_REG_AUDIO3);
-                wm8900_write(codec, WM8900_REG_AUDIO3,
+                reg = snd_soc_read(codec, WM8900_REG_AUDIO3);
+                snd_soc_write(codec, WM8900_REG_AUDIO3,
                              div | (reg & WM8900_LRC_MASK));
                 break;
         case WM8900_DAC_CLKDIV:
-                reg = wm8900_read(codec, WM8900_REG_CLOCKING2);
-                wm8900_write(codec, WM8900_REG_CLOCKING2,
+                reg = snd_soc_read(codec, WM8900_REG_CLOCKING2);
+                snd_soc_write(codec, WM8900_REG_CLOCKING2,
                              div | (reg & WM8900_REG_CLOCKING2_DAC_CLKDIV));
                 break;
         case WM8900_ADC_CLKDIV:
-                reg = wm8900_read(codec, WM8900_REG_CLOCKING2);
-                wm8900_write(codec, WM8900_REG_CLOCKING2,
+                reg = snd_soc_read(codec, WM8900_REG_CLOCKING2);
+                snd_soc_write(codec, WM8900_REG_CLOCKING2,
                              div | (reg & WM8900_REG_CLOCKING2_ADC_CLKDIV));
                 break;
         case WM8900_LRCLK_MODE:
-                reg = wm8900_read(codec, WM8900_REG_DACCTRL);
-                wm8900_write(codec, WM8900_REG_DACCTRL,
+                reg = snd_soc_read(codec, WM8900_REG_DACCTRL);
+                snd_soc_write(codec, WM8900_REG_DACCTRL,
                              div | (reg & WM8900_REG_DACCTRL_AIF_LRCLKRATE));
                 break;
         default:
@@ -956,10 +876,10 @@ static int wm8900_set_dai_fmt(struct snd_soc_dai *codec_dai,
         struct snd_soc_codec *codec = codec_dai->codec;
         unsigned int clocking1, aif1, aif3, aif4;
 
-        clocking1 = wm8900_read(codec, WM8900_REG_CLOCKING1);
-        aif1 = wm8900_read(codec, WM8900_REG_AUDIO1);
-        aif3 = wm8900_read(codec, WM8900_REG_AUDIO3);
-        aif4 = wm8900_read(codec, WM8900_REG_AUDIO4);
+        clocking1 = snd_soc_read(codec, WM8900_REG_CLOCKING1);
+        aif1 = snd_soc_read(codec, WM8900_REG_AUDIO1);
+        aif3 = snd_soc_read(codec, WM8900_REG_AUDIO3);
+        aif4 = snd_soc_read(codec, WM8900_REG_AUDIO4);
 
         /* set master/slave audio interface */
         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
@@ -1055,10 +975,10 @@ static int wm8900_set_dai_fmt(struct snd_soc_dai *codec_dai,
                 return -EINVAL;
         }
 
-        wm8900_write(codec, WM8900_REG_CLOCKING1, clocking1);
-        wm8900_write(codec, WM8900_REG_AUDIO1, aif1);
-        wm8900_write(codec, WM8900_REG_AUDIO3, aif3);
-        wm8900_write(codec, WM8900_REG_AUDIO4, aif4);
+        snd_soc_write(codec, WM8900_REG_CLOCKING1, clocking1);
+        snd_soc_write(codec, WM8900_REG_AUDIO1, aif1);
+        snd_soc_write(codec, WM8900_REG_AUDIO3, aif3);
+        snd_soc_write(codec, WM8900_REG_AUDIO4, aif4);
 
         return 0;
 }
@@ -1068,14 +988,14 @@ static int wm8900_digital_mute(struct snd_soc_dai *codec_dai, int mute)
         struct snd_soc_codec *codec = codec_dai->codec;
         u16 reg;
 
-        reg = wm8900_read(codec, WM8900_REG_DACCTRL);
+        reg = snd_soc_read(codec, WM8900_REG_DACCTRL);
 
         if (mute)
                 reg |= WM8900_REG_DACCTRL_MUTE;
         else
                 reg &= ~WM8900_REG_DACCTRL_MUTE;
 
-        wm8900_write(codec, WM8900_REG_DACCTRL, reg);
+        snd_soc_write(codec, WM8900_REG_DACCTRL, reg);
 
         return 0;
 }
@@ -1124,11 +1044,11 @@ static int wm8900_set_bias_level(struct snd_soc_codec *codec,
         switch (level) {
         case SND_SOC_BIAS_ON:
                 /* Enable thermal shutdown */
-                reg = wm8900_read(codec, WM8900_REG_GPIO);
-                wm8900_write(codec, WM8900_REG_GPIO,
+                reg = snd_soc_read(codec, WM8900_REG_GPIO);
+                snd_soc_write(codec, WM8900_REG_GPIO,
                              reg | WM8900_REG_GPIO_TEMP_ENA);
-                reg = wm8900_read(codec, WM8900_REG_ADDCTL);
-                wm8900_write(codec, WM8900_REG_ADDCTL,
+                reg = snd_soc_read(codec, WM8900_REG_ADDCTL);
+                snd_soc_write(codec, WM8900_REG_ADDCTL,
                              reg | WM8900_REG_ADDCTL_TEMP_SD);
                 break;
 
@@ -1139,69 +1059,69 @@ static int wm8900_set_bias_level(struct snd_soc_codec *codec,
                 /* Charge capacitors if initial power up */
                 if (codec->bias_level == SND_SOC_BIAS_OFF) {
                         /* STARTUP_BIAS_ENA on */
-                        wm8900_write(codec, WM8900_REG_POWER1,
+                        snd_soc_write(codec, WM8900_REG_POWER1,
                                      WM8900_REG_POWER1_STARTUP_BIAS_ENA);
 
                         /* Startup bias mode */
-                        wm8900_write(codec, WM8900_REG_ADDCTL,
+                        snd_soc_write(codec, WM8900_REG_ADDCTL,
                                      WM8900_REG_ADDCTL_BIAS_SRC |
                                      WM8900_REG_ADDCTL_VMID_SOFTST);
 
                         /* VMID 2x50k */
-                        wm8900_write(codec, WM8900_REG_POWER1,
+                        snd_soc_write(codec, WM8900_REG_POWER1,
                                      WM8900_REG_POWER1_STARTUP_BIAS_ENA | 0x1);
 
                         /* Allow capacitors to charge */
                         schedule_timeout_interruptible(msecs_to_jiffies(400));
 
                         /* Enable bias */
-                        wm8900_write(codec, WM8900_REG_POWER1,
+                        snd_soc_write(codec, WM8900_REG_POWER1,
                                      WM8900_REG_POWER1_STARTUP_BIAS_ENA |
                                      WM8900_REG_POWER1_BIAS_ENA | 0x1);
 
-                        wm8900_write(codec, WM8900_REG_ADDCTL, 0);
+                        snd_soc_write(codec, WM8900_REG_ADDCTL, 0);
 
-                        wm8900_write(codec, WM8900_REG_POWER1,
+                        snd_soc_write(codec, WM8900_REG_POWER1,
                                      WM8900_REG_POWER1_BIAS_ENA | 0x1);
                 }
 
-                reg = wm8900_read(codec, WM8900_REG_POWER1);
-                wm8900_write(codec, WM8900_REG_POWER1,
+                reg = snd_soc_read(codec, WM8900_REG_POWER1);
+                snd_soc_write(codec, WM8900_REG_POWER1,
                              (reg & WM8900_REG_POWER1_FLL_ENA) |
                              WM8900_REG_POWER1_BIAS_ENA | 0x1);
-                wm8900_write(codec, WM8900_REG_POWER2,
+                snd_soc_write(codec, WM8900_REG_POWER2,
                              WM8900_REG_POWER2_SYSCLK_ENA);
-                wm8900_write(codec, WM8900_REG_POWER3, 0);
+                snd_soc_write(codec, WM8900_REG_POWER3, 0);
                 break;
 
         case SND_SOC_BIAS_OFF:
                 /* Startup bias enable */
-                reg = wm8900_read(codec, WM8900_REG_POWER1);
-                wm8900_write(codec, WM8900_REG_POWER1,
+                reg = snd_soc_read(codec, WM8900_REG_POWER1);
+                snd_soc_write(codec, WM8900_REG_POWER1,
                              reg & WM8900_REG_POWER1_STARTUP_BIAS_ENA);
-                wm8900_write(codec, WM8900_REG_ADDCTL,
+                snd_soc_write(codec, WM8900_REG_ADDCTL,
                              WM8900_REG_ADDCTL_BIAS_SRC |
                              WM8900_REG_ADDCTL_VMID_SOFTST);
 
                 /* Discharge caps */
-                wm8900_write(codec, WM8900_REG_POWER1,
+                snd_soc_write(codec, WM8900_REG_POWER1,
                              WM8900_REG_POWER1_STARTUP_BIAS_ENA);
                 schedule_timeout_interruptible(msecs_to_jiffies(500));
 
                 /* Remove clamp */
-                wm8900_write(codec, WM8900_REG_HPCTL1, 0);
+                snd_soc_write(codec, WM8900_REG_HPCTL1, 0);
 
                 /* Power down */
-                wm8900_write(codec, WM8900_REG_ADDCTL, 0);
-                wm8900_write(codec, WM8900_REG_POWER1, 0);
-                wm8900_write(codec, WM8900_REG_POWER2, 0);
-                wm8900_write(codec, WM8900_REG_POWER3, 0);
+                snd_soc_write(codec, WM8900_REG_ADDCTL, 0);
+                snd_soc_write(codec, WM8900_REG_POWER1, 0);
+                snd_soc_write(codec, WM8900_REG_POWER2, 0);
+                snd_soc_write(codec, WM8900_REG_POWER3, 0);
 
                 /* Need to let things settle before stopping the clock
                  * to ensure that restart works, see "Stopping the
                  * master clock" in the datasheet. */
                 schedule_timeout_interruptible(msecs_to_jiffies(1));
-                wm8900_write(codec, WM8900_REG_POWER2,
+                snd_soc_write(codec, WM8900_REG_POWER2,
                              WM8900_REG_POWER2_SYSCLK_ENA);
                 break;
         }
@@ -1264,7 +1184,7 @@ static int wm8900_resume(struct platform_device *pdev)
 
         if (cache) {
                 for (i = 0; i < WM8900_MAXREG; i++)
-                        wm8900_write(codec, i, cache[i]);
+                        snd_soc_write(codec, i, cache[i]);
                 kfree(cache);
         } else
                 dev_err(&pdev->dev, "Unable to allocate register cache\n");
@@ -1297,16 +1217,20 @@ static __devinit int wm8900_i2c_probe(struct i2c_client *i2c,
 
         codec->name = "WM8900";
         codec->owner = THIS_MODULE;
-        codec->read = wm8900_read;
-        codec->write = wm8900_write;
         codec->dai = &wm8900_dai;
         codec->num_dai = 1;
-        codec->hw_write = (hw_write_t)i2c_master_send;
         codec->control_data = i2c;
         codec->set_bias_level = wm8900_set_bias_level;
+        codec->volatile_register = wm8900_volatile_register;
         codec->dev = &i2c->dev;
 
-        reg = wm8900_read(codec, WM8900_REG_ID);
+        ret = snd_soc_codec_set_cache_io(codec, 8, 16, SND_SOC_I2C);
+        if (ret != 0) {
+                dev_err(&i2c->dev, "Failed to set cache I/O: %d\n", ret);
+                goto err;
+        }
+
+        reg = snd_soc_read(codec, WM8900_REG_ID);
         if (reg != 0x8900) {
                 dev_err(&i2c->dev, "Device is not a WM8900 - ID %x\n", reg);
                 ret = -ENODEV;
@@ -1314,7 +1238,7 @@ static __devinit int wm8900_i2c_probe(struct i2c_client *i2c,
         }
 
         /* Read back from the chip */
-        reg = wm8900_chip_read(codec, WM8900_REG_POWER1);
+        reg = snd_soc_read(codec, WM8900_REG_POWER1);
         reg = (reg >> 12) & 0xf;
         dev_info(&i2c->dev, "WM8900 revision %d\n", reg);
 
@@ -1324,29 +1248,29 @@ static __devinit int wm8900_i2c_probe(struct i2c_client *i2c,
         wm8900_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
 
         /* Latch the volume update bits */
-        wm8900_write(codec, WM8900_REG_LINVOL,
-                     wm8900_read(codec, WM8900_REG_LINVOL) | 0x100);
-        wm8900_write(codec, WM8900_REG_RINVOL,
-                     wm8900_read(codec, WM8900_REG_RINVOL) | 0x100);
-        wm8900_write(codec, WM8900_REG_LOUT1CTL,
-                     wm8900_read(codec, WM8900_REG_LOUT1CTL) | 0x100);
-        wm8900_write(codec, WM8900_REG_ROUT1CTL,
-                     wm8900_read(codec, WM8900_REG_ROUT1CTL) | 0x100);
-        wm8900_write(codec, WM8900_REG_LOUT2CTL,
-                     wm8900_read(codec, WM8900_REG_LOUT2CTL) | 0x100);
-        wm8900_write(codec, WM8900_REG_ROUT2CTL,
-                     wm8900_read(codec, WM8900_REG_ROUT2CTL) | 0x100);
-        wm8900_write(codec, WM8900_REG_LDAC_DV,
-                     wm8900_read(codec, WM8900_REG_LDAC_DV) | 0x100);
-        wm8900_write(codec, WM8900_REG_RDAC_DV,
-                     wm8900_read(codec, WM8900_REG_RDAC_DV) | 0x100);
-        wm8900_write(codec, WM8900_REG_LADC_DV,
-                     wm8900_read(codec, WM8900_REG_LADC_DV) | 0x100);
-        wm8900_write(codec, WM8900_REG_RADC_DV,
-                     wm8900_read(codec, WM8900_REG_RADC_DV) | 0x100);
+        snd_soc_write(codec, WM8900_REG_LINVOL,
+                      snd_soc_read(codec, WM8900_REG_LINVOL) | 0x100);
+        snd_soc_write(codec, WM8900_REG_RINVOL,
+                      snd_soc_read(codec, WM8900_REG_RINVOL) | 0x100);
+        snd_soc_write(codec, WM8900_REG_LOUT1CTL,
+                      snd_soc_read(codec, WM8900_REG_LOUT1CTL) | 0x100);
+        snd_soc_write(codec, WM8900_REG_ROUT1CTL,
+                      snd_soc_read(codec, WM8900_REG_ROUT1CTL) | 0x100);
+        snd_soc_write(codec, WM8900_REG_LOUT2CTL,
+                      snd_soc_read(codec, WM8900_REG_LOUT2CTL) | 0x100);
+        snd_soc_write(codec, WM8900_REG_ROUT2CTL,
+                      snd_soc_read(codec, WM8900_REG_ROUT2CTL) | 0x100);
+        snd_soc_write(codec, WM8900_REG_LDAC_DV,
+                      snd_soc_read(codec, WM8900_REG_LDAC_DV) | 0x100);
+        snd_soc_write(codec, WM8900_REG_RDAC_DV,
+                      snd_soc_read(codec, WM8900_REG_RDAC_DV) | 0x100);
+        snd_soc_write(codec, WM8900_REG_LADC_DV,
+                      snd_soc_read(codec, WM8900_REG_LADC_DV) | 0x100);
+        snd_soc_write(codec, WM8900_REG_RADC_DV,
+                      snd_soc_read(codec, WM8900_REG_RADC_DV) | 0x100);
 
         /* Set the DAC and mixer output bias */
-        wm8900_write(codec, WM8900_REG_OUTBIASCTL, 0x81);
+        snd_soc_write(codec, WM8900_REG_OUTBIASCTL, 0x81);
 
         wm8900_dai.dev = &i2c->dev;
 
@@ -1388,6 +1312,21 @@ 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 },
         { }
@@ -1401,6 +1340,8 @@ 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,
 };
 
diff --git a/sound/soc/codecs/wm8903.c b/sound/soc/codecs/wm8903.c
index 8cf571f1a803..fe1307b500cf 100644
--- a/sound/soc/codecs/wm8903.c
+++ b/sound/soc/codecs/wm8903.c
@@ -217,7 +217,6 @@ struct wm8903_priv {
         int sysclk;
 
         /* Reference counts */
-        int charge_pump_users;
         int class_w_users;
         int playback_active;
         int capture_active;
@@ -226,94 +225,18 @@ struct wm8903_priv {
         struct snd_pcm_substream *slave_substream;
 };
 
-
-static unsigned int wm8903_read_reg_cache(struct snd_soc_codec *codec,
-                                                 unsigned int reg)
-{
-        u16 *cache = codec->reg_cache;
-
-        BUG_ON(reg >= ARRAY_SIZE(wm8903_reg_defaults));
-
-        return cache[reg];
-}
-
-static unsigned int wm8903_hw_read(struct snd_soc_codec *codec, u8 reg)
-{
-        struct i2c_msg xfer[2];
-        u16 data;
-        int ret;
-        struct i2c_client *client = codec->control_data;
-
-        /* Write register */
-        xfer[0].addr = client->addr;
-        xfer[0].flags = 0;
-        xfer[0].len = 1;
-        xfer[0].buf = &reg;
-
-        /* Read data */
-        xfer[1].addr = client->addr;
-        xfer[1].flags = I2C_M_RD;
-        xfer[1].len = 2;
-        xfer[1].buf = (u8 *)&data;
-
-        ret = i2c_transfer(client->adapter, xfer, 2);
-        if (ret != 2) {
-                pr_err("i2c_transfer returned %d\n", ret);
-                return 0;
-        }
-
-        return (data >> 8) | ((data & 0xff) << 8);
-}
-
-static unsigned int wm8903_read(struct snd_soc_codec *codec,
-                                unsigned int reg)
+static int wm8903_volatile_register(unsigned int reg)
 {
         switch (reg) {
         case WM8903_SW_RESET_AND_ID:
         case WM8903_REVISION_NUMBER:
         case WM8903_INTERRUPT_STATUS_1:
         case WM8903_WRITE_SEQUENCER_4:
-                return wm8903_hw_read(codec, reg);
-
-        default:
-                return wm8903_read_reg_cache(codec, reg);
-        }
-}
-
-static void wm8903_write_reg_cache(struct snd_soc_codec *codec,
-                                   u16 reg, unsigned int value)
-{
-        u16 *cache = codec->reg_cache;
-
-        BUG_ON(reg >= ARRAY_SIZE(wm8903_reg_defaults));
-
-        switch (reg) {
-        case WM8903_SW_RESET_AND_ID:
-        case WM8903_REVISION_NUMBER:
-                break;
+                return 1;
 
         default:
-                cache[reg] = value;
-                break;
-        }
-}
-
-static int wm8903_write(struct snd_soc_codec *codec, unsigned int reg,
-                        unsigned int value)
-{
-        u8 data[3];
-
-        wm8903_write_reg_cache(codec, reg, value);
-
-        /* Data format is 1 byte of address followed by 2 bytes of data */
-        data[0] = reg;
-        data[1] = (value >> 8) & 0xff;
-        data[2] = value & 0xff;
-
-        if (codec->hw_write(codec->control_data, data, 3) == 2)
                 return 0;
-        else
-                return -EIO;
+        }
 }
 
 static int wm8903_run_sequence(struct snd_soc_codec *codec, unsigned int start)
@@ -324,13 +247,13 @@ static int wm8903_run_sequence(struct snd_soc_codec *codec, unsigned int start)
         BUG_ON(start > 48);
 
         /* Enable the sequencer */
-        reg[0] = wm8903_read(codec, WM8903_WRITE_SEQUENCER_0);
+        reg[0] = snd_soc_read(codec, WM8903_WRITE_SEQUENCER_0);
         reg[0] |= WM8903_WSEQ_ENA;
-        wm8903_write(codec, WM8903_WRITE_SEQUENCER_0, reg[0]);
+        snd_soc_write(codec, WM8903_WRITE_SEQUENCER_0, reg[0]);
 
         dev_dbg(&i2c->dev, "Starting sequence at %d\n", start);
 
-        wm8903_write(codec, WM8903_WRITE_SEQUENCER_3,
+        snd_soc_write(codec, WM8903_WRITE_SEQUENCER_3,
                      start | WM8903_WSEQ_START);
 
         /* Wait for it to complete.  If we have the interrupt wired up then
@@ -340,13 +263,13 @@ static int wm8903_run_sequence(struct snd_soc_codec *codec, unsigned int start)
         do {
                 msleep(10);
 
-                reg[4] = wm8903_read(codec, WM8903_WRITE_SEQUENCER_4);
+                reg[4] = snd_soc_read(codec, WM8903_WRITE_SEQUENCER_4);
         } while (reg[4] & WM8903_WSEQ_BUSY);
 
         dev_dbg(&i2c->dev, "Sequence complete\n");
 
         /* Disable the sequencer again */
-        wm8903_write(codec, WM8903_WRITE_SEQUENCER_0,
+        snd_soc_write(codec, WM8903_WRITE_SEQUENCER_0,
                      reg[0] & ~WM8903_WSEQ_ENA);
 
         return 0;
@@ -358,12 +281,12 @@ static void wm8903_sync_reg_cache(struct snd_soc_codec *codec, u16 *cache)
 
         /* There really ought to be something better we can do here :/ */
         for (i = 0; i < ARRAY_SIZE(wm8903_reg_defaults); i++)
-                cache[i] = wm8903_hw_read(codec, i);
+                cache[i] = codec->hw_read(codec, i);
 }
 
 static void wm8903_reset(struct snd_soc_codec *codec)
 {
-        wm8903_write(codec, WM8903_SW_RESET_AND_ID, 0);
+        snd_soc_write(codec, WM8903_SW_RESET_AND_ID, 0);
         memcpy(codec->reg_cache, wm8903_reg_defaults,
                sizeof(wm8903_reg_defaults));
 }
@@ -373,6 +296,15 @@ static void wm8903_reset(struct snd_soc_codec *codec)
 #define WM8903_OUTPUT_INT   0x2
 #define WM8903_OUTPUT_IN    0x1
 
+static int wm8903_cp_event(struct snd_soc_dapm_widget *w,
+                           struct snd_kcontrol *kcontrol, int event)
+{
+        WARN_ON(event != SND_SOC_DAPM_POST_PMU);
+        mdelay(4);
+
+        return 0;
+}
+
 /*
  * Event for headphone and line out amplifier power changes.  Special
  * power up/down sequences are required in order to maximise pop/click
@@ -382,19 +314,20 @@ static int wm8903_output_event(struct snd_soc_dapm_widget *w,
                                struct snd_kcontrol *kcontrol, int event)
 {
         struct snd_soc_codec *codec = w->codec;
-        struct wm8903_priv *wm8903 = codec->private_data;
-        struct i2c_client *i2c = codec->control_data;
         u16 val;
         u16 reg;
+        u16 dcs_reg;
+        u16 dcs_bit;
         int shift;
-        u16 cp_reg = wm8903_read(codec, WM8903_CHARGE_PUMP_0);
 
         switch (w->reg) {
         case WM8903_POWER_MANAGEMENT_2:
                 reg = WM8903_ANALOGUE_HP_0;
+                dcs_bit = 0 + w->shift;
                 break;
         case WM8903_POWER_MANAGEMENT_3:
                 reg = WM8903_ANALOGUE_LINEOUT_0;
+                dcs_bit = 2 + w->shift;
                 break;
         default:
                 BUG();
@@ -414,67 +347,52 @@ static int wm8903_output_event(struct snd_soc_dapm_widget *w,
         }
 
         if (event & SND_SOC_DAPM_PRE_PMU) {
-                val = wm8903_read(codec, reg);
+                val = snd_soc_read(codec, reg);
 
                 /* Short the output */
                 val &= ~(WM8903_OUTPUT_SHORT << shift);
-                wm8903_write(codec, reg, val);
-
-                wm8903->charge_pump_users++;
-
-                dev_dbg(&i2c->dev, "Charge pump use count now %d\n",
-                        wm8903->charge_pump_users);
-
-                if (wm8903->charge_pump_users == 1) {
-                        dev_dbg(&i2c->dev, "Enabling charge pump\n");
-                        wm8903_write(codec, WM8903_CHARGE_PUMP_0,
-                                     cp_reg | WM8903_CP_ENA);
-                        mdelay(4);
-                }
+                snd_soc_write(codec, reg, val);
         }
 
         if (event & SND_SOC_DAPM_POST_PMU) {
-                val = wm8903_read(codec, reg);
+                val = snd_soc_read(codec, reg);
 
                 val |= (WM8903_OUTPUT_IN << shift);
-                wm8903_write(codec, reg, val);
+                snd_soc_write(codec, reg, val);
 
                 val |= (WM8903_OUTPUT_INT << shift);
-                wm8903_write(codec, reg, val);
+                snd_soc_write(codec, reg, val);
 
                 /* Turn on the output ENA_OUTP */
                 val |= (WM8903_OUTPUT_OUT << shift);
-                wm8903_write(codec, reg, val);
+                snd_soc_write(codec, reg, val);
+
+                /* Enable the DC servo */
+                dcs_reg = snd_soc_read(codec, WM8903_DC_SERVO_0);
+                dcs_reg |= dcs_bit;
+                snd_soc_write(codec, WM8903_DC_SERVO_0, dcs_reg);
 
                 /* Remove the short */
                 val |= (WM8903_OUTPUT_SHORT << shift);
-                wm8903_write(codec, reg, val);
+                snd_soc_write(codec, reg, val);
         }
 
         if (event & SND_SOC_DAPM_PRE_PMD) {
-                val = wm8903_read(codec, reg);
+                val = snd_soc_read(codec, reg);
 
                 /* Short the output */
                 val &= ~(WM8903_OUTPUT_SHORT << shift);
-                wm8903_write(codec, reg, val);
+                snd_soc_write(codec, reg, val);
+
+                /* Disable the DC servo */
+                dcs_reg = snd_soc_read(codec, WM8903_DC_SERVO_0);
+                dcs_reg &= ~dcs_bit;
+                snd_soc_write(codec, WM8903_DC_SERVO_0, dcs_reg);
 
                 /* Then disable the intermediate and output stages */
                 val &= ~((WM8903_OUTPUT_OUT | WM8903_OUTPUT_INT |
                           WM8903_OUTPUT_IN) << shift);
-                wm8903_write(codec, reg, val);
-        }
-
-        if (event & SND_SOC_DAPM_POST_PMD) {
-                wm8903->charge_pump_users--;
-
-                dev_dbg(&i2c->dev, "Charge pump use count now %d\n",
-                        wm8903->charge_pump_users);
-
-                if (wm8903->charge_pump_users == 0) {
-                        dev_dbg(&i2c->dev, "Disabling charge pump\n");
-                        wm8903_write(codec, WM8903_CHARGE_PUMP_0,
-                                     cp_reg & ~WM8903_CP_ENA);
-                }
+                snd_soc_write(codec, reg, val);
         }
 
         return 0;
@@ -498,13 +416,13 @@ static int wm8903_class_w_put(struct snd_kcontrol *kcontrol,
         u16 reg;
         int ret;
 
-        reg = wm8903_read(codec, WM8903_CLASS_W_0);
+        reg = snd_soc_read(codec, WM8903_CLASS_W_0);
 
         /* Turn it off if we're about to enable bypass */
         if (ucontrol->value.integer.value[0]) {
                 if (wm8903->class_w_users == 0) {
                         dev_dbg(&i2c->dev, "Disabling Class W\n");
-                        wm8903_write(codec, WM8903_CLASS_W_0, reg &
+                        snd_soc_write(codec, WM8903_CLASS_W_0, reg &
                                      ~(WM8903_CP_DYN_FREQ | WM8903_CP_DYN_V));
                 }
                 wm8903->class_w_users++;
@@ -517,7 +435,7 @@ static int wm8903_class_w_put(struct snd_kcontrol *kcontrol,
         if (!ucontrol->value.integer.value[0]) {
                 if (wm8903->class_w_users == 1) {
                         dev_dbg(&i2c->dev, "Enabling Class W\n");
-                        wm8903_write(codec, WM8903_CLASS_W_0, reg |
+                        snd_soc_write(codec, WM8903_CLASS_W_0, reg |
                                      WM8903_CP_DYN_FREQ | WM8903_CP_DYN_V);
                 }
                 wm8903->class_w_users--;
@@ -539,6 +457,7 @@ static int wm8903_class_w_put(struct snd_kcontrol *kcontrol,
 /* ALSA can only do steps of .01dB */
 static const DECLARE_TLV_DB_SCALE(digital_tlv, -7200, 75, 1);
 
+static const DECLARE_TLV_DB_SCALE(digital_sidetone_tlv, -3600, 300, 0);
 static const DECLARE_TLV_DB_SCALE(out_tlv, -5700, 100, 0);
 
 static const DECLARE_TLV_DB_SCALE(drc_tlv_thresh, 0, 75, 0);
@@ -657,6 +576,16 @@ static const struct soc_enum rinput_inv_enum =
         SOC_ENUM_SINGLE(WM8903_ANALOGUE_RIGHT_INPUT_1, 4, 3, rinput_mux_text);
 
 
+static const char *sidetone_text[] = {
+        "None", "Left", "Right"
+};
+
+static const struct soc_enum lsidetone_enum =
+        SOC_ENUM_SINGLE(WM8903_DAC_DIGITAL_0, 2, 3, sidetone_text);
+
+static const struct soc_enum rsidetone_enum =
+        SOC_ENUM_SINGLE(WM8903_DAC_DIGITAL_0, 0, 3, sidetone_text);
+
 static const struct snd_kcontrol_new wm8903_snd_controls[] = {
 
 /* Input PGAs - No TLV since the scale depends on PGA mode */
@@ -700,6 +629,9 @@ SOC_DOUBLE_R_TLV("Digital Capture Volume", WM8903_ADC_DIGITAL_VOLUME_LEFT,
 SOC_ENUM("ADC Companding Mode", adc_companding),
 SOC_SINGLE("ADC Companding Switch", WM8903_AUDIO_INTERFACE_0, 3, 1, 0),
 
+SOC_DOUBLE_TLV("Digital Sidetone Volume", WM8903_DAC_DIGITAL_0, 4, 8,
+               12, 0, digital_sidetone_tlv),
+
 /* DAC */
 SOC_DOUBLE_R_TLV("Digital Playback Volume", WM8903_DAC_DIGITAL_VOLUME_LEFT,
                  WM8903_DAC_DIGITAL_VOLUME_RIGHT, 1, 120, 0, digital_tlv),
@@ -707,8 +639,6 @@ SOC_ENUM("DAC Soft Mute Rate", soft_mute),
 SOC_ENUM("DAC Mute Mode", mute_mode),
 SOC_SINGLE("DAC Mono Switch", WM8903_DAC_DIGITAL_1, 12, 1, 0),
 SOC_ENUM("DAC De-emphasis", dac_deemphasis),
-SOC_SINGLE("DAC Sloping Stopband Filter Switch",
-           WM8903_DAC_DIGITAL_1, 11, 1, 0),
 SOC_ENUM("DAC Companding Mode", dac_companding),
 SOC_SINGLE("DAC Companding Switch", WM8903_AUDIO_INTERFACE_0, 1, 1, 0),
 
@@ -762,6 +692,12 @@ static const struct snd_kcontrol_new rinput_mux =
 static const struct snd_kcontrol_new rinput_inv_mux =
         SOC_DAPM_ENUM("Right Inverting Input Mux", rinput_inv_enum);
 
+static const struct snd_kcontrol_new lsidetone_mux =
+        SOC_DAPM_ENUM("DACL Sidetone Mux", lsidetone_enum);
+
+static const struct snd_kcontrol_new rsidetone_mux =
+        SOC_DAPM_ENUM("DACR Sidetone Mux", rsidetone_enum);
+
 static const struct snd_kcontrol_new left_output_mixer[] = {
 SOC_DAPM_SINGLE("DACL Switch", WM8903_ANALOGUE_LEFT_MIX_0, 3, 1, 0),
 SOC_DAPM_SINGLE("DACR Switch", WM8903_ANALOGUE_LEFT_MIX_0, 2, 1, 0),
@@ -828,6 +764,9 @@ SND_SOC_DAPM_PGA("Right Input PGA", WM8903_POWER_MANAGEMENT_0, 0, 0, NULL, 0),
 SND_SOC_DAPM_ADC("ADCL", "Left HiFi Capture", WM8903_POWER_MANAGEMENT_6, 1, 0),
 SND_SOC_DAPM_ADC("ADCR", "Right HiFi Capture", WM8903_POWER_MANAGEMENT_6, 0, 0),
 
+SND_SOC_DAPM_MUX("DACL Sidetone", SND_SOC_NOPM, 0, 0, &lsidetone_mux),
+SND_SOC_DAPM_MUX("DACR Sidetone", SND_SOC_NOPM, 0, 0, &rsidetone_mux),
+
 SND_SOC_DAPM_DAC("DACL", "Left Playback", WM8903_POWER_MANAGEMENT_6, 3, 0),
 SND_SOC_DAPM_DAC("DACR", "Right Playback", WM8903_POWER_MANAGEMENT_6, 2, 0),
 
@@ -844,26 +783,29 @@ SND_SOC_DAPM_MIXER("Right Speaker Mixer", WM8903_POWER_MANAGEMENT_4, 0, 0,
 SND_SOC_DAPM_PGA_E("Left Headphone Output PGA", WM8903_POWER_MANAGEMENT_2,
                    1, 0, NULL, 0, wm8903_output_event,
                    SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
-                   SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMD),
+                   SND_SOC_DAPM_PRE_PMD),
 SND_SOC_DAPM_PGA_E("Right Headphone Output PGA", WM8903_POWER_MANAGEMENT_2,
                    0, 0, NULL, 0, wm8903_output_event,
                    SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
-                   SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMD),
+                   SND_SOC_DAPM_PRE_PMD),
 
 SND_SOC_DAPM_PGA_E("Left Line Output PGA", WM8903_POWER_MANAGEMENT_3, 1, 0,
                    NULL, 0, wm8903_output_event,
                    SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
-                   SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMD),
+                   SND_SOC_DAPM_PRE_PMD),
 SND_SOC_DAPM_PGA_E("Right Line Output PGA", WM8903_POWER_MANAGEMENT_3, 0, 0,
                    NULL, 0, wm8903_output_event,
                    SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
-                   SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMD),
+                   SND_SOC_DAPM_PRE_PMD),
 
 SND_SOC_DAPM_PGA("Left Speaker PGA", WM8903_POWER_MANAGEMENT_5, 1, 0,
                  NULL, 0),
 SND_SOC_DAPM_PGA("Right Speaker PGA", WM8903_POWER_MANAGEMENT_5, 0, 0,
                  NULL, 0),
 
+SND_SOC_DAPM_SUPPLY("Charge Pump", WM8903_CHARGE_PUMP_0, 0, 0,
+                    wm8903_cp_event, SND_SOC_DAPM_POST_PMU),
+SND_SOC_DAPM_SUPPLY("CLK_DSP", WM8903_CLOCK_RATES_2, 1, 0, NULL, 0),
 };
 
 static const struct snd_soc_dapm_route intercon[] = {
@@ -909,7 +851,19 @@ static const struct snd_soc_dapm_route intercon[] = {
         { "Right Input PGA", NULL, "Right Input Mode Mux" },
 
         { "ADCL", NULL, "Left Input PGA" },
+        { "ADCL", NULL, "CLK_DSP" },
         { "ADCR", NULL, "Right Input PGA" },
+        { "ADCR", NULL, "CLK_DSP" },
+
+        { "DACL Sidetone", "Left", "ADCL" },
+        { "DACL Sidetone", "Right", "ADCR" },
+        { "DACR Sidetone", "Left", "ADCL" },
+        { "DACR Sidetone", "Right", "ADCR" },
+
+        { "DACL", NULL, "DACL Sidetone" },
+        { "DACL", NULL, "CLK_DSP" },
+        { "DACR", NULL, "DACR Sidetone" },
+        { "DACR", NULL, "CLK_DSP" },
 
         { "Left Output Mixer", "Left Bypass Switch", "Left Input PGA" },
         { "Left Output Mixer", "Right Bypass Switch", "Right Input PGA" },
@@ -951,6 +905,11 @@ static const struct snd_soc_dapm_route intercon[] = {
 
         { "ROP", NULL, "Right Speaker PGA" },
         { "RON", NULL, "Right Speaker PGA" },
+
+        { "Left Headphone Output PGA", NULL, "Charge Pump" },
+        { "Right Headphone Output PGA", NULL, "Charge Pump" },
+        { "Left Line Output PGA", NULL, "Charge Pump" },
+        { "Right Line Output PGA", NULL, "Charge Pump" },
 };
 
 static int wm8903_add_widgets(struct snd_soc_codec *codec)
@@ -974,50 +933,55 @@ static int wm8903_set_bias_level(struct snd_soc_codec *codec,
         switch (level) {
         case SND_SOC_BIAS_ON:
         case SND_SOC_BIAS_PREPARE:
-                reg = wm8903_read(codec, WM8903_VMID_CONTROL_0);
+                reg = snd_soc_read(codec, WM8903_VMID_CONTROL_0);
                 reg &= ~(WM8903_VMID_RES_MASK);
                 reg |= WM8903_VMID_RES_50K;
-                wm8903_write(codec, WM8903_VMID_CONTROL_0, reg);
+                snd_soc_write(codec, WM8903_VMID_CONTROL_0, reg);
                 break;
 
         case SND_SOC_BIAS_STANDBY:
                 if (codec->bias_level == SND_SOC_BIAS_OFF) {
-                        wm8903_write(codec, WM8903_CLOCK_RATES_2,
+                        snd_soc_write(codec, WM8903_CLOCK_RATES_2,
                                      WM8903_CLK_SYS_ENA);
 
+                        /* Change DC servo dither level in startup sequence */
+                        snd_soc_write(codec, WM8903_WRITE_SEQUENCER_0, 0x11);
+                        snd_soc_write(codec, WM8903_WRITE_SEQUENCER_1, 0x1257);
+                        snd_soc_write(codec, WM8903_WRITE_SEQUENCER_2, 0x2);
+
                         wm8903_run_sequence(codec, 0);
                         wm8903_sync_reg_cache(codec, codec->reg_cache);
 
                         /* Enable low impedence charge pump output */
-                        reg = wm8903_read(codec,
+                        reg = snd_soc_read(codec,
                                           WM8903_CONTROL_INTERFACE_TEST_1);
-                        wm8903_write(codec, WM8903_CONTROL_INTERFACE_TEST_1,
+                        snd_soc_write(codec, WM8903_CONTROL_INTERFACE_TEST_1,
                                      reg | WM8903_TEST_KEY);
-                        reg2 = wm8903_read(codec, WM8903_CHARGE_PUMP_TEST_1);
-                        wm8903_write(codec, WM8903_CHARGE_PUMP_TEST_1,
+                        reg2 = snd_soc_read(codec, WM8903_CHARGE_PUMP_TEST_1);
+                        snd_soc_write(codec, WM8903_CHARGE_PUMP_TEST_1,
                                      reg2 | WM8903_CP_SW_KELVIN_MODE_MASK);
-                        wm8903_write(codec, WM8903_CONTROL_INTERFACE_TEST_1,
+                        snd_soc_write(codec, WM8903_CONTROL_INTERFACE_TEST_1,
                                      reg);
 
                         /* By default no bypass paths are enabled so
                          * enable Class W support.
                          */
                         dev_dbg(&i2c->dev, "Enabling Class W\n");
-                        wm8903_write(codec, WM8903_CLASS_W_0, reg |
+                        snd_soc_write(codec, WM8903_CLASS_W_0, reg |
                                      WM8903_CP_DYN_FREQ | WM8903_CP_DYN_V);
                 }
 
-                reg = wm8903_read(codec, WM8903_VMID_CONTROL_0);
+                reg = snd_soc_read(codec, WM8903_VMID_CONTROL_0);
                 reg &= ~(WM8903_VMID_RES_MASK);
                 reg |= WM8903_VMID_RES_250K;
-                wm8903_write(codec, WM8903_VMID_CONTROL_0, reg);
+                snd_soc_write(codec, WM8903_VMID_CONTROL_0, reg);
                 break;
 
         case SND_SOC_BIAS_OFF:
                 wm8903_run_sequence(codec, 32);
-                reg = wm8903_read(codec, WM8903_CLOCK_RATES_2);
+                reg = snd_soc_read(codec, WM8903_CLOCK_RATES_2);
                 reg &= ~WM8903_CLK_SYS_ENA;
-                wm8903_write(codec, WM8903_CLOCK_RATES_2, reg);
+                snd_soc_write(codec, WM8903_CLOCK_RATES_2, reg);
                 break;
         }
 
@@ -1041,7 +1005,7 @@ static int wm8903_set_dai_fmt(struct snd_soc_dai *codec_dai,
                               unsigned int fmt)
 {
         struct snd_soc_codec *codec = codec_dai->codec;
-        u16 aif1 = wm8903_read(codec, WM8903_AUDIO_INTERFACE_1);
+        u16 aif1 = snd_soc_read(codec, WM8903_AUDIO_INTERFACE_1);
 
         aif1 &= ~(WM8903_LRCLK_DIR | WM8903_BCLK_DIR | WM8903_AIF_FMT_MASK |
                   WM8903_AIF_LRCLK_INV | WM8903_AIF_BCLK_INV);
@@ -1119,7 +1083,7 @@ static int wm8903_set_dai_fmt(struct snd_soc_dai *codec_dai,
                 return -EINVAL;
         }
 
-        wm8903_write(codec, WM8903_AUDIO_INTERFACE_1, aif1);
+        snd_soc_write(codec, WM8903_AUDIO_INTERFACE_1, aif1);
 
         return 0;
 }
@@ -1129,14 +1093,14 @@ static int wm8903_digital_mute(struct snd_soc_dai *codec_dai, int mute)
         struct snd_soc_codec *codec = codec_dai->codec;
         u16 reg;
 
-        reg = wm8903_read(codec, WM8903_DAC_DIGITAL_1);
+        reg = snd_soc_read(codec, WM8903_DAC_DIGITAL_1);
 
         if (mute)
                 reg |= WM8903_DAC_MUTE;
         else
                 reg &= ~WM8903_DAC_MUTE;
 
-        wm8903_write(codec, WM8903_DAC_DIGITAL_1, reg);
+        snd_soc_write(codec, WM8903_DAC_DIGITAL_1, reg);
 
         return 0;
 }
@@ -1215,22 +1179,18 @@ static struct {
         int 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, 15 },
-        { 250, 16 },
         { 300, 17 },
         { 320, 18 },
         { 440, 19 },
@@ -1277,14 +1237,8 @@ static int wm8903_startup(struct snd_pcm_substream *substream,
         if (wm8903->master_substream) {
                 master_runtime = wm8903->master_substream->runtime;
 
-                dev_dbg(&i2c->dev, "Constraining to %d bits at %dHz\n",
-                        master_runtime->sample_bits,
-                        master_runtime->rate);
-
-                snd_pcm_hw_constraint_minmax(substream->runtime,
-                                             SNDRV_PCM_HW_PARAM_RATE,
-                                             master_runtime->rate,
-                                             master_runtime->rate);
+                dev_dbg(&i2c->dev, "Constraining to %d bits\n",
+                        master_runtime->sample_bits);
 
                 snd_pcm_hw_constraint_minmax(substream->runtime,
                                              SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
@@ -1336,17 +1290,24 @@ static int wm8903_hw_params(struct snd_pcm_substream *substream,
         int cur_val;
         int clk_sys;
 
-        u16 aif1 = wm8903_read(codec, WM8903_AUDIO_INTERFACE_1);
-        u16 aif2 = wm8903_read(codec, WM8903_AUDIO_INTERFACE_2);
-        u16 aif3 = wm8903_read(codec, WM8903_AUDIO_INTERFACE_3);
-        u16 clock0 = wm8903_read(codec, WM8903_CLOCK_RATES_0);
-        u16 clock1 = wm8903_read(codec, WM8903_CLOCK_RATES_1);
+        u16 aif1 = snd_soc_read(codec, WM8903_AUDIO_INTERFACE_1);
+        u16 aif2 = snd_soc_read(codec, WM8903_AUDIO_INTERFACE_2);
+        u16 aif3 = snd_soc_read(codec, WM8903_AUDIO_INTERFACE_3);
+        u16 clock0 = snd_soc_read(codec, WM8903_CLOCK_RATES_0);
+        u16 clock1 = snd_soc_read(codec, WM8903_CLOCK_RATES_1);
+        u16 dac_digital1 = snd_soc_read(codec, WM8903_DAC_DIGITAL_1);
 
         if (substream == wm8903->slave_substream) {
                 dev_dbg(&i2c->dev, "Ignoring hw_params for slave substream\n");
                 return 0;
         }
 
+        /* Enable sloping stopband filter for low sample rates */
+        if (fs <= 24000)
+                dac_digital1 |= WM8903_DAC_SB_FILT;
+        else
+                dac_digital1 &= ~WM8903_DAC_SB_FILT;
+
         /* Configure sample rate logic for DSP - choose nearest rate */
         dsp_config = 0;
         best_val = abs(sample_rates[dsp_config].rate - fs);
@@ -1466,11 +1427,12 @@ static int wm8903_hw_params(struct snd_pcm_substream *substream,
         aif2 |= bclk_divs[bclk_div].div;
         aif3 |= bclk / fs;
 
-        wm8903_write(codec, WM8903_CLOCK_RATES_0, clock0);
-        wm8903_write(codec, WM8903_CLOCK_RATES_1, clock1);
-        wm8903_write(codec, WM8903_AUDIO_INTERFACE_1, aif1);
-        wm8903_write(codec, WM8903_AUDIO_INTERFACE_2, aif2);
-        wm8903_write(codec, WM8903_AUDIO_INTERFACE_3, aif3);
+        snd_soc_write(codec, WM8903_CLOCK_RATES_0, clock0);
+        snd_soc_write(codec, WM8903_CLOCK_RATES_1, clock1);
+        snd_soc_write(codec, WM8903_AUDIO_INTERFACE_1, aif1);
+        snd_soc_write(codec, WM8903_AUDIO_INTERFACE_2, aif2);
+        snd_soc_write(codec, WM8903_AUDIO_INTERFACE_3, aif3);
+        snd_soc_write(codec, WM8903_DAC_DIGITAL_1, dac_digital1);
 
         return 0;
 }
@@ -1523,6 +1485,7 @@ struct snd_soc_dai wm8903_dai = {
                  .formats = WM8903_FORMATS,
          },
         .ops = &wm8903_dai_ops,
+        .symmetric_rates = 1,
 };
 EXPORT_SYMBOL_GPL(wm8903_dai);
 
@@ -1554,7 +1517,7 @@ static int wm8903_resume(struct platform_device *pdev)
         if (tmp_cache) {
                 for (i = 2; i < ARRAY_SIZE(wm8903_reg_defaults); i++)
                         if (tmp_cache[i] != reg_cache[i])
-                                wm8903_write(codec, i, tmp_cache[i]);
+                                snd_soc_write(codec, i, tmp_cache[i]);
         } else {
                 dev_err(&i2c->dev, "Failed to allocate temporary cache\n");
         }
@@ -1585,9 +1548,6 @@ static __devinit int wm8903_i2c_probe(struct i2c_client *i2c,
         codec->dev = &i2c->dev;
         codec->name = "WM8903";
         codec->owner = THIS_MODULE;
-        codec->read = wm8903_read;
-        codec->write = wm8903_write;
-        codec->hw_write = (hw_write_t)i2c_master_send;
         codec->bias_level = SND_SOC_BIAS_OFF;
         codec->set_bias_level = wm8903_set_bias_level;
         codec->dai = &wm8903_dai;
@@ -1595,18 +1555,25 @@ static __devinit int wm8903_i2c_probe(struct i2c_client *i2c,
         codec->reg_cache_size = ARRAY_SIZE(wm8903->reg_cache);
         codec->reg_cache = &wm8903->reg_cache[0];
         codec->private_data = wm8903;
+        codec->volatile_register = wm8903_volatile_register;
 
         i2c_set_clientdata(i2c, codec);
         codec->control_data = i2c;
 
-        val = wm8903_hw_read(codec, WM8903_SW_RESET_AND_ID);
+        ret = snd_soc_codec_set_cache_io(codec, 8, 16, SND_SOC_I2C);
+        if (ret != 0) {
+                dev_err(&i2c->dev, "Failed to set cache I/O: %d\n", ret);
+                goto err;
+        }
+
+        val = snd_soc_read(codec, WM8903_SW_RESET_AND_ID);
         if (val != wm8903_reg_defaults[WM8903_SW_RESET_AND_ID]) {
                 dev_err(&i2c->dev,
                         "Device with ID register %x is not a WM8903\n", val);
                 return -ENODEV;
         }
 
-        val = wm8903_read(codec, WM8903_REVISION_NUMBER);
+        val = snd_soc_read(codec, WM8903_REVISION_NUMBER);
         dev_info(&i2c->dev, "WM8903 revision %d\n",
                  val & WM8903_CHIP_REV_MASK);
 
@@ -1616,35 +1583,35 @@ static __devinit int wm8903_i2c_probe(struct i2c_client *i2c,
         wm8903_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
 
         /* Latch volume update bits */
-        val = wm8903_read(codec, WM8903_ADC_DIGITAL_VOLUME_LEFT);
+        val = snd_soc_read(codec, WM8903_ADC_DIGITAL_VOLUME_LEFT);
         val |= WM8903_ADCVU;
-        wm8903_write(codec, WM8903_ADC_DIGITAL_VOLUME_LEFT, val);
-        wm8903_write(codec, WM8903_ADC_DIGITAL_VOLUME_RIGHT, val);
+        snd_soc_write(codec, WM8903_ADC_DIGITAL_VOLUME_LEFT, val);
+        snd_soc_write(codec, WM8903_ADC_DIGITAL_VOLUME_RIGHT, val);
 
-        val = wm8903_read(codec, WM8903_DAC_DIGITAL_VOLUME_LEFT);
+        val = snd_soc_read(codec, WM8903_DAC_DIGITAL_VOLUME_LEFT);
         val |= WM8903_DACVU;
-        wm8903_write(codec, WM8903_DAC_DIGITAL_VOLUME_LEFT, val);
-        wm8903_write(codec, WM8903_DAC_DIGITAL_VOLUME_RIGHT, val);
+        snd_soc_write(codec, WM8903_DAC_DIGITAL_VOLUME_LEFT, val);
+        snd_soc_write(codec, WM8903_DAC_DIGITAL_VOLUME_RIGHT, val);
 
-        val = wm8903_read(codec, WM8903_ANALOGUE_OUT1_LEFT);
+        val = snd_soc_read(codec, WM8903_ANALOGUE_OUT1_LEFT);
         val |= WM8903_HPOUTVU;
-        wm8903_write(codec, WM8903_ANALOGUE_OUT1_LEFT, val);
-        wm8903_write(codec, WM8903_ANALOGUE_OUT1_RIGHT, val);
+        snd_soc_write(codec, WM8903_ANALOGUE_OUT1_LEFT, val);
+        snd_soc_write(codec, WM8903_ANALOGUE_OUT1_RIGHT, val);
 
-        val = wm8903_read(codec, WM8903_ANALOGUE_OUT2_LEFT);
+        val = snd_soc_read(codec, WM8903_ANALOGUE_OUT2_LEFT);
         val |= WM8903_LINEOUTVU;
-        wm8903_write(codec, WM8903_ANALOGUE_OUT2_LEFT, val);
-        wm8903_write(codec, WM8903_ANALOGUE_OUT2_RIGHT, val);
+        snd_soc_write(codec, WM8903_ANALOGUE_OUT2_LEFT, val);
+        snd_soc_write(codec, WM8903_ANALOGUE_OUT2_RIGHT, val);
 
-        val = wm8903_read(codec, WM8903_ANALOGUE_OUT3_LEFT);
+        val = snd_soc_read(codec, WM8903_ANALOGUE_OUT3_LEFT);
         val |= WM8903_SPKVU;
-        wm8903_write(codec, WM8903_ANALOGUE_OUT3_LEFT, val);
-        wm8903_write(codec, WM8903_ANALOGUE_OUT3_RIGHT, val);
+        snd_soc_write(codec, WM8903_ANALOGUE_OUT3_LEFT, val);
+        snd_soc_write(codec, WM8903_ANALOGUE_OUT3_RIGHT, val);
 
         /* Enable DAC soft mute by default */
-        val = wm8903_read(codec, WM8903_DAC_DIGITAL_1);
+        val = snd_soc_read(codec, WM8903_DAC_DIGITAL_1);
         val |= WM8903_DAC_MUTEMODE;
-        wm8903_write(codec, WM8903_DAC_DIGITAL_1, val);
+        snd_soc_write(codec, WM8903_DAC_DIGITAL_1, val);
 
         wm8903_dai.dev = &i2c->dev;
         wm8903_codec = codec;
@@ -1688,6 +1655,21 @@ 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 },
@@ -1702,6 +1684,8 @@ 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,
 };
 
diff --git a/sound/soc/codecs/wm8940.c b/sound/soc/codecs/wm8940.c
new file mode 100644
index 000000000000..da97aae475a2
--- /dev/null
+++ b/sound/soc/codecs/wm8940.c
@@ -0,0 +1,933 @@
+/*
+ * wm8940.c  --  WM8940 ALSA Soc Audio driver
+ *
+ * Author: Jonathan Cameron <jic23@cam.ac.uk>
+ *
+ * Based on wm8510.c
+ *    Copyright  2006 Wolfson Microelectronics PLC.
+ *    Author:  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.
+ *
+ * Not currently handled:
+ * Notch filter control
+ * AUXMode (inverting vs mixer)
+ * No means to obtain current gain if alc enabled.
+ * No use made of gpio
+ * Fast VMID discharge for power down
+ * Soft Start
+ * DLR and ALR Swaps not enabled
+ * Digital Sidetone not supported
+ */
+#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/spi/spi.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 "wm8940.h"
+
+struct wm8940_priv {
+        unsigned int sysclk;
+        u16 reg_cache[WM8940_CACHEREGNUM];
+        struct snd_soc_codec codec;
+};
+
+static u16 wm8940_reg_defaults[] = {
+        0x8940, /* Soft Reset */
+        0x0000, /* Power 1 */
+        0x0000, /* Power 2 */
+        0x0000, /* Power 3 */
+        0x0010, /* Interface Control */
+        0x0000, /* Companding Control */
+        0x0140, /* Clock Control */
+        0x0000, /* Additional Controls */
+        0x0000, /* GPIO Control */
+        0x0002, /* Auto Increment Control */
+        0x0000, /* DAC Control */
+        0x00FF, /* DAC Volume */
+        0,
+        0,
+        0x0100, /* ADC Control */
+        0x00FF, /* ADC Volume */
+        0x0000, /* Notch Filter 1 Control 1 */
+        0x0000, /* Notch Filter 1 Control 2 */
+        0x0000, /* Notch Filter 2 Control 1 */
+        0x0000, /* Notch Filter 2 Control 2 */
+        0x0000, /* Notch Filter 3 Control 1 */
+        0x0000, /* Notch Filter 3 Control 2 */
+        0x0000, /* Notch Filter 4 Control 1 */
+        0x0000, /* Notch Filter 4 Control 2 */
+        0x0032, /* DAC Limit Control 1 */
+        0x0000, /* DAC Limit Control 2 */
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0x0038, /* ALC Control 1 */
+        0x000B, /* ALC Control 2 */
+        0x0032, /* ALC Control 3 */
+        0x0000, /* Noise Gate */
+        0x0041, /* PLLN */
+        0x000C, /* PLLK1 */
+        0x0093, /* PLLK2 */
+        0x00E9, /* PLLK3 */
+        0,
+        0,
+        0x0030, /* ALC Control 4 */
+        0,
+        0x0002, /* Input Control */
+        0x0050, /* PGA Gain */
+        0,
+        0x0002, /* ADC Boost Control */
+        0,
+        0x0002, /* Output Control */
+        0x0000, /* Speaker Mixer Control */
+        0,
+        0,
+        0,
+        0x0079, /* Speaker Volume */
+        0,
+        0x0000, /* Mono Mixer Control */
+};
+
+static const char *wm8940_companding[] = { "Off", "NC", "u-law", "A-law" };
+static const struct soc_enum wm8940_adc_companding_enum
+= SOC_ENUM_SINGLE(WM8940_COMPANDINGCTL, 1, 4, wm8940_companding);
+static const struct soc_enum wm8940_dac_companding_enum
+= SOC_ENUM_SINGLE(WM8940_COMPANDINGCTL, 3, 4, wm8940_companding);
+
+static const char *wm8940_alc_mode_text[] = {"ALC", "Limiter"};
+static const struct soc_enum wm8940_alc_mode_enum
+= SOC_ENUM_SINGLE(WM8940_ALC3, 8, 2, wm8940_alc_mode_text);
+
+static const char *wm8940_mic_bias_level_text[] = {"0.9", "0.65"};
+static const struct soc_enum wm8940_mic_bias_level_enum
+= SOC_ENUM_SINGLE(WM8940_INPUTCTL, 8, 2, wm8940_mic_bias_level_text);
+
+static const char *wm8940_filter_mode_text[] = {"Audio", "Application"};
+static const struct soc_enum wm8940_filter_mode_enum
+= SOC_ENUM_SINGLE(WM8940_ADC, 7, 2, wm8940_filter_mode_text);
+
+static DECLARE_TLV_DB_SCALE(wm8940_spk_vol_tlv, -5700, 100, 1);
+static DECLARE_TLV_DB_SCALE(wm8940_att_tlv, -1000, 1000, 0);
+static DECLARE_TLV_DB_SCALE(wm8940_pga_vol_tlv, -1200, 75, 0);
+static DECLARE_TLV_DB_SCALE(wm8940_alc_min_tlv, -1200, 600, 0);
+static DECLARE_TLV_DB_SCALE(wm8940_alc_max_tlv, 675, 600, 0);
+static DECLARE_TLV_DB_SCALE(wm8940_alc_tar_tlv, -2250, 50, 0);
+static DECLARE_TLV_DB_SCALE(wm8940_lim_boost_tlv, 0, 100, 0);
+static DECLARE_TLV_DB_SCALE(wm8940_lim_thresh_tlv, -600, 100, 0);
+static DECLARE_TLV_DB_SCALE(wm8940_adc_tlv, -12750, 50, 1);
+static DECLARE_TLV_DB_SCALE(wm8940_capture_boost_vol_tlv, 0, 2000, 0);
+
+static const struct snd_kcontrol_new wm8940_snd_controls[] = {
+        SOC_SINGLE("Digital Loopback Switch", WM8940_COMPANDINGCTL,
+                   6, 1, 0),
+        SOC_ENUM("DAC Companding", wm8940_dac_companding_enum),
+        SOC_ENUM("ADC Companding", wm8940_adc_companding_enum),
+
+        SOC_ENUM("ALC Mode", wm8940_alc_mode_enum),
+        SOC_SINGLE("ALC Switch", WM8940_ALC1, 8, 1, 0),
+        SOC_SINGLE_TLV("ALC Capture Max Gain", WM8940_ALC1,
+                       3, 7, 1, wm8940_alc_max_tlv),
+        SOC_SINGLE_TLV("ALC Capture Min Gain", WM8940_ALC1,
+                       0, 7, 0, wm8940_alc_min_tlv),
+        SOC_SINGLE_TLV("ALC Capture Target", WM8940_ALC2,
+                       0, 14, 0, wm8940_alc_tar_tlv),
+        SOC_SINGLE("ALC Capture Hold", WM8940_ALC2, 4, 10, 0),
+        SOC_SINGLE("ALC Capture Decay", WM8940_ALC3, 4, 10, 0),
+        SOC_SINGLE("ALC Capture Attach", WM8940_ALC3, 0, 10, 0),
+        SOC_SINGLE("ALC ZC Switch", WM8940_ALC4, 1, 1, 0),
+        SOC_SINGLE("ALC Capture Noise Gate Switch", WM8940_NOISEGATE,
+                   3, 1, 0),
+        SOC_SINGLE("ALC Capture Noise Gate Threshold", WM8940_NOISEGATE,
+                   0, 7, 0),
+
+        SOC_SINGLE("DAC Playback Limiter Switch", WM8940_DACLIM1, 8, 1, 0),
+        SOC_SINGLE("DAC Playback Limiter Attack", WM8940_DACLIM1, 0, 9, 0),
+        SOC_SINGLE("DAC Playback Limiter Decay", WM8940_DACLIM1, 4, 11, 0),
+        SOC_SINGLE_TLV("DAC Playback Limiter Threshold", WM8940_DACLIM2,
+                       4, 9, 1, wm8940_lim_thresh_tlv),
+        SOC_SINGLE_TLV("DAC Playback Limiter Boost", WM8940_DACLIM2,
+                       0, 12, 0, wm8940_lim_boost_tlv),
+
+        SOC_SINGLE("Capture PGA ZC Switch", WM8940_PGAGAIN, 7, 1, 0),
+        SOC_SINGLE_TLV("Capture PGA Volume", WM8940_PGAGAIN,
+                       0, 63, 0, wm8940_pga_vol_tlv),
+        SOC_SINGLE_TLV("Digital Playback Volume", WM8940_DACVOL,
+                       0, 255, 0, wm8940_adc_tlv),
+        SOC_SINGLE_TLV("Digital Capture Volume", WM8940_ADCVOL,
+                       0, 255, 0, wm8940_adc_tlv),
+        SOC_ENUM("Mic Bias Level", wm8940_mic_bias_level_enum),
+        SOC_SINGLE_TLV("Capture Boost Volue", WM8940_ADCBOOST,
+                       8, 1, 0, wm8940_capture_boost_vol_tlv),
+        SOC_SINGLE_TLV("Speaker Playback Volume", WM8940_SPKVOL,
+                       0, 63, 0, wm8940_spk_vol_tlv),
+        SOC_SINGLE("Speaker Playback Switch", WM8940_SPKVOL,  6, 1, 1),
+
+        SOC_SINGLE_TLV("Speaker Mixer Line Bypass Volume", WM8940_SPKVOL,
+                       8, 1, 1, wm8940_att_tlv),
+        SOC_SINGLE("Speaker Playback ZC Switch", WM8940_SPKVOL, 7, 1, 0),
+
+        SOC_SINGLE("Mono Out Switch", WM8940_MONOMIX, 6, 1, 1),
+        SOC_SINGLE_TLV("Mono Mixer Line Bypass Volume", WM8940_MONOMIX,
+                       7, 1, 1, wm8940_att_tlv),
+
+        SOC_SINGLE("High Pass Filter Switch", WM8940_ADC, 8, 1, 0),
+        SOC_ENUM("High Pass Filter Mode", wm8940_filter_mode_enum),
+        SOC_SINGLE("High Pass Filter Cut Off", WM8940_ADC, 4, 7, 0),
+        SOC_SINGLE("ADC Inversion Switch", WM8940_ADC, 0, 1, 0),
+        SOC_SINGLE("DAC Inversion Switch", WM8940_DAC, 0, 1, 0),
+        SOC_SINGLE("DAC Auto Mute Switch", WM8940_DAC, 2, 1, 0),
+        SOC_SINGLE("ZC Timeout Clock Switch", WM8940_ADDCNTRL, 0, 1, 0),
+};
+
+static const struct snd_kcontrol_new wm8940_speaker_mixer_controls[] = {
+        SOC_DAPM_SINGLE("Line Bypass Switch", WM8940_SPKMIX, 1, 1, 0),
+        SOC_DAPM_SINGLE("Aux Playback Switch", WM8940_SPKMIX, 5, 1, 0),
+        SOC_DAPM_SINGLE("PCM Playback Switch", WM8940_SPKMIX, 0, 1, 0),
+};
+
+static const struct snd_kcontrol_new wm8940_mono_mixer_controls[] = {
+        SOC_DAPM_SINGLE("Line Bypass Switch", WM8940_MONOMIX, 1, 1, 0),
+        SOC_DAPM_SINGLE("Aux Playback Switch", WM8940_MONOMIX, 2, 1, 0),
+        SOC_DAPM_SINGLE("PCM Playback Switch", WM8940_MONOMIX, 0, 1, 0),
+};
+
+static DECLARE_TLV_DB_SCALE(wm8940_boost_vol_tlv, -1500, 300, 1);
+static const struct snd_kcontrol_new wm8940_input_boost_controls[] = {
+        SOC_DAPM_SINGLE("Mic PGA Switch", WM8940_PGAGAIN, 6, 1, 1),
+        SOC_DAPM_SINGLE_TLV("Aux Volume", WM8940_ADCBOOST,
+                            0, 7, 0, wm8940_boost_vol_tlv),
+        SOC_DAPM_SINGLE_TLV("Mic Volume", WM8940_ADCBOOST,
+                            4, 7, 0, wm8940_boost_vol_tlv),
+};
+
+static const struct snd_kcontrol_new wm8940_micpga_controls[] = {
+        SOC_DAPM_SINGLE("AUX Switch", WM8940_INPUTCTL, 2, 1, 0),
+        SOC_DAPM_SINGLE("MICP Switch", WM8940_INPUTCTL, 0, 1, 0),
+        SOC_DAPM_SINGLE("MICN Switch", WM8940_INPUTCTL, 1, 1, 0),
+};
+
+static const struct snd_soc_dapm_widget wm8940_dapm_widgets[] = {
+        SND_SOC_DAPM_MIXER("Speaker Mixer", WM8940_POWER3, 2, 0,
+                           &wm8940_speaker_mixer_controls[0],
+                           ARRAY_SIZE(wm8940_speaker_mixer_controls)),
+        SND_SOC_DAPM_MIXER("Mono Mixer", WM8940_POWER3, 3, 0,
+                           &wm8940_mono_mixer_controls[0],
+                           ARRAY_SIZE(wm8940_mono_mixer_controls)),
+        SND_SOC_DAPM_DAC("DAC", "HiFi Playback", WM8940_POWER3, 0, 0),
+
+        SND_SOC_DAPM_PGA("SpkN Out", WM8940_POWER3, 5, 0, NULL, 0),
+        SND_SOC_DAPM_PGA("SpkP Out", WM8940_POWER3, 6, 0, NULL, 0),
+        SND_SOC_DAPM_PGA("Mono Out", WM8940_POWER3, 7, 0, NULL, 0),
+        SND_SOC_DAPM_OUTPUT("MONOOUT"),
+        SND_SOC_DAPM_OUTPUT("SPKOUTP"),
+        SND_SOC_DAPM_OUTPUT("SPKOUTN"),
+
+        SND_SOC_DAPM_PGA("Aux Input", WM8940_POWER1, 6, 0, NULL, 0),
+        SND_SOC_DAPM_ADC("ADC", "HiFi Capture", WM8940_POWER2, 0, 0),
+        SND_SOC_DAPM_MIXER("Mic PGA", WM8940_POWER2, 2, 0,
+                           &wm8940_micpga_controls[0],
+                           ARRAY_SIZE(wm8940_micpga_controls)),
+        SND_SOC_DAPM_MIXER("Boost Mixer", WM8940_POWER2, 4, 0,
+                           &wm8940_input_boost_controls[0],
+                           ARRAY_SIZE(wm8940_input_boost_controls)),
+        SND_SOC_DAPM_MICBIAS("Mic Bias", WM8940_POWER1, 4, 0),
+
+        SND_SOC_DAPM_INPUT("MICN"),
+        SND_SOC_DAPM_INPUT("MICP"),
+        SND_SOC_DAPM_INPUT("AUX"),
+};
+
+static const struct snd_soc_dapm_route audio_map[] = {
+        /* Mono output mixer */
+        {"Mono Mixer", "PCM Playback Switch", "DAC"},
+        {"Mono Mixer", "Aux Playback Switch", "Aux Input"},
+        {"Mono Mixer", "Line Bypass Switch", "Boost Mixer"},
+
+        /* Speaker output mixer */
+        {"Speaker Mixer", "PCM Playback Switch", "DAC"},
+        {"Speaker Mixer", "Aux Playback Switch", "Aux Input"},
+        {"Speaker Mixer", "Line Bypass Switch", "Boost Mixer"},
+
+        /* Outputs */
+        {"Mono Out", NULL, "Mono Mixer"},
+        {"MONOOUT", NULL, "Mono Out"},
+        {"SpkN Out", NULL, "Speaker Mixer"},
+        {"SpkP Out", NULL, "Speaker Mixer"},
+        {"SPKOUTN", NULL, "SpkN Out"},
+        {"SPKOUTP", NULL, "SpkP Out"},
+
+        /*  Microphone PGA */
+        {"Mic PGA", "MICN Switch", "MICN"},
+        {"Mic PGA", "MICP Switch", "MICP"},
+        {"Mic PGA", "AUX Switch", "AUX"},
+
+        /* Boost Mixer */
+        {"Boost Mixer", "Mic PGA Switch", "Mic PGA"},
+        {"Boost Mixer", "Mic Volume",  "MICP"},
+        {"Boost Mixer", "Aux Volume", "Aux Input"},
+
+        {"ADC", NULL, "Boost Mixer"},
+};
+
+static int wm8940_add_widgets(struct snd_soc_codec *codec)
+{
+        int ret;
+
+        ret = snd_soc_dapm_new_controls(codec, wm8940_dapm_widgets,
+                                        ARRAY_SIZE(wm8940_dapm_widgets));
+        if (ret)
+                goto error_ret;
+        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;
+}
+
+#define wm8940_reset(c) snd_soc_write(c, WM8940_SOFTRESET, 0);
+
+static int wm8940_set_dai_fmt(struct snd_soc_dai *codec_dai,
+                              unsigned int fmt)
+{
+        struct snd_soc_codec *codec = codec_dai->codec;
+        u16 iface = snd_soc_read(codec, WM8940_IFACE) & 0xFE67;
+        u16 clk = snd_soc_read(codec, WM8940_CLOCK) & 0x1fe;
+
+        switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
+        case SND_SOC_DAIFMT_CBM_CFM:
+                clk |= 1;
+                break;
+        case SND_SOC_DAIFMT_CBS_CFS:
+                break;
+        default:
+                return -EINVAL;
+        }
+        snd_soc_write(codec, WM8940_CLOCK, clk);
+
+        switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
+        case SND_SOC_DAIFMT_I2S:
+                iface |= (2 << 3);
+                break;
+        case SND_SOC_DAIFMT_LEFT_J:
+                iface |= (1 << 3);
+                break;
+        case SND_SOC_DAIFMT_RIGHT_J:
+                break;
+        case SND_SOC_DAIFMT_DSP_A:
+                iface |= (3 << 3);
+                break;
+        case SND_SOC_DAIFMT_DSP_B:
+                iface |= (3 << 3) | (1 << 7);
+                break;
+        }
+
+        switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
+        case SND_SOC_DAIFMT_NB_NF:
+                break;
+        case SND_SOC_DAIFMT_NB_IF:
+                iface |= (1 << 7);
+                break;
+        case SND_SOC_DAIFMT_IB_NF:
+                iface |= (1 << 8);
+                break;
+        case SND_SOC_DAIFMT_IB_IF:
+                iface |= (1 << 8) | (1 << 7);
+                break;
+        }
+
+        snd_soc_write(codec, WM8940_IFACE, iface);
+
+        return 0;
+}
+
+static int wm8940_i2s_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;
+        u16 iface = snd_soc_read(codec, WM8940_IFACE) & 0xFD9F;
+        u16 addcntrl = snd_soc_read(codec, WM8940_ADDCNTRL) & 0xFFF1;
+        u16 companding =  snd_soc_read(codec,
+                                                WM8940_COMPANDINGCTL) & 0xFFDF;
+        int ret;
+
+        /* LoutR control */
+        if (substream->stream == SNDRV_PCM_STREAM_CAPTURE
+            && params_channels(params) == 2)
+                iface |= (1 << 9);
+
+        switch (params_rate(params)) {
+        case SNDRV_PCM_RATE_8000:
+                addcntrl |= (0x5 << 1);
+                break;
+        case SNDRV_PCM_RATE_11025:
+                addcntrl |= (0x4 << 1);
+                break;
+        case SNDRV_PCM_RATE_16000:
+                addcntrl |= (0x3 << 1);
+                break;
+        case SNDRV_PCM_RATE_22050:
+                addcntrl |= (0x2 << 1);
+                break;
+        case SNDRV_PCM_RATE_32000:
+                addcntrl |= (0x1 << 1);
+                break;
+        case SNDRV_PCM_RATE_44100:
+        case SNDRV_PCM_RATE_48000:
+                break;
+        }
+        ret = snd_soc_write(codec, WM8940_ADDCNTRL, addcntrl);
+        if (ret)
+                goto error_ret;
+
+        switch (params_format(params)) {
+        case SNDRV_PCM_FORMAT_S8:
+                companding = companding | (1 << 5);
+                break;
+        case SNDRV_PCM_FORMAT_S16_LE:
+                break;
+        case SNDRV_PCM_FORMAT_S20_3LE:
+                iface |= (1 << 5);
+                break;
+        case SNDRV_PCM_FORMAT_S24_LE:
+                iface |= (2 << 5);
+                break;
+        case SNDRV_PCM_FORMAT_S32_LE:
+                iface |= (3 << 5);
+                break;
+        }
+        ret = snd_soc_write(codec, WM8940_COMPANDINGCTL, companding);
+        if (ret)
+                goto error_ret;
+        ret = snd_soc_write(codec, WM8940_IFACE, iface);
+
+error_ret:
+        return ret;
+}
+
+static int wm8940_mute(struct snd_soc_dai *dai, int mute)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        u16 mute_reg = snd_soc_read(codec, WM8940_DAC) & 0xffbf;
+
+        if (mute)
+                mute_reg |= 0x40;
+
+        return snd_soc_write(codec, WM8940_DAC, mute_reg);
+}
+
+static int wm8940_set_bias_level(struct snd_soc_codec *codec,
+                                 enum snd_soc_bias_level level)
+{
+        u16 val;
+        u16 pwr_reg = snd_soc_read(codec, WM8940_POWER1) & 0x1F0;
+        int ret = 0;
+
+        switch (level) {
+        case SND_SOC_BIAS_ON:
+                /* ensure bufioen and biasen */
+                pwr_reg |= (1 << 2) | (1 << 3);
+                /* Enable thermal shutdown */
+                val = snd_soc_read(codec, WM8940_OUTPUTCTL);
+                ret = snd_soc_write(codec, WM8940_OUTPUTCTL, val | 0x2);
+                if (ret)
+                        break;
+                /* set vmid to 75k */
+                ret = snd_soc_write(codec, WM8940_POWER1, pwr_reg | 0x1);
+                break;
+        case SND_SOC_BIAS_PREPARE:
+                /* ensure bufioen and biasen */
+                pwr_reg |= (1 << 2) | (1 << 3);
+                ret = snd_soc_write(codec, WM8940_POWER1, pwr_reg | 0x1);
+                break;
+        case SND_SOC_BIAS_STANDBY:
+                /* ensure bufioen and biasen */
+                pwr_reg |= (1 << 2) | (1 << 3);
+                /* set vmid to 300k for standby */
+                ret = snd_soc_write(codec, WM8940_POWER1, pwr_reg | 0x2);
+                break;
+        case SND_SOC_BIAS_OFF:
+                ret = snd_soc_write(codec, WM8940_POWER1, pwr_reg);
+                break;
+        }
+
+        return ret;
+}
+
+struct pll_ {
+        unsigned int pre_scale:2;
+        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)
+{
+        unsigned long long Kpart;
+        unsigned int K, Ndiv, Nmod;
+        /* The left shift ist to avoid accuracy loss when right shifting */
+        Ndiv = target / source;
+
+        if (Ndiv > 12) {
+                source <<= 1;
+                /* Multiply by 2 */
+                pll_div.pre_scale = 0;
+                Ndiv = target / source;
+        } else if (Ndiv < 3) {
+                source >>= 2;
+                /* Divide by 4 */
+                pll_div.pre_scale = 3;
+                Ndiv = target / source;
+        } else if (Ndiv < 6) {
+                source >>= 1;
+                /* divide by 2 */
+                pll_div.pre_scale = 2;
+                Ndiv = target / source;
+        } else
+                pll_div.pre_scale = 1;
+
+        if ((Ndiv < 6) || (Ndiv > 12))
+                printk(KERN_WARNING
+                        "WM8940 N value %d outwith recommended range!d\n",
+                        Ndiv);
+
+        pll_div.n = Ndiv;
+        Nmod = target % source;
+        Kpart = FIXED_PLL_SIZE * (long long)Nmod;
+
+        do_div(Kpart, source);
+
+        K = Kpart & 0xFFFFFFFF;
+
+        /* Check if we need to round */
+        if ((K % 10) >= 5)
+                K += 5;
+
+        /* Move down to proper range now rounding is done */
+        K /= 10;
+
+        pll_div.k = K;
+}
+
+/* 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)
+{
+        struct snd_soc_codec *codec = codec_dai->codec;
+        u16 reg;
+
+        /* Turn off PLL */
+        reg = snd_soc_read(codec, WM8940_POWER1);
+        snd_soc_write(codec, WM8940_POWER1, reg & 0x1df);
+
+        if (freq_in == 0 || freq_out == 0) {
+                /* Clock CODEC directly from MCLK */
+                reg = snd_soc_read(codec, WM8940_CLOCK);
+                snd_soc_write(codec, WM8940_CLOCK, reg & 0x0ff);
+                /* Pll power down */
+                snd_soc_write(codec, WM8940_PLLN, (1 << 7));
+                return 0;
+        }
+
+        /* Pll is followed by a frequency divide by 4 */
+        pll_factors(freq_out*4, freq_in);
+        if (pll_div.k)
+                snd_soc_write(codec, WM8940_PLLN,
+                             (pll_div.pre_scale << 4) | pll_div.n | (1 << 6));
+        else /* No factional component */
+                snd_soc_write(codec, WM8940_PLLN,
+                             (pll_div.pre_scale << 4) | pll_div.n);
+        snd_soc_write(codec, WM8940_PLLK1, pll_div.k >> 18);
+        snd_soc_write(codec, WM8940_PLLK2, (pll_div.k >> 9) & 0x1ff);
+        snd_soc_write(codec, WM8940_PLLK3, pll_div.k & 0x1ff);
+        /* Enable the PLL */
+        reg = snd_soc_read(codec, WM8940_POWER1);
+        snd_soc_write(codec, WM8940_POWER1, reg | 0x020);
+
+        /* Run CODEC from PLL instead of MCLK */
+        reg = snd_soc_read(codec, WM8940_CLOCK);
+        snd_soc_write(codec, WM8940_CLOCK, reg | 0x100);
+
+        return 0;
+}
+
+static int wm8940_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 wm8940_priv *wm8940 = codec->private_data;
+
+        switch (freq) {
+        case 11289600:
+        case 12000000:
+        case 12288000:
+        case 16934400:
+        case 18432000:
+                wm8940->sysclk = freq;
+                return 0;
+        }
+        return -EINVAL;
+}
+
+static int wm8940_set_dai_clkdiv(struct snd_soc_dai *codec_dai,
+                                 int div_id, int div)
+{
+        struct snd_soc_codec *codec = codec_dai->codec;
+        u16 reg;
+        int ret = 0;
+
+        switch (div_id) {
+        case WM8940_BCLKDIV:
+                reg = snd_soc_read(codec, WM8940_CLOCK) & 0xFFEF3;
+                ret = snd_soc_write(codec, WM8940_CLOCK, reg | (div << 2));
+                break;
+        case WM8940_MCLKDIV:
+                reg = snd_soc_read(codec, WM8940_CLOCK) & 0xFF1F;
+                ret = snd_soc_write(codec, WM8940_CLOCK, reg | (div << 5));
+                break;
+        case WM8940_OPCLKDIV:
+                reg = snd_soc_read(codec, WM8940_ADDCNTRL) & 0xFFCF;
+                ret = snd_soc_write(codec, WM8940_ADDCNTRL, reg | (div << 4));
+                break;
+        }
+        return ret;
+}
+
+#define WM8940_RATES SNDRV_PCM_RATE_8000_48000
+
+#define WM8940_FORMATS (SNDRV_PCM_FMTBIT_S8 |                           \
+                        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 wm8940_dai_ops = {
+        .hw_params = wm8940_i2s_hw_params,
+        .set_sysclk = wm8940_set_dai_sysclk,
+        .digital_mute = wm8940_mute,
+        .set_fmt = wm8940_set_dai_fmt,
+        .set_clkdiv = wm8940_set_dai_clkdiv,
+        .set_pll = wm8940_set_dai_pll,
+};
+
+struct snd_soc_dai wm8940_dai = {
+        .name = "WM8940",
+        .playback = {
+                .stream_name = "Playback",
+                .channels_min = 1,
+                .channels_max = 2,
+                .rates = WM8940_RATES,
+                .formats = WM8940_FORMATS,
+        },
+        .capture = {
+                .stream_name = "Capture",
+                .channels_min = 1,
+                .channels_max = 2,
+                .rates = WM8940_RATES,
+                .formats = WM8940_FORMATS,
+        },
+        .ops = &wm8940_dai_ops,
+        .symmetric_rates = 1,
+};
+EXPORT_SYMBOL_GPL(wm8940_dai);
+
+static int wm8940_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;
+
+        return wm8940_set_bias_level(codec, SND_SOC_BIAS_OFF);
+}
+
+static int wm8940_resume(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec = socdev->card->codec;
+        int i;
+        int ret;
+        u8 data[3];
+        u16 *cache = codec->reg_cache;
+
+        /* Sync reg_cache with the hardware
+         * Could use auto incremented writes to speed this up
+         */
+        for (i = 0; i < ARRAY_SIZE(wm8940_reg_defaults); i++) {
+                data[0] = i;
+                data[1] = (cache[i] & 0xFF00) >> 8;
+                data[2] = cache[i] & 0x00FF;
+                ret = codec->hw_write(codec->control_data, data, 3);
+                if (ret < 0)
+                        goto error_ret;
+                else if (ret != 3) {
+                        ret = -EIO;
+                        goto error_ret;
+                }
+        }
+        ret = wm8940_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+        if (ret)
+                goto error_ret;
+        ret = wm8940_set_bias_level(codec, codec->suspend_bias_level);
+
+error_ret:
+        return ret;
+}
+
+static struct snd_soc_codec *wm8940_codec;
+
+static int wm8940_probe(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec;
+
+        int ret = 0;
+
+        if (wm8940_codec == NULL) {
+                dev_err(&pdev->dev, "Codec device not registered\n");
+                return -ENODEV;
+        }
+
+        socdev->card->codec = wm8940_codec;
+        codec = wm8940_codec;
+
+        mutex_init(&codec->mutex);
+        /* 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;
+        }
+
+        ret = snd_soc_add_controls(codec, wm8940_snd_controls,
+                             ARRAY_SIZE(wm8940_snd_controls));
+        if (ret)
+                goto error_free_pcms;
+        ret = wm8940_add_widgets(codec);
+        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:
+        snd_soc_free_pcms(socdev);
+        snd_soc_dapm_free(socdev);
+pcm_err:
+        return ret;
+}
+
+static int wm8940_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_wm8940 = {
+        .probe = wm8940_probe,
+        .remove = wm8940_remove,
+        .suspend = wm8940_suspend,
+        .resume = wm8940_resume,
+};
+EXPORT_SYMBOL_GPL(soc_codec_dev_wm8940);
+
+static int wm8940_register(struct wm8940_priv *wm8940,
+                           enum snd_soc_control_type control)
+{
+        struct wm8940_setup_data *pdata = wm8940->codec.dev->platform_data;
+        struct snd_soc_codec *codec = &wm8940->codec;
+        int ret;
+        u16 reg;
+        if (wm8940_codec) {
+                dev_err(codec->dev, "Another WM8940 is registered\n");
+                return -EINVAL;
+        }
+
+        INIT_LIST_HEAD(&codec->dapm_widgets);
+        INIT_LIST_HEAD(&codec->dapm_paths);
+
+        codec->private_data = wm8940;
+        codec->name = "WM8940";
+        codec->owner = THIS_MODULE;
+        codec->bias_level = SND_SOC_BIAS_OFF;
+        codec->set_bias_level = wm8940_set_bias_level;
+        codec->dai = &wm8940_dai;
+        codec->num_dai = 1;
+        codec->reg_cache_size = ARRAY_SIZE(wm8940_reg_defaults);
+        codec->reg_cache = &wm8940->reg_cache;
+
+        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);
+                return ret;
+        }
+
+        memcpy(codec->reg_cache, wm8940_reg_defaults,
+               sizeof(wm8940_reg_defaults));
+
+        ret = wm8940_reset(codec);
+        if (ret < 0) {
+                dev_err(codec->dev, "Failed to issue reset\n");
+                return ret;
+        }
+
+        wm8940_dai.dev = codec->dev;
+
+        wm8940_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+
+        ret = snd_soc_write(codec, WM8940_POWER1, 0x180);
+        if (ret < 0)
+                return ret;
+
+        if (!pdata)
+                dev_warn(codec->dev, "No platform data supplied\n");
+        else {
+                reg = snd_soc_read(codec, WM8940_OUTPUTCTL);
+                ret = snd_soc_write(codec, WM8940_OUTPUTCTL, reg | pdata->vroi);
+                if (ret < 0)
+                        return ret;
+        }
+
+
+        wm8940_codec = codec;
+
+        ret = snd_soc_register_codec(codec);
+        if (ret) {
+                dev_err(codec->dev, "Failed to register codec: %d\n", ret);
+                return ret;
+        }
+
+        ret = snd_soc_register_dai(&wm8940_dai);
+        if (ret) {
+                dev_err(codec->dev, "Failed to register DAI: %d\n", ret);
+                snd_soc_unregister_codec(codec);
+                return ret;
+        }
+
+        return 0;
+}
+
+static void wm8940_unregister(struct wm8940_priv *wm8940)
+{
+        wm8940_set_bias_level(&wm8940->codec, SND_SOC_BIAS_OFF);
+        snd_soc_unregister_dai(&wm8940_dai);
+        snd_soc_unregister_codec(&wm8940->codec);
+        kfree(wm8940);
+        wm8940_codec = NULL;
+}
+
+static int wm8940_i2c_probe(struct i2c_client *i2c,
+                            const struct i2c_device_id *id)
+{
+        struct wm8940_priv *wm8940;
+        struct snd_soc_codec *codec;
+
+        wm8940 = kzalloc(sizeof *wm8940, GFP_KERNEL);
+        if (wm8940 == NULL)
+                return -ENOMEM;
+
+        codec = &wm8940->codec;
+        codec->hw_write = (hw_write_t)i2c_master_send;
+        i2c_set_clientdata(i2c, wm8940);
+        codec->control_data = i2c;
+        codec->dev = &i2c->dev;
+
+        return wm8940_register(wm8940, SND_SOC_I2C);
+}
+
+static int __devexit wm8940_i2c_remove(struct i2c_client *client)
+{
+        struct wm8940_priv *wm8940 = i2c_get_clientdata(client);
+
+        wm8940_unregister(wm8940);
+
+        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 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, wm8940_i2c_id);
+
+static struct i2c_driver wm8940_i2c_driver = {
+        .driver = {
+                .name = "WM8940 I2C Codec",
+                .owner = THIS_MODULE,
+        },
+        .probe = wm8940_i2c_probe,
+        .remove = __devexit_p(wm8940_i2c_remove),
+        .suspend = wm8940_i2c_suspend,
+        .resume = wm8940_i2c_resume,
+        .id_table = wm8940_i2c_id,
+};
+
+static int __init wm8940_modinit(void)
+{
+        int ret;
+
+        ret = i2c_add_driver(&wm8940_i2c_driver);
+        if (ret)
+                printk(KERN_ERR "Failed to register WM8940 I2C driver: %d\n",
+                       ret);
+        return ret;
+}
+module_init(wm8940_modinit);
+
+static void __exit wm8940_exit(void)
+{
+        i2c_del_driver(&wm8940_i2c_driver);
+}
+module_exit(wm8940_exit);
+
+MODULE_DESCRIPTION("ASoC WM8940 driver");
+MODULE_AUTHOR("Jonathan Cameron");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/codecs/wm8940.h b/sound/soc/codecs/wm8940.h
new file mode 100644
index 000000000000..8410eed3ef84
--- /dev/null
+++ b/sound/soc/codecs/wm8940.h
@@ -0,0 +1,104 @@
+/*
+ * wm8940.h -- WM8940 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 _WM8940_H
+#define _WM8940_H
+
+struct wm8940_setup_data {
+        /* Vref to analogue output resistance */
+#define WM8940_VROI_1K 0
+#define WM8940_VROI_30K 1
+        unsigned int vroi:1;
+};
+extern struct snd_soc_dai wm8940_dai;
+extern struct snd_soc_codec_device soc_codec_dev_wm8940;
+
+/* WM8940 register space */
+#define WM8940_SOFTRESET        0x00
+#define WM8940_POWER1           0x01
+#define WM8940_POWER2           0x02
+#define WM8940_POWER3           0x03
+#define WM8940_IFACE            0x04
+#define WM8940_COMPANDINGCTL    0x05
+#define WM8940_CLOCK            0x06
+#define WM8940_ADDCNTRL         0x07
+#define WM8940_GPIO             0x08
+#define WM8940_CTLINT           0x09
+#define WM8940_DAC              0x0A
+#define WM8940_DACVOL           0x0B
+
+#define WM8940_ADC              0x0E
+#define WM8940_ADCVOL           0x0F
+#define WM8940_NOTCH1           0x10
+#define WM8940_NOTCH2           0x11
+#define WM8940_NOTCH3           0x12
+#define WM8940_NOTCH4           0x13
+#define WM8940_NOTCH5           0x14
+#define WM8940_NOTCH6           0x15
+#define WM8940_NOTCH7           0x16
+#define WM8940_NOTCH8           0x17
+#define WM8940_DACLIM1          0x18
+#define WM8940_DACLIM2          0x19
+
+#define WM8940_ALC1             0x20
+#define WM8940_ALC2             0x21
+#define WM8940_ALC3             0x22
+#define WM8940_NOISEGATE        0x23
+#define WM8940_PLLN             0x24
+#define WM8940_PLLK1            0x25
+#define WM8940_PLLK2            0x26
+#define WM8940_PLLK3            0x27
+
+#define WM8940_ALC4             0x2A
+
+#define WM8940_INPUTCTL         0x2C
+#define WM8940_PGAGAIN          0x2D
+
+#define WM8940_ADCBOOST         0x2F
+
+#define WM8940_OUTPUTCTL        0x31
+#define WM8940_SPKMIX           0x32
+
+#define WM8940_SPKVOL           0x36
+
+#define WM8940_MONOMIX          0x38
+
+#define WM8940_CACHEREGNUM  0x57
+
+
+/* Clock divider Id's */
+#define WM8940_BCLKDIV 0
+#define WM8940_MCLKDIV 1
+#define WM8940_OPCLKDIV 2
+
+/* MCLK clock dividers */
+#define WM8940_MCLKDIV_1        0
+#define WM8940_MCLKDIV_1_5      1
+#define WM8940_MCLKDIV_2        2
+#define WM8940_MCLKDIV_3        3
+#define WM8940_MCLKDIV_4        4
+#define WM8940_MCLKDIV_6        5
+#define WM8940_MCLKDIV_8        6
+#define WM8940_MCLKDIV_12       7
+
+/* BCLK clock dividers */
+#define WM8940_BCLKDIV_1 0
+#define WM8940_BCLKDIV_2 1
+#define WM8940_BCLKDIV_4 2
+#define WM8940_BCLKDIV_8 3
+#define WM8940_BCLKDIV_16 4
+#define WM8940_BCLKDIV_32 5
+
+/* PLL Out Dividers */
+#define WM8940_OPCLKDIV_1 0
+#define WM8940_OPCLKDIV_2 1
+#define WM8940_OPCLKDIV_3 2
+#define WM8940_OPCLKDIV_4 3
+
+#endif /* _WM8940_H */
+
diff --git a/sound/soc/codecs/wm8960.c b/sound/soc/codecs/wm8960.c
new file mode 100644
index 000000000000..f59703be61c8
--- /dev/null
+++ b/sound/soc/codecs/wm8960.c
@@ -0,0 +1,942 @@
+/*
+ * wm8960.c  --  WM8960 ALSA SoC Audio driver
+ *
+ * Author: 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/moduleparam.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/pm.h>
+#include <linux/i2c.h>
+#include <linux/platform_device.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 "wm8960.h"
+
+#define AUDIO_NAME "wm8960"
+
+struct snd_soc_codec_device soc_codec_dev_wm8960;
+
+/* R25 - Power 1 */
+#define WM8960_VREF      0x40
+
+/* R28 - Anti-pop 1 */
+#define WM8960_POBCTRL   0x80
+#define WM8960_BUFDCOPEN 0x10
+#define WM8960_BUFIOEN   0x08
+#define WM8960_SOFT_ST   0x04
+#define WM8960_HPSTBY    0x01
+
+/* R29 - Anti-pop 2 */
+#define WM8960_DISOP     0x40
+
+/*
+ * wm8960 register cache
+ * We can't read the WM8960 register space when we are
+ * using 2 wire for device control, so we cache them instead.
+ */
+static const u16 wm8960_reg[WM8960_CACHEREGNUM] = {
+        0x0097, 0x0097, 0x0000, 0x0000,
+        0x0000, 0x0008, 0x0000, 0x000a,
+        0x01c0, 0x0000, 0x00ff, 0x00ff,
+        0x0000, 0x0000, 0x0000, 0x0000,
+        0x0000, 0x007b, 0x0100, 0x0032,
+        0x0000, 0x00c3, 0x00c3, 0x01c0,
+        0x0000, 0x0000, 0x0000, 0x0000,
+        0x0000, 0x0000, 0x0000, 0x0000,
+        0x0100, 0x0100, 0x0050, 0x0050,
+        0x0050, 0x0050, 0x0000, 0x0000,
+        0x0000, 0x0000, 0x0040, 0x0000,
+        0x0000, 0x0050, 0x0050, 0x0000,
+        0x0002, 0x0037, 0x004d, 0x0080,
+        0x0008, 0x0031, 0x0026, 0x00e9,
+};
+
+struct wm8960_priv {
+        u16 reg_cache[WM8960_CACHEREGNUM];
+        struct snd_soc_codec codec;
+};
+
+#define wm8960_reset(c) snd_soc_write(c, WM8960_RESET, 0)
+
+/* enumerated controls */
+static const char *wm8960_deemph[] = {"None", "32Khz", "44.1Khz", "48Khz"};
+static const char *wm8960_polarity[] = {"No Inversion", "Left Inverted",
+        "Right Inverted", "Stereo Inversion"};
+static const char *wm8960_3d_upper_cutoff[] = {"High", "Low"};
+static const char *wm8960_3d_lower_cutoff[] = {"Low", "High"};
+static const char *wm8960_alcfunc[] = {"Off", "Right", "Left", "Stereo"};
+static const char *wm8960_alcmode[] = {"ALC", "Limiter"};
+
+static const struct soc_enum wm8960_enum[] = {
+        SOC_ENUM_SINGLE(WM8960_DACCTL1, 1, 4, wm8960_deemph),
+        SOC_ENUM_SINGLE(WM8960_DACCTL1, 5, 4, wm8960_polarity),
+        SOC_ENUM_SINGLE(WM8960_DACCTL2, 5, 4, wm8960_polarity),
+        SOC_ENUM_SINGLE(WM8960_3D, 6, 2, wm8960_3d_upper_cutoff),
+        SOC_ENUM_SINGLE(WM8960_3D, 5, 2, wm8960_3d_lower_cutoff),
+        SOC_ENUM_SINGLE(WM8960_ALC1, 7, 4, wm8960_alcfunc),
+        SOC_ENUM_SINGLE(WM8960_ALC3, 8, 2, wm8960_alcmode),
+};
+
+static const DECLARE_TLV_DB_SCALE(adc_tlv, -9700, 50, 0);
+static const DECLARE_TLV_DB_SCALE(dac_tlv, -12700, 50, 1);
+static const DECLARE_TLV_DB_SCALE(bypass_tlv, -2100, 300, 0);
+static const DECLARE_TLV_DB_SCALE(out_tlv, -12100, 100, 1);
+
+static const struct snd_kcontrol_new wm8960_snd_controls[] = {
+SOC_DOUBLE_R_TLV("Capture Volume", WM8960_LINVOL, WM8960_RINVOL,
+                 0, 63, 0, adc_tlv),
+SOC_DOUBLE_R("Capture Volume ZC Switch", WM8960_LINVOL, WM8960_RINVOL,
+        6, 1, 0),
+SOC_DOUBLE_R("Capture Switch", WM8960_LINVOL, WM8960_RINVOL,
+        7, 1, 0),
+
+SOC_DOUBLE_R_TLV("Playback Volume", WM8960_LDAC, WM8960_RDAC,
+                 0, 255, 0, dac_tlv),
+
+SOC_DOUBLE_R_TLV("Headphone Playback Volume", WM8960_LOUT1, WM8960_ROUT1,
+                 0, 127, 0, out_tlv),
+SOC_DOUBLE_R("Headphone Playback ZC Switch", WM8960_LOUT1, WM8960_ROUT1,
+        7, 1, 0),
+
+SOC_DOUBLE_R_TLV("Speaker Playback Volume", WM8960_LOUT2, WM8960_ROUT2,
+                 0, 127, 0, out_tlv),
+SOC_DOUBLE_R("Speaker Playback ZC Switch", WM8960_LOUT2, WM8960_ROUT2,
+        7, 1, 0),
+SOC_SINGLE("Speaker DC Volume", WM8960_CLASSD3, 3, 5, 0),
+SOC_SINGLE("Speaker AC Volume", WM8960_CLASSD3, 0, 5, 0),
+
+SOC_SINGLE("PCM Playback -6dB Switch", WM8960_DACCTL1, 7, 1, 0),
+SOC_ENUM("ADC Polarity", wm8960_enum[1]),
+SOC_ENUM("Playback De-emphasis", wm8960_enum[0]),
+SOC_SINGLE("ADC High Pass Filter Switch", WM8960_DACCTL1, 0, 1, 0),
+
+SOC_ENUM("DAC Polarity", wm8960_enum[2]),
+
+SOC_ENUM("3D Filter Upper Cut-Off", wm8960_enum[3]),
+SOC_ENUM("3D Filter Lower Cut-Off", wm8960_enum[4]),
+SOC_SINGLE("3D Volume", WM8960_3D, 1, 15, 0),
+SOC_SINGLE("3D Switch", WM8960_3D, 0, 1, 0),
+
+SOC_ENUM("ALC Function", wm8960_enum[5]),
+SOC_SINGLE("ALC Max Gain", WM8960_ALC1, 4, 7, 0),
+SOC_SINGLE("ALC Target", WM8960_ALC1, 0, 15, 1),
+SOC_SINGLE("ALC Min Gain", WM8960_ALC2, 4, 7, 0),
+SOC_SINGLE("ALC Hold Time", WM8960_ALC2, 0, 15, 0),
+SOC_ENUM("ALC Mode", wm8960_enum[6]),
+SOC_SINGLE("ALC Decay", WM8960_ALC3, 4, 15, 0),
+SOC_SINGLE("ALC Attack", WM8960_ALC3, 0, 15, 0),
+
+SOC_SINGLE("Noise Gate Threshold", WM8960_NOISEG, 3, 31, 0),
+SOC_SINGLE("Noise Gate Switch", WM8960_NOISEG, 0, 1, 0),
+
+SOC_DOUBLE_R("ADC PCM Capture Volume", WM8960_LINPATH, WM8960_RINPATH,
+        0, 127, 0),
+
+SOC_SINGLE_TLV("Left Output Mixer Boost Bypass Volume",
+               WM8960_BYPASS1, 4, 7, 1, bypass_tlv),
+SOC_SINGLE_TLV("Left Output Mixer LINPUT3 Volume",
+               WM8960_LOUTMIX, 4, 7, 1, bypass_tlv),
+SOC_SINGLE_TLV("Right Output Mixer Boost Bypass Volume",
+               WM8960_BYPASS2, 4, 7, 1, bypass_tlv),
+SOC_SINGLE_TLV("Right Output Mixer RINPUT3 Volume",
+               WM8960_ROUTMIX, 4, 7, 1, bypass_tlv),
+};
+
+static const struct snd_kcontrol_new wm8960_lin_boost[] = {
+SOC_DAPM_SINGLE("LINPUT2 Switch", WM8960_LINPATH, 6, 1, 0),
+SOC_DAPM_SINGLE("LINPUT3 Switch", WM8960_LINPATH, 7, 1, 0),
+SOC_DAPM_SINGLE("LINPUT1 Switch", WM8960_LINPATH, 8, 1, 0),
+};
+
+static const struct snd_kcontrol_new wm8960_lin[] = {
+SOC_DAPM_SINGLE("Boost Switch", WM8960_LINPATH, 3, 1, 0),
+};
+
+static const struct snd_kcontrol_new wm8960_rin_boost[] = {
+SOC_DAPM_SINGLE("RINPUT2 Switch", WM8960_RINPATH, 6, 1, 0),
+SOC_DAPM_SINGLE("RINPUT3 Switch", WM8960_RINPATH, 7, 1, 0),
+SOC_DAPM_SINGLE("RINPUT1 Switch", WM8960_RINPATH, 8, 1, 0),
+};
+
+static const struct snd_kcontrol_new wm8960_rin[] = {
+SOC_DAPM_SINGLE("Boost Switch", WM8960_RINPATH, 3, 1, 0),
+};
+
+static const struct snd_kcontrol_new wm8960_loutput_mixer[] = {
+SOC_DAPM_SINGLE("PCM Playback Switch", WM8960_LOUTMIX, 8, 1, 0),
+SOC_DAPM_SINGLE("LINPUT3 Switch", WM8960_LOUTMIX, 7, 1, 0),
+SOC_DAPM_SINGLE("Boost Bypass Switch", WM8960_BYPASS1, 7, 1, 0),
+};
+
+static const struct snd_kcontrol_new wm8960_routput_mixer[] = {
+SOC_DAPM_SINGLE("PCM Playback Switch", WM8960_ROUTMIX, 8, 1, 0),
+SOC_DAPM_SINGLE("RINPUT3 Switch", WM8960_ROUTMIX, 7, 1, 0),
+SOC_DAPM_SINGLE("Boost Bypass Switch", WM8960_BYPASS2, 7, 1, 0),
+};
+
+static const struct snd_kcontrol_new wm8960_mono_out[] = {
+SOC_DAPM_SINGLE("Left Switch", WM8960_MONOMIX1, 7, 1, 0),
+SOC_DAPM_SINGLE("Right Switch", WM8960_MONOMIX2, 7, 1, 0),
+};
+
+static const struct snd_soc_dapm_widget wm8960_dapm_widgets[] = {
+SND_SOC_DAPM_INPUT("LINPUT1"),
+SND_SOC_DAPM_INPUT("RINPUT1"),
+SND_SOC_DAPM_INPUT("LINPUT2"),
+SND_SOC_DAPM_INPUT("RINPUT2"),
+SND_SOC_DAPM_INPUT("LINPUT3"),
+SND_SOC_DAPM_INPUT("RINPUT3"),
+
+SND_SOC_DAPM_MICBIAS("MICB", WM8960_POWER1, 1, 0),
+
+SND_SOC_DAPM_MIXER("Left Boost Mixer", WM8960_POWER1, 5, 0,
+                   wm8960_lin_boost, ARRAY_SIZE(wm8960_lin_boost)),
+SND_SOC_DAPM_MIXER("Right Boost Mixer", WM8960_POWER1, 4, 0,
+                   wm8960_rin_boost, ARRAY_SIZE(wm8960_rin_boost)),
+
+SND_SOC_DAPM_MIXER("Left Input Mixer", WM8960_POWER3, 5, 0,
+                   wm8960_lin, ARRAY_SIZE(wm8960_lin)),
+SND_SOC_DAPM_MIXER("Right Input Mixer", WM8960_POWER3, 4, 0,
+                   wm8960_rin, ARRAY_SIZE(wm8960_rin)),
+
+SND_SOC_DAPM_ADC("Left ADC", "Capture", WM8960_POWER2, 3, 0),
+SND_SOC_DAPM_ADC("Right ADC", "Capture", WM8960_POWER2, 2, 0),
+
+SND_SOC_DAPM_DAC("Left DAC", "Playback", WM8960_POWER2, 8, 0),
+SND_SOC_DAPM_DAC("Right DAC", "Playback", WM8960_POWER2, 7, 0),
+
+SND_SOC_DAPM_MIXER("Left Output Mixer", WM8960_POWER3, 3, 0,
+        &wm8960_loutput_mixer[0],
+        ARRAY_SIZE(wm8960_loutput_mixer)),
+SND_SOC_DAPM_MIXER("Right Output Mixer", WM8960_POWER3, 2, 0,
+        &wm8960_routput_mixer[0],
+        ARRAY_SIZE(wm8960_routput_mixer)),
+
+SND_SOC_DAPM_MIXER("Mono Output Mixer", WM8960_POWER2, 1, 0,
+        &wm8960_mono_out[0],
+        ARRAY_SIZE(wm8960_mono_out)),
+
+SND_SOC_DAPM_PGA("LOUT1 PGA", WM8960_POWER2, 6, 0, NULL, 0),
+SND_SOC_DAPM_PGA("ROUT1 PGA", WM8960_POWER2, 5, 0, NULL, 0),
+
+SND_SOC_DAPM_PGA("Left Speaker PGA", WM8960_POWER2, 4, 0, NULL, 0),
+SND_SOC_DAPM_PGA("Right Speaker PGA", WM8960_POWER2, 3, 0, NULL, 0),
+
+SND_SOC_DAPM_PGA("Right Speaker Output", WM8960_CLASSD1, 7, 0, NULL, 0),
+SND_SOC_DAPM_PGA("Left Speaker Output", WM8960_CLASSD1, 6, 0, NULL, 0),
+
+SND_SOC_DAPM_OUTPUT("SPK_LP"),
+SND_SOC_DAPM_OUTPUT("SPK_LN"),
+SND_SOC_DAPM_OUTPUT("HP_L"),
+SND_SOC_DAPM_OUTPUT("HP_R"),
+SND_SOC_DAPM_OUTPUT("SPK_RP"),
+SND_SOC_DAPM_OUTPUT("SPK_RN"),
+SND_SOC_DAPM_OUTPUT("OUT3"),
+};
+
+static const struct snd_soc_dapm_route audio_paths[] = {
+        { "Left Boost Mixer", "LINPUT1 Switch", "LINPUT1" },
+        { "Left Boost Mixer", "LINPUT2 Switch", "LINPUT2" },
+        { "Left Boost Mixer", "LINPUT3 Switch", "LINPUT3" },
+
+        { "Left Input Mixer", "Boost Switch", "Left Boost Mixer", },
+        { "Left Input Mixer", NULL, "LINPUT1", },  /* Really Boost Switch */
+        { "Left Input Mixer", NULL, "LINPUT2" },
+        { "Left Input Mixer", NULL, "LINPUT3" },
+
+        { "Right Boost Mixer", "RINPUT1 Switch", "RINPUT1" },
+        { "Right Boost Mixer", "RINPUT2 Switch", "RINPUT2" },
+        { "Right Boost Mixer", "RINPUT3 Switch", "RINPUT3" },
+
+        { "Right Input Mixer", "Boost Switch", "Right Boost Mixer", },
+        { "Right Input Mixer", NULL, "RINPUT1", },  /* Really Boost Switch */
+        { "Right Input Mixer", NULL, "RINPUT2" },
+        { "Right Input Mixer", NULL, "LINPUT3" },
+
+        { "Left ADC", NULL, "Left Input Mixer" },
+        { "Right ADC", NULL, "Right Input Mixer" },
+
+        { "Left Output Mixer", "LINPUT3 Switch", "LINPUT3" },
+        { "Left Output Mixer", "Boost Bypass Switch", "Left Boost Mixer"} ,
+        { "Left Output Mixer", "PCM Playback Switch", "Left DAC" },
+
+        { "Right Output Mixer", "RINPUT3 Switch", "RINPUT3" },
+        { "Right Output Mixer", "Boost Bypass Switch", "Right Boost Mixer" } ,
+        { "Right Output Mixer", "PCM Playback Switch", "Right DAC" },
+
+        { "Mono Output Mixer", "Left Switch", "Left Output Mixer" },
+        { "Mono Output Mixer", "Right Switch", "Right Output Mixer" },
+
+        { "LOUT1 PGA", NULL, "Left Output Mixer" },
+        { "ROUT1 PGA", NULL, "Right Output Mixer" },
+
+        { "HP_L", NULL, "LOUT1 PGA" },
+        { "HP_R", NULL, "ROUT1 PGA" },
+
+        { "Left Speaker PGA", NULL, "Left Output Mixer" },
+        { "Right Speaker PGA", NULL, "Right Output Mixer" },
+
+        { "Left Speaker Output", NULL, "Left Speaker PGA" },
+        { "Right Speaker Output", NULL, "Right Speaker PGA" },
+
+        { "SPK_LN", NULL, "Left Speaker Output" },
+        { "SPK_LP", NULL, "Left Speaker Output" },
+        { "SPK_RN", NULL, "Right Speaker Output" },
+        { "SPK_RP", NULL, "Right Speaker Output" },
+
+        { "OUT3", NULL, "Mono Output Mixer", }
+};
+
+static int wm8960_add_widgets(struct snd_soc_codec *codec)
+{
+        snd_soc_dapm_new_controls(codec, wm8960_dapm_widgets,
+                                  ARRAY_SIZE(wm8960_dapm_widgets));
+
+        snd_soc_dapm_add_routes(codec, audio_paths, ARRAY_SIZE(audio_paths));
+
+        snd_soc_dapm_new_widgets(codec);
+        return 0;
+}
+
+static int wm8960_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, WM8960_IFACE1, iface);
+        return 0;
+}
+
+static int wm8960_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;
+        u16 iface = snd_soc_read(codec, WM8960_IFACE1) & 0xfff3;
+
+        /* 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;
+        }
+
+        /* set iface */
+        snd_soc_write(codec, WM8960_IFACE1, iface);
+        return 0;
+}
+
+static int wm8960_mute(struct snd_soc_dai *dai, int mute)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        u16 mute_reg = snd_soc_read(codec, WM8960_DACCTL1) & 0xfff7;
+
+        if (mute)
+                snd_soc_write(codec, WM8960_DACCTL1, mute_reg | 0x8);
+        else
+                snd_soc_write(codec, WM8960_DACCTL1, mute_reg);
+        return 0;
+}
+
+static int wm8960_set_bias_level(struct snd_soc_codec *codec,
+                                 enum snd_soc_bias_level level)
+{
+        struct wm8960_data *pdata = codec->dev->platform_data;
+        u16 reg;
+
+        switch (level) {
+        case SND_SOC_BIAS_ON:
+                break;
+
+        case SND_SOC_BIAS_PREPARE:
+                /* Set VMID to 2x50k */
+                reg = snd_soc_read(codec, WM8960_POWER1);
+                reg &= ~0x180;
+                reg |= 0x80;
+                snd_soc_write(codec, WM8960_POWER1, reg);
+                break;
+
+        case SND_SOC_BIAS_STANDBY:
+                if (codec->bias_level == SND_SOC_BIAS_OFF) {
+                        /* Enable anti-pop features */
+                        snd_soc_write(codec, WM8960_APOP1,
+                                     WM8960_POBCTRL | WM8960_SOFT_ST |
+                                     WM8960_BUFDCOPEN | WM8960_BUFIOEN);
+
+                        /* Discharge HP output */
+                        reg = WM8960_DISOP;
+                        if (pdata)
+                                reg |= pdata->dres << 4;
+                        snd_soc_write(codec, WM8960_APOP2, reg);
+
+                        msleep(400);
+
+                        snd_soc_write(codec, WM8960_APOP2, 0);
+
+                        /* Enable & ramp VMID at 2x50k */
+                        reg = snd_soc_read(codec, WM8960_POWER1);
+                        reg |= 0x80;
+                        snd_soc_write(codec, WM8960_POWER1, reg);
+                        msleep(100);
+
+                        /* Enable VREF */
+                        snd_soc_write(codec, WM8960_POWER1, reg | WM8960_VREF);
+
+                        /* Disable anti-pop features */
+                        snd_soc_write(codec, WM8960_APOP1, WM8960_BUFIOEN);
+                }
+
+                /* Set VMID to 2x250k */
+                reg = snd_soc_read(codec, WM8960_POWER1);
+                reg &= ~0x180;
+                reg |= 0x100;
+                snd_soc_write(codec, WM8960_POWER1, reg);
+                break;
+
+        case SND_SOC_BIAS_OFF:
+                /* Enable anti-pop features */
+                snd_soc_write(codec, WM8960_APOP1,
+                             WM8960_POBCTRL | WM8960_SOFT_ST |
+                             WM8960_BUFDCOPEN | WM8960_BUFIOEN);
+
+                /* Disable VMID and VREF, let them discharge */
+                snd_soc_write(codec, WM8960_POWER1, 0);
+                msleep(600);
+
+                snd_soc_write(codec, WM8960_APOP1, 0);
+                break;
+        }
+
+        codec->bias_level = level;
+
+        return 0;
+}
+
+/* PLL divisors */
+struct _pll_div {
+        u32 pre_div:1;
+        u32 n:4;
+        u32 k:24;
+};
+
+/* The size in bits of the pll divide multiplied by 10
+ * to allow rounding later */
+#define FIXED_PLL_SIZE ((1 << 24) * 10)
+
+static int pll_factors(unsigned int source, unsigned int target,
+                       struct _pll_div *pll_div)
+{
+        unsigned long long Kpart;
+        unsigned int K, Ndiv, Nmod;
+
+        pr_debug("WM8960 PLL: setting %dHz->%dHz\n", source, target);
+
+        /* Scale up target to PLL operating frequency */
+        target *= 4;
+
+        Ndiv = target / source;
+        if (Ndiv < 6) {
+                source >>= 1;
+                pll_div->pre_div = 1;
+                Ndiv = target / source;
+        } else
+                pll_div->pre_div = 0;
+
+        if ((Ndiv < 6) || (Ndiv > 12)) {
+                pr_err("WM8960 PLL: Unsupported N=%d\n", Ndiv);
+                return -EINVAL;
+        }
+
+        pll_div->n = Ndiv;
+        Nmod = target % source;
+        Kpart = FIXED_PLL_SIZE * (long long)Nmod;
+
+        do_div(Kpart, source);
+
+        K = Kpart & 0xFFFFFFFF;
+
+        /* Check if we need to round */
+        if ((K % 10) >= 5)
+                K += 5;
+
+        /* Move down to proper range now rounding is done */
+        K /= 10;
+
+        pll_div->k = K;
+
+        pr_debug("WM8960 PLL: N=%x K=%x pre_div=%d\n",
+                 pll_div->n, pll_div->k, pll_div->pre_div);
+
+        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)
+{
+        struct snd_soc_codec *codec = codec_dai->codec;
+        u16 reg;
+        static struct _pll_div pll_div;
+        int ret;
+
+        if (freq_in && freq_out) {
+                ret = pll_factors(freq_in, freq_out, &pll_div);
+                if (ret != 0)
+                        return ret;
+        }
+
+        /* Disable the PLL: even if we are changing the frequency the
+         * PLL needs to be disabled while we do so. */
+        snd_soc_write(codec, WM8960_CLOCK1,
+                     snd_soc_read(codec, WM8960_CLOCK1) & ~1);
+        snd_soc_write(codec, WM8960_POWER2,
+                     snd_soc_read(codec, WM8960_POWER2) & ~1);
+
+        if (!freq_in || !freq_out)
+                return 0;
+
+        reg = snd_soc_read(codec, WM8960_PLL1) & ~0x3f;
+        reg |= pll_div.pre_div << 4;
+        reg |= pll_div.n;
+
+        if (pll_div.k) {
+                reg |= 0x20;
+
+                snd_soc_write(codec, WM8960_PLL2, (pll_div.k >> 18) & 0x3f);
+                snd_soc_write(codec, WM8960_PLL3, (pll_div.k >> 9) & 0x1ff);
+                snd_soc_write(codec, WM8960_PLL4, pll_div.k & 0x1ff);
+        }
+        snd_soc_write(codec, WM8960_PLL1, reg);
+
+        /* Turn it on */
+        snd_soc_write(codec, WM8960_POWER2,
+                     snd_soc_read(codec, WM8960_POWER2) | 1);
+        msleep(250);
+        snd_soc_write(codec, WM8960_CLOCK1,
+                     snd_soc_read(codec, WM8960_CLOCK1) | 1);
+
+        return 0;
+}
+
+static int wm8960_set_dai_clkdiv(struct snd_soc_dai *codec_dai,
+                int div_id, int div)
+{
+        struct snd_soc_codec *codec = codec_dai->codec;
+        u16 reg;
+
+        switch (div_id) {
+        case WM8960_SYSCLKSEL:
+                reg = snd_soc_read(codec, WM8960_CLOCK1) & 0x1fe;
+                snd_soc_write(codec, WM8960_CLOCK1, reg | div);
+                break;
+        case WM8960_SYSCLKDIV:
+                reg = snd_soc_read(codec, WM8960_CLOCK1) & 0x1f9;
+                snd_soc_write(codec, WM8960_CLOCK1, reg | div);
+                break;
+        case WM8960_DACDIV:
+                reg = snd_soc_read(codec, WM8960_CLOCK1) & 0x1c7;
+                snd_soc_write(codec, WM8960_CLOCK1, reg | div);
+                break;
+        case WM8960_OPCLKDIV:
+                reg = snd_soc_read(codec, WM8960_PLL1) & 0x03f;
+                snd_soc_write(codec, WM8960_PLL1, reg | div);
+                break;
+        case WM8960_DCLKDIV:
+                reg = snd_soc_read(codec, WM8960_CLOCK2) & 0x03f;
+                snd_soc_write(codec, WM8960_CLOCK2, reg | div);
+                break;
+        case WM8960_TOCLKSEL:
+                reg = snd_soc_read(codec, WM8960_ADDCTL1) & 0x1fd;
+                snd_soc_write(codec, WM8960_ADDCTL1, reg | div);
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+#define WM8960_RATES SNDRV_PCM_RATE_8000_48000
+
+#define WM8960_FORMATS \
+        (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE | \
+        SNDRV_PCM_FMTBIT_S24_LE)
+
+static struct snd_soc_dai_ops wm8960_dai_ops = {
+        .hw_params = wm8960_hw_params,
+        .digital_mute = wm8960_mute,
+        .set_fmt = wm8960_set_dai_fmt,
+        .set_clkdiv = wm8960_set_dai_clkdiv,
+        .set_pll = wm8960_set_dai_pll,
+};
+
+struct snd_soc_dai wm8960_dai = {
+        .name = "WM8960",
+        .playback = {
+                .stream_name = "Playback",
+                .channels_min = 1,
+                .channels_max = 2,
+                .rates = WM8960_RATES,
+                .formats = WM8960_FORMATS,},
+        .capture = {
+                .stream_name = "Capture",
+                .channels_min = 1,
+                .channels_max = 2,
+                .rates = WM8960_RATES,
+                .formats = WM8960_FORMATS,},
+        .ops = &wm8960_dai_ops,
+        .symmetric_rates = 1,
+};
+EXPORT_SYMBOL_GPL(wm8960_dai);
+
+static int wm8960_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;
+
+        wm8960_set_bias_level(codec, SND_SOC_BIAS_OFF);
+        return 0;
+}
+
+static int wm8960_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(wm8960_reg); i++) {
+                data[0] = (i << 1) | ((cache[i] >> 8) & 0x0001);
+                data[1] = cache[i] & 0x00ff;
+                codec->hw_write(codec->control_data, data, 2);
+        }
+
+        wm8960_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+        wm8960_set_bias_level(codec, codec->suspend_bias_level);
+        return 0;
+}
+
+static struct snd_soc_codec *wm8960_codec;
+
+static int wm8960_probe(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec;
+        int ret = 0;
+
+        if (wm8960_codec == NULL) {
+                dev_err(&pdev->dev, "Codec device not registered\n");
+                return -ENODEV;
+        }
+
+        socdev->card->codec = wm8960_codec;
+        codec = wm8960_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, 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;
+}
+
+/* power down chip */
+static int wm8960_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_wm8960 = {
+        .probe =        wm8960_probe,
+        .remove =       wm8960_remove,
+        .suspend =      wm8960_suspend,
+        .resume =       wm8960_resume,
+};
+EXPORT_SYMBOL_GPL(soc_codec_dev_wm8960);
+
+static int wm8960_register(struct wm8960_priv *wm8960,
+                           enum snd_soc_control_type control)
+{
+        struct wm8960_data *pdata = wm8960->codec.dev->platform_data;
+        struct snd_soc_codec *codec = &wm8960->codec;
+        int ret;
+        u16 reg;
+
+        if (wm8960_codec) {
+                dev_err(codec->dev, "Another WM8960 is registered\n");
+                ret = -EINVAL;
+                goto err;
+        }
+
+        if (!pdata) {
+                dev_warn(codec->dev, "No platform data supplied\n");
+        } else {
+                if (pdata->dres > WM8960_DRES_MAX) {
+                        dev_err(codec->dev, "Invalid DRES: %d\n", pdata->dres);
+                        pdata->dres = 0;
+                }
+        }
+
+        mutex_init(&codec->mutex);
+        INIT_LIST_HEAD(&codec->dapm_widgets);
+        INIT_LIST_HEAD(&codec->dapm_paths);
+
+        codec->private_data = wm8960;
+        codec->name = "WM8960";
+        codec->owner = THIS_MODULE;
+        codec->bias_level = SND_SOC_BIAS_OFF;
+        codec->set_bias_level = wm8960_set_bias_level;
+        codec->dai = &wm8960_dai;
+        codec->num_dai = 1;
+        codec->reg_cache_size = WM8960_CACHEREGNUM;
+        codec->reg_cache = &wm8960->reg_cache;
+
+        memcpy(codec->reg_cache, wm8960_reg, sizeof(wm8960_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 = wm8960_reset(codec);
+        if (ret < 0) {
+                dev_err(codec->dev, "Failed to issue reset\n");
+                goto err;
+        }
+
+        wm8960_dai.dev = codec->dev;
+
+        wm8960_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+
+        /* Latch the update bits */
+        reg = snd_soc_read(codec, WM8960_LINVOL);
+        snd_soc_write(codec, WM8960_LINVOL, reg | 0x100);
+        reg = snd_soc_read(codec, WM8960_RINVOL);
+        snd_soc_write(codec, WM8960_RINVOL, reg | 0x100);
+        reg = snd_soc_read(codec, WM8960_LADC);
+        snd_soc_write(codec, WM8960_LADC, reg | 0x100);
+        reg = snd_soc_read(codec, WM8960_RADC);
+        snd_soc_write(codec, WM8960_RADC, reg | 0x100);
+        reg = snd_soc_read(codec, WM8960_LDAC);
+        snd_soc_write(codec, WM8960_LDAC, reg | 0x100);
+        reg = snd_soc_read(codec, WM8960_RDAC);
+        snd_soc_write(codec, WM8960_RDAC, reg | 0x100);
+        reg = snd_soc_read(codec, WM8960_LOUT1);
+        snd_soc_write(codec, WM8960_LOUT1, reg | 0x100);
+        reg = snd_soc_read(codec, WM8960_ROUT1);
+        snd_soc_write(codec, WM8960_ROUT1, reg | 0x100);
+        reg = snd_soc_read(codec, WM8960_LOUT2);
+        snd_soc_write(codec, WM8960_LOUT2, reg | 0x100);
+        reg = snd_soc_read(codec, WM8960_ROUT2);
+        snd_soc_write(codec, WM8960_ROUT2, reg | 0x100);
+
+        wm8960_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(&wm8960_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(wm8960);
+        return ret;
+}
+
+static void wm8960_unregister(struct wm8960_priv *wm8960)
+{
+        wm8960_set_bias_level(&wm8960->codec, SND_SOC_BIAS_OFF);
+        snd_soc_unregister_dai(&wm8960_dai);
+        snd_soc_unregister_codec(&wm8960->codec);
+        kfree(wm8960);
+        wm8960_codec = NULL;
+}
+
+static __devinit int wm8960_i2c_probe(struct i2c_client *i2c,
+                                      const struct i2c_device_id *id)
+{
+        struct wm8960_priv *wm8960;
+        struct snd_soc_codec *codec;
+
+        wm8960 = kzalloc(sizeof(struct wm8960_priv), GFP_KERNEL);
+        if (wm8960 == NULL)
+                return -ENOMEM;
+
+        codec = &wm8960->codec;
+
+        i2c_set_clientdata(i2c, wm8960);
+        codec->control_data = i2c;
+
+        codec->dev = &i2c->dev;
+
+        return wm8960_register(wm8960, SND_SOC_I2C);
+}
+
+static __devexit int wm8960_i2c_remove(struct i2c_client *client)
+{
+        struct wm8960_priv *wm8960 = i2c_get_clientdata(client);
+        wm8960_unregister(wm8960);
+        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 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, wm8960_i2c_id);
+
+static struct i2c_driver wm8960_i2c_driver = {
+        .driver = {
+                .name = "WM8960 I2C Codec",
+                .owner = THIS_MODULE,
+        },
+        .probe =    wm8960_i2c_probe,
+        .remove =   __devexit_p(wm8960_i2c_remove),
+        .suspend =  wm8960_i2c_suspend,
+        .resume =   wm8960_i2c_resume,
+        .id_table = wm8960_i2c_id,
+};
+
+static int __init wm8960_modinit(void)
+{
+        int ret;
+
+        ret = i2c_add_driver(&wm8960_i2c_driver);
+        if (ret != 0) {
+                printk(KERN_ERR "Failed to register WM8960 I2C driver: %d\n",
+                       ret);
+        }
+
+        return ret;
+}
+module_init(wm8960_modinit);
+
+static void __exit wm8960_exit(void)
+{
+        i2c_del_driver(&wm8960_i2c_driver);
+}
+module_exit(wm8960_exit);
+
+
+MODULE_DESCRIPTION("ASoC WM8960 driver");
+MODULE_AUTHOR("Liam Girdwood");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/codecs/wm8960.h b/sound/soc/codecs/wm8960.h
new file mode 100644
index 000000000000..c9af56c9d9d4
--- /dev/null
+++ b/sound/soc/codecs/wm8960.h
@@ -0,0 +1,127 @@
+/*
+ * wm8960.h  --  WM8960 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 _WM8960_H
+#define _WM8960_H
+
+/* WM8960 register space */
+
+
+#define WM8960_CACHEREGNUM      56
+
+#define WM8960_LINVOL           0x0
+#define WM8960_RINVOL           0x1
+#define WM8960_LOUT1            0x2
+#define WM8960_ROUT1            0x3
+#define WM8960_CLOCK1           0x4
+#define WM8960_DACCTL1          0x5
+#define WM8960_DACCTL2          0x6
+#define WM8960_IFACE1           0x7
+#define WM8960_CLOCK2           0x8
+#define WM8960_IFACE2           0x9
+#define WM8960_LDAC             0xa
+#define WM8960_RDAC             0xb
+
+#define WM8960_RESET            0xf
+#define WM8960_3D               0x10
+#define WM8960_ALC1             0x11
+#define WM8960_ALC2             0x12
+#define WM8960_ALC3             0x13
+#define WM8960_NOISEG           0x14
+#define WM8960_LADC             0x15
+#define WM8960_RADC             0x16
+#define WM8960_ADDCTL1          0x17
+#define WM8960_ADDCTL2          0x18
+#define WM8960_POWER1           0x19
+#define WM8960_POWER2           0x1a
+#define WM8960_ADDCTL3          0x1b
+#define WM8960_APOP1            0x1c
+#define WM8960_APOP2            0x1d
+
+#define WM8960_LINPATH          0x20
+#define WM8960_RINPATH          0x21
+#define WM8960_LOUTMIX          0x22
+
+#define WM8960_ROUTMIX          0x25
+#define WM8960_MONOMIX1         0x26
+#define WM8960_MONOMIX2         0x27
+#define WM8960_LOUT2            0x28
+#define WM8960_ROUT2            0x29
+#define WM8960_MONO             0x2a
+#define WM8960_INBMIX1          0x2b
+#define WM8960_INBMIX2          0x2c
+#define WM8960_BYPASS1          0x2d
+#define WM8960_BYPASS2          0x2e
+#define WM8960_POWER3           0x2f
+#define WM8960_ADDCTL4          0x30
+#define WM8960_CLASSD1          0x31
+
+#define WM8960_CLASSD3          0x33
+#define WM8960_PLL1             0x34
+#define WM8960_PLL2             0x35
+#define WM8960_PLL3             0x36
+#define WM8960_PLL4             0x37
+
+
+/*
+ * WM8960 Clock dividers
+ */
+#define WM8960_SYSCLKDIV                0
+#define WM8960_DACDIV                   1
+#define WM8960_OPCLKDIV                 2
+#define WM8960_DCLKDIV                  3
+#define WM8960_TOCLKSEL                 4
+#define WM8960_SYSCLKSEL                5
+
+#define WM8960_SYSCLK_DIV_1             (0 << 1)
+#define WM8960_SYSCLK_DIV_2             (2 << 1)
+
+#define WM8960_SYSCLK_MCLK              (0 << 0)
+#define WM8960_SYSCLK_PLL               (1 << 0)
+
+#define WM8960_DAC_DIV_1                (0 << 3)
+#define WM8960_DAC_DIV_1_5              (1 << 3)
+#define WM8960_DAC_DIV_2                (2 << 3)
+#define WM8960_DAC_DIV_3                (3 << 3)
+#define WM8960_DAC_DIV_4                (4 << 3)
+#define WM8960_DAC_DIV_5_5              (5 << 3)
+#define WM8960_DAC_DIV_6                (6 << 3)
+
+#define WM8960_DCLK_DIV_1_5             (0 << 6)
+#define WM8960_DCLK_DIV_2               (1 << 6)
+#define WM8960_DCLK_DIV_3               (2 << 6)
+#define WM8960_DCLK_DIV_4               (3 << 6)
+#define WM8960_DCLK_DIV_6               (4 << 6)
+#define WM8960_DCLK_DIV_8               (5 << 6)
+#define WM8960_DCLK_DIV_12              (6 << 6)
+#define WM8960_DCLK_DIV_16              (7 << 6)
+
+#define WM8960_TOCLK_F19                (0 << 1)
+#define WM8960_TOCLK_F21                (1 << 1)
+
+#define WM8960_OPCLK_DIV_1              (0 << 0)
+#define WM8960_OPCLK_DIV_2              (1 << 0)
+#define WM8960_OPCLK_DIV_3              (2 << 0)
+#define WM8960_OPCLK_DIV_4              (3 << 0)
+#define WM8960_OPCLK_DIV_5_5            (4 << 0)
+#define WM8960_OPCLK_DIV_6              (5 << 0)
+
+extern struct snd_soc_dai wm8960_dai;
+extern struct snd_soc_codec_device soc_codec_dev_wm8960;
+
+#define WM8960_DRES_400R 0
+#define WM8960_DRES_200R 1
+#define WM8960_DRES_600R 2
+#define WM8960_DRES_150R 3
+#define WM8960_DRES_MAX  3
+
+struct wm8960_data {
+        int dres;
+};
+
+#endif
diff --git a/sound/soc/codecs/wm8961.c b/sound/soc/codecs/wm8961.c
new file mode 100644
index 000000000000..503032085899
--- /dev/null
+++ b/sound/soc/codecs/wm8961.c
@@ -0,0 +1,1265 @@
+/*
+ * wm8961.c  --  WM8961 ALSA SoC Audio driver
+ *
+ * Author: Mark Brown
+ *
+ * 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.
+ *
+ * Currently unimplemented features:
+ *  - ALC
+ */
+
+#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 <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 "wm8961.h"
+
+#define WM8961_MAX_REGISTER                     0xFC
+
+static u16 wm8961_reg_defaults[] = {
+        0x009F,     /* R0   - Left Input volume */
+        0x009F,     /* R1   - Right Input volume */
+        0x0000,     /* R2   - LOUT1 volume */
+        0x0000,     /* R3   - ROUT1 volume */
+        0x0020,     /* R4   - Clocking1 */
+        0x0008,     /* R5   - ADC & DAC Control 1 */
+        0x0000,     /* R6   - ADC & DAC Control 2 */
+        0x000A,     /* R7   - Audio Interface 0 */
+        0x01F4,     /* R8   - Clocking2 */
+        0x0000,     /* R9   - Audio Interface 1 */
+        0x00FF,     /* R10  - Left DAC volume */
+        0x00FF,     /* R11  - Right DAC volume */
+        0x0000,     /* R12 */
+        0x0000,     /* R13 */
+        0x0040,     /* R14  - Audio Interface 2 */
+        0x0000,     /* R15  - Software Reset */
+        0x0000,     /* R16 */
+        0x007B,     /* R17  - ALC1 */
+        0x0000,     /* R18  - ALC2 */
+        0x0032,     /* R19  - ALC3 */
+        0x0000,     /* R20  - Noise Gate */
+        0x00C0,     /* R21  - Left ADC volume */
+        0x00C0,     /* R22  - Right ADC volume */
+        0x0120,     /* R23  - Additional control(1) */
+        0x0000,     /* R24  - Additional control(2) */
+        0x0000,     /* R25  - Pwr Mgmt (1) */
+        0x0000,     /* R26  - Pwr Mgmt (2) */
+        0x0000,     /* R27  - Additional Control (3) */
+        0x0000,     /* R28  - Anti-pop */
+        0x0000,     /* R29 */
+        0x005F,     /* R30  - Clocking 3 */
+        0x0000,     /* R31 */
+        0x0000,     /* R32  - ADCL signal path */
+        0x0000,     /* R33  - ADCR signal path */
+        0x0000,     /* R34 */
+        0x0000,     /* R35 */
+        0x0000,     /* R36 */
+        0x0000,     /* R37 */
+        0x0000,     /* R38 */
+        0x0000,     /* R39 */
+        0x0000,     /* R40  - LOUT2 volume */
+        0x0000,     /* R41  - ROUT2 volume */
+        0x0000,     /* R42 */
+        0x0000,     /* R43 */
+        0x0000,     /* R44 */
+        0x0000,     /* R45 */
+        0x0000,     /* R46 */
+        0x0000,     /* R47  - Pwr Mgmt (3) */
+        0x0023,     /* R48  - Additional Control (4) */
+        0x0000,     /* R49  - Class D Control 1 */
+        0x0000,     /* R50 */
+        0x0003,     /* R51  - Class D Control 2 */
+        0x0000,     /* R52 */
+        0x0000,     /* R53 */
+        0x0000,     /* R54 */
+        0x0000,     /* R55 */
+        0x0106,     /* R56  - Clocking 4 */
+        0x0000,     /* R57  - DSP Sidetone 0 */
+        0x0000,     /* R58  - DSP Sidetone 1 */
+        0x0000,     /* R59 */
+        0x0000,     /* R60  - DC Servo 0 */
+        0x0000,     /* R61  - DC Servo 1 */
+        0x0000,     /* R62 */
+        0x015E,     /* R63  - DC Servo 3 */
+        0x0010,     /* R64 */
+        0x0010,     /* R65  - DC Servo 5 */
+        0x0000,     /* R66 */
+        0x0001,     /* R67 */
+        0x0003,     /* R68  - Analogue PGA Bias */
+        0x0000,     /* R69  - Analogue HP 0 */
+        0x0060,     /* R70 */
+        0x01FB,     /* R71  - Analogue HP 2 */
+        0x0000,     /* R72  - Charge Pump 1 */
+        0x0065,     /* R73 */
+        0x005F,     /* R74 */
+        0x0059,     /* R75 */
+        0x006B,     /* R76 */
+        0x0038,     /* R77 */
+        0x000C,     /* R78 */
+        0x000A,     /* R79 */
+        0x006B,     /* R80 */
+        0x0000,     /* R81 */
+        0x0000,     /* R82  - Charge Pump B */
+        0x0087,     /* R83 */
+        0x0000,     /* R84 */
+        0x005C,     /* R85 */
+        0x0000,     /* R86 */
+        0x0000,     /* R87  - Write Sequencer 1 */
+        0x0000,     /* R88  - Write Sequencer 2 */
+        0x0000,     /* R89  - Write Sequencer 3 */
+        0x0000,     /* R90  - Write Sequencer 4 */
+        0x0000,     /* R91  - Write Sequencer 5 */
+        0x0000,     /* R92  - Write Sequencer 6 */
+        0x0000,     /* R93  - Write Sequencer 7 */
+        0x0000,     /* R94 */
+        0x0000,     /* R95 */
+        0x0000,     /* R96 */
+        0x0000,     /* R97 */
+        0x0000,     /* R98 */
+        0x0000,     /* R99 */
+        0x0000,     /* R100 */
+        0x0000,     /* R101 */
+        0x0000,     /* R102 */
+        0x0000,     /* R103 */
+        0x0000,     /* R104 */
+        0x0000,     /* R105 */
+        0x0000,     /* R106 */
+        0x0000,     /* R107 */
+        0x0000,     /* R108 */
+        0x0000,     /* R109 */
+        0x0000,     /* R110 */
+        0x0000,     /* R111 */
+        0x0000,     /* R112 */
+        0x0000,     /* R113 */
+        0x0000,     /* R114 */
+        0x0000,     /* R115 */
+        0x0000,     /* R116 */
+        0x0000,     /* R117 */
+        0x0000,     /* R118 */
+        0x0000,     /* R119 */
+        0x0000,     /* R120 */
+        0x0000,     /* R121 */
+        0x0000,     /* R122 */
+        0x0000,     /* R123 */
+        0x0000,     /* R124 */
+        0x0000,     /* R125 */
+        0x0000,     /* R126 */
+        0x0000,     /* R127 */
+        0x0000,     /* R128 */
+        0x0000,     /* R129 */
+        0x0000,     /* R130 */
+        0x0000,     /* R131 */
+        0x0000,     /* R132 */
+        0x0000,     /* R133 */
+        0x0000,     /* R134 */
+        0x0000,     /* R135 */
+        0x0000,     /* R136 */
+        0x0000,     /* R137 */
+        0x0000,     /* R138 */
+        0x0000,     /* R139 */
+        0x0000,     /* R140 */
+        0x0000,     /* R141 */
+        0x0000,     /* R142 */
+        0x0000,     /* R143 */
+        0x0000,     /* R144 */
+        0x0000,     /* R145 */
+        0x0000,     /* R146 */
+        0x0000,     /* R147 */
+        0x0000,     /* R148 */
+        0x0000,     /* R149 */
+        0x0000,     /* R150 */
+        0x0000,     /* R151 */
+        0x0000,     /* R152 */
+        0x0000,     /* R153 */
+        0x0000,     /* R154 */
+        0x0000,     /* R155 */
+        0x0000,     /* R156 */
+        0x0000,     /* R157 */
+        0x0000,     /* R158 */
+        0x0000,     /* R159 */
+        0x0000,     /* R160 */
+        0x0000,     /* R161 */
+        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 */
+        0x0030,     /* R196 */
+        0x0006,     /* R197 */
+        0x0000,     /* R198 */
+        0x0060,     /* R199 */
+        0x0000,     /* R200 */
+        0x003F,     /* R201 */
+        0x0000,     /* R202 */
+        0x0000,     /* R203 */
+        0x0000,     /* R204 */
+        0x0001,     /* R205 */
+        0x0000,     /* R206 */
+        0x0181,     /* R207 */
+        0x0005,     /* R208 */
+        0x0008,     /* R209 */
+        0x0008,     /* R210 */
+        0x0000,     /* R211 */
+        0x013B,     /* R212 */
+        0x0000,     /* R213 */
+        0x0000,     /* R214 */
+        0x0000,     /* R215 */
+        0x0000,     /* R216 */
+        0x0070,     /* R217 */
+        0x0000,     /* R218 */
+        0x0000,     /* R219 */
+        0x0000,     /* R220 */
+        0x0000,     /* R221 */
+        0x0000,     /* R222 */
+        0x0003,     /* R223 */
+        0x0000,     /* R224 */
+        0x0000,     /* R225 */
+        0x0001,     /* R226 */
+        0x0008,     /* R227 */
+        0x0000,     /* R228 */
+        0x0000,     /* R229 */
+        0x0000,     /* R230 */
+        0x0000,     /* R231 */
+        0x0004,     /* R232 */
+        0x0000,     /* R233 */
+        0x0000,     /* R234 */
+        0x0000,     /* R235 */
+        0x0000,     /* R236 */
+        0x0000,     /* R237 */
+        0x0080,     /* R238 */
+        0x0000,     /* R239 */
+        0x0000,     /* R240 */
+        0x0000,     /* R241 */
+        0x0000,     /* R242 */
+        0x0000,     /* R243 */
+        0x0000,     /* R244 */
+        0x0052,     /* R245 */
+        0x0110,     /* R246 */
+        0x0040,     /* R247 */
+        0x0000,     /* R248 */
+        0x0030,     /* R249 */
+        0x0000,     /* R250 */
+        0x0000,     /* R251 */
+        0x0001,     /* R252 - General test 1 */
+};
+
+struct wm8961_priv {
+        struct snd_soc_codec codec;
+        int sysclk;
+        u16 reg_cache[WM8961_MAX_REGISTER];
+};
+
+static int wm8961_volatile_register(unsigned int reg)
+{
+        switch (reg) {
+        case WM8961_SOFTWARE_RESET:
+        case WM8961_WRITE_SEQUENCER_7:
+        case WM8961_DC_SERVO_1:
+                return 1;
+
+        default:
+                return 0;
+        }
+}
+
+static int wm8961_reset(struct snd_soc_codec *codec)
+{
+        return snd_soc_write(codec, WM8961_SOFTWARE_RESET, 0);
+}
+
+/*
+ * The headphone output supports special anti-pop sequences giving
+ * silent power up and power down.
+ */
+static int wm8961_hp_event(struct snd_soc_dapm_widget *w,
+                           struct snd_kcontrol *kcontrol, int event)
+{
+        struct snd_soc_codec *codec = w->codec;
+        u16 hp_reg = snd_soc_read(codec, WM8961_ANALOGUE_HP_0);
+        u16 cp_reg = snd_soc_read(codec, WM8961_CHARGE_PUMP_1);
+        u16 pwr_reg = snd_soc_read(codec, WM8961_PWR_MGMT_2);
+        u16 dcs_reg = snd_soc_read(codec, WM8961_DC_SERVO_1);
+        int timeout = 500;
+
+        if (event & SND_SOC_DAPM_POST_PMU) {
+                /* Make sure the output is shorted */
+                hp_reg &= ~(WM8961_HPR_RMV_SHORT | WM8961_HPL_RMV_SHORT);
+                snd_soc_write(codec, WM8961_ANALOGUE_HP_0, hp_reg);
+
+                /* Enable the charge pump */
+                cp_reg |= WM8961_CP_ENA;
+                snd_soc_write(codec, WM8961_CHARGE_PUMP_1, cp_reg);
+                mdelay(5);
+
+                /* Enable the PGA */
+                pwr_reg |= WM8961_LOUT1_PGA | WM8961_ROUT1_PGA;
+                snd_soc_write(codec, WM8961_PWR_MGMT_2, pwr_reg);
+
+                /* Enable the amplifier */
+                hp_reg |= WM8961_HPR_ENA | WM8961_HPL_ENA;
+                snd_soc_write(codec, WM8961_ANALOGUE_HP_0, hp_reg);
+
+                /* Second stage enable */
+                hp_reg |= WM8961_HPR_ENA_DLY | WM8961_HPL_ENA_DLY;
+                snd_soc_write(codec, WM8961_ANALOGUE_HP_0, hp_reg);
+
+                /* Enable the DC servo & trigger startup */
+                dcs_reg |=
+                        WM8961_DCS_ENA_CHAN_HPR | WM8961_DCS_TRIG_STARTUP_HPR |
+                        WM8961_DCS_ENA_CHAN_HPL | WM8961_DCS_TRIG_STARTUP_HPL;
+                dev_dbg(codec->dev, "Enabling DC servo\n");
+
+                snd_soc_write(codec, WM8961_DC_SERVO_1, dcs_reg);
+                do {
+                        msleep(1);
+                        dcs_reg = snd_soc_read(codec, WM8961_DC_SERVO_1);
+                } while (--timeout &&
+                         dcs_reg & (WM8961_DCS_TRIG_STARTUP_HPR |
+                                WM8961_DCS_TRIG_STARTUP_HPL));
+                if (dcs_reg & (WM8961_DCS_TRIG_STARTUP_HPR |
+                               WM8961_DCS_TRIG_STARTUP_HPL))
+                        dev_err(codec->dev, "DC servo timed out\n");
+                else
+                        dev_dbg(codec->dev, "DC servo startup complete\n");
+
+                /* Enable the output stage */
+                hp_reg |= WM8961_HPR_ENA_OUTP | WM8961_HPL_ENA_OUTP;
+                snd_soc_write(codec, WM8961_ANALOGUE_HP_0, hp_reg);
+
+                /* Remove the short on the output stage */
+                hp_reg |= WM8961_HPR_RMV_SHORT | WM8961_HPL_RMV_SHORT;
+                snd_soc_write(codec, WM8961_ANALOGUE_HP_0, hp_reg);
+        }
+
+        if (event & SND_SOC_DAPM_PRE_PMD) {
+                /* Short the output */
+                hp_reg &= ~(WM8961_HPR_RMV_SHORT | WM8961_HPL_RMV_SHORT);
+                snd_soc_write(codec, WM8961_ANALOGUE_HP_0, hp_reg);
+
+                /* Disable the output stage */
+                hp_reg &= ~(WM8961_HPR_ENA_OUTP | WM8961_HPL_ENA_OUTP);
+                snd_soc_write(codec, WM8961_ANALOGUE_HP_0, hp_reg);
+
+                /* Disable DC offset cancellation */
+                dcs_reg &= ~(WM8961_DCS_ENA_CHAN_HPR |
+                             WM8961_DCS_ENA_CHAN_HPL);
+                snd_soc_write(codec, WM8961_DC_SERVO_1, dcs_reg);
+
+                /* Finish up */
+                hp_reg &= ~(WM8961_HPR_ENA_DLY | WM8961_HPR_ENA |
+                            WM8961_HPL_ENA_DLY | WM8961_HPL_ENA);
+                snd_soc_write(codec, WM8961_ANALOGUE_HP_0, hp_reg);
+
+                /* Disable the PGA */
+                pwr_reg &= ~(WM8961_LOUT1_PGA | WM8961_ROUT1_PGA);
+                snd_soc_write(codec, WM8961_PWR_MGMT_2, pwr_reg);
+
+                /* Disable the charge pump */
+                dev_dbg(codec->dev, "Disabling charge pump\n");
+                snd_soc_write(codec, WM8961_CHARGE_PUMP_1,
+                             cp_reg & ~WM8961_CP_ENA);
+        }
+
+        return 0;
+}
+
+static int wm8961_spk_event(struct snd_soc_dapm_widget *w,
+                            struct snd_kcontrol *kcontrol, int event)
+{
+        struct snd_soc_codec *codec = w->codec;
+        u16 pwr_reg = snd_soc_read(codec, WM8961_PWR_MGMT_2);
+        u16 spk_reg = snd_soc_read(codec, WM8961_CLASS_D_CONTROL_1);
+
+        if (event & SND_SOC_DAPM_POST_PMU) {
+                /* Enable the PGA */
+                pwr_reg |= WM8961_SPKL_PGA | WM8961_SPKR_PGA;
+                snd_soc_write(codec, WM8961_PWR_MGMT_2, pwr_reg);
+
+                /* Enable the amplifier */
+                spk_reg |= WM8961_SPKL_ENA | WM8961_SPKR_ENA;
+                snd_soc_write(codec, WM8961_CLASS_D_CONTROL_1, spk_reg);
+        }
+
+        if (event & SND_SOC_DAPM_PRE_PMD) {
+                /* Enable the amplifier */
+                spk_reg &= ~(WM8961_SPKL_ENA | WM8961_SPKR_ENA);
+                snd_soc_write(codec, WM8961_CLASS_D_CONTROL_1, spk_reg);
+
+                /* Enable the PGA */
+                pwr_reg &= ~(WM8961_SPKL_PGA | WM8961_SPKR_PGA);
+                snd_soc_write(codec, WM8961_PWR_MGMT_2, pwr_reg);
+        }
+
+        return 0;
+}
+
+static const char *adc_hpf_text[] = {
+        "Hi-fi", "Voice 1", "Voice 2", "Voice 3",
+};
+
+static const struct soc_enum adc_hpf =
+        SOC_ENUM_SINGLE(WM8961_ADC_DAC_CONTROL_2, 7, 4, adc_hpf_text);
+
+static const char *dac_deemph_text[] = {
+        "None", "32kHz", "44.1kHz", "48kHz",
+};
+
+static const struct soc_enum dac_deemph =
+        SOC_ENUM_SINGLE(WM8961_ADC_DAC_CONTROL_1, 1, 4, dac_deemph_text);
+
+static const DECLARE_TLV_DB_SCALE(out_tlv, -12100, 100, 1);
+static const DECLARE_TLV_DB_SCALE(hp_sec_tlv, -700, 100, 0);
+static const DECLARE_TLV_DB_SCALE(adc_tlv, -7200, 75, 1);
+static const DECLARE_TLV_DB_SCALE(sidetone_tlv, -3600, 300, 0);
+static unsigned int boost_tlv[] = {
+        TLV_DB_RANGE_HEAD(4),
+        0, 0, TLV_DB_SCALE_ITEM(0,  0, 0),
+        1, 1, TLV_DB_SCALE_ITEM(13, 0, 0),
+        2, 2, TLV_DB_SCALE_ITEM(20, 0, 0),
+        3, 3, TLV_DB_SCALE_ITEM(29, 0, 0),
+};
+static const DECLARE_TLV_DB_SCALE(pga_tlv, -2325, 75, 0);
+
+static const struct snd_kcontrol_new wm8961_snd_controls[] = {
+SOC_DOUBLE_R_TLV("Headphone Volume", WM8961_LOUT1_VOLUME, WM8961_ROUT1_VOLUME,
+                 0, 127, 0, out_tlv),
+SOC_DOUBLE_TLV("Headphone Secondary Volume", WM8961_ANALOGUE_HP_2,
+               6, 3, 7, 0, hp_sec_tlv),
+SOC_DOUBLE_R("Headphone ZC Switch", WM8961_LOUT1_VOLUME, WM8961_ROUT1_VOLUME,
+             7, 1, 0),
+
+SOC_DOUBLE_R_TLV("Speaker Volume", WM8961_LOUT2_VOLUME, WM8961_ROUT2_VOLUME,
+                 0, 127, 0, out_tlv),
+SOC_DOUBLE_R("Speaker ZC Switch", WM8961_LOUT2_VOLUME, WM8961_ROUT2_VOLUME,
+           7, 1, 0),
+SOC_SINGLE("Speaker AC Gain", WM8961_CLASS_D_CONTROL_2, 0, 7, 0),
+
+SOC_SINGLE("DAC x128 OSR Switch", WM8961_ADC_DAC_CONTROL_2, 0, 1, 0),
+SOC_ENUM("DAC Deemphasis", dac_deemph),
+SOC_SINGLE("DAC Soft Mute Switch", WM8961_ADC_DAC_CONTROL_2, 3, 1, 0),
+
+SOC_DOUBLE_R_TLV("Sidetone Volume", WM8961_DSP_SIDETONE_0,
+                 WM8961_DSP_SIDETONE_1, 4, 12, 0, sidetone_tlv),
+
+SOC_SINGLE("ADC High Pass Filter Switch", WM8961_ADC_DAC_CONTROL_1, 0, 1, 0),
+SOC_ENUM("ADC High Pass Filter Mode", adc_hpf),
+
+SOC_DOUBLE_R_TLV("Capture Volume",
+                 WM8961_LEFT_ADC_VOLUME, WM8961_RIGHT_ADC_VOLUME,
+                 1, 119, 0, adc_tlv),
+SOC_DOUBLE_R_TLV("Capture Boost Volume",
+                 WM8961_ADCL_SIGNAL_PATH, WM8961_ADCR_SIGNAL_PATH,
+                 4, 3, 0, boost_tlv),
+SOC_DOUBLE_R_TLV("Capture PGA Volume",
+                 WM8961_LEFT_INPUT_VOLUME, WM8961_RIGHT_INPUT_VOLUME,
+                 0, 62, 0, pga_tlv),
+SOC_DOUBLE_R("Capture PGA ZC Switch",
+             WM8961_LEFT_INPUT_VOLUME, WM8961_RIGHT_INPUT_VOLUME,
+             6, 1, 1),
+SOC_DOUBLE_R("Capture PGA Switch",
+             WM8961_LEFT_INPUT_VOLUME, WM8961_RIGHT_INPUT_VOLUME,
+             7, 1, 1),
+};
+
+static const char *sidetone_text[] = {
+        "None", "Left", "Right"
+};
+
+static const struct soc_enum dacl_sidetone =
+        SOC_ENUM_SINGLE(WM8961_DSP_SIDETONE_0, 2, 3, sidetone_text);
+
+static const struct soc_enum dacr_sidetone =
+        SOC_ENUM_SINGLE(WM8961_DSP_SIDETONE_1, 2, 3, sidetone_text);
+
+static const struct snd_kcontrol_new dacl_mux =
+        SOC_DAPM_ENUM("DACL Sidetone", dacl_sidetone);
+
+static const struct snd_kcontrol_new dacr_mux =
+        SOC_DAPM_ENUM("DACR Sidetone", dacr_sidetone);
+
+static const struct snd_soc_dapm_widget wm8961_dapm_widgets[] = {
+SND_SOC_DAPM_INPUT("LINPUT"),
+SND_SOC_DAPM_INPUT("RINPUT"),
+
+SND_SOC_DAPM_SUPPLY("CLK_DSP", WM8961_CLOCKING2, 4, 0, NULL, 0),
+
+SND_SOC_DAPM_PGA("Left Input", WM8961_PWR_MGMT_1, 5, 0, NULL, 0),
+SND_SOC_DAPM_PGA("Right Input", WM8961_PWR_MGMT_1, 4, 0, NULL, 0),
+
+SND_SOC_DAPM_ADC("ADCL", "HiFi Capture", WM8961_PWR_MGMT_1, 3, 0),
+SND_SOC_DAPM_ADC("ADCR", "HiFi Capture", WM8961_PWR_MGMT_1, 2, 0),
+
+SND_SOC_DAPM_MICBIAS("MICBIAS", WM8961_PWR_MGMT_1, 1, 0),
+
+SND_SOC_DAPM_MUX("DACL Sidetone", SND_SOC_NOPM, 0, 0, &dacl_mux),
+SND_SOC_DAPM_MUX("DACR Sidetone", SND_SOC_NOPM, 0, 0, &dacr_mux),
+
+SND_SOC_DAPM_DAC("DACL", "HiFi Playback", WM8961_PWR_MGMT_2, 8, 0),
+SND_SOC_DAPM_DAC("DACR", "HiFi Playback", WM8961_PWR_MGMT_2, 7, 0),
+
+/* Handle as a mono path for DCS */
+SND_SOC_DAPM_PGA_E("Headphone Output", SND_SOC_NOPM,
+                   4, 0, NULL, 0, wm8961_hp_event,
+                   SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
+SND_SOC_DAPM_PGA_E("Speaker Output", SND_SOC_NOPM,
+                   4, 0, NULL, 0, wm8961_spk_event,
+                   SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
+
+SND_SOC_DAPM_OUTPUT("HP_L"),
+SND_SOC_DAPM_OUTPUT("HP_R"),
+SND_SOC_DAPM_OUTPUT("SPK_LN"),
+SND_SOC_DAPM_OUTPUT("SPK_LP"),
+SND_SOC_DAPM_OUTPUT("SPK_RN"),
+SND_SOC_DAPM_OUTPUT("SPK_RP"),
+};
+
+
+static const struct snd_soc_dapm_route audio_paths[] = {
+        { "DACL", NULL, "CLK_DSP" },
+        { "DACL", NULL, "DACL Sidetone" },
+        { "DACR", NULL, "CLK_DSP" },
+        { "DACR", NULL, "DACR Sidetone" },
+
+        { "DACL Sidetone", "Left", "ADCL" },
+        { "DACL Sidetone", "Right", "ADCR" },
+
+        { "DACR Sidetone", "Left", "ADCL" },
+        { "DACR Sidetone", "Right", "ADCR" },
+
+        { "HP_L", NULL, "Headphone Output" },
+        { "HP_R", NULL, "Headphone Output" },
+        { "Headphone Output", NULL, "DACL" },
+        { "Headphone Output", NULL, "DACR" },
+
+        { "SPK_LN", NULL, "Speaker Output" },
+        { "SPK_LP", NULL, "Speaker Output" },
+        { "SPK_RN", NULL, "Speaker Output" },
+        { "SPK_RP", NULL, "Speaker Output" },
+
+        { "Speaker Output", NULL, "DACL" },
+        { "Speaker Output", NULL, "DACR" },
+
+        { "ADCL", NULL, "Left Input" },
+        { "ADCL", NULL, "CLK_DSP" },
+        { "ADCR", NULL, "Right Input" },
+        { "ADCR", NULL, "CLK_DSP" },
+
+        { "Left Input", NULL, "LINPUT" },
+        { "Right Input", NULL, "RINPUT" },
+
+};
+
+/* Values for CLK_SYS_RATE */
+static struct {
+        int ratio;
+        u16 val;
+} wm8961_clk_sys_ratio[] = {
+        {  64,  0 },
+        {  128, 1 },
+        {  192, 2 },
+        {  256, 3 },
+        {  384, 4 },
+        {  512, 5 },
+        {  768, 6 },
+        { 1024, 7 },
+        { 1408, 8 },
+        { 1536, 9 },
+};
+
+/* Values for SAMPLE_RATE */
+static struct {
+        int rate;
+        u16 val;
+} wm8961_srate[] = {
+        { 48000, 0 },
+        { 44100, 0 },
+        { 32000, 1 },
+        { 22050, 2 },
+        { 24000, 2 },
+        { 16000, 3 },
+        { 11250, 4 },
+        { 12000, 4 },
+        {  8000, 5 },
+};
+
+static int wm8961_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 wm8961_priv *wm8961 = codec->private_data;
+        int i, best, target, fs;
+        u16 reg;
+
+        fs = params_rate(params);
+
+        if (!wm8961->sysclk) {
+                dev_err(codec->dev, "MCLK has not been specified\n");
+                return -EINVAL;
+        }
+
+        /* Find the closest sample rate for the filters */
+        best = 0;
+        for (i = 0; i < ARRAY_SIZE(wm8961_srate); i++) {
+                if (abs(wm8961_srate[i].rate - fs) <
+                    abs(wm8961_srate[best].rate - fs))
+                        best = i;
+        }
+        reg = snd_soc_read(codec, WM8961_ADDITIONAL_CONTROL_3);
+        reg &= ~WM8961_SAMPLE_RATE_MASK;
+        reg |= wm8961_srate[best].val;
+        snd_soc_write(codec, WM8961_ADDITIONAL_CONTROL_3, reg);
+        dev_dbg(codec->dev, "Selected SRATE %dHz for %dHz\n",
+                wm8961_srate[best].rate, fs);
+
+        /* Select a CLK_SYS/fs ratio equal to or higher than required */
+        target = wm8961->sysclk / fs;
+
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && target < 64) {
+                dev_err(codec->dev,
+                        "SYSCLK must be at least 64*fs for DAC\n");
+                return -EINVAL;
+        }
+        if (substream->stream == SNDRV_PCM_STREAM_CAPTURE && target < 256) {
+                dev_err(codec->dev,
+                        "SYSCLK must be at least 256*fs for ADC\n");
+                return -EINVAL;
+        }
+
+        for (i = 0; i < ARRAY_SIZE(wm8961_clk_sys_ratio); i++) {
+                if (wm8961_clk_sys_ratio[i].ratio >= target)
+                        break;
+        }
+        if (i == ARRAY_SIZE(wm8961_clk_sys_ratio)) {
+                dev_err(codec->dev, "Unable to generate CLK_SYS_RATE\n");
+                return -EINVAL;
+        }
+        dev_dbg(codec->dev, "Selected CLK_SYS_RATE of %d for %d/%d=%d\n",
+                wm8961_clk_sys_ratio[i].ratio, wm8961->sysclk, fs,
+                wm8961->sysclk / fs);
+
+        reg = snd_soc_read(codec, WM8961_CLOCKING_4);
+        reg &= ~WM8961_CLK_SYS_RATE_MASK;
+        reg |= wm8961_clk_sys_ratio[i].val << WM8961_CLK_SYS_RATE_SHIFT;
+        snd_soc_write(codec, WM8961_CLOCKING_4, reg);
+
+        reg = snd_soc_read(codec, WM8961_AUDIO_INTERFACE_0);
+        reg &= ~WM8961_WL_MASK;
+        switch (params_format(params)) {
+        case SNDRV_PCM_FORMAT_S16_LE:
+                break;
+        case SNDRV_PCM_FORMAT_S20_3LE:
+                reg |= 1 << WM8961_WL_SHIFT;
+                break;
+        case SNDRV_PCM_FORMAT_S24_LE:
+                reg |= 2 << WM8961_WL_SHIFT;
+                break;
+        case SNDRV_PCM_FORMAT_S32_LE:
+                reg |= 3 << WM8961_WL_SHIFT;
+                break;
+        default:
+                return -EINVAL;
+        }
+        snd_soc_write(codec, WM8961_AUDIO_INTERFACE_0, reg);
+
+        /* Sloping stop-band filter is recommended for <= 24kHz */
+        reg = snd_soc_read(codec, WM8961_ADC_DAC_CONTROL_2);
+        if (fs <= 24000)
+                reg |= WM8961_DACSLOPE;
+        else
+                reg &= WM8961_DACSLOPE;
+        snd_soc_write(codec, WM8961_ADC_DAC_CONTROL_2, reg);
+
+        return 0;
+}
+
+static int wm8961_set_sysclk(struct snd_soc_dai *dai, int clk_id,
+                             unsigned int freq,
+                             int dir)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        struct wm8961_priv *wm8961 = codec->private_data;
+        u16 reg = snd_soc_read(codec, WM8961_CLOCKING1);
+
+        if (freq > 33000000) {
+                dev_err(codec->dev, "MCLK must be <33MHz\n");
+                return -EINVAL;
+        }
+
+        if (freq > 16500000) {
+                dev_dbg(codec->dev, "Using MCLK/2 for %dHz MCLK\n", freq);
+                reg |= WM8961_MCLKDIV;
+                freq /= 2;
+        } else {
+                dev_dbg(codec->dev, "Using MCLK/1 for %dHz MCLK\n", freq);
+                reg &= WM8961_MCLKDIV;
+        }
+
+        snd_soc_write(codec, WM8961_CLOCKING1, reg);
+
+        wm8961->sysclk = freq;
+
+        return 0;
+}
+
+static int wm8961_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        u16 aif = snd_soc_read(codec, WM8961_AUDIO_INTERFACE_0);
+
+        aif &= ~(WM8961_BCLKINV | WM8961_LRP |
+                 WM8961_MS | WM8961_FORMAT_MASK);
+
+        switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
+        case SND_SOC_DAIFMT_CBM_CFM:
+                aif |= WM8961_MS;
+                break;
+        case SND_SOC_DAIFMT_CBS_CFS:
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
+        case SND_SOC_DAIFMT_RIGHT_J:
+                break;
+
+        case SND_SOC_DAIFMT_LEFT_J:
+                aif |= 1;
+                break;
+
+        case SND_SOC_DAIFMT_I2S:
+                aif |= 2;
+                break;
+
+        case SND_SOC_DAIFMT_DSP_B:
+                aif |= WM8961_LRP;
+        case SND_SOC_DAIFMT_DSP_A:
+                aif |= 3;
+                switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
+                case SND_SOC_DAIFMT_NB_NF:
+                case SND_SOC_DAIFMT_IB_NF:
+                        break;
+                default:
+                        return -EINVAL;
+                }
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
+        case SND_SOC_DAIFMT_NB_NF:
+                break;
+        case SND_SOC_DAIFMT_NB_IF:
+                aif |= WM8961_LRP;
+                break;
+        case SND_SOC_DAIFMT_IB_NF:
+                aif |= WM8961_BCLKINV;
+                break;
+        case SND_SOC_DAIFMT_IB_IF:
+                aif |= WM8961_BCLKINV | WM8961_LRP;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return snd_soc_write(codec, WM8961_AUDIO_INTERFACE_0, aif);
+}
+
+static int wm8961_set_tristate(struct snd_soc_dai *dai, int tristate)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        u16 reg = snd_soc_read(codec, WM8961_ADDITIONAL_CONTROL_2);
+
+        if (tristate)
+                reg |= WM8961_TRIS;
+        else
+                reg &= ~WM8961_TRIS;
+
+        return snd_soc_write(codec, WM8961_ADDITIONAL_CONTROL_2, reg);
+}
+
+static int wm8961_digital_mute(struct snd_soc_dai *dai, int mute)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        u16 reg = snd_soc_read(codec, WM8961_ADC_DAC_CONTROL_1);
+
+        if (mute)
+                reg |= WM8961_DACMU;
+        else
+                reg &= ~WM8961_DACMU;
+
+        msleep(17);
+
+        return snd_soc_write(codec, WM8961_ADC_DAC_CONTROL_1, reg);
+}
+
+static int wm8961_set_clkdiv(struct snd_soc_dai *dai, int div_id, int div)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        u16 reg;
+
+        switch (div_id) {
+        case WM8961_BCLK:
+                reg = snd_soc_read(codec, WM8961_CLOCKING2);
+                reg &= ~WM8961_BCLKDIV_MASK;
+                reg |= div;
+                snd_soc_write(codec, WM8961_CLOCKING2, reg);
+                break;
+
+        case WM8961_LRCLK:
+                reg = snd_soc_read(codec, WM8961_AUDIO_INTERFACE_2);
+                reg &= ~WM8961_LRCLK_RATE_MASK;
+                reg |= div;
+                snd_soc_write(codec, WM8961_AUDIO_INTERFACE_2, reg);
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int wm8961_set_bias_level(struct snd_soc_codec *codec,
+                                 enum snd_soc_bias_level level)
+{
+        u16 reg;
+
+        /* This is all slightly unusual since we have no bypass paths
+         * and the output amplifier structure means we can just slam
+         * the biases straight up rather than having to ramp them
+         * slowly.
+         */
+        switch (level) {
+        case SND_SOC_BIAS_ON:
+                break;
+
+        case SND_SOC_BIAS_PREPARE:
+                if (codec->bias_level == SND_SOC_BIAS_STANDBY) {
+                        /* Enable bias generation */
+                        reg = snd_soc_read(codec, WM8961_ANTI_POP);
+                        reg |= WM8961_BUFIOEN | WM8961_BUFDCOPEN;
+                        snd_soc_write(codec, WM8961_ANTI_POP, reg);
+
+                        /* VMID=2*50k, VREF */
+                        reg = snd_soc_read(codec, WM8961_PWR_MGMT_1);
+                        reg &= ~WM8961_VMIDSEL_MASK;
+                        reg |= (1 << WM8961_VMIDSEL_SHIFT) | WM8961_VREF;
+                        snd_soc_write(codec, WM8961_PWR_MGMT_1, reg);
+                }
+                break;
+
+        case SND_SOC_BIAS_STANDBY:
+                if (codec->bias_level == SND_SOC_BIAS_PREPARE) {
+                        /* VREF off */
+                        reg = snd_soc_read(codec, WM8961_PWR_MGMT_1);
+                        reg &= ~WM8961_VREF;
+                        snd_soc_write(codec, WM8961_PWR_MGMT_1, reg);
+
+                        /* Bias generation off */
+                        reg = snd_soc_read(codec, WM8961_ANTI_POP);
+                        reg &= ~(WM8961_BUFIOEN | WM8961_BUFDCOPEN);
+                        snd_soc_write(codec, WM8961_ANTI_POP, reg);
+
+                        /* VMID off */
+                        reg = snd_soc_read(codec, WM8961_PWR_MGMT_1);
+                        reg &= ~WM8961_VMIDSEL_MASK;
+                        snd_soc_write(codec, WM8961_PWR_MGMT_1, reg);
+                }
+                break;
+
+        case SND_SOC_BIAS_OFF:
+                break;
+        }
+
+        codec->bias_level = level;
+
+        return 0;
+}
+
+
+#define WM8961_RATES SNDRV_PCM_RATE_8000_48000
+
+#define WM8961_FORMATS \
+        (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE | \
+        SNDRV_PCM_FMTBIT_S24_LE)
+
+static struct snd_soc_dai_ops wm8961_dai_ops = {
+        .hw_params = wm8961_hw_params,
+        .set_sysclk = wm8961_set_sysclk,
+        .set_fmt = wm8961_set_fmt,
+        .digital_mute = wm8961_digital_mute,
+        .set_tristate = wm8961_set_tristate,
+        .set_clkdiv = wm8961_set_clkdiv,
+};
+
+struct snd_soc_dai wm8961_dai = {
+        .name = "WM8961",
+        .playback = {
+                .stream_name = "HiFi Playback",
+                .channels_min = 1,
+                .channels_max = 2,
+                .rates = WM8961_RATES,
+                .formats = WM8961_FORMATS,},
+        .capture = {
+                .stream_name = "HiFi Capture",
+                .channels_min = 1,
+                .channels_max = 2,
+                .rates = WM8961_RATES,
+                .formats = WM8961_FORMATS,},
+        .ops = &wm8961_dai_ops,
+};
+EXPORT_SYMBOL_GPL(wm8961_dai);
+
+
+static struct snd_soc_codec *wm8961_codec;
+
+static int wm8961_probe(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec;
+        int ret = 0;
+
+        if (wm8961_codec == NULL) {
+                dev_err(&pdev->dev, "Codec device not registered\n");
+                return -ENODEV;
+        }
+
+        socdev->card->codec = wm8961_codec;
+        codec = wm8961_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, wm8961_snd_controls,
+                                ARRAY_SIZE(wm8961_snd_controls));
+        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;
+}
+
+static int wm8961_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;
+}
+
+#ifdef CONFIG_PM
+static int wm8961_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;
+
+        wm8961_set_bias_level(codec, SND_SOC_BIAS_OFF);
+
+        return 0;
+}
+
+static int wm8961_resume(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec = socdev->card->codec;
+        u16 *reg_cache = codec->reg_cache;
+        int i;
+
+        for (i = 0; i < codec->reg_cache_size; i++) {
+                if (i == WM8961_SOFTWARE_RESET)
+                        continue;
+
+                snd_soc_write(codec, i, reg_cache[i]);
+        }
+
+        wm8961_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+
+        return 0;
+}
+#else
+#define wm8961_suspend NULL
+#define wm8961_resume NULL
+#endif
+
+struct snd_soc_codec_device soc_codec_dev_wm8961 = {
+        .probe =        wm8961_probe,
+        .remove =       wm8961_remove,
+        .suspend =      wm8961_suspend,
+        .resume =       wm8961_resume,
+};
+EXPORT_SYMBOL_GPL(soc_codec_dev_wm8961);
+
+static int wm8961_register(struct wm8961_priv *wm8961)
+{
+        struct snd_soc_codec *codec = &wm8961->codec;
+        int ret;
+        u16 reg;
+
+        if (wm8961_codec) {
+                dev_err(codec->dev, "Another WM8961 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 = wm8961;
+        codec->name = "WM8961";
+        codec->owner = THIS_MODULE;
+        codec->dai = &wm8961_dai;
+        codec->num_dai = 1;
+        codec->reg_cache_size = ARRAY_SIZE(wm8961->reg_cache);
+        codec->reg_cache = &wm8961->reg_cache;
+        codec->bias_level = SND_SOC_BIAS_OFF;
+        codec->set_bias_level = wm8961_set_bias_level;
+        codec->volatile_register = wm8961_volatile_register;
+
+        memcpy(codec->reg_cache, wm8961_reg_defaults,
+               sizeof(wm8961_reg_defaults));
+
+        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;
+        }
+
+        reg = snd_soc_read(codec, WM8961_SOFTWARE_RESET);
+        if (reg != 0x1801) {
+                dev_err(codec->dev, "Device is not a WM8961: ID=0x%x\n", reg);
+                ret = -EINVAL;
+                goto err;
+        }
+
+        /* This isn't volatile - readback doesn't correspond to write */
+        reg = codec->hw_read(codec, WM8961_RIGHT_INPUT_VOLUME);
+        dev_info(codec->dev, "WM8961 family %d revision %c\n",
+                 (reg & WM8961_DEVICE_ID_MASK) >> WM8961_DEVICE_ID_SHIFT,
+                 ((reg & WM8961_CHIP_REV_MASK) >> WM8961_CHIP_REV_SHIFT)
+                 + 'A');
+
+        ret = wm8961_reset(codec);
+        if (ret < 0) {
+                dev_err(codec->dev, "Failed to issue reset\n");
+                return ret;
+        }
+
+        /* Enable class W */
+        reg = snd_soc_read(codec, WM8961_CHARGE_PUMP_B);
+        reg |= WM8961_CP_DYN_PWR_MASK;
+        snd_soc_write(codec, WM8961_CHARGE_PUMP_B, reg);
+
+        /* Latch volume update bits (right channel only, we always
+         * write both out) and default ZC on. */
+        reg = snd_soc_read(codec, WM8961_ROUT1_VOLUME);
+        snd_soc_write(codec, WM8961_ROUT1_VOLUME,
+                     reg | WM8961_LO1ZC | WM8961_OUT1VU);
+        snd_soc_write(codec, WM8961_LOUT1_VOLUME, reg | WM8961_LO1ZC);
+        reg = snd_soc_read(codec, WM8961_ROUT2_VOLUME);
+        snd_soc_write(codec, WM8961_ROUT2_VOLUME,
+                     reg | WM8961_SPKRZC | WM8961_SPKVU);
+        snd_soc_write(codec, WM8961_LOUT2_VOLUME, reg | WM8961_SPKLZC);
+
+        reg = snd_soc_read(codec, WM8961_RIGHT_ADC_VOLUME);
+        snd_soc_write(codec, WM8961_RIGHT_ADC_VOLUME, reg | WM8961_ADCVU);
+        reg = snd_soc_read(codec, WM8961_RIGHT_INPUT_VOLUME);
+        snd_soc_write(codec, WM8961_RIGHT_INPUT_VOLUME, reg | WM8961_IPVU);
+
+        /* Use soft mute by default */
+        reg = snd_soc_read(codec, WM8961_ADC_DAC_CONTROL_2);
+        reg |= WM8961_DACSMM;
+        snd_soc_write(codec, WM8961_ADC_DAC_CONTROL_2, reg);
+
+        /* Use automatic clocking mode by default; for now this is all
+         * we support.
+         */
+        reg = snd_soc_read(codec, WM8961_CLOCKING_3);
+        reg &= ~WM8961_MANUAL_MODE;
+        snd_soc_write(codec, WM8961_CLOCKING_3, reg);
+
+        wm8961_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+
+        wm8961_dai.dev = codec->dev;
+
+        wm8961_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(&wm8961_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:
+        kfree(wm8961);
+        return ret;
+}
+
+static void wm8961_unregister(struct wm8961_priv *wm8961)
+{
+        wm8961_set_bias_level(&wm8961->codec, SND_SOC_BIAS_OFF);
+        snd_soc_unregister_dai(&wm8961_dai);
+        snd_soc_unregister_codec(&wm8961->codec);
+        kfree(wm8961);
+        wm8961_codec = NULL;
+}
+
+static __devinit int wm8961_i2c_probe(struct i2c_client *i2c,
+                                      const struct i2c_device_id *id)
+{
+        struct wm8961_priv *wm8961;
+        struct snd_soc_codec *codec;
+
+        wm8961 = kzalloc(sizeof(struct wm8961_priv), GFP_KERNEL);
+        if (wm8961 == NULL)
+                return -ENOMEM;
+
+        codec = &wm8961->codec;
+
+        i2c_set_clientdata(i2c, wm8961);
+        codec->control_data = i2c;
+
+        codec->dev = &i2c->dev;
+
+        return wm8961_register(wm8961);
+}
+
+static __devexit int wm8961_i2c_remove(struct i2c_client *client)
+{
+        struct wm8961_priv *wm8961 = i2c_get_clientdata(client);
+        wm8961_unregister(wm8961);
+        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 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, wm8961_i2c_id);
+
+static struct i2c_driver wm8961_i2c_driver = {
+        .driver = {
+                .name = "wm8961",
+                .owner = THIS_MODULE,
+        },
+        .probe =    wm8961_i2c_probe,
+        .remove =   __devexit_p(wm8961_i2c_remove),
+        .suspend =  wm8961_i2c_suspend,
+        .resume =   wm8961_i2c_resume,
+        .id_table = wm8961_i2c_id,
+};
+
+static int __init wm8961_modinit(void)
+{
+        int ret;
+
+        ret = i2c_add_driver(&wm8961_i2c_driver);
+        if (ret != 0) {
+                printk(KERN_ERR "Failed to register WM8961 I2C driver: %d\n",
+                       ret);
+        }
+
+        return ret;
+}
+module_init(wm8961_modinit);
+
+static void __exit wm8961_exit(void)
+{
+        i2c_del_driver(&wm8961_i2c_driver);
+}
+module_exit(wm8961_exit);
+
+
+MODULE_DESCRIPTION("ASoC WM8961 driver");
+MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/codecs/wm8961.h b/sound/soc/codecs/wm8961.h
new file mode 100644
index 000000000000..5513bfd720d6
--- /dev/null
+++ b/sound/soc/codecs/wm8961.h
@@ -0,0 +1,866 @@
+/*
+ * wm8961.h  --  WM8961 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 _WM8961_H
+#define _WM8961_H
+
+#include <sound/soc.h>
+
+extern struct snd_soc_codec_device soc_codec_dev_wm8961;
+extern struct snd_soc_dai wm8961_dai;
+
+#define WM8961_BCLK  1
+#define WM8961_LRCLK 2
+
+#define WM8961_BCLK_DIV_1    0
+#define WM8961_BCLK_DIV_1_5  1
+#define WM8961_BCLK_DIV_2    2
+#define WM8961_BCLK_DIV_3    3
+#define WM8961_BCLK_DIV_4    4
+#define WM8961_BCLK_DIV_5_5  5
+#define WM8961_BCLK_DIV_6    6
+#define WM8961_BCLK_DIV_8    7
+#define WM8961_BCLK_DIV_11   8
+#define WM8961_BCLK_DIV_12   9
+#define WM8961_BCLK_DIV_16  10
+#define WM8961_BCLK_DIV_24  11
+#define WM8961_BCLK_DIV_32  13
+
+
+/*
+ * Register values.
+ */
+#define WM8961_LEFT_INPUT_VOLUME                0x00
+#define WM8961_RIGHT_INPUT_VOLUME               0x01
+#define WM8961_LOUT1_VOLUME                     0x02
+#define WM8961_ROUT1_VOLUME                     0x03
+#define WM8961_CLOCKING1                        0x04
+#define WM8961_ADC_DAC_CONTROL_1                0x05
+#define WM8961_ADC_DAC_CONTROL_2                0x06
+#define WM8961_AUDIO_INTERFACE_0                0x07
+#define WM8961_CLOCKING2                        0x08
+#define WM8961_AUDIO_INTERFACE_1                0x09
+#define WM8961_LEFT_DAC_VOLUME                  0x0A
+#define WM8961_RIGHT_DAC_VOLUME                 0x0B
+#define WM8961_AUDIO_INTERFACE_2                0x0E
+#define WM8961_SOFTWARE_RESET                   0x0F
+#define WM8961_ALC1                             0x11
+#define WM8961_ALC2                             0x12
+#define WM8961_ALC3                             0x13
+#define WM8961_NOISE_GATE                       0x14
+#define WM8961_LEFT_ADC_VOLUME                  0x15
+#define WM8961_RIGHT_ADC_VOLUME                 0x16
+#define WM8961_ADDITIONAL_CONTROL_1             0x17
+#define WM8961_ADDITIONAL_CONTROL_2             0x18
+#define WM8961_PWR_MGMT_1                       0x19
+#define WM8961_PWR_MGMT_2                       0x1A
+#define WM8961_ADDITIONAL_CONTROL_3             0x1B
+#define WM8961_ANTI_POP                         0x1C
+#define WM8961_CLOCKING_3                       0x1E
+#define WM8961_ADCL_SIGNAL_PATH                 0x20
+#define WM8961_ADCR_SIGNAL_PATH                 0x21
+#define WM8961_LOUT2_VOLUME                     0x28
+#define WM8961_ROUT2_VOLUME                     0x29
+#define WM8961_PWR_MGMT_3                       0x2F
+#define WM8961_ADDITIONAL_CONTROL_4             0x30
+#define WM8961_CLASS_D_CONTROL_1                0x31
+#define WM8961_CLASS_D_CONTROL_2                0x33
+#define WM8961_CLOCKING_4                       0x38
+#define WM8961_DSP_SIDETONE_0                   0x39
+#define WM8961_DSP_SIDETONE_1                   0x3A
+#define WM8961_DC_SERVO_0                       0x3C
+#define WM8961_DC_SERVO_1                       0x3D
+#define WM8961_DC_SERVO_3                       0x3F
+#define WM8961_DC_SERVO_5                       0x41
+#define WM8961_ANALOGUE_PGA_BIAS                0x44
+#define WM8961_ANALOGUE_HP_0                    0x45
+#define WM8961_ANALOGUE_HP_2                    0x47
+#define WM8961_CHARGE_PUMP_1                    0x48
+#define WM8961_CHARGE_PUMP_B                    0x52
+#define WM8961_WRITE_SEQUENCER_1                0x57
+#define WM8961_WRITE_SEQUENCER_2                0x58
+#define WM8961_WRITE_SEQUENCER_3                0x59
+#define WM8961_WRITE_SEQUENCER_4                0x5A
+#define WM8961_WRITE_SEQUENCER_5                0x5B
+#define WM8961_WRITE_SEQUENCER_6                0x5C
+#define WM8961_WRITE_SEQUENCER_7                0x5D
+#define WM8961_GENERAL_TEST_1                   0xFC
+
+
+/*
+ * Field Definitions.
+ */
+
+/*
+ * R0 (0x00) - Left Input volume
+ */
+#define WM8961_IPVU                             0x0100  /* IPVU */
+#define WM8961_IPVU_MASK                        0x0100  /* IPVU */
+#define WM8961_IPVU_SHIFT                            8  /* IPVU */
+#define WM8961_IPVU_WIDTH                            1  /* IPVU */
+#define WM8961_LINMUTE                          0x0080  /* LINMUTE */
+#define WM8961_LINMUTE_MASK                     0x0080  /* LINMUTE */
+#define WM8961_LINMUTE_SHIFT                         7  /* LINMUTE */
+#define WM8961_LINMUTE_WIDTH                         1  /* LINMUTE */
+#define WM8961_LIZC                             0x0040  /* LIZC */
+#define WM8961_LIZC_MASK                        0x0040  /* LIZC */
+#define WM8961_LIZC_SHIFT                            6  /* LIZC */
+#define WM8961_LIZC_WIDTH                            1  /* LIZC */
+#define WM8961_LINVOL_MASK                      0x003F  /* LINVOL - [5:0] */
+#define WM8961_LINVOL_SHIFT                          0  /* LINVOL - [5:0] */
+#define WM8961_LINVOL_WIDTH                          6  /* LINVOL - [5:0] */
+
+/*
+ * R1 (0x01) - Right Input volume
+ */
+#define WM8961_DEVICE_ID_MASK                   0xF000  /* DEVICE_ID - [15:12] */
+#define WM8961_DEVICE_ID_SHIFT                      12  /* DEVICE_ID - [15:12] */
+#define WM8961_DEVICE_ID_WIDTH                       4  /* DEVICE_ID - [15:12] */
+#define WM8961_CHIP_REV_MASK                    0x0E00  /* CHIP_REV - [11:9] */
+#define WM8961_CHIP_REV_SHIFT                        9  /* CHIP_REV - [11:9] */
+#define WM8961_CHIP_REV_WIDTH                        3  /* CHIP_REV - [11:9] */
+#define WM8961_IPVU                             0x0100  /* IPVU */
+#define WM8961_IPVU_MASK                        0x0100  /* IPVU */
+#define WM8961_IPVU_SHIFT                            8  /* IPVU */
+#define WM8961_IPVU_WIDTH                            1  /* IPVU */
+#define WM8961_RINMUTE                          0x0080  /* RINMUTE */
+#define WM8961_RINMUTE_MASK                     0x0080  /* RINMUTE */
+#define WM8961_RINMUTE_SHIFT                         7  /* RINMUTE */
+#define WM8961_RINMUTE_WIDTH                         1  /* RINMUTE */
+#define WM8961_RIZC                             0x0040  /* RIZC */
+#define WM8961_RIZC_MASK                        0x0040  /* RIZC */
+#define WM8961_RIZC_SHIFT                            6  /* RIZC */
+#define WM8961_RIZC_WIDTH                            1  /* RIZC */
+#define WM8961_RINVOL_MASK                      0x003F  /* RINVOL - [5:0] */
+#define WM8961_RINVOL_SHIFT                          0  /* RINVOL - [5:0] */
+#define WM8961_RINVOL_WIDTH                          6  /* RINVOL - [5:0] */
+
+/*
+ * R2 (0x02) - LOUT1 volume
+ */
+#define WM8961_OUT1VU                           0x0100  /* OUT1VU */
+#define WM8961_OUT1VU_MASK                      0x0100  /* OUT1VU */
+#define WM8961_OUT1VU_SHIFT                          8  /* OUT1VU */
+#define WM8961_OUT1VU_WIDTH                          1  /* OUT1VU */
+#define WM8961_LO1ZC                            0x0080  /* LO1ZC */
+#define WM8961_LO1ZC_MASK                       0x0080  /* LO1ZC */
+#define WM8961_LO1ZC_SHIFT                           7  /* LO1ZC */
+#define WM8961_LO1ZC_WIDTH                           1  /* LO1ZC */
+#define WM8961_LOUT1VOL_MASK                    0x007F  /* LOUT1VOL - [6:0] */
+#define WM8961_LOUT1VOL_SHIFT                        0  /* LOUT1VOL - [6:0] */
+#define WM8961_LOUT1VOL_WIDTH                        7  /* LOUT1VOL - [6:0] */
+
+/*
+ * R3 (0x03) - ROUT1 volume
+ */
+#define WM8961_OUT1VU                           0x0100  /* OUT1VU */
+#define WM8961_OUT1VU_MASK                      0x0100  /* OUT1VU */
+#define WM8961_OUT1VU_SHIFT                          8  /* OUT1VU */
+#define WM8961_OUT1VU_WIDTH                          1  /* OUT1VU */
+#define WM8961_RO1ZC                            0x0080  /* RO1ZC */
+#define WM8961_RO1ZC_MASK                       0x0080  /* RO1ZC */
+#define WM8961_RO1ZC_SHIFT                           7  /* RO1ZC */
+#define WM8961_RO1ZC_WIDTH                           1  /* RO1ZC */
+#define WM8961_ROUT1VOL_MASK                    0x007F  /* ROUT1VOL - [6:0] */
+#define WM8961_ROUT1VOL_SHIFT                        0  /* ROUT1VOL - [6:0] */
+#define WM8961_ROUT1VOL_WIDTH                        7  /* ROUT1VOL - [6:0] */
+
+/*
+ * R4 (0x04) - Clocking1
+ */
+#define WM8961_ADCDIV_MASK                      0x01C0  /* ADCDIV - [8:6] */
+#define WM8961_ADCDIV_SHIFT                          6  /* ADCDIV - [8:6] */
+#define WM8961_ADCDIV_WIDTH                          3  /* ADCDIV - [8:6] */
+#define WM8961_DACDIV_MASK                      0x0038  /* DACDIV - [5:3] */
+#define WM8961_DACDIV_SHIFT                          3  /* DACDIV - [5:3] */
+#define WM8961_DACDIV_WIDTH                          3  /* DACDIV - [5:3] */
+#define WM8961_MCLKDIV                          0x0004  /* MCLKDIV */
+#define WM8961_MCLKDIV_MASK                     0x0004  /* MCLKDIV */
+#define WM8961_MCLKDIV_SHIFT                         2  /* MCLKDIV */
+#define WM8961_MCLKDIV_WIDTH                         1  /* MCLKDIV */
+
+/*
+ * R5 (0x05) - ADC & DAC Control 1
+ */
+#define WM8961_ADCPOL_MASK                      0x0060  /* ADCPOL - [6:5] */
+#define WM8961_ADCPOL_SHIFT                          5  /* ADCPOL - [6:5] */
+#define WM8961_ADCPOL_WIDTH                          2  /* ADCPOL - [6:5] */
+#define WM8961_DACMU                            0x0008  /* DACMU */
+#define WM8961_DACMU_MASK                       0x0008  /* DACMU */
+#define WM8961_DACMU_SHIFT                           3  /* DACMU */
+#define WM8961_DACMU_WIDTH                           1  /* DACMU */
+#define WM8961_DEEMPH_MASK                      0x0006  /* DEEMPH - [2:1] */
+#define WM8961_DEEMPH_SHIFT                          1  /* DEEMPH - [2:1] */
+#define WM8961_DEEMPH_WIDTH                          2  /* DEEMPH - [2:1] */
+#define WM8961_ADCHPD                           0x0001  /* ADCHPD */
+#define WM8961_ADCHPD_MASK                      0x0001  /* ADCHPD */
+#define WM8961_ADCHPD_SHIFT                          0  /* ADCHPD */
+#define WM8961_ADCHPD_WIDTH                          1  /* ADCHPD */
+
+/*
+ * R6 (0x06) - ADC & DAC Control 2
+ */
+#define WM8961_ADC_HPF_CUT_MASK                 0x0180  /* ADC_HPF_CUT - [8:7] */
+#define WM8961_ADC_HPF_CUT_SHIFT                     7  /* ADC_HPF_CUT - [8:7] */
+#define WM8961_ADC_HPF_CUT_WIDTH                     2  /* ADC_HPF_CUT - [8:7] */
+#define WM8961_DACPOL_MASK                      0x0060  /* DACPOL - [6:5] */
+#define WM8961_DACPOL_SHIFT                          5  /* DACPOL - [6:5] */
+#define WM8961_DACPOL_WIDTH                          2  /* DACPOL - [6:5] */
+#define WM8961_DACSMM                           0x0008  /* DACSMM */
+#define WM8961_DACSMM_MASK                      0x0008  /* DACSMM */
+#define WM8961_DACSMM_SHIFT                          3  /* DACSMM */
+#define WM8961_DACSMM_WIDTH                          1  /* DACSMM */
+#define WM8961_DACMR                            0x0004  /* DACMR */
+#define WM8961_DACMR_MASK                       0x0004  /* DACMR */
+#define WM8961_DACMR_SHIFT                           2  /* DACMR */
+#define WM8961_DACMR_WIDTH                           1  /* DACMR */
+#define WM8961_DACSLOPE                         0x0002  /* DACSLOPE */
+#define WM8961_DACSLOPE_MASK                    0x0002  /* DACSLOPE */
+#define WM8961_DACSLOPE_SHIFT                        1  /* DACSLOPE */
+#define WM8961_DACSLOPE_WIDTH                        1  /* DACSLOPE */
+#define WM8961_DAC_OSR128                       0x0001  /* DAC_OSR128 */
+#define WM8961_DAC_OSR128_MASK                  0x0001  /* DAC_OSR128 */
+#define WM8961_DAC_OSR128_SHIFT                      0  /* DAC_OSR128 */
+#define WM8961_DAC_OSR128_WIDTH                      1  /* DAC_OSR128 */
+
+/*
+ * R7 (0x07) - Audio Interface 0
+ */
+#define WM8961_ALRSWAP                          0x0100  /* ALRSWAP */
+#define WM8961_ALRSWAP_MASK                     0x0100  /* ALRSWAP */
+#define WM8961_ALRSWAP_SHIFT                         8  /* ALRSWAP */
+#define WM8961_ALRSWAP_WIDTH                         1  /* ALRSWAP */
+#define WM8961_BCLKINV                          0x0080  /* BCLKINV */
+#define WM8961_BCLKINV_MASK                     0x0080  /* BCLKINV */
+#define WM8961_BCLKINV_SHIFT                         7  /* BCLKINV */
+#define WM8961_BCLKINV_WIDTH                         1  /* BCLKINV */
+#define WM8961_MS                               0x0040  /* MS */
+#define WM8961_MS_MASK                          0x0040  /* MS */
+#define WM8961_MS_SHIFT                              6  /* MS */
+#define WM8961_MS_WIDTH                              1  /* MS */
+#define WM8961_DLRSWAP                          0x0020  /* DLRSWAP */
+#define WM8961_DLRSWAP_MASK                     0x0020  /* DLRSWAP */
+#define WM8961_DLRSWAP_SHIFT                         5  /* DLRSWAP */
+#define WM8961_DLRSWAP_WIDTH                         1  /* DLRSWAP */
+#define WM8961_LRP                              0x0010  /* LRP */
+#define WM8961_LRP_MASK                         0x0010  /* LRP */
+#define WM8961_LRP_SHIFT                             4  /* LRP */
+#define WM8961_LRP_WIDTH                             1  /* LRP */
+#define WM8961_WL_MASK                          0x000C  /* WL - [3:2] */
+#define WM8961_WL_SHIFT                              2  /* WL - [3:2] */
+#define WM8961_WL_WIDTH                              2  /* WL - [3:2] */
+#define WM8961_FORMAT_MASK                      0x0003  /* FORMAT - [1:0] */
+#define WM8961_FORMAT_SHIFT                          0  /* FORMAT - [1:0] */
+#define WM8961_FORMAT_WIDTH                          2  /* FORMAT - [1:0] */
+
+/*
+ * R8 (0x08) - Clocking2
+ */
+#define WM8961_DCLKDIV_MASK                     0x01C0  /* DCLKDIV - [8:6] */
+#define WM8961_DCLKDIV_SHIFT                         6  /* DCLKDIV - [8:6] */
+#define WM8961_DCLKDIV_WIDTH                         3  /* DCLKDIV - [8:6] */
+#define WM8961_CLK_SYS_ENA                      0x0020  /* CLK_SYS_ENA */
+#define WM8961_CLK_SYS_ENA_MASK                 0x0020  /* CLK_SYS_ENA */
+#define WM8961_CLK_SYS_ENA_SHIFT                     5  /* CLK_SYS_ENA */
+#define WM8961_CLK_SYS_ENA_WIDTH                     1  /* CLK_SYS_ENA */
+#define WM8961_CLK_DSP_ENA                      0x0010  /* CLK_DSP_ENA */
+#define WM8961_CLK_DSP_ENA_MASK                 0x0010  /* CLK_DSP_ENA */
+#define WM8961_CLK_DSP_ENA_SHIFT                     4  /* CLK_DSP_ENA */
+#define WM8961_CLK_DSP_ENA_WIDTH                     1  /* CLK_DSP_ENA */
+#define WM8961_BCLKDIV_MASK                     0x000F  /* BCLKDIV - [3:0] */
+#define WM8961_BCLKDIV_SHIFT                         0  /* BCLKDIV - [3:0] */
+#define WM8961_BCLKDIV_WIDTH                         4  /* BCLKDIV - [3:0] */
+
+/*
+ * R9 (0x09) - Audio Interface 1
+ */
+#define WM8961_DACCOMP_MASK                     0x0018  /* DACCOMP - [4:3] */
+#define WM8961_DACCOMP_SHIFT                         3  /* DACCOMP - [4:3] */
+#define WM8961_DACCOMP_WIDTH                         2  /* DACCOMP - [4:3] */
+#define WM8961_ADCCOMP_MASK                     0x0006  /* ADCCOMP - [2:1] */
+#define WM8961_ADCCOMP_SHIFT                         1  /* ADCCOMP - [2:1] */
+#define WM8961_ADCCOMP_WIDTH                         2  /* ADCCOMP - [2:1] */
+#define WM8961_LOOPBACK                         0x0001  /* LOOPBACK */
+#define WM8961_LOOPBACK_MASK                    0x0001  /* LOOPBACK */
+#define WM8961_LOOPBACK_SHIFT                        0  /* LOOPBACK */
+#define WM8961_LOOPBACK_WIDTH                        1  /* LOOPBACK */
+
+/*
+ * R10 (0x0A) - Left DAC volume
+ */
+#define WM8961_DACVU                            0x0100  /* DACVU */
+#define WM8961_DACVU_MASK                       0x0100  /* DACVU */
+#define WM8961_DACVU_SHIFT                           8  /* DACVU */
+#define WM8961_DACVU_WIDTH                           1  /* DACVU */
+#define WM8961_LDACVOL_MASK                     0x00FF  /* LDACVOL - [7:0] */
+#define WM8961_LDACVOL_SHIFT                         0  /* LDACVOL - [7:0] */
+#define WM8961_LDACVOL_WIDTH                         8  /* LDACVOL - [7:0] */
+
+/*
+ * R11 (0x0B) - Right DAC volume
+ */
+#define WM8961_DACVU                            0x0100  /* DACVU */
+#define WM8961_DACVU_MASK                       0x0100  /* DACVU */
+#define WM8961_DACVU_SHIFT                           8  /* DACVU */
+#define WM8961_DACVU_WIDTH                           1  /* DACVU */
+#define WM8961_RDACVOL_MASK                     0x00FF  /* RDACVOL - [7:0] */
+#define WM8961_RDACVOL_SHIFT                         0  /* RDACVOL - [7:0] */
+#define WM8961_RDACVOL_WIDTH                         8  /* RDACVOL - [7:0] */
+
+/*
+ * R14 (0x0E) - Audio Interface 2
+ */
+#define WM8961_LRCLK_RATE_MASK                  0x01FF  /* LRCLK_RATE - [8:0] */
+#define WM8961_LRCLK_RATE_SHIFT                      0  /* LRCLK_RATE - [8:0] */
+#define WM8961_LRCLK_RATE_WIDTH                      9  /* LRCLK_RATE - [8:0] */
+
+/*
+ * R15 (0x0F) - Software Reset
+ */
+#define WM8961_SW_RST_DEV_ID1_MASK              0xFFFF  /* SW_RST_DEV_ID1 - [15:0] */
+#define WM8961_SW_RST_DEV_ID1_SHIFT                  0  /* SW_RST_DEV_ID1 - [15:0] */
+#define WM8961_SW_RST_DEV_ID1_WIDTH                 16  /* SW_RST_DEV_ID1 - [15:0] */
+
+/*
+ * R17 (0x11) - ALC1
+ */
+#define WM8961_ALCSEL_MASK                      0x0180  /* ALCSEL - [8:7] */
+#define WM8961_ALCSEL_SHIFT                          7  /* ALCSEL - [8:7] */
+#define WM8961_ALCSEL_WIDTH                          2  /* ALCSEL - [8:7] */
+#define WM8961_MAXGAIN_MASK                     0x0070  /* MAXGAIN - [6:4] */
+#define WM8961_MAXGAIN_SHIFT                         4  /* MAXGAIN - [6:4] */
+#define WM8961_MAXGAIN_WIDTH                         3  /* MAXGAIN - [6:4] */
+#define WM8961_ALCL_MASK                        0x000F  /* ALCL - [3:0] */
+#define WM8961_ALCL_SHIFT                            0  /* ALCL - [3:0] */
+#define WM8961_ALCL_WIDTH                            4  /* ALCL - [3:0] */
+
+/*
+ * R18 (0x12) - ALC2
+ */
+#define WM8961_ALCZC                            0x0080  /* ALCZC */
+#define WM8961_ALCZC_MASK                       0x0080  /* ALCZC */
+#define WM8961_ALCZC_SHIFT                           7  /* ALCZC */
+#define WM8961_ALCZC_WIDTH                           1  /* ALCZC */
+#define WM8961_MINGAIN_MASK                     0x0070  /* MINGAIN - [6:4] */
+#define WM8961_MINGAIN_SHIFT                         4  /* MINGAIN - [6:4] */
+#define WM8961_MINGAIN_WIDTH                         3  /* MINGAIN - [6:4] */
+#define WM8961_HLD_MASK                         0x000F  /* HLD - [3:0] */
+#define WM8961_HLD_SHIFT                             0  /* HLD - [3:0] */
+#define WM8961_HLD_WIDTH                             4  /* HLD - [3:0] */
+
+/*
+ * R19 (0x13) - ALC3
+ */
+#define WM8961_ALCMODE                          0x0100  /* ALCMODE */
+#define WM8961_ALCMODE_MASK                     0x0100  /* ALCMODE */
+#define WM8961_ALCMODE_SHIFT                         8  /* ALCMODE */
+#define WM8961_ALCMODE_WIDTH                         1  /* ALCMODE */
+#define WM8961_DCY_MASK                         0x00F0  /* DCY - [7:4] */
+#define WM8961_DCY_SHIFT                             4  /* DCY - [7:4] */
+#define WM8961_DCY_WIDTH                             4  /* DCY - [7:4] */
+#define WM8961_ATK_MASK                         0x000F  /* ATK - [3:0] */
+#define WM8961_ATK_SHIFT                             0  /* ATK - [3:0] */
+#define WM8961_ATK_WIDTH                             4  /* ATK - [3:0] */
+
+/*
+ * R20 (0x14) - Noise Gate
+ */
+#define WM8961_NGTH_MASK                        0x00F8  /* NGTH - [7:3] */
+#define WM8961_NGTH_SHIFT                            3  /* NGTH - [7:3] */
+#define WM8961_NGTH_WIDTH                            5  /* NGTH - [7:3] */
+#define WM8961_NGG                              0x0002  /* NGG */
+#define WM8961_NGG_MASK                         0x0002  /* NGG */
+#define WM8961_NGG_SHIFT                             1  /* NGG */
+#define WM8961_NGG_WIDTH                             1  /* NGG */
+#define WM8961_NGAT                             0x0001  /* NGAT */
+#define WM8961_NGAT_MASK                        0x0001  /* NGAT */
+#define WM8961_NGAT_SHIFT                            0  /* NGAT */
+#define WM8961_NGAT_WIDTH                            1  /* NGAT */
+
+/*
+ * R21 (0x15) - Left ADC volume
+ */
+#define WM8961_ADCVU                            0x0100  /* ADCVU */
+#define WM8961_ADCVU_MASK                       0x0100  /* ADCVU */
+#define WM8961_ADCVU_SHIFT                           8  /* ADCVU */
+#define WM8961_ADCVU_WIDTH                           1  /* ADCVU */
+#define WM8961_LADCVOL_MASK                     0x00FF  /* LADCVOL - [7:0] */
+#define WM8961_LADCVOL_SHIFT                         0  /* LADCVOL - [7:0] */
+#define WM8961_LADCVOL_WIDTH                         8  /* LADCVOL - [7:0] */
+
+/*
+ * R22 (0x16) - Right ADC volume
+ */
+#define WM8961_ADCVU                            0x0100  /* ADCVU */
+#define WM8961_ADCVU_MASK                       0x0100  /* ADCVU */
+#define WM8961_ADCVU_SHIFT                           8  /* ADCVU */
+#define WM8961_ADCVU_WIDTH                           1  /* ADCVU */
+#define WM8961_RADCVOL_MASK                     0x00FF  /* RADCVOL - [7:0] */
+#define WM8961_RADCVOL_SHIFT                         0  /* RADCVOL - [7:0] */
+#define WM8961_RADCVOL_WIDTH                         8  /* RADCVOL - [7:0] */
+
+/*
+ * R23 (0x17) - Additional control(1)
+ */
+#define WM8961_TSDEN                            0x0100  /* TSDEN */
+#define WM8961_TSDEN_MASK                       0x0100  /* TSDEN */
+#define WM8961_TSDEN_SHIFT                           8  /* TSDEN */
+#define WM8961_TSDEN_WIDTH                           1  /* TSDEN */
+#define WM8961_DMONOMIX                         0x0010  /* DMONOMIX */
+#define WM8961_DMONOMIX_MASK                    0x0010  /* DMONOMIX */
+#define WM8961_DMONOMIX_SHIFT                        4  /* DMONOMIX */
+#define WM8961_DMONOMIX_WIDTH                        1  /* DMONOMIX */
+#define WM8961_TOEN                             0x0001  /* TOEN */
+#define WM8961_TOEN_MASK                        0x0001  /* TOEN */
+#define WM8961_TOEN_SHIFT                            0  /* TOEN */
+#define WM8961_TOEN_WIDTH                            1  /* TOEN */
+
+/*
+ * R24 (0x18) - Additional control(2)
+ */
+#define WM8961_TRIS                             0x0008  /* TRIS */
+#define WM8961_TRIS_MASK                        0x0008  /* TRIS */
+#define WM8961_TRIS_SHIFT                            3  /* TRIS */
+#define WM8961_TRIS_WIDTH                            1  /* TRIS */
+
+/*
+ * R25 (0x19) - Pwr Mgmt (1)
+ */
+#define WM8961_VMIDSEL_MASK                     0x0180  /* VMIDSEL - [8:7] */
+#define WM8961_VMIDSEL_SHIFT                         7  /* VMIDSEL - [8:7] */
+#define WM8961_VMIDSEL_WIDTH                         2  /* VMIDSEL - [8:7] */
+#define WM8961_VREF                             0x0040  /* VREF */
+#define WM8961_VREF_MASK                        0x0040  /* VREF */
+#define WM8961_VREF_SHIFT                            6  /* VREF */
+#define WM8961_VREF_WIDTH                            1  /* VREF */
+#define WM8961_AINL                             0x0020  /* AINL */
+#define WM8961_AINL_MASK                        0x0020  /* AINL */
+#define WM8961_AINL_SHIFT                            5  /* AINL */
+#define WM8961_AINL_WIDTH                            1  /* AINL */
+#define WM8961_AINR                             0x0010  /* AINR */
+#define WM8961_AINR_MASK                        0x0010  /* AINR */
+#define WM8961_AINR_SHIFT                            4  /* AINR */
+#define WM8961_AINR_WIDTH                            1  /* AINR */
+#define WM8961_ADCL                             0x0008  /* ADCL */
+#define WM8961_ADCL_MASK                        0x0008  /* ADCL */
+#define WM8961_ADCL_SHIFT                            3  /* ADCL */
+#define WM8961_ADCL_WIDTH                            1  /* ADCL */
+#define WM8961_ADCR                             0x0004  /* ADCR */
+#define WM8961_ADCR_MASK                        0x0004  /* ADCR */
+#define WM8961_ADCR_SHIFT                            2  /* ADCR */
+#define WM8961_ADCR_WIDTH                            1  /* ADCR */
+#define WM8961_MICB                             0x0002  /* MICB */
+#define WM8961_MICB_MASK                        0x0002  /* MICB */
+#define WM8961_MICB_SHIFT                            1  /* MICB */
+#define WM8961_MICB_WIDTH                            1  /* MICB */
+
+/*
+ * R26 (0x1A) - Pwr Mgmt (2)
+ */
+#define WM8961_DACL                             0x0100  /* DACL */
+#define WM8961_DACL_MASK                        0x0100  /* DACL */
+#define WM8961_DACL_SHIFT                            8  /* DACL */
+#define WM8961_DACL_WIDTH                            1  /* DACL */
+#define WM8961_DACR                             0x0080  /* DACR */
+#define WM8961_DACR_MASK                        0x0080  /* DACR */
+#define WM8961_DACR_SHIFT                            7  /* DACR */
+#define WM8961_DACR_WIDTH                            1  /* DACR */
+#define WM8961_LOUT1_PGA                        0x0040  /* LOUT1_PGA */
+#define WM8961_LOUT1_PGA_MASK                   0x0040  /* LOUT1_PGA */
+#define WM8961_LOUT1_PGA_SHIFT                       6  /* LOUT1_PGA */
+#define WM8961_LOUT1_PGA_WIDTH                       1  /* LOUT1_PGA */
+#define WM8961_ROUT1_PGA                        0x0020  /* ROUT1_PGA */
+#define WM8961_ROUT1_PGA_MASK                   0x0020  /* ROUT1_PGA */
+#define WM8961_ROUT1_PGA_SHIFT                       5  /* ROUT1_PGA */
+#define WM8961_ROUT1_PGA_WIDTH                       1  /* ROUT1_PGA */
+#define WM8961_SPKL_PGA                         0x0010  /* SPKL_PGA */
+#define WM8961_SPKL_PGA_MASK                    0x0010  /* SPKL_PGA */
+#define WM8961_SPKL_PGA_SHIFT                        4  /* SPKL_PGA */
+#define WM8961_SPKL_PGA_WIDTH                        1  /* SPKL_PGA */
+#define WM8961_SPKR_PGA                         0x0008  /* SPKR_PGA */
+#define WM8961_SPKR_PGA_MASK                    0x0008  /* SPKR_PGA */
+#define WM8961_SPKR_PGA_SHIFT                        3  /* SPKR_PGA */
+#define WM8961_SPKR_PGA_WIDTH                        1  /* SPKR_PGA */
+
+/*
+ * R27 (0x1B) - Additional Control (3)
+ */
+#define WM8961_SAMPLE_RATE_MASK                 0x0007  /* SAMPLE_RATE - [2:0] */
+#define WM8961_SAMPLE_RATE_SHIFT                     0  /* SAMPLE_RATE - [2:0] */
+#define WM8961_SAMPLE_RATE_WIDTH                     3  /* SAMPLE_RATE - [2:0] */
+
+/*
+ * R28 (0x1C) - Anti-pop
+ */
+#define WM8961_BUFDCOPEN                        0x0010  /* BUFDCOPEN */
+#define WM8961_BUFDCOPEN_MASK                   0x0010  /* BUFDCOPEN */
+#define WM8961_BUFDCOPEN_SHIFT                       4  /* BUFDCOPEN */
+#define WM8961_BUFDCOPEN_WIDTH                       1  /* BUFDCOPEN */
+#define WM8961_BUFIOEN                          0x0008  /* BUFIOEN */
+#define WM8961_BUFIOEN_MASK                     0x0008  /* BUFIOEN */
+#define WM8961_BUFIOEN_SHIFT                         3  /* BUFIOEN */
+#define WM8961_BUFIOEN_WIDTH                         1  /* BUFIOEN */
+#define WM8961_SOFT_ST                          0x0004  /* SOFT_ST */
+#define WM8961_SOFT_ST_MASK                     0x0004  /* SOFT_ST */
+#define WM8961_SOFT_ST_SHIFT                         2  /* SOFT_ST */
+#define WM8961_SOFT_ST_WIDTH                         1  /* SOFT_ST */
+
+/*
+ * R30 (0x1E) - Clocking 3
+ */
+#define WM8961_CLK_TO_DIV_MASK                  0x0180  /* CLK_TO_DIV - [8:7] */
+#define WM8961_CLK_TO_DIV_SHIFT                      7  /* CLK_TO_DIV - [8:7] */
+#define WM8961_CLK_TO_DIV_WIDTH                      2  /* CLK_TO_DIV - [8:7] */
+#define WM8961_CLK_256K_DIV_MASK                0x007E  /* CLK_256K_DIV - [6:1] */
+#define WM8961_CLK_256K_DIV_SHIFT                    1  /* CLK_256K_DIV - [6:1] */
+#define WM8961_CLK_256K_DIV_WIDTH                    6  /* CLK_256K_DIV - [6:1] */
+#define WM8961_MANUAL_MODE                      0x0001  /* MANUAL_MODE */
+#define WM8961_MANUAL_MODE_MASK                 0x0001  /* MANUAL_MODE */
+#define WM8961_MANUAL_MODE_SHIFT                     0  /* MANUAL_MODE */
+#define WM8961_MANUAL_MODE_WIDTH                     1  /* MANUAL_MODE */
+
+/*
+ * R32 (0x20) - ADCL signal path
+ */
+#define WM8961_LMICBOOST_MASK                   0x0030  /* LMICBOOST - [5:4] */
+#define WM8961_LMICBOOST_SHIFT                       4  /* LMICBOOST - [5:4] */
+#define WM8961_LMICBOOST_WIDTH                       2  /* LMICBOOST - [5:4] */
+
+/*
+ * R33 (0x21) - ADCR signal path
+ */
+#define WM8961_RMICBOOST_MASK                   0x0030  /* RMICBOOST - [5:4] */
+#define WM8961_RMICBOOST_SHIFT                       4  /* RMICBOOST - [5:4] */
+#define WM8961_RMICBOOST_WIDTH                       2  /* RMICBOOST - [5:4] */
+
+/*
+ * R40 (0x28) - LOUT2 volume
+ */
+#define WM8961_SPKVU                            0x0100  /* SPKVU */
+#define WM8961_SPKVU_MASK                       0x0100  /* SPKVU */
+#define WM8961_SPKVU_SHIFT                           8  /* SPKVU */
+#define WM8961_SPKVU_WIDTH                           1  /* SPKVU */
+#define WM8961_SPKLZC                           0x0080  /* SPKLZC */
+#define WM8961_SPKLZC_MASK                      0x0080  /* SPKLZC */
+#define WM8961_SPKLZC_SHIFT                          7  /* SPKLZC */
+#define WM8961_SPKLZC_WIDTH                          1  /* SPKLZC */
+#define WM8961_SPKLVOL_MASK                     0x007F  /* SPKLVOL - [6:0] */
+#define WM8961_SPKLVOL_SHIFT                         0  /* SPKLVOL - [6:0] */
+#define WM8961_SPKLVOL_WIDTH                         7  /* SPKLVOL - [6:0] */
+
+/*
+ * R41 (0x29) - ROUT2 volume
+ */
+#define WM8961_SPKVU                            0x0100  /* SPKVU */
+#define WM8961_SPKVU_MASK                       0x0100  /* SPKVU */
+#define WM8961_SPKVU_SHIFT                           8  /* SPKVU */
+#define WM8961_SPKVU_WIDTH                           1  /* SPKVU */
+#define WM8961_SPKRZC                           0x0080  /* SPKRZC */
+#define WM8961_SPKRZC_MASK                      0x0080  /* SPKRZC */
+#define WM8961_SPKRZC_SHIFT                          7  /* SPKRZC */
+#define WM8961_SPKRZC_WIDTH                          1  /* SPKRZC */
+#define WM8961_SPKRVOL_MASK                     0x007F  /* SPKRVOL - [6:0] */
+#define WM8961_SPKRVOL_SHIFT                         0  /* SPKRVOL - [6:0] */
+#define WM8961_SPKRVOL_WIDTH                         7  /* SPKRVOL - [6:0] */
+
+/*
+ * R47 (0x2F) - Pwr Mgmt (3)
+ */
+#define WM8961_TEMP_SHUT                        0x0002  /* TEMP_SHUT */
+#define WM8961_TEMP_SHUT_MASK                   0x0002  /* TEMP_SHUT */
+#define WM8961_TEMP_SHUT_SHIFT                       1  /* TEMP_SHUT */
+#define WM8961_TEMP_SHUT_WIDTH                       1  /* TEMP_SHUT */
+#define WM8961_TEMP_WARN                        0x0001  /* TEMP_WARN */
+#define WM8961_TEMP_WARN_MASK                   0x0001  /* TEMP_WARN */
+#define WM8961_TEMP_WARN_SHIFT                       0  /* TEMP_WARN */
+#define WM8961_TEMP_WARN_WIDTH                       1  /* TEMP_WARN */
+
+/*
+ * R48 (0x30) - Additional Control (4)
+ */
+#define WM8961_TSENSEN                          0x0002  /* TSENSEN */
+#define WM8961_TSENSEN_MASK                     0x0002  /* TSENSEN */
+#define WM8961_TSENSEN_SHIFT                         1  /* TSENSEN */
+#define WM8961_TSENSEN_WIDTH                         1  /* TSENSEN */
+#define WM8961_MBSEL                            0x0001  /* MBSEL */
+#define WM8961_MBSEL_MASK                       0x0001  /* MBSEL */
+#define WM8961_MBSEL_SHIFT                           0  /* MBSEL */
+#define WM8961_MBSEL_WIDTH                           1  /* MBSEL */
+
+/*
+ * R49 (0x31) - Class D Control 1
+ */
+#define WM8961_SPKR_ENA                         0x0080  /* SPKR_ENA */
+#define WM8961_SPKR_ENA_MASK                    0x0080  /* SPKR_ENA */
+#define WM8961_SPKR_ENA_SHIFT                        7  /* SPKR_ENA */
+#define WM8961_SPKR_ENA_WIDTH                        1  /* SPKR_ENA */
+#define WM8961_SPKL_ENA                         0x0040  /* SPKL_ENA */
+#define WM8961_SPKL_ENA_MASK                    0x0040  /* SPKL_ENA */
+#define WM8961_SPKL_ENA_SHIFT                        6  /* SPKL_ENA */
+#define WM8961_SPKL_ENA_WIDTH                        1  /* SPKL_ENA */
+
+/*
+ * R51 (0x33) - Class D Control 2
+ */
+#define WM8961_CLASSD_ACGAIN_MASK               0x0007  /* CLASSD_ACGAIN - [2:0] */
+#define WM8961_CLASSD_ACGAIN_SHIFT                   0  /* CLASSD_ACGAIN - [2:0] */
+#define WM8961_CLASSD_ACGAIN_WIDTH                   3  /* CLASSD_ACGAIN - [2:0] */
+
+/*
+ * R56 (0x38) - Clocking 4
+ */
+#define WM8961_CLK_DCS_DIV_MASK                 0x01E0  /* CLK_DCS_DIV - [8:5] */
+#define WM8961_CLK_DCS_DIV_SHIFT                     5  /* CLK_DCS_DIV - [8:5] */
+#define WM8961_CLK_DCS_DIV_WIDTH                     4  /* CLK_DCS_DIV - [8:5] */
+#define WM8961_CLK_SYS_RATE_MASK                0x001E  /* CLK_SYS_RATE - [4:1] */
+#define WM8961_CLK_SYS_RATE_SHIFT                    1  /* CLK_SYS_RATE - [4:1] */
+#define WM8961_CLK_SYS_RATE_WIDTH                    4  /* CLK_SYS_RATE - [4:1] */
+
+/*
+ * R57 (0x39) - DSP Sidetone 0
+ */
+#define WM8961_ADCR_DAC_SVOL_MASK               0x00F0  /* ADCR_DAC_SVOL - [7:4] */
+#define WM8961_ADCR_DAC_SVOL_SHIFT                   4  /* ADCR_DAC_SVOL - [7:4] */
+#define WM8961_ADCR_DAC_SVOL_WIDTH                   4  /* ADCR_DAC_SVOL - [7:4] */
+#define WM8961_ADC_TO_DACR_MASK                 0x000C  /* ADC_TO_DACR - [3:2] */
+#define WM8961_ADC_TO_DACR_SHIFT                     2  /* ADC_TO_DACR - [3:2] */
+#define WM8961_ADC_TO_DACR_WIDTH                     2  /* ADC_TO_DACR - [3:2] */
+
+/*
+ * R58 (0x3A) - DSP Sidetone 1
+ */
+#define WM8961_ADCL_DAC_SVOL_MASK               0x00F0  /* ADCL_DAC_SVOL - [7:4] */
+#define WM8961_ADCL_DAC_SVOL_SHIFT                   4  /* ADCL_DAC_SVOL - [7:4] */
+#define WM8961_ADCL_DAC_SVOL_WIDTH                   4  /* ADCL_DAC_SVOL - [7:4] */
+#define WM8961_ADC_TO_DACL_MASK                 0x000C  /* ADC_TO_DACL - [3:2] */
+#define WM8961_ADC_TO_DACL_SHIFT                     2  /* ADC_TO_DACL - [3:2] */
+#define WM8961_ADC_TO_DACL_WIDTH                     2  /* ADC_TO_DACL - [3:2] */
+
+/*
+ * R60 (0x3C) - DC Servo 0
+ */
+#define WM8961_DCS_ENA_CHAN_INL                 0x0080  /* DCS_ENA_CHAN_INL */
+#define WM8961_DCS_ENA_CHAN_INL_MASK            0x0080  /* DCS_ENA_CHAN_INL */
+#define WM8961_DCS_ENA_CHAN_INL_SHIFT                7  /* DCS_ENA_CHAN_INL */
+#define WM8961_DCS_ENA_CHAN_INL_WIDTH                1  /* DCS_ENA_CHAN_INL */
+#define WM8961_DCS_TRIG_STARTUP_INL             0x0040  /* DCS_TRIG_STARTUP_INL */
+#define WM8961_DCS_TRIG_STARTUP_INL_MASK        0x0040  /* DCS_TRIG_STARTUP_INL */
+#define WM8961_DCS_TRIG_STARTUP_INL_SHIFT            6  /* DCS_TRIG_STARTUP_INL */
+#define WM8961_DCS_TRIG_STARTUP_INL_WIDTH            1  /* DCS_TRIG_STARTUP_INL */
+#define WM8961_DCS_TRIG_SERIES_INL              0x0010  /* DCS_TRIG_SERIES_INL */
+#define WM8961_DCS_TRIG_SERIES_INL_MASK         0x0010  /* DCS_TRIG_SERIES_INL */
+#define WM8961_DCS_TRIG_SERIES_INL_SHIFT             4  /* DCS_TRIG_SERIES_INL */
+#define WM8961_DCS_TRIG_SERIES_INL_WIDTH             1  /* DCS_TRIG_SERIES_INL */
+#define WM8961_DCS_ENA_CHAN_INR                 0x0008  /* DCS_ENA_CHAN_INR */
+#define WM8961_DCS_ENA_CHAN_INR_MASK            0x0008  /* DCS_ENA_CHAN_INR */
+#define WM8961_DCS_ENA_CHAN_INR_SHIFT                3  /* DCS_ENA_CHAN_INR */
+#define WM8961_DCS_ENA_CHAN_INR_WIDTH                1  /* DCS_ENA_CHAN_INR */
+#define WM8961_DCS_TRIG_STARTUP_INR             0x0004  /* DCS_TRIG_STARTUP_INR */
+#define WM8961_DCS_TRIG_STARTUP_INR_MASK        0x0004  /* DCS_TRIG_STARTUP_INR */
+#define WM8961_DCS_TRIG_STARTUP_INR_SHIFT            2  /* DCS_TRIG_STARTUP_INR */
+#define WM8961_DCS_TRIG_STARTUP_INR_WIDTH            1  /* DCS_TRIG_STARTUP_INR */
+#define WM8961_DCS_TRIG_SERIES_INR              0x0001  /* DCS_TRIG_SERIES_INR */
+#define WM8961_DCS_TRIG_SERIES_INR_MASK         0x0001  /* DCS_TRIG_SERIES_INR */
+#define WM8961_DCS_TRIG_SERIES_INR_SHIFT             0  /* DCS_TRIG_SERIES_INR */
+#define WM8961_DCS_TRIG_SERIES_INR_WIDTH             1  /* DCS_TRIG_SERIES_INR */
+
+/*
+ * R61 (0x3D) - DC Servo 1
+ */
+#define WM8961_DCS_ENA_CHAN_HPL                 0x0080  /* DCS_ENA_CHAN_HPL */
+#define WM8961_DCS_ENA_CHAN_HPL_MASK            0x0080  /* DCS_ENA_CHAN_HPL */
+#define WM8961_DCS_ENA_CHAN_HPL_SHIFT                7  /* DCS_ENA_CHAN_HPL */
+#define WM8961_DCS_ENA_CHAN_HPL_WIDTH                1  /* DCS_ENA_CHAN_HPL */
+#define WM8961_DCS_TRIG_STARTUP_HPL             0x0040  /* DCS_TRIG_STARTUP_HPL */
+#define WM8961_DCS_TRIG_STARTUP_HPL_MASK        0x0040  /* DCS_TRIG_STARTUP_HPL */
+#define WM8961_DCS_TRIG_STARTUP_HPL_SHIFT            6  /* DCS_TRIG_STARTUP_HPL */
+#define WM8961_DCS_TRIG_STARTUP_HPL_WIDTH            1  /* DCS_TRIG_STARTUP_HPL */
+#define WM8961_DCS_TRIG_SERIES_HPL              0x0010  /* DCS_TRIG_SERIES_HPL */
+#define WM8961_DCS_TRIG_SERIES_HPL_MASK         0x0010  /* DCS_TRIG_SERIES_HPL */
+#define WM8961_DCS_TRIG_SERIES_HPL_SHIFT             4  /* DCS_TRIG_SERIES_HPL */
+#define WM8961_DCS_TRIG_SERIES_HPL_WIDTH             1  /* DCS_TRIG_SERIES_HPL */
+#define WM8961_DCS_ENA_CHAN_HPR                 0x0008  /* DCS_ENA_CHAN_HPR */
+#define WM8961_DCS_ENA_CHAN_HPR_MASK            0x0008  /* DCS_ENA_CHAN_HPR */
+#define WM8961_DCS_ENA_CHAN_HPR_SHIFT                3  /* DCS_ENA_CHAN_HPR */
+#define WM8961_DCS_ENA_CHAN_HPR_WIDTH                1  /* DCS_ENA_CHAN_HPR */
+#define WM8961_DCS_TRIG_STARTUP_HPR             0x0004  /* DCS_TRIG_STARTUP_HPR */
+#define WM8961_DCS_TRIG_STARTUP_HPR_MASK        0x0004  /* DCS_TRIG_STARTUP_HPR */
+#define WM8961_DCS_TRIG_STARTUP_HPR_SHIFT            2  /* DCS_TRIG_STARTUP_HPR */
+#define WM8961_DCS_TRIG_STARTUP_HPR_WIDTH            1  /* DCS_TRIG_STARTUP_HPR */
+#define WM8961_DCS_TRIG_SERIES_HPR              0x0001  /* DCS_TRIG_SERIES_HPR */
+#define WM8961_DCS_TRIG_SERIES_HPR_MASK         0x0001  /* DCS_TRIG_SERIES_HPR */
+#define WM8961_DCS_TRIG_SERIES_HPR_SHIFT             0  /* DCS_TRIG_SERIES_HPR */
+#define WM8961_DCS_TRIG_SERIES_HPR_WIDTH             1  /* DCS_TRIG_SERIES_HPR */
+
+/*
+ * R63 (0x3F) - DC Servo 3
+ */
+#define WM8961_DCS_FILT_BW_SERIES_MASK          0x0030  /* DCS_FILT_BW_SERIES - [5:4] */
+#define WM8961_DCS_FILT_BW_SERIES_SHIFT              4  /* DCS_FILT_BW_SERIES - [5:4] */
+#define WM8961_DCS_FILT_BW_SERIES_WIDTH              2  /* DCS_FILT_BW_SERIES - [5:4] */
+
+/*
+ * R65 (0x41) - DC Servo 5
+ */
+#define WM8961_DCS_SERIES_NO_HP_MASK            0x007F  /* DCS_SERIES_NO_HP - [6:0] */
+#define WM8961_DCS_SERIES_NO_HP_SHIFT                0  /* DCS_SERIES_NO_HP - [6:0] */
+#define WM8961_DCS_SERIES_NO_HP_WIDTH                7  /* DCS_SERIES_NO_HP - [6:0] */
+
+/*
+ * R68 (0x44) - Analogue PGA Bias
+ */
+#define WM8961_HP_PGAS_BIAS_MASK                0x0007  /* HP_PGAS_BIAS - [2:0] */
+#define WM8961_HP_PGAS_BIAS_SHIFT                    0  /* HP_PGAS_BIAS - [2:0] */
+#define WM8961_HP_PGAS_BIAS_WIDTH                    3  /* HP_PGAS_BIAS - [2:0] */
+
+/*
+ * R69 (0x45) - Analogue HP 0
+ */
+#define WM8961_HPL_RMV_SHORT                    0x0080  /* HPL_RMV_SHORT */
+#define WM8961_HPL_RMV_SHORT_MASK               0x0080  /* HPL_RMV_SHORT */
+#define WM8961_HPL_RMV_SHORT_SHIFT                   7  /* HPL_RMV_SHORT */
+#define WM8961_HPL_RMV_SHORT_WIDTH                   1  /* HPL_RMV_SHORT */
+#define WM8961_HPL_ENA_OUTP                     0x0040  /* HPL_ENA_OUTP */
+#define WM8961_HPL_ENA_OUTP_MASK                0x0040  /* HPL_ENA_OUTP */
+#define WM8961_HPL_ENA_OUTP_SHIFT                    6  /* HPL_ENA_OUTP */
+#define WM8961_HPL_ENA_OUTP_WIDTH                    1  /* HPL_ENA_OUTP */
+#define WM8961_HPL_ENA_DLY                      0x0020  /* HPL_ENA_DLY */
+#define WM8961_HPL_ENA_DLY_MASK                 0x0020  /* HPL_ENA_DLY */
+#define WM8961_HPL_ENA_DLY_SHIFT                     5  /* HPL_ENA_DLY */
+#define WM8961_HPL_ENA_DLY_WIDTH                     1  /* HPL_ENA_DLY */
+#define WM8961_HPL_ENA                          0x0010  /* HPL_ENA */
+#define WM8961_HPL_ENA_MASK                     0x0010  /* HPL_ENA */
+#define WM8961_HPL_ENA_SHIFT                         4  /* HPL_ENA */
+#define WM8961_HPL_ENA_WIDTH                         1  /* HPL_ENA */
+#define WM8961_HPR_RMV_SHORT                    0x0008  /* HPR_RMV_SHORT */
+#define WM8961_HPR_RMV_SHORT_MASK               0x0008  /* HPR_RMV_SHORT */
+#define WM8961_HPR_RMV_SHORT_SHIFT                   3  /* HPR_RMV_SHORT */
+#define WM8961_HPR_RMV_SHORT_WIDTH                   1  /* HPR_RMV_SHORT */
+#define WM8961_HPR_ENA_OUTP                     0x0004  /* HPR_ENA_OUTP */
+#define WM8961_HPR_ENA_OUTP_MASK                0x0004  /* HPR_ENA_OUTP */
+#define WM8961_HPR_ENA_OUTP_SHIFT                    2  /* HPR_ENA_OUTP */
+#define WM8961_HPR_ENA_OUTP_WIDTH                    1  /* HPR_ENA_OUTP */
+#define WM8961_HPR_ENA_DLY                      0x0002  /* HPR_ENA_DLY */
+#define WM8961_HPR_ENA_DLY_MASK                 0x0002  /* HPR_ENA_DLY */
+#define WM8961_HPR_ENA_DLY_SHIFT                     1  /* HPR_ENA_DLY */
+#define WM8961_HPR_ENA_DLY_WIDTH                     1  /* HPR_ENA_DLY */
+#define WM8961_HPR_ENA                          0x0001  /* HPR_ENA */
+#define WM8961_HPR_ENA_MASK                     0x0001  /* HPR_ENA */
+#define WM8961_HPR_ENA_SHIFT                         0  /* HPR_ENA */
+#define WM8961_HPR_ENA_WIDTH                         1  /* HPR_ENA */
+
+/*
+ * R71 (0x47) - Analogue HP 2
+ */
+#define WM8961_HPL_VOL_MASK                     0x01C0  /* HPL_VOL - [8:6] */
+#define WM8961_HPL_VOL_SHIFT                         6  /* HPL_VOL - [8:6] */
+#define WM8961_HPL_VOL_WIDTH                         3  /* HPL_VOL - [8:6] */
+#define WM8961_HPR_VOL_MASK                     0x0038  /* HPR_VOL - [5:3] */
+#define WM8961_HPR_VOL_SHIFT                         3  /* HPR_VOL - [5:3] */
+#define WM8961_HPR_VOL_WIDTH                         3  /* HPR_VOL - [5:3] */
+#define WM8961_HP_BIAS_BOOST_MASK               0x0007  /* HP_BIAS_BOOST - [2:0] */
+#define WM8961_HP_BIAS_BOOST_SHIFT                   0  /* HP_BIAS_BOOST - [2:0] */
+#define WM8961_HP_BIAS_BOOST_WIDTH                   3  /* HP_BIAS_BOOST - [2:0] */
+
+/*
+ * R72 (0x48) - Charge Pump 1
+ */
+#define WM8961_CP_ENA                           0x0001  /* CP_ENA */
+#define WM8961_CP_ENA_MASK                      0x0001  /* CP_ENA */
+#define WM8961_CP_ENA_SHIFT                          0  /* CP_ENA */
+#define WM8961_CP_ENA_WIDTH                          1  /* CP_ENA */
+
+/*
+ * R82 (0x52) - Charge Pump B
+ */
+#define WM8961_CP_DYN_PWR_MASK                  0x0003  /* CP_DYN_PWR - [1:0] */
+#define WM8961_CP_DYN_PWR_SHIFT                      0  /* CP_DYN_PWR - [1:0] */
+#define WM8961_CP_DYN_PWR_WIDTH                      2  /* CP_DYN_PWR - [1:0] */
+
+/*
+ * R87 (0x57) - Write Sequencer 1
+ */
+#define WM8961_WSEQ_ENA                         0x0020  /* WSEQ_ENA */
+#define WM8961_WSEQ_ENA_MASK                    0x0020  /* WSEQ_ENA */
+#define WM8961_WSEQ_ENA_SHIFT                        5  /* WSEQ_ENA */
+#define WM8961_WSEQ_ENA_WIDTH                        1  /* WSEQ_ENA */
+#define WM8961_WSEQ_WRITE_INDEX_MASK            0x001F  /* WSEQ_WRITE_INDEX - [4:0] */
+#define WM8961_WSEQ_WRITE_INDEX_SHIFT                0  /* WSEQ_WRITE_INDEX - [4:0] */
+#define WM8961_WSEQ_WRITE_INDEX_WIDTH                5  /* WSEQ_WRITE_INDEX - [4:0] */
+
+/*
+ * R88 (0x58) - Write Sequencer 2
+ */
+#define WM8961_WSEQ_EOS                         0x0100  /* WSEQ_EOS */
+#define WM8961_WSEQ_EOS_MASK                    0x0100  /* WSEQ_EOS */
+#define WM8961_WSEQ_EOS_SHIFT                        8  /* WSEQ_EOS */
+#define WM8961_WSEQ_EOS_WIDTH                        1  /* WSEQ_EOS */
+#define WM8961_WSEQ_ADDR_MASK                   0x00FF  /* WSEQ_ADDR - [7:0] */
+#define WM8961_WSEQ_ADDR_SHIFT                       0  /* WSEQ_ADDR - [7:0] */
+#define WM8961_WSEQ_ADDR_WIDTH                       8  /* WSEQ_ADDR - [7:0] */
+
+/*
+ * R89 (0x59) - Write Sequencer 3
+ */
+#define WM8961_WSEQ_DATA_MASK                   0x00FF  /* WSEQ_DATA - [7:0] */
+#define WM8961_WSEQ_DATA_SHIFT                       0  /* WSEQ_DATA - [7:0] */
+#define WM8961_WSEQ_DATA_WIDTH                       8  /* WSEQ_DATA - [7:0] */
+
+/*
+ * R90 (0x5A) - Write Sequencer 4
+ */
+#define WM8961_WSEQ_ABORT                       0x0100  /* WSEQ_ABORT */
+#define WM8961_WSEQ_ABORT_MASK                  0x0100  /* WSEQ_ABORT */
+#define WM8961_WSEQ_ABORT_SHIFT                      8  /* WSEQ_ABORT */
+#define WM8961_WSEQ_ABORT_WIDTH                      1  /* WSEQ_ABORT */
+#define WM8961_WSEQ_START                       0x0080  /* WSEQ_START */
+#define WM8961_WSEQ_START_MASK                  0x0080  /* WSEQ_START */
+#define WM8961_WSEQ_START_SHIFT                      7  /* WSEQ_START */
+#define WM8961_WSEQ_START_WIDTH                      1  /* WSEQ_START */
+#define WM8961_WSEQ_START_INDEX_MASK            0x003F  /* WSEQ_START_INDEX - [5:0] */
+#define WM8961_WSEQ_START_INDEX_SHIFT                0  /* WSEQ_START_INDEX - [5:0] */
+#define WM8961_WSEQ_START_INDEX_WIDTH                6  /* WSEQ_START_INDEX - [5:0] */
+
+/*
+ * R91 (0x5B) - Write Sequencer 5
+ */
+#define WM8961_WSEQ_DATA_WIDTH_MASK             0x0070  /* WSEQ_DATA_WIDTH - [6:4] */
+#define WM8961_WSEQ_DATA_WIDTH_SHIFT                 4  /* WSEQ_DATA_WIDTH - [6:4] */
+#define WM8961_WSEQ_DATA_WIDTH_WIDTH                 3  /* WSEQ_DATA_WIDTH - [6:4] */
+#define WM8961_WSEQ_DATA_START_MASK             0x000F  /* WSEQ_DATA_START - [3:0] */
+#define WM8961_WSEQ_DATA_START_SHIFT                 0  /* WSEQ_DATA_START - [3:0] */
+#define WM8961_WSEQ_DATA_START_WIDTH                 4  /* WSEQ_DATA_START - [3:0] */
+
+/*
+ * R92 (0x5C) - Write Sequencer 6
+ */
+#define WM8961_WSEQ_DELAY_MASK                  0x000F  /* WSEQ_DELAY - [3:0] */
+#define WM8961_WSEQ_DELAY_SHIFT                      0  /* WSEQ_DELAY - [3:0] */
+#define WM8961_WSEQ_DELAY_WIDTH                      4  /* WSEQ_DELAY - [3:0] */
+
+/*
+ * R93 (0x5D) - Write Sequencer 7
+ */
+#define WM8961_WSEQ_BUSY                        0x0001  /* WSEQ_BUSY */
+#define WM8961_WSEQ_BUSY_MASK                   0x0001  /* WSEQ_BUSY */
+#define WM8961_WSEQ_BUSY_SHIFT                       0  /* WSEQ_BUSY */
+#define WM8961_WSEQ_BUSY_WIDTH                       1  /* WSEQ_BUSY */
+
+/*
+ * R252 (0xFC) - General test 1
+ */
+#define WM8961_ARA_ENA                          0x0002  /* ARA_ENA */
+#define WM8961_ARA_ENA_MASK                     0x0002  /* ARA_ENA */
+#define WM8961_ARA_ENA_SHIFT                         1  /* ARA_ENA */
+#define WM8961_ARA_ENA_WIDTH                         1  /* ARA_ENA */
+#define WM8961_AUTO_INC                         0x0001  /* AUTO_INC */
+#define WM8961_AUTO_INC_MASK                    0x0001  /* AUTO_INC */
+#define WM8961_AUTO_INC_SHIFT                        0  /* AUTO_INC */
+#define WM8961_AUTO_INC_WIDTH                        1  /* AUTO_INC */
+
+#endif
diff --git a/sound/soc/codecs/wm8971.c b/sound/soc/codecs/wm8971.c
index 032dca22dbd3..d66efb0546ea 100644
--- a/sound/soc/codecs/wm8971.c
+++ b/sound/soc/codecs/wm8971.c
@@ -59,44 +59,7 @@ static const u16 wm8971_reg[] = {
         0x0079, 0x0079, 0x0079,          /* 40 */
 };
 
-static inline unsigned int wm8971_read_reg_cache(struct snd_soc_codec *codec,
-        unsigned int reg)
-{
-        u16 *cache = codec->reg_cache;
-        if (reg < WM8971_REG_COUNT)
-                return cache[reg];
-
-        return -1;
-}
-
-static inline void wm8971_write_reg_cache(struct snd_soc_codec *codec,
-        unsigned int reg, unsigned int value)
-{
-        u16 *cache = codec->reg_cache;
-        if (reg < WM8971_REG_COUNT)
-                cache[reg] = value;
-}
-
-static int wm8971_write(struct snd_soc_codec *codec, unsigned int reg,
-        unsigned int value)
-{
-        u8 data[2];
-
-        /* data is
-         *   D15..D9 WM8753 register offset
-         *   D8...D0 register data
-         */
-        data[0] = (reg << 1) | ((value >> 8) & 0x0001);
-        data[1] = value & 0x00ff;
-
-        wm8971_write_reg_cache (codec, reg, value);
-        if (codec->hw_write(codec->control_data, data, 2) == 2)
-                return 0;
-        else
-                return -EIO;
-}
-
-#define wm8971_reset(c) wm8971_write(c, WM8971_RESET, 0)
+#define wm8971_reset(c) snd_soc_write(c, WM8971_RESET, 0)
 
 /* WM8971 Controls */
 static const char *wm8971_bass[] = { "Linear Control", "Adaptive Boost" };
@@ -521,7 +484,7 @@ static int wm8971_set_dai_fmt(struct snd_soc_dai *codec_dai,
                 return -EINVAL;
         }
 
-        wm8971_write(codec, WM8971_IFACE, iface);
+        snd_soc_write(codec, WM8971_IFACE, iface);
         return 0;
 }
 
@@ -533,8 +496,8 @@ static int wm8971_pcm_hw_params(struct snd_pcm_substream *substream,
         struct snd_soc_device *socdev = rtd->socdev;
         struct snd_soc_codec *codec = socdev->card->codec;
         struct wm8971_priv *wm8971 = codec->private_data;
-        u16 iface = wm8971_read_reg_cache(codec, WM8971_IFACE) & 0x1f3;
-        u16 srate = wm8971_read_reg_cache(codec, WM8971_SRATE) & 0x1c0;
+        u16 iface = snd_soc_read(codec, WM8971_IFACE) & 0x1f3;
+        u16 srate = snd_soc_read(codec, WM8971_SRATE) & 0x1c0;
         int coeff = get_coeff(wm8971->sysclk, params_rate(params));
 
         /* bit size */
@@ -553,9 +516,9 @@ static int wm8971_pcm_hw_params(struct snd_pcm_substream *substream,
         }
 
         /* set iface & srate */
-        wm8971_write(codec, WM8971_IFACE, iface);
+        snd_soc_write(codec, WM8971_IFACE, iface);
         if (coeff >= 0)
-                wm8971_write(codec, WM8971_SRATE, srate |
+                snd_soc_write(codec, WM8971_SRATE, srate |
                         (coeff_div[coeff].sr << 1) | coeff_div[coeff].usb);
 
         return 0;
@@ -564,33 +527,33 @@ static int wm8971_pcm_hw_params(struct snd_pcm_substream *substream,
 static int wm8971_mute(struct snd_soc_dai *dai, int mute)
 {
         struct snd_soc_codec *codec = dai->codec;
-        u16 mute_reg = wm8971_read_reg_cache(codec, WM8971_ADCDAC) & 0xfff7;
+        u16 mute_reg = snd_soc_read(codec, WM8971_ADCDAC) & 0xfff7;
 
         if (mute)
-                wm8971_write(codec, WM8971_ADCDAC, mute_reg | 0x8);
+                snd_soc_write(codec, WM8971_ADCDAC, mute_reg | 0x8);
         else
-                wm8971_write(codec, WM8971_ADCDAC, mute_reg);
+                snd_soc_write(codec, WM8971_ADCDAC, mute_reg);
         return 0;
 }
 
 static int wm8971_set_bias_level(struct snd_soc_codec *codec,
         enum snd_soc_bias_level level)
 {
-        u16 pwr_reg = wm8971_read_reg_cache(codec, WM8971_PWR1) & 0xfe3e;
+        u16 pwr_reg = snd_soc_read(codec, WM8971_PWR1) & 0xfe3e;
 
         switch (level) {
         case SND_SOC_BIAS_ON:
                 /* set vmid to 50k and unmute dac */
-                wm8971_write(codec, WM8971_PWR1, pwr_reg | 0x00c1);
+                snd_soc_write(codec, WM8971_PWR1, pwr_reg | 0x00c1);
                 break;
         case SND_SOC_BIAS_PREPARE:
                 break;
         case SND_SOC_BIAS_STANDBY:
                 /* mute dac and set vmid to 500k, enable VREF */
-                wm8971_write(codec, WM8971_PWR1, pwr_reg | 0x0140);
+                snd_soc_write(codec, WM8971_PWR1, pwr_reg | 0x0140);
                 break;
         case SND_SOC_BIAS_OFF:
-                wm8971_write(codec, WM8971_PWR1, 0x0001);
+                snd_soc_write(codec, WM8971_PWR1, 0x0001);
                 break;
         }
         codec->bias_level = level;
@@ -667,8 +630,8 @@ static int wm8971_resume(struct platform_device *pdev)
 
         /* charge wm8971 caps */
         if (codec->suspend_bias_level == SND_SOC_BIAS_ON) {
-                reg = wm8971_read_reg_cache(codec, WM8971_PWR1) & 0xfe3e;
-                wm8971_write(codec, WM8971_PWR1, reg | 0x01c0);
+                reg = snd_soc_read(codec, WM8971_PWR1) & 0xfe3e;
+                snd_soc_write(codec, WM8971_PWR1, reg | 0x01c0);
                 codec->bias_level = SND_SOC_BIAS_ON;
                 queue_delayed_work(wm8971_workq, &codec->delayed_work,
                         msecs_to_jiffies(1000));
@@ -677,15 +640,14 @@ static int wm8971_resume(struct platform_device *pdev)
         return 0;
 }
 
-static int wm8971_init(struct snd_soc_device *socdev)
+static int wm8971_init(struct snd_soc_device *socdev,
+                       enum snd_soc_control_type control)
 {
         struct snd_soc_codec *codec = socdev->card->codec;
         int reg, ret = 0;
 
         codec->name = "WM8971";
         codec->owner = THIS_MODULE;
-        codec->read = wm8971_read_reg_cache;
-        codec->write = wm8971_write;
         codec->set_bias_level = wm8971_set_bias_level;
         codec->dai = &wm8971_dai;
         codec->reg_cache_size = ARRAY_SIZE(wm8971_reg);
@@ -695,42 +657,48 @@ static int wm8971_init(struct snd_soc_device *socdev)
         if (codec->reg_cache == NULL)
                 return -ENOMEM;
 
+        ret = snd_soc_codec_set_cache_io(codec, 7, 9, control);
+        if (ret < 0) {
+                printk(KERN_ERR "wm8971: failed to set cache I/O: %d\n", ret);
+                goto err;
+        }
+
         wm8971_reset(codec);
 
         /* register pcms */
         ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
         if (ret < 0) {
                 printk(KERN_ERR "wm8971: failed to create pcms\n");
-                goto pcm_err;
+                goto err;
         }
 
         /* charge output caps - set vmid to 5k for quick power up */
-        reg = wm8971_read_reg_cache(codec, WM8971_PWR1) & 0xfe3e;
-        wm8971_write(codec, WM8971_PWR1, reg | 0x01c0);
+        reg = snd_soc_read(codec, WM8971_PWR1) & 0xfe3e;
+        snd_soc_write(codec, WM8971_PWR1, reg | 0x01c0);
         codec->bias_level = SND_SOC_BIAS_STANDBY;
         queue_delayed_work(wm8971_workq, &codec->delayed_work,
                 msecs_to_jiffies(1000));
 
         /* set the update bits */
-        reg = wm8971_read_reg_cache(codec, WM8971_LDAC);
-        wm8971_write(codec, WM8971_LDAC, reg | 0x0100);
-        reg = wm8971_read_reg_cache(codec, WM8971_RDAC);
-        wm8971_write(codec, WM8971_RDAC, reg | 0x0100);
-
-        reg = wm8971_read_reg_cache(codec, WM8971_LOUT1V);
-        wm8971_write(codec, WM8971_LOUT1V, reg | 0x0100);
-        reg = wm8971_read_reg_cache(codec, WM8971_ROUT1V);
-        wm8971_write(codec, WM8971_ROUT1V, reg | 0x0100);
-
-        reg = wm8971_read_reg_cache(codec, WM8971_LOUT2V);
-        wm8971_write(codec, WM8971_LOUT2V, reg | 0x0100);
-        reg = wm8971_read_reg_cache(codec, WM8971_ROUT2V);
-        wm8971_write(codec, WM8971_ROUT2V, reg | 0x0100);
-
-        reg = wm8971_read_reg_cache(codec, WM8971_LINVOL);
-        wm8971_write(codec, WM8971_LINVOL, reg | 0x0100);
-        reg = wm8971_read_reg_cache(codec, WM8971_RINVOL);
-        wm8971_write(codec, WM8971_RINVOL, reg | 0x0100);
+        reg = snd_soc_read(codec, WM8971_LDAC);
+        snd_soc_write(codec, WM8971_LDAC, reg | 0x0100);
+        reg = snd_soc_read(codec, WM8971_RDAC);
+        snd_soc_write(codec, WM8971_RDAC, reg | 0x0100);
+
+        reg = snd_soc_read(codec, WM8971_LOUT1V);
+        snd_soc_write(codec, WM8971_LOUT1V, reg | 0x0100);
+        reg = snd_soc_read(codec, WM8971_ROUT1V);
+        snd_soc_write(codec, WM8971_ROUT1V, reg | 0x0100);
+
+        reg = snd_soc_read(codec, WM8971_LOUT2V);
+        snd_soc_write(codec, WM8971_LOUT2V, reg | 0x0100);
+        reg = snd_soc_read(codec, WM8971_ROUT2V);
+        snd_soc_write(codec, WM8971_ROUT2V, reg | 0x0100);
+
+        reg = snd_soc_read(codec, WM8971_LINVOL);
+        snd_soc_write(codec, WM8971_LINVOL, reg | 0x0100);
+        reg = snd_soc_read(codec, WM8971_RINVOL);
+        snd_soc_write(codec, WM8971_RINVOL, reg | 0x0100);
 
         snd_soc_add_controls(codec, wm8971_snd_controls,
                                 ARRAY_SIZE(wm8971_snd_controls));
@@ -745,7 +713,7 @@ static int wm8971_init(struct snd_soc_device *socdev)
 card_err:
         snd_soc_free_pcms(socdev);
         snd_soc_dapm_free(socdev);
-pcm_err:
+err:
         kfree(codec->reg_cache);
         return ret;
 }
@@ -767,7 +735,7 @@ static int wm8971_i2c_probe(struct i2c_client *i2c,
 
         codec->control_data = i2c;
 
-        ret = wm8971_init(socdev);
+        ret = wm8971_init(socdev, SND_SOC_I2C);
         if (ret < 0)
                 pr_err("failed to initialise WM8971\n");
 
@@ -877,7 +845,6 @@ static int wm8971_probe(struct platform_device *pdev)
 
 #if defined (CONFIG_I2C) || defined (CONFIG_I2C_MODULE)
         if (setup->i2c_address) {
-                codec->hw_write = (hw_write_t)i2c_master_send;
                 ret = wm8971_add_i2c_device(pdev, setup);
         }
 #endif
diff --git a/sound/soc/codecs/wm8974.c b/sound/soc/codecs/wm8974.c
new file mode 100644
index 000000000000..d8a013ab3177
--- /dev/null
+++ b/sound/soc/codecs/wm8974.c
@@ -0,0 +1,808 @@
+/*
+ * wm8974.c  --  WM8974 ALSA Soc Audio driver
+ *
+ * Copyright 2006-2009 Wolfson Microelectronics PLC.
+ *
+ * Author: Liam Girdwood <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 version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/version.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 <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 "wm8974.h"
+
+static const u16 wm8974_reg[WM8974_CACHEREGNUM] = {
+        0x0000, 0x0000, 0x0000, 0x0000,
+        0x0050, 0x0000, 0x0140, 0x0000,
+        0x0000, 0x0000, 0x0000, 0x00ff,
+        0x0000, 0x0000, 0x0100, 0x00ff,
+        0x0000, 0x0000, 0x012c, 0x002c,
+        0x002c, 0x002c, 0x002c, 0x0000,
+        0x0032, 0x0000, 0x0000, 0x0000,
+        0x0000, 0x0000, 0x0000, 0x0000,
+        0x0038, 0x000b, 0x0032, 0x0000,
+        0x0008, 0x000c, 0x0093, 0x00e9,
+        0x0000, 0x0000, 0x0000, 0x0000,
+        0x0003, 0x0010, 0x0000, 0x0000,
+        0x0000, 0x0002, 0x0000, 0x0000,
+        0x0000, 0x0000, 0x0039, 0x0000,
+        0x0000,
+};
+
+#define WM8974_POWER1_BIASEN  0x08
+#define WM8974_POWER1_BUFIOEN 0x10
+
+struct wm8974_priv {
+        struct snd_soc_codec codec;
+        u16 reg_cache[WM8974_CACHEREGNUM];
+};
+
+static struct snd_soc_codec *wm8974_codec;
+
+#define wm8974_reset(c) snd_soc_write(c, WM8974_RESET, 0)
+
+static const char *wm8974_companding[] = {"Off", "NC", "u-law", "A-law" };
+static const char *wm8974_deemp[] = {"None", "32kHz", "44.1kHz", "48kHz" };
+static const char *wm8974_eqmode[] = {"Capture", "Playback" };
+static const char *wm8974_bw[] = {"Narrow", "Wide" };
+static const char *wm8974_eq1[] = {"80Hz", "105Hz", "135Hz", "175Hz" };
+static const char *wm8974_eq2[] = {"230Hz", "300Hz", "385Hz", "500Hz" };
+static const char *wm8974_eq3[] = {"650Hz", "850Hz", "1.1kHz", "1.4kHz" };
+static const char *wm8974_eq4[] = {"1.8kHz", "2.4kHz", "3.2kHz", "4.1kHz" };
+static const char *wm8974_eq5[] = {"5.3kHz", "6.9kHz", "9kHz", "11.7kHz" };
+static const char *wm8974_alc[] = {"ALC", "Limiter" };
+
+static const struct soc_enum wm8974_enum[] = {
+        SOC_ENUM_SINGLE(WM8974_COMP, 1, 4, wm8974_companding), /* adc */
+        SOC_ENUM_SINGLE(WM8974_COMP, 3, 4, wm8974_companding), /* dac */
+        SOC_ENUM_SINGLE(WM8974_DAC,  4, 4, wm8974_deemp),
+        SOC_ENUM_SINGLE(WM8974_EQ1,  8, 2, wm8974_eqmode),
+
+        SOC_ENUM_SINGLE(WM8974_EQ1,  5, 4, wm8974_eq1),
+        SOC_ENUM_SINGLE(WM8974_EQ2,  8, 2, wm8974_bw),
+        SOC_ENUM_SINGLE(WM8974_EQ2,  5, 4, wm8974_eq2),
+        SOC_ENUM_SINGLE(WM8974_EQ3,  8, 2, wm8974_bw),
+
+        SOC_ENUM_SINGLE(WM8974_EQ3,  5, 4, wm8974_eq3),
+        SOC_ENUM_SINGLE(WM8974_EQ4,  8, 2, wm8974_bw),
+        SOC_ENUM_SINGLE(WM8974_EQ4,  5, 4, wm8974_eq4),
+        SOC_ENUM_SINGLE(WM8974_EQ5,  8, 2, wm8974_bw),
+
+        SOC_ENUM_SINGLE(WM8974_EQ5,  5, 4, wm8974_eq5),
+        SOC_ENUM_SINGLE(WM8974_ALC3,  8, 2, wm8974_alc),
+};
+
+static const char *wm8974_auxmode_text[] = { "Buffer", "Mixer" };
+
+static const struct soc_enum wm8974_auxmode =
+        SOC_ENUM_SINGLE(WM8974_INPUT,  3, 2, wm8974_auxmode_text);
+
+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 struct snd_kcontrol_new wm8974_snd_controls[] = {
+
+SOC_SINGLE("Digital Loopback Switch", WM8974_COMP, 0, 1, 0),
+
+SOC_ENUM("DAC Companding", wm8974_enum[1]),
+SOC_ENUM("ADC Companding", wm8974_enum[0]),
+
+SOC_ENUM("Playback De-emphasis", wm8974_enum[2]),
+SOC_SINGLE("DAC Inversion Switch", WM8974_DAC, 0, 1, 0),
+
+SOC_SINGLE_TLV("PCM Volume", WM8974_DACVOL, 0, 255, 0, digital_tlv),
+
+SOC_SINGLE("High Pass Filter Switch", WM8974_ADC, 8, 1, 0),
+SOC_SINGLE("High Pass Cut Off", WM8974_ADC, 4, 7, 0),
+SOC_SINGLE("ADC Inversion Switch", WM8974_ADC, 0, 1, 0),
+
+SOC_SINGLE_TLV("Capture Volume", WM8974_ADCVOL,  0, 255, 0, digital_tlv),
+
+SOC_ENUM("Equaliser Function", wm8974_enum[3]),
+SOC_ENUM("EQ1 Cut Off", wm8974_enum[4]),
+SOC_SINGLE_TLV("EQ1 Volume", WM8974_EQ1,  0, 24, 1, eq_tlv),
+
+SOC_ENUM("Equaliser EQ2 Bandwith", wm8974_enum[5]),
+SOC_ENUM("EQ2 Cut Off", wm8974_enum[6]),
+SOC_SINGLE_TLV("EQ2 Volume", WM8974_EQ2,  0, 24, 1, eq_tlv),
+
+SOC_ENUM("Equaliser EQ3 Bandwith", wm8974_enum[7]),
+SOC_ENUM("EQ3 Cut Off", wm8974_enum[8]),
+SOC_SINGLE_TLV("EQ3 Volume", WM8974_EQ3,  0, 24, 1, eq_tlv),
+
+SOC_ENUM("Equaliser EQ4 Bandwith", wm8974_enum[9]),
+SOC_ENUM("EQ4 Cut Off", wm8974_enum[10]),
+SOC_SINGLE_TLV("EQ4 Volume", WM8974_EQ4,  0, 24, 1, eq_tlv),
+
+SOC_ENUM("Equaliser EQ5 Bandwith", wm8974_enum[11]),
+SOC_ENUM("EQ5 Cut Off", wm8974_enum[12]),
+SOC_SINGLE_TLV("EQ5 Volume", WM8974_EQ5,  0, 24, 1, eq_tlv),
+
+SOC_SINGLE("DAC Playback Limiter Switch", WM8974_DACLIM1,  8, 1, 0),
+SOC_SINGLE("DAC Playback Limiter Decay", WM8974_DACLIM1,  4, 15, 0),
+SOC_SINGLE("DAC Playback Limiter Attack", WM8974_DACLIM1,  0, 15, 0),
+
+SOC_SINGLE("DAC Playback Limiter Threshold", WM8974_DACLIM2,  4, 7, 0),
+SOC_SINGLE("DAC Playback Limiter Boost", WM8974_DACLIM2,  0, 15, 0),
+
+SOC_SINGLE("ALC Enable Switch", WM8974_ALC1,  8, 1, 0),
+SOC_SINGLE("ALC Capture Max Gain", WM8974_ALC1,  3, 7, 0),
+SOC_SINGLE("ALC Capture Min Gain", WM8974_ALC1,  0, 7, 0),
+
+SOC_SINGLE("ALC Capture ZC Switch", WM8974_ALC2,  8, 1, 0),
+SOC_SINGLE("ALC Capture Hold", WM8974_ALC2,  4, 7, 0),
+SOC_SINGLE("ALC Capture Target", WM8974_ALC2,  0, 15, 0),
+
+SOC_ENUM("ALC Capture Mode", wm8974_enum[13]),
+SOC_SINGLE("ALC Capture Decay", WM8974_ALC3,  4, 15, 0),
+SOC_SINGLE("ALC Capture Attack", WM8974_ALC3,  0, 15, 0),
+
+SOC_SINGLE("ALC Capture Noise Gate Switch", WM8974_NGATE,  3, 1, 0),
+SOC_SINGLE("ALC Capture Noise Gate Threshold", WM8974_NGATE,  0, 7, 0),
+
+SOC_SINGLE("Capture PGA ZC Switch", WM8974_INPPGA,  7, 1, 0),
+SOC_SINGLE_TLV("Capture PGA Volume", WM8974_INPPGA,  0, 63, 0, inpga_tlv),
+
+SOC_SINGLE("Speaker Playback ZC Switch", WM8974_SPKVOL,  7, 1, 0),
+SOC_SINGLE("Speaker Playback Switch", WM8974_SPKVOL,  6, 1, 1),
+SOC_SINGLE_TLV("Speaker Playback Volume", WM8974_SPKVOL,  0, 63, 0, spk_tlv),
+
+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),
+};
+
+/* Speaker Output Mixer */
+static const struct snd_kcontrol_new wm8974_speaker_mixer_controls[] = {
+SOC_DAPM_SINGLE("Line Bypass Switch", WM8974_SPKMIX, 1, 1, 0),
+SOC_DAPM_SINGLE("Aux Playback Switch", WM8974_SPKMIX, 5, 1, 0),
+SOC_DAPM_SINGLE("PCM Playback Switch", WM8974_SPKMIX, 0, 1, 1),
+};
+
+/* Mono Output Mixer */
+static const struct snd_kcontrol_new wm8974_mono_mixer_controls[] = {
+SOC_DAPM_SINGLE("Line Bypass Switch", WM8974_MONOMIX, 1, 1, 0),
+SOC_DAPM_SINGLE("Aux Playback Switch", WM8974_MONOMIX, 2, 1, 0),
+SOC_DAPM_SINGLE("PCM Playback Switch", WM8974_MONOMIX, 0, 1, 0),
+};
+
+/* Boost mixer */
+static const struct snd_kcontrol_new wm8974_boost_mixer[] = {
+SOC_DAPM_SINGLE("Aux Switch", WM8974_INPPGA, 6, 1, 0),
+};
+
+/* Input PGA */
+static const struct snd_kcontrol_new wm8974_inpga[] = {
+SOC_DAPM_SINGLE("Aux Switch", WM8974_INPUT, 2, 1, 0),
+SOC_DAPM_SINGLE("MicN Switch", WM8974_INPUT, 1, 1, 0),
+SOC_DAPM_SINGLE("MicP Switch", WM8974_INPUT, 0, 1, 0),
+};
+
+/* AUX Input boost vol */
+static const struct snd_kcontrol_new wm8974_aux_boost_controls =
+SOC_DAPM_SINGLE("Aux Volume", WM8974_ADCBOOST, 0, 7, 0);
+
+/* Mic Input boost vol */
+static const struct snd_kcontrol_new wm8974_mic_boost_controls =
+SOC_DAPM_SINGLE("Mic Volume", WM8974_ADCBOOST, 4, 7, 0);
+
+static const struct snd_soc_dapm_widget wm8974_dapm_widgets[] = {
+SND_SOC_DAPM_MIXER("Speaker Mixer", WM8974_POWER3, 2, 0,
+        &wm8974_speaker_mixer_controls[0],
+        ARRAY_SIZE(wm8974_speaker_mixer_controls)),
+SND_SOC_DAPM_MIXER("Mono Mixer", WM8974_POWER3, 3, 0,
+        &wm8974_mono_mixer_controls[0],
+        ARRAY_SIZE(wm8974_mono_mixer_controls)),
+SND_SOC_DAPM_DAC("DAC", "HiFi Playback", WM8974_POWER3, 0, 0),
+SND_SOC_DAPM_ADC("ADC", "HiFi Capture", WM8974_POWER2, 0, 0),
+SND_SOC_DAPM_PGA("Aux Input", WM8974_POWER1, 6, 0, NULL, 0),
+SND_SOC_DAPM_PGA("SpkN Out", WM8974_POWER3, 5, 0, NULL, 0),
+SND_SOC_DAPM_PGA("SpkP Out", WM8974_POWER3, 6, 0, NULL, 0),
+SND_SOC_DAPM_PGA("Mono Out", WM8974_POWER3, 7, 0, NULL, 0),
+
+SND_SOC_DAPM_MIXER("Input PGA", WM8974_POWER2, 2, 0, wm8974_inpga,
+                   ARRAY_SIZE(wm8974_inpga)),
+SND_SOC_DAPM_MIXER("Boost Mixer", WM8974_POWER2, 4, 0,
+                   wm8974_boost_mixer, ARRAY_SIZE(wm8974_boost_mixer)),
+
+SND_SOC_DAPM_MICBIAS("Mic Bias", WM8974_POWER1, 4, 0),
+
+SND_SOC_DAPM_INPUT("MICN"),
+SND_SOC_DAPM_INPUT("MICP"),
+SND_SOC_DAPM_INPUT("AUX"),
+SND_SOC_DAPM_OUTPUT("MONOOUT"),
+SND_SOC_DAPM_OUTPUT("SPKOUTP"),
+SND_SOC_DAPM_OUTPUT("SPKOUTN"),
+};
+
+static const struct snd_soc_dapm_route audio_map[] = {
+        /* Mono output mixer */
+        {"Mono Mixer", "PCM Playback Switch", "DAC"},
+        {"Mono Mixer", "Aux Playback Switch", "Aux Input"},
+        {"Mono Mixer", "Line Bypass Switch", "Boost Mixer"},
+
+        /* Speaker output mixer */
+        {"Speaker Mixer", "PCM Playback Switch", "DAC"},
+        {"Speaker Mixer", "Aux Playback Switch", "Aux Input"},
+        {"Speaker Mixer", "Line Bypass Switch", "Boost Mixer"},
+
+        /* Outputs */
+        {"Mono Out", NULL, "Mono Mixer"},
+        {"MONOOUT", NULL, "Mono Out"},
+        {"SpkN Out", NULL, "Speaker Mixer"},
+        {"SpkP Out", NULL, "Speaker Mixer"},
+        {"SPKOUTN", NULL, "SpkN Out"},
+        {"SPKOUTP", NULL, "SpkP Out"},
+
+        /* Boost Mixer */
+        {"ADC", NULL, "Boost Mixer"},
+        {"Boost Mixer", "Aux Switch", "Aux Input"},
+        {"Boost Mixer", NULL, "Input PGA"},
+        {"Boost Mixer", NULL, "MICP"},
+
+        /* Input PGA */
+        {"Input PGA", "Aux Switch", "Aux Input"},
+        {"Input PGA", "MicN Switch", "MICN"},
+        {"Input PGA", "MicP Switch", "MICP"},
+
+        /* Inputs */
+        {"Aux Input", NULL, "AUX"},
+};
+
+static int wm8974_add_widgets(struct snd_soc_codec *codec)
+{
+        snd_soc_dapm_new_controls(codec, wm8974_dapm_widgets,
+                                  ARRAY_SIZE(wm8974_dapm_widgets));
+
+        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 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)
+{
+        unsigned long long Kpart;
+        unsigned int K, Ndiv, Nmod;
+
+        Ndiv = target / source;
+        if (Ndiv < 6) {
+                source >>= 1;
+                pll_div.pre_div = 1;
+                Ndiv = target / source;
+        } else
+                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;
+        Nmod = target % source;
+        Kpart = FIXED_PLL_SIZE * (long long)Nmod;
+
+        do_div(Kpart, source);
+
+        K = Kpart & 0xFFFFFFFF;
+
+        /* Check if we need to round */
+        if ((K % 10) >= 5)
+                K += 5;
+
+        /* Move down to proper range now rounding is done */
+        K /= 10;
+
+        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)
+{
+        struct snd_soc_codec *codec = codec_dai->codec;
+        u16 reg;
+
+        if (freq_in == 0 || freq_out == 0) {
+                /* Clock CODEC directly from MCLK */
+                reg = snd_soc_read(codec, WM8974_CLOCK);
+                snd_soc_write(codec, WM8974_CLOCK, reg & 0x0ff);
+
+                /* Turn off PLL */
+                reg = snd_soc_read(codec, WM8974_POWER1);
+                snd_soc_write(codec, WM8974_POWER1, reg & 0x1df);
+                return 0;
+        }
+
+        pll_factors(freq_out*4, 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);
+        snd_soc_write(codec, WM8974_PLLK2, (pll_div.k >> 9) & 0x1ff);
+        snd_soc_write(codec, WM8974_PLLK3, pll_div.k & 0x1ff);
+        reg = snd_soc_read(codec, WM8974_POWER1);
+        snd_soc_write(codec, WM8974_POWER1, reg | 0x020);
+
+        /* Run CODEC from PLL instead of MCLK */
+        reg = snd_soc_read(codec, WM8974_CLOCK);
+        snd_soc_write(codec, WM8974_CLOCK, reg | 0x100);
+
+        return 0;
+}
+
+/*
+ * Configure WM8974 clock dividers.
+ */
+static int wm8974_set_dai_clkdiv(struct snd_soc_dai *codec_dai,
+                int div_id, int div)
+{
+        struct snd_soc_codec *codec = codec_dai->codec;
+        u16 reg;
+
+        switch (div_id) {
+        case WM8974_OPCLKDIV:
+                reg = snd_soc_read(codec, WM8974_GPIO) & 0x1cf;
+                snd_soc_write(codec, WM8974_GPIO, reg | div);
+                break;
+        case WM8974_MCLKDIV:
+                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);
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int wm8974_set_dai_fmt(struct snd_soc_dai *codec_dai,
+                unsigned int fmt)
+{
+        struct snd_soc_codec *codec = codec_dai->codec;
+        u16 iface = 0;
+        u16 clk = snd_soc_read(codec, WM8974_CLOCK) & 0x1fe;
+
+        /* set master/slave audio interface */
+        switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
+        case SND_SOC_DAIFMT_CBM_CFM:
+                clk |= 0x0001;
+                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 |= 0x0010;
+                break;
+        case SND_SOC_DAIFMT_RIGHT_J:
+                break;
+        case SND_SOC_DAIFMT_LEFT_J:
+                iface |= 0x0008;
+                break;
+        case SND_SOC_DAIFMT_DSP_A:
+                iface |= 0x00018;
+                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 |= 0x0180;
+                break;
+        case SND_SOC_DAIFMT_IB_NF:
+                iface |= 0x0100;
+                break;
+        case SND_SOC_DAIFMT_NB_IF:
+                iface |= 0x0080;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        snd_soc_write(codec, WM8974_IFACE, iface);
+        snd_soc_write(codec, WM8974_CLOCK, clk);
+        return 0;
+}
+
+static int wm8974_pcm_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;
+        u16 iface = snd_soc_read(codec, WM8974_IFACE) & 0x19f;
+        u16 adn = snd_soc_read(codec, WM8974_ADD) & 0x1f1;
+
+        /* bit size */
+        switch (params_format(params)) {
+        case SNDRV_PCM_FORMAT_S16_LE:
+                break;
+        case SNDRV_PCM_FORMAT_S20_3LE:
+                iface |= 0x0020;
+                break;
+        case SNDRV_PCM_FORMAT_S24_LE:
+                iface |= 0x0040;
+                break;
+        case SNDRV_PCM_FORMAT_S32_LE:
+                iface |= 0x0060;
+                break;
+        }
+
+        /* filter coefficient */
+        switch (params_rate(params)) {
+        case SNDRV_PCM_RATE_8000:
+                adn |= 0x5 << 1;
+                break;
+        case SNDRV_PCM_RATE_11025:
+                adn |= 0x4 << 1;
+                break;
+        case SNDRV_PCM_RATE_16000:
+                adn |= 0x3 << 1;
+                break;
+        case SNDRV_PCM_RATE_22050:
+                adn |= 0x2 << 1;
+                break;
+        case SNDRV_PCM_RATE_32000:
+                adn |= 0x1 << 1;
+                break;
+        case SNDRV_PCM_RATE_44100:
+        case SNDRV_PCM_RATE_48000:
+                break;
+        }
+
+        snd_soc_write(codec, WM8974_IFACE, iface);
+        snd_soc_write(codec, WM8974_ADD, adn);
+        return 0;
+}
+
+static int wm8974_mute(struct snd_soc_dai *dai, int mute)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        u16 mute_reg = snd_soc_read(codec, WM8974_DAC) & 0xffbf;
+
+        if (mute)
+                snd_soc_write(codec, WM8974_DAC, mute_reg | 0x40);
+        else
+                snd_soc_write(codec, WM8974_DAC, mute_reg);
+        return 0;
+}
+
+/* liam need to make this lower power with dapm */
+static int wm8974_set_bias_level(struct snd_soc_codec *codec,
+        enum snd_soc_bias_level level)
+{
+        u16 power1 = snd_soc_read(codec, WM8974_POWER1) & ~0x3;
+
+        switch (level) {
+        case SND_SOC_BIAS_ON:
+        case SND_SOC_BIAS_PREPARE:
+                power1 |= 0x1;  /* VMID 50k */
+                snd_soc_write(codec, WM8974_POWER1, power1);
+                break;
+
+        case SND_SOC_BIAS_STANDBY:
+                power1 |= WM8974_POWER1_BIASEN | WM8974_POWER1_BUFIOEN;
+
+                if (codec->bias_level == SND_SOC_BIAS_OFF) {
+                        /* Initial cap charge at VMID 5k */
+                        snd_soc_write(codec, WM8974_POWER1, power1 | 0x3);
+                        mdelay(100);
+                }
+
+                power1 |= 0x2;  /* VMID 500k */
+                snd_soc_write(codec, WM8974_POWER1, power1);
+                break;
+
+        case SND_SOC_BIAS_OFF:
+                snd_soc_write(codec, WM8974_POWER1, 0);
+                snd_soc_write(codec, WM8974_POWER2, 0);
+                snd_soc_write(codec, WM8974_POWER3, 0);
+                break;
+        }
+
+        codec->bias_level = level;
+        return 0;
+}
+
+#define WM8974_RATES (SNDRV_PCM_RATE_8000_48000)
+
+#define WM8974_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
+        SNDRV_PCM_FMTBIT_S24_LE)
+
+static struct snd_soc_dai_ops wm8974_ops = {
+        .hw_params = wm8974_pcm_hw_params,
+        .digital_mute = wm8974_mute,
+        .set_fmt = wm8974_set_dai_fmt,
+        .set_clkdiv = wm8974_set_dai_clkdiv,
+        .set_pll = wm8974_set_dai_pll,
+};
+
+struct snd_soc_dai wm8974_dai = {
+        .name = "WM8974 HiFi",
+        .playback = {
+                .stream_name = "Playback",
+                .channels_min = 1,
+                .channels_max = 2,   /* Only 1 channel of data */
+                .rates = WM8974_RATES,
+                .formats = WM8974_FORMATS,},
+        .capture = {
+                .stream_name = "Capture",
+                .channels_min = 1,
+                .channels_max = 2,   /* Only 1 channel of data */
+                .rates = WM8974_RATES,
+                .formats = WM8974_FORMATS,},
+        .ops = &wm8974_ops,
+        .symmetric_rates = 1,
+};
+EXPORT_SYMBOL_GPL(wm8974_dai);
+
+static int wm8974_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;
+
+        wm8974_set_bias_level(codec, SND_SOC_BIAS_OFF);
+        return 0;
+}
+
+static int wm8974_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(wm8974_reg); i++) {
+                data[0] = (i << 1) | ((cache[i] >> 8) & 0x0001);
+                data[1] = cache[i] & 0x00ff;
+                codec->hw_write(codec->control_data, data, 2);
+        }
+        wm8974_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+        wm8974_set_bias_level(codec, codec->suspend_bias_level);
+        return 0;
+}
+
+static int wm8974_probe(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec;
+        int ret = 0;
+
+        if (wm8974_codec == NULL) {
+                dev_err(&pdev->dev, "Codec device not registered\n");
+                return -ENODEV;
+        }
+
+        socdev->card->codec = wm8974_codec;
+        codec = wm8974_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, 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;
+}
+
+/* power down chip */
+static int wm8974_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_wm8974 = {
+        .probe =        wm8974_probe,
+        .remove =       wm8974_remove,
+        .suspend =      wm8974_suspend,
+        .resume =       wm8974_resume,
+};
+EXPORT_SYMBOL_GPL(soc_codec_dev_wm8974);
+
+static __devinit int wm8974_register(struct wm8974_priv *wm8974)
+{
+        int ret;
+        struct snd_soc_codec *codec = &wm8974->codec;
+
+        if (wm8974_codec) {
+                dev_err(codec->dev, "Another WM8974 is registered\n");
+                return -EINVAL;
+        }
+
+        mutex_init(&codec->mutex);
+        INIT_LIST_HEAD(&codec->dapm_widgets);
+        INIT_LIST_HEAD(&codec->dapm_paths);
+
+        codec->private_data = wm8974;
+        codec->name = "WM8974";
+        codec->owner = THIS_MODULE;
+        codec->bias_level = SND_SOC_BIAS_OFF;
+        codec->set_bias_level = wm8974_set_bias_level;
+        codec->dai = &wm8974_dai;
+        codec->num_dai = 1;
+        codec->reg_cache_size = WM8974_CACHEREGNUM;
+        codec->reg_cache = &wm8974->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, wm8974_reg, sizeof(wm8974_reg));
+
+        ret = wm8974_reset(codec);
+        if (ret < 0) {
+                dev_err(codec->dev, "Failed to issue reset\n");
+                goto err;
+        }
+
+        wm8974_dai.dev = codec->dev;
+
+        wm8974_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+
+        wm8974_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(&wm8974_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(wm8974);
+        return ret;
+}
+
+static __devexit void wm8974_unregister(struct wm8974_priv *wm8974)
+{
+        wm8974_set_bias_level(&wm8974->codec, SND_SOC_BIAS_OFF);
+        snd_soc_unregister_dai(&wm8974_dai);
+        snd_soc_unregister_codec(&wm8974->codec);
+        kfree(wm8974);
+        wm8974_codec = NULL;
+}
+
+static __devinit int wm8974_i2c_probe(struct i2c_client *i2c,
+                                      const struct i2c_device_id *id)
+{
+        struct wm8974_priv *wm8974;
+        struct snd_soc_codec *codec;
+
+        wm8974 = kzalloc(sizeof(struct wm8974_priv), GFP_KERNEL);
+        if (wm8974 == NULL)
+                return -ENOMEM;
+
+        codec = &wm8974->codec;
+        codec->hw_write = (hw_write_t)i2c_master_send;
+
+        i2c_set_clientdata(i2c, wm8974);
+        codec->control_data = i2c;
+
+        codec->dev = &i2c->dev;
+
+        return wm8974_register(wm8974);
+}
+
+static __devexit int wm8974_i2c_remove(struct i2c_client *client)
+{
+        struct wm8974_priv *wm8974 = i2c_get_clientdata(client);
+        wm8974_unregister(wm8974);
+        return 0;
+}
+
+static const struct i2c_device_id wm8974_i2c_id[] = {
+        { "wm8974", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, wm8974_i2c_id);
+
+static struct i2c_driver wm8974_i2c_driver = {
+        .driver = {
+                .name = "WM8974",
+                .owner = THIS_MODULE,
+        },
+        .probe =    wm8974_i2c_probe,
+        .remove =   __devexit_p(wm8974_i2c_remove),
+        .id_table = wm8974_i2c_id,
+};
+
+static int __init wm8974_modinit(void)
+{
+        return i2c_add_driver(&wm8974_i2c_driver);
+}
+module_init(wm8974_modinit);
+
+static void __exit wm8974_exit(void)
+{
+        i2c_del_driver(&wm8974_i2c_driver);
+}
+module_exit(wm8974_exit);
+
+MODULE_DESCRIPTION("ASoC WM8974 driver");
+MODULE_AUTHOR("Liam Girdwood");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/codecs/wm8974.h b/sound/soc/codecs/wm8974.h
new file mode 100644
index 000000000000..98de9562d4d2
--- /dev/null
+++ b/sound/soc/codecs/wm8974.h
@@ -0,0 +1,99 @@
+/*
+ * wm8974.h  --  WM8974 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 _WM8974_H
+#define _WM8974_H
+
+/* WM8974 register space */
+
+#define WM8974_RESET            0x0
+#define WM8974_POWER1           0x1
+#define WM8974_POWER2           0x2
+#define WM8974_POWER3           0x3
+#define WM8974_IFACE            0x4
+#define WM8974_COMP             0x5
+#define WM8974_CLOCK            0x6
+#define WM8974_ADD              0x7
+#define WM8974_GPIO             0x8
+#define WM8974_DAC              0xa
+#define WM8974_DACVOL           0xb
+#define WM8974_ADC              0xe
+#define WM8974_ADCVOL           0xf
+#define WM8974_EQ1              0x12
+#define WM8974_EQ2              0x13
+#define WM8974_EQ3              0x14
+#define WM8974_EQ4              0x15
+#define WM8974_EQ5              0x16
+#define WM8974_DACLIM1          0x18
+#define WM8974_DACLIM2          0x19
+#define WM8974_NOTCH1           0x1b
+#define WM8974_NOTCH2           0x1c
+#define WM8974_NOTCH3           0x1d
+#define WM8974_NOTCH4           0x1e
+#define WM8974_ALC1             0x20
+#define WM8974_ALC2             0x21
+#define WM8974_ALC3             0x22
+#define WM8974_NGATE            0x23
+#define WM8974_PLLN             0x24
+#define WM8974_PLLK1            0x25
+#define WM8974_PLLK2            0x26
+#define WM8974_PLLK3            0x27
+#define WM8974_ATTEN            0x28
+#define WM8974_INPUT            0x2c
+#define WM8974_INPPGA           0x2d
+#define WM8974_ADCBOOST         0x2f
+#define WM8974_OUTPUT           0x31
+#define WM8974_SPKMIX           0x32
+#define WM8974_SPKVOL           0x36
+#define WM8974_MONOMIX          0x38
+
+#define WM8974_CACHEREGNUM      57
+
+/* 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)
+
+/* PLL Out dividers */
+#define WM8974_OPCLKDIV_1       (0 << 4)
+#define WM8974_OPCLKDIV_2       (1 << 4)
+#define WM8974_OPCLKDIV_3       (2 << 4)
+#define WM8974_OPCLKDIV_4       (3 << 4)
+
+/* BCLK clock dividers */
+#define WM8974_BCLKDIV_1        (0 << 2)
+#define WM8974_BCLKDIV_2        (1 << 2)
+#define WM8974_BCLKDIV_4        (2 << 2)
+#define WM8974_BCLKDIV_8        (3 << 2)
+#define WM8974_BCLKDIV_16       (4 << 2)
+#define WM8974_BCLKDIV_32       (5 << 2)
+
+/* MCLK clock dividers */
+#define WM8974_MCLKDIV_1        (0 << 5)
+#define WM8974_MCLKDIV_1_5      (1 << 5)
+#define WM8974_MCLKDIV_2        (2 << 5)
+#define WM8974_MCLKDIV_3        (3 << 5)
+#define WM8974_MCLKDIV_4        (4 << 5)
+#define WM8974_MCLKDIV_6        (5 << 5)
+#define WM8974_MCLKDIV_8        (6 << 5)
+#define WM8974_MCLKDIV_12       (7 << 5)
+
+extern struct snd_soc_dai wm8974_dai;
+extern struct snd_soc_codec_device soc_codec_dev_wm8974;
+
+#endif
diff --git a/sound/soc/codecs/wm8988.c b/sound/soc/codecs/wm8988.c
new file mode 100644
index 000000000000..1c8653523c8c
--- /dev/null
+++ b/sound/soc/codecs/wm8988.c
@@ -0,0 +1,1069 @@
+/*
+ * wm8988.c -- WM8988 ALSA SoC audio driver
+ *
+ * Copyright 2009 Wolfson Microelectronics plc
+ * Copyright 2005 Openedhand Ltd.
+ *
+ * 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/spi/spi.h>
+#include <linux/platform_device.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/tlv.h>
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+#include <sound/initval.h>
+
+#include "wm8988.h"
+
+/*
+ * wm8988 register cache
+ * We can't read the WM8988 register space when we
+ * are using 2 wire for device control, so we cache them instead.
+ */
+static const u16 wm8988_reg[] = {
+        0x0097, 0x0097, 0x0079, 0x0079,  /*  0 */
+        0x0000, 0x0008, 0x0000, 0x000a,  /*  4 */
+        0x0000, 0x0000, 0x00ff, 0x00ff,  /*  8 */
+        0x000f, 0x000f, 0x0000, 0x0000,  /* 12 */
+        0x0000, 0x007b, 0x0000, 0x0032,  /* 16 */
+        0x0000, 0x00c3, 0x00c3, 0x00c0,  /* 20 */
+        0x0000, 0x0000, 0x0000, 0x0000,  /* 24 */
+        0x0000, 0x0000, 0x0000, 0x0000,  /* 28 */
+        0x0000, 0x0000, 0x0050, 0x0050,  /* 32 */
+        0x0050, 0x0050, 0x0050, 0x0050,  /* 36 */
+        0x0079, 0x0079, 0x0079,          /* 40 */
+};
+
+/* codec private data */
+struct wm8988_priv {
+        unsigned int sysclk;
+        struct snd_soc_codec codec;
+        struct snd_pcm_hw_constraint_list *sysclk_constraints;
+        u16 reg_cache[WM8988_NUM_REG];
+};
+
+
+#define wm8988_reset(c) snd_soc_write(c, WM8988_RESET, 0)
+
+/*
+ * WM8988 Controls
+ */
+
+static const char *bass_boost_txt[] = {"Linear Control", "Adaptive Boost"};
+static const struct soc_enum bass_boost =
+        SOC_ENUM_SINGLE(WM8988_BASS, 7, 2, bass_boost_txt);
+
+static const char *bass_filter_txt[] = { "130Hz @ 48kHz", "200Hz @ 48kHz" };
+static const struct soc_enum bass_filter =
+        SOC_ENUM_SINGLE(WM8988_BASS, 6, 2, bass_filter_txt);
+
+static const char *treble_txt[] = {"8kHz", "4kHz"};
+static const struct soc_enum treble =
+        SOC_ENUM_SINGLE(WM8988_TREBLE, 6, 2, treble_txt);
+
+static const char *stereo_3d_lc_txt[] = {"200Hz", "500Hz"};
+static const struct soc_enum stereo_3d_lc =
+        SOC_ENUM_SINGLE(WM8988_3D, 5, 2, stereo_3d_lc_txt);
+
+static const char *stereo_3d_uc_txt[] = {"2.2kHz", "1.5kHz"};
+static const struct soc_enum stereo_3d_uc =
+        SOC_ENUM_SINGLE(WM8988_3D, 6, 2, stereo_3d_uc_txt);
+
+static const char *stereo_3d_func_txt[] = {"Capture", "Playback"};
+static const struct soc_enum stereo_3d_func =
+        SOC_ENUM_SINGLE(WM8988_3D, 7, 2, stereo_3d_func_txt);
+
+static const char *alc_func_txt[] = {"Off", "Right", "Left", "Stereo"};
+static const struct soc_enum alc_func =
+        SOC_ENUM_SINGLE(WM8988_ALC1, 7, 4, alc_func_txt);
+
+static const char *ng_type_txt[] = {"Constant PGA Gain",
+                                    "Mute ADC Output"};
+static const struct soc_enum ng_type =
+        SOC_ENUM_SINGLE(WM8988_NGATE, 1, 2, ng_type_txt);
+
+static const char *deemph_txt[] = {"None", "32Khz", "44.1Khz", "48Khz"};
+static const struct soc_enum deemph =
+        SOC_ENUM_SINGLE(WM8988_ADCDAC, 1, 4, deemph_txt);
+
+static const char *adcpol_txt[] = {"Normal", "L Invert", "R Invert",
+                                   "L + R Invert"};
+static const struct soc_enum adcpol =
+        SOC_ENUM_SINGLE(WM8988_ADCDAC, 5, 4, adcpol_txt);
+
+static const DECLARE_TLV_DB_SCALE(pga_tlv, -1725, 75, 0);
+static const DECLARE_TLV_DB_SCALE(adc_tlv, -9750, 50, 1);
+static const DECLARE_TLV_DB_SCALE(dac_tlv, -12750, 50, 1);
+static const DECLARE_TLV_DB_SCALE(out_tlv, -12100, 100, 1);
+static const DECLARE_TLV_DB_SCALE(bypass_tlv, -1500, 300, 0);
+
+static const struct snd_kcontrol_new wm8988_snd_controls[] = {
+
+SOC_ENUM("Bass Boost", bass_boost),
+SOC_ENUM("Bass Filter", bass_filter),
+SOC_SINGLE("Bass Volume", WM8988_BASS, 0, 15, 1),
+
+SOC_SINGLE("Treble Volume", WM8988_TREBLE, 0, 15, 0),
+SOC_ENUM("Treble Cut-off", treble),
+
+SOC_SINGLE("3D Switch", WM8988_3D, 0, 1, 0),
+SOC_SINGLE("3D Volume", WM8988_3D, 1, 15, 0),
+SOC_ENUM("3D Lower Cut-off", stereo_3d_lc),
+SOC_ENUM("3D Upper Cut-off", stereo_3d_uc),
+SOC_ENUM("3D Mode", stereo_3d_func),
+
+SOC_SINGLE("ALC Capture Target Volume", WM8988_ALC1, 0, 7, 0),
+SOC_SINGLE("ALC Capture Max Volume", WM8988_ALC1, 4, 7, 0),
+SOC_ENUM("ALC Capture Function", alc_func),
+SOC_SINGLE("ALC Capture ZC Switch", WM8988_ALC2, 7, 1, 0),
+SOC_SINGLE("ALC Capture Hold Time", WM8988_ALC2, 0, 15, 0),
+SOC_SINGLE("ALC Capture Decay Time", WM8988_ALC3, 4, 15, 0),
+SOC_SINGLE("ALC Capture Attack Time", WM8988_ALC3, 0, 15, 0),
+SOC_SINGLE("ALC Capture NG Threshold", WM8988_NGATE, 3, 31, 0),
+SOC_ENUM("ALC Capture NG Type", ng_type),
+SOC_SINGLE("ALC Capture NG Switch", WM8988_NGATE, 0, 1, 0),
+
+SOC_SINGLE("ZC Timeout Switch", WM8988_ADCTL1, 0, 1, 0),
+
+SOC_DOUBLE_R_TLV("Capture Digital Volume", WM8988_LADC, WM8988_RADC,
+                 0, 255, 0, adc_tlv),
+SOC_DOUBLE_R_TLV("Capture Volume", WM8988_LINVOL, WM8988_RINVOL,
+                 0, 63, 0, pga_tlv),
+SOC_DOUBLE_R("Capture ZC Switch", WM8988_LINVOL, WM8988_RINVOL, 6, 1, 0),
+SOC_DOUBLE_R("Capture Switch", WM8988_LINVOL, WM8988_RINVOL, 7, 1, 1),
+
+SOC_ENUM("Playback De-emphasis", deemph),
+
+SOC_ENUM("Capture Polarity", adcpol),
+SOC_SINGLE("Playback 6dB Attenuate", WM8988_ADCDAC, 7, 1, 0),
+SOC_SINGLE("Capture 6dB Attenuate", WM8988_ADCDAC, 8, 1, 0),
+
+SOC_DOUBLE_R_TLV("PCM Volume", WM8988_LDAC, WM8988_RDAC, 0, 255, 0, dac_tlv),
+
+SOC_SINGLE_TLV("Left Mixer Left Bypass Volume", WM8988_LOUTM1, 4, 7, 1,
+               bypass_tlv),
+SOC_SINGLE_TLV("Left Mixer Right Bypass Volume", WM8988_LOUTM2, 4, 7, 1,
+               bypass_tlv),
+SOC_SINGLE_TLV("Right Mixer Left Bypass Volume", WM8988_ROUTM1, 4, 7, 1,
+               bypass_tlv),
+SOC_SINGLE_TLV("Right Mixer Right Bypass Volume", WM8988_ROUTM2, 4, 7, 1,
+               bypass_tlv),
+
+SOC_DOUBLE_R("Output 1 Playback ZC Switch", WM8988_LOUT1V,
+             WM8988_ROUT1V, 7, 1, 0),
+SOC_DOUBLE_R_TLV("Output 1 Playback Volume", WM8988_LOUT1V, WM8988_ROUT1V,
+                 0, 127, 0, out_tlv),
+
+SOC_DOUBLE_R("Output 2 Playback ZC Switch", WM8988_LOUT2V,
+             WM8988_ROUT2V, 7, 1, 0),
+SOC_DOUBLE_R_TLV("Output 2 Playback Volume", WM8988_LOUT2V, WM8988_ROUT2V,
+                 0, 127, 0, out_tlv),
+
+};
+
+/*
+ * DAPM Controls
+ */
+
+static int wm8988_lrc_control(struct snd_soc_dapm_widget *w,
+                              struct snd_kcontrol *kcontrol, int event)
+{
+        struct snd_soc_codec *codec = w->codec;
+        u16 adctl2 = snd_soc_read(codec, WM8988_ADCTL2);
+
+        /* Use the DAC to gate LRC if active, otherwise use ADC */
+        if (snd_soc_read(codec, WM8988_PWR2) & 0x180)
+                adctl2 &= ~0x4;
+        else
+                adctl2 |= 0x4;
+
+        return snd_soc_write(codec, WM8988_ADCTL2, adctl2);
+}
+
+static const char *wm8988_line_texts[] = {
+        "Line 1", "Line 2", "PGA", "Differential"};
+
+static const unsigned int wm8988_line_values[] = {
+        0, 1, 3, 4};
+
+static const struct soc_enum wm8988_lline_enum =
+        SOC_VALUE_ENUM_SINGLE(WM8988_LOUTM1, 0, 7,
+                              ARRAY_SIZE(wm8988_line_texts),
+                              wm8988_line_texts,
+                              wm8988_line_values);
+static const struct snd_kcontrol_new wm8988_left_line_controls =
+        SOC_DAPM_VALUE_ENUM("Route", wm8988_lline_enum);
+
+static const struct soc_enum wm8988_rline_enum =
+        SOC_VALUE_ENUM_SINGLE(WM8988_ROUTM1, 0, 7,
+                              ARRAY_SIZE(wm8988_line_texts),
+                              wm8988_line_texts,
+                              wm8988_line_values);
+static const struct snd_kcontrol_new wm8988_right_line_controls =
+        SOC_DAPM_VALUE_ENUM("Route", wm8988_lline_enum);
+
+/* Left Mixer */
+static const struct snd_kcontrol_new wm8988_left_mixer_controls[] = {
+        SOC_DAPM_SINGLE("Playback Switch", WM8988_LOUTM1, 8, 1, 0),
+        SOC_DAPM_SINGLE("Left Bypass Switch", WM8988_LOUTM1, 7, 1, 0),
+        SOC_DAPM_SINGLE("Right Playback Switch", WM8988_LOUTM2, 8, 1, 0),
+        SOC_DAPM_SINGLE("Right Bypass Switch", WM8988_LOUTM2, 7, 1, 0),
+};
+
+/* Right Mixer */
+static const struct snd_kcontrol_new wm8988_right_mixer_controls[] = {
+        SOC_DAPM_SINGLE("Left Playback Switch", WM8988_ROUTM1, 8, 1, 0),
+        SOC_DAPM_SINGLE("Left Bypass Switch", WM8988_ROUTM1, 7, 1, 0),
+        SOC_DAPM_SINGLE("Playback Switch", WM8988_ROUTM2, 8, 1, 0),
+        SOC_DAPM_SINGLE("Right Bypass Switch", WM8988_ROUTM2, 7, 1, 0),
+};
+
+static const char *wm8988_pga_sel[] = {"Line 1", "Line 2", "Differential"};
+static const unsigned int wm8988_pga_val[] = { 0, 1, 3 };
+
+/* Left PGA Mux */
+static const struct soc_enum wm8988_lpga_enum =
+        SOC_VALUE_ENUM_SINGLE(WM8988_LADCIN, 6, 3,
+                              ARRAY_SIZE(wm8988_pga_sel),
+                              wm8988_pga_sel,
+                              wm8988_pga_val);
+static const struct snd_kcontrol_new wm8988_left_pga_controls =
+        SOC_DAPM_VALUE_ENUM("Route", wm8988_lpga_enum);
+
+/* Right PGA Mux */
+static const struct soc_enum wm8988_rpga_enum =
+        SOC_VALUE_ENUM_SINGLE(WM8988_RADCIN, 6, 3,
+                              ARRAY_SIZE(wm8988_pga_sel),
+                              wm8988_pga_sel,
+                              wm8988_pga_val);
+static const struct snd_kcontrol_new wm8988_right_pga_controls =
+        SOC_DAPM_VALUE_ENUM("Route", wm8988_rpga_enum);
+
+/* Differential Mux */
+static const char *wm8988_diff_sel[] = {"Line 1", "Line 2"};
+static const struct soc_enum diffmux =
+        SOC_ENUM_SINGLE(WM8988_ADCIN, 8, 2, wm8988_diff_sel);
+static const struct snd_kcontrol_new wm8988_diffmux_controls =
+        SOC_DAPM_ENUM("Route", diffmux);
+
+/* Mono ADC Mux */
+static const char *wm8988_mono_mux[] = {"Stereo", "Mono (Left)",
+        "Mono (Right)", "Digital Mono"};
+static const struct soc_enum monomux =
+        SOC_ENUM_SINGLE(WM8988_ADCIN, 6, 4, wm8988_mono_mux);
+static const struct snd_kcontrol_new wm8988_monomux_controls =
+        SOC_DAPM_ENUM("Route", monomux);
+
+static const struct snd_soc_dapm_widget wm8988_dapm_widgets[] = {
+        SND_SOC_DAPM_MICBIAS("Mic Bias", WM8988_PWR1, 1, 0),
+
+        SND_SOC_DAPM_MUX("Differential Mux", SND_SOC_NOPM, 0, 0,
+                &wm8988_diffmux_controls),
+        SND_SOC_DAPM_MUX("Left ADC Mux", SND_SOC_NOPM, 0, 0,
+                &wm8988_monomux_controls),
+        SND_SOC_DAPM_MUX("Right ADC Mux", SND_SOC_NOPM, 0, 0,
+                &wm8988_monomux_controls),
+
+        SND_SOC_DAPM_MUX("Left PGA Mux", WM8988_PWR1, 5, 0,
+                &wm8988_left_pga_controls),
+        SND_SOC_DAPM_MUX("Right PGA Mux", WM8988_PWR1, 4, 0,
+                &wm8988_right_pga_controls),
+
+        SND_SOC_DAPM_MUX("Left Line Mux", SND_SOC_NOPM, 0, 0,
+                &wm8988_left_line_controls),
+        SND_SOC_DAPM_MUX("Right Line Mux", SND_SOC_NOPM, 0, 0,
+                &wm8988_right_line_controls),
+
+        SND_SOC_DAPM_ADC("Right ADC", "Right Capture", WM8988_PWR1, 2, 0),
+        SND_SOC_DAPM_ADC("Left ADC", "Left Capture", WM8988_PWR1, 3, 0),
+
+        SND_SOC_DAPM_DAC("Right DAC", "Right Playback", WM8988_PWR2, 7, 0),
+        SND_SOC_DAPM_DAC("Left DAC", "Left Playback", WM8988_PWR2, 8, 0),
+
+        SND_SOC_DAPM_MIXER("Left Mixer", SND_SOC_NOPM, 0, 0,
+                &wm8988_left_mixer_controls[0],
+                ARRAY_SIZE(wm8988_left_mixer_controls)),
+        SND_SOC_DAPM_MIXER("Right Mixer", SND_SOC_NOPM, 0, 0,
+                &wm8988_right_mixer_controls[0],
+                ARRAY_SIZE(wm8988_right_mixer_controls)),
+
+        SND_SOC_DAPM_PGA("Right Out 2", WM8988_PWR2, 3, 0, NULL, 0),
+        SND_SOC_DAPM_PGA("Left Out 2", WM8988_PWR2, 4, 0, NULL, 0),
+        SND_SOC_DAPM_PGA("Right Out 1", WM8988_PWR2, 5, 0, NULL, 0),
+        SND_SOC_DAPM_PGA("Left Out 1", WM8988_PWR2, 6, 0, NULL, 0),
+
+        SND_SOC_DAPM_POST("LRC control", wm8988_lrc_control),
+
+        SND_SOC_DAPM_OUTPUT("LOUT1"),
+        SND_SOC_DAPM_OUTPUT("ROUT1"),
+        SND_SOC_DAPM_OUTPUT("LOUT2"),
+        SND_SOC_DAPM_OUTPUT("ROUT2"),
+        SND_SOC_DAPM_OUTPUT("VREF"),
+
+        SND_SOC_DAPM_INPUT("LINPUT1"),
+        SND_SOC_DAPM_INPUT("LINPUT2"),
+        SND_SOC_DAPM_INPUT("RINPUT1"),
+        SND_SOC_DAPM_INPUT("RINPUT2"),
+};
+
+static const struct snd_soc_dapm_route audio_map[] = {
+
+        { "Left Line Mux", "Line 1", "LINPUT1" },
+        { "Left Line Mux", "Line 2", "LINPUT2" },
+        { "Left Line Mux", "PGA", "Left PGA Mux" },
+        { "Left Line Mux", "Differential", "Differential Mux" },
+
+        { "Right Line Mux", "Line 1", "RINPUT1" },
+        { "Right Line Mux", "Line 2", "RINPUT2" },
+        { "Right Line Mux", "PGA", "Right PGA Mux" },
+        { "Right Line Mux", "Differential", "Differential Mux" },
+
+        { "Left PGA Mux", "Line 1", "LINPUT1" },
+        { "Left PGA Mux", "Line 2", "LINPUT2" },
+        { "Left PGA Mux", "Differential", "Differential Mux" },
+
+        { "Right PGA Mux", "Line 1", "RINPUT1" },
+        { "Right PGA Mux", "Line 2", "RINPUT2" },
+        { "Right PGA Mux", "Differential", "Differential Mux" },
+
+        { "Differential Mux", "Line 1", "LINPUT1" },
+        { "Differential Mux", "Line 1", "RINPUT1" },
+        { "Differential Mux", "Line 2", "LINPUT2" },
+        { "Differential Mux", "Line 2", "RINPUT2" },
+
+        { "Left ADC Mux", "Stereo", "Left PGA Mux" },
+        { "Left ADC Mux", "Mono (Left)", "Left PGA Mux" },
+        { "Left ADC Mux", "Digital Mono", "Left PGA Mux" },
+
+        { "Right ADC Mux", "Stereo", "Right PGA Mux" },
+        { "Right ADC Mux", "Mono (Right)", "Right PGA Mux" },
+        { "Right ADC Mux", "Digital Mono", "Right PGA Mux" },
+
+        { "Left ADC", NULL, "Left ADC Mux" },
+        { "Right ADC", NULL, "Right ADC Mux" },
+
+        { "Left Line Mux", "Line 1", "LINPUT1" },
+        { "Left Line Mux", "Line 2", "LINPUT2" },
+        { "Left Line Mux", "PGA", "Left PGA Mux" },
+        { "Left Line Mux", "Differential", "Differential Mux" },
+
+        { "Right Line Mux", "Line 1", "RINPUT1" },
+        { "Right Line Mux", "Line 2", "RINPUT2" },
+        { "Right Line Mux", "PGA", "Right PGA Mux" },
+        { "Right Line Mux", "Differential", "Differential Mux" },
+
+        { "Left Mixer", "Playback Switch", "Left DAC" },
+        { "Left Mixer", "Left Bypass Switch", "Left Line Mux" },
+        { "Left Mixer", "Right Playback Switch", "Right DAC" },
+        { "Left Mixer", "Right Bypass Switch", "Right Line Mux" },
+
+        { "Right Mixer", "Left Playback Switch", "Left DAC" },
+        { "Right Mixer", "Left Bypass Switch", "Left Line Mux" },
+        { "Right Mixer", "Playback Switch", "Right DAC" },
+        { "Right Mixer", "Right Bypass Switch", "Right Line Mux" },
+
+        { "Left Out 1", NULL, "Left Mixer" },
+        { "LOUT1", NULL, "Left Out 1" },
+        { "Right Out 1", NULL, "Right Mixer" },
+        { "ROUT1", NULL, "Right Out 1" },
+
+        { "Left Out 2", NULL, "Left Mixer" },
+        { "LOUT2", NULL, "Left Out 2" },
+        { "Right Out 2", NULL, "Right Mixer" },
+        { "ROUT2", NULL, "Right Out 2" },
+};
+
+struct _coeff_div {
+        u32 mclk;
+        u32 rate;
+        u16 fs;
+        u8 sr:5;
+        u8 usb:1;
+};
+
+/* codec hifi mclk clock divider coefficients */
+static const struct _coeff_div coeff_div[] = {
+        /* 8k */
+        {12288000, 8000, 1536, 0x6, 0x0},
+        {11289600, 8000, 1408, 0x16, 0x0},
+        {18432000, 8000, 2304, 0x7, 0x0},
+        {16934400, 8000, 2112, 0x17, 0x0},
+        {12000000, 8000, 1500, 0x6, 0x1},
+
+        /* 11.025k */
+        {11289600, 11025, 1024, 0x18, 0x0},
+        {16934400, 11025, 1536, 0x19, 0x0},
+        {12000000, 11025, 1088, 0x19, 0x1},
+
+        /* 16k */
+        {12288000, 16000, 768, 0xa, 0x0},
+        {18432000, 16000, 1152, 0xb, 0x0},
+        {12000000, 16000, 750, 0xa, 0x1},
+
+        /* 22.05k */
+        {11289600, 22050, 512, 0x1a, 0x0},
+        {16934400, 22050, 768, 0x1b, 0x0},
+        {12000000, 22050, 544, 0x1b, 0x1},
+
+        /* 32k */
+        {12288000, 32000, 384, 0xc, 0x0},
+        {18432000, 32000, 576, 0xd, 0x0},
+        {12000000, 32000, 375, 0xa, 0x1},
+
+        /* 44.1k */
+        {11289600, 44100, 256, 0x10, 0x0},
+        {16934400, 44100, 384, 0x11, 0x0},
+        {12000000, 44100, 272, 0x11, 0x1},
+
+        /* 48k */
+        {12288000, 48000, 256, 0x0, 0x0},
+        {18432000, 48000, 384, 0x1, 0x0},
+        {12000000, 48000, 250, 0x0, 0x1},
+
+        /* 88.2k */
+        {11289600, 88200, 128, 0x1e, 0x0},
+        {16934400, 88200, 192, 0x1f, 0x0},
+        {12000000, 88200, 136, 0x1f, 0x1},
+
+        /* 96k */
+        {12288000, 96000, 128, 0xe, 0x0},
+        {18432000, 96000, 192, 0xf, 0x0},
+        {12000000, 96000, 125, 0xe, 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 -EINVAL;
+}
+
+/* The set of rates we can generate from the above for each SYSCLK */
+
+static unsigned int rates_12288[] = {
+        8000, 12000, 16000, 24000, 24000, 32000, 48000, 96000,
+};
+
+static struct snd_pcm_hw_constraint_list constraints_12288 = {
+        .count  = ARRAY_SIZE(rates_12288),
+        .list   = rates_12288,
+};
+
+static unsigned int rates_112896[] = {
+        8000, 11025, 22050, 44100,
+};
+
+static struct snd_pcm_hw_constraint_list constraints_112896 = {
+        .count  = ARRAY_SIZE(rates_112896),
+        .list   = rates_112896,
+};
+
+static unsigned int rates_12[] = {
+        8000, 11025, 12000, 16000, 22050, 2400, 32000, 41100, 48000,
+        48000, 88235, 96000,
+};
+
+static struct snd_pcm_hw_constraint_list constraints_12 = {
+        .count  = ARRAY_SIZE(rates_12),
+        .list   = rates_12,
+};
+
+/*
+ * Note that this should be called from init rather than from hw_params.
+ */
+static int wm8988_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 wm8988_priv *wm8988 = codec->private_data;
+
+        switch (freq) {
+        case 11289600:
+        case 18432000:
+        case 22579200:
+        case 36864000:
+                wm8988->sysclk_constraints = &constraints_112896;
+                wm8988->sysclk = freq;
+                return 0;
+
+        case 12288000:
+        case 16934400:
+        case 24576000:
+        case 33868800:
+                wm8988->sysclk_constraints = &constraints_12288;
+                wm8988->sysclk = freq;
+                return 0;
+
+        case 12000000:
+        case 24000000:
+                wm8988->sysclk_constraints = &constraints_12;
+                wm8988->sysclk = freq;
+                return 0;
+        }
+        return -EINVAL;
+}
+
+static int wm8988_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;
+        }
+
+        snd_soc_write(codec, WM8988_IFACE, iface);
+        return 0;
+}
+
+static int wm8988_pcm_startup(struct snd_pcm_substream *substream,
+                              struct snd_soc_dai *dai)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        struct wm8988_priv *wm8988 = codec->private_data;
+
+        /* The set of sample rates that can be supported depends on the
+         * MCLK supplied to the CODEC - enforce this.
+         */
+        if (!wm8988->sysclk) {
+                dev_err(codec->dev,
+                        "No MCLK configured, call set_sysclk() on init\n");
+                return -EINVAL;
+        }
+
+        snd_pcm_hw_constraint_list(substream->runtime, 0,
+                                   SNDRV_PCM_HW_PARAM_RATE,
+                                   wm8988->sysclk_constraints);
+
+        return 0;
+}
+
+static int wm8988_pcm_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 wm8988_priv *wm8988 = codec->private_data;
+        u16 iface = snd_soc_read(codec, WM8988_IFACE) & 0x1f3;
+        u16 srate = snd_soc_read(codec, WM8988_SRATE) & 0x180;
+        int coeff;
+
+        coeff = get_coeff(wm8988->sysclk, params_rate(params));
+        if (coeff < 0) {
+                coeff = get_coeff(wm8988->sysclk / 2, params_rate(params));
+                srate |= 0x40;
+        }
+        if (coeff < 0) {
+                dev_err(codec->dev,
+                        "Unable to configure sample rate %dHz with %dHz MCLK\n",
+                        params_rate(params), wm8988->sysclk);
+                return coeff;
+        }
+
+        /* 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;
+        case SNDRV_PCM_FORMAT_S32_LE:
+                iface |= 0x000c;
+                break;
+        }
+
+        /* set iface & srate */
+        snd_soc_write(codec, WM8988_IFACE, iface);
+        if (coeff >= 0)
+                snd_soc_write(codec, WM8988_SRATE, srate |
+                        (coeff_div[coeff].sr << 1) | coeff_div[coeff].usb);
+
+        return 0;
+}
+
+static int wm8988_mute(struct snd_soc_dai *dai, int mute)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        u16 mute_reg = snd_soc_read(codec, WM8988_ADCDAC) & 0xfff7;
+
+        if (mute)
+                snd_soc_write(codec, WM8988_ADCDAC, mute_reg | 0x8);
+        else
+                snd_soc_write(codec, WM8988_ADCDAC, mute_reg);
+        return 0;
+}
+
+static int wm8988_set_bias_level(struct snd_soc_codec *codec,
+                                 enum snd_soc_bias_level level)
+{
+        u16 pwr_reg = snd_soc_read(codec, WM8988_PWR1) & ~0x1c1;
+
+        switch (level) {
+        case SND_SOC_BIAS_ON:
+                break;
+
+        case SND_SOC_BIAS_PREPARE:
+                /* VREF, VMID=2x50k, digital enabled */
+                snd_soc_write(codec, WM8988_PWR1, pwr_reg | 0x00c0);
+                break;
+
+        case SND_SOC_BIAS_STANDBY:
+                if (codec->bias_level == SND_SOC_BIAS_OFF) {
+                        /* VREF, VMID=2x5k */
+                        snd_soc_write(codec, WM8988_PWR1, pwr_reg | 0x1c1);
+
+                        /* Charge caps */
+                        msleep(100);
+                }
+
+                /* VREF, VMID=2*500k, digital stopped */
+                snd_soc_write(codec, WM8988_PWR1, pwr_reg | 0x0141);
+                break;
+
+        case SND_SOC_BIAS_OFF:
+                snd_soc_write(codec, WM8988_PWR1, 0x0000);
+                break;
+        }
+        codec->bias_level = level;
+        return 0;
+}
+
+#define WM8988_RATES SNDRV_PCM_RATE_8000_96000
+
+#define WM8988_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
+        SNDRV_PCM_FMTBIT_S24_LE)
+
+static struct snd_soc_dai_ops wm8988_ops = {
+        .startup = wm8988_pcm_startup,
+        .hw_params = wm8988_pcm_hw_params,
+        .set_fmt = wm8988_set_dai_fmt,
+        .set_sysclk = wm8988_set_dai_sysclk,
+        .digital_mute = wm8988_mute,
+};
+
+struct snd_soc_dai wm8988_dai = {
+        .name = "WM8988",
+        .playback = {
+                .stream_name = "Playback",
+                .channels_min = 1,
+                .channels_max = 2,
+                .rates = WM8988_RATES,
+                .formats = WM8988_FORMATS,
+        },
+        .capture = {
+                .stream_name = "Capture",
+                .channels_min = 1,
+                .channels_max = 2,
+                .rates = WM8988_RATES,
+                .formats = WM8988_FORMATS,
+         },
+        .ops = &wm8988_ops,
+        .symmetric_rates = 1,
+};
+EXPORT_SYMBOL_GPL(wm8988_dai);
+
+static int wm8988_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;
+
+        wm8988_set_bias_level(codec, SND_SOC_BIAS_OFF);
+        return 0;
+}
+
+static int wm8988_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 < WM8988_NUM_REG; i++) {
+                if (i == WM8988_RESET)
+                        continue;
+                data[0] = (i << 1) | ((cache[i] >> 8) & 0x0001);
+                data[1] = cache[i] & 0x00ff;
+                codec->hw_write(codec->control_data, data, 2);
+        }
+
+        wm8988_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+
+        return 0;
+}
+
+static struct snd_soc_codec *wm8988_codec;
+
+static int wm8988_probe(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec;
+        int ret = 0;
+
+        if (wm8988_codec == NULL) {
+                dev_err(&pdev->dev, "Codec device not registered\n");
+                return -ENODEV;
+        }
+
+        socdev->card->codec = wm8988_codec;
+        codec = wm8988_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, wm8988_snd_controls,
+                                ARRAY_SIZE(wm8988_snd_controls));
+        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;
+}
+
+static int wm8988_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_wm8988 = {
+        .probe =        wm8988_probe,
+        .remove =       wm8988_remove,
+        .suspend =      wm8988_suspend,
+        .resume =       wm8988_resume,
+};
+EXPORT_SYMBOL_GPL(soc_codec_dev_wm8988);
+
+static int wm8988_register(struct wm8988_priv *wm8988,
+                           enum snd_soc_control_type control)
+{
+        struct snd_soc_codec *codec = &wm8988->codec;
+        int ret;
+        u16 reg;
+
+        if (wm8988_codec) {
+                dev_err(codec->dev, "Another WM8988 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 = wm8988;
+        codec->name = "WM8988";
+        codec->owner = THIS_MODULE;
+        codec->dai = &wm8988_dai;
+        codec->num_dai = 1;
+        codec->reg_cache_size = ARRAY_SIZE(wm8988->reg_cache);
+        codec->reg_cache = &wm8988->reg_cache;
+        codec->bias_level = SND_SOC_BIAS_OFF;
+        codec->set_bias_level = wm8988_set_bias_level;
+
+        memcpy(codec->reg_cache, wm8988_reg,
+               sizeof(wm8988_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 = wm8988_reset(codec);
+        if (ret < 0) {
+                dev_err(codec->dev, "Failed to issue reset\n");
+                goto err;
+        }
+
+        /* set the update bits (we always update left then right) */
+        reg = snd_soc_read(codec, WM8988_RADC);
+        snd_soc_write(codec, WM8988_RADC, reg | 0x100);
+        reg = snd_soc_read(codec, WM8988_RDAC);
+        snd_soc_write(codec, WM8988_RDAC, reg | 0x0100);
+        reg = snd_soc_read(codec, WM8988_ROUT1V);
+        snd_soc_write(codec, WM8988_ROUT1V, reg | 0x0100);
+        reg = snd_soc_read(codec, WM8988_ROUT2V);
+        snd_soc_write(codec, WM8988_ROUT2V, reg | 0x0100);
+        reg = snd_soc_read(codec, WM8988_RINVOL);
+        snd_soc_write(codec, WM8988_RINVOL, reg | 0x0100);
+
+        wm8988_set_bias_level(&wm8988->codec, SND_SOC_BIAS_STANDBY);
+
+        wm8988_dai.dev = codec->dev;
+
+        wm8988_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(&wm8988_dai);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to register DAI: %d\n", ret);
+                snd_soc_unregister_codec(codec);
+                goto err_codec;
+        }
+
+        return 0;
+
+err_codec:
+        snd_soc_unregister_codec(codec);
+err:
+        kfree(wm8988);
+        return ret;
+}
+
+static void wm8988_unregister(struct wm8988_priv *wm8988)
+{
+        wm8988_set_bias_level(&wm8988->codec, SND_SOC_BIAS_OFF);
+        snd_soc_unregister_dai(&wm8988_dai);
+        snd_soc_unregister_codec(&wm8988->codec);
+        kfree(wm8988);
+        wm8988_codec = NULL;
+}
+
+#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+static int wm8988_i2c_probe(struct i2c_client *i2c,
+                            const struct i2c_device_id *id)
+{
+        struct wm8988_priv *wm8988;
+        struct snd_soc_codec *codec;
+
+        wm8988 = kzalloc(sizeof(struct wm8988_priv), GFP_KERNEL);
+        if (wm8988 == NULL)
+                return -ENOMEM;
+
+        codec = &wm8988->codec;
+
+        i2c_set_clientdata(i2c, wm8988);
+        codec->control_data = i2c;
+
+        codec->dev = &i2c->dev;
+
+        return wm8988_register(wm8988, SND_SOC_I2C);
+}
+
+static int wm8988_i2c_remove(struct i2c_client *client)
+{
+        struct wm8988_priv *wm8988 = i2c_get_clientdata(client);
+        wm8988_unregister(wm8988);
+        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 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, wm8988_i2c_id);
+
+static struct i2c_driver wm8988_i2c_driver = {
+        .driver = {
+                .name = "WM8988",
+                .owner = THIS_MODULE,
+        },
+        .probe = wm8988_i2c_probe,
+        .remove = wm8988_i2c_remove,
+        .suspend = wm8988_i2c_suspend,
+        .resume = wm8988_i2c_resume,
+        .id_table = wm8988_i2c_id,
+};
+#endif
+
+#if defined(CONFIG_SPI_MASTER)
+static int __devinit wm8988_spi_probe(struct spi_device *spi)
+{
+        struct wm8988_priv *wm8988;
+        struct snd_soc_codec *codec;
+
+        wm8988 = kzalloc(sizeof(struct wm8988_priv), GFP_KERNEL);
+        if (wm8988 == NULL)
+                return -ENOMEM;
+
+        codec = &wm8988->codec;
+        codec->control_data = spi;
+        codec->dev = &spi->dev;
+
+        spi->dev.driver_data = wm8988;
+
+        return wm8988_register(wm8988, SND_SOC_SPI);
+}
+
+static int __devexit wm8988_spi_remove(struct spi_device *spi)
+{
+        struct wm8988_priv *wm8988 = spi->dev.driver_data;
+
+        wm8988_unregister(wm8988);
+
+        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",
+                .bus    = &spi_bus_type,
+                .owner  = THIS_MODULE,
+        },
+        .probe          = wm8988_spi_probe,
+        .remove         = __devexit_p(wm8988_spi_remove),
+        .suspend        = wm8988_spi_suspend,
+        .resume         = wm8988_spi_resume,
+};
+#endif
+
+static int __init wm8988_modinit(void)
+{
+        int ret;
+
+#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+        ret = i2c_add_driver(&wm8988_i2c_driver);
+        if (ret != 0)
+                pr_err("WM8988: Unable to register I2C driver: %d\n", ret);
+#endif
+#if defined(CONFIG_SPI_MASTER)
+        ret = spi_register_driver(&wm8988_spi_driver);
+        if (ret != 0)
+                pr_err("WM8988: Unable to register SPI driver: %d\n", ret);
+#endif
+        return ret;
+}
+module_init(wm8988_modinit);
+
+static void __exit wm8988_exit(void)
+{
+#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+        i2c_del_driver(&wm8988_i2c_driver);
+#endif
+#if defined(CONFIG_SPI_MASTER)
+        spi_unregister_driver(&wm8988_spi_driver);
+#endif
+}
+module_exit(wm8988_exit);
+
+
+MODULE_DESCRIPTION("ASoC WM8988 driver");
+MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/codecs/wm8988.h b/sound/soc/codecs/wm8988.h
new file mode 100644
index 000000000000..4552d37fdd41
--- /dev/null
+++ b/sound/soc/codecs/wm8988.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2005 Openedhand Ltd.
+ *
+ * Author: Richard Purdie <richard@openedhand.com>
+ *
+ * Based on WM8753.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 _WM8988_H
+#define _WM8988_H
+
+/* WM8988 register space */
+
+#define WM8988_LINVOL    0x00
+#define WM8988_RINVOL    0x01
+#define WM8988_LOUT1V    0x02
+#define WM8988_ROUT1V    0x03
+#define WM8988_ADCDAC    0x05
+#define WM8988_IFACE     0x07
+#define WM8988_SRATE     0x08
+#define WM8988_LDAC      0x0a
+#define WM8988_RDAC      0x0b
+#define WM8988_BASS      0x0c
+#define WM8988_TREBLE    0x0d
+#define WM8988_RESET     0x0f
+#define WM8988_3D        0x10
+#define WM8988_ALC1      0x11
+#define WM8988_ALC2      0x12
+#define WM8988_ALC3      0x13
+#define WM8988_NGATE     0x14
+#define WM8988_LADC      0x15
+#define WM8988_RADC      0x16
+#define WM8988_ADCTL1    0x17
+#define WM8988_ADCTL2    0x18
+#define WM8988_PWR1      0x19
+#define WM8988_PWR2      0x1a
+#define WM8988_ADCTL3    0x1b
+#define WM8988_ADCIN     0x1f
+#define WM8988_LADCIN    0x20
+#define WM8988_RADCIN    0x21
+#define WM8988_LOUTM1    0x22
+#define WM8988_LOUTM2    0x23
+#define WM8988_ROUTM1    0x24
+#define WM8988_ROUTM2    0x25
+#define WM8988_LOUT2V    0x28
+#define WM8988_ROUT2V    0x29
+#define WM8988_LPPB      0x43
+#define WM8988_NUM_REG   0x44
+
+#define WM8988_SYSCLK   0
+
+extern struct snd_soc_dai wm8988_dai;
+extern struct snd_soc_codec_device soc_codec_dev_wm8988;
+
+#endif
diff --git a/sound/soc/codecs/wm8990.c b/sound/soc/codecs/wm8990.c
index 40cd274eb1ef..2d702db4131d 100644
--- a/sound/soc/codecs/wm8990.c
+++ b/sound/soc/codecs/wm8990.c
@@ -108,53 +108,7 @@ static const u16 wm8990_reg[] = {
         0x0000,     /* R63 - Driver internal */
 };
 
-/*
- * read wm8990 register cache
- */
-static inline unsigned int wm8990_read_reg_cache(struct snd_soc_codec *codec,
-        unsigned int reg)
-{
-        u16 *cache = codec->reg_cache;
-        BUG_ON(reg >= ARRAY_SIZE(wm8990_reg));
-        return cache[reg];
-}
-
-/*
- * write wm8990 register cache
- */
-static inline void wm8990_write_reg_cache(struct snd_soc_codec *codec,
-        unsigned int reg, unsigned int value)
-{
-        u16 *cache = codec->reg_cache;
-
-        /* Reset register and reserved registers are uncached */
-        if (reg == 0 || reg >= ARRAY_SIZE(wm8990_reg))
-                return;
-
-        cache[reg] = value;
-}
-
-/*
- * write to the wm8990 register space
- */
-static int wm8990_write(struct snd_soc_codec *codec, unsigned int reg,
-        unsigned int value)
-{
-        u8 data[3];
-
-        data[0] = reg & 0xFF;
-        data[1] = (value >> 8) & 0xFF;
-        data[2] = value & 0xFF;
-
-        wm8990_write_reg_cache(codec, reg, value);
-
-        if (codec->hw_write(codec->control_data, data, 3) == 2)
-                return 0;
-        else
-                return -EIO;
-}
-
-#define wm8990_reset(c) wm8990_write(c, WM8990_RESET, 0)
+#define wm8990_reset(c) snd_soc_write(c, WM8990_RESET, 0)
 
 static const DECLARE_TLV_DB_LINEAR(rec_mix_tlv, -1500, 600);
 
@@ -187,8 +141,8 @@ static int wm899x_outpga_put_volsw_vu(struct snd_kcontrol *kcontrol,
                 return ret;
 
         /* now hit the volume update bits (always bit 8) */
-        val = wm8990_read_reg_cache(codec, reg);
-        return wm8990_write(codec, reg, val | 0x0100);
+        val = snd_soc_read(codec, reg);
+        return snd_soc_write(codec, reg, val | 0x0100);
 }
 
 #define SOC_WM899X_OUTPGA_SINGLE_R_TLV(xname, reg, shift, max, invert,\
@@ -427,8 +381,8 @@ static int inmixer_event(struct snd_soc_dapm_widget *w,
 {
         u16 reg, fakepower;
 
-        reg = wm8990_read_reg_cache(w->codec, WM8990_POWER_MANAGEMENT_2);
-        fakepower = wm8990_read_reg_cache(w->codec, WM8990_INTDRIVBITS);
+        reg = snd_soc_read(w->codec, WM8990_POWER_MANAGEMENT_2);
+        fakepower = snd_soc_read(w->codec, WM8990_INTDRIVBITS);
 
         if (fakepower & ((1 << WM8990_INMIXL_PWR_BIT) |
                 (1 << WM8990_AINLMUX_PWR_BIT))) {
@@ -443,7 +397,7 @@ static int inmixer_event(struct snd_soc_dapm_widget *w,
         } else {
                 reg &= ~WM8990_AINL_ENA;
         }
-        wm8990_write(w->codec, WM8990_POWER_MANAGEMENT_2, reg);
+        snd_soc_write(w->codec, WM8990_POWER_MANAGEMENT_2, reg);
 
         return 0;
 }
@@ -457,7 +411,7 @@ static int outmixer_event(struct snd_soc_dapm_widget *w,
 
         switch (reg_shift) {
         case WM8990_SPEAKER_MIXER | (WM8990_LDSPK_BIT << 8) :
-                reg = wm8990_read_reg_cache(w->codec, WM8990_OUTPUT_MIXER1);
+                reg = snd_soc_read(w->codec, WM8990_OUTPUT_MIXER1);
                 if (reg & WM8990_LDLO) {
                         printk(KERN_WARNING
                         "Cannot set as Output Mixer 1 LDLO Set\n");
@@ -465,7 +419,7 @@ static int outmixer_event(struct snd_soc_dapm_widget *w,
                 }
                 break;
         case WM8990_SPEAKER_MIXER | (WM8990_RDSPK_BIT << 8):
-                reg = wm8990_read_reg_cache(w->codec, WM8990_OUTPUT_MIXER2);
+                reg = snd_soc_read(w->codec, WM8990_OUTPUT_MIXER2);
                 if (reg & WM8990_RDRO) {
                         printk(KERN_WARNING
                         "Cannot set as Output Mixer 2 RDRO Set\n");
@@ -473,7 +427,7 @@ static int outmixer_event(struct snd_soc_dapm_widget *w,
                 }
                 break;
         case WM8990_OUTPUT_MIXER1 | (WM8990_LDLO_BIT << 8):
-                reg = wm8990_read_reg_cache(w->codec, WM8990_SPEAKER_MIXER);
+                reg = snd_soc_read(w->codec, WM8990_SPEAKER_MIXER);
                 if (reg & WM8990_LDSPK) {
                         printk(KERN_WARNING
                         "Cannot set as Speaker Mixer LDSPK Set\n");
@@ -481,7 +435,7 @@ static int outmixer_event(struct snd_soc_dapm_widget *w,
                 }
                 break;
         case WM8990_OUTPUT_MIXER2 | (WM8990_RDRO_BIT << 8):
-                reg = wm8990_read_reg_cache(w->codec, WM8990_SPEAKER_MIXER);
+                reg = snd_soc_read(w->codec, WM8990_SPEAKER_MIXER);
                 if (reg & WM8990_RDSPK) {
                         printk(KERN_WARNING
                         "Cannot set as Speaker Mixer RDSPK Set\n");
@@ -998,7 +952,7 @@ static void pll_factors(struct _pll_div *pll_div, unsigned int target,
 
         if ((Ndiv < 6) || (Ndiv > 12))
                 printk(KERN_WARNING
-                "WM8990 N value outwith recommended range! N = %d\n", Ndiv);
+                "WM8990 N value outwith recommended range! N = %u\n", Ndiv);
 
         pll_div->n = Ndiv;
         Nmod = target % source;
@@ -1029,24 +983,24 @@ static int wm8990_set_dai_pll(struct snd_soc_dai *codec_dai,
                 pll_factors(&pll_div, freq_out * 4, freq_in);
 
                 /* Turn on PLL */
-                reg = wm8990_read_reg_cache(codec, WM8990_POWER_MANAGEMENT_2);
+                reg = snd_soc_read(codec, WM8990_POWER_MANAGEMENT_2);
                 reg |= WM8990_PLL_ENA;
-                wm8990_write(codec, WM8990_POWER_MANAGEMENT_2, reg);
+                snd_soc_write(codec, WM8990_POWER_MANAGEMENT_2, reg);
 
                 /* sysclk comes from PLL */
-                reg = wm8990_read_reg_cache(codec, WM8990_CLOCKING_2);
-                wm8990_write(codec, WM8990_CLOCKING_2, reg | WM8990_SYSCLK_SRC);
+                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 */
-                wm8990_write(codec, WM8990_PLL1, pll_div.n | WM8990_SDM |
+                snd_soc_write(codec, WM8990_PLL1, pll_div.n | WM8990_SDM |
                         (pll_div.div2?WM8990_PRESCALE:0));
-                wm8990_write(codec, WM8990_PLL2, (u8)(pll_div.k>>8));
-                wm8990_write(codec, WM8990_PLL3, (u8)(pll_div.k & 0xFF));
+                snd_soc_write(codec, WM8990_PLL2, (u8)(pll_div.k>>8));
+                snd_soc_write(codec, WM8990_PLL3, (u8)(pll_div.k & 0xFF));
         } else {
                 /* Turn on PLL */
-                reg = wm8990_read_reg_cache(codec, WM8990_POWER_MANAGEMENT_2);
+                reg = snd_soc_read(codec, WM8990_POWER_MANAGEMENT_2);
                 reg &= ~WM8990_PLL_ENA;
-                wm8990_write(codec, WM8990_POWER_MANAGEMENT_2, reg);
+                snd_soc_write(codec, WM8990_POWER_MANAGEMENT_2, reg);
         }
         return 0;
 }
@@ -1073,8 +1027,8 @@ static int wm8990_set_dai_fmt(struct snd_soc_dai *codec_dai,
         struct snd_soc_codec *codec = codec_dai->codec;
         u16 audio1, audio3;
 
-        audio1 = wm8990_read_reg_cache(codec, WM8990_AUDIO_INTERFACE_1);
-        audio3 = wm8990_read_reg_cache(codec, WM8990_AUDIO_INTERFACE_3);
+        audio1 = snd_soc_read(codec, WM8990_AUDIO_INTERFACE_1);
+        audio3 = snd_soc_read(codec, WM8990_AUDIO_INTERFACE_3);
 
         /* set master/slave audio interface */
         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
@@ -1115,8 +1069,8 @@ static int wm8990_set_dai_fmt(struct snd_soc_dai *codec_dai,
                 return -EINVAL;
         }
 
-        wm8990_write(codec, WM8990_AUDIO_INTERFACE_1, audio1);
-        wm8990_write(codec, WM8990_AUDIO_INTERFACE_3, audio3);
+        snd_soc_write(codec, WM8990_AUDIO_INTERFACE_1, audio1);
+        snd_soc_write(codec, WM8990_AUDIO_INTERFACE_3, audio3);
         return 0;
 }
 
@@ -1128,24 +1082,24 @@ static int wm8990_set_dai_clkdiv(struct snd_soc_dai *codec_dai,
 
         switch (div_id) {
         case WM8990_MCLK_DIV:
-                reg = wm8990_read_reg_cache(codec, WM8990_CLOCKING_2) &
+                reg = snd_soc_read(codec, WM8990_CLOCKING_2) &
                         ~WM8990_MCLK_DIV_MASK;
-                wm8990_write(codec, WM8990_CLOCKING_2, reg | div);
+                snd_soc_write(codec, WM8990_CLOCKING_2, reg | div);
                 break;
         case WM8990_DACCLK_DIV:
-                reg = wm8990_read_reg_cache(codec, WM8990_CLOCKING_2) &
+                reg = snd_soc_read(codec, WM8990_CLOCKING_2) &
                         ~WM8990_DAC_CLKDIV_MASK;
-                wm8990_write(codec, WM8990_CLOCKING_2, reg | div);
+                snd_soc_write(codec, WM8990_CLOCKING_2, reg | div);
                 break;
         case WM8990_ADCCLK_DIV:
-                reg = wm8990_read_reg_cache(codec, WM8990_CLOCKING_2) &
+                reg = snd_soc_read(codec, WM8990_CLOCKING_2) &
                         ~WM8990_ADC_CLKDIV_MASK;
-                wm8990_write(codec, WM8990_CLOCKING_2, reg | div);
+                snd_soc_write(codec, WM8990_CLOCKING_2, reg | div);
                 break;
         case WM8990_BCLK_DIV:
-                reg = wm8990_read_reg_cache(codec, WM8990_CLOCKING_1) &
+                reg = snd_soc_read(codec, WM8990_CLOCKING_1) &
                         ~WM8990_BCLK_DIV_MASK;
-                wm8990_write(codec, WM8990_CLOCKING_1, reg | div);
+                snd_soc_write(codec, WM8990_CLOCKING_1, reg | div);
                 break;
         default:
                 return -EINVAL;
@@ -1164,7 +1118,7 @@ static int wm8990_hw_params(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;
-        u16 audio1 = wm8990_read_reg_cache(codec, WM8990_AUDIO_INTERFACE_1);
+        u16 audio1 = snd_soc_read(codec, WM8990_AUDIO_INTERFACE_1);
 
         audio1 &= ~WM8990_AIF_WL_MASK;
         /* bit size */
@@ -1182,7 +1136,7 @@ static int wm8990_hw_params(struct snd_pcm_substream *substream,
                 break;
         }
 
-        wm8990_write(codec, WM8990_AUDIO_INTERFACE_1, audio1);
+        snd_soc_write(codec, WM8990_AUDIO_INTERFACE_1, audio1);
         return 0;
 }
 
@@ -1191,12 +1145,12 @@ static int wm8990_mute(struct snd_soc_dai *dai, int mute)
         struct snd_soc_codec *codec = dai->codec;
         u16 val;
 
-        val  = wm8990_read_reg_cache(codec, WM8990_DAC_CTRL) & ~WM8990_DAC_MUTE;
+        val  = snd_soc_read(codec, WM8990_DAC_CTRL) & ~WM8990_DAC_MUTE;
 
         if (mute)
-                wm8990_write(codec, WM8990_DAC_CTRL, val | WM8990_DAC_MUTE);
+                snd_soc_write(codec, WM8990_DAC_CTRL, val | WM8990_DAC_MUTE);
         else
-                wm8990_write(codec, WM8990_DAC_CTRL, val);
+                snd_soc_write(codec, WM8990_DAC_CTRL, val);
 
         return 0;
 }
@@ -1212,21 +1166,21 @@ static int wm8990_set_bias_level(struct snd_soc_codec *codec,
 
         case SND_SOC_BIAS_PREPARE:
                 /* VMID=2*50k */
-                val = wm8990_read_reg_cache(codec, WM8990_POWER_MANAGEMENT_1) &
+                val = snd_soc_read(codec, WM8990_POWER_MANAGEMENT_1) &
                         ~WM8990_VMID_MODE_MASK;
-                wm8990_write(codec, WM8990_POWER_MANAGEMENT_1, val | 0x2);
+                snd_soc_write(codec, WM8990_POWER_MANAGEMENT_1, val | 0x2);
                 break;
 
         case SND_SOC_BIAS_STANDBY:
                 if (codec->bias_level == SND_SOC_BIAS_OFF) {
                         /* Enable all output discharge bits */
-                        wm8990_write(codec, WM8990_ANTIPOP1, WM8990_DIS_LLINE |
+                        snd_soc_write(codec, WM8990_ANTIPOP1, WM8990_DIS_LLINE |
                                 WM8990_DIS_RLINE | WM8990_DIS_OUT3 |
                                 WM8990_DIS_OUT4 | WM8990_DIS_LOUT |
                                 WM8990_DIS_ROUT);
 
                         /* Enable POBCTRL, SOFT_ST, VMIDTOG and BUFDCOPEN */
-                        wm8990_write(codec, WM8990_ANTIPOP2, WM8990_SOFTST |
+                        snd_soc_write(codec, WM8990_ANTIPOP2, WM8990_SOFTST |
                                      WM8990_BUFDCOPEN | WM8990_POBCTRL |
                                      WM8990_VMIDTOG);
 
@@ -1234,83 +1188,83 @@ static int wm8990_set_bias_level(struct snd_soc_codec *codec,
                         msleep(msecs_to_jiffies(300));
 
                         /* Disable VMIDTOG */
-                        wm8990_write(codec, WM8990_ANTIPOP2, WM8990_SOFTST |
+                        snd_soc_write(codec, WM8990_ANTIPOP2, WM8990_SOFTST |
                                      WM8990_BUFDCOPEN | WM8990_POBCTRL);
 
                         /* disable all output discharge bits */
-                        wm8990_write(codec, WM8990_ANTIPOP1, 0);
+                        snd_soc_write(codec, WM8990_ANTIPOP1, 0);
 
                         /* Enable outputs */
-                        wm8990_write(codec, WM8990_POWER_MANAGEMENT_1, 0x1b00);
+                        snd_soc_write(codec, WM8990_POWER_MANAGEMENT_1, 0x1b00);
 
                         msleep(msecs_to_jiffies(50));
 
                         /* Enable VMID at 2x50k */
-                        wm8990_write(codec, WM8990_POWER_MANAGEMENT_1, 0x1f02);
+                        snd_soc_write(codec, WM8990_POWER_MANAGEMENT_1, 0x1f02);
 
                         msleep(msecs_to_jiffies(100));
 
                         /* Enable VREF */
-                        wm8990_write(codec, WM8990_POWER_MANAGEMENT_1, 0x1f03);
+                        snd_soc_write(codec, WM8990_POWER_MANAGEMENT_1, 0x1f03);
 
                         msleep(msecs_to_jiffies(600));
 
                         /* Enable BUFIOEN */
-                        wm8990_write(codec, WM8990_ANTIPOP2, WM8990_SOFTST |
+                        snd_soc_write(codec, WM8990_ANTIPOP2, WM8990_SOFTST |
                                      WM8990_BUFDCOPEN | WM8990_POBCTRL |
                                      WM8990_BUFIOEN);
 
                         /* Disable outputs */
-                        wm8990_write(codec, WM8990_POWER_MANAGEMENT_1, 0x3);
+                        snd_soc_write(codec, WM8990_POWER_MANAGEMENT_1, 0x3);
 
                         /* disable POBCTRL, SOFT_ST and BUFDCOPEN */
-                        wm8990_write(codec, WM8990_ANTIPOP2, WM8990_BUFIOEN);
+                        snd_soc_write(codec, WM8990_ANTIPOP2, WM8990_BUFIOEN);
 
                         /* Enable workaround for ADC clocking issue. */
-                        wm8990_write(codec, WM8990_EXT_ACCESS_ENA, 0x2);
-                        wm8990_write(codec, WM8990_EXT_CTL1, 0xa003);
-                        wm8990_write(codec, WM8990_EXT_ACCESS_ENA, 0);
+                        snd_soc_write(codec, WM8990_EXT_ACCESS_ENA, 0x2);
+                        snd_soc_write(codec, WM8990_EXT_CTL1, 0xa003);
+                        snd_soc_write(codec, WM8990_EXT_ACCESS_ENA, 0);
                 }
 
                 /* VMID=2*250k */
-                val = wm8990_read_reg_cache(codec, WM8990_POWER_MANAGEMENT_1) &
+                val = snd_soc_read(codec, WM8990_POWER_MANAGEMENT_1) &
                         ~WM8990_VMID_MODE_MASK;
-                wm8990_write(codec, WM8990_POWER_MANAGEMENT_1, val | 0x4);
+                snd_soc_write(codec, WM8990_POWER_MANAGEMENT_1, val | 0x4);
                 break;
 
         case SND_SOC_BIAS_OFF:
                 /* Enable POBCTRL and SOFT_ST */
-                wm8990_write(codec, WM8990_ANTIPOP2, WM8990_SOFTST |
+                snd_soc_write(codec, WM8990_ANTIPOP2, WM8990_SOFTST |
                         WM8990_POBCTRL | WM8990_BUFIOEN);
 
                 /* Enable POBCTRL, SOFT_ST and BUFDCOPEN */
-                wm8990_write(codec, WM8990_ANTIPOP2, WM8990_SOFTST |
+                snd_soc_write(codec, WM8990_ANTIPOP2, WM8990_SOFTST |
                         WM8990_BUFDCOPEN | WM8990_POBCTRL |
                         WM8990_BUFIOEN);
 
                 /* mute DAC */
-                val = wm8990_read_reg_cache(codec, WM8990_DAC_CTRL);
-                wm8990_write(codec, WM8990_DAC_CTRL, val | WM8990_DAC_MUTE);
+                val = snd_soc_read(codec, WM8990_DAC_CTRL);
+                snd_soc_write(codec, WM8990_DAC_CTRL, val | WM8990_DAC_MUTE);
 
                 /* Enable any disabled outputs */
-                wm8990_write(codec, WM8990_POWER_MANAGEMENT_1, 0x1f03);
+                snd_soc_write(codec, WM8990_POWER_MANAGEMENT_1, 0x1f03);
 
                 /* Disable VMID */
-                wm8990_write(codec, WM8990_POWER_MANAGEMENT_1, 0x1f01);
+                snd_soc_write(codec, WM8990_POWER_MANAGEMENT_1, 0x1f01);
 
                 msleep(msecs_to_jiffies(300));
 
                 /* Enable all output discharge bits */
-                wm8990_write(codec, WM8990_ANTIPOP1, WM8990_DIS_LLINE |
+                snd_soc_write(codec, WM8990_ANTIPOP1, WM8990_DIS_LLINE |
                         WM8990_DIS_RLINE | WM8990_DIS_OUT3 |
                         WM8990_DIS_OUT4 | WM8990_DIS_LOUT |
                         WM8990_DIS_ROUT);
 
                 /* Disable VREF */
-                wm8990_write(codec, WM8990_POWER_MANAGEMENT_1, 0x0);
+                snd_soc_write(codec, WM8990_POWER_MANAGEMENT_1, 0x0);
 
                 /* disable POBCTRL, SOFT_ST and BUFDCOPEN */
-                wm8990_write(codec, WM8990_ANTIPOP2, 0x0);
+                snd_soc_write(codec, WM8990_ANTIPOP2, 0x0);
                 break;
         }
 
@@ -1411,8 +1365,6 @@ static int wm8990_init(struct snd_soc_device *socdev)
 
         codec->name = "WM8990";
         codec->owner = THIS_MODULE;
-        codec->read = wm8990_read_reg_cache;
-        codec->write = wm8990_write;
         codec->set_bias_level = wm8990_set_bias_level;
         codec->dai = &wm8990_dai;
         codec->num_dai = 2;
@@ -1422,6 +1374,12 @@ static int wm8990_init(struct snd_soc_device *socdev)
         if (codec->reg_cache == NULL)
                 return -ENOMEM;
 
+        ret = snd_soc_codec_set_cache_io(codec, 8, 16, SND_SOC_I2C);
+        if (ret < 0) {
+                printk(KERN_ERR "wm8990: failed to set cache I/O: %d\n", ret);
+                goto pcm_err;
+        }
+
         wm8990_reset(codec);
 
         /* register pcms */
@@ -1435,18 +1393,18 @@ static int wm8990_init(struct snd_soc_device *socdev)
         codec->bias_level = SND_SOC_BIAS_OFF;
         wm8990_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
 
-        reg = wm8990_read_reg_cache(codec, WM8990_AUDIO_INTERFACE_4);
-        wm8990_write(codec, WM8990_AUDIO_INTERFACE_4, reg | WM8990_ALRCGPIO1);
+        reg = snd_soc_read(codec, WM8990_AUDIO_INTERFACE_4);
+        snd_soc_write(codec, WM8990_AUDIO_INTERFACE_4, reg | WM8990_ALRCGPIO1);
 
-        reg = wm8990_read_reg_cache(codec, WM8990_GPIO1_GPIO2) &
+        reg = snd_soc_read(codec, WM8990_GPIO1_GPIO2) &
                 ~WM8990_GPIO1_SEL_MASK;
-        wm8990_write(codec, WM8990_GPIO1_GPIO2, reg | 1);
+        snd_soc_write(codec, WM8990_GPIO1_GPIO2, reg | 1);
 
-        reg = wm8990_read_reg_cache(codec, WM8990_POWER_MANAGEMENT_2);
-        wm8990_write(codec, WM8990_POWER_MANAGEMENT_2, reg | WM8990_OPCLK_ENA);
+        reg = snd_soc_read(codec, WM8990_POWER_MANAGEMENT_2);
+        snd_soc_write(codec, WM8990_POWER_MANAGEMENT_2, reg | WM8990_OPCLK_ENA);
 
-        wm8990_write(codec, WM8990_LEFT_OUTPUT_VOLUME, 0x50 | (1<<8));
-        wm8990_write(codec, WM8990_RIGHT_OUTPUT_VOLUME, 0x50 | (1<<8));
+        snd_soc_write(codec, WM8990_LEFT_OUTPUT_VOLUME, 0x50 | (1<<8));
+        snd_soc_write(codec, WM8990_RIGHT_OUTPUT_VOLUME, 0x50 | (1<<8));
 
         snd_soc_add_controls(codec, wm8990_snd_controls,
                                 ARRAY_SIZE(wm8990_snd_controls));
diff --git a/sound/soc/codecs/wm8993.c b/sound/soc/codecs/wm8993.c
new file mode 100644
index 000000000000..13befa338247
--- /dev/null
+++ b/sound/soc/codecs/wm8993.c
@@ -0,0 +1,1595 @@
+/*
+ * wm8993.c -- WM8993 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/spi/spi.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/tlv.h>
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+#include <sound/initval.h>
+#include <sound/wm8993.h>
+
+#include "wm8993.h"
+#include "wm_hubs.h"
+
+static u16 wm8993_reg_defaults[WM8993_REGISTER_COUNT] = {
+        0x8993,     /* R0   - Software Reset */
+        0x0000,     /* R1   - Power Management (1) */
+        0x6000,     /* R2   - Power Management (2) */
+        0x0000,     /* R3   - Power Management (3) */
+        0x4050,     /* R4   - Audio Interface (1) */
+        0x4000,     /* R5   - Audio Interface (2) */
+        0x01C8,     /* R6   - Clocking 1 */
+        0x0000,     /* R7   - Clocking 2 */
+        0x0000,     /* R8   - Audio Interface (3) */
+        0x0040,     /* R9   - Audio Interface (4) */
+        0x0004,     /* R10  - DAC CTRL */
+        0x00C0,     /* R11  - Left DAC Digital Volume */
+        0x00C0,     /* R12  - Right DAC Digital Volume */
+        0x0000,     /* R13  - Digital Side Tone */
+        0x0300,     /* R14  - ADC CTRL */
+        0x00C0,     /* R15  - Left ADC Digital Volume */
+        0x00C0,     /* R16  - Right ADC Digital Volume */
+        0x0000,     /* R17 */
+        0x0000,     /* R18  - GPIO CTRL 1 */
+        0x0010,     /* R19  - GPIO1 */
+        0x0000,     /* R20  - IRQ_DEBOUNCE */
+        0x0000,     /* R21 */
+        0x8000,     /* R22  - GPIOCTRL 2 */
+        0x0800,     /* R23  - GPIO_POL */
+        0x008B,     /* R24  - Left Line Input 1&2 Volume */
+        0x008B,     /* R25  - Left Line Input 3&4 Volume */
+        0x008B,     /* R26  - Right Line Input 1&2 Volume */
+        0x008B,     /* R27  - Right Line Input 3&4 Volume */
+        0x006D,     /* R28  - Left Output Volume */
+        0x006D,     /* R29  - Right Output Volume */
+        0x0066,     /* R30  - Line Outputs Volume */
+        0x0020,     /* R31  - HPOUT2 Volume */
+        0x0079,     /* R32  - Left OPGA Volume */
+        0x0079,     /* R33  - Right OPGA Volume */
+        0x0003,     /* R34  - SPKMIXL Attenuation */
+        0x0003,     /* R35  - SPKMIXR Attenuation */
+        0x0011,     /* R36  - SPKOUT Mixers */
+        0x0100,     /* R37  - SPKOUT Boost */
+        0x0079,     /* R38  - Speaker Volume Left */
+        0x0079,     /* R39  - Speaker Volume Right */
+        0x0000,     /* R40  - Input Mixer2 */
+        0x0000,     /* R41  - Input Mixer3 */
+        0x0000,     /* R42  - Input Mixer4 */
+        0x0000,     /* R43  - Input Mixer5 */
+        0x0000,     /* R44  - Input Mixer6 */
+        0x0000,     /* R45  - Output Mixer1 */
+        0x0000,     /* R46  - Output Mixer2 */
+        0x0000,     /* R47  - Output Mixer3 */
+        0x0000,     /* R48  - Output Mixer4 */
+        0x0000,     /* R49  - Output Mixer5 */
+        0x0000,     /* R50  - Output Mixer6 */
+        0x0000,     /* R51  - HPOUT2 Mixer */
+        0x0000,     /* R52  - Line Mixer1 */
+        0x0000,     /* R53  - Line Mixer2 */
+        0x0000,     /* R54  - Speaker Mixer */
+        0x0000,     /* R55  - Additional Control */
+        0x0000,     /* R56  - AntiPOP1 */
+        0x0000,     /* R57  - AntiPOP2 */
+        0x0000,     /* R58  - MICBIAS */
+        0x0000,     /* R59 */
+        0x0000,     /* R60  - FLL Control 1 */
+        0x0000,     /* R61  - FLL Control 2 */
+        0x0000,     /* R62  - FLL Control 3 */
+        0x2EE0,     /* R63  - FLL Control 4 */
+        0x0002,     /* R64  - FLL Control 5 */
+        0x2287,     /* R65  - Clocking 3 */
+        0x025F,     /* R66  - Clocking 4 */
+        0x0000,     /* R67  - MW Slave Control */
+        0x0000,     /* R68 */
+        0x0002,     /* R69  - Bus Control 1 */
+        0x0000,     /* R70  - Write Sequencer 0 */
+        0x0000,     /* R71  - Write Sequencer 1 */
+        0x0000,     /* R72  - Write Sequencer 2 */
+        0x0000,     /* R73  - Write Sequencer 3 */
+        0x0000,     /* R74  - Write Sequencer 4 */
+        0x0000,     /* R75  - Write Sequencer 5 */
+        0x1F25,     /* R76  - Charge Pump 1 */
+        0x0000,     /* R77 */
+        0x0000,     /* R78 */
+        0x0000,     /* R79 */
+        0x0000,     /* R80 */
+        0x0000,     /* R81  - Class W 0 */
+        0x0000,     /* R82 */
+        0x0000,     /* R83 */
+        0x0000,     /* R84  - DC Servo 0 */
+        0x054A,     /* R85  - DC Servo 1 */
+        0x0000,     /* R86 */
+        0x0000,     /* R87  - DC Servo 3 */
+        0x0000,     /* R88  - DC Servo Readback 0 */
+        0x0000,     /* R89  - DC Servo Readback 1 */
+        0x0000,     /* R90  - DC Servo Readback 2 */
+        0x0000,     /* R91 */
+        0x0000,     /* R92 */
+        0x0000,     /* R93 */
+        0x0000,     /* R94 */
+        0x0000,     /* R95 */
+        0x0100,     /* R96  - Analogue HP 0 */
+        0x0000,     /* R97 */
+        0x0000,     /* R98  - EQ1 */
+        0x000C,     /* R99  - EQ2 */
+        0x000C,     /* R100 - EQ3 */
+        0x000C,     /* R101 - EQ4 */
+        0x000C,     /* R102 - EQ5 */
+        0x000C,     /* R103 - EQ6 */
+        0x0FCA,     /* R104 - EQ7 */
+        0x0400,     /* R105 - EQ8 */
+        0x00D8,     /* R106 - EQ9 */
+        0x1EB5,     /* R107 - EQ10 */
+        0xF145,     /* R108 - EQ11 */
+        0x0B75,     /* R109 - EQ12 */
+        0x01C5,     /* R110 - EQ13 */
+        0x1C58,     /* R111 - EQ14 */
+        0xF373,     /* R112 - EQ15 */
+        0x0A54,     /* R113 - EQ16 */
+        0x0558,     /* R114 - EQ17 */
+        0x168E,     /* R115 - EQ18 */
+        0xF829,     /* R116 - EQ19 */
+        0x07AD,     /* R117 - EQ20 */
+        0x1103,     /* R118 - EQ21 */
+        0x0564,     /* R119 - EQ22 */
+        0x0559,     /* R120 - EQ23 */
+        0x4000,     /* R121 - EQ24 */
+        0x0000,     /* R122 - Digital Pulls */
+        0x0F08,     /* R123 - DRC Control 1 */
+        0x0000,     /* R124 - DRC Control 2 */
+        0x0080,     /* R125 - DRC Control 3 */
+        0x0000,     /* R126 - DRC Control 4 */
+};
+
+static struct {
+        int ratio;
+        int clk_sys_rate;
+} clk_sys_rates[] = {
+        { 64,   0 },
+        { 128,  1 },
+        { 192,  2 },
+        { 256,  3 },
+        { 384,  4 },
+        { 512,  5 },
+        { 768,  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  },
+        { 55,  5  },
+        { 60,  6  },
+        { 80,  7  },
+        { 110, 8  },
+        { 120, 9  },
+        { 160, 10 },
+        { 220, 11 },
+        { 240, 12 },
+        { 320, 13 },
+        { 440, 14 },
+        { 480, 15 },
+};
+
+struct wm8993_priv {
+        u16 reg_cache[WM8993_REGISTER_COUNT];
+        struct wm8993_platform_data pdata;
+        struct snd_soc_codec codec;
+        int master;
+        int sysclk_source;
+        int tdm_slots;
+        int tdm_width;
+        unsigned int mclk_rate;
+        unsigned int sysclk_rate;
+        unsigned int fs;
+        unsigned int bclk;
+        int class_w_users;
+        unsigned int fll_fref;
+        unsigned int fll_fout;
+};
+
+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) {
+        case WM8993_SOFTWARE_RESET:
+        case WM8993_DC_SERVO_0:
+        case WM8993_DC_SERVO_READBACK_0:
+        case WM8993_DC_SERVO_READBACK_1:
+        case WM8993_DC_SERVO_READBACK_2:
+                return 1;
+        default:
+                return 0;
+        }
+}
+
+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;
+        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 = 0;
+        target = Fout * 2;
+        while (target < 90000000) {
+                div++;
+                target *= 2;
+                if (div > 7) {
+                        pr_err("Unable to find FLL_OUTDIV for Fout=%uHz\n",
+                               Fout);
+                        return -EINVAL;
+                }
+        }
+        fll_div->fll_outdiv = div;
+
+        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 wm8993_set_fll(struct snd_soc_dai *dai, int fll_id,
+                          unsigned int Fref, unsigned int Fout)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        struct wm8993_priv *wm8993 = codec->private_data;
+        u16 reg1, reg4, reg5;
+        struct _fll_div fll_div;
+        int ret;
+
+        /* Any change? */
+        if (Fref == wm8993->fll_fref && Fout == wm8993->fll_fout)
+                return 0;
+
+        /* Disable the FLL */
+        if (Fout == 0) {
+                dev_dbg(codec->dev, "FLL disabled\n");
+                wm8993->fll_fref = 0;
+                wm8993->fll_fout = 0;
+
+                reg1 = wm8993_read(codec, WM8993_FLL_CONTROL_1);
+                reg1 &= ~WM8993_FLL_ENA;
+                wm8993_write(codec, WM8993_FLL_CONTROL_1, reg1);
+
+                return 0;
+        }
+
+        ret = fll_factors(&fll_div, Fref, Fout);
+        if (ret != 0)
+                return ret;
+
+        reg5 = wm8993_read(codec, WM8993_FLL_CONTROL_5);
+        reg5 &= ~WM8993_FLL_CLK_SRC_MASK;
+
+        switch (fll_id) {
+        case WM8993_FLL_MCLK:
+                break;
+
+        case WM8993_FLL_LRCLK:
+                reg5 |= 1;
+                break;
+
+        case WM8993_FLL_BCLK:
+                reg5 |= 2;
+                break;
+
+        default:
+                dev_err(codec->dev, "Unknown FLL ID %d\n", fll_id);
+                return -EINVAL;
+        }
+
+        /* Any FLL configuration change requires that the FLL be
+         * disabled first. */
+        reg1 = wm8993_read(codec, WM8993_FLL_CONTROL_1);
+        reg1 &= ~WM8993_FLL_ENA;
+        wm8993_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);
+
+        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);
+
+        reg4 = wm8993_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);
+
+        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);
+
+        /* Enable the FLL */
+        wm8993_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;
+
+        return 0;
+}
+
+static int configure_clock(struct snd_soc_codec *codec)
+{
+        struct wm8993_priv *wm8993 = codec->private_data;
+        unsigned int reg;
+
+        /* This should be done on init() for bypass paths */
+        switch (wm8993->sysclk_source) {
+        case WM8993_SYSCLK_MCLK:
+                dev_dbg(codec->dev, "Using %dHz MCLK\n", wm8993->mclk_rate);
+
+                reg = wm8993_read(codec, WM8993_CLOCKING_2);
+                reg &= ~(WM8993_MCLK_DIV | WM8993_SYSCLK_SRC);
+                if (wm8993->mclk_rate > 13500000) {
+                        reg |= WM8993_MCLK_DIV;
+                        wm8993->sysclk_rate = wm8993->mclk_rate / 2;
+                } else {
+                        reg &= ~WM8993_MCLK_DIV;
+                        wm8993->sysclk_rate = wm8993->mclk_rate;
+                }
+                wm8993_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 |= WM8993_SYSCLK_SRC;
+                if (wm8993->fll_fout > 13500000) {
+                        reg |= WM8993_MCLK_DIV;
+                        wm8993->sysclk_rate = wm8993->fll_fout / 2;
+                } else {
+                        reg &= ~WM8993_MCLK_DIV;
+                        wm8993->sysclk_rate = wm8993->fll_fout;
+                }
+                wm8993_write(codec, WM8993_CLOCKING_2, reg);
+                break;
+
+        default:
+                dev_err(codec->dev, "System clock not configured\n");
+                return -EINVAL;
+        }
+
+        dev_dbg(codec->dev, "CLK_SYS is %dHz\n", wm8993->sysclk_rate);
+
+        return 0;
+}
+
+static const DECLARE_TLV_DB_SCALE(sidetone_tlv, -3600, 300, 0);
+static const DECLARE_TLV_DB_SCALE(drc_comp_threash, -4500, 75, 0);
+static const DECLARE_TLV_DB_SCALE(drc_comp_amp, -2250, 75, 0);
+static const DECLARE_TLV_DB_SCALE(drc_min_tlv, -1800, 600, 0);
+static const unsigned int drc_max_tlv[] = {
+        TLV_DB_RANGE_HEAD(4),
+        0, 2, TLV_DB_SCALE_ITEM(1200, 600, 0),
+        3, 3, TLV_DB_SCALE_ITEM(3600, 0, 0),
+};
+static const DECLARE_TLV_DB_SCALE(drc_qr_tlv, 1200, 600, 0);
+static const DECLARE_TLV_DB_SCALE(drc_startup_tlv, -1800, 300, 0);
+static const DECLARE_TLV_DB_SCALE(eq_tlv, -1200, 100, 0);
+static const DECLARE_TLV_DB_SCALE(digital_tlv, -7200, 75, 1);
+static const DECLARE_TLV_DB_SCALE(dac_boost_tlv, 0, 600, 0);
+
+static const char *dac_deemph_text[] = {
+        "None",
+        "32kHz",
+        "44.1kHz",
+        "48kHz",
+};
+
+static const struct soc_enum dac_deemph =
+        SOC_ENUM_SINGLE(WM8993_DAC_CTRL, 4, 4, dac_deemph_text);
+
+static const char *adc_hpf_text[] = {
+        "Hi-Fi",
+        "Voice 1",
+        "Voice 2",
+        "Voice 3",
+};
+
+static const struct soc_enum adc_hpf =
+        SOC_ENUM_SINGLE(WM8993_ADC_CTRL, 5, 4, adc_hpf_text);
+
+static const char *drc_path_text[] = {
+        "ADC",
+        "DAC"
+};
+
+static const struct soc_enum drc_path =
+        SOC_ENUM_SINGLE(WM8993_DRC_CONTROL_1, 14, 2, drc_path_text);
+
+static const char *drc_r0_text[] = {
+        "1",
+        "1/2",
+        "1/4",
+        "1/8",
+        "1/16",
+        "0",
+};
+
+static const struct soc_enum drc_r0 =
+        SOC_ENUM_SINGLE(WM8993_DRC_CONTROL_3, 8, 6, drc_r0_text);
+
+static const char *drc_r1_text[] = {
+        "1",
+        "1/2",
+        "1/4",
+        "1/8",
+        "0",
+};
+
+static const struct soc_enum drc_r1 =
+        SOC_ENUM_SINGLE(WM8993_DRC_CONTROL_4, 13, 5, drc_r1_text);
+
+static const char *drc_attack_text[] = {
+        "Reserved",
+        "181us",
+        "363us",
+        "726us",
+        "1.45ms",
+        "2.9ms",
+        "5.8ms",
+        "11.6ms",
+        "23.2ms",
+        "46.4ms",
+        "92.8ms",
+        "185.6ms",
+};
+
+static const struct soc_enum drc_attack =
+        SOC_ENUM_SINGLE(WM8993_DRC_CONTROL_2, 12, 12, drc_attack_text);
+
+static const char *drc_decay_text[] = {
+        "186ms",
+        "372ms",
+        "743ms",
+        "1.49s",
+        "2.97ms",
+        "5.94ms",
+        "11.89ms",
+        "23.78ms",
+        "47.56ms",
+};
+
+static const struct soc_enum drc_decay =
+        SOC_ENUM_SINGLE(WM8993_DRC_CONTROL_2, 8, 9, drc_decay_text);
+
+static const char *drc_ff_text[] = {
+        "5 samples",
+        "9 samples",
+};
+
+static const struct soc_enum drc_ff =
+        SOC_ENUM_SINGLE(WM8993_DRC_CONTROL_3, 7, 2, drc_ff_text);
+
+static const char *drc_qr_rate_text[] = {
+        "0.725ms",
+        "1.45ms",
+        "5.8ms",
+};
+
+static const struct soc_enum drc_qr_rate =
+        SOC_ENUM_SINGLE(WM8993_DRC_CONTROL_3, 0, 3, drc_qr_rate_text);
+
+static const char *drc_smooth_text[] = {
+        "Low",
+        "Medium",
+        "High",
+};
+
+static const struct soc_enum drc_smooth =
+        SOC_ENUM_SINGLE(WM8993_DRC_CONTROL_1, 4, 3, drc_smooth_text);
+
+static const struct snd_kcontrol_new wm8993_snd_controls[] = {
+SOC_DOUBLE_TLV("Digital Sidetone Volume", WM8993_DIGITAL_SIDE_TONE,
+               5, 9, 12, 0, sidetone_tlv),
+
+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,
+               2, 60, 1, drc_comp_threash),
+SOC_SINGLE_TLV("DRC Compressor Amplitude Volume", WM8993_DRC_CONTROL_3,
+               11, 30, 1, drc_comp_amp),
+SOC_ENUM("DRC R0", drc_r0),
+SOC_ENUM("DRC R1", drc_r1),
+SOC_SINGLE_TLV("DRC Minimum Volume", WM8993_DRC_CONTROL_1, 2, 3, 1,
+               drc_min_tlv),
+SOC_SINGLE_TLV("DRC Maximum Volume", WM8993_DRC_CONTROL_1, 0, 3, 0,
+               drc_max_tlv),
+SOC_ENUM("DRC Attack Rate", drc_attack),
+SOC_ENUM("DRC Decay Rate", drc_decay),
+SOC_ENUM("DRC FF Delay", drc_ff),
+SOC_SINGLE("DRC Anti-clip Switch", WM8993_DRC_CONTROL_1, 9, 1, 0),
+SOC_SINGLE("DRC Quick Release Switch", WM8993_DRC_CONTROL_1, 10, 1, 0),
+SOC_SINGLE_TLV("DRC Quick Release Volume", WM8993_DRC_CONTROL_3, 2, 3, 0,
+               drc_qr_tlv),
+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_SINGLE_TLV("DRC Startup Volume", WM8993_DRC_CONTROL_4, 8, 18, 0,
+               drc_startup_tlv),
+
+SOC_SINGLE("EQ Switch", WM8993_EQ1, 0, 1, 0),
+
+SOC_DOUBLE_R_TLV("Capture Volume", WM8993_LEFT_ADC_DIGITAL_VOLUME,
+                 WM8993_RIGHT_ADC_DIGITAL_VOLUME, 1, 96, 0, digital_tlv),
+SOC_SINGLE("ADC High Pass Filter Switch", WM8993_ADC_CTRL, 8, 1, 0),
+SOC_ENUM("ADC High Pass Filter Mode", adc_hpf),
+
+SOC_DOUBLE_R_TLV("Playback Volume", WM8993_LEFT_DAC_DIGITAL_VOLUME,
+                 WM8993_RIGHT_DAC_DIGITAL_VOLUME, 1, 96, 0, digital_tlv),
+SOC_SINGLE_TLV("Playback Boost Volume", WM8993_AUDIO_INTERFACE_2, 10, 3, 0,
+               dac_boost_tlv),
+SOC_ENUM("DAC Deemphasis", dac_deemph),
+
+SOC_SINGLE_TLV("SPKL DAC Volume", WM8993_SPKMIXL_ATTENUATION,
+               2, 1, 1, wm_hubs_spkmix_tlv),
+
+SOC_SINGLE_TLV("SPKR DAC Volume", WM8993_SPKMIXR_ATTENUATION,
+               2, 1, 1, wm_hubs_spkmix_tlv),
+};
+
+static const struct snd_kcontrol_new wm8993_eq_controls[] = {
+SOC_SINGLE_TLV("EQ1 Volume", WM8993_EQ2, 0, 24, 0, eq_tlv),
+SOC_SINGLE_TLV("EQ2 Volume", WM8993_EQ3, 0, 24, 0, eq_tlv),
+SOC_SINGLE_TLV("EQ3 Volume", WM8993_EQ4, 0, 24, 0, eq_tlv),
+SOC_SINGLE_TLV("EQ4 Volume", WM8993_EQ5, 0, 24, 0, eq_tlv),
+SOC_SINGLE_TLV("EQ5 Volume", WM8993_EQ6, 0, 24, 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:
+                break;
+        }
+
+        return 0;
+}
+
+/*
+ * When used with DAC outputs only the WM8993 charge pump supports
+ * operation in class W mode, providing very low power consumption
+ * when used with digital sources.  Enable and disable this mode
+ * automatically depending on the mixer configuration.
+ *
+ * Currently the only supported paths are the direct DAC->headphone
+ * paths (which provide minimum power consumption anyway).
+ */
+static int class_w_put(struct snd_kcontrol *kcontrol,
+                       struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
+        struct snd_soc_codec *codec = widget->codec;
+        struct wm8993_priv *wm8993 = codec->private_data;
+        int ret;
+
+        /* Turn it off if we're using the main output mixer */
+        if (ucontrol->value.integer.value[0] == 0) {
+                if (wm8993->class_w_users == 0) {
+                        dev_dbg(codec->dev, "Disabling Class W\n");
+                        snd_soc_update_bits(codec, WM8993_CLASS_W_0,
+                                            WM8993_CP_DYN_FREQ |
+                                            WM8993_CP_DYN_V,
+                                            0);
+                }
+                wm8993->class_w_users++;
+        }
+
+        /* Implement the change */
+        ret = snd_soc_dapm_put_enum_double(kcontrol, ucontrol);
+
+        /* Enable it if we're using the direct DAC path */
+        if (ucontrol->value.integer.value[0] == 1) {
+                if (wm8993->class_w_users == 1) {
+                        dev_dbg(codec->dev, "Enabling Class W\n");
+                        snd_soc_update_bits(codec, WM8993_CLASS_W_0,
+                                            WM8993_CP_DYN_FREQ |
+                                            WM8993_CP_DYN_V,
+                                            WM8993_CP_DYN_FREQ |
+                                            WM8993_CP_DYN_V);
+                }
+                wm8993->class_w_users--;
+        }
+
+        dev_dbg(codec->dev, "Indirect DAC use count now %d\n",
+                wm8993->class_w_users);
+
+        return ret;
+}
+
+#define SOC_DAPM_ENUM_W(xname, xenum) \
+{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
+        .info = snd_soc_info_enum_double, \
+        .get = snd_soc_dapm_get_enum_double, \
+        .put = class_w_put, \
+        .private_value = (unsigned long)&xenum }
+
+static const char *hp_mux_text[] = {
+        "Mixer",
+        "DAC",
+};
+
+static const struct soc_enum hpl_enum =
+        SOC_ENUM_SINGLE(WM8993_OUTPUT_MIXER1, 8, 2, hp_mux_text);
+
+static const struct snd_kcontrol_new hpl_mux =
+        SOC_DAPM_ENUM_W("Left Headphone Mux", hpl_enum);
+
+static const struct soc_enum hpr_enum =
+        SOC_ENUM_SINGLE(WM8993_OUTPUT_MIXER2, 8, 2, hp_mux_text);
+
+static const struct snd_kcontrol_new hpr_mux =
+        SOC_DAPM_ENUM_W("Right Headphone Mux", hpr_enum);
+
+static const struct snd_kcontrol_new left_speaker_mixer[] = {
+SOC_DAPM_SINGLE("Input Switch", WM8993_SPEAKER_MIXER, 7, 1, 0),
+SOC_DAPM_SINGLE("IN1LP Switch", WM8993_SPEAKER_MIXER, 5, 1, 0),
+SOC_DAPM_SINGLE("Output Switch", WM8993_SPEAKER_MIXER, 3, 1, 0),
+SOC_DAPM_SINGLE("DAC Switch", WM8993_SPEAKER_MIXER, 6, 1, 0),
+};
+
+static const struct snd_kcontrol_new right_speaker_mixer[] = {
+SOC_DAPM_SINGLE("Input Switch", WM8993_SPEAKER_MIXER, 6, 1, 0),
+SOC_DAPM_SINGLE("IN1RP Switch", WM8993_SPEAKER_MIXER, 4, 1, 0),
+SOC_DAPM_SINGLE("Output Switch", WM8993_SPEAKER_MIXER, 2, 1, 0),
+SOC_DAPM_SINGLE("DAC Switch", WM8993_SPEAKER_MIXER, 0, 1, 0),
+};
+
+static const struct snd_soc_dapm_widget wm8993_dapm_widgets[] = {
+SND_SOC_DAPM_SUPPLY("CLK_SYS", WM8993_BUS_CONTROL_1, 1, 0, clk_sys_event,
+                    SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
+SND_SOC_DAPM_SUPPLY("TOCLK", WM8993_CLOCKING_1, 14, 0, NULL, 0),
+SND_SOC_DAPM_SUPPLY("CLK_DSP", WM8993_CLOCKING_3, 0, 0, NULL, 0),
+
+
+SND_SOC_DAPM_ADC("ADCL", "Capture", WM8993_POWER_MANAGEMENT_2, 1, 0),
+SND_SOC_DAPM_ADC("ADCR", "Capture", WM8993_POWER_MANAGEMENT_2, 0, 0),
+
+SND_SOC_DAPM_DAC("DACL", "Playback", WM8993_POWER_MANAGEMENT_3, 1, 0),
+SND_SOC_DAPM_DAC("DACR", "Playback", WM8993_POWER_MANAGEMENT_3, 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", WM8993_POWER_MANAGEMENT_3, 8, 0,
+                   left_speaker_mixer, ARRAY_SIZE(left_speaker_mixer)),
+SND_SOC_DAPM_MIXER("SPKR", WM8993_POWER_MANAGEMENT_3, 9, 0,
+                   right_speaker_mixer, ARRAY_SIZE(right_speaker_mixer)),
+
+};
+
+static const struct snd_soc_dapm_route routes[] = {
+        { "ADCL", NULL, "CLK_SYS" },
+        { "ADCL", NULL, "CLK_DSP" },
+        { "ADCR", NULL, "CLK_SYS" },
+        { "ADCR", NULL, "CLK_DSP" },
+
+        { "DACL", NULL, "CLK_SYS" },
+        { "DACL", NULL, "CLK_DSP" },
+        { "DACR", NULL, "CLK_SYS" },
+        { "DACR", NULL, "CLK_DSP" },
+
+        { "Left Output Mixer", "DAC Switch", "DACL" },
+
+        { "Right Output Mixer", "DAC Switch", "DACR" },
+
+        { "Left Output PGA", NULL, "CLK_SYS" },
+
+        { "Right Output PGA", NULL, "CLK_SYS" },
+
+        { "SPKL", "DAC Switch", "DACL" },
+        { "SPKL", NULL, "CLK_SYS" },
+
+        { "SPKR", "DAC Switch", "DACR" },
+        { "SPKR", NULL, "CLK_SYS" },
+
+        { "Left Headphone Mux", "DAC", "DACL" },
+        { "Right Headphone Mux", "DAC", "DACR" },
+};
+
+static int wm8993_set_bias_level(struct snd_soc_codec *codec,
+                                 enum snd_soc_bias_level level)
+{
+        struct wm8993_priv *wm8993 = codec->private_data;
+
+        switch (level) {
+        case SND_SOC_BIAS_ON:
+        case SND_SOC_BIAS_PREPARE:
+                /* VMID=2*40k */
+                snd_soc_update_bits(codec, WM8993_POWER_MANAGEMENT_1,
+                                    WM8993_VMID_SEL_MASK, 0x2);
+                snd_soc_update_bits(codec, WM8993_POWER_MANAGEMENT_2,
+                                    WM8993_TSHUT_ENA, WM8993_TSHUT_ENA);
+                break;
+
+        case SND_SOC_BIAS_STANDBY:
+                if (codec->bias_level == SND_SOC_BIAS_OFF) {
+                        /* Bring up VMID with fast soft start */
+                        snd_soc_update_bits(codec, WM8993_ANTIPOP2,
+                                            WM8993_STARTUP_BIAS_ENA |
+                                            WM8993_VMID_BUF_ENA |
+                                            WM8993_VMID_RAMP_MASK |
+                                            WM8993_BIAS_SRC,
+                                            WM8993_STARTUP_BIAS_ENA |
+                                            WM8993_VMID_BUF_ENA |
+                                            WM8993_VMID_RAMP_MASK |
+                                            WM8993_BIAS_SRC);
+
+                        /* If either line output is single ended we
+                         * need the VMID buffer */
+                        if (!wm8993->pdata.lineout1_diff ||
+                            !wm8993->pdata.lineout2_diff)
+                                snd_soc_update_bits(codec, WM8993_ANTIPOP1,
+                                                 WM8993_LINEOUT_VMID_BUF_ENA,
+                                                 WM8993_LINEOUT_VMID_BUF_ENA);
+
+                        /* VMID=2*40k */
+                        snd_soc_update_bits(codec, WM8993_POWER_MANAGEMENT_1,
+                                            WM8993_VMID_SEL_MASK |
+                                            WM8993_BIAS_ENA,
+                                            WM8993_BIAS_ENA | 0x2);
+                        msleep(32);
+
+                        /* Switch to normal bias */
+                        snd_soc_update_bits(codec, WM8993_ANTIPOP2,
+                                            WM8993_BIAS_SRC |
+                                            WM8993_STARTUP_BIAS_ENA, 0);
+                }
+
+                /* VMID=2*240k */
+                snd_soc_update_bits(codec, WM8993_POWER_MANAGEMENT_1,
+                                    WM8993_VMID_SEL_MASK, 0x4);
+
+                snd_soc_update_bits(codec, WM8993_POWER_MANAGEMENT_2,
+                                    WM8993_TSHUT_ENA, 0);
+                break;
+
+        case SND_SOC_BIAS_OFF:
+                snd_soc_update_bits(codec, WM8993_ANTIPOP1,
+                                    WM8993_LINEOUT_VMID_BUF_ENA, 0);
+
+                snd_soc_update_bits(codec, WM8993_POWER_MANAGEMENT_1,
+                                    WM8993_VMID_SEL_MASK | WM8993_BIAS_ENA,
+                                    0);
+                break;
+        }
+
+        codec->bias_level = level;
+
+        return 0;
+}
+
+static int wm8993_set_sysclk(struct snd_soc_dai *codec_dai,
+                             int clk_id, unsigned int freq, int dir)
+{
+        struct snd_soc_codec *codec = codec_dai->codec;
+        struct wm8993_priv *wm8993 = codec->private_data;
+
+        switch (clk_id) {
+        case WM8993_SYSCLK_MCLK:
+                wm8993->mclk_rate = freq;
+        case WM8993_SYSCLK_FLL:
+                wm8993->sysclk_source = clk_id;
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int wm8993_set_dai_fmt(struct snd_soc_dai *dai,
+                              unsigned int fmt)
+{
+        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);
+
+        aif1 &= ~(WM8993_BCLK_DIR | WM8993_AIF_BCLK_INV |
+                  WM8993_AIF_LRCLK_INV | WM8993_AIF_FMT_MASK);
+        aif4 &= ~WM8993_LRCLK_DIR;
+
+        switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
+        case SND_SOC_DAIFMT_CBS_CFS:
+                wm8993->master = 0;
+                break;
+        case SND_SOC_DAIFMT_CBS_CFM:
+                aif4 |= WM8993_LRCLK_DIR;
+                wm8993->master = 1;
+                break;
+        case SND_SOC_DAIFMT_CBM_CFS:
+                aif1 |= WM8993_BCLK_DIR;
+                wm8993->master = 1;
+                break;
+        case SND_SOC_DAIFMT_CBM_CFM:
+                aif1 |= WM8993_BCLK_DIR;
+                aif4 |= WM8993_LRCLK_DIR;
+                wm8993->master = 1;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
+        case SND_SOC_DAIFMT_DSP_B:
+                aif1 |= WM8993_AIF_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 |= WM8993_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 |= WM8993_AIF_BCLK_INV | WM8993_AIF_LRCLK_INV;
+                        break;
+                case SND_SOC_DAIFMT_IB_NF:
+                        aif1 |= WM8993_AIF_BCLK_INV;
+                        break;
+                case SND_SOC_DAIFMT_NB_IF:
+                        aif1 |= WM8993_AIF_LRCLK_INV;
+                        break;
+                default:
+                        return -EINVAL;
+                }
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        wm8993_write(codec, WM8993_AUDIO_INTERFACE_1, aif1);
+        wm8993_write(codec, WM8993_AUDIO_INTERFACE_4, aif4);
+
+        return 0;
+}
+
+static int wm8993_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 wm8993_priv *wm8993 = codec->private_data;
+        int ret, i, best, best_val, cur_val;
+        unsigned int clocking1, clocking3, aif1, aif4;
+
+        clocking1 = wm8993_read(codec, WM8993_CLOCKING_1);
+        clocking1 &= ~WM8993_BCLK_DIV_MASK;
+
+        clocking3 = wm8993_read(codec, WM8993_CLOCKING_3);
+        clocking3 &= ~(WM8993_CLK_SYS_RATE_MASK | WM8993_SAMPLE_RATE_MASK);
+
+        aif1 = wm8993_read(codec, WM8993_AUDIO_INTERFACE_1);
+        aif1 &= ~WM8993_AIF_WL_MASK;
+
+        aif4 = wm8993_read(codec, WM8993_AUDIO_INTERFACE_4);
+        aif4 &= ~WM8993_LRCLK_RATE_MASK;
+
+        /* What BCLK do we need? */
+        wm8993->fs = params_rate(params);
+        wm8993->bclk = 2 * wm8993->fs;
+        if (wm8993->tdm_slots) {
+                dev_dbg(codec->dev, "Configuring for %d %d bit TDM slots\n",
+                        wm8993->tdm_slots, wm8993->tdm_width);
+                wm8993->bclk *= wm8993->tdm_width * wm8993->tdm_slots;
+        } else {
+                switch (params_format(params)) {
+                case SNDRV_PCM_FORMAT_S16_LE:
+                        wm8993->bclk *= 16;
+                        break;
+                case SNDRV_PCM_FORMAT_S20_3LE:
+                        wm8993->bclk *= 20;
+                        aif1 |= 0x8;
+                        break;
+                case SNDRV_PCM_FORMAT_S24_LE:
+                        wm8993->bclk *= 24;
+                        aif1 |= 0x10;
+                        break;
+                case SNDRV_PCM_FORMAT_S32_LE:
+                        wm8993->bclk *= 32;
+                        aif1 |= 0x18;
+                        break;
+                default:
+                        return -EINVAL;
+                }
+        }
+
+        dev_dbg(codec->dev, "Target BCLK is %dHz\n", wm8993->bclk);
+
+        ret = configure_clock(codec);
+        if (ret != 0)
+                return ret;
+
+        /* Select nearest CLK_SYS_RATE */
+        best = 0;
+        best_val = abs((wm8993->sysclk_rate / clk_sys_rates[0].ratio)
+                       - wm8993->fs);
+        for (i = 1; i < ARRAY_SIZE(clk_sys_rates); i++) {
+                cur_val = abs((wm8993->sysclk_rate /
+                               clk_sys_rates[i].ratio) - wm8993->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);
+        clocking3 |= (clk_sys_rates[best].clk_sys_rate
+                      << WM8993_CLK_SYS_RATE_SHIFT);
+
+        /* SAMPLE_RATE */
+        best = 0;
+        best_val = abs(wm8993->fs - sample_rates[0].rate);
+        for (i = 1; i < ARRAY_SIZE(sample_rates); i++) {
+                /* Closest match */
+                cur_val = abs(wm8993->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);
+        clocking3 |= (sample_rates[best].sample_rate
+                      << WM8993_SAMPLE_RATE_SHIFT);
+
+        /* BCLK_DIV */
+        best = 0;
+        best_val = INT_MAX;
+        for (i = 0; i < ARRAY_SIZE(bclk_divs); i++) {
+                cur_val = ((wm8993->sysclk_rate * 10) / bclk_divs[i].div)
+                        - wm8993->bclk;
+                if (cur_val < 0) /* Table is sorted */
+                        break;
+                if (cur_val < best_val) {
+                        best = i;
+                        best_val = cur_val;
+                }
+        }
+        wm8993->bclk = (wm8993->sysclk_rate * 10) / bclk_divs[best].div;
+        dev_dbg(codec->dev, "Selected BCLK_DIV of %d for %dHz BCLK\n",
+                bclk_divs[best].div, wm8993->bclk);
+        clocking1 |= bclk_divs[best].bclk_div << WM8993_BCLK_DIV_SHIFT;
+
+        /* LRCLK is a simple fraction of BCLK */
+        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);
+
+        /* ReTune Mobile? */
+        if (wm8993->pdata.num_retune_configs) {
+                u16 eq1 = wm8993_read(codec, WM8993_EQ1);
+                struct wm8993_retune_mobile_setting *s;
+
+                best = 0;
+                best_val = abs(wm8993->pdata.retune_configs[0].rate
+                               - wm8993->fs);
+                for (i = 0; i < wm8993->pdata.num_retune_configs; i++) {
+                        cur_val = abs(wm8993->pdata.retune_configs[i].rate
+                                      - wm8993->fs);
+                        if (cur_val < best_val) {
+                                best_val = cur_val;
+                                best = i;
+                        }
+                }
+                s = &wm8993->pdata.retune_configs[best];
+
+                dev_dbg(codec->dev, "ReTune Mobile %s tuned for %dHz\n",
+                        s->name, s->rate);
+
+                /* Disable EQ while we reconfigure */
+                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_update_bits(codec, WM8993_EQ1, WM8993_EQ_ENA, eq1);
+        }
+
+        return 0;
+}
+
+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);
+
+        if (mute)
+                reg |= WM8993_DAC_MUTE;
+        else
+                reg &= ~WM8993_DAC_MUTE;
+
+        wm8993_write(codec, WM8993_DAC_CTRL, reg);
+
+        return 0;
+}
+
+static int wm8993_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 wm8993_priv *wm8993 = codec->private_data;
+        int aif1 = 0;
+        int aif2 = 0;
+
+        /* Don't need to validate anything if we're turning off TDM */
+        if (slots == 0) {
+                wm8993->tdm_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 |= WM8993_AIFADC_TDM;
+        aif2 |= WM8993_AIFDAC_TDM;
+
+        switch (rx_mask) {
+        case 3:
+                break;
+        case 0xc:
+                aif1 |= WM8993_AIFADC_TDM_CHAN;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+
+        switch (tx_mask) {
+        case 3:
+                break;
+        case 0xc:
+                aif2 |= WM8993_AIFDAC_TDM_CHAN;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+out:
+        wm8993->tdm_width = slot_width;
+        wm8993->tdm_slots = slots / 2;
+
+        snd_soc_update_bits(codec, WM8993_AUDIO_INTERFACE_1,
+                            WM8993_AIFADC_TDM | WM8993_AIFADC_TDM_CHAN, aif1);
+        snd_soc_update_bits(codec, WM8993_AUDIO_INTERFACE_2,
+                            WM8993_AIFDAC_TDM | WM8993_AIFDAC_TDM_CHAN, aif2);
+
+        return 0;
+}
+
+static struct snd_soc_dai_ops wm8993_ops = {
+        .set_sysclk = wm8993_set_sysclk,
+        .set_fmt = wm8993_set_dai_fmt,
+        .hw_params = wm8993_hw_params,
+        .digital_mute = wm8993_digital_mute,
+        .set_pll = wm8993_set_fll,
+        .set_tdm_slot = wm8993_set_tdm_slot,
+};
+
+#define WM8993_RATES SNDRV_PCM_RATE_8000_48000
+
+#define WM8993_FORMATS (SNDRV_PCM_FMTBIT_S16_LE |\
+                        SNDRV_PCM_FMTBIT_S20_3LE |\
+                        SNDRV_PCM_FMTBIT_S24_LE |\
+                        SNDRV_PCM_FMTBIT_S32_LE)
+
+struct snd_soc_dai wm8993_dai = {
+        .name = "WM8993",
+        .playback = {
+                .stream_name = "Playback",
+                .channels_min = 1,
+                .channels_max = 2,
+                .rates = WM8993_RATES,
+                .formats = WM8993_FORMATS,
+        },
+        .capture = {
+                 .stream_name = "Capture",
+                 .channels_min = 1,
+                 .channels_max = 2,
+                 .rates = WM8993_RATES,
+                 .formats = WM8993_FORMATS,
+         },
+        .ops = &wm8993_ops,
+        .symmetric_rates = 1,
+};
+EXPORT_SYMBOL_GPL(wm8993_dai);
+
+static struct snd_soc_codec *wm8993_codec;
+
+static int wm8993_probe(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec;
+        struct wm8993_priv *wm8993;
+        int ret = 0;
+
+        if (!wm8993_codec) {
+                dev_err(&pdev->dev, "I2C device not yet probed\n");
+                goto err;
+        }
+
+        socdev->card->codec = wm8993_codec;
+        codec = wm8993_codec;
+        wm8993 = codec->private_data;
+
+        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 err;
+        }
+
+        snd_soc_add_controls(codec, wm8993_snd_controls,
+                             ARRAY_SIZE(wm8993_snd_controls));
+        if (wm8993->pdata.num_retune_configs != 0) {
+                dev_dbg(codec->dev, "Using ReTune Mobile\n");
+        } else {
+                dev_dbg(codec->dev, "No ReTune Mobile, using normal EQ\n");
+                snd_soc_add_controls(codec, wm8993_eq_controls,
+                                     ARRAY_SIZE(wm8993_eq_controls));
+        }
+
+        snd_soc_dapm_new_controls(codec, wm8993_dapm_widgets,
+                                  ARRAY_SIZE(wm8993_dapm_widgets));
+        wm_hubs_add_analogue_controls(codec);
+
+        snd_soc_dapm_add_routes(codec, routes, ARRAY_SIZE(routes));
+        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;
+}
+
+static int wm8993_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_wm8993 = {
+        .probe =        wm8993_probe,
+        .remove =       wm8993_remove,
+};
+EXPORT_SYMBOL_GPL(soc_codec_dev_wm8993);
+
+static int wm8993_i2c_probe(struct i2c_client *i2c,
+                            const struct i2c_device_id *id)
+{
+        struct wm8993_priv *wm8993;
+        struct snd_soc_codec *codec;
+        unsigned int val;
+        int ret;
+
+        if (wm8993_codec) {
+                dev_err(&i2c->dev, "A WM8993 is already registered\n");
+                return -EINVAL;
+        }
+
+        wm8993 = kzalloc(sizeof(struct wm8993_priv), GFP_KERNEL);
+        if (wm8993 == NULL)
+                return -ENOMEM;
+
+        codec = &wm8993->codec;
+        if (i2c->dev.platform_data)
+                memcpy(&wm8993->pdata, i2c->dev.platform_data,
+                       sizeof(wm8993->pdata));
+
+        mutex_init(&codec->mutex);
+        INIT_LIST_HEAD(&codec->dapm_widgets);
+        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->reg_cache = wm8993->reg_cache;
+        codec->reg_cache_size = ARRAY_SIZE(wm8993->reg_cache);
+        codec->bias_level = SND_SOC_BIAS_OFF;
+        codec->set_bias_level = wm8993_set_bias_level;
+        codec->dai = &wm8993_dai;
+        codec->num_dai = 1;
+        codec->private_data = wm8993;
+
+        memcpy(wm8993->reg_cache, wm8993_reg_defaults,
+               sizeof(wm8993->reg_cache));
+
+        i2c_set_clientdata(i2c, wm8993);
+        codec->control_data = i2c;
+        wm8993_codec = codec;
+
+        codec->dev = &i2c->dev;
+
+        val = wm8993_read_hw(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;
+        }
+
+        ret = wm8993_write(codec, WM8993_SOFTWARE_RESET, 0xffff);
+        if (ret != 0)
+                goto err;
+
+        /* By default we're using the output mixers */
+        wm8993->class_w_users = 2;
+
+        /* Latch volume update bits and default ZC on */
+        snd_soc_update_bits(codec, WM8993_RIGHT_DAC_DIGITAL_VOLUME,
+                            WM8993_DAC_VU, WM8993_DAC_VU);
+        snd_soc_update_bits(codec, WM8993_RIGHT_ADC_DIGITAL_VOLUME,
+                            WM8993_ADC_VU, WM8993_ADC_VU);
+
+        /* Manualy manage the HPOUT sequencing for independent stereo
+         * control. */
+        snd_soc_update_bits(codec, WM8993_ANALOGUE_HP_0,
+                            WM8993_HPOUT1_AUTO_PU, 0);
+
+        /* 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);
+
+        ret = wm8993_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+        if (ret != 0)
+                goto err;
+
+        wm8993_dai.dev = codec->dev;
+
+        ret = snd_soc_register_dai(&wm8993_dai);
+        if (ret != 0)
+                goto err_bias;
+
+        ret = snd_soc_register_codec(codec);
+
+        return 0;
+
+err_bias:
+        wm8993_set_bias_level(codec, SND_SOC_BIAS_OFF);
+err:
+        wm8993_codec = NULL;
+        kfree(wm8993);
+        return ret;
+}
+
+static int wm8993_i2c_remove(struct i2c_client *client)
+{
+        struct wm8993_priv *wm8993 = i2c_get_clientdata(client);
+
+        snd_soc_unregister_codec(&wm8993->codec);
+        snd_soc_unregister_dai(&wm8993_dai);
+
+        wm8993_set_bias_level(&wm8993->codec, SND_SOC_BIAS_OFF);
+        kfree(wm8993);
+
+        return 0;
+}
+
+static const struct i2c_device_id wm8993_i2c_id[] = {
+        { "wm8993", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, wm8993_i2c_id);
+
+static struct i2c_driver wm8993_i2c_driver = {
+        .driver = {
+                .name = "WM8993",
+                .owner = THIS_MODULE,
+        },
+        .probe = wm8993_i2c_probe,
+        .remove = wm8993_i2c_remove,
+        .id_table = wm8993_i2c_id,
+};
+
+
+static int __init wm8993_modinit(void)
+{
+        int ret;
+
+        ret = i2c_add_driver(&wm8993_i2c_driver);
+        if (ret != 0)
+                pr_err("WM8993: Unable to register I2C driver: %d\n", ret);
+
+        return ret;
+}
+module_init(wm8993_modinit);
+
+static void __exit wm8993_exit(void)
+{
+        i2c_del_driver(&wm8993_i2c_driver);
+}
+module_exit(wm8993_exit);
+
+
+MODULE_DESCRIPTION("ASoC WM8993 driver");
+MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/codecs/wm8993.h b/sound/soc/codecs/wm8993.h
new file mode 100644
index 000000000000..30e71ca88dad
--- /dev/null
+++ b/sound/soc/codecs/wm8993.h
@@ -0,0 +1,2132 @@
+#ifndef WM8993_H
+#define WM8993_H
+
+extern struct snd_soc_dai wm8993_dai;
+extern struct snd_soc_codec_device soc_codec_dev_wm8993;
+
+#define WM8993_SYSCLK_MCLK     1
+#define WM8993_SYSCLK_FLL      2
+
+#define WM8993_FLL_MCLK  1
+#define WM8993_FLL_BCLK  2
+#define WM8993_FLL_LRCLK 3
+
+/*
+ * Register values.
+ */
+#define WM8993_SOFTWARE_RESET                   0x00
+#define WM8993_POWER_MANAGEMENT_1               0x01
+#define WM8993_POWER_MANAGEMENT_2               0x02
+#define WM8993_POWER_MANAGEMENT_3               0x03
+#define WM8993_AUDIO_INTERFACE_1                0x04
+#define WM8993_AUDIO_INTERFACE_2                0x05
+#define WM8993_CLOCKING_1                       0x06
+#define WM8993_CLOCKING_2                       0x07
+#define WM8993_AUDIO_INTERFACE_3                0x08
+#define WM8993_AUDIO_INTERFACE_4                0x09
+#define WM8993_DAC_CTRL                         0x0A
+#define WM8993_LEFT_DAC_DIGITAL_VOLUME          0x0B
+#define WM8993_RIGHT_DAC_DIGITAL_VOLUME         0x0C
+#define WM8993_DIGITAL_SIDE_TONE                0x0D
+#define WM8993_ADC_CTRL                         0x0E
+#define WM8993_LEFT_ADC_DIGITAL_VOLUME          0x0F
+#define WM8993_RIGHT_ADC_DIGITAL_VOLUME         0x10
+#define WM8993_GPIO_CTRL_1                      0x12
+#define WM8993_GPIO1                            0x13
+#define WM8993_IRQ_DEBOUNCE                     0x14
+#define WM8993_GPIOCTRL_2                       0x16
+#define WM8993_GPIO_POL                         0x17
+#define WM8993_LEFT_LINE_INPUT_1_2_VOLUME       0x18
+#define WM8993_LEFT_LINE_INPUT_3_4_VOLUME       0x19
+#define WM8993_RIGHT_LINE_INPUT_1_2_VOLUME      0x1A
+#define WM8993_RIGHT_LINE_INPUT_3_4_VOLUME      0x1B
+#define WM8993_LEFT_OUTPUT_VOLUME               0x1C
+#define WM8993_RIGHT_OUTPUT_VOLUME              0x1D
+#define WM8993_LINE_OUTPUTS_VOLUME              0x1E
+#define WM8993_HPOUT2_VOLUME                    0x1F
+#define WM8993_LEFT_OPGA_VOLUME                 0x20
+#define WM8993_RIGHT_OPGA_VOLUME                0x21
+#define WM8993_SPKMIXL_ATTENUATION              0x22
+#define WM8993_SPKMIXR_ATTENUATION              0x23
+#define WM8993_SPKOUT_MIXERS                    0x24
+#define WM8993_SPKOUT_BOOST                     0x25
+#define WM8993_SPEAKER_VOLUME_LEFT              0x26
+#define WM8993_SPEAKER_VOLUME_RIGHT             0x27
+#define WM8993_INPUT_MIXER2                     0x28
+#define WM8993_INPUT_MIXER3                     0x29
+#define WM8993_INPUT_MIXER4                     0x2A
+#define WM8993_INPUT_MIXER5                     0x2B
+#define WM8993_INPUT_MIXER6                     0x2C
+#define WM8993_OUTPUT_MIXER1                    0x2D
+#define WM8993_OUTPUT_MIXER2                    0x2E
+#define WM8993_OUTPUT_MIXER3                    0x2F
+#define WM8993_OUTPUT_MIXER4                    0x30
+#define WM8993_OUTPUT_MIXER5                    0x31
+#define WM8993_OUTPUT_MIXER6                    0x32
+#define WM8993_HPOUT2_MIXER                     0x33
+#define WM8993_LINE_MIXER1                      0x34
+#define WM8993_LINE_MIXER2                      0x35
+#define WM8993_SPEAKER_MIXER                    0x36
+#define WM8993_ADDITIONAL_CONTROL               0x37
+#define WM8993_ANTIPOP1                         0x38
+#define WM8993_ANTIPOP2                         0x39
+#define WM8993_MICBIAS                          0x3A
+#define WM8993_FLL_CONTROL_1                    0x3C
+#define WM8993_FLL_CONTROL_2                    0x3D
+#define WM8993_FLL_CONTROL_3                    0x3E
+#define WM8993_FLL_CONTROL_4                    0x3F
+#define WM8993_FLL_CONTROL_5                    0x40
+#define WM8993_CLOCKING_3                       0x41
+#define WM8993_CLOCKING_4                       0x42
+#define WM8993_MW_SLAVE_CONTROL                 0x43
+#define WM8993_BUS_CONTROL_1                    0x45
+#define WM8993_WRITE_SEQUENCER_0                0x46
+#define WM8993_WRITE_SEQUENCER_1                0x47
+#define WM8993_WRITE_SEQUENCER_2                0x48
+#define WM8993_WRITE_SEQUENCER_3                0x49
+#define WM8993_WRITE_SEQUENCER_4                0x4A
+#define WM8993_WRITE_SEQUENCER_5                0x4B
+#define WM8993_CHARGE_PUMP_1                    0x4C
+#define WM8993_CLASS_W_0                        0x51
+#define WM8993_DC_SERVO_0                       0x54
+#define WM8993_DC_SERVO_1                       0x55
+#define WM8993_DC_SERVO_3                       0x57
+#define WM8993_DC_SERVO_READBACK_0              0x58
+#define WM8993_DC_SERVO_READBACK_1              0x59
+#define WM8993_DC_SERVO_READBACK_2              0x5A
+#define WM8993_ANALOGUE_HP_0                    0x60
+#define WM8993_EQ1                              0x62
+#define WM8993_EQ2                              0x63
+#define WM8993_EQ3                              0x64
+#define WM8993_EQ4                              0x65
+#define WM8993_EQ5                              0x66
+#define WM8993_EQ6                              0x67
+#define WM8993_EQ7                              0x68
+#define WM8993_EQ8                              0x69
+#define WM8993_EQ9                              0x6A
+#define WM8993_EQ10                             0x6B
+#define WM8993_EQ11                             0x6C
+#define WM8993_EQ12                             0x6D
+#define WM8993_EQ13                             0x6E
+#define WM8993_EQ14                             0x6F
+#define WM8993_EQ15                             0x70
+#define WM8993_EQ16                             0x71
+#define WM8993_EQ17                             0x72
+#define WM8993_EQ18                             0x73
+#define WM8993_EQ19                             0x74
+#define WM8993_EQ20                             0x75
+#define WM8993_EQ21                             0x76
+#define WM8993_EQ22                             0x77
+#define WM8993_EQ23                             0x78
+#define WM8993_EQ24                             0x79
+#define WM8993_DIGITAL_PULLS                    0x7A
+#define WM8993_DRC_CONTROL_1                    0x7B
+#define WM8993_DRC_CONTROL_2                    0x7C
+#define WM8993_DRC_CONTROL_3                    0x7D
+#define WM8993_DRC_CONTROL_4                    0x7E
+
+#define WM8993_REGISTER_COUNT                   0x7F
+#define WM8993_MAX_REGISTER                     0x7E
+
+/*
+ * Field Definitions.
+ */
+
+/*
+ * R0 (0x00) - Software Reset
+ */
+#define WM8993_SW_RESET_MASK                    0xFFFF  /* SW_RESET - [15:0] */
+#define WM8993_SW_RESET_SHIFT                        0  /* SW_RESET - [15:0] */
+#define WM8993_SW_RESET_WIDTH                       16  /* SW_RESET - [15:0] */
+
+/*
+ * R1 (0x01) - Power Management (1)
+ */
+#define WM8993_SPKOUTR_ENA                      0x2000  /* SPKOUTR_ENA */
+#define WM8993_SPKOUTR_ENA_MASK                 0x2000  /* SPKOUTR_ENA */
+#define WM8993_SPKOUTR_ENA_SHIFT                    13  /* SPKOUTR_ENA */
+#define WM8993_SPKOUTR_ENA_WIDTH                     1  /* SPKOUTR_ENA */
+#define WM8993_SPKOUTL_ENA                      0x1000  /* SPKOUTL_ENA */
+#define WM8993_SPKOUTL_ENA_MASK                 0x1000  /* SPKOUTL_ENA */
+#define WM8993_SPKOUTL_ENA_SHIFT                    12  /* SPKOUTL_ENA */
+#define WM8993_SPKOUTL_ENA_WIDTH                     1  /* SPKOUTL_ENA */
+#define WM8993_HPOUT2_ENA                       0x0800  /* HPOUT2_ENA */
+#define WM8993_HPOUT2_ENA_MASK                  0x0800  /* HPOUT2_ENA */
+#define WM8993_HPOUT2_ENA_SHIFT                     11  /* HPOUT2_ENA */
+#define WM8993_HPOUT2_ENA_WIDTH                      1  /* HPOUT2_ENA */
+#define WM8993_HPOUT1L_ENA                      0x0200  /* HPOUT1L_ENA */
+#define WM8993_HPOUT1L_ENA_MASK                 0x0200  /* HPOUT1L_ENA */
+#define WM8993_HPOUT1L_ENA_SHIFT                     9  /* HPOUT1L_ENA */
+#define WM8993_HPOUT1L_ENA_WIDTH                     1  /* HPOUT1L_ENA */
+#define WM8993_HPOUT1R_ENA                      0x0100  /* HPOUT1R_ENA */
+#define WM8993_HPOUT1R_ENA_MASK                 0x0100  /* HPOUT1R_ENA */
+#define WM8993_HPOUT1R_ENA_SHIFT                     8  /* HPOUT1R_ENA */
+#define WM8993_HPOUT1R_ENA_WIDTH                     1  /* HPOUT1R_ENA */
+#define WM8993_MICB2_ENA                        0x0020  /* MICB2_ENA */
+#define WM8993_MICB2_ENA_MASK                   0x0020  /* MICB2_ENA */
+#define WM8993_MICB2_ENA_SHIFT                       5  /* MICB2_ENA */
+#define WM8993_MICB2_ENA_WIDTH                       1  /* MICB2_ENA */
+#define WM8993_MICB1_ENA                        0x0010  /* MICB1_ENA */
+#define WM8993_MICB1_ENA_MASK                   0x0010  /* MICB1_ENA */
+#define WM8993_MICB1_ENA_SHIFT                       4  /* MICB1_ENA */
+#define WM8993_MICB1_ENA_WIDTH                       1  /* MICB1_ENA */
+#define WM8993_VMID_SEL_MASK                    0x0006  /* VMID_SEL - [2:1] */
+#define WM8993_VMID_SEL_SHIFT                        1  /* VMID_SEL - [2:1] */
+#define WM8993_VMID_SEL_WIDTH                        2  /* VMID_SEL - [2:1] */
+#define WM8993_BIAS_ENA                         0x0001  /* BIAS_ENA */
+#define WM8993_BIAS_ENA_MASK                    0x0001  /* BIAS_ENA */
+#define WM8993_BIAS_ENA_SHIFT                        0  /* BIAS_ENA */
+#define WM8993_BIAS_ENA_WIDTH                        1  /* BIAS_ENA */
+
+/*
+ * R2 (0x02) - Power Management (2)
+ */
+#define WM8993_TSHUT_ENA                        0x4000  /* TSHUT_ENA */
+#define WM8993_TSHUT_ENA_MASK                   0x4000  /* TSHUT_ENA */
+#define WM8993_TSHUT_ENA_SHIFT                      14  /* TSHUT_ENA */
+#define WM8993_TSHUT_ENA_WIDTH                       1  /* TSHUT_ENA */
+#define WM8993_TSHUT_OPDIS                      0x2000  /* TSHUT_OPDIS */
+#define WM8993_TSHUT_OPDIS_MASK                 0x2000  /* TSHUT_OPDIS */
+#define WM8993_TSHUT_OPDIS_SHIFT                    13  /* TSHUT_OPDIS */
+#define WM8993_TSHUT_OPDIS_WIDTH                     1  /* TSHUT_OPDIS */
+#define WM8993_OPCLK_ENA                        0x0800  /* OPCLK_ENA */
+#define WM8993_OPCLK_ENA_MASK                   0x0800  /* OPCLK_ENA */
+#define WM8993_OPCLK_ENA_SHIFT                      11  /* OPCLK_ENA */
+#define WM8993_OPCLK_ENA_WIDTH                       1  /* OPCLK_ENA */
+#define WM8993_MIXINL_ENA                       0x0200  /* MIXINL_ENA */
+#define WM8993_MIXINL_ENA_MASK                  0x0200  /* MIXINL_ENA */
+#define WM8993_MIXINL_ENA_SHIFT                      9  /* MIXINL_ENA */
+#define WM8993_MIXINL_ENA_WIDTH                      1  /* MIXINL_ENA */
+#define WM8993_MIXINR_ENA                       0x0100  /* MIXINR_ENA */
+#define WM8993_MIXINR_ENA_MASK                  0x0100  /* MIXINR_ENA */
+#define WM8993_MIXINR_ENA_SHIFT                      8  /* MIXINR_ENA */
+#define WM8993_MIXINR_ENA_WIDTH                      1  /* MIXINR_ENA */
+#define WM8993_IN2L_ENA                         0x0080  /* IN2L_ENA */
+#define WM8993_IN2L_ENA_MASK                    0x0080  /* IN2L_ENA */
+#define WM8993_IN2L_ENA_SHIFT                        7  /* IN2L_ENA */
+#define WM8993_IN2L_ENA_WIDTH                        1  /* IN2L_ENA */
+#define WM8993_IN1L_ENA                         0x0040  /* IN1L_ENA */
+#define WM8993_IN1L_ENA_MASK                    0x0040  /* IN1L_ENA */
+#define WM8993_IN1L_ENA_SHIFT                        6  /* IN1L_ENA */
+#define WM8993_IN1L_ENA_WIDTH                        1  /* IN1L_ENA */
+#define WM8993_IN2R_ENA                         0x0020  /* IN2R_ENA */
+#define WM8993_IN2R_ENA_MASK                    0x0020  /* IN2R_ENA */
+#define WM8993_IN2R_ENA_SHIFT                        5  /* IN2R_ENA */
+#define WM8993_IN2R_ENA_WIDTH                        1  /* IN2R_ENA */
+#define WM8993_IN1R_ENA                         0x0010  /* IN1R_ENA */
+#define WM8993_IN1R_ENA_MASK                    0x0010  /* IN1R_ENA */
+#define WM8993_IN1R_ENA_SHIFT                        4  /* IN1R_ENA */
+#define WM8993_IN1R_ENA_WIDTH                        1  /* IN1R_ENA */
+#define WM8993_ADCL_ENA                         0x0002  /* ADCL_ENA */
+#define WM8993_ADCL_ENA_MASK                    0x0002  /* ADCL_ENA */
+#define WM8993_ADCL_ENA_SHIFT                        1  /* ADCL_ENA */
+#define WM8993_ADCL_ENA_WIDTH                        1  /* ADCL_ENA */
+#define WM8993_ADCR_ENA                         0x0001  /* ADCR_ENA */
+#define WM8993_ADCR_ENA_MASK                    0x0001  /* ADCR_ENA */
+#define WM8993_ADCR_ENA_SHIFT                        0  /* ADCR_ENA */
+#define WM8993_ADCR_ENA_WIDTH                        1  /* ADCR_ENA */
+
+/*
+ * R3 (0x03) - Power Management (3)
+ */
+#define WM8993_LINEOUT1N_ENA                    0x2000  /* LINEOUT1N_ENA */
+#define WM8993_LINEOUT1N_ENA_MASK               0x2000  /* LINEOUT1N_ENA */
+#define WM8993_LINEOUT1N_ENA_SHIFT                  13  /* LINEOUT1N_ENA */
+#define WM8993_LINEOUT1N_ENA_WIDTH                   1  /* LINEOUT1N_ENA */
+#define WM8993_LINEOUT1P_ENA                    0x1000  /* LINEOUT1P_ENA */
+#define WM8993_LINEOUT1P_ENA_MASK               0x1000  /* LINEOUT1P_ENA */
+#define WM8993_LINEOUT1P_ENA_SHIFT                  12  /* LINEOUT1P_ENA */
+#define WM8993_LINEOUT1P_ENA_WIDTH                   1  /* LINEOUT1P_ENA */
+#define WM8993_LINEOUT2N_ENA                    0x0800  /* LINEOUT2N_ENA */
+#define WM8993_LINEOUT2N_ENA_MASK               0x0800  /* LINEOUT2N_ENA */
+#define WM8993_LINEOUT2N_ENA_SHIFT                  11  /* LINEOUT2N_ENA */
+#define WM8993_LINEOUT2N_ENA_WIDTH                   1  /* LINEOUT2N_ENA */
+#define WM8993_LINEOUT2P_ENA                    0x0400  /* LINEOUT2P_ENA */
+#define WM8993_LINEOUT2P_ENA_MASK               0x0400  /* LINEOUT2P_ENA */
+#define WM8993_LINEOUT2P_ENA_SHIFT                  10  /* LINEOUT2P_ENA */
+#define WM8993_LINEOUT2P_ENA_WIDTH                   1  /* LINEOUT2P_ENA */
+#define WM8993_SPKRVOL_ENA                      0x0200  /* SPKRVOL_ENA */
+#define WM8993_SPKRVOL_ENA_MASK                 0x0200  /* SPKRVOL_ENA */
+#define WM8993_SPKRVOL_ENA_SHIFT                     9  /* SPKRVOL_ENA */
+#define WM8993_SPKRVOL_ENA_WIDTH                     1  /* SPKRVOL_ENA */
+#define WM8993_SPKLVOL_ENA                      0x0100  /* SPKLVOL_ENA */
+#define WM8993_SPKLVOL_ENA_MASK                 0x0100  /* SPKLVOL_ENA */
+#define WM8993_SPKLVOL_ENA_SHIFT                     8  /* SPKLVOL_ENA */
+#define WM8993_SPKLVOL_ENA_WIDTH                     1  /* SPKLVOL_ENA */
+#define WM8993_MIXOUTLVOL_ENA                   0x0080  /* MIXOUTLVOL_ENA */
+#define WM8993_MIXOUTLVOL_ENA_MASK              0x0080  /* MIXOUTLVOL_ENA */
+#define WM8993_MIXOUTLVOL_ENA_SHIFT                  7  /* MIXOUTLVOL_ENA */
+#define WM8993_MIXOUTLVOL_ENA_WIDTH                  1  /* MIXOUTLVOL_ENA */
+#define WM8993_MIXOUTRVOL_ENA                   0x0040  /* MIXOUTRVOL_ENA */
+#define WM8993_MIXOUTRVOL_ENA_MASK              0x0040  /* MIXOUTRVOL_ENA */
+#define WM8993_MIXOUTRVOL_ENA_SHIFT                  6  /* MIXOUTRVOL_ENA */
+#define WM8993_MIXOUTRVOL_ENA_WIDTH                  1  /* MIXOUTRVOL_ENA */
+#define WM8993_MIXOUTL_ENA                      0x0020  /* MIXOUTL_ENA */
+#define WM8993_MIXOUTL_ENA_MASK                 0x0020  /* MIXOUTL_ENA */
+#define WM8993_MIXOUTL_ENA_SHIFT                     5  /* MIXOUTL_ENA */
+#define WM8993_MIXOUTL_ENA_WIDTH                     1  /* MIXOUTL_ENA */
+#define WM8993_MIXOUTR_ENA                      0x0010  /* MIXOUTR_ENA */
+#define WM8993_MIXOUTR_ENA_MASK                 0x0010  /* MIXOUTR_ENA */
+#define WM8993_MIXOUTR_ENA_SHIFT                     4  /* MIXOUTR_ENA */
+#define WM8993_MIXOUTR_ENA_WIDTH                     1  /* MIXOUTR_ENA */
+#define WM8993_DACL_ENA                         0x0002  /* DACL_ENA */
+#define WM8993_DACL_ENA_MASK                    0x0002  /* DACL_ENA */
+#define WM8993_DACL_ENA_SHIFT                        1  /* DACL_ENA */
+#define WM8993_DACL_ENA_WIDTH                        1  /* DACL_ENA */
+#define WM8993_DACR_ENA                         0x0001  /* DACR_ENA */
+#define WM8993_DACR_ENA_MASK                    0x0001  /* DACR_ENA */
+#define WM8993_DACR_ENA_SHIFT                        0  /* DACR_ENA */
+#define WM8993_DACR_ENA_WIDTH                        1  /* DACR_ENA */
+
+/*
+ * R4 (0x04) - Audio Interface (1)
+ */
+#define WM8993_AIFADCL_SRC                      0x8000  /* AIFADCL_SRC */
+#define WM8993_AIFADCL_SRC_MASK                 0x8000  /* AIFADCL_SRC */
+#define WM8993_AIFADCL_SRC_SHIFT                    15  /* AIFADCL_SRC */
+#define WM8993_AIFADCL_SRC_WIDTH                     1  /* AIFADCL_SRC */
+#define WM8993_AIFADCR_SRC                      0x4000  /* AIFADCR_SRC */
+#define WM8993_AIFADCR_SRC_MASK                 0x4000  /* AIFADCR_SRC */
+#define WM8993_AIFADCR_SRC_SHIFT                    14  /* AIFADCR_SRC */
+#define WM8993_AIFADCR_SRC_WIDTH                     1  /* AIFADCR_SRC */
+#define WM8993_AIFADC_TDM                       0x2000  /* AIFADC_TDM */
+#define WM8993_AIFADC_TDM_MASK                  0x2000  /* AIFADC_TDM */
+#define WM8993_AIFADC_TDM_SHIFT                     13  /* AIFADC_TDM */
+#define WM8993_AIFADC_TDM_WIDTH                      1  /* AIFADC_TDM */
+#define WM8993_AIFADC_TDM_CHAN                  0x1000  /* AIFADC_TDM_CHAN */
+#define WM8993_AIFADC_TDM_CHAN_MASK             0x1000  /* AIFADC_TDM_CHAN */
+#define WM8993_AIFADC_TDM_CHAN_SHIFT                12  /* AIFADC_TDM_CHAN */
+#define WM8993_AIFADC_TDM_CHAN_WIDTH                 1  /* AIFADC_TDM_CHAN */
+#define WM8993_BCLK_DIR                         0x0200  /* BCLK_DIR */
+#define WM8993_BCLK_DIR_MASK                    0x0200  /* BCLK_DIR */
+#define WM8993_BCLK_DIR_SHIFT                        9  /* BCLK_DIR */
+#define WM8993_BCLK_DIR_WIDTH                        1  /* BCLK_DIR */
+#define WM8993_AIF_BCLK_INV                     0x0100  /* AIF_BCLK_INV */
+#define WM8993_AIF_BCLK_INV_MASK                0x0100  /* AIF_BCLK_INV */
+#define WM8993_AIF_BCLK_INV_SHIFT                    8  /* AIF_BCLK_INV */
+#define WM8993_AIF_BCLK_INV_WIDTH                    1  /* AIF_BCLK_INV */
+#define WM8993_AIF_LRCLK_INV                    0x0080  /* AIF_LRCLK_INV */
+#define WM8993_AIF_LRCLK_INV_MASK               0x0080  /* AIF_LRCLK_INV */
+#define WM8993_AIF_LRCLK_INV_SHIFT                   7  /* AIF_LRCLK_INV */
+#define WM8993_AIF_LRCLK_INV_WIDTH                   1  /* AIF_LRCLK_INV */
+#define WM8993_AIF_WL_MASK                      0x0060  /* AIF_WL - [6:5] */
+#define WM8993_AIF_WL_SHIFT                          5  /* AIF_WL - [6:5] */
+#define WM8993_AIF_WL_WIDTH                          2  /* AIF_WL - [6:5] */
+#define WM8993_AIF_FMT_MASK                     0x0018  /* AIF_FMT - [4:3] */
+#define WM8993_AIF_FMT_SHIFT                         3  /* AIF_FMT - [4:3] */
+#define WM8993_AIF_FMT_WIDTH                         2  /* AIF_FMT - [4:3] */
+
+/*
+ * R5 (0x05) - Audio Interface (2)
+ */
+#define WM8993_AIFDACL_SRC                      0x8000  /* AIFDACL_SRC */
+#define WM8993_AIFDACL_SRC_MASK                 0x8000  /* AIFDACL_SRC */
+#define WM8993_AIFDACL_SRC_SHIFT                    15  /* AIFDACL_SRC */
+#define WM8993_AIFDACL_SRC_WIDTH                     1  /* AIFDACL_SRC */
+#define WM8993_AIFDACR_SRC                      0x4000  /* AIFDACR_SRC */
+#define WM8993_AIFDACR_SRC_MASK                 0x4000  /* AIFDACR_SRC */
+#define WM8993_AIFDACR_SRC_SHIFT                    14  /* AIFDACR_SRC */
+#define WM8993_AIFDACR_SRC_WIDTH                     1  /* AIFDACR_SRC */
+#define WM8993_AIFDAC_TDM                       0x2000  /* AIFDAC_TDM */
+#define WM8993_AIFDAC_TDM_MASK                  0x2000  /* AIFDAC_TDM */
+#define WM8993_AIFDAC_TDM_SHIFT                     13  /* AIFDAC_TDM */
+#define WM8993_AIFDAC_TDM_WIDTH                      1  /* AIFDAC_TDM */
+#define WM8993_AIFDAC_TDM_CHAN                  0x1000  /* AIFDAC_TDM_CHAN */
+#define WM8993_AIFDAC_TDM_CHAN_MASK             0x1000  /* AIFDAC_TDM_CHAN */
+#define WM8993_AIFDAC_TDM_CHAN_SHIFT                12  /* AIFDAC_TDM_CHAN */
+#define WM8993_AIFDAC_TDM_CHAN_WIDTH                 1  /* AIFDAC_TDM_CHAN */
+#define WM8993_DAC_BOOST_MASK                   0x0C00  /* DAC_BOOST - [11:10] */
+#define WM8993_DAC_BOOST_SHIFT                      10  /* DAC_BOOST - [11:10] */
+#define WM8993_DAC_BOOST_WIDTH                       2  /* DAC_BOOST - [11:10] */
+#define WM8993_DAC_COMP                         0x0010  /* DAC_COMP */
+#define WM8993_DAC_COMP_MASK                    0x0010  /* DAC_COMP */
+#define WM8993_DAC_COMP_SHIFT                        4  /* DAC_COMP */
+#define WM8993_DAC_COMP_WIDTH                        1  /* DAC_COMP */
+#define WM8993_DAC_COMPMODE                     0x0008  /* DAC_COMPMODE */
+#define WM8993_DAC_COMPMODE_MASK                0x0008  /* DAC_COMPMODE */
+#define WM8993_DAC_COMPMODE_SHIFT                    3  /* DAC_COMPMODE */
+#define WM8993_DAC_COMPMODE_WIDTH                    1  /* DAC_COMPMODE */
+#define WM8993_ADC_COMP                         0x0004  /* ADC_COMP */
+#define WM8993_ADC_COMP_MASK                    0x0004  /* ADC_COMP */
+#define WM8993_ADC_COMP_SHIFT                        2  /* ADC_COMP */
+#define WM8993_ADC_COMP_WIDTH                        1  /* ADC_COMP */
+#define WM8993_ADC_COMPMODE                     0x0002  /* ADC_COMPMODE */
+#define WM8993_ADC_COMPMODE_MASK                0x0002  /* ADC_COMPMODE */
+#define WM8993_ADC_COMPMODE_SHIFT                    1  /* ADC_COMPMODE */
+#define WM8993_ADC_COMPMODE_WIDTH                    1  /* ADC_COMPMODE */
+#define WM8993_LOOPBACK                         0x0001  /* LOOPBACK */
+#define WM8993_LOOPBACK_MASK                    0x0001  /* LOOPBACK */
+#define WM8993_LOOPBACK_SHIFT                        0  /* LOOPBACK */
+#define WM8993_LOOPBACK_WIDTH                        1  /* LOOPBACK */
+
+/*
+ * R6 (0x06) - Clocking 1
+ */
+#define WM8993_TOCLK_RATE                       0x8000  /* TOCLK_RATE */
+#define WM8993_TOCLK_RATE_MASK                  0x8000  /* TOCLK_RATE */
+#define WM8993_TOCLK_RATE_SHIFT                     15  /* TOCLK_RATE */
+#define WM8993_TOCLK_RATE_WIDTH                      1  /* TOCLK_RATE */
+#define WM8993_TOCLK_ENA                        0x4000  /* TOCLK_ENA */
+#define WM8993_TOCLK_ENA_MASK                   0x4000  /* TOCLK_ENA */
+#define WM8993_TOCLK_ENA_SHIFT                      14  /* TOCLK_ENA */
+#define WM8993_TOCLK_ENA_WIDTH                       1  /* TOCLK_ENA */
+#define WM8993_OPCLK_DIV_MASK                   0x1E00  /* OPCLK_DIV - [12:9] */
+#define WM8993_OPCLK_DIV_SHIFT                       9  /* OPCLK_DIV - [12:9] */
+#define WM8993_OPCLK_DIV_WIDTH                       4  /* OPCLK_DIV - [12:9] */
+#define WM8993_DCLK_DIV_MASK                    0x01C0  /* DCLK_DIV - [8:6] */
+#define WM8993_DCLK_DIV_SHIFT                        6  /* DCLK_DIV - [8:6] */
+#define WM8993_DCLK_DIV_WIDTH                        3  /* DCLK_DIV - [8:6] */
+#define WM8993_BCLK_DIV_MASK                    0x001E  /* BCLK_DIV - [4:1] */
+#define WM8993_BCLK_DIV_SHIFT                        1  /* BCLK_DIV - [4:1] */
+#define WM8993_BCLK_DIV_WIDTH                        4  /* BCLK_DIV - [4:1] */
+
+/*
+ * R7 (0x07) - Clocking 2
+ */
+#define WM8993_MCLK_SRC                         0x8000  /* MCLK_SRC */
+#define WM8993_MCLK_SRC_MASK                    0x8000  /* MCLK_SRC */
+#define WM8993_MCLK_SRC_SHIFT                       15  /* MCLK_SRC */
+#define WM8993_MCLK_SRC_WIDTH                        1  /* MCLK_SRC */
+#define WM8993_SYSCLK_SRC                       0x4000  /* SYSCLK_SRC */
+#define WM8993_SYSCLK_SRC_MASK                  0x4000  /* SYSCLK_SRC */
+#define WM8993_SYSCLK_SRC_SHIFT                     14  /* SYSCLK_SRC */
+#define WM8993_SYSCLK_SRC_WIDTH                      1  /* SYSCLK_SRC */
+#define WM8993_MCLK_DIV                         0x1000  /* MCLK_DIV */
+#define WM8993_MCLK_DIV_MASK                    0x1000  /* MCLK_DIV */
+#define WM8993_MCLK_DIV_SHIFT                       12  /* MCLK_DIV */
+#define WM8993_MCLK_DIV_WIDTH                        1  /* MCLK_DIV */
+#define WM8993_MCLK_INV                         0x0400  /* MCLK_INV */
+#define WM8993_MCLK_INV_MASK                    0x0400  /* MCLK_INV */
+#define WM8993_MCLK_INV_SHIFT                       10  /* MCLK_INV */
+#define WM8993_MCLK_INV_WIDTH                        1  /* MCLK_INV */
+#define WM8993_ADC_DIV_MASK                     0x00E0  /* ADC_DIV - [7:5] */
+#define WM8993_ADC_DIV_SHIFT                         5  /* ADC_DIV - [7:5] */
+#define WM8993_ADC_DIV_WIDTH                         3  /* ADC_DIV - [7:5] */
+#define WM8993_DAC_DIV_MASK                     0x001C  /* DAC_DIV - [4:2] */
+#define WM8993_DAC_DIV_SHIFT                         2  /* DAC_DIV - [4:2] */
+#define WM8993_DAC_DIV_WIDTH                         3  /* DAC_DIV - [4:2] */
+
+/*
+ * R8 (0x08) - Audio Interface (3)
+ */
+#define WM8993_AIF_MSTR1                        0x8000  /* AIF_MSTR1 */
+#define WM8993_AIF_MSTR1_MASK                   0x8000  /* AIF_MSTR1 */
+#define WM8993_AIF_MSTR1_SHIFT                      15  /* AIF_MSTR1 */
+#define WM8993_AIF_MSTR1_WIDTH                       1  /* AIF_MSTR1 */
+
+/*
+ * R9 (0x09) - Audio Interface (4)
+ */
+#define WM8993_AIF_TRIS                         0x2000  /* AIF_TRIS */
+#define WM8993_AIF_TRIS_MASK                    0x2000  /* AIF_TRIS */
+#define WM8993_AIF_TRIS_SHIFT                       13  /* AIF_TRIS */
+#define WM8993_AIF_TRIS_WIDTH                        1  /* AIF_TRIS */
+#define WM8993_LRCLK_DIR                        0x0800  /* LRCLK_DIR */
+#define WM8993_LRCLK_DIR_MASK                   0x0800  /* LRCLK_DIR */
+#define WM8993_LRCLK_DIR_SHIFT                      11  /* LRCLK_DIR */
+#define WM8993_LRCLK_DIR_WIDTH                       1  /* LRCLK_DIR */
+#define WM8993_LRCLK_RATE_MASK                  0x07FF  /* LRCLK_RATE - [10:0] */
+#define WM8993_LRCLK_RATE_SHIFT                      0  /* LRCLK_RATE - [10:0] */
+#define WM8993_LRCLK_RATE_WIDTH                     11  /* LRCLK_RATE - [10:0] */
+
+/*
+ * R10 (0x0A) - DAC CTRL
+ */
+#define WM8993_DAC_OSR128                       0x2000  /* DAC_OSR128 */
+#define WM8993_DAC_OSR128_MASK                  0x2000  /* DAC_OSR128 */
+#define WM8993_DAC_OSR128_SHIFT                     13  /* DAC_OSR128 */
+#define WM8993_DAC_OSR128_WIDTH                      1  /* DAC_OSR128 */
+#define WM8993_DAC_MONO                         0x0200  /* DAC_MONO */
+#define WM8993_DAC_MONO_MASK                    0x0200  /* DAC_MONO */
+#define WM8993_DAC_MONO_SHIFT                        9  /* DAC_MONO */
+#define WM8993_DAC_MONO_WIDTH                        1  /* DAC_MONO */
+#define WM8993_DAC_SB_FILT                      0x0100  /* DAC_SB_FILT */
+#define WM8993_DAC_SB_FILT_MASK                 0x0100  /* DAC_SB_FILT */
+#define WM8993_DAC_SB_FILT_SHIFT                     8  /* DAC_SB_FILT */
+#define WM8993_DAC_SB_FILT_WIDTH                     1  /* DAC_SB_FILT */
+#define WM8993_DAC_MUTERATE                     0x0080  /* DAC_MUTERATE */
+#define WM8993_DAC_MUTERATE_MASK                0x0080  /* DAC_MUTERATE */
+#define WM8993_DAC_MUTERATE_SHIFT                    7  /* DAC_MUTERATE */
+#define WM8993_DAC_MUTERATE_WIDTH                    1  /* DAC_MUTERATE */
+#define WM8993_DAC_UNMUTE_RAMP                  0x0040  /* DAC_UNMUTE_RAMP */
+#define WM8993_DAC_UNMUTE_RAMP_MASK             0x0040  /* DAC_UNMUTE_RAMP */
+#define WM8993_DAC_UNMUTE_RAMP_SHIFT                 6  /* DAC_UNMUTE_RAMP */
+#define WM8993_DAC_UNMUTE_RAMP_WIDTH                 1  /* DAC_UNMUTE_RAMP */
+#define WM8993_DEEMPH_MASK                      0x0030  /* DEEMPH - [5:4] */
+#define WM8993_DEEMPH_SHIFT                          4  /* DEEMPH - [5:4] */
+#define WM8993_DEEMPH_WIDTH                          2  /* DEEMPH - [5:4] */
+#define WM8993_DAC_MUTE                         0x0004  /* DAC_MUTE */
+#define WM8993_DAC_MUTE_MASK                    0x0004  /* DAC_MUTE */
+#define WM8993_DAC_MUTE_SHIFT                        2  /* DAC_MUTE */
+#define WM8993_DAC_MUTE_WIDTH                        1  /* DAC_MUTE */
+#define WM8993_DACL_DATINV                      0x0002  /* DACL_DATINV */
+#define WM8993_DACL_DATINV_MASK                 0x0002  /* DACL_DATINV */
+#define WM8993_DACL_DATINV_SHIFT                     1  /* DACL_DATINV */
+#define WM8993_DACL_DATINV_WIDTH                     1  /* DACL_DATINV */
+#define WM8993_DACR_DATINV                      0x0001  /* DACR_DATINV */
+#define WM8993_DACR_DATINV_MASK                 0x0001  /* DACR_DATINV */
+#define WM8993_DACR_DATINV_SHIFT                     0  /* DACR_DATINV */
+#define WM8993_DACR_DATINV_WIDTH                     1  /* DACR_DATINV */
+
+/*
+ * R11 (0x0B) - Left DAC Digital Volume
+ */
+#define WM8993_DAC_VU                           0x0100  /* DAC_VU */
+#define WM8993_DAC_VU_MASK                      0x0100  /* DAC_VU */
+#define WM8993_DAC_VU_SHIFT                          8  /* DAC_VU */
+#define WM8993_DAC_VU_WIDTH                          1  /* DAC_VU */
+#define WM8993_DACL_VOL_MASK                    0x00FF  /* DACL_VOL - [7:0] */
+#define WM8993_DACL_VOL_SHIFT                        0  /* DACL_VOL - [7:0] */
+#define WM8993_DACL_VOL_WIDTH                        8  /* DACL_VOL - [7:0] */
+
+/*
+ * R12 (0x0C) - Right DAC Digital Volume
+ */
+#define WM8993_DAC_VU                           0x0100  /* DAC_VU */
+#define WM8993_DAC_VU_MASK                      0x0100  /* DAC_VU */
+#define WM8993_DAC_VU_SHIFT                          8  /* DAC_VU */
+#define WM8993_DAC_VU_WIDTH                          1  /* DAC_VU */
+#define WM8993_DACR_VOL_MASK                    0x00FF  /* DACR_VOL - [7:0] */
+#define WM8993_DACR_VOL_SHIFT                        0  /* DACR_VOL - [7:0] */
+#define WM8993_DACR_VOL_WIDTH                        8  /* DACR_VOL - [7:0] */
+
+/*
+ * R13 (0x0D) - Digital Side Tone
+ */
+#define WM8993_ADCL_DAC_SVOL_MASK               0x1E00  /* ADCL_DAC_SVOL - [12:9] */
+#define WM8993_ADCL_DAC_SVOL_SHIFT                   9  /* ADCL_DAC_SVOL - [12:9] */
+#define WM8993_ADCL_DAC_SVOL_WIDTH                   4  /* ADCL_DAC_SVOL - [12:9] */
+#define WM8993_ADCR_DAC_SVOL_MASK               0x01E0  /* ADCR_DAC_SVOL - [8:5] */
+#define WM8993_ADCR_DAC_SVOL_SHIFT                   5  /* ADCR_DAC_SVOL - [8:5] */
+#define WM8993_ADCR_DAC_SVOL_WIDTH                   4  /* ADCR_DAC_SVOL - [8:5] */
+#define WM8993_ADC_TO_DACL_MASK                 0x000C  /* ADC_TO_DACL - [3:2] */
+#define WM8993_ADC_TO_DACL_SHIFT                     2  /* ADC_TO_DACL - [3:2] */
+#define WM8993_ADC_TO_DACL_WIDTH                     2  /* ADC_TO_DACL - [3:2] */
+#define WM8993_ADC_TO_DACR_MASK                 0x0003  /* ADC_TO_DACR - [1:0] */
+#define WM8993_ADC_TO_DACR_SHIFT                     0  /* ADC_TO_DACR - [1:0] */
+#define WM8993_ADC_TO_DACR_WIDTH                     2  /* ADC_TO_DACR - [1:0] */
+
+/*
+ * R14 (0x0E) - ADC CTRL
+ */
+#define WM8993_ADC_OSR128                       0x0200  /* ADC_OSR128 */
+#define WM8993_ADC_OSR128_MASK                  0x0200  /* ADC_OSR128 */
+#define WM8993_ADC_OSR128_SHIFT                      9  /* ADC_OSR128 */
+#define WM8993_ADC_OSR128_WIDTH                      1  /* ADC_OSR128 */
+#define WM8993_ADC_HPF                          0x0100  /* ADC_HPF */
+#define WM8993_ADC_HPF_MASK                     0x0100  /* ADC_HPF */
+#define WM8993_ADC_HPF_SHIFT                         8  /* ADC_HPF */
+#define WM8993_ADC_HPF_WIDTH                         1  /* ADC_HPF */
+#define WM8993_ADC_HPF_CUT_MASK                 0x0060  /* ADC_HPF_CUT - [6:5] */
+#define WM8993_ADC_HPF_CUT_SHIFT                     5  /* ADC_HPF_CUT - [6:5] */
+#define WM8993_ADC_HPF_CUT_WIDTH                     2  /* ADC_HPF_CUT - [6:5] */
+#define WM8993_ADCL_DATINV                      0x0002  /* ADCL_DATINV */
+#define WM8993_ADCL_DATINV_MASK                 0x0002  /* ADCL_DATINV */
+#define WM8993_ADCL_DATINV_SHIFT                     1  /* ADCL_DATINV */
+#define WM8993_ADCL_DATINV_WIDTH                     1  /* ADCL_DATINV */
+#define WM8993_ADCR_DATINV                      0x0001  /* ADCR_DATINV */
+#define WM8993_ADCR_DATINV_MASK                 0x0001  /* ADCR_DATINV */
+#define WM8993_ADCR_DATINV_SHIFT                     0  /* ADCR_DATINV */
+#define WM8993_ADCR_DATINV_WIDTH                     1  /* ADCR_DATINV */
+
+/*
+ * R15 (0x0F) - Left ADC Digital Volume
+ */
+#define WM8993_ADC_VU                           0x0100  /* ADC_VU */
+#define WM8993_ADC_VU_MASK                      0x0100  /* ADC_VU */
+#define WM8993_ADC_VU_SHIFT                          8  /* ADC_VU */
+#define WM8993_ADC_VU_WIDTH                          1  /* ADC_VU */
+#define WM8993_ADCL_VOL_MASK                    0x00FF  /* ADCL_VOL - [7:0] */
+#define WM8993_ADCL_VOL_SHIFT                        0  /* ADCL_VOL - [7:0] */
+#define WM8993_ADCL_VOL_WIDTH                        8  /* ADCL_VOL - [7:0] */
+
+/*
+ * R16 (0x10) - Right ADC Digital Volume
+ */
+#define WM8993_ADC_VU                           0x0100  /* ADC_VU */
+#define WM8993_ADC_VU_MASK                      0x0100  /* ADC_VU */
+#define WM8993_ADC_VU_SHIFT                          8  /* ADC_VU */
+#define WM8993_ADC_VU_WIDTH                          1  /* ADC_VU */
+#define WM8993_ADCR_VOL_MASK                    0x00FF  /* ADCR_VOL - [7:0] */
+#define WM8993_ADCR_VOL_SHIFT                        0  /* ADCR_VOL - [7:0] */
+#define WM8993_ADCR_VOL_WIDTH                        8  /* ADCR_VOL - [7:0] */
+
+/*
+ * R18 (0x12) - GPIO CTRL 1
+ */
+#define WM8993_JD2_SC_EINT                      0x8000  /* JD2_SC_EINT */
+#define WM8993_JD2_SC_EINT_MASK                 0x8000  /* JD2_SC_EINT */
+#define WM8993_JD2_SC_EINT_SHIFT                    15  /* JD2_SC_EINT */
+#define WM8993_JD2_SC_EINT_WIDTH                     1  /* JD2_SC_EINT */
+#define WM8993_JD2_EINT                         0x4000  /* JD2_EINT */
+#define WM8993_JD2_EINT_MASK                    0x4000  /* JD2_EINT */
+#define WM8993_JD2_EINT_SHIFT                       14  /* JD2_EINT */
+#define WM8993_JD2_EINT_WIDTH                        1  /* JD2_EINT */
+#define WM8993_WSEQ_EINT                        0x2000  /* WSEQ_EINT */
+#define WM8993_WSEQ_EINT_MASK                   0x2000  /* WSEQ_EINT */
+#define WM8993_WSEQ_EINT_SHIFT                      13  /* WSEQ_EINT */
+#define WM8993_WSEQ_EINT_WIDTH                       1  /* WSEQ_EINT */
+#define WM8993_IRQ                              0x1000  /* IRQ */
+#define WM8993_IRQ_MASK                         0x1000  /* IRQ */
+#define WM8993_IRQ_SHIFT                            12  /* IRQ */
+#define WM8993_IRQ_WIDTH                             1  /* IRQ */
+#define WM8993_TEMPOK_EINT                      0x0800  /* TEMPOK_EINT */
+#define WM8993_TEMPOK_EINT_MASK                 0x0800  /* TEMPOK_EINT */
+#define WM8993_TEMPOK_EINT_SHIFT                    11  /* TEMPOK_EINT */
+#define WM8993_TEMPOK_EINT_WIDTH                     1  /* TEMPOK_EINT */
+#define WM8993_JD1_SC_EINT                      0x0400  /* JD1_SC_EINT */
+#define WM8993_JD1_SC_EINT_MASK                 0x0400  /* JD1_SC_EINT */
+#define WM8993_JD1_SC_EINT_SHIFT                    10  /* JD1_SC_EINT */
+#define WM8993_JD1_SC_EINT_WIDTH                     1  /* JD1_SC_EINT */
+#define WM8993_JD1_EINT                         0x0200  /* JD1_EINT */
+#define WM8993_JD1_EINT_MASK                    0x0200  /* JD1_EINT */
+#define WM8993_JD1_EINT_SHIFT                        9  /* JD1_EINT */
+#define WM8993_JD1_EINT_WIDTH                        1  /* JD1_EINT */
+#define WM8993_FLL_LOCK_EINT                    0x0100  /* FLL_LOCK_EINT */
+#define WM8993_FLL_LOCK_EINT_MASK               0x0100  /* FLL_LOCK_EINT */
+#define WM8993_FLL_LOCK_EINT_SHIFT                   8  /* FLL_LOCK_EINT */
+#define WM8993_FLL_LOCK_EINT_WIDTH                   1  /* FLL_LOCK_EINT */
+#define WM8993_GPI8_EINT                        0x0080  /* GPI8_EINT */
+#define WM8993_GPI8_EINT_MASK                   0x0080  /* GPI8_EINT */
+#define WM8993_GPI8_EINT_SHIFT                       7  /* GPI8_EINT */
+#define WM8993_GPI8_EINT_WIDTH                       1  /* GPI8_EINT */
+#define WM8993_GPI7_EINT                        0x0040  /* GPI7_EINT */
+#define WM8993_GPI7_EINT_MASK                   0x0040  /* GPI7_EINT */
+#define WM8993_GPI7_EINT_SHIFT                       6  /* GPI7_EINT */
+#define WM8993_GPI7_EINT_WIDTH                       1  /* GPI7_EINT */
+#define WM8993_GPIO1_EINT                       0x0001  /* GPIO1_EINT */
+#define WM8993_GPIO1_EINT_MASK                  0x0001  /* GPIO1_EINT */
+#define WM8993_GPIO1_EINT_SHIFT                      0  /* GPIO1_EINT */
+#define WM8993_GPIO1_EINT_WIDTH                      1  /* GPIO1_EINT */
+
+/*
+ * R19 (0x13) - GPIO1
+ */
+#define WM8993_GPIO1_PU                         0x0020  /* GPIO1_PU */
+#define WM8993_GPIO1_PU_MASK                    0x0020  /* GPIO1_PU */
+#define WM8993_GPIO1_PU_SHIFT                        5  /* GPIO1_PU */
+#define WM8993_GPIO1_PU_WIDTH                        1  /* GPIO1_PU */
+#define WM8993_GPIO1_PD                         0x0010  /* GPIO1_PD */
+#define WM8993_GPIO1_PD_MASK                    0x0010  /* GPIO1_PD */
+#define WM8993_GPIO1_PD_SHIFT                        4  /* GPIO1_PD */
+#define WM8993_GPIO1_PD_WIDTH                        1  /* GPIO1_PD */
+#define WM8993_GPIO1_SEL_MASK                   0x000F  /* GPIO1_SEL - [3:0] */
+#define WM8993_GPIO1_SEL_SHIFT                       0  /* GPIO1_SEL - [3:0] */
+#define WM8993_GPIO1_SEL_WIDTH                       4  /* GPIO1_SEL - [3:0] */
+
+/*
+ * R20 (0x14) - IRQ_DEBOUNCE
+ */
+#define WM8993_JD2_SC_DB                        0x8000  /* JD2_SC_DB */
+#define WM8993_JD2_SC_DB_MASK                   0x8000  /* JD2_SC_DB */
+#define WM8993_JD2_SC_DB_SHIFT                      15  /* JD2_SC_DB */
+#define WM8993_JD2_SC_DB_WIDTH                       1  /* JD2_SC_DB */
+#define WM8993_JD2_DB                           0x4000  /* JD2_DB */
+#define WM8993_JD2_DB_MASK                      0x4000  /* JD2_DB */
+#define WM8993_JD2_DB_SHIFT                         14  /* JD2_DB */
+#define WM8993_JD2_DB_WIDTH                          1  /* JD2_DB */
+#define WM8993_WSEQ_DB                          0x2000  /* WSEQ_DB */
+#define WM8993_WSEQ_DB_MASK                     0x2000  /* WSEQ_DB */
+#define WM8993_WSEQ_DB_SHIFT                        13  /* WSEQ_DB */
+#define WM8993_WSEQ_DB_WIDTH                         1  /* WSEQ_DB */
+#define WM8993_TEMPOK_DB                        0x0800  /* TEMPOK_DB */
+#define WM8993_TEMPOK_DB_MASK                   0x0800  /* TEMPOK_DB */
+#define WM8993_TEMPOK_DB_SHIFT                      11  /* TEMPOK_DB */
+#define WM8993_TEMPOK_DB_WIDTH                       1  /* TEMPOK_DB */
+#define WM8993_JD1_SC_DB                        0x0400  /* JD1_SC_DB */
+#define WM8993_JD1_SC_DB_MASK                   0x0400  /* JD1_SC_DB */
+#define WM8993_JD1_SC_DB_SHIFT                      10  /* JD1_SC_DB */
+#define WM8993_JD1_SC_DB_WIDTH                       1  /* JD1_SC_DB */
+#define WM8993_JD1_DB                           0x0200  /* JD1_DB */
+#define WM8993_JD1_DB_MASK                      0x0200  /* JD1_DB */
+#define WM8993_JD1_DB_SHIFT                          9  /* JD1_DB */
+#define WM8993_JD1_DB_WIDTH                          1  /* JD1_DB */
+#define WM8993_FLL_LOCK_DB                      0x0100  /* FLL_LOCK_DB */
+#define WM8993_FLL_LOCK_DB_MASK                 0x0100  /* FLL_LOCK_DB */
+#define WM8993_FLL_LOCK_DB_SHIFT                     8  /* FLL_LOCK_DB */
+#define WM8993_FLL_LOCK_DB_WIDTH                     1  /* FLL_LOCK_DB */
+#define WM8993_GPI8_DB                          0x0080  /* GPI8_DB */
+#define WM8993_GPI8_DB_MASK                     0x0080  /* GPI8_DB */
+#define WM8993_GPI8_DB_SHIFT                         7  /* GPI8_DB */
+#define WM8993_GPI8_DB_WIDTH                         1  /* GPI8_DB */
+#define WM8993_GPI7_DB                          0x0008  /* GPI7_DB */
+#define WM8993_GPI7_DB_MASK                     0x0008  /* GPI7_DB */
+#define WM8993_GPI7_DB_SHIFT                         3  /* GPI7_DB */
+#define WM8993_GPI7_DB_WIDTH                         1  /* GPI7_DB */
+#define WM8993_GPIO1_DB                         0x0001  /* GPIO1_DB */
+#define WM8993_GPIO1_DB_MASK                    0x0001  /* GPIO1_DB */
+#define WM8993_GPIO1_DB_SHIFT                        0  /* GPIO1_DB */
+#define WM8993_GPIO1_DB_WIDTH                        1  /* GPIO1_DB */
+
+/*
+ * R22 (0x16) - GPIOCTRL 2
+ */
+#define WM8993_IM_JD2_EINT                      0x2000  /* IM_JD2_EINT */
+#define WM8993_IM_JD2_EINT_MASK                 0x2000  /* IM_JD2_EINT */
+#define WM8993_IM_JD2_EINT_SHIFT                    13  /* IM_JD2_EINT */
+#define WM8993_IM_JD2_EINT_WIDTH                     1  /* IM_JD2_EINT */
+#define WM8993_IM_JD2_SC_EINT                   0x1000  /* IM_JD2_SC_EINT */
+#define WM8993_IM_JD2_SC_EINT_MASK              0x1000  /* IM_JD2_SC_EINT */
+#define WM8993_IM_JD2_SC_EINT_SHIFT                 12  /* IM_JD2_SC_EINT */
+#define WM8993_IM_JD2_SC_EINT_WIDTH                  1  /* IM_JD2_SC_EINT */
+#define WM8993_IM_TEMPOK_EINT                   0x0800  /* IM_TEMPOK_EINT */
+#define WM8993_IM_TEMPOK_EINT_MASK              0x0800  /* IM_TEMPOK_EINT */
+#define WM8993_IM_TEMPOK_EINT_SHIFT                 11  /* IM_TEMPOK_EINT */
+#define WM8993_IM_TEMPOK_EINT_WIDTH                  1  /* IM_TEMPOK_EINT */
+#define WM8993_IM_JD1_SC_EINT                   0x0400  /* IM_JD1_SC_EINT */
+#define WM8993_IM_JD1_SC_EINT_MASK              0x0400  /* IM_JD1_SC_EINT */
+#define WM8993_IM_JD1_SC_EINT_SHIFT                 10  /* IM_JD1_SC_EINT */
+#define WM8993_IM_JD1_SC_EINT_WIDTH                  1  /* IM_JD1_SC_EINT */
+#define WM8993_IM_JD1_EINT                      0x0200  /* IM_JD1_EINT */
+#define WM8993_IM_JD1_EINT_MASK                 0x0200  /* IM_JD1_EINT */
+#define WM8993_IM_JD1_EINT_SHIFT                     9  /* IM_JD1_EINT */
+#define WM8993_IM_JD1_EINT_WIDTH                     1  /* IM_JD1_EINT */
+#define WM8993_IM_FLL_LOCK_EINT                 0x0100  /* IM_FLL_LOCK_EINT */
+#define WM8993_IM_FLL_LOCK_EINT_MASK            0x0100  /* IM_FLL_LOCK_EINT */
+#define WM8993_IM_FLL_LOCK_EINT_SHIFT                8  /* IM_FLL_LOCK_EINT */
+#define WM8993_IM_FLL_LOCK_EINT_WIDTH                1  /* IM_FLL_LOCK_EINT */
+#define WM8993_IM_GPI8_EINT                     0x0040  /* IM_GPI8_EINT */
+#define WM8993_IM_GPI8_EINT_MASK                0x0040  /* IM_GPI8_EINT */
+#define WM8993_IM_GPI8_EINT_SHIFT                    6  /* IM_GPI8_EINT */
+#define WM8993_IM_GPI8_EINT_WIDTH                    1  /* IM_GPI8_EINT */
+#define WM8993_IM_GPIO1_EINT                    0x0020  /* IM_GPIO1_EINT */
+#define WM8993_IM_GPIO1_EINT_MASK               0x0020  /* IM_GPIO1_EINT */
+#define WM8993_IM_GPIO1_EINT_SHIFT                   5  /* IM_GPIO1_EINT */
+#define WM8993_IM_GPIO1_EINT_WIDTH                   1  /* IM_GPIO1_EINT */
+#define WM8993_GPI8_ENA                         0x0010  /* GPI8_ENA */
+#define WM8993_GPI8_ENA_MASK                    0x0010  /* GPI8_ENA */
+#define WM8993_GPI8_ENA_SHIFT                        4  /* GPI8_ENA */
+#define WM8993_GPI8_ENA_WIDTH                        1  /* GPI8_ENA */
+#define WM8993_IM_GPI7_EINT                     0x0004  /* IM_GPI7_EINT */
+#define WM8993_IM_GPI7_EINT_MASK                0x0004  /* IM_GPI7_EINT */
+#define WM8993_IM_GPI7_EINT_SHIFT                    2  /* IM_GPI7_EINT */
+#define WM8993_IM_GPI7_EINT_WIDTH                    1  /* IM_GPI7_EINT */
+#define WM8993_IM_WSEQ_EINT                     0x0002  /* IM_WSEQ_EINT */
+#define WM8993_IM_WSEQ_EINT_MASK                0x0002  /* IM_WSEQ_EINT */
+#define WM8993_IM_WSEQ_EINT_SHIFT                    1  /* IM_WSEQ_EINT */
+#define WM8993_IM_WSEQ_EINT_WIDTH                    1  /* IM_WSEQ_EINT */
+#define WM8993_GPI7_ENA                         0x0001  /* GPI7_ENA */
+#define WM8993_GPI7_ENA_MASK                    0x0001  /* GPI7_ENA */
+#define WM8993_GPI7_ENA_SHIFT                        0  /* GPI7_ENA */
+#define WM8993_GPI7_ENA_WIDTH                        1  /* GPI7_ENA */
+
+/*
+ * R23 (0x17) - GPIO_POL
+ */
+#define WM8993_JD2_SC_POL                       0x8000  /* JD2_SC_POL */
+#define WM8993_JD2_SC_POL_MASK                  0x8000  /* JD2_SC_POL */
+#define WM8993_JD2_SC_POL_SHIFT                     15  /* JD2_SC_POL */
+#define WM8993_JD2_SC_POL_WIDTH                      1  /* JD2_SC_POL */
+#define WM8993_JD2_POL                          0x4000  /* JD2_POL */
+#define WM8993_JD2_POL_MASK                     0x4000  /* JD2_POL */
+#define WM8993_JD2_POL_SHIFT                        14  /* JD2_POL */
+#define WM8993_JD2_POL_WIDTH                         1  /* JD2_POL */
+#define WM8993_WSEQ_POL                         0x2000  /* WSEQ_POL */
+#define WM8993_WSEQ_POL_MASK                    0x2000  /* WSEQ_POL */
+#define WM8993_WSEQ_POL_SHIFT                       13  /* WSEQ_POL */
+#define WM8993_WSEQ_POL_WIDTH                        1  /* WSEQ_POL */
+#define WM8993_IRQ_POL                          0x1000  /* IRQ_POL */
+#define WM8993_IRQ_POL_MASK                     0x1000  /* IRQ_POL */
+#define WM8993_IRQ_POL_SHIFT                        12  /* IRQ_POL */
+#define WM8993_IRQ_POL_WIDTH                         1  /* IRQ_POL */
+#define WM8993_TEMPOK_POL                       0x0800  /* TEMPOK_POL */
+#define WM8993_TEMPOK_POL_MASK                  0x0800  /* TEMPOK_POL */
+#define WM8993_TEMPOK_POL_SHIFT                     11  /* TEMPOK_POL */
+#define WM8993_TEMPOK_POL_WIDTH                      1  /* TEMPOK_POL */
+#define WM8993_JD1_SC_POL                       0x0400  /* JD1_SC_POL */
+#define WM8993_JD1_SC_POL_MASK                  0x0400  /* JD1_SC_POL */
+#define WM8993_JD1_SC_POL_SHIFT                     10  /* JD1_SC_POL */
+#define WM8993_JD1_SC_POL_WIDTH                      1  /* JD1_SC_POL */
+#define WM8993_JD1_POL                          0x0200  /* JD1_POL */
+#define WM8993_JD1_POL_MASK                     0x0200  /* JD1_POL */
+#define WM8993_JD1_POL_SHIFT                         9  /* JD1_POL */
+#define WM8993_JD1_POL_WIDTH                         1  /* JD1_POL */
+#define WM8993_FLL_LOCK_POL                     0x0100  /* FLL_LOCK_POL */
+#define WM8993_FLL_LOCK_POL_MASK                0x0100  /* FLL_LOCK_POL */
+#define WM8993_FLL_LOCK_POL_SHIFT                    8  /* FLL_LOCK_POL */
+#define WM8993_FLL_LOCK_POL_WIDTH                    1  /* FLL_LOCK_POL */
+#define WM8993_GPI8_POL                         0x0080  /* GPI8_POL */
+#define WM8993_GPI8_POL_MASK                    0x0080  /* GPI8_POL */
+#define WM8993_GPI8_POL_SHIFT                        7  /* GPI8_POL */
+#define WM8993_GPI8_POL_WIDTH                        1  /* GPI8_POL */
+#define WM8993_GPI7_POL                         0x0040  /* GPI7_POL */
+#define WM8993_GPI7_POL_MASK                    0x0040  /* GPI7_POL */
+#define WM8993_GPI7_POL_SHIFT                        6  /* GPI7_POL */
+#define WM8993_GPI7_POL_WIDTH                        1  /* GPI7_POL */
+#define WM8993_GPIO1_POL                        0x0001  /* GPIO1_POL */
+#define WM8993_GPIO1_POL_MASK                   0x0001  /* GPIO1_POL */
+#define WM8993_GPIO1_POL_SHIFT                       0  /* GPIO1_POL */
+#define WM8993_GPIO1_POL_WIDTH                       1  /* GPIO1_POL */
+
+/*
+ * R24 (0x18) - Left Line Input 1&2 Volume
+ */
+#define WM8993_IN1_VU                           0x0100  /* IN1_VU */
+#define WM8993_IN1_VU_MASK                      0x0100  /* IN1_VU */
+#define WM8993_IN1_VU_SHIFT                          8  /* IN1_VU */
+#define WM8993_IN1_VU_WIDTH                          1  /* IN1_VU */
+#define WM8993_IN1L_MUTE                        0x0080  /* IN1L_MUTE */
+#define WM8993_IN1L_MUTE_MASK                   0x0080  /* IN1L_MUTE */
+#define WM8993_IN1L_MUTE_SHIFT                       7  /* IN1L_MUTE */
+#define WM8993_IN1L_MUTE_WIDTH                       1  /* IN1L_MUTE */
+#define WM8993_IN1L_ZC                          0x0040  /* IN1L_ZC */
+#define WM8993_IN1L_ZC_MASK                     0x0040  /* IN1L_ZC */
+#define WM8993_IN1L_ZC_SHIFT                         6  /* IN1L_ZC */
+#define WM8993_IN1L_ZC_WIDTH                         1  /* IN1L_ZC */
+#define WM8993_IN1L_VOL_MASK                    0x001F  /* IN1L_VOL - [4:0] */
+#define WM8993_IN1L_VOL_SHIFT                        0  /* IN1L_VOL - [4:0] */
+#define WM8993_IN1L_VOL_WIDTH                        5  /* IN1L_VOL - [4:0] */
+
+/*
+ * R25 (0x19) - Left Line Input 3&4 Volume
+ */
+#define WM8993_IN2_VU                           0x0100  /* IN2_VU */
+#define WM8993_IN2_VU_MASK                      0x0100  /* IN2_VU */
+#define WM8993_IN2_VU_SHIFT                          8  /* IN2_VU */
+#define WM8993_IN2_VU_WIDTH                          1  /* IN2_VU */
+#define WM8993_IN2L_MUTE                        0x0080  /* IN2L_MUTE */
+#define WM8993_IN2L_MUTE_MASK                   0x0080  /* IN2L_MUTE */
+#define WM8993_IN2L_MUTE_SHIFT                       7  /* IN2L_MUTE */
+#define WM8993_IN2L_MUTE_WIDTH                       1  /* IN2L_MUTE */
+#define WM8993_IN2L_ZC                          0x0040  /* IN2L_ZC */
+#define WM8993_IN2L_ZC_MASK                     0x0040  /* IN2L_ZC */
+#define WM8993_IN2L_ZC_SHIFT                         6  /* IN2L_ZC */
+#define WM8993_IN2L_ZC_WIDTH                         1  /* IN2L_ZC */
+#define WM8993_IN2L_VOL_MASK                    0x001F  /* IN2L_VOL - [4:0] */
+#define WM8993_IN2L_VOL_SHIFT                        0  /* IN2L_VOL - [4:0] */
+#define WM8993_IN2L_VOL_WIDTH                        5  /* IN2L_VOL - [4:0] */
+
+/*
+ * R26 (0x1A) - Right Line Input 1&2 Volume
+ */
+#define WM8993_IN1_VU                           0x0100  /* IN1_VU */
+#define WM8993_IN1_VU_MASK                      0x0100  /* IN1_VU */
+#define WM8993_IN1_VU_SHIFT                          8  /* IN1_VU */
+#define WM8993_IN1_VU_WIDTH                          1  /* IN1_VU */
+#define WM8993_IN1R_MUTE                        0x0080  /* IN1R_MUTE */
+#define WM8993_IN1R_MUTE_MASK                   0x0080  /* IN1R_MUTE */
+#define WM8993_IN1R_MUTE_SHIFT                       7  /* IN1R_MUTE */
+#define WM8993_IN1R_MUTE_WIDTH                       1  /* IN1R_MUTE */
+#define WM8993_IN1R_ZC                          0x0040  /* IN1R_ZC */
+#define WM8993_IN1R_ZC_MASK                     0x0040  /* IN1R_ZC */
+#define WM8993_IN1R_ZC_SHIFT                         6  /* IN1R_ZC */
+#define WM8993_IN1R_ZC_WIDTH                         1  /* IN1R_ZC */
+#define WM8993_IN1R_VOL_MASK                    0x001F  /* IN1R_VOL - [4:0] */
+#define WM8993_IN1R_VOL_SHIFT                        0  /* IN1R_VOL - [4:0] */
+#define WM8993_IN1R_VOL_WIDTH                        5  /* IN1R_VOL - [4:0] */
+
+/*
+ * R27 (0x1B) - Right Line Input 3&4 Volume
+ */
+#define WM8993_IN2_VU                           0x0100  /* IN2_VU */
+#define WM8993_IN2_VU_MASK                      0x0100  /* IN2_VU */
+#define WM8993_IN2_VU_SHIFT                          8  /* IN2_VU */
+#define WM8993_IN2_VU_WIDTH                          1  /* IN2_VU */
+#define WM8993_IN2R_MUTE                        0x0080  /* IN2R_MUTE */
+#define WM8993_IN2R_MUTE_MASK                   0x0080  /* IN2R_MUTE */
+#define WM8993_IN2R_MUTE_SHIFT                       7  /* IN2R_MUTE */
+#define WM8993_IN2R_MUTE_WIDTH                       1  /* IN2R_MUTE */
+#define WM8993_IN2R_ZC                          0x0040  /* IN2R_ZC */
+#define WM8993_IN2R_ZC_MASK                     0x0040  /* IN2R_ZC */
+#define WM8993_IN2R_ZC_SHIFT                         6  /* IN2R_ZC */
+#define WM8993_IN2R_ZC_WIDTH                         1  /* IN2R_ZC */
+#define WM8993_IN2R_VOL_MASK                    0x001F  /* IN2R_VOL - [4:0] */
+#define WM8993_IN2R_VOL_SHIFT                        0  /* IN2R_VOL - [4:0] */
+#define WM8993_IN2R_VOL_WIDTH                        5  /* IN2R_VOL - [4:0] */
+
+/*
+ * R28 (0x1C) - Left Output Volume
+ */
+#define WM8993_HPOUT1_VU                        0x0100  /* HPOUT1_VU */
+#define WM8993_HPOUT1_VU_MASK                   0x0100  /* HPOUT1_VU */
+#define WM8993_HPOUT1_VU_SHIFT                       8  /* HPOUT1_VU */
+#define WM8993_HPOUT1_VU_WIDTH                       1  /* HPOUT1_VU */
+#define WM8993_HPOUT1L_ZC                       0x0080  /* HPOUT1L_ZC */
+#define WM8993_HPOUT1L_ZC_MASK                  0x0080  /* HPOUT1L_ZC */
+#define WM8993_HPOUT1L_ZC_SHIFT                      7  /* HPOUT1L_ZC */
+#define WM8993_HPOUT1L_ZC_WIDTH                      1  /* HPOUT1L_ZC */
+#define WM8993_HPOUT1L_MUTE_N                   0x0040  /* HPOUT1L_MUTE_N */
+#define WM8993_HPOUT1L_MUTE_N_MASK              0x0040  /* HPOUT1L_MUTE_N */
+#define WM8993_HPOUT1L_MUTE_N_SHIFT                  6  /* HPOUT1L_MUTE_N */
+#define WM8993_HPOUT1L_MUTE_N_WIDTH                  1  /* HPOUT1L_MUTE_N */
+#define WM8993_HPOUT1L_VOL_MASK                 0x003F  /* HPOUT1L_VOL - [5:0] */
+#define WM8993_HPOUT1L_VOL_SHIFT                     0  /* HPOUT1L_VOL - [5:0] */
+#define WM8993_HPOUT1L_VOL_WIDTH                     6  /* HPOUT1L_VOL - [5:0] */
+
+/*
+ * R29 (0x1D) - Right Output Volume
+ */
+#define WM8993_HPOUT1_VU                        0x0100  /* HPOUT1_VU */
+#define WM8993_HPOUT1_VU_MASK                   0x0100  /* HPOUT1_VU */
+#define WM8993_HPOUT1_VU_SHIFT                       8  /* HPOUT1_VU */
+#define WM8993_HPOUT1_VU_WIDTH                       1  /* HPOUT1_VU */
+#define WM8993_HPOUT1R_ZC                       0x0080  /* HPOUT1R_ZC */
+#define WM8993_HPOUT1R_ZC_MASK                  0x0080  /* HPOUT1R_ZC */
+#define WM8993_HPOUT1R_ZC_SHIFT                      7  /* HPOUT1R_ZC */
+#define WM8993_HPOUT1R_ZC_WIDTH                      1  /* HPOUT1R_ZC */
+#define WM8993_HPOUT1R_MUTE_N                   0x0040  /* HPOUT1R_MUTE_N */
+#define WM8993_HPOUT1R_MUTE_N_MASK              0x0040  /* HPOUT1R_MUTE_N */
+#define WM8993_HPOUT1R_MUTE_N_SHIFT                  6  /* HPOUT1R_MUTE_N */
+#define WM8993_HPOUT1R_MUTE_N_WIDTH                  1  /* HPOUT1R_MUTE_N */
+#define WM8993_HPOUT1R_VOL_MASK                 0x003F  /* HPOUT1R_VOL - [5:0] */
+#define WM8993_HPOUT1R_VOL_SHIFT                     0  /* HPOUT1R_VOL - [5:0] */
+#define WM8993_HPOUT1R_VOL_WIDTH                     6  /* HPOUT1R_VOL - [5:0] */
+
+/*
+ * R30 (0x1E) - Line Outputs Volume
+ */
+#define WM8993_LINEOUT1N_MUTE                   0x0040  /* LINEOUT1N_MUTE */
+#define WM8993_LINEOUT1N_MUTE_MASK              0x0040  /* LINEOUT1N_MUTE */
+#define WM8993_LINEOUT1N_MUTE_SHIFT                  6  /* LINEOUT1N_MUTE */
+#define WM8993_LINEOUT1N_MUTE_WIDTH                  1  /* LINEOUT1N_MUTE */
+#define WM8993_LINEOUT1P_MUTE                   0x0020  /* LINEOUT1P_MUTE */
+#define WM8993_LINEOUT1P_MUTE_MASK              0x0020  /* LINEOUT1P_MUTE */
+#define WM8993_LINEOUT1P_MUTE_SHIFT                  5  /* LINEOUT1P_MUTE */
+#define WM8993_LINEOUT1P_MUTE_WIDTH                  1  /* LINEOUT1P_MUTE */
+#define WM8993_LINEOUT1_VOL                     0x0010  /* LINEOUT1_VOL */
+#define WM8993_LINEOUT1_VOL_MASK                0x0010  /* LINEOUT1_VOL */
+#define WM8993_LINEOUT1_VOL_SHIFT                    4  /* LINEOUT1_VOL */
+#define WM8993_LINEOUT1_VOL_WIDTH                    1  /* LINEOUT1_VOL */
+#define WM8993_LINEOUT2N_MUTE                   0x0004  /* LINEOUT2N_MUTE */
+#define WM8993_LINEOUT2N_MUTE_MASK              0x0004  /* LINEOUT2N_MUTE */
+#define WM8993_LINEOUT2N_MUTE_SHIFT                  2  /* LINEOUT2N_MUTE */
+#define WM8993_LINEOUT2N_MUTE_WIDTH                  1  /* LINEOUT2N_MUTE */
+#define WM8993_LINEOUT2P_MUTE                   0x0002  /* LINEOUT2P_MUTE */
+#define WM8993_LINEOUT2P_MUTE_MASK              0x0002  /* LINEOUT2P_MUTE */
+#define WM8993_LINEOUT2P_MUTE_SHIFT                  1  /* LINEOUT2P_MUTE */
+#define WM8993_LINEOUT2P_MUTE_WIDTH                  1  /* LINEOUT2P_MUTE */
+#define WM8993_LINEOUT2_VOL                     0x0001  /* LINEOUT2_VOL */
+#define WM8993_LINEOUT2_VOL_MASK                0x0001  /* LINEOUT2_VOL */
+#define WM8993_LINEOUT2_VOL_SHIFT                    0  /* LINEOUT2_VOL */
+#define WM8993_LINEOUT2_VOL_WIDTH                    1  /* LINEOUT2_VOL */
+
+/*
+ * R31 (0x1F) - HPOUT2 Volume
+ */
+#define WM8993_HPOUT2_MUTE                      0x0020  /* HPOUT2_MUTE */
+#define WM8993_HPOUT2_MUTE_MASK                 0x0020  /* HPOUT2_MUTE */
+#define WM8993_HPOUT2_MUTE_SHIFT                     5  /* HPOUT2_MUTE */
+#define WM8993_HPOUT2_MUTE_WIDTH                     1  /* HPOUT2_MUTE */
+#define WM8993_HPOUT2_VOL                       0x0010  /* HPOUT2_VOL */
+#define WM8993_HPOUT2_VOL_MASK                  0x0010  /* HPOUT2_VOL */
+#define WM8993_HPOUT2_VOL_SHIFT                      4  /* HPOUT2_VOL */
+#define WM8993_HPOUT2_VOL_WIDTH                      1  /* HPOUT2_VOL */
+
+/*
+ * R32 (0x20) - Left OPGA Volume
+ */
+#define WM8993_MIXOUT_VU                        0x0100  /* MIXOUT_VU */
+#define WM8993_MIXOUT_VU_MASK                   0x0100  /* MIXOUT_VU */
+#define WM8993_MIXOUT_VU_SHIFT                       8  /* MIXOUT_VU */
+#define WM8993_MIXOUT_VU_WIDTH                       1  /* MIXOUT_VU */
+#define WM8993_MIXOUTL_ZC                       0x0080  /* MIXOUTL_ZC */
+#define WM8993_MIXOUTL_ZC_MASK                  0x0080  /* MIXOUTL_ZC */
+#define WM8993_MIXOUTL_ZC_SHIFT                      7  /* MIXOUTL_ZC */
+#define WM8993_MIXOUTL_ZC_WIDTH                      1  /* MIXOUTL_ZC */
+#define WM8993_MIXOUTL_MUTE_N                   0x0040  /* MIXOUTL_MUTE_N */
+#define WM8993_MIXOUTL_MUTE_N_MASK              0x0040  /* MIXOUTL_MUTE_N */
+#define WM8993_MIXOUTL_MUTE_N_SHIFT                  6  /* MIXOUTL_MUTE_N */
+#define WM8993_MIXOUTL_MUTE_N_WIDTH                  1  /* MIXOUTL_MUTE_N */
+#define WM8993_MIXOUTL_VOL_MASK                 0x003F  /* MIXOUTL_VOL - [5:0] */
+#define WM8993_MIXOUTL_VOL_SHIFT                     0  /* MIXOUTL_VOL - [5:0] */
+#define WM8993_MIXOUTL_VOL_WIDTH                     6  /* MIXOUTL_VOL - [5:0] */
+
+/*
+ * R33 (0x21) - Right OPGA Volume
+ */
+#define WM8993_MIXOUT_VU                        0x0100  /* MIXOUT_VU */
+#define WM8993_MIXOUT_VU_MASK                   0x0100  /* MIXOUT_VU */
+#define WM8993_MIXOUT_VU_SHIFT                       8  /* MIXOUT_VU */
+#define WM8993_MIXOUT_VU_WIDTH                       1  /* MIXOUT_VU */
+#define WM8993_MIXOUTR_ZC                       0x0080  /* MIXOUTR_ZC */
+#define WM8993_MIXOUTR_ZC_MASK                  0x0080  /* MIXOUTR_ZC */
+#define WM8993_MIXOUTR_ZC_SHIFT                      7  /* MIXOUTR_ZC */
+#define WM8993_MIXOUTR_ZC_WIDTH                      1  /* MIXOUTR_ZC */
+#define WM8993_MIXOUTR_MUTE_N                   0x0040  /* MIXOUTR_MUTE_N */
+#define WM8993_MIXOUTR_MUTE_N_MASK              0x0040  /* MIXOUTR_MUTE_N */
+#define WM8993_MIXOUTR_MUTE_N_SHIFT                  6  /* MIXOUTR_MUTE_N */
+#define WM8993_MIXOUTR_MUTE_N_WIDTH                  1  /* MIXOUTR_MUTE_N */
+#define WM8993_MIXOUTR_VOL_MASK                 0x003F  /* MIXOUTR_VOL - [5:0] */
+#define WM8993_MIXOUTR_VOL_SHIFT                     0  /* MIXOUTR_VOL - [5:0] */
+#define WM8993_MIXOUTR_VOL_WIDTH                     6  /* MIXOUTR_VOL - [5:0] */
+
+/*
+ * R34 (0x22) - SPKMIXL Attenuation
+ */
+#define WM8993_MIXINL_SPKMIXL_VOL               0x0020  /* MIXINL_SPKMIXL_VOL */
+#define WM8993_MIXINL_SPKMIXL_VOL_MASK          0x0020  /* MIXINL_SPKMIXL_VOL */
+#define WM8993_MIXINL_SPKMIXL_VOL_SHIFT              5  /* MIXINL_SPKMIXL_VOL */
+#define WM8993_MIXINL_SPKMIXL_VOL_WIDTH              1  /* MIXINL_SPKMIXL_VOL */
+#define WM8993_IN1LP_SPKMIXL_VOL                0x0010  /* IN1LP_SPKMIXL_VOL */
+#define WM8993_IN1LP_SPKMIXL_VOL_MASK           0x0010  /* IN1LP_SPKMIXL_VOL */
+#define WM8993_IN1LP_SPKMIXL_VOL_SHIFT               4  /* IN1LP_SPKMIXL_VOL */
+#define WM8993_IN1LP_SPKMIXL_VOL_WIDTH               1  /* IN1LP_SPKMIXL_VOL */
+#define WM8993_MIXOUTL_SPKMIXL_VOL              0x0008  /* MIXOUTL_SPKMIXL_VOL */
+#define WM8993_MIXOUTL_SPKMIXL_VOL_MASK         0x0008  /* MIXOUTL_SPKMIXL_VOL */
+#define WM8993_MIXOUTL_SPKMIXL_VOL_SHIFT             3  /* MIXOUTL_SPKMIXL_VOL */
+#define WM8993_MIXOUTL_SPKMIXL_VOL_WIDTH             1  /* MIXOUTL_SPKMIXL_VOL */
+#define WM8993_DACL_SPKMIXL_VOL                 0x0004  /* DACL_SPKMIXL_VOL */
+#define WM8993_DACL_SPKMIXL_VOL_MASK            0x0004  /* DACL_SPKMIXL_VOL */
+#define WM8993_DACL_SPKMIXL_VOL_SHIFT                2  /* DACL_SPKMIXL_VOL */
+#define WM8993_DACL_SPKMIXL_VOL_WIDTH                1  /* DACL_SPKMIXL_VOL */
+#define WM8993_SPKMIXL_VOL_MASK                 0x0003  /* SPKMIXL_VOL - [1:0] */
+#define WM8993_SPKMIXL_VOL_SHIFT                     0  /* SPKMIXL_VOL - [1:0] */
+#define WM8993_SPKMIXL_VOL_WIDTH                     2  /* SPKMIXL_VOL - [1:0] */
+
+/*
+ * R35 (0x23) - SPKMIXR Attenuation
+ */
+#define WM8993_SPKOUT_CLASSAB_MODE              0x0100  /* SPKOUT_CLASSAB_MODE */
+#define WM8993_SPKOUT_CLASSAB_MODE_MASK         0x0100  /* SPKOUT_CLASSAB_MODE */
+#define WM8993_SPKOUT_CLASSAB_MODE_SHIFT             8  /* SPKOUT_CLASSAB_MODE */
+#define WM8993_SPKOUT_CLASSAB_MODE_WIDTH             1  /* SPKOUT_CLASSAB_MODE */
+#define WM8993_MIXINR_SPKMIXR_VOL               0x0020  /* MIXINR_SPKMIXR_VOL */
+#define WM8993_MIXINR_SPKMIXR_VOL_MASK          0x0020  /* MIXINR_SPKMIXR_VOL */
+#define WM8993_MIXINR_SPKMIXR_VOL_SHIFT              5  /* MIXINR_SPKMIXR_VOL */
+#define WM8993_MIXINR_SPKMIXR_VOL_WIDTH              1  /* MIXINR_SPKMIXR_VOL */
+#define WM8993_IN1RP_SPKMIXR_VOL                0x0010  /* IN1RP_SPKMIXR_VOL */
+#define WM8993_IN1RP_SPKMIXR_VOL_MASK           0x0010  /* IN1RP_SPKMIXR_VOL */
+#define WM8993_IN1RP_SPKMIXR_VOL_SHIFT               4  /* IN1RP_SPKMIXR_VOL */
+#define WM8993_IN1RP_SPKMIXR_VOL_WIDTH               1  /* IN1RP_SPKMIXR_VOL */
+#define WM8993_MIXOUTR_SPKMIXR_VOL              0x0008  /* MIXOUTR_SPKMIXR_VOL */
+#define WM8993_MIXOUTR_SPKMIXR_VOL_MASK         0x0008  /* MIXOUTR_SPKMIXR_VOL */
+#define WM8993_MIXOUTR_SPKMIXR_VOL_SHIFT             3  /* MIXOUTR_SPKMIXR_VOL */
+#define WM8993_MIXOUTR_SPKMIXR_VOL_WIDTH             1  /* MIXOUTR_SPKMIXR_VOL */
+#define WM8993_DACR_SPKMIXR_VOL                 0x0004  /* DACR_SPKMIXR_VOL */
+#define WM8993_DACR_SPKMIXR_VOL_MASK            0x0004  /* DACR_SPKMIXR_VOL */
+#define WM8993_DACR_SPKMIXR_VOL_SHIFT                2  /* DACR_SPKMIXR_VOL */
+#define WM8993_DACR_SPKMIXR_VOL_WIDTH                1  /* DACR_SPKMIXR_VOL */
+#define WM8993_SPKMIXR_VOL_MASK                 0x0003  /* SPKMIXR_VOL - [1:0] */
+#define WM8993_SPKMIXR_VOL_SHIFT                     0  /* SPKMIXR_VOL - [1:0] */
+#define WM8993_SPKMIXR_VOL_WIDTH                     2  /* SPKMIXR_VOL - [1:0] */
+
+/*
+ * R36 (0x24) - SPKOUT Mixers
+ */
+#define WM8993_VRX_TO_SPKOUTL                   0x0020  /* VRX_TO_SPKOUTL */
+#define WM8993_VRX_TO_SPKOUTL_MASK              0x0020  /* VRX_TO_SPKOUTL */
+#define WM8993_VRX_TO_SPKOUTL_SHIFT                  5  /* VRX_TO_SPKOUTL */
+#define WM8993_VRX_TO_SPKOUTL_WIDTH                  1  /* VRX_TO_SPKOUTL */
+#define WM8993_SPKMIXL_TO_SPKOUTL               0x0010  /* SPKMIXL_TO_SPKOUTL */
+#define WM8993_SPKMIXL_TO_SPKOUTL_MASK          0x0010  /* SPKMIXL_TO_SPKOUTL */
+#define WM8993_SPKMIXL_TO_SPKOUTL_SHIFT              4  /* SPKMIXL_TO_SPKOUTL */
+#define WM8993_SPKMIXL_TO_SPKOUTL_WIDTH              1  /* SPKMIXL_TO_SPKOUTL */
+#define WM8993_SPKMIXR_TO_SPKOUTL               0x0008  /* SPKMIXR_TO_SPKOUTL */
+#define WM8993_SPKMIXR_TO_SPKOUTL_MASK          0x0008  /* SPKMIXR_TO_SPKOUTL */
+#define WM8993_SPKMIXR_TO_SPKOUTL_SHIFT              3  /* SPKMIXR_TO_SPKOUTL */
+#define WM8993_SPKMIXR_TO_SPKOUTL_WIDTH              1  /* SPKMIXR_TO_SPKOUTL */
+#define WM8993_VRX_TO_SPKOUTR                   0x0004  /* VRX_TO_SPKOUTR */
+#define WM8993_VRX_TO_SPKOUTR_MASK              0x0004  /* VRX_TO_SPKOUTR */
+#define WM8993_VRX_TO_SPKOUTR_SHIFT                  2  /* VRX_TO_SPKOUTR */
+#define WM8993_VRX_TO_SPKOUTR_WIDTH                  1  /* VRX_TO_SPKOUTR */
+#define WM8993_SPKMIXL_TO_SPKOUTR               0x0002  /* SPKMIXL_TO_SPKOUTR */
+#define WM8993_SPKMIXL_TO_SPKOUTR_MASK          0x0002  /* SPKMIXL_TO_SPKOUTR */
+#define WM8993_SPKMIXL_TO_SPKOUTR_SHIFT              1  /* SPKMIXL_TO_SPKOUTR */
+#define WM8993_SPKMIXL_TO_SPKOUTR_WIDTH              1  /* SPKMIXL_TO_SPKOUTR */
+#define WM8993_SPKMIXR_TO_SPKOUTR               0x0001  /* SPKMIXR_TO_SPKOUTR */
+#define WM8993_SPKMIXR_TO_SPKOUTR_MASK          0x0001  /* SPKMIXR_TO_SPKOUTR */
+#define WM8993_SPKMIXR_TO_SPKOUTR_SHIFT              0  /* SPKMIXR_TO_SPKOUTR */
+#define WM8993_SPKMIXR_TO_SPKOUTR_WIDTH              1  /* SPKMIXR_TO_SPKOUTR */
+
+/*
+ * R37 (0x25) - SPKOUT Boost
+ */
+#define WM8993_SPKOUTL_BOOST_MASK               0x0038  /* SPKOUTL_BOOST - [5:3] */
+#define WM8993_SPKOUTL_BOOST_SHIFT                   3  /* SPKOUTL_BOOST - [5:3] */
+#define WM8993_SPKOUTL_BOOST_WIDTH                   3  /* SPKOUTL_BOOST - [5:3] */
+#define WM8993_SPKOUTR_BOOST_MASK               0x0007  /* SPKOUTR_BOOST - [2:0] */
+#define WM8993_SPKOUTR_BOOST_SHIFT                   0  /* SPKOUTR_BOOST - [2:0] */
+#define WM8993_SPKOUTR_BOOST_WIDTH                   3  /* SPKOUTR_BOOST - [2:0] */
+
+/*
+ * R38 (0x26) - Speaker Volume Left
+ */
+#define WM8993_SPKOUT_VU                        0x0100  /* SPKOUT_VU */
+#define WM8993_SPKOUT_VU_MASK                   0x0100  /* SPKOUT_VU */
+#define WM8993_SPKOUT_VU_SHIFT                       8  /* SPKOUT_VU */
+#define WM8993_SPKOUT_VU_WIDTH                       1  /* SPKOUT_VU */
+#define WM8993_SPKOUTL_ZC                       0x0080  /* SPKOUTL_ZC */
+#define WM8993_SPKOUTL_ZC_MASK                  0x0080  /* SPKOUTL_ZC */
+#define WM8993_SPKOUTL_ZC_SHIFT                      7  /* SPKOUTL_ZC */
+#define WM8993_SPKOUTL_ZC_WIDTH                      1  /* SPKOUTL_ZC */
+#define WM8993_SPKOUTL_MUTE_N                   0x0040  /* SPKOUTL_MUTE_N */
+#define WM8993_SPKOUTL_MUTE_N_MASK              0x0040  /* SPKOUTL_MUTE_N */
+#define WM8993_SPKOUTL_MUTE_N_SHIFT                  6  /* SPKOUTL_MUTE_N */
+#define WM8993_SPKOUTL_MUTE_N_WIDTH                  1  /* SPKOUTL_MUTE_N */
+#define WM8993_SPKOUTL_VOL_MASK                 0x003F  /* SPKOUTL_VOL - [5:0] */
+#define WM8993_SPKOUTL_VOL_SHIFT                     0  /* SPKOUTL_VOL - [5:0] */
+#define WM8993_SPKOUTL_VOL_WIDTH                     6  /* SPKOUTL_VOL - [5:0] */
+
+/*
+ * R39 (0x27) - Speaker Volume Right
+ */
+#define WM8993_SPKOUT_VU                        0x0100  /* SPKOUT_VU */
+#define WM8993_SPKOUT_VU_MASK                   0x0100  /* SPKOUT_VU */
+#define WM8993_SPKOUT_VU_SHIFT                       8  /* SPKOUT_VU */
+#define WM8993_SPKOUT_VU_WIDTH                       1  /* SPKOUT_VU */
+#define WM8993_SPKOUTR_ZC                       0x0080  /* SPKOUTR_ZC */
+#define WM8993_SPKOUTR_ZC_MASK                  0x0080  /* SPKOUTR_ZC */
+#define WM8993_SPKOUTR_ZC_SHIFT                      7  /* SPKOUTR_ZC */
+#define WM8993_SPKOUTR_ZC_WIDTH                      1  /* SPKOUTR_ZC */
+#define WM8993_SPKOUTR_MUTE_N                   0x0040  /* SPKOUTR_MUTE_N */
+#define WM8993_SPKOUTR_MUTE_N_MASK              0x0040  /* SPKOUTR_MUTE_N */
+#define WM8993_SPKOUTR_MUTE_N_SHIFT                  6  /* SPKOUTR_MUTE_N */
+#define WM8993_SPKOUTR_MUTE_N_WIDTH                  1  /* SPKOUTR_MUTE_N */
+#define WM8993_SPKOUTR_VOL_MASK                 0x003F  /* SPKOUTR_VOL - [5:0] */
+#define WM8993_SPKOUTR_VOL_SHIFT                     0  /* SPKOUTR_VOL - [5:0] */
+#define WM8993_SPKOUTR_VOL_WIDTH                     6  /* SPKOUTR_VOL - [5:0] */
+
+/*
+ * R40 (0x28) - Input Mixer2
+ */
+#define WM8993_IN2LP_TO_IN2L                    0x0080  /* IN2LP_TO_IN2L */
+#define WM8993_IN2LP_TO_IN2L_MASK               0x0080  /* IN2LP_TO_IN2L */
+#define WM8993_IN2LP_TO_IN2L_SHIFT                   7  /* IN2LP_TO_IN2L */
+#define WM8993_IN2LP_TO_IN2L_WIDTH                   1  /* IN2LP_TO_IN2L */
+#define WM8993_IN2LN_TO_IN2L                    0x0040  /* IN2LN_TO_IN2L */
+#define WM8993_IN2LN_TO_IN2L_MASK               0x0040  /* IN2LN_TO_IN2L */
+#define WM8993_IN2LN_TO_IN2L_SHIFT                   6  /* IN2LN_TO_IN2L */
+#define WM8993_IN2LN_TO_IN2L_WIDTH                   1  /* IN2LN_TO_IN2L */
+#define WM8993_IN1LP_TO_IN1L                    0x0020  /* IN1LP_TO_IN1L */
+#define WM8993_IN1LP_TO_IN1L_MASK               0x0020  /* IN1LP_TO_IN1L */
+#define WM8993_IN1LP_TO_IN1L_SHIFT                   5  /* IN1LP_TO_IN1L */
+#define WM8993_IN1LP_TO_IN1L_WIDTH                   1  /* IN1LP_TO_IN1L */
+#define WM8993_IN1LN_TO_IN1L                    0x0010  /* IN1LN_TO_IN1L */
+#define WM8993_IN1LN_TO_IN1L_MASK               0x0010  /* IN1LN_TO_IN1L */
+#define WM8993_IN1LN_TO_IN1L_SHIFT                   4  /* IN1LN_TO_IN1L */
+#define WM8993_IN1LN_TO_IN1L_WIDTH                   1  /* IN1LN_TO_IN1L */
+#define WM8993_IN2RP_TO_IN2R                    0x0008  /* IN2RP_TO_IN2R */
+#define WM8993_IN2RP_TO_IN2R_MASK               0x0008  /* IN2RP_TO_IN2R */
+#define WM8993_IN2RP_TO_IN2R_SHIFT                   3  /* IN2RP_TO_IN2R */
+#define WM8993_IN2RP_TO_IN2R_WIDTH                   1  /* IN2RP_TO_IN2R */
+#define WM8993_IN2RN_TO_IN2R                    0x0004  /* IN2RN_TO_IN2R */
+#define WM8993_IN2RN_TO_IN2R_MASK               0x0004  /* IN2RN_TO_IN2R */
+#define WM8993_IN2RN_TO_IN2R_SHIFT                   2  /* IN2RN_TO_IN2R */
+#define WM8993_IN2RN_TO_IN2R_WIDTH                   1  /* IN2RN_TO_IN2R */
+#define WM8993_IN1RP_TO_IN1R                    0x0002  /* IN1RP_TO_IN1R */
+#define WM8993_IN1RP_TO_IN1R_MASK               0x0002  /* IN1RP_TO_IN1R */
+#define WM8993_IN1RP_TO_IN1R_SHIFT                   1  /* IN1RP_TO_IN1R */
+#define WM8993_IN1RP_TO_IN1R_WIDTH                   1  /* IN1RP_TO_IN1R */
+#define WM8993_IN1RN_TO_IN1R                    0x0001  /* IN1RN_TO_IN1R */
+#define WM8993_IN1RN_TO_IN1R_MASK               0x0001  /* IN1RN_TO_IN1R */
+#define WM8993_IN1RN_TO_IN1R_SHIFT                   0  /* IN1RN_TO_IN1R */
+#define WM8993_IN1RN_TO_IN1R_WIDTH                   1  /* IN1RN_TO_IN1R */
+
+/*
+ * R41 (0x29) - Input Mixer3
+ */
+#define WM8993_IN2L_TO_MIXINL                   0x0100  /* IN2L_TO_MIXINL */
+#define WM8993_IN2L_TO_MIXINL_MASK              0x0100  /* IN2L_TO_MIXINL */
+#define WM8993_IN2L_TO_MIXINL_SHIFT                  8  /* IN2L_TO_MIXINL */
+#define WM8993_IN2L_TO_MIXINL_WIDTH                  1  /* IN2L_TO_MIXINL */
+#define WM8993_IN2L_MIXINL_VOL                  0x0080  /* IN2L_MIXINL_VOL */
+#define WM8993_IN2L_MIXINL_VOL_MASK             0x0080  /* IN2L_MIXINL_VOL */
+#define WM8993_IN2L_MIXINL_VOL_SHIFT                 7  /* IN2L_MIXINL_VOL */
+#define WM8993_IN2L_MIXINL_VOL_WIDTH                 1  /* IN2L_MIXINL_VOL */
+#define WM8993_IN1L_TO_MIXINL                   0x0020  /* IN1L_TO_MIXINL */
+#define WM8993_IN1L_TO_MIXINL_MASK              0x0020  /* IN1L_TO_MIXINL */
+#define WM8993_IN1L_TO_MIXINL_SHIFT                  5  /* IN1L_TO_MIXINL */
+#define WM8993_IN1L_TO_MIXINL_WIDTH                  1  /* IN1L_TO_MIXINL */
+#define WM8993_IN1L_MIXINL_VOL                  0x0010  /* IN1L_MIXINL_VOL */
+#define WM8993_IN1L_MIXINL_VOL_MASK             0x0010  /* IN1L_MIXINL_VOL */
+#define WM8993_IN1L_MIXINL_VOL_SHIFT                 4  /* IN1L_MIXINL_VOL */
+#define WM8993_IN1L_MIXINL_VOL_WIDTH                 1  /* IN1L_MIXINL_VOL */
+#define WM8993_MIXOUTL_MIXINL_VOL_MASK          0x0007  /* MIXOUTL_MIXINL_VOL - [2:0] */
+#define WM8993_MIXOUTL_MIXINL_VOL_SHIFT              0  /* MIXOUTL_MIXINL_VOL - [2:0] */
+#define WM8993_MIXOUTL_MIXINL_VOL_WIDTH              3  /* MIXOUTL_MIXINL_VOL - [2:0] */
+
+/*
+ * R42 (0x2A) - Input Mixer4
+ */
+#define WM8993_IN2R_TO_MIXINR                   0x0100  /* IN2R_TO_MIXINR */
+#define WM8993_IN2R_TO_MIXINR_MASK              0x0100  /* IN2R_TO_MIXINR */
+#define WM8993_IN2R_TO_MIXINR_SHIFT                  8  /* IN2R_TO_MIXINR */
+#define WM8993_IN2R_TO_MIXINR_WIDTH                  1  /* IN2R_TO_MIXINR */
+#define WM8993_IN2R_MIXINR_VOL                  0x0080  /* IN2R_MIXINR_VOL */
+#define WM8993_IN2R_MIXINR_VOL_MASK             0x0080  /* IN2R_MIXINR_VOL */
+#define WM8993_IN2R_MIXINR_VOL_SHIFT                 7  /* IN2R_MIXINR_VOL */
+#define WM8993_IN2R_MIXINR_VOL_WIDTH                 1  /* IN2R_MIXINR_VOL */
+#define WM8993_IN1R_TO_MIXINR                   0x0020  /* IN1R_TO_MIXINR */
+#define WM8993_IN1R_TO_MIXINR_MASK              0x0020  /* IN1R_TO_MIXINR */
+#define WM8993_IN1R_TO_MIXINR_SHIFT                  5  /* IN1R_TO_MIXINR */
+#define WM8993_IN1R_TO_MIXINR_WIDTH                  1  /* IN1R_TO_MIXINR */
+#define WM8993_IN1R_MIXINR_VOL                  0x0010  /* IN1R_MIXINR_VOL */
+#define WM8993_IN1R_MIXINR_VOL_MASK             0x0010  /* IN1R_MIXINR_VOL */
+#define WM8993_IN1R_MIXINR_VOL_SHIFT                 4  /* IN1R_MIXINR_VOL */
+#define WM8993_IN1R_MIXINR_VOL_WIDTH                 1  /* IN1R_MIXINR_VOL */
+#define WM8993_MIXOUTR_MIXINR_VOL_MASK          0x0007  /* MIXOUTR_MIXINR_VOL - [2:0] */
+#define WM8993_MIXOUTR_MIXINR_VOL_SHIFT              0  /* MIXOUTR_MIXINR_VOL - [2:0] */
+#define WM8993_MIXOUTR_MIXINR_VOL_WIDTH              3  /* MIXOUTR_MIXINR_VOL - [2:0] */
+
+/*
+ * R43 (0x2B) - Input Mixer5
+ */
+#define WM8993_IN1LP_MIXINL_VOL_MASK            0x01C0  /* IN1LP_MIXINL_VOL - [8:6] */
+#define WM8993_IN1LP_MIXINL_VOL_SHIFT                6  /* IN1LP_MIXINL_VOL - [8:6] */
+#define WM8993_IN1LP_MIXINL_VOL_WIDTH                3  /* IN1LP_MIXINL_VOL - [8:6] */
+#define WM8993_VRX_MIXINL_VOL_MASK              0x0007  /* VRX_MIXINL_VOL - [2:0] */
+#define WM8993_VRX_MIXINL_VOL_SHIFT                  0  /* VRX_MIXINL_VOL - [2:0] */
+#define WM8993_VRX_MIXINL_VOL_WIDTH                  3  /* VRX_MIXINL_VOL - [2:0] */
+
+/*
+ * R44 (0x2C) - Input Mixer6
+ */
+#define WM8993_IN1RP_MIXINR_VOL_MASK            0x01C0  /* IN1RP_MIXINR_VOL - [8:6] */
+#define WM8993_IN1RP_MIXINR_VOL_SHIFT                6  /* IN1RP_MIXINR_VOL - [8:6] */
+#define WM8993_IN1RP_MIXINR_VOL_WIDTH                3  /* IN1RP_MIXINR_VOL - [8:6] */
+#define WM8993_VRX_MIXINR_VOL_MASK              0x0007  /* VRX_MIXINR_VOL - [2:0] */
+#define WM8993_VRX_MIXINR_VOL_SHIFT                  0  /* VRX_MIXINR_VOL - [2:0] */
+#define WM8993_VRX_MIXINR_VOL_WIDTH                  3  /* VRX_MIXINR_VOL - [2:0] */
+
+/*
+ * R45 (0x2D) - Output Mixer1
+ */
+#define WM8993_DACL_TO_HPOUT1L                  0x0100  /* DACL_TO_HPOUT1L */
+#define WM8993_DACL_TO_HPOUT1L_MASK             0x0100  /* DACL_TO_HPOUT1L */
+#define WM8993_DACL_TO_HPOUT1L_SHIFT                 8  /* DACL_TO_HPOUT1L */
+#define WM8993_DACL_TO_HPOUT1L_WIDTH                 1  /* DACL_TO_HPOUT1L */
+#define WM8993_MIXINR_TO_MIXOUTL                0x0080  /* MIXINR_TO_MIXOUTL */
+#define WM8993_MIXINR_TO_MIXOUTL_MASK           0x0080  /* MIXINR_TO_MIXOUTL */
+#define WM8993_MIXINR_TO_MIXOUTL_SHIFT               7  /* MIXINR_TO_MIXOUTL */
+#define WM8993_MIXINR_TO_MIXOUTL_WIDTH               1  /* MIXINR_TO_MIXOUTL */
+#define WM8993_MIXINL_TO_MIXOUTL                0x0040  /* MIXINL_TO_MIXOUTL */
+#define WM8993_MIXINL_TO_MIXOUTL_MASK           0x0040  /* MIXINL_TO_MIXOUTL */
+#define WM8993_MIXINL_TO_MIXOUTL_SHIFT               6  /* MIXINL_TO_MIXOUTL */
+#define WM8993_MIXINL_TO_MIXOUTL_WIDTH               1  /* MIXINL_TO_MIXOUTL */
+#define WM8993_IN2RN_TO_MIXOUTL                 0x0020  /* IN2RN_TO_MIXOUTL */
+#define WM8993_IN2RN_TO_MIXOUTL_MASK            0x0020  /* IN2RN_TO_MIXOUTL */
+#define WM8993_IN2RN_TO_MIXOUTL_SHIFT                5  /* IN2RN_TO_MIXOUTL */
+#define WM8993_IN2RN_TO_MIXOUTL_WIDTH                1  /* IN2RN_TO_MIXOUTL */
+#define WM8993_IN2LN_TO_MIXOUTL                 0x0010  /* IN2LN_TO_MIXOUTL */
+#define WM8993_IN2LN_TO_MIXOUTL_MASK            0x0010  /* IN2LN_TO_MIXOUTL */
+#define WM8993_IN2LN_TO_MIXOUTL_SHIFT                4  /* IN2LN_TO_MIXOUTL */
+#define WM8993_IN2LN_TO_MIXOUTL_WIDTH                1  /* IN2LN_TO_MIXOUTL */
+#define WM8993_IN1R_TO_MIXOUTL                  0x0008  /* IN1R_TO_MIXOUTL */
+#define WM8993_IN1R_TO_MIXOUTL_MASK             0x0008  /* IN1R_TO_MIXOUTL */
+#define WM8993_IN1R_TO_MIXOUTL_SHIFT                 3  /* IN1R_TO_MIXOUTL */
+#define WM8993_IN1R_TO_MIXOUTL_WIDTH                 1  /* IN1R_TO_MIXOUTL */
+#define WM8993_IN1L_TO_MIXOUTL                  0x0004  /* IN1L_TO_MIXOUTL */
+#define WM8993_IN1L_TO_MIXOUTL_MASK             0x0004  /* IN1L_TO_MIXOUTL */
+#define WM8993_IN1L_TO_MIXOUTL_SHIFT                 2  /* IN1L_TO_MIXOUTL */
+#define WM8993_IN1L_TO_MIXOUTL_WIDTH                 1  /* IN1L_TO_MIXOUTL */
+#define WM8993_IN2LP_TO_MIXOUTL                 0x0002  /* IN2LP_TO_MIXOUTL */
+#define WM8993_IN2LP_TO_MIXOUTL_MASK            0x0002  /* IN2LP_TO_MIXOUTL */
+#define WM8993_IN2LP_TO_MIXOUTL_SHIFT                1  /* IN2LP_TO_MIXOUTL */
+#define WM8993_IN2LP_TO_MIXOUTL_WIDTH                1  /* IN2LP_TO_MIXOUTL */
+#define WM8993_DACL_TO_MIXOUTL                  0x0001  /* DACL_TO_MIXOUTL */
+#define WM8993_DACL_TO_MIXOUTL_MASK             0x0001  /* DACL_TO_MIXOUTL */
+#define WM8993_DACL_TO_MIXOUTL_SHIFT                 0  /* DACL_TO_MIXOUTL */
+#define WM8993_DACL_TO_MIXOUTL_WIDTH                 1  /* DACL_TO_MIXOUTL */
+
+/*
+ * R46 (0x2E) - Output Mixer2
+ */
+#define WM8993_DACR_TO_HPOUT1R                  0x0100  /* DACR_TO_HPOUT1R */
+#define WM8993_DACR_TO_HPOUT1R_MASK             0x0100  /* DACR_TO_HPOUT1R */
+#define WM8993_DACR_TO_HPOUT1R_SHIFT                 8  /* DACR_TO_HPOUT1R */
+#define WM8993_DACR_TO_HPOUT1R_WIDTH                 1  /* DACR_TO_HPOUT1R */
+#define WM8993_MIXINL_TO_MIXOUTR                0x0080  /* MIXINL_TO_MIXOUTR */
+#define WM8993_MIXINL_TO_MIXOUTR_MASK           0x0080  /* MIXINL_TO_MIXOUTR */
+#define WM8993_MIXINL_TO_MIXOUTR_SHIFT               7  /* MIXINL_TO_MIXOUTR */
+#define WM8993_MIXINL_TO_MIXOUTR_WIDTH               1  /* MIXINL_TO_MIXOUTR */
+#define WM8993_MIXINR_TO_MIXOUTR                0x0040  /* MIXINR_TO_MIXOUTR */
+#define WM8993_MIXINR_TO_MIXOUTR_MASK           0x0040  /* MIXINR_TO_MIXOUTR */
+#define WM8993_MIXINR_TO_MIXOUTR_SHIFT               6  /* MIXINR_TO_MIXOUTR */
+#define WM8993_MIXINR_TO_MIXOUTR_WIDTH               1  /* MIXINR_TO_MIXOUTR */
+#define WM8993_IN2LN_TO_MIXOUTR                 0x0020  /* IN2LN_TO_MIXOUTR */
+#define WM8993_IN2LN_TO_MIXOUTR_MASK            0x0020  /* IN2LN_TO_MIXOUTR */
+#define WM8993_IN2LN_TO_MIXOUTR_SHIFT                5  /* IN2LN_TO_MIXOUTR */
+#define WM8993_IN2LN_TO_MIXOUTR_WIDTH                1  /* IN2LN_TO_MIXOUTR */
+#define WM8993_IN2RN_TO_MIXOUTR                 0x0010  /* IN2RN_TO_MIXOUTR */
+#define WM8993_IN2RN_TO_MIXOUTR_MASK            0x0010  /* IN2RN_TO_MIXOUTR */
+#define WM8993_IN2RN_TO_MIXOUTR_SHIFT                4  /* IN2RN_TO_MIXOUTR */
+#define WM8993_IN2RN_TO_MIXOUTR_WIDTH                1  /* IN2RN_TO_MIXOUTR */
+#define WM8993_IN1L_TO_MIXOUTR                  0x0008  /* IN1L_TO_MIXOUTR */
+#define WM8993_IN1L_TO_MIXOUTR_MASK             0x0008  /* IN1L_TO_MIXOUTR */
+#define WM8993_IN1L_TO_MIXOUTR_SHIFT                 3  /* IN1L_TO_MIXOUTR */
+#define WM8993_IN1L_TO_MIXOUTR_WIDTH                 1  /* IN1L_TO_MIXOUTR */
+#define WM8993_IN1R_TO_MIXOUTR                  0x0004  /* IN1R_TO_MIXOUTR */
+#define WM8993_IN1R_TO_MIXOUTR_MASK             0x0004  /* IN1R_TO_MIXOUTR */
+#define WM8993_IN1R_TO_MIXOUTR_SHIFT                 2  /* IN1R_TO_MIXOUTR */
+#define WM8993_IN1R_TO_MIXOUTR_WIDTH                 1  /* IN1R_TO_MIXOUTR */
+#define WM8993_IN2RP_TO_MIXOUTR                 0x0002  /* IN2RP_TO_MIXOUTR */
+#define WM8993_IN2RP_TO_MIXOUTR_MASK            0x0002  /* IN2RP_TO_MIXOUTR */
+#define WM8993_IN2RP_TO_MIXOUTR_SHIFT                1  /* IN2RP_TO_MIXOUTR */
+#define WM8993_IN2RP_TO_MIXOUTR_WIDTH                1  /* IN2RP_TO_MIXOUTR */
+#define WM8993_DACR_TO_MIXOUTR                  0x0001  /* DACR_TO_MIXOUTR */
+#define WM8993_DACR_TO_MIXOUTR_MASK             0x0001  /* DACR_TO_MIXOUTR */
+#define WM8993_DACR_TO_MIXOUTR_SHIFT                 0  /* DACR_TO_MIXOUTR */
+#define WM8993_DACR_TO_MIXOUTR_WIDTH                 1  /* DACR_TO_MIXOUTR */
+
+/*
+ * R47 (0x2F) - Output Mixer3
+ */
+#define WM8993_IN2LP_MIXOUTL_VOL_MASK           0x0E00  /* IN2LP_MIXOUTL_VOL - [11:9] */
+#define WM8993_IN2LP_MIXOUTL_VOL_SHIFT               9  /* IN2LP_MIXOUTL_VOL - [11:9] */
+#define WM8993_IN2LP_MIXOUTL_VOL_WIDTH               3  /* IN2LP_MIXOUTL_VOL - [11:9] */
+#define WM8993_IN2LN_MIXOUTL_VOL_MASK           0x01C0  /* IN2LN_MIXOUTL_VOL - [8:6] */
+#define WM8993_IN2LN_MIXOUTL_VOL_SHIFT               6  /* IN2LN_MIXOUTL_VOL - [8:6] */
+#define WM8993_IN2LN_MIXOUTL_VOL_WIDTH               3  /* IN2LN_MIXOUTL_VOL - [8:6] */
+#define WM8993_IN1R_MIXOUTL_VOL_MASK            0x0038  /* IN1R_MIXOUTL_VOL - [5:3] */
+#define WM8993_IN1R_MIXOUTL_VOL_SHIFT                3  /* IN1R_MIXOUTL_VOL - [5:3] */
+#define WM8993_IN1R_MIXOUTL_VOL_WIDTH                3  /* IN1R_MIXOUTL_VOL - [5:3] */
+#define WM8993_IN1L_MIXOUTL_VOL_MASK            0x0007  /* IN1L_MIXOUTL_VOL - [2:0] */
+#define WM8993_IN1L_MIXOUTL_VOL_SHIFT                0  /* IN1L_MIXOUTL_VOL - [2:0] */
+#define WM8993_IN1L_MIXOUTL_VOL_WIDTH                3  /* IN1L_MIXOUTL_VOL - [2:0] */
+
+/*
+ * R48 (0x30) - Output Mixer4
+ */
+#define WM8993_IN2RP_MIXOUTR_VOL_MASK           0x0E00  /* IN2RP_MIXOUTR_VOL - [11:9] */
+#define WM8993_IN2RP_MIXOUTR_VOL_SHIFT               9  /* IN2RP_MIXOUTR_VOL - [11:9] */
+#define WM8993_IN2RP_MIXOUTR_VOL_WIDTH               3  /* IN2RP_MIXOUTR_VOL - [11:9] */
+#define WM8993_IN2RN_MIXOUTR_VOL_MASK           0x01C0  /* IN2RN_MIXOUTR_VOL - [8:6] */
+#define WM8993_IN2RN_MIXOUTR_VOL_SHIFT               6  /* IN2RN_MIXOUTR_VOL - [8:6] */
+#define WM8993_IN2RN_MIXOUTR_VOL_WIDTH               3  /* IN2RN_MIXOUTR_VOL - [8:6] */
+#define WM8993_IN1L_MIXOUTR_VOL_MASK            0x0038  /* IN1L_MIXOUTR_VOL - [5:3] */
+#define WM8993_IN1L_MIXOUTR_VOL_SHIFT                3  /* IN1L_MIXOUTR_VOL - [5:3] */
+#define WM8993_IN1L_MIXOUTR_VOL_WIDTH                3  /* IN1L_MIXOUTR_VOL - [5:3] */
+#define WM8993_IN1R_MIXOUTR_VOL_MASK            0x0007  /* IN1R_MIXOUTR_VOL - [2:0] */
+#define WM8993_IN1R_MIXOUTR_VOL_SHIFT                0  /* IN1R_MIXOUTR_VOL - [2:0] */
+#define WM8993_IN1R_MIXOUTR_VOL_WIDTH                3  /* IN1R_MIXOUTR_VOL - [2:0] */
+
+/*
+ * R49 (0x31) - Output Mixer5
+ */
+#define WM8993_DACL_MIXOUTL_VOL_MASK            0x0E00  /* DACL_MIXOUTL_VOL - [11:9] */
+#define WM8993_DACL_MIXOUTL_VOL_SHIFT                9  /* DACL_MIXOUTL_VOL - [11:9] */
+#define WM8993_DACL_MIXOUTL_VOL_WIDTH                3  /* DACL_MIXOUTL_VOL - [11:9] */
+#define WM8993_IN2RN_MIXOUTL_VOL_MASK           0x01C0  /* IN2RN_MIXOUTL_VOL - [8:6] */
+#define WM8993_IN2RN_MIXOUTL_VOL_SHIFT               6  /* IN2RN_MIXOUTL_VOL - [8:6] */
+#define WM8993_IN2RN_MIXOUTL_VOL_WIDTH               3  /* IN2RN_MIXOUTL_VOL - [8:6] */
+#define WM8993_MIXINR_MIXOUTL_VOL_MASK          0x0038  /* MIXINR_MIXOUTL_VOL - [5:3] */
+#define WM8993_MIXINR_MIXOUTL_VOL_SHIFT              3  /* MIXINR_MIXOUTL_VOL - [5:3] */
+#define WM8993_MIXINR_MIXOUTL_VOL_WIDTH              3  /* MIXINR_MIXOUTL_VOL - [5:3] */
+#define WM8993_MIXINL_MIXOUTL_VOL_MASK          0x0007  /* MIXINL_MIXOUTL_VOL - [2:0] */
+#define WM8993_MIXINL_MIXOUTL_VOL_SHIFT              0  /* MIXINL_MIXOUTL_VOL - [2:0] */
+#define WM8993_MIXINL_MIXOUTL_VOL_WIDTH              3  /* MIXINL_MIXOUTL_VOL - [2:0] */
+
+/*
+ * R50 (0x32) - Output Mixer6
+ */
+#define WM8993_DACR_MIXOUTR_VOL_MASK            0x0E00  /* DACR_MIXOUTR_VOL - [11:9] */
+#define WM8993_DACR_MIXOUTR_VOL_SHIFT                9  /* DACR_MIXOUTR_VOL - [11:9] */
+#define WM8993_DACR_MIXOUTR_VOL_WIDTH                3  /* DACR_MIXOUTR_VOL - [11:9] */
+#define WM8993_IN2LN_MIXOUTR_VOL_MASK           0x01C0  /* IN2LN_MIXOUTR_VOL - [8:6] */
+#define WM8993_IN2LN_MIXOUTR_VOL_SHIFT               6  /* IN2LN_MIXOUTR_VOL - [8:6] */
+#define WM8993_IN2LN_MIXOUTR_VOL_WIDTH               3  /* IN2LN_MIXOUTR_VOL - [8:6] */
+#define WM8993_MIXINL_MIXOUTR_VOL_MASK          0x0038  /* MIXINL_MIXOUTR_VOL - [5:3] */
+#define WM8993_MIXINL_MIXOUTR_VOL_SHIFT              3  /* MIXINL_MIXOUTR_VOL - [5:3] */
+#define WM8993_MIXINL_MIXOUTR_VOL_WIDTH              3  /* MIXINL_MIXOUTR_VOL - [5:3] */
+#define WM8993_MIXINR_MIXOUTR_VOL_MASK          0x0007  /* MIXINR_MIXOUTR_VOL - [2:0] */
+#define WM8993_MIXINR_MIXOUTR_VOL_SHIFT              0  /* MIXINR_MIXOUTR_VOL - [2:0] */
+#define WM8993_MIXINR_MIXOUTR_VOL_WIDTH              3  /* MIXINR_MIXOUTR_VOL - [2:0] */
+
+/*
+ * R51 (0x33) - HPOUT2 Mixer
+ */
+#define WM8993_VRX_TO_HPOUT2                    0x0020  /* VRX_TO_HPOUT2 */
+#define WM8993_VRX_TO_HPOUT2_MASK               0x0020  /* VRX_TO_HPOUT2 */
+#define WM8993_VRX_TO_HPOUT2_SHIFT                   5  /* VRX_TO_HPOUT2 */
+#define WM8993_VRX_TO_HPOUT2_WIDTH                   1  /* VRX_TO_HPOUT2 */
+#define WM8993_MIXOUTLVOL_TO_HPOUT2             0x0010  /* MIXOUTLVOL_TO_HPOUT2 */
+#define WM8993_MIXOUTLVOL_TO_HPOUT2_MASK        0x0010  /* MIXOUTLVOL_TO_HPOUT2 */
+#define WM8993_MIXOUTLVOL_TO_HPOUT2_SHIFT            4  /* MIXOUTLVOL_TO_HPOUT2 */
+#define WM8993_MIXOUTLVOL_TO_HPOUT2_WIDTH            1  /* MIXOUTLVOL_TO_HPOUT2 */
+#define WM8993_MIXOUTRVOL_TO_HPOUT2             0x0008  /* MIXOUTRVOL_TO_HPOUT2 */
+#define WM8993_MIXOUTRVOL_TO_HPOUT2_MASK        0x0008  /* MIXOUTRVOL_TO_HPOUT2 */
+#define WM8993_MIXOUTRVOL_TO_HPOUT2_SHIFT            3  /* MIXOUTRVOL_TO_HPOUT2 */
+#define WM8993_MIXOUTRVOL_TO_HPOUT2_WIDTH            1  /* MIXOUTRVOL_TO_HPOUT2 */
+
+/*
+ * R52 (0x34) - Line Mixer1
+ */
+#define WM8993_MIXOUTL_TO_LINEOUT1N             0x0040  /* MIXOUTL_TO_LINEOUT1N */
+#define WM8993_MIXOUTL_TO_LINEOUT1N_MASK        0x0040  /* MIXOUTL_TO_LINEOUT1N */
+#define WM8993_MIXOUTL_TO_LINEOUT1N_SHIFT            6  /* MIXOUTL_TO_LINEOUT1N */
+#define WM8993_MIXOUTL_TO_LINEOUT1N_WIDTH            1  /* MIXOUTL_TO_LINEOUT1N */
+#define WM8993_MIXOUTR_TO_LINEOUT1N             0x0020  /* MIXOUTR_TO_LINEOUT1N */
+#define WM8993_MIXOUTR_TO_LINEOUT1N_MASK        0x0020  /* MIXOUTR_TO_LINEOUT1N */
+#define WM8993_MIXOUTR_TO_LINEOUT1N_SHIFT            5  /* MIXOUTR_TO_LINEOUT1N */
+#define WM8993_MIXOUTR_TO_LINEOUT1N_WIDTH            1  /* MIXOUTR_TO_LINEOUT1N */
+#define WM8993_LINEOUT1_MODE                    0x0010  /* LINEOUT1_MODE */
+#define WM8993_LINEOUT1_MODE_MASK               0x0010  /* LINEOUT1_MODE */
+#define WM8993_LINEOUT1_MODE_SHIFT                   4  /* LINEOUT1_MODE */
+#define WM8993_LINEOUT1_MODE_WIDTH                   1  /* LINEOUT1_MODE */
+#define WM8993_IN1R_TO_LINEOUT1P                0x0004  /* IN1R_TO_LINEOUT1P */
+#define WM8993_IN1R_TO_LINEOUT1P_MASK           0x0004  /* IN1R_TO_LINEOUT1P */
+#define WM8993_IN1R_TO_LINEOUT1P_SHIFT               2  /* IN1R_TO_LINEOUT1P */
+#define WM8993_IN1R_TO_LINEOUT1P_WIDTH               1  /* IN1R_TO_LINEOUT1P */
+#define WM8993_IN1L_TO_LINEOUT1P                0x0002  /* IN1L_TO_LINEOUT1P */
+#define WM8993_IN1L_TO_LINEOUT1P_MASK           0x0002  /* IN1L_TO_LINEOUT1P */
+#define WM8993_IN1L_TO_LINEOUT1P_SHIFT               1  /* IN1L_TO_LINEOUT1P */
+#define WM8993_IN1L_TO_LINEOUT1P_WIDTH               1  /* IN1L_TO_LINEOUT1P */
+#define WM8993_MIXOUTL_TO_LINEOUT1P             0x0001  /* MIXOUTL_TO_LINEOUT1P */
+#define WM8993_MIXOUTL_TO_LINEOUT1P_MASK        0x0001  /* MIXOUTL_TO_LINEOUT1P */
+#define WM8993_MIXOUTL_TO_LINEOUT1P_SHIFT            0  /* MIXOUTL_TO_LINEOUT1P */
+#define WM8993_MIXOUTL_TO_LINEOUT1P_WIDTH            1  /* MIXOUTL_TO_LINEOUT1P */
+
+/*
+ * R53 (0x35) - Line Mixer2
+ */
+#define WM8993_MIXOUTR_TO_LINEOUT2N             0x0040  /* MIXOUTR_TO_LINEOUT2N */
+#define WM8993_MIXOUTR_TO_LINEOUT2N_MASK        0x0040  /* MIXOUTR_TO_LINEOUT2N */
+#define WM8993_MIXOUTR_TO_LINEOUT2N_SHIFT            6  /* MIXOUTR_TO_LINEOUT2N */
+#define WM8993_MIXOUTR_TO_LINEOUT2N_WIDTH            1  /* MIXOUTR_TO_LINEOUT2N */
+#define WM8993_MIXOUTL_TO_LINEOUT2N             0x0020  /* MIXOUTL_TO_LINEOUT2N */
+#define WM8993_MIXOUTL_TO_LINEOUT2N_MASK        0x0020  /* MIXOUTL_TO_LINEOUT2N */
+#define WM8993_MIXOUTL_TO_LINEOUT2N_SHIFT            5  /* MIXOUTL_TO_LINEOUT2N */
+#define WM8993_MIXOUTL_TO_LINEOUT2N_WIDTH            1  /* MIXOUTL_TO_LINEOUT2N */
+#define WM8993_LINEOUT2_MODE                    0x0010  /* LINEOUT2_MODE */
+#define WM8993_LINEOUT2_MODE_MASK               0x0010  /* LINEOUT2_MODE */
+#define WM8993_LINEOUT2_MODE_SHIFT                   4  /* LINEOUT2_MODE */
+#define WM8993_LINEOUT2_MODE_WIDTH                   1  /* LINEOUT2_MODE */
+#define WM8993_IN1L_TO_LINEOUT2P                0x0004  /* IN1L_TO_LINEOUT2P */
+#define WM8993_IN1L_TO_LINEOUT2P_MASK           0x0004  /* IN1L_TO_LINEOUT2P */
+#define WM8993_IN1L_TO_LINEOUT2P_SHIFT               2  /* IN1L_TO_LINEOUT2P */
+#define WM8993_IN1L_TO_LINEOUT2P_WIDTH               1  /* IN1L_TO_LINEOUT2P */
+#define WM8993_IN1R_TO_LINEOUT2P                0x0002  /* IN1R_TO_LINEOUT2P */
+#define WM8993_IN1R_TO_LINEOUT2P_MASK           0x0002  /* IN1R_TO_LINEOUT2P */
+#define WM8993_IN1R_TO_LINEOUT2P_SHIFT               1  /* IN1R_TO_LINEOUT2P */
+#define WM8993_IN1R_TO_LINEOUT2P_WIDTH               1  /* IN1R_TO_LINEOUT2P */
+#define WM8993_MIXOUTR_TO_LINEOUT2P             0x0001  /* MIXOUTR_TO_LINEOUT2P */
+#define WM8993_MIXOUTR_TO_LINEOUT2P_MASK        0x0001  /* MIXOUTR_TO_LINEOUT2P */
+#define WM8993_MIXOUTR_TO_LINEOUT2P_SHIFT            0  /* MIXOUTR_TO_LINEOUT2P */
+#define WM8993_MIXOUTR_TO_LINEOUT2P_WIDTH            1  /* MIXOUTR_TO_LINEOUT2P */
+
+/*
+ * R54 (0x36) - Speaker Mixer
+ */
+#define WM8993_SPKAB_REF_SEL                    0x0100  /* SPKAB_REF_SEL */
+#define WM8993_SPKAB_REF_SEL_MASK               0x0100  /* SPKAB_REF_SEL */
+#define WM8993_SPKAB_REF_SEL_SHIFT                   8  /* SPKAB_REF_SEL */
+#define WM8993_SPKAB_REF_SEL_WIDTH                   1  /* SPKAB_REF_SEL */
+#define WM8993_MIXINL_TO_SPKMIXL                0x0080  /* MIXINL_TO_SPKMIXL */
+#define WM8993_MIXINL_TO_SPKMIXL_MASK           0x0080  /* MIXINL_TO_SPKMIXL */
+#define WM8993_MIXINL_TO_SPKMIXL_SHIFT               7  /* MIXINL_TO_SPKMIXL */
+#define WM8993_MIXINL_TO_SPKMIXL_WIDTH               1  /* MIXINL_TO_SPKMIXL */
+#define WM8993_MIXINR_TO_SPKMIXR                0x0040  /* MIXINR_TO_SPKMIXR */
+#define WM8993_MIXINR_TO_SPKMIXR_MASK           0x0040  /* MIXINR_TO_SPKMIXR */
+#define WM8993_MIXINR_TO_SPKMIXR_SHIFT               6  /* MIXINR_TO_SPKMIXR */
+#define WM8993_MIXINR_TO_SPKMIXR_WIDTH               1  /* MIXINR_TO_SPKMIXR */
+#define WM8993_IN1LP_TO_SPKMIXL                 0x0020  /* IN1LP_TO_SPKMIXL */
+#define WM8993_IN1LP_TO_SPKMIXL_MASK            0x0020  /* IN1LP_TO_SPKMIXL */
+#define WM8993_IN1LP_TO_SPKMIXL_SHIFT                5  /* IN1LP_TO_SPKMIXL */
+#define WM8993_IN1LP_TO_SPKMIXL_WIDTH                1  /* IN1LP_TO_SPKMIXL */
+#define WM8993_IN1RP_TO_SPKMIXR                 0x0010  /* IN1RP_TO_SPKMIXR */
+#define WM8993_IN1RP_TO_SPKMIXR_MASK            0x0010  /* IN1RP_TO_SPKMIXR */
+#define WM8993_IN1RP_TO_SPKMIXR_SHIFT                4  /* IN1RP_TO_SPKMIXR */
+#define WM8993_IN1RP_TO_SPKMIXR_WIDTH                1  /* IN1RP_TO_SPKMIXR */
+#define WM8993_MIXOUTL_TO_SPKMIXL               0x0008  /* MIXOUTL_TO_SPKMIXL */
+#define WM8993_MIXOUTL_TO_SPKMIXL_MASK          0x0008  /* MIXOUTL_TO_SPKMIXL */
+#define WM8993_MIXOUTL_TO_SPKMIXL_SHIFT              3  /* MIXOUTL_TO_SPKMIXL */
+#define WM8993_MIXOUTL_TO_SPKMIXL_WIDTH              1  /* MIXOUTL_TO_SPKMIXL */
+#define WM8993_MIXOUTR_TO_SPKMIXR               0x0004  /* MIXOUTR_TO_SPKMIXR */
+#define WM8993_MIXOUTR_TO_SPKMIXR_MASK          0x0004  /* MIXOUTR_TO_SPKMIXR */
+#define WM8993_MIXOUTR_TO_SPKMIXR_SHIFT              2  /* MIXOUTR_TO_SPKMIXR */
+#define WM8993_MIXOUTR_TO_SPKMIXR_WIDTH              1  /* MIXOUTR_TO_SPKMIXR */
+#define WM8993_DACL_TO_SPKMIXL                  0x0002  /* DACL_TO_SPKMIXL */
+#define WM8993_DACL_TO_SPKMIXL_MASK             0x0002  /* DACL_TO_SPKMIXL */
+#define WM8993_DACL_TO_SPKMIXL_SHIFT                 1  /* DACL_TO_SPKMIXL */
+#define WM8993_DACL_TO_SPKMIXL_WIDTH                 1  /* DACL_TO_SPKMIXL */
+#define WM8993_DACR_TO_SPKMIXR                  0x0001  /* DACR_TO_SPKMIXR */
+#define WM8993_DACR_TO_SPKMIXR_MASK             0x0001  /* DACR_TO_SPKMIXR */
+#define WM8993_DACR_TO_SPKMIXR_SHIFT                 0  /* DACR_TO_SPKMIXR */
+#define WM8993_DACR_TO_SPKMIXR_WIDTH                 1  /* DACR_TO_SPKMIXR */
+
+/*
+ * R55 (0x37) - Additional Control
+ */
+#define WM8993_LINEOUT1_FB                      0x0080  /* LINEOUT1_FB */
+#define WM8993_LINEOUT1_FB_MASK                 0x0080  /* LINEOUT1_FB */
+#define WM8993_LINEOUT1_FB_SHIFT                     7  /* LINEOUT1_FB */
+#define WM8993_LINEOUT1_FB_WIDTH                     1  /* LINEOUT1_FB */
+#define WM8993_LINEOUT2_FB                      0x0040  /* LINEOUT2_FB */
+#define WM8993_LINEOUT2_FB_MASK                 0x0040  /* LINEOUT2_FB */
+#define WM8993_LINEOUT2_FB_SHIFT                     6  /* LINEOUT2_FB */
+#define WM8993_LINEOUT2_FB_WIDTH                     1  /* LINEOUT2_FB */
+#define WM8993_VROI                             0x0001  /* VROI */
+#define WM8993_VROI_MASK                        0x0001  /* VROI */
+#define WM8993_VROI_SHIFT                            0  /* VROI */
+#define WM8993_VROI_WIDTH                            1  /* VROI */
+
+/*
+ * R56 (0x38) - AntiPOP1
+ */
+#define WM8993_LINEOUT_VMID_BUF_ENA             0x0080  /* LINEOUT_VMID_BUF_ENA */
+#define WM8993_LINEOUT_VMID_BUF_ENA_MASK        0x0080  /* LINEOUT_VMID_BUF_ENA */
+#define WM8993_LINEOUT_VMID_BUF_ENA_SHIFT            7  /* LINEOUT_VMID_BUF_ENA */
+#define WM8993_LINEOUT_VMID_BUF_ENA_WIDTH            1  /* LINEOUT_VMID_BUF_ENA */
+#define WM8993_HPOUT2_IN_ENA                    0x0040  /* HPOUT2_IN_ENA */
+#define WM8993_HPOUT2_IN_ENA_MASK               0x0040  /* HPOUT2_IN_ENA */
+#define WM8993_HPOUT2_IN_ENA_SHIFT                   6  /* HPOUT2_IN_ENA */
+#define WM8993_HPOUT2_IN_ENA_WIDTH                   1  /* HPOUT2_IN_ENA */
+#define WM8993_LINEOUT1_DISCH                   0x0020  /* LINEOUT1_DISCH */
+#define WM8993_LINEOUT1_DISCH_MASK              0x0020  /* LINEOUT1_DISCH */
+#define WM8993_LINEOUT1_DISCH_SHIFT                  5  /* LINEOUT1_DISCH */
+#define WM8993_LINEOUT1_DISCH_WIDTH                  1  /* LINEOUT1_DISCH */
+#define WM8993_LINEOUT2_DISCH                   0x0010  /* LINEOUT2_DISCH */
+#define WM8993_LINEOUT2_DISCH_MASK              0x0010  /* LINEOUT2_DISCH */
+#define WM8993_LINEOUT2_DISCH_SHIFT                  4  /* LINEOUT2_DISCH */
+#define WM8993_LINEOUT2_DISCH_WIDTH                  1  /* LINEOUT2_DISCH */
+
+/*
+ * R57 (0x39) - AntiPOP2
+ */
+#define WM8993_VMID_RAMP_MASK                   0x0060  /* VMID_RAMP - [6:5] */
+#define WM8993_VMID_RAMP_SHIFT                       5  /* VMID_RAMP - [6:5] */
+#define WM8993_VMID_RAMP_WIDTH                       2  /* VMID_RAMP - [6:5] */
+#define WM8993_VMID_BUF_ENA                     0x0008  /* VMID_BUF_ENA */
+#define WM8993_VMID_BUF_ENA_MASK                0x0008  /* VMID_BUF_ENA */
+#define WM8993_VMID_BUF_ENA_SHIFT                    3  /* VMID_BUF_ENA */
+#define WM8993_VMID_BUF_ENA_WIDTH                    1  /* VMID_BUF_ENA */
+#define WM8993_STARTUP_BIAS_ENA                 0x0004  /* STARTUP_BIAS_ENA */
+#define WM8993_STARTUP_BIAS_ENA_MASK            0x0004  /* STARTUP_BIAS_ENA */
+#define WM8993_STARTUP_BIAS_ENA_SHIFT                2  /* STARTUP_BIAS_ENA */
+#define WM8993_STARTUP_BIAS_ENA_WIDTH                1  /* STARTUP_BIAS_ENA */
+#define WM8993_BIAS_SRC                         0x0002  /* BIAS_SRC */
+#define WM8993_BIAS_SRC_MASK                    0x0002  /* BIAS_SRC */
+#define WM8993_BIAS_SRC_SHIFT                        1  /* BIAS_SRC */
+#define WM8993_BIAS_SRC_WIDTH                        1  /* BIAS_SRC */
+#define WM8993_VMID_DISCH                       0x0001  /* VMID_DISCH */
+#define WM8993_VMID_DISCH_MASK                  0x0001  /* VMID_DISCH */
+#define WM8993_VMID_DISCH_SHIFT                      0  /* VMID_DISCH */
+#define WM8993_VMID_DISCH_WIDTH                      1  /* VMID_DISCH */
+
+/*
+ * R58 (0x3A) - MICBIAS
+ */
+#define WM8993_JD_SCTHR_MASK                    0x00C0  /* JD_SCTHR - [7:6] */
+#define WM8993_JD_SCTHR_SHIFT                        6  /* JD_SCTHR - [7:6] */
+#define WM8993_JD_SCTHR_WIDTH                        2  /* JD_SCTHR - [7:6] */
+#define WM8993_JD_THR_MASK                      0x0030  /* JD_THR - [5:4] */
+#define WM8993_JD_THR_SHIFT                          4  /* JD_THR - [5:4] */
+#define WM8993_JD_THR_WIDTH                          2  /* JD_THR - [5:4] */
+#define WM8993_JD_ENA                           0x0004  /* JD_ENA */
+#define WM8993_JD_ENA_MASK                      0x0004  /* JD_ENA */
+#define WM8993_JD_ENA_SHIFT                          2  /* JD_ENA */
+#define WM8993_JD_ENA_WIDTH                          1  /* JD_ENA */
+#define WM8993_MICB2_LVL                        0x0002  /* MICB2_LVL */
+#define WM8993_MICB2_LVL_MASK                   0x0002  /* MICB2_LVL */
+#define WM8993_MICB2_LVL_SHIFT                       1  /* MICB2_LVL */
+#define WM8993_MICB2_LVL_WIDTH                       1  /* MICB2_LVL */
+#define WM8993_MICB1_LVL                        0x0001  /* MICB1_LVL */
+#define WM8993_MICB1_LVL_MASK                   0x0001  /* MICB1_LVL */
+#define WM8993_MICB1_LVL_SHIFT                       0  /* MICB1_LVL */
+#define WM8993_MICB1_LVL_WIDTH                       1  /* MICB1_LVL */
+
+/*
+ * R60 (0x3C) - FLL Control 1
+ */
+#define WM8993_FLL_FRAC                         0x0004  /* FLL_FRAC */
+#define WM8993_FLL_FRAC_MASK                    0x0004  /* FLL_FRAC */
+#define WM8993_FLL_FRAC_SHIFT                        2  /* FLL_FRAC */
+#define WM8993_FLL_FRAC_WIDTH                        1  /* FLL_FRAC */
+#define WM8993_FLL_OSC_ENA                      0x0002  /* FLL_OSC_ENA */
+#define WM8993_FLL_OSC_ENA_MASK                 0x0002  /* FLL_OSC_ENA */
+#define WM8993_FLL_OSC_ENA_SHIFT                     1  /* FLL_OSC_ENA */
+#define WM8993_FLL_OSC_ENA_WIDTH                     1  /* FLL_OSC_ENA */
+#define WM8993_FLL_ENA                          0x0001  /* FLL_ENA */
+#define WM8993_FLL_ENA_MASK                     0x0001  /* FLL_ENA */
+#define WM8993_FLL_ENA_SHIFT                         0  /* FLL_ENA */
+#define WM8993_FLL_ENA_WIDTH                         1  /* FLL_ENA */
+
+/*
+ * R61 (0x3D) - FLL Control 2
+ */
+#define WM8993_FLL_OUTDIV_MASK                  0x0700  /* FLL_OUTDIV - [10:8] */
+#define WM8993_FLL_OUTDIV_SHIFT                      8  /* FLL_OUTDIV - [10:8] */
+#define WM8993_FLL_OUTDIV_WIDTH                      3  /* FLL_OUTDIV - [10:8] */
+#define WM8993_FLL_CTRL_RATE_MASK               0x0070  /* FLL_CTRL_RATE - [6:4] */
+#define WM8993_FLL_CTRL_RATE_SHIFT                   4  /* FLL_CTRL_RATE - [6:4] */
+#define WM8993_FLL_CTRL_RATE_WIDTH                   3  /* FLL_CTRL_RATE - [6:4] */
+#define WM8993_FLL_FRATIO_MASK                  0x0007  /* FLL_FRATIO - [2:0] */
+#define WM8993_FLL_FRATIO_SHIFT                      0  /* FLL_FRATIO - [2:0] */
+#define WM8993_FLL_FRATIO_WIDTH                      3  /* FLL_FRATIO - [2:0] */
+
+/*
+ * R62 (0x3E) - FLL Control 3
+ */
+#define WM8993_FLL_K_MASK                       0xFFFF  /* FLL_K - [15:0] */
+#define WM8993_FLL_K_SHIFT                           0  /* FLL_K - [15:0] */
+#define WM8993_FLL_K_WIDTH                          16  /* FLL_K - [15:0] */
+
+/*
+ * R63 (0x3F) - FLL Control 4
+ */
+#define WM8993_FLL_N_MASK                       0x7FE0  /* FLL_N - [14:5] */
+#define WM8993_FLL_N_SHIFT                           5  /* FLL_N - [14:5] */
+#define WM8993_FLL_N_WIDTH                          10  /* FLL_N - [14:5] */
+#define WM8993_FLL_GAIN_MASK                    0x000F  /* FLL_GAIN - [3:0] */
+#define WM8993_FLL_GAIN_SHIFT                        0  /* FLL_GAIN - [3:0] */
+#define WM8993_FLL_GAIN_WIDTH                        4  /* FLL_GAIN - [3:0] */
+
+/*
+ * R64 (0x40) - FLL Control 5
+ */
+#define WM8993_FLL_FRC_NCO_VAL_MASK             0x1F80  /* FLL_FRC_NCO_VAL - [12:7] */
+#define WM8993_FLL_FRC_NCO_VAL_SHIFT                 7  /* FLL_FRC_NCO_VAL - [12:7] */
+#define WM8993_FLL_FRC_NCO_VAL_WIDTH                 6  /* FLL_FRC_NCO_VAL - [12:7] */
+#define WM8993_FLL_FRC_NCO                      0x0040  /* FLL_FRC_NCO */
+#define WM8993_FLL_FRC_NCO_MASK                 0x0040  /* FLL_FRC_NCO */
+#define WM8993_FLL_FRC_NCO_SHIFT                     6  /* FLL_FRC_NCO */
+#define WM8993_FLL_FRC_NCO_WIDTH                     1  /* FLL_FRC_NCO */
+#define WM8993_FLL_CLK_REF_DIV_MASK             0x0018  /* FLL_CLK_REF_DIV - [4:3] */
+#define WM8993_FLL_CLK_REF_DIV_SHIFT                 3  /* FLL_CLK_REF_DIV - [4:3] */
+#define WM8993_FLL_CLK_REF_DIV_WIDTH                 2  /* FLL_CLK_REF_DIV - [4:3] */
+#define WM8993_FLL_CLK_SRC_MASK                 0x0003  /* FLL_CLK_SRC - [1:0] */
+#define WM8993_FLL_CLK_SRC_SHIFT                     0  /* FLL_CLK_SRC - [1:0] */
+#define WM8993_FLL_CLK_SRC_WIDTH                     2  /* FLL_CLK_SRC - [1:0] */
+
+/*
+ * R65 (0x41) - Clocking 3
+ */
+#define WM8993_CLK_DCS_DIV_MASK                 0x3C00  /* CLK_DCS_DIV - [13:10] */
+#define WM8993_CLK_DCS_DIV_SHIFT                    10  /* CLK_DCS_DIV - [13:10] */
+#define WM8993_CLK_DCS_DIV_WIDTH                     4  /* CLK_DCS_DIV - [13:10] */
+#define WM8993_SAMPLE_RATE_MASK                 0x0380  /* SAMPLE_RATE - [9:7] */
+#define WM8993_SAMPLE_RATE_SHIFT                     7  /* SAMPLE_RATE - [9:7] */
+#define WM8993_SAMPLE_RATE_WIDTH                     3  /* SAMPLE_RATE - [9:7] */
+#define WM8993_CLK_SYS_RATE_MASK                0x001E  /* CLK_SYS_RATE - [4:1] */
+#define WM8993_CLK_SYS_RATE_SHIFT                    1  /* CLK_SYS_RATE - [4:1] */
+#define WM8993_CLK_SYS_RATE_WIDTH                    4  /* CLK_SYS_RATE - [4:1] */
+#define WM8993_CLK_DSP_ENA                      0x0001  /* CLK_DSP_ENA */
+#define WM8993_CLK_DSP_ENA_MASK                 0x0001  /* CLK_DSP_ENA */
+#define WM8993_CLK_DSP_ENA_SHIFT                     0  /* CLK_DSP_ENA */
+#define WM8993_CLK_DSP_ENA_WIDTH                     1  /* CLK_DSP_ENA */
+
+/*
+ * R66 (0x42) - Clocking 4
+ */
+#define WM8993_DAC_DIV4                         0x0200  /* DAC_DIV4 */
+#define WM8993_DAC_DIV4_MASK                    0x0200  /* DAC_DIV4 */
+#define WM8993_DAC_DIV4_SHIFT                        9  /* DAC_DIV4 */
+#define WM8993_DAC_DIV4_WIDTH                        1  /* DAC_DIV4 */
+#define WM8993_CLK_256K_DIV_MASK                0x007E  /* CLK_256K_DIV - [6:1] */
+#define WM8993_CLK_256K_DIV_SHIFT                    1  /* CLK_256K_DIV - [6:1] */
+#define WM8993_CLK_256K_DIV_WIDTH                    6  /* CLK_256K_DIV - [6:1] */
+#define WM8993_SR_MODE                          0x0001  /* SR_MODE */
+#define WM8993_SR_MODE_MASK                     0x0001  /* SR_MODE */
+#define WM8993_SR_MODE_SHIFT                         0  /* SR_MODE */
+#define WM8993_SR_MODE_WIDTH                         1  /* SR_MODE */
+
+/*
+ * R67 (0x43) - MW Slave Control
+ */
+#define WM8993_MASK_WRITE_ENA                   0x0001  /* MASK_WRITE_ENA */
+#define WM8993_MASK_WRITE_ENA_MASK              0x0001  /* MASK_WRITE_ENA */
+#define WM8993_MASK_WRITE_ENA_SHIFT                  0  /* MASK_WRITE_ENA */
+#define WM8993_MASK_WRITE_ENA_WIDTH                  1  /* MASK_WRITE_ENA */
+
+/*
+ * R69 (0x45) - Bus Control 1
+ */
+#define WM8993_CLK_SYS_ENA                      0x0002  /* CLK_SYS_ENA */
+#define WM8993_CLK_SYS_ENA_MASK                 0x0002  /* CLK_SYS_ENA */
+#define WM8993_CLK_SYS_ENA_SHIFT                     1  /* CLK_SYS_ENA */
+#define WM8993_CLK_SYS_ENA_WIDTH                     1  /* CLK_SYS_ENA */
+
+/*
+ * R70 (0x46) - Write Sequencer 0
+ */
+#define WM8993_WSEQ_ENA                         0x0100  /* WSEQ_ENA */
+#define WM8993_WSEQ_ENA_MASK                    0x0100  /* WSEQ_ENA */
+#define WM8993_WSEQ_ENA_SHIFT                        8  /* WSEQ_ENA */
+#define WM8993_WSEQ_ENA_WIDTH                        1  /* WSEQ_ENA */
+#define WM8993_WSEQ_WRITE_INDEX_MASK            0x001F  /* WSEQ_WRITE_INDEX - [4:0] */
+#define WM8993_WSEQ_WRITE_INDEX_SHIFT                0  /* WSEQ_WRITE_INDEX - [4:0] */
+#define WM8993_WSEQ_WRITE_INDEX_WIDTH                5  /* WSEQ_WRITE_INDEX - [4:0] */
+
+/*
+ * R71 (0x47) - Write Sequencer 1
+ */
+#define WM8993_WSEQ_DATA_WIDTH_MASK             0x7000  /* WSEQ_DATA_WIDTH - [14:12] */
+#define WM8993_WSEQ_DATA_WIDTH_SHIFT                12  /* WSEQ_DATA_WIDTH - [14:12] */
+#define WM8993_WSEQ_DATA_WIDTH_WIDTH                 3  /* WSEQ_DATA_WIDTH - [14:12] */
+#define WM8993_WSEQ_DATA_START_MASK             0x0F00  /* WSEQ_DATA_START - [11:8] */
+#define WM8993_WSEQ_DATA_START_SHIFT                 8  /* WSEQ_DATA_START - [11:8] */
+#define WM8993_WSEQ_DATA_START_WIDTH                 4  /* WSEQ_DATA_START - [11:8] */
+#define WM8993_WSEQ_ADDR_MASK                   0x00FF  /* WSEQ_ADDR - [7:0] */
+#define WM8993_WSEQ_ADDR_SHIFT                       0  /* WSEQ_ADDR - [7:0] */
+#define WM8993_WSEQ_ADDR_WIDTH                       8  /* WSEQ_ADDR - [7:0] */
+
+/*
+ * R72 (0x48) - Write Sequencer 2
+ */
+#define WM8993_WSEQ_EOS                         0x4000  /* WSEQ_EOS */
+#define WM8993_WSEQ_EOS_MASK                    0x4000  /* WSEQ_EOS */
+#define WM8993_WSEQ_EOS_SHIFT                       14  /* WSEQ_EOS */
+#define WM8993_WSEQ_EOS_WIDTH                        1  /* WSEQ_EOS */
+#define WM8993_WSEQ_DELAY_MASK                  0x0F00  /* WSEQ_DELAY - [11:8] */
+#define WM8993_WSEQ_DELAY_SHIFT                      8  /* WSEQ_DELAY - [11:8] */
+#define WM8993_WSEQ_DELAY_WIDTH                      4  /* WSEQ_DELAY - [11:8] */
+#define WM8993_WSEQ_DATA_MASK                   0x00FF  /* WSEQ_DATA - [7:0] */
+#define WM8993_WSEQ_DATA_SHIFT                       0  /* WSEQ_DATA - [7:0] */
+#define WM8993_WSEQ_DATA_WIDTH                       8  /* WSEQ_DATA - [7:0] */
+
+/*
+ * R73 (0x49) - Write Sequencer 3
+ */
+#define WM8993_WSEQ_ABORT                       0x0200  /* WSEQ_ABORT */
+#define WM8993_WSEQ_ABORT_MASK                  0x0200  /* WSEQ_ABORT */
+#define WM8993_WSEQ_ABORT_SHIFT                      9  /* WSEQ_ABORT */
+#define WM8993_WSEQ_ABORT_WIDTH                      1  /* WSEQ_ABORT */
+#define WM8993_WSEQ_START                       0x0100  /* WSEQ_START */
+#define WM8993_WSEQ_START_MASK                  0x0100  /* WSEQ_START */
+#define WM8993_WSEQ_START_SHIFT                      8  /* WSEQ_START */
+#define WM8993_WSEQ_START_WIDTH                      1  /* WSEQ_START */
+#define WM8993_WSEQ_START_INDEX_MASK            0x003F  /* WSEQ_START_INDEX - [5:0] */
+#define WM8993_WSEQ_START_INDEX_SHIFT                0  /* WSEQ_START_INDEX - [5:0] */
+#define WM8993_WSEQ_START_INDEX_WIDTH                6  /* WSEQ_START_INDEX - [5:0] */
+
+/*
+ * R74 (0x4A) - Write Sequencer 4
+ */
+#define WM8993_WSEQ_BUSY                        0x0001  /* WSEQ_BUSY */
+#define WM8993_WSEQ_BUSY_MASK                   0x0001  /* WSEQ_BUSY */
+#define WM8993_WSEQ_BUSY_SHIFT                       0  /* WSEQ_BUSY */
+#define WM8993_WSEQ_BUSY_WIDTH                       1  /* WSEQ_BUSY */
+
+/*
+ * R75 (0x4B) - Write Sequencer 5
+ */
+#define WM8993_WSEQ_CURRENT_INDEX_MASK          0x003F  /* WSEQ_CURRENT_INDEX - [5:0] */
+#define WM8993_WSEQ_CURRENT_INDEX_SHIFT              0  /* WSEQ_CURRENT_INDEX - [5:0] */
+#define WM8993_WSEQ_CURRENT_INDEX_WIDTH              6  /* WSEQ_CURRENT_INDEX - [5:0] */
+
+/*
+ * R76 (0x4C) - Charge Pump 1
+ */
+#define WM8993_CP_ENA                           0x8000  /* CP_ENA */
+#define WM8993_CP_ENA_MASK                      0x8000  /* CP_ENA */
+#define WM8993_CP_ENA_SHIFT                         15  /* CP_ENA */
+#define WM8993_CP_ENA_WIDTH                          1  /* CP_ENA */
+
+/*
+ * R81 (0x51) - Class W 0
+ */
+#define WM8993_CP_DYN_FREQ                      0x0002  /* CP_DYN_FREQ */
+#define WM8993_CP_DYN_FREQ_MASK                 0x0002  /* CP_DYN_FREQ */
+#define WM8993_CP_DYN_FREQ_SHIFT                     1  /* CP_DYN_FREQ */
+#define WM8993_CP_DYN_FREQ_WIDTH                     1  /* CP_DYN_FREQ */
+#define WM8993_CP_DYN_V                         0x0001  /* CP_DYN_V */
+#define WM8993_CP_DYN_V_MASK                    0x0001  /* CP_DYN_V */
+#define WM8993_CP_DYN_V_SHIFT                        0  /* CP_DYN_V */
+#define WM8993_CP_DYN_V_WIDTH                        1  /* CP_DYN_V */
+
+/*
+ * R84 (0x54) - DC Servo 0
+ */
+#define WM8993_DCS_TRIG_SINGLE_1                0x2000  /* DCS_TRIG_SINGLE_1 */
+#define WM8993_DCS_TRIG_SINGLE_1_MASK           0x2000  /* DCS_TRIG_SINGLE_1 */
+#define WM8993_DCS_TRIG_SINGLE_1_SHIFT              13  /* DCS_TRIG_SINGLE_1 */
+#define WM8993_DCS_TRIG_SINGLE_1_WIDTH               1  /* DCS_TRIG_SINGLE_1 */
+#define WM8993_DCS_TRIG_SINGLE_0                0x1000  /* DCS_TRIG_SINGLE_0 */
+#define WM8993_DCS_TRIG_SINGLE_0_MASK           0x1000  /* DCS_TRIG_SINGLE_0 */
+#define WM8993_DCS_TRIG_SINGLE_0_SHIFT              12  /* DCS_TRIG_SINGLE_0 */
+#define WM8993_DCS_TRIG_SINGLE_0_WIDTH               1  /* DCS_TRIG_SINGLE_0 */
+#define WM8993_DCS_TRIG_SERIES_1                0x0200  /* DCS_TRIG_SERIES_1 */
+#define WM8993_DCS_TRIG_SERIES_1_MASK           0x0200  /* DCS_TRIG_SERIES_1 */
+#define WM8993_DCS_TRIG_SERIES_1_SHIFT               9  /* DCS_TRIG_SERIES_1 */
+#define WM8993_DCS_TRIG_SERIES_1_WIDTH               1  /* DCS_TRIG_SERIES_1 */
+#define WM8993_DCS_TRIG_SERIES_0                0x0100  /* DCS_TRIG_SERIES_0 */
+#define WM8993_DCS_TRIG_SERIES_0_MASK           0x0100  /* DCS_TRIG_SERIES_0 */
+#define WM8993_DCS_TRIG_SERIES_0_SHIFT               8  /* DCS_TRIG_SERIES_0 */
+#define WM8993_DCS_TRIG_SERIES_0_WIDTH               1  /* DCS_TRIG_SERIES_0 */
+#define WM8993_DCS_TRIG_STARTUP_1               0x0020  /* DCS_TRIG_STARTUP_1 */
+#define WM8993_DCS_TRIG_STARTUP_1_MASK          0x0020  /* DCS_TRIG_STARTUP_1 */
+#define WM8993_DCS_TRIG_STARTUP_1_SHIFT              5  /* DCS_TRIG_STARTUP_1 */
+#define WM8993_DCS_TRIG_STARTUP_1_WIDTH              1  /* DCS_TRIG_STARTUP_1 */
+#define WM8993_DCS_TRIG_STARTUP_0               0x0010  /* DCS_TRIG_STARTUP_0 */
+#define WM8993_DCS_TRIG_STARTUP_0_MASK          0x0010  /* DCS_TRIG_STARTUP_0 */
+#define WM8993_DCS_TRIG_STARTUP_0_SHIFT              4  /* DCS_TRIG_STARTUP_0 */
+#define WM8993_DCS_TRIG_STARTUP_0_WIDTH              1  /* DCS_TRIG_STARTUP_0 */
+#define WM8993_DCS_TRIG_DAC_WR_1                0x0008  /* DCS_TRIG_DAC_WR_1 */
+#define WM8993_DCS_TRIG_DAC_WR_1_MASK           0x0008  /* DCS_TRIG_DAC_WR_1 */
+#define WM8993_DCS_TRIG_DAC_WR_1_SHIFT               3  /* DCS_TRIG_DAC_WR_1 */
+#define WM8993_DCS_TRIG_DAC_WR_1_WIDTH               1  /* DCS_TRIG_DAC_WR_1 */
+#define WM8993_DCS_TRIG_DAC_WR_0                0x0004  /* DCS_TRIG_DAC_WR_0 */
+#define WM8993_DCS_TRIG_DAC_WR_0_MASK           0x0004  /* DCS_TRIG_DAC_WR_0 */
+#define WM8993_DCS_TRIG_DAC_WR_0_SHIFT               2  /* DCS_TRIG_DAC_WR_0 */
+#define WM8993_DCS_TRIG_DAC_WR_0_WIDTH               1  /* DCS_TRIG_DAC_WR_0 */
+#define WM8993_DCS_ENA_CHAN_1                   0x0002  /* DCS_ENA_CHAN_1 */
+#define WM8993_DCS_ENA_CHAN_1_MASK              0x0002  /* DCS_ENA_CHAN_1 */
+#define WM8993_DCS_ENA_CHAN_1_SHIFT                  1  /* DCS_ENA_CHAN_1 */
+#define WM8993_DCS_ENA_CHAN_1_WIDTH                  1  /* DCS_ENA_CHAN_1 */
+#define WM8993_DCS_ENA_CHAN_0                   0x0001  /* DCS_ENA_CHAN_0 */
+#define WM8993_DCS_ENA_CHAN_0_MASK              0x0001  /* DCS_ENA_CHAN_0 */
+#define WM8993_DCS_ENA_CHAN_0_SHIFT                  0  /* DCS_ENA_CHAN_0 */
+#define WM8993_DCS_ENA_CHAN_0_WIDTH                  1  /* DCS_ENA_CHAN_0 */
+
+/*
+ * R85 (0x55) - DC Servo 1
+ */
+#define WM8993_DCS_SERIES_NO_01_MASK            0x0FE0  /* DCS_SERIES_NO_01 - [11:5] */
+#define WM8993_DCS_SERIES_NO_01_SHIFT                5  /* DCS_SERIES_NO_01 - [11:5] */
+#define WM8993_DCS_SERIES_NO_01_WIDTH                7  /* DCS_SERIES_NO_01 - [11:5] */
+#define WM8993_DCS_TIMER_PERIOD_01_MASK         0x000F  /* DCS_TIMER_PERIOD_01 - [3:0] */
+#define WM8993_DCS_TIMER_PERIOD_01_SHIFT             0  /* DCS_TIMER_PERIOD_01 - [3:0] */
+#define WM8993_DCS_TIMER_PERIOD_01_WIDTH             4  /* DCS_TIMER_PERIOD_01 - [3:0] */
+
+/*
+ * R87 (0x57) - DC Servo 3
+ */
+#define WM8993_DCS_DAC_WR_VAL_1_MASK            0xFF00  /* DCS_DAC_WR_VAL_1 - [15:8] */
+#define WM8993_DCS_DAC_WR_VAL_1_SHIFT                8  /* DCS_DAC_WR_VAL_1 - [15:8] */
+#define WM8993_DCS_DAC_WR_VAL_1_WIDTH                8  /* DCS_DAC_WR_VAL_1 - [15:8] */
+#define WM8993_DCS_DAC_WR_VAL_0_MASK            0x00FF  /* DCS_DAC_WR_VAL_0 - [7:0] */
+#define WM8993_DCS_DAC_WR_VAL_0_SHIFT                0  /* DCS_DAC_WR_VAL_0 - [7:0] */
+#define WM8993_DCS_DAC_WR_VAL_0_WIDTH                8  /* DCS_DAC_WR_VAL_0 - [7:0] */
+
+/*
+ * R88 (0x58) - DC Servo Readback 0
+ */
+#define WM8993_DCS_DATAPATH_BUSY                0x4000  /* DCS_DATAPATH_BUSY */
+#define WM8993_DCS_DATAPATH_BUSY_MASK           0x4000  /* DCS_DATAPATH_BUSY */
+#define WM8993_DCS_DATAPATH_BUSY_SHIFT              14  /* DCS_DATAPATH_BUSY */
+#define WM8993_DCS_DATAPATH_BUSY_WIDTH               1  /* DCS_DATAPATH_BUSY */
+#define WM8993_DCS_CHANNEL_MASK                 0x3000  /* DCS_CHANNEL - [13:12] */
+#define WM8993_DCS_CHANNEL_SHIFT                    12  /* DCS_CHANNEL - [13:12] */
+#define WM8993_DCS_CHANNEL_WIDTH                     2  /* DCS_CHANNEL - [13:12] */
+#define WM8993_DCS_CAL_COMPLETE_MASK            0x0300  /* DCS_CAL_COMPLETE - [9:8] */
+#define WM8993_DCS_CAL_COMPLETE_SHIFT                8  /* DCS_CAL_COMPLETE - [9:8] */
+#define WM8993_DCS_CAL_COMPLETE_WIDTH                2  /* DCS_CAL_COMPLETE - [9:8] */
+#define WM8993_DCS_DAC_WR_COMPLETE_MASK         0x0030  /* DCS_DAC_WR_COMPLETE - [5:4] */
+#define WM8993_DCS_DAC_WR_COMPLETE_SHIFT             4  /* DCS_DAC_WR_COMPLETE - [5:4] */
+#define WM8993_DCS_DAC_WR_COMPLETE_WIDTH             2  /* DCS_DAC_WR_COMPLETE - [5:4] */
+#define WM8993_DCS_STARTUP_COMPLETE_MASK        0x0003  /* DCS_STARTUP_COMPLETE - [1:0] */
+#define WM8993_DCS_STARTUP_COMPLETE_SHIFT            0  /* DCS_STARTUP_COMPLETE - [1:0] */
+#define WM8993_DCS_STARTUP_COMPLETE_WIDTH            2  /* DCS_STARTUP_COMPLETE - [1:0] */
+
+/*
+ * R89 (0x59) - DC Servo Readback 1
+ */
+#define WM8993_DCS_INTEG_CHAN_1_MASK            0x00FF  /* DCS_INTEG_CHAN_1 - [7:0] */
+#define WM8993_DCS_INTEG_CHAN_1_SHIFT                0  /* DCS_INTEG_CHAN_1 - [7:0] */
+#define WM8993_DCS_INTEG_CHAN_1_WIDTH                8  /* DCS_INTEG_CHAN_1 - [7:0] */
+
+/*
+ * R90 (0x5A) - DC Servo Readback 2
+ */
+#define WM8993_DCS_INTEG_CHAN_0_MASK            0x00FF  /* DCS_INTEG_CHAN_0 - [7:0] */
+#define WM8993_DCS_INTEG_CHAN_0_SHIFT                0  /* DCS_INTEG_CHAN_0 - [7:0] */
+#define WM8993_DCS_INTEG_CHAN_0_WIDTH                8  /* DCS_INTEG_CHAN_0 - [7:0] */
+
+/*
+ * R96 (0x60) - Analogue HP 0
+ */
+#define WM8993_HPOUT1_AUTO_PU                   0x0100  /* HPOUT1_AUTO_PU */
+#define WM8993_HPOUT1_AUTO_PU_MASK              0x0100  /* HPOUT1_AUTO_PU */
+#define WM8993_HPOUT1_AUTO_PU_SHIFT                  8  /* HPOUT1_AUTO_PU */
+#define WM8993_HPOUT1_AUTO_PU_WIDTH                  1  /* HPOUT1_AUTO_PU */
+#define WM8993_HPOUT1L_RMV_SHORT                0x0080  /* HPOUT1L_RMV_SHORT */
+#define WM8993_HPOUT1L_RMV_SHORT_MASK           0x0080  /* HPOUT1L_RMV_SHORT */
+#define WM8993_HPOUT1L_RMV_SHORT_SHIFT               7  /* HPOUT1L_RMV_SHORT */
+#define WM8993_HPOUT1L_RMV_SHORT_WIDTH               1  /* HPOUT1L_RMV_SHORT */
+#define WM8993_HPOUT1L_OUTP                     0x0040  /* HPOUT1L_OUTP */
+#define WM8993_HPOUT1L_OUTP_MASK                0x0040  /* HPOUT1L_OUTP */
+#define WM8993_HPOUT1L_OUTP_SHIFT                    6  /* HPOUT1L_OUTP */
+#define WM8993_HPOUT1L_OUTP_WIDTH                    1  /* HPOUT1L_OUTP */
+#define WM8993_HPOUT1L_DLY                      0x0020  /* HPOUT1L_DLY */
+#define WM8993_HPOUT1L_DLY_MASK                 0x0020  /* HPOUT1L_DLY */
+#define WM8993_HPOUT1L_DLY_SHIFT                     5  /* HPOUT1L_DLY */
+#define WM8993_HPOUT1L_DLY_WIDTH                     1  /* HPOUT1L_DLY */
+#define WM8993_HPOUT1R_RMV_SHORT                0x0008  /* HPOUT1R_RMV_SHORT */
+#define WM8993_HPOUT1R_RMV_SHORT_MASK           0x0008  /* HPOUT1R_RMV_SHORT */
+#define WM8993_HPOUT1R_RMV_SHORT_SHIFT               3  /* HPOUT1R_RMV_SHORT */
+#define WM8993_HPOUT1R_RMV_SHORT_WIDTH               1  /* HPOUT1R_RMV_SHORT */
+#define WM8993_HPOUT1R_OUTP                     0x0004  /* HPOUT1R_OUTP */
+#define WM8993_HPOUT1R_OUTP_MASK                0x0004  /* HPOUT1R_OUTP */
+#define WM8993_HPOUT1R_OUTP_SHIFT                    2  /* HPOUT1R_OUTP */
+#define WM8993_HPOUT1R_OUTP_WIDTH                    1  /* HPOUT1R_OUTP */
+#define WM8993_HPOUT1R_DLY                      0x0002  /* HPOUT1R_DLY */
+#define WM8993_HPOUT1R_DLY_MASK                 0x0002  /* HPOUT1R_DLY */
+#define WM8993_HPOUT1R_DLY_SHIFT                     1  /* HPOUT1R_DLY */
+#define WM8993_HPOUT1R_DLY_WIDTH                     1  /* HPOUT1R_DLY */
+
+/*
+ * R98 (0x62) - EQ1
+ */
+#define WM8993_EQ_ENA                           0x0001  /* EQ_ENA */
+#define WM8993_EQ_ENA_MASK                      0x0001  /* EQ_ENA */
+#define WM8993_EQ_ENA_SHIFT                          0  /* EQ_ENA */
+#define WM8993_EQ_ENA_WIDTH                          1  /* EQ_ENA */
+
+/*
+ * R99 (0x63) - EQ2
+ */
+#define WM8993_EQ_B1_GAIN_MASK                  0x001F  /* EQ_B1_GAIN - [4:0] */
+#define WM8993_EQ_B1_GAIN_SHIFT                      0  /* EQ_B1_GAIN - [4:0] */
+#define WM8993_EQ_B1_GAIN_WIDTH                      5  /* EQ_B1_GAIN - [4:0] */
+
+/*
+ * R100 (0x64) - EQ3
+ */
+#define WM8993_EQ_B2_GAIN_MASK                  0x001F  /* EQ_B2_GAIN - [4:0] */
+#define WM8993_EQ_B2_GAIN_SHIFT                      0  /* EQ_B2_GAIN - [4:0] */
+#define WM8993_EQ_B2_GAIN_WIDTH                      5  /* EQ_B2_GAIN - [4:0] */
+
+/*
+ * R101 (0x65) - EQ4
+ */
+#define WM8993_EQ_B3_GAIN_MASK                  0x001F  /* EQ_B3_GAIN - [4:0] */
+#define WM8993_EQ_B3_GAIN_SHIFT                      0  /* EQ_B3_GAIN - [4:0] */
+#define WM8993_EQ_B3_GAIN_WIDTH                      5  /* EQ_B3_GAIN - [4:0] */
+
+/*
+ * R102 (0x66) - EQ5
+ */
+#define WM8993_EQ_B4_GAIN_MASK                  0x001F  /* EQ_B4_GAIN - [4:0] */
+#define WM8993_EQ_B4_GAIN_SHIFT                      0  /* EQ_B4_GAIN - [4:0] */
+#define WM8993_EQ_B4_GAIN_WIDTH                      5  /* EQ_B4_GAIN - [4:0] */
+
+/*
+ * R103 (0x67) - EQ6
+ */
+#define WM8993_EQ_B5_GAIN_MASK                  0x001F  /* EQ_B5_GAIN - [4:0] */
+#define WM8993_EQ_B5_GAIN_SHIFT                      0  /* EQ_B5_GAIN - [4:0] */
+#define WM8993_EQ_B5_GAIN_WIDTH                      5  /* EQ_B5_GAIN - [4:0] */
+
+/*
+ * R104 (0x68) - EQ7
+ */
+#define WM8993_EQ_B1_A_MASK                     0xFFFF  /* EQ_B1_A - [15:0] */
+#define WM8993_EQ_B1_A_SHIFT                         0  /* EQ_B1_A - [15:0] */
+#define WM8993_EQ_B1_A_WIDTH                        16  /* EQ_B1_A - [15:0] */
+
+/*
+ * R105 (0x69) - EQ8
+ */
+#define WM8993_EQ_B1_B_MASK                     0xFFFF  /* EQ_B1_B - [15:0] */
+#define WM8993_EQ_B1_B_SHIFT                         0  /* EQ_B1_B - [15:0] */
+#define WM8993_EQ_B1_B_WIDTH                        16  /* EQ_B1_B - [15:0] */
+
+/*
+ * R106 (0x6A) - EQ9
+ */
+#define WM8993_EQ_B1_PG_MASK                    0xFFFF  /* EQ_B1_PG - [15:0] */
+#define WM8993_EQ_B1_PG_SHIFT                        0  /* EQ_B1_PG - [15:0] */
+#define WM8993_EQ_B1_PG_WIDTH                       16  /* EQ_B1_PG - [15:0] */
+
+/*
+ * R107 (0x6B) - EQ10
+ */
+#define WM8993_EQ_B2_A_MASK                     0xFFFF  /* EQ_B2_A - [15:0] */
+#define WM8993_EQ_B2_A_SHIFT                         0  /* EQ_B2_A - [15:0] */
+#define WM8993_EQ_B2_A_WIDTH                        16  /* EQ_B2_A - [15:0] */
+
+/*
+ * R108 (0x6C) - EQ11
+ */
+#define WM8993_EQ_B2_B_MASK                     0xFFFF  /* EQ_B2_B - [15:0] */
+#define WM8993_EQ_B2_B_SHIFT                         0  /* EQ_B2_B - [15:0] */
+#define WM8993_EQ_B2_B_WIDTH                        16  /* EQ_B2_B - [15:0] */
+
+/*
+ * R109 (0x6D) - EQ12
+ */
+#define WM8993_EQ_B2_C_MASK                     0xFFFF  /* EQ_B2_C - [15:0] */
+#define WM8993_EQ_B2_C_SHIFT                         0  /* EQ_B2_C - [15:0] */
+#define WM8993_EQ_B2_C_WIDTH                        16  /* EQ_B2_C - [15:0] */
+
+/*
+ * R110 (0x6E) - EQ13
+ */
+#define WM8993_EQ_B2_PG_MASK                    0xFFFF  /* EQ_B2_PG - [15:0] */
+#define WM8993_EQ_B2_PG_SHIFT                        0  /* EQ_B2_PG - [15:0] */
+#define WM8993_EQ_B2_PG_WIDTH                       16  /* EQ_B2_PG - [15:0] */
+
+/*
+ * R111 (0x6F) - EQ14
+ */
+#define WM8993_EQ_B3_A_MASK                     0xFFFF  /* EQ_B3_A - [15:0] */
+#define WM8993_EQ_B3_A_SHIFT                         0  /* EQ_B3_A - [15:0] */
+#define WM8993_EQ_B3_A_WIDTH                        16  /* EQ_B3_A - [15:0] */
+
+/*
+ * R112 (0x70) - EQ15
+ */
+#define WM8993_EQ_B3_B_MASK                     0xFFFF  /* EQ_B3_B - [15:0] */
+#define WM8993_EQ_B3_B_SHIFT                         0  /* EQ_B3_B - [15:0] */
+#define WM8993_EQ_B3_B_WIDTH                        16  /* EQ_B3_B - [15:0] */
+
+/*
+ * R113 (0x71) - EQ16
+ */
+#define WM8993_EQ_B3_C_MASK                     0xFFFF  /* EQ_B3_C - [15:0] */
+#define WM8993_EQ_B3_C_SHIFT                         0  /* EQ_B3_C - [15:0] */
+#define WM8993_EQ_B3_C_WIDTH                        16  /* EQ_B3_C - [15:0] */
+
+/*
+ * R114 (0x72) - EQ17
+ */
+#define WM8993_EQ_B3_PG_MASK                    0xFFFF  /* EQ_B3_PG - [15:0] */
+#define WM8993_EQ_B3_PG_SHIFT                        0  /* EQ_B3_PG - [15:0] */
+#define WM8993_EQ_B3_PG_WIDTH                       16  /* EQ_B3_PG - [15:0] */
+
+/*
+ * R115 (0x73) - EQ18
+ */
+#define WM8993_EQ_B4_A_MASK                     0xFFFF  /* EQ_B4_A - [15:0] */
+#define WM8993_EQ_B4_A_SHIFT                         0  /* EQ_B4_A - [15:0] */
+#define WM8993_EQ_B4_A_WIDTH                        16  /* EQ_B4_A - [15:0] */
+
+/*
+ * R116 (0x74) - EQ19
+ */
+#define WM8993_EQ_B4_B_MASK                     0xFFFF  /* EQ_B4_B - [15:0] */
+#define WM8993_EQ_B4_B_SHIFT                         0  /* EQ_B4_B - [15:0] */
+#define WM8993_EQ_B4_B_WIDTH                        16  /* EQ_B4_B - [15:0] */
+
+/*
+ * R117 (0x75) - EQ20
+ */
+#define WM8993_EQ_B4_C_MASK                     0xFFFF  /* EQ_B4_C - [15:0] */
+#define WM8993_EQ_B4_C_SHIFT                         0  /* EQ_B4_C - [15:0] */
+#define WM8993_EQ_B4_C_WIDTH                        16  /* EQ_B4_C - [15:0] */
+
+/*
+ * R118 (0x76) - EQ21
+ */
+#define WM8993_EQ_B4_PG_MASK                    0xFFFF  /* EQ_B4_PG - [15:0] */
+#define WM8993_EQ_B4_PG_SHIFT                        0  /* EQ_B4_PG - [15:0] */
+#define WM8993_EQ_B4_PG_WIDTH                       16  /* EQ_B4_PG - [15:0] */
+
+/*
+ * R119 (0x77) - EQ22
+ */
+#define WM8993_EQ_B5_A_MASK                     0xFFFF  /* EQ_B5_A - [15:0] */
+#define WM8993_EQ_B5_A_SHIFT                         0  /* EQ_B5_A - [15:0] */
+#define WM8993_EQ_B5_A_WIDTH                        16  /* EQ_B5_A - [15:0] */
+
+/*
+ * R120 (0x78) - EQ23
+ */
+#define WM8993_EQ_B5_B_MASK                     0xFFFF  /* EQ_B5_B - [15:0] */
+#define WM8993_EQ_B5_B_SHIFT                         0  /* EQ_B5_B - [15:0] */
+#define WM8993_EQ_B5_B_WIDTH                        16  /* EQ_B5_B - [15:0] */
+
+/*
+ * R121 (0x79) - EQ24
+ */
+#define WM8993_EQ_B5_PG_MASK                    0xFFFF  /* EQ_B5_PG - [15:0] */
+#define WM8993_EQ_B5_PG_SHIFT                        0  /* EQ_B5_PG - [15:0] */
+#define WM8993_EQ_B5_PG_WIDTH                       16  /* EQ_B5_PG - [15:0] */
+
+/*
+ * R122 (0x7A) - Digital Pulls
+ */
+#define WM8993_MCLK_PU                          0x0080  /* MCLK_PU */
+#define WM8993_MCLK_PU_MASK                     0x0080  /* MCLK_PU */
+#define WM8993_MCLK_PU_SHIFT                         7  /* MCLK_PU */
+#define WM8993_MCLK_PU_WIDTH                         1  /* MCLK_PU */
+#define WM8993_MCLK_PD                          0x0040  /* MCLK_PD */
+#define WM8993_MCLK_PD_MASK                     0x0040  /* MCLK_PD */
+#define WM8993_MCLK_PD_SHIFT                         6  /* MCLK_PD */
+#define WM8993_MCLK_PD_WIDTH                         1  /* MCLK_PD */
+#define WM8993_DACDAT_PU                        0x0020  /* DACDAT_PU */
+#define WM8993_DACDAT_PU_MASK                   0x0020  /* DACDAT_PU */
+#define WM8993_DACDAT_PU_SHIFT                       5  /* DACDAT_PU */
+#define WM8993_DACDAT_PU_WIDTH                       1  /* DACDAT_PU */
+#define WM8993_DACDAT_PD                        0x0010  /* DACDAT_PD */
+#define WM8993_DACDAT_PD_MASK                   0x0010  /* DACDAT_PD */
+#define WM8993_DACDAT_PD_SHIFT                       4  /* DACDAT_PD */
+#define WM8993_DACDAT_PD_WIDTH                       1  /* DACDAT_PD */
+#define WM8993_LRCLK_PU                         0x0008  /* LRCLK_PU */
+#define WM8993_LRCLK_PU_MASK                    0x0008  /* LRCLK_PU */
+#define WM8993_LRCLK_PU_SHIFT                        3  /* LRCLK_PU */
+#define WM8993_LRCLK_PU_WIDTH                        1  /* LRCLK_PU */
+#define WM8993_LRCLK_PD                         0x0004  /* LRCLK_PD */
+#define WM8993_LRCLK_PD_MASK                    0x0004  /* LRCLK_PD */
+#define WM8993_LRCLK_PD_SHIFT                        2  /* LRCLK_PD */
+#define WM8993_LRCLK_PD_WIDTH                        1  /* LRCLK_PD */
+#define WM8993_BCLK_PU                          0x0002  /* BCLK_PU */
+#define WM8993_BCLK_PU_MASK                     0x0002  /* BCLK_PU */
+#define WM8993_BCLK_PU_SHIFT                         1  /* BCLK_PU */
+#define WM8993_BCLK_PU_WIDTH                         1  /* BCLK_PU */
+#define WM8993_BCLK_PD                          0x0001  /* BCLK_PD */
+#define WM8993_BCLK_PD_MASK                     0x0001  /* BCLK_PD */
+#define WM8993_BCLK_PD_SHIFT                         0  /* BCLK_PD */
+#define WM8993_BCLK_PD_WIDTH                         1  /* BCLK_PD */
+
+/*
+ * R123 (0x7B) - DRC Control 1
+ */
+#define WM8993_DRC_ENA                          0x8000  /* DRC_ENA */
+#define WM8993_DRC_ENA_MASK                     0x8000  /* DRC_ENA */
+#define WM8993_DRC_ENA_SHIFT                        15  /* DRC_ENA */
+#define WM8993_DRC_ENA_WIDTH                         1  /* DRC_ENA */
+#define WM8993_DRC_DAC_PATH                     0x4000  /* DRC_DAC_PATH */
+#define WM8993_DRC_DAC_PATH_MASK                0x4000  /* DRC_DAC_PATH */
+#define WM8993_DRC_DAC_PATH_SHIFT                   14  /* DRC_DAC_PATH */
+#define WM8993_DRC_DAC_PATH_WIDTH                    1  /* DRC_DAC_PATH */
+#define WM8993_DRC_SMOOTH_ENA                   0x0800  /* DRC_SMOOTH_ENA */
+#define WM8993_DRC_SMOOTH_ENA_MASK              0x0800  /* DRC_SMOOTH_ENA */
+#define WM8993_DRC_SMOOTH_ENA_SHIFT                 11  /* DRC_SMOOTH_ENA */
+#define WM8993_DRC_SMOOTH_ENA_WIDTH                  1  /* DRC_SMOOTH_ENA */
+#define WM8993_DRC_QR_ENA                       0x0400  /* DRC_QR_ENA */
+#define WM8993_DRC_QR_ENA_MASK                  0x0400  /* DRC_QR_ENA */
+#define WM8993_DRC_QR_ENA_SHIFT                     10  /* DRC_QR_ENA */
+#define WM8993_DRC_QR_ENA_WIDTH                      1  /* DRC_QR_ENA */
+#define WM8993_DRC_ANTICLIP_ENA                 0x0200  /* DRC_ANTICLIP_ENA */
+#define WM8993_DRC_ANTICLIP_ENA_MASK            0x0200  /* DRC_ANTICLIP_ENA */
+#define WM8993_DRC_ANTICLIP_ENA_SHIFT                9  /* DRC_ANTICLIP_ENA */
+#define WM8993_DRC_ANTICLIP_ENA_WIDTH                1  /* DRC_ANTICLIP_ENA */
+#define WM8993_DRC_HYST_ENA                     0x0100  /* DRC_HYST_ENA */
+#define WM8993_DRC_HYST_ENA_MASK                0x0100  /* DRC_HYST_ENA */
+#define WM8993_DRC_HYST_ENA_SHIFT                    8  /* DRC_HYST_ENA */
+#define WM8993_DRC_HYST_ENA_WIDTH                    1  /* DRC_HYST_ENA */
+#define WM8993_DRC_THRESH_HYST_MASK             0x0030  /* DRC_THRESH_HYST - [5:4] */
+#define WM8993_DRC_THRESH_HYST_SHIFT                 4  /* DRC_THRESH_HYST - [5:4] */
+#define WM8993_DRC_THRESH_HYST_WIDTH                 2  /* DRC_THRESH_HYST - [5:4] */
+#define WM8993_DRC_MINGAIN_MASK                 0x000C  /* DRC_MINGAIN - [3:2] */
+#define WM8993_DRC_MINGAIN_SHIFT                     2  /* DRC_MINGAIN - [3:2] */
+#define WM8993_DRC_MINGAIN_WIDTH                     2  /* DRC_MINGAIN - [3:2] */
+#define WM8993_DRC_MAXGAIN_MASK                 0x0003  /* DRC_MAXGAIN - [1:0] */
+#define WM8993_DRC_MAXGAIN_SHIFT                     0  /* DRC_MAXGAIN - [1:0] */
+#define WM8993_DRC_MAXGAIN_WIDTH                     2  /* DRC_MAXGAIN - [1:0] */
+
+/*
+ * R124 (0x7C) - DRC Control 2
+ */
+#define WM8993_DRC_ATTACK_RATE_MASK             0xF000  /* DRC_ATTACK_RATE - [15:12] */
+#define WM8993_DRC_ATTACK_RATE_SHIFT                12  /* DRC_ATTACK_RATE - [15:12] */
+#define WM8993_DRC_ATTACK_RATE_WIDTH                 4  /* DRC_ATTACK_RATE - [15:12] */
+#define WM8993_DRC_DECAY_RATE_MASK              0x0F00  /* DRC_DECAY_RATE - [11:8] */
+#define WM8993_DRC_DECAY_RATE_SHIFT                  8  /* DRC_DECAY_RATE - [11:8] */
+#define WM8993_DRC_DECAY_RATE_WIDTH                  4  /* DRC_DECAY_RATE - [11:8] */
+#define WM8993_DRC_THRESH_COMP_MASK             0x00FC  /* DRC_THRESH_COMP - [7:2] */
+#define WM8993_DRC_THRESH_COMP_SHIFT                 2  /* DRC_THRESH_COMP - [7:2] */
+#define WM8993_DRC_THRESH_COMP_WIDTH                 6  /* DRC_THRESH_COMP - [7:2] */
+
+/*
+ * R125 (0x7D) - DRC Control 3
+ */
+#define WM8993_DRC_AMP_COMP_MASK                0xF800  /* DRC_AMP_COMP - [15:11] */
+#define WM8993_DRC_AMP_COMP_SHIFT                   11  /* DRC_AMP_COMP - [15:11] */
+#define WM8993_DRC_AMP_COMP_WIDTH                    5  /* DRC_AMP_COMP - [15:11] */
+#define WM8993_DRC_R0_SLOPE_COMP_MASK           0x0700  /* DRC_R0_SLOPE_COMP - [10:8] */
+#define WM8993_DRC_R0_SLOPE_COMP_SHIFT               8  /* DRC_R0_SLOPE_COMP - [10:8] */
+#define WM8993_DRC_R0_SLOPE_COMP_WIDTH               3  /* DRC_R0_SLOPE_COMP - [10:8] */
+#define WM8993_DRC_FF_DELAY                     0x0080  /* DRC_FF_DELAY */
+#define WM8993_DRC_FF_DELAY_MASK                0x0080  /* DRC_FF_DELAY */
+#define WM8993_DRC_FF_DELAY_SHIFT                    7  /* DRC_FF_DELAY */
+#define WM8993_DRC_FF_DELAY_WIDTH                    1  /* DRC_FF_DELAY */
+#define WM8993_DRC_THRESH_QR_MASK               0x000C  /* DRC_THRESH_QR - [3:2] */
+#define WM8993_DRC_THRESH_QR_SHIFT                   2  /* DRC_THRESH_QR - [3:2] */
+#define WM8993_DRC_THRESH_QR_WIDTH                   2  /* DRC_THRESH_QR - [3:2] */
+#define WM8993_DRC_RATE_QR_MASK                 0x0003  /* DRC_RATE_QR - [1:0] */
+#define WM8993_DRC_RATE_QR_SHIFT                     0  /* DRC_RATE_QR - [1:0] */
+#define WM8993_DRC_RATE_QR_WIDTH                     2  /* DRC_RATE_QR - [1:0] */
+
+/*
+ * R126 (0x7E) - DRC Control 4
+ */
+#define WM8993_DRC_R1_SLOPE_COMP_MASK           0xE000  /* DRC_R1_SLOPE_COMP - [15:13] */
+#define WM8993_DRC_R1_SLOPE_COMP_SHIFT              13  /* DRC_R1_SLOPE_COMP - [15:13] */
+#define WM8993_DRC_R1_SLOPE_COMP_WIDTH               3  /* DRC_R1_SLOPE_COMP - [15:13] */
+#define WM8993_DRC_STARTUP_GAIN_MASK            0x1F00  /* DRC_STARTUP_GAIN - [12:8] */
+#define WM8993_DRC_STARTUP_GAIN_SHIFT                8  /* DRC_STARTUP_GAIN - [12:8] */
+#define WM8993_DRC_STARTUP_GAIN_WIDTH                5  /* DRC_STARTUP_GAIN - [12:8] */
+
+#endif
diff --git a/sound/soc/codecs/wm9081.c b/sound/soc/codecs/wm9081.c
new file mode 100644
index 000000000000..c64e55aa63b6
--- /dev/null
+++ b/sound/soc/codecs/wm9081.c
@@ -0,0 +1,1511 @@
+/*
+ * wm9081.c  --  WM9081 ALSA SoC Audio driver
+ *
+ * Author: Mark Brown
+ *
+ * Copyright 2009 Wolfson Microelectronics plc
+ *
+ * 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 <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/wm9081.h>
+#include "wm9081.h"
+
+static u16 wm9081_reg_defaults[] = {
+        0x0000,     /* R0  - Software Reset */
+        0x0000,     /* R1 */
+        0x00B9,     /* R2  - Analogue Lineout */
+        0x00B9,     /* R3  - Analogue Speaker PGA */
+        0x0001,     /* R4  - VMID Control */
+        0x0068,     /* R5  - Bias Control 1 */
+        0x0000,     /* R6 */
+        0x0000,     /* R7  - Analogue Mixer */
+        0x0000,     /* R8  - Anti Pop Control */
+        0x01DB,     /* R9  - Analogue Speaker 1 */
+        0x0018,     /* R10 - Analogue Speaker 2 */
+        0x0180,     /* R11 - Power Management */
+        0x0000,     /* R12 - Clock Control 1 */
+        0x0038,     /* R13 - Clock Control 2 */
+        0x4000,     /* R14 - Clock Control 3 */
+        0x0000,     /* R15 */
+        0x0000,     /* R16 - FLL Control 1 */
+        0x0200,     /* R17 - FLL Control 2 */
+        0x0000,     /* R18 - FLL Control 3 */
+        0x0204,     /* R19 - FLL Control 4 */
+        0x0000,     /* R20 - FLL Control 5 */
+        0x0000,     /* R21 */
+        0x0000,     /* R22 - Audio Interface 1 */
+        0x0002,     /* R23 - Audio Interface 2 */
+        0x0008,     /* R24 - Audio Interface 3 */
+        0x0022,     /* R25 - Audio Interface 4 */
+        0x0000,     /* R26 - Interrupt Status */
+        0x0006,     /* R27 - Interrupt Status Mask */
+        0x0000,     /* R28 - Interrupt Polarity */
+        0x0000,     /* R29 - Interrupt Control */
+        0x00C0,     /* R30 - DAC Digital 1 */
+        0x0008,     /* R31 - DAC Digital 2 */
+        0x09AF,     /* R32 - DRC 1 */
+        0x4201,     /* R33 - DRC 2 */
+        0x0000,     /* R34 - DRC 3 */
+        0x0000,     /* R35 - DRC 4 */
+        0x0000,     /* R36 */
+        0x0000,     /* R37 */
+        0x0000,     /* R38 - Write Sequencer 1 */
+        0x0000,     /* R39 - Write Sequencer 2 */
+        0x0002,     /* R40 - MW Slave 1 */
+        0x0000,     /* R41 */
+        0x0000,     /* R42 - EQ 1 */
+        0x0000,     /* R43 - EQ 2 */
+        0x0FCA,     /* R44 - EQ 3 */
+        0x0400,     /* R45 - EQ 4 */
+        0x00B8,     /* R46 - EQ 5 */
+        0x1EB5,     /* R47 - EQ 6 */
+        0xF145,     /* R48 - EQ 7 */
+        0x0B75,     /* R49 - EQ 8 */
+        0x01C5,     /* R50 - EQ 9 */
+        0x169E,     /* R51 - EQ 10 */
+        0xF829,     /* R52 - EQ 11 */
+        0x07AD,     /* R53 - EQ 12 */
+        0x1103,     /* R54 - EQ 13 */
+        0x1C58,     /* R55 - EQ 14 */
+        0xF373,     /* R56 - EQ 15 */
+        0x0A54,     /* R57 - EQ 16 */
+        0x0558,     /* R58 - EQ 17 */
+        0x0564,     /* R59 - EQ 18 */
+        0x0559,     /* R60 - EQ 19 */
+        0x4000,     /* R61 - EQ 20 */
+};
+
+static struct {
+        int ratio;
+        int clk_sys_rate;
+} clk_sys_rates[] = {
+        { 64,   0 },
+        { 128,  1 },
+        { 192,  2 },
+        { 256,  3 },
+        { 384,  4 },
+        { 512,  5 },
+        { 768,  6 },
+        { 1024, 7 },
+        { 1408, 8 },
+        { 1536, 9 },
+};
+
+static struct {
+        int rate;
+        int sample_rate;
+} sample_rates[] = {
+        { 8000,  0  },
+        { 11025, 1  },
+        { 12000, 2  },
+        { 16000, 3  },
+        { 22050, 4  },
+        { 24000, 5  },
+        { 32000, 6  },
+        { 44100, 7  },
+        { 48000, 8  },
+        { 88200, 9  },
+        { 96000, 10 },
+};
+
+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, 15 },
+        { 250, 16 },
+        { 300, 17 },
+        { 320, 18 },
+        { 440, 19 },
+        { 480, 20 },
+};
+
+struct wm9081_priv {
+        struct snd_soc_codec codec;
+        u16 reg_cache[WM9081_MAX_REGISTER + 1];
+        int sysclk_source;
+        int mclk_rate;
+        int sysclk_rate;
+        int fs;
+        int bclk;
+        int master;
+        int fll_fref;
+        int fll_fout;
+        int tdm_width;
+        struct wm9081_retune_mobile_config *retune;
+};
+
+static int wm9081_volatile_register(unsigned int reg)
+{
+        switch (reg) {
+        case WM9081_SOFTWARE_RESET:
+                return 1;
+        default:
+                return 0;
+        }
+}
+
+static int wm9081_reset(struct snd_soc_codec *codec)
+{
+        return snd_soc_write(codec, WM9081_SOFTWARE_RESET, 0);
+}
+
+static const DECLARE_TLV_DB_SCALE(drc_in_tlv, -4500, 75, 0);
+static const DECLARE_TLV_DB_SCALE(drc_out_tlv, -2250, 75, 0);
+static const DECLARE_TLV_DB_SCALE(drc_min_tlv, -1800, 600, 0);
+static unsigned int drc_max_tlv[] = {
+        TLV_DB_RANGE_HEAD(4),
+        0, 0, TLV_DB_SCALE_ITEM(1200, 0, 0),
+        1, 1, TLV_DB_SCALE_ITEM(1800, 0, 0),
+        2, 2, TLV_DB_SCALE_ITEM(2400, 0, 0),
+        3, 3, TLV_DB_SCALE_ITEM(3600, 0, 0),
+};
+static const DECLARE_TLV_DB_SCALE(drc_qr_tlv, 1200, 600, 0);
+static const DECLARE_TLV_DB_SCALE(drc_startup_tlv, -300, 50, 0);
+
+static const DECLARE_TLV_DB_SCALE(eq_tlv, -1200, 100, 0);
+
+static const DECLARE_TLV_DB_SCALE(in_tlv, -600, 600, 0);
+static const DECLARE_TLV_DB_SCALE(dac_tlv, -7200, 75, 1);
+static const DECLARE_TLV_DB_SCALE(out_tlv, -5700, 100, 0);
+
+static const char *drc_high_text[] = {
+        "1",
+        "1/2",
+        "1/4",
+        "1/8",
+        "1/16",
+        "0",
+};
+
+static const struct soc_enum drc_high =
+        SOC_ENUM_SINGLE(WM9081_DRC_3, 3, 6, drc_high_text);
+
+static const char *drc_low_text[] = {
+        "1",
+        "1/2",
+        "1/4",
+        "1/8",
+        "0",
+};
+
+static const struct soc_enum drc_low =
+        SOC_ENUM_SINGLE(WM9081_DRC_3, 0, 5, drc_low_text);
+
+static const char *drc_atk_text[] = {
+        "181us",
+        "181us",
+        "363us",
+        "726us",
+        "1.45ms",
+        "2.9ms",
+        "5.8ms",
+        "11.6ms",
+        "23.2ms",
+        "46.4ms",
+        "92.8ms",
+        "185.6ms",
+};
+
+static const struct soc_enum drc_atk =
+        SOC_ENUM_SINGLE(WM9081_DRC_2, 12, 12, drc_atk_text);
+
+static const char *drc_dcy_text[] = {
+        "186ms",
+        "372ms",
+        "743ms",
+        "1.49s",
+        "2.97s",
+        "5.94s",
+        "11.89s",
+        "23.78s",
+        "47.56s",
+};
+
+static const struct soc_enum drc_dcy =
+        SOC_ENUM_SINGLE(WM9081_DRC_2, 8, 9, drc_dcy_text);
+
+static const char *drc_qr_dcy_text[] = {
+        "0.725ms",
+        "1.45ms",
+        "5.8ms",
+};
+
+static const struct soc_enum drc_qr_dcy =
+        SOC_ENUM_SINGLE(WM9081_DRC_2, 4, 3, drc_qr_dcy_text);
+
+static const char *dac_deemph_text[] = {
+        "None",
+        "32kHz",
+        "44.1kHz",
+        "48kHz",
+};
+
+static const struct soc_enum dac_deemph =
+        SOC_ENUM_SINGLE(WM9081_DAC_DIGITAL_2, 1, 4, dac_deemph_text);
+
+static const char *speaker_mode_text[] = {
+        "Class D",
+        "Class AB",
+};
+
+static const struct soc_enum speaker_mode =
+        SOC_ENUM_SINGLE(WM9081_ANALOGUE_SPEAKER_2, 6, 2, speaker_mode_text);
+
+static int speaker_mode_get(struct snd_kcontrol *kcontrol,
+                            struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+        unsigned int reg;
+
+        reg = snd_soc_read(codec, WM9081_ANALOGUE_SPEAKER_2);
+        if (reg & WM9081_SPK_MODE)
+                ucontrol->value.integer.value[0] = 1;
+        else
+                ucontrol->value.integer.value[0] = 0;
+
+        return 0;
+}
+
+/*
+ * Stop any attempts to change speaker mode while the speaker is enabled.
+ *
+ * We also have some special anti-pop controls dependant on speaker
+ * mode which must be changed along with the mode.
+ */
+static int speaker_mode_put(struct snd_kcontrol *kcontrol,
+                            struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+        unsigned int reg_pwr = snd_soc_read(codec, WM9081_POWER_MANAGEMENT);
+        unsigned int reg2 = snd_soc_read(codec, WM9081_ANALOGUE_SPEAKER_2);
+
+        /* Are we changing anything? */
+        if (ucontrol->value.integer.value[0] ==
+            ((reg2 & WM9081_SPK_MODE) != 0))
+                return 0;
+
+        /* Don't try to change modes while enabled */
+        if (reg_pwr & WM9081_SPK_ENA)
+                return -EINVAL;
+
+        if (ucontrol->value.integer.value[0]) {
+                /* Class AB */
+                reg2 &= ~(WM9081_SPK_INV_MUTE | WM9081_OUT_SPK_CTRL);
+                reg2 |= WM9081_SPK_MODE;
+        } else {
+                /* Class D */
+                reg2 |= WM9081_SPK_INV_MUTE | WM9081_OUT_SPK_CTRL;
+                reg2 &= ~WM9081_SPK_MODE;
+        }
+
+        snd_soc_write(codec, WM9081_ANALOGUE_SPEAKER_2, reg2);
+
+        return 0;
+}
+
+static const struct snd_kcontrol_new wm9081_snd_controls[] = {
+SOC_SINGLE_TLV("IN1 Volume", WM9081_ANALOGUE_MIXER, 1, 1, 1, in_tlv),
+SOC_SINGLE_TLV("IN2 Volume", WM9081_ANALOGUE_MIXER, 3, 1, 1, in_tlv),
+
+SOC_SINGLE_TLV("Playback Volume", WM9081_DAC_DIGITAL_1, 1, 96, 0, dac_tlv),
+
+SOC_SINGLE("LINEOUT Switch", WM9081_ANALOGUE_LINEOUT, 7, 1, 1),
+SOC_SINGLE("LINEOUT ZC Switch", WM9081_ANALOGUE_LINEOUT, 6, 1, 0),
+SOC_SINGLE_TLV("LINEOUT Volume", WM9081_ANALOGUE_LINEOUT, 0, 63, 0, out_tlv),
+
+SOC_SINGLE("DRC Switch", WM9081_DRC_1, 15, 1, 0),
+SOC_ENUM("DRC High Slope", drc_high),
+SOC_ENUM("DRC Low Slope", drc_low),
+SOC_SINGLE_TLV("DRC Input Volume", WM9081_DRC_4, 5, 60, 1, drc_in_tlv),
+SOC_SINGLE_TLV("DRC Output Volume", WM9081_DRC_4, 0, 30, 1, drc_out_tlv),
+SOC_SINGLE_TLV("DRC Minimum Volume", WM9081_DRC_2, 2, 3, 1, drc_min_tlv),
+SOC_SINGLE_TLV("DRC Maximum Volume", WM9081_DRC_2, 0, 3, 0, drc_max_tlv),
+SOC_ENUM("DRC Attack", drc_atk),
+SOC_ENUM("DRC Decay", drc_dcy),
+SOC_SINGLE("DRC Quick Release Switch", WM9081_DRC_1, 2, 1, 0),
+SOC_SINGLE_TLV("DRC Quick Release Volume", WM9081_DRC_2, 6, 3, 0, drc_qr_tlv),
+SOC_ENUM("DRC Quick Release Decay", drc_qr_dcy),
+SOC_SINGLE_TLV("DRC Startup Volume", WM9081_DRC_1, 6, 18, 0, drc_startup_tlv),
+
+SOC_SINGLE("EQ Switch", WM9081_EQ_1, 0, 1, 0),
+
+SOC_SINGLE("Speaker DC Volume", WM9081_ANALOGUE_SPEAKER_1, 3, 5, 0),
+SOC_SINGLE("Speaker AC Volume", WM9081_ANALOGUE_SPEAKER_1, 0, 5, 0),
+SOC_SINGLE("Speaker Switch", WM9081_ANALOGUE_SPEAKER_PGA, 7, 1, 1),
+SOC_SINGLE("Speaker ZC Switch", WM9081_ANALOGUE_SPEAKER_PGA, 6, 1, 0),
+SOC_SINGLE_TLV("Speaker Volume", WM9081_ANALOGUE_SPEAKER_PGA, 0, 63, 0,
+               out_tlv),
+SOC_ENUM("DAC Deemphasis", dac_deemph),
+SOC_ENUM_EXT("Speaker Mode", speaker_mode, speaker_mode_get, speaker_mode_put),
+};
+
+static const struct snd_kcontrol_new wm9081_eq_controls[] = {
+SOC_SINGLE_TLV("EQ1 Volume", WM9081_EQ_1, 11, 24, 0, eq_tlv),
+SOC_SINGLE_TLV("EQ2 Volume", WM9081_EQ_1, 6, 24, 0, eq_tlv),
+SOC_SINGLE_TLV("EQ3 Volume", WM9081_EQ_1, 1, 24, 0, eq_tlv),
+SOC_SINGLE_TLV("EQ4 Volume", WM9081_EQ_2, 11, 24, 0, eq_tlv),
+SOC_SINGLE_TLV("EQ5 Volume", WM9081_EQ_2, 6, 24, 0, eq_tlv),
+};
+
+static const struct snd_kcontrol_new mixer[] = {
+SOC_DAPM_SINGLE("IN1 Switch", WM9081_ANALOGUE_MIXER, 0, 1, 0),
+SOC_DAPM_SINGLE("IN2 Switch", WM9081_ANALOGUE_MIXER, 2, 1, 0),
+SOC_DAPM_SINGLE("Playback Switch", WM9081_ANALOGUE_MIXER, 4, 1, 0),
+};
+
+static int speaker_event(struct snd_soc_dapm_widget *w,
+                         struct snd_kcontrol *kcontrol, int event)
+{
+        struct snd_soc_codec *codec = w->codec;
+        unsigned int reg = snd_soc_read(codec, WM9081_POWER_MANAGEMENT);
+
+        switch (event) {
+        case SND_SOC_DAPM_POST_PMU:
+                reg |= WM9081_SPK_ENA;
+                break;
+
+        case SND_SOC_DAPM_PRE_PMD:
+                reg &= ~WM9081_SPK_ENA;
+                break;
+        }
+
+        snd_soc_write(codec, WM9081_POWER_MANAGEMENT, reg);
+
+        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;
+        while ((Fref / div) > 13500000) {
+                div *= 2;
+
+                if (div > 8) {
+                        pr_err("Can't scale %dMHz input down to <=13.5MHz\n",
+                               Fref);
+                        return -EINVAL;
+                }
+        }
+        fll_div->fll_clk_ref_div = div / 2;
+
+        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 = 0;
+        target = Fout * 2;
+        while (target < 90000000) {
+                div++;
+                target *= 2;
+                if (div > 7) {
+                        pr_err("Unable to find FLL_OUTDIV for Fout=%uHz\n",
+                               Fout);
+                        return -EINVAL;
+                }
+        }
+        fll_div->fll_outdiv = div;
+
+        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 wm9081_set_fll(struct snd_soc_codec *codec, int fll_id,
+                          unsigned int Fref, unsigned int Fout)
+{
+        struct wm9081_priv *wm9081 = codec->private_data;
+        u16 reg1, reg4, reg5;
+        struct _fll_div fll_div;
+        int ret;
+        int clk_sys_reg;
+
+        /* Any change? */
+        if (Fref == wm9081->fll_fref && Fout == wm9081->fll_fout)
+                return 0;
+
+        /* Disable the FLL */
+        if (Fout == 0) {
+                dev_dbg(codec->dev, "FLL disabled\n");
+                wm9081->fll_fref = 0;
+                wm9081->fll_fout = 0;
+
+                return 0;
+        }
+
+        ret = fll_factors(&fll_div, Fref, Fout);
+        if (ret != 0)
+                return ret;
+
+        reg5 = snd_soc_read(codec, WM9081_FLL_CONTROL_5);
+        reg5 &= ~WM9081_FLL_CLK_SRC_MASK;
+
+        switch (fll_id) {
+        case WM9081_SYSCLK_FLL_MCLK:
+                reg5 |= 0x1;
+                break;
+
+        default:
+                dev_err(codec->dev, "Unknown FLL ID %d\n", fll_id);
+                return -EINVAL;
+        }
+
+        /* Disable CLK_SYS while we reconfigure */
+        clk_sys_reg = snd_soc_read(codec, WM9081_CLOCK_CONTROL_3);
+        if (clk_sys_reg & WM9081_CLK_SYS_ENA)
+                snd_soc_write(codec, WM9081_CLOCK_CONTROL_3,
+                             clk_sys_reg & ~WM9081_CLK_SYS_ENA);
+
+        /* Any FLL configuration change requires that the FLL be
+         * disabled first. */
+        reg1 = snd_soc_read(codec, WM9081_FLL_CONTROL_1);
+        reg1 &= ~WM9081_FLL_ENA;
+        snd_soc_write(codec, WM9081_FLL_CONTROL_1, reg1);
+
+        /* Apply the configuration */
+        if (fll_div.k)
+                reg1 |= WM9081_FLL_FRAC_MASK;
+        else
+                reg1 &= ~WM9081_FLL_FRAC_MASK;
+        snd_soc_write(codec, WM9081_FLL_CONTROL_1, reg1);
+
+        snd_soc_write(codec, WM9081_FLL_CONTROL_2,
+                     (fll_div.fll_outdiv << WM9081_FLL_OUTDIV_SHIFT) |
+                     (fll_div.fll_fratio << WM9081_FLL_FRATIO_SHIFT));
+        snd_soc_write(codec, WM9081_FLL_CONTROL_3, fll_div.k);
+
+        reg4 = snd_soc_read(codec, WM9081_FLL_CONTROL_4);
+        reg4 &= ~WM9081_FLL_N_MASK;
+        reg4 |= fll_div.n << WM9081_FLL_N_SHIFT;
+        snd_soc_write(codec, WM9081_FLL_CONTROL_4, reg4);
+
+        reg5 &= ~WM9081_FLL_CLK_REF_DIV_MASK;
+        reg5 |= fll_div.fll_clk_ref_div << WM9081_FLL_CLK_REF_DIV_SHIFT;
+        snd_soc_write(codec, WM9081_FLL_CONTROL_5, reg5);
+
+        /* Enable the FLL */
+        snd_soc_write(codec, WM9081_FLL_CONTROL_1, reg1 | WM9081_FLL_ENA);
+
+        /* Then bring CLK_SYS up again if it was disabled */
+        if (clk_sys_reg & WM9081_CLK_SYS_ENA)
+                snd_soc_write(codec, WM9081_CLOCK_CONTROL_3, clk_sys_reg);
+
+        dev_dbg(codec->dev, "FLL enabled at %dHz->%dHz\n", Fref, Fout);
+
+        wm9081->fll_fref = Fref;
+        wm9081->fll_fout = Fout;
+
+        return 0;
+}
+
+static int configure_clock(struct snd_soc_codec *codec)
+{
+        struct wm9081_priv *wm9081 = codec->private_data;
+        int new_sysclk, i, target;
+        unsigned int reg;
+        int ret = 0;
+        int mclkdiv = 0;
+        int fll = 0;
+
+        switch (wm9081->sysclk_source) {
+        case WM9081_SYSCLK_MCLK:
+                if (wm9081->mclk_rate > 12225000) {
+                        mclkdiv = 1;
+                        wm9081->sysclk_rate = wm9081->mclk_rate / 2;
+                } else {
+                        wm9081->sysclk_rate = wm9081->mclk_rate;
+                }
+                wm9081_set_fll(codec, WM9081_SYSCLK_FLL_MCLK, 0, 0);
+                break;
+
+        case WM9081_SYSCLK_FLL_MCLK:
+                /* If we have a sample rate calculate a CLK_SYS that
+                 * gives us a suitable DAC configuration, plus BCLK.
+                 * Ideally we would check to see if we can clock
+                 * directly from MCLK and only use the FLL if this is
+                 * not the case, though care must be taken with free
+                 * running mode.
+                 */
+                if (wm9081->master && wm9081->bclk) {
+                        /* Make sure we can generate CLK_SYS and BCLK
+                         * and that we've got 3MHz for optimal
+                         * performance. */
+                        for (i = 0; i < ARRAY_SIZE(clk_sys_rates); i++) {
+                                target = wm9081->fs * clk_sys_rates[i].ratio;
+                                new_sysclk = target;
+                                if (target >= wm9081->bclk &&
+                                    target > 3000000)
+                                        break;
+                        }
+
+                        if (i == ARRAY_SIZE(clk_sys_rates))
+                                return -EINVAL;
+
+                } else if (wm9081->fs) {
+                        for (i = 0; i < ARRAY_SIZE(clk_sys_rates); i++) {
+                                new_sysclk = clk_sys_rates[i].ratio
+                                        * wm9081->fs;
+                                if (new_sysclk > 3000000)
+                                        break;
+                        }
+
+                        if (i == ARRAY_SIZE(clk_sys_rates))
+                                return -EINVAL;
+
+                } else {
+                        new_sysclk = 12288000;
+                }
+
+                ret = wm9081_set_fll(codec, WM9081_SYSCLK_FLL_MCLK,
+                                     wm9081->mclk_rate, new_sysclk);
+                if (ret == 0) {
+                        wm9081->sysclk_rate = new_sysclk;
+
+                        /* Switch SYSCLK over to FLL */
+                        fll = 1;
+                } else {
+                        wm9081->sysclk_rate = wm9081->mclk_rate;
+                }
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        reg = snd_soc_read(codec, WM9081_CLOCK_CONTROL_1);
+        if (mclkdiv)
+                reg |= WM9081_MCLKDIV2;
+        else
+                reg &= ~WM9081_MCLKDIV2;
+        snd_soc_write(codec, WM9081_CLOCK_CONTROL_1, reg);
+
+        reg = snd_soc_read(codec, WM9081_CLOCK_CONTROL_3);
+        if (fll)
+                reg |= WM9081_CLK_SRC_SEL;
+        else
+                reg &= ~WM9081_CLK_SRC_SEL;
+        snd_soc_write(codec, WM9081_CLOCK_CONTROL_3, reg);
+
+        dev_dbg(codec->dev, "CLK_SYS is %dHz\n", wm9081->sysclk_rate);
+
+        return ret;
+}
+
+static int clk_sys_event(struct snd_soc_dapm_widget *w,
+                         struct snd_kcontrol *kcontrol, int event)
+{
+        struct snd_soc_codec *codec = w->codec;
+        struct wm9081_priv *wm9081 = codec->private_data;
+
+        /* This should be done on init() for bypass paths */
+        switch (wm9081->sysclk_source) {
+        case WM9081_SYSCLK_MCLK:
+                dev_dbg(codec->dev, "Using %dHz MCLK\n", wm9081->mclk_rate);
+                break;
+        case WM9081_SYSCLK_FLL_MCLK:
+                dev_dbg(codec->dev, "Using %dHz MCLK with FLL\n",
+                        wm9081->mclk_rate);
+                break;
+        default:
+                dev_err(codec->dev, "System clock not configured\n");
+                return -EINVAL;
+        }
+
+        switch (event) {
+        case SND_SOC_DAPM_PRE_PMU:
+                configure_clock(codec);
+                break;
+
+        case SND_SOC_DAPM_POST_PMD:
+                /* Disable the FLL if it's running */
+                wm9081_set_fll(codec, 0, 0, 0);
+                break;
+        }
+
+        return 0;
+}
+
+static const struct snd_soc_dapm_widget wm9081_dapm_widgets[] = {
+SND_SOC_DAPM_INPUT("IN1"),
+SND_SOC_DAPM_INPUT("IN2"),
+
+SND_SOC_DAPM_DAC("DAC", "HiFi Playback", WM9081_POWER_MANAGEMENT, 0, 0),
+
+SND_SOC_DAPM_MIXER_NAMED_CTL("Mixer", SND_SOC_NOPM, 0, 0,
+                             mixer, ARRAY_SIZE(mixer)),
+
+SND_SOC_DAPM_PGA("LINEOUT PGA", WM9081_POWER_MANAGEMENT, 4, 0, NULL, 0),
+
+SND_SOC_DAPM_PGA_E("Speaker PGA", WM9081_POWER_MANAGEMENT, 2, 0, NULL, 0,
+                   speaker_event,
+                   SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
+
+SND_SOC_DAPM_OUTPUT("LINEOUT"),
+SND_SOC_DAPM_OUTPUT("SPKN"),
+SND_SOC_DAPM_OUTPUT("SPKP"),
+
+SND_SOC_DAPM_SUPPLY("CLK_SYS", WM9081_CLOCK_CONTROL_3, 0, 0, clk_sys_event,
+                    SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
+SND_SOC_DAPM_SUPPLY("CLK_DSP", WM9081_CLOCK_CONTROL_3, 1, 0, NULL, 0),
+SND_SOC_DAPM_SUPPLY("TOCLK", WM9081_CLOCK_CONTROL_3, 2, 0, NULL, 0),
+};
+
+
+static const struct snd_soc_dapm_route audio_paths[] = {
+        { "DAC", NULL, "CLK_SYS" },
+        { "DAC", NULL, "CLK_DSP" },
+
+        { "Mixer", "IN1 Switch", "IN1" },
+        { "Mixer", "IN2 Switch", "IN2" },
+        { "Mixer", "Playback Switch", "DAC" },
+
+        { "LINEOUT PGA", NULL, "Mixer" },
+        { "LINEOUT PGA", NULL, "TOCLK" },
+        { "LINEOUT PGA", NULL, "CLK_SYS" },
+
+        { "LINEOUT", NULL, "LINEOUT PGA" },
+
+        { "Speaker PGA", NULL, "Mixer" },
+        { "Speaker PGA", NULL, "TOCLK" },
+        { "Speaker PGA", NULL, "CLK_SYS" },
+
+        { "SPKN", NULL, "Speaker PGA" },
+        { "SPKP", NULL, "Speaker PGA" },
+};
+
+static int wm9081_set_bias_level(struct snd_soc_codec *codec,
+                                 enum snd_soc_bias_level level)
+{
+        u16 reg;
+
+        switch (level) {
+        case SND_SOC_BIAS_ON:
+                break;
+
+        case SND_SOC_BIAS_PREPARE:
+                /* VMID=2*40k */
+                reg = snd_soc_read(codec, WM9081_VMID_CONTROL);
+                reg &= ~WM9081_VMID_SEL_MASK;
+                reg |= 0x2;
+                snd_soc_write(codec, WM9081_VMID_CONTROL, reg);
+
+                /* Normal bias current */
+                reg = snd_soc_read(codec, WM9081_BIAS_CONTROL_1);
+                reg &= ~WM9081_STBY_BIAS_ENA;
+                snd_soc_write(codec, WM9081_BIAS_CONTROL_1, reg);
+                break;
+
+        case SND_SOC_BIAS_STANDBY:
+                /* Initial cold start */
+                if (codec->bias_level == SND_SOC_BIAS_OFF) {
+                        /* Disable LINEOUT discharge */
+                        reg = snd_soc_read(codec, WM9081_ANTI_POP_CONTROL);
+                        reg &= ~WM9081_LINEOUT_DISCH;
+                        snd_soc_write(codec, WM9081_ANTI_POP_CONTROL, reg);
+
+                        /* Select startup bias source */
+                        reg = snd_soc_read(codec, WM9081_BIAS_CONTROL_1);
+                        reg |= WM9081_BIAS_SRC | WM9081_BIAS_ENA;
+                        snd_soc_write(codec, WM9081_BIAS_CONTROL_1, reg);
+
+                        /* VMID 2*4k; Soft VMID ramp enable */
+                        reg = snd_soc_read(codec, WM9081_VMID_CONTROL);
+                        reg |= WM9081_VMID_RAMP | 0x6;
+                        snd_soc_write(codec, WM9081_VMID_CONTROL, reg);
+
+                        mdelay(100);
+
+                        /* Normal bias enable & soft start off */
+                        reg |= WM9081_BIAS_ENA;
+                        reg &= ~WM9081_VMID_RAMP;
+                        snd_soc_write(codec, WM9081_VMID_CONTROL, reg);
+
+                        /* Standard bias source */
+                        reg = snd_soc_read(codec, WM9081_BIAS_CONTROL_1);
+                        reg &= ~WM9081_BIAS_SRC;
+                        snd_soc_write(codec, WM9081_BIAS_CONTROL_1, reg);
+                }
+
+                /* VMID 2*240k */
+                reg = snd_soc_read(codec, WM9081_BIAS_CONTROL_1);
+                reg &= ~WM9081_VMID_SEL_MASK;
+                reg |= 0x40;
+                snd_soc_write(codec, WM9081_VMID_CONTROL, reg);
+
+                /* Standby bias current on */
+                reg = snd_soc_read(codec, WM9081_BIAS_CONTROL_1);
+                reg |= WM9081_STBY_BIAS_ENA;
+                snd_soc_write(codec, WM9081_BIAS_CONTROL_1, reg);
+                break;
+
+        case SND_SOC_BIAS_OFF:
+                /* Startup bias source */
+                reg = snd_soc_read(codec, WM9081_BIAS_CONTROL_1);
+                reg |= WM9081_BIAS_SRC;
+                snd_soc_write(codec, WM9081_BIAS_CONTROL_1, reg);
+
+                /* Disable VMID and biases with soft ramping */
+                reg = snd_soc_read(codec, WM9081_VMID_CONTROL);
+                reg &= ~(WM9081_VMID_SEL_MASK | WM9081_BIAS_ENA);
+                reg |= WM9081_VMID_RAMP;
+                snd_soc_write(codec, WM9081_VMID_CONTROL, reg);
+
+                /* Actively discharge LINEOUT */
+                reg = snd_soc_read(codec, WM9081_ANTI_POP_CONTROL);
+                reg |= WM9081_LINEOUT_DISCH;
+                snd_soc_write(codec, WM9081_ANTI_POP_CONTROL, reg);
+                break;
+        }
+
+        codec->bias_level = level;
+
+        return 0;
+}
+
+static int wm9081_set_dai_fmt(struct snd_soc_dai *dai,
+                              unsigned int fmt)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        struct wm9081_priv *wm9081 = codec->private_data;
+        unsigned int aif2 = snd_soc_read(codec, WM9081_AUDIO_INTERFACE_2);
+
+        aif2 &= ~(WM9081_AIF_BCLK_INV | WM9081_AIF_LRCLK_INV |
+                  WM9081_BCLK_DIR | WM9081_LRCLK_DIR | WM9081_AIF_FMT_MASK);
+
+        switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
+        case SND_SOC_DAIFMT_CBS_CFS:
+                wm9081->master = 0;
+                break;
+        case SND_SOC_DAIFMT_CBS_CFM:
+                aif2 |= WM9081_LRCLK_DIR;
+                wm9081->master = 1;
+                break;
+        case SND_SOC_DAIFMT_CBM_CFS:
+                aif2 |= WM9081_BCLK_DIR;
+                wm9081->master = 1;
+                break;
+        case SND_SOC_DAIFMT_CBM_CFM:
+                aif2 |= WM9081_LRCLK_DIR | WM9081_BCLK_DIR;
+                wm9081->master = 1;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
+        case SND_SOC_DAIFMT_DSP_B:
+                aif2 |= WM9081_AIF_LRCLK_INV;
+        case SND_SOC_DAIFMT_DSP_A:
+                aif2 |= 0x3;
+                break;
+        case SND_SOC_DAIFMT_I2S:
+                aif2 |= 0x2;
+                break;
+        case SND_SOC_DAIFMT_RIGHT_J:
+                break;
+        case SND_SOC_DAIFMT_LEFT_J:
+                aif2 |= 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:
+                        aif2 |= WM9081_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:
+                        aif2 |= WM9081_AIF_BCLK_INV | WM9081_AIF_LRCLK_INV;
+                        break;
+                case SND_SOC_DAIFMT_IB_NF:
+                        aif2 |= WM9081_AIF_BCLK_INV;
+                        break;
+                case SND_SOC_DAIFMT_NB_IF:
+                        aif2 |= WM9081_AIF_LRCLK_INV;
+                        break;
+                default:
+                        return -EINVAL;
+                }
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        snd_soc_write(codec, WM9081_AUDIO_INTERFACE_2, aif2);
+
+        return 0;
+}
+
+static int wm9081_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 wm9081_priv *wm9081 = codec->private_data;
+        int ret, i, best, best_val, cur_val;
+        unsigned int clk_ctrl2, aif1, aif2, aif3, aif4;
+
+        clk_ctrl2 = snd_soc_read(codec, WM9081_CLOCK_CONTROL_2);
+        clk_ctrl2 &= ~(WM9081_CLK_SYS_RATE_MASK | WM9081_SAMPLE_RATE_MASK);
+
+        aif1 = snd_soc_read(codec, WM9081_AUDIO_INTERFACE_1);
+
+        aif2 = snd_soc_read(codec, WM9081_AUDIO_INTERFACE_2);
+        aif2 &= ~WM9081_AIF_WL_MASK;
+
+        aif3 = snd_soc_read(codec, WM9081_AUDIO_INTERFACE_3);
+        aif3 &= ~WM9081_BCLK_DIV_MASK;
+
+        aif4 = snd_soc_read(codec, WM9081_AUDIO_INTERFACE_4);
+        aif4 &= ~WM9081_LRCLK_RATE_MASK;
+
+        wm9081->fs = params_rate(params);
+
+        if (wm9081->tdm_width) {
+                /* If TDM is set up then that fixes our BCLK. */
+                int slots = ((aif1 & WM9081_AIFDAC_TDM_MODE_MASK) >>
+                             WM9081_AIFDAC_TDM_MODE_SHIFT) + 1;
+
+                wm9081->bclk = wm9081->fs * wm9081->tdm_width * slots;
+        } else {
+                /* Otherwise work out a BCLK from the sample size */
+                wm9081->bclk = 2 * wm9081->fs;
+
+                switch (params_format(params)) {
+                case SNDRV_PCM_FORMAT_S16_LE:
+                        wm9081->bclk *= 16;
+                        break;
+                case SNDRV_PCM_FORMAT_S20_3LE:
+                        wm9081->bclk *= 20;
+                        aif2 |= 0x4;
+                        break;
+                case SNDRV_PCM_FORMAT_S24_LE:
+                        wm9081->bclk *= 24;
+                        aif2 |= 0x8;
+                        break;
+                case SNDRV_PCM_FORMAT_S32_LE:
+                        wm9081->bclk *= 32;
+                        aif2 |= 0xc;
+                        break;
+                default:
+                        return -EINVAL;
+                }
+        }
+
+        dev_dbg(codec->dev, "Target BCLK is %dHz\n", wm9081->bclk);
+
+        ret = configure_clock(codec);
+        if (ret != 0)
+                return ret;
+
+        /* Select nearest CLK_SYS_RATE */
+        best = 0;
+        best_val = abs((wm9081->sysclk_rate / clk_sys_rates[0].ratio)
+                       - wm9081->fs);
+        for (i = 1; i < ARRAY_SIZE(clk_sys_rates); i++) {
+                cur_val = abs((wm9081->sysclk_rate /
+                               clk_sys_rates[i].ratio) - wm9081->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);
+        clk_ctrl2 |= (clk_sys_rates[best].clk_sys_rate
+                      << WM9081_CLK_SYS_RATE_SHIFT);
+
+        /* SAMPLE_RATE */
+        best = 0;
+        best_val = abs(wm9081->fs - sample_rates[0].rate);
+        for (i = 1; i < ARRAY_SIZE(sample_rates); i++) {
+                /* Closest match */
+                cur_val = abs(wm9081->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);
+        clk_ctrl2 |= (sample_rates[best].sample_rate
+                        << WM9081_SAMPLE_RATE_SHIFT);
+
+        /* BCLK_DIV */
+        best = 0;
+        best_val = INT_MAX;
+        for (i = 0; i < ARRAY_SIZE(bclk_divs); i++) {
+                cur_val = ((wm9081->sysclk_rate * 10) / bclk_divs[i].div)
+                        - wm9081->bclk;
+                if (cur_val < 0) /* Table is sorted */
+                        break;
+                if (cur_val < best_val) {
+                        best = i;
+                        best_val = cur_val;
+                }
+        }
+        wm9081->bclk = (wm9081->sysclk_rate * 10) / bclk_divs[best].div;
+        dev_dbg(codec->dev, "Selected BCLK_DIV of %d for %dHz BCLK\n",
+                bclk_divs[best].div, wm9081->bclk);
+        aif3 |= bclk_divs[best].bclk_div;
+
+        /* LRCLK is a simple fraction of BCLK */
+        dev_dbg(codec->dev, "LRCLK_RATE is %d\n", wm9081->bclk / wm9081->fs);
+        aif4 |= wm9081->bclk / wm9081->fs;
+
+        /* Apply a ReTune Mobile configuration if it's in use */
+        if (wm9081->retune) {
+                struct wm9081_retune_mobile_config *retune = wm9081->retune;
+                struct wm9081_retune_mobile_setting *s;
+                int eq1;
+
+                best = 0;
+                best_val = abs(retune->configs[0].rate - wm9081->fs);
+                for (i = 0; i < retune->num_configs; i++) {
+                        cur_val = abs(retune->configs[i].rate - wm9081->fs);
+                        if (cur_val < best_val) {
+                                best_val = cur_val;
+                                best = i;
+                        }
+                }
+                s = &retune->configs[best];
+
+                dev_dbg(codec->dev, "ReTune Mobile %s tuned for %dHz\n",
+                        s->name, s->rate);
+
+                /* If the EQ is enabled then disable it while we write out */
+                eq1 = snd_soc_read(codec, WM9081_EQ_1) & WM9081_EQ_ENA;
+                if (eq1 & WM9081_EQ_ENA)
+                        snd_soc_write(codec, WM9081_EQ_1, 0);
+
+                /* Write out the other values */
+                for (i = 1; i < ARRAY_SIZE(s->config); i++)
+                        snd_soc_write(codec, WM9081_EQ_1 + i, s->config[i]);
+
+                eq1 |= (s->config[0] & ~WM9081_EQ_ENA);
+                snd_soc_write(codec, WM9081_EQ_1, eq1);
+        }
+
+        snd_soc_write(codec, WM9081_CLOCK_CONTROL_2, clk_ctrl2);
+        snd_soc_write(codec, WM9081_AUDIO_INTERFACE_2, aif2);
+        snd_soc_write(codec, WM9081_AUDIO_INTERFACE_3, aif3);
+        snd_soc_write(codec, WM9081_AUDIO_INTERFACE_4, aif4);
+
+        return 0;
+}
+
+static int wm9081_digital_mute(struct snd_soc_dai *codec_dai, int mute)
+{
+        struct snd_soc_codec *codec = codec_dai->codec;
+        unsigned int reg;
+
+        reg = snd_soc_read(codec, WM9081_DAC_DIGITAL_2);
+
+        if (mute)
+                reg |= WM9081_DAC_MUTE;
+        else
+                reg &= ~WM9081_DAC_MUTE;
+
+        snd_soc_write(codec, WM9081_DAC_DIGITAL_2, reg);
+
+        return 0;
+}
+
+static int wm9081_set_sysclk(struct snd_soc_dai *codec_dai,
+                             int clk_id, unsigned int freq, int dir)
+{
+        struct snd_soc_codec *codec = codec_dai->codec;
+        struct wm9081_priv *wm9081 = codec->private_data;
+
+        switch (clk_id) {
+        case WM9081_SYSCLK_MCLK:
+        case WM9081_SYSCLK_FLL_MCLK:
+                wm9081->sysclk_source = clk_id;
+                wm9081->mclk_rate = freq;
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int wm9081_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 wm9081_priv *wm9081 = codec->private_data;
+        unsigned int aif1 = snd_soc_read(codec, WM9081_AUDIO_INTERFACE_1);
+
+        aif1 &= ~(WM9081_AIFDAC_TDM_SLOT_MASK | WM9081_AIFDAC_TDM_MODE_MASK);
+
+        if (slots < 0 || slots > 4)
+                return -EINVAL;
+
+        wm9081->tdm_width = slot_width;
+
+        if (slots == 0)
+                slots = 1;
+
+        aif1 |= (slots - 1) << WM9081_AIFDAC_TDM_MODE_SHIFT;
+
+        switch (rx_mask) {
+        case 1:
+                break;
+        case 2:
+                aif1 |= 0x10;
+                break;
+        case 4:
+                aif1 |= 0x20;
+                break;
+        case 8:
+                aif1 |= 0x30;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        snd_soc_write(codec, WM9081_AUDIO_INTERFACE_1, aif1);
+
+        return 0;
+}
+
+#define WM9081_RATES SNDRV_PCM_RATE_8000_96000
+
+#define WM9081_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 wm9081_dai_ops = {
+        .hw_params = wm9081_hw_params,
+        .set_sysclk = wm9081_set_sysclk,
+        .set_fmt = wm9081_set_dai_fmt,
+        .digital_mute = wm9081_digital_mute,
+        .set_tdm_slot = wm9081_set_tdm_slot,
+};
+
+/* We report two channels because the CODEC processes a stereo signal, even
+ * though it is only capable of handling a mono output.
+ */
+struct snd_soc_dai wm9081_dai = {
+        .name = "WM9081",
+        .playback = {
+                .stream_name = "HiFi Playback",
+                .channels_min = 1,
+                .channels_max = 2,
+                .rates = WM9081_RATES,
+                .formats = WM9081_FORMATS,
+        },
+        .ops = &wm9081_dai_ops,
+};
+EXPORT_SYMBOL_GPL(wm9081_dai);
+
+
+static struct snd_soc_codec *wm9081_codec;
+
+static int wm9081_probe(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec;
+        struct wm9081_priv *wm9081;
+        int ret = 0;
+
+        if (wm9081_codec == NULL) {
+                dev_err(&pdev->dev, "Codec device not registered\n");
+                return -ENODEV;
+        }
+
+        socdev->card->codec = wm9081_codec;
+        codec = wm9081_codec;
+        wm9081 = codec->private_data;
+
+        /* 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, wm9081_snd_controls,
+                             ARRAY_SIZE(wm9081_snd_controls));
+        if (!wm9081->retune) {
+                dev_dbg(codec->dev,
+                        "No ReTune Mobile data, using normal EQ\n");
+                snd_soc_add_controls(codec, wm9081_eq_controls,
+                                     ARRAY_SIZE(wm9081_eq_controls));
+        }
+
+        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;
+}
+
+static int wm9081_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;
+}
+
+#ifdef CONFIG_PM
+static int wm9081_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;
+
+        wm9081_set_bias_level(codec, SND_SOC_BIAS_OFF);
+
+        return 0;
+}
+
+static int wm9081_resume(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec = socdev->card->codec;
+        u16 *reg_cache = codec->reg_cache;
+        int i;
+
+        for (i = 0; i < codec->reg_cache_size; i++) {
+                if (i == WM9081_SOFTWARE_RESET)
+                        continue;
+
+                snd_soc_write(codec, i, reg_cache[i]);
+        }
+
+        wm9081_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+
+        return 0;
+}
+#else
+#define wm9081_suspend NULL
+#define wm9081_resume NULL
+#endif
+
+struct snd_soc_codec_device soc_codec_dev_wm9081 = {
+        .probe =        wm9081_probe,
+        .remove =       wm9081_remove,
+        .suspend =      wm9081_suspend,
+        .resume =       wm9081_resume,
+};
+EXPORT_SYMBOL_GPL(soc_codec_dev_wm9081);
+
+static int wm9081_register(struct wm9081_priv *wm9081,
+                           enum snd_soc_control_type control)
+{
+        struct snd_soc_codec *codec = &wm9081->codec;
+        int ret;
+        u16 reg;
+
+        if (wm9081_codec) {
+                dev_err(codec->dev, "Another WM9081 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 = wm9081;
+        codec->name = "WM9081";
+        codec->owner = THIS_MODULE;
+        codec->dai = &wm9081_dai;
+        codec->num_dai = 1;
+        codec->reg_cache_size = ARRAY_SIZE(wm9081->reg_cache);
+        codec->reg_cache = &wm9081->reg_cache;
+        codec->bias_level = SND_SOC_BIAS_OFF;
+        codec->set_bias_level = wm9081_set_bias_level;
+        codec->volatile_register = wm9081_volatile_register;
+
+        memcpy(codec->reg_cache, wm9081_reg_defaults,
+               sizeof(wm9081_reg_defaults));
+
+        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);
+                return ret;
+        }
+
+        reg = snd_soc_read(codec, WM9081_SOFTWARE_RESET);
+        if (reg != 0x9081) {
+                dev_err(codec->dev, "Device is not a WM9081: ID=0x%x\n", reg);
+                ret = -EINVAL;
+                goto err;
+        }
+
+        ret = wm9081_reset(codec);
+        if (ret < 0) {
+                dev_err(codec->dev, "Failed to issue reset\n");
+                return ret;
+        }
+
+        wm9081_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+
+        /* Enable zero cross by default */
+        reg = snd_soc_read(codec, WM9081_ANALOGUE_LINEOUT);
+        snd_soc_write(codec, WM9081_ANALOGUE_LINEOUT, reg | WM9081_LINEOUTZC);
+        reg = snd_soc_read(codec, WM9081_ANALOGUE_SPEAKER_PGA);
+        snd_soc_write(codec, WM9081_ANALOGUE_SPEAKER_PGA,
+                     reg | WM9081_SPKPGAZC);
+
+        wm9081_dai.dev = codec->dev;
+
+        wm9081_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(&wm9081_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:
+        kfree(wm9081);
+        return ret;
+}
+
+static void wm9081_unregister(struct wm9081_priv *wm9081)
+{
+        wm9081_set_bias_level(&wm9081->codec, SND_SOC_BIAS_OFF);
+        snd_soc_unregister_dai(&wm9081_dai);
+        snd_soc_unregister_codec(&wm9081->codec);
+        kfree(wm9081);
+        wm9081_codec = NULL;
+}
+
+static __devinit int wm9081_i2c_probe(struct i2c_client *i2c,
+                                      const struct i2c_device_id *id)
+{
+        struct wm9081_priv *wm9081;
+        struct snd_soc_codec *codec;
+
+        wm9081 = kzalloc(sizeof(struct wm9081_priv), GFP_KERNEL);
+        if (wm9081 == NULL)
+                return -ENOMEM;
+
+        codec = &wm9081->codec;
+        codec->hw_write = (hw_write_t)i2c_master_send;
+        wm9081->retune = i2c->dev.platform_data;
+
+        i2c_set_clientdata(i2c, wm9081);
+        codec->control_data = i2c;
+
+        codec->dev = &i2c->dev;
+
+        return wm9081_register(wm9081, SND_SOC_I2C);
+}
+
+static __devexit int wm9081_i2c_remove(struct i2c_client *client)
+{
+        struct wm9081_priv *wm9081 = i2c_get_clientdata(client);
+        wm9081_unregister(wm9081);
+        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 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, wm9081_i2c_id);
+
+static struct i2c_driver wm9081_i2c_driver = {
+        .driver = {
+                .name = "wm9081",
+                .owner = THIS_MODULE,
+        },
+        .probe =    wm9081_i2c_probe,
+        .remove =   __devexit_p(wm9081_i2c_remove),
+        .suspend =  wm9081_i2c_suspend,
+        .resume =   wm9081_i2c_resume,
+        .id_table = wm9081_i2c_id,
+};
+
+static int __init wm9081_modinit(void)
+{
+        int ret;
+
+        ret = i2c_add_driver(&wm9081_i2c_driver);
+        if (ret != 0) {
+                printk(KERN_ERR "Failed to register WM9081 I2C driver: %d\n",
+                       ret);
+        }
+
+        return ret;
+}
+module_init(wm9081_modinit);
+
+static void __exit wm9081_exit(void)
+{
+        i2c_del_driver(&wm9081_i2c_driver);
+}
+module_exit(wm9081_exit);
+
+
+MODULE_DESCRIPTION("ASoC WM9081 driver");
+MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/codecs/wm9081.h b/sound/soc/codecs/wm9081.h
new file mode 100644
index 000000000000..42d3bc757021
--- /dev/null
+++ b/sound/soc/codecs/wm9081.h
@@ -0,0 +1,787 @@
+#ifndef WM9081_H
+#define WM9081_H
+
+/*
+ * wm9081.c  --  WM9081 ALSA SoC Audio driver
+ *
+ * Author: Mark Brown
+ *
+ * Copyright 2009 Wolfson Microelectronics plc
+ *
+ * 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 <sound/soc.h>
+
+extern struct snd_soc_dai wm9081_dai;
+extern struct snd_soc_codec_device soc_codec_dev_wm9081;
+
+/*
+ * SYSCLK sources
+ */
+#define WM9081_SYSCLK_MCLK      1   /* Use MCLK without FLL */
+#define WM9081_SYSCLK_FLL_MCLK  2   /* Use MCLK, enabling FLL if required */
+
+/*
+ * Register values.
+ */
+#define WM9081_SOFTWARE_RESET                   0x00
+#define WM9081_ANALOGUE_LINEOUT                 0x02
+#define WM9081_ANALOGUE_SPEAKER_PGA             0x03
+#define WM9081_VMID_CONTROL                     0x04
+#define WM9081_BIAS_CONTROL_1                   0x05
+#define WM9081_ANALOGUE_MIXER                   0x07
+#define WM9081_ANTI_POP_CONTROL                 0x08
+#define WM9081_ANALOGUE_SPEAKER_1               0x09
+#define WM9081_ANALOGUE_SPEAKER_2               0x0A
+#define WM9081_POWER_MANAGEMENT                 0x0B
+#define WM9081_CLOCK_CONTROL_1                  0x0C
+#define WM9081_CLOCK_CONTROL_2                  0x0D
+#define WM9081_CLOCK_CONTROL_3                  0x0E
+#define WM9081_FLL_CONTROL_1                    0x10
+#define WM9081_FLL_CONTROL_2                    0x11
+#define WM9081_FLL_CONTROL_3                    0x12
+#define WM9081_FLL_CONTROL_4                    0x13
+#define WM9081_FLL_CONTROL_5                    0x14
+#define WM9081_AUDIO_INTERFACE_1                0x16
+#define WM9081_AUDIO_INTERFACE_2                0x17
+#define WM9081_AUDIO_INTERFACE_3                0x18
+#define WM9081_AUDIO_INTERFACE_4                0x19
+#define WM9081_INTERRUPT_STATUS                 0x1A
+#define WM9081_INTERRUPT_STATUS_MASK            0x1B
+#define WM9081_INTERRUPT_POLARITY               0x1C
+#define WM9081_INTERRUPT_CONTROL                0x1D
+#define WM9081_DAC_DIGITAL_1                    0x1E
+#define WM9081_DAC_DIGITAL_2                    0x1F
+#define WM9081_DRC_1                            0x20
+#define WM9081_DRC_2                            0x21
+#define WM9081_DRC_3                            0x22
+#define WM9081_DRC_4                            0x23
+#define WM9081_WRITE_SEQUENCER_1                0x26
+#define WM9081_WRITE_SEQUENCER_2                0x27
+#define WM9081_MW_SLAVE_1                       0x28
+#define WM9081_EQ_1                             0x2A
+#define WM9081_EQ_2                             0x2B
+#define WM9081_EQ_3                             0x2C
+#define WM9081_EQ_4                             0x2D
+#define WM9081_EQ_5                             0x2E
+#define WM9081_EQ_6                             0x2F
+#define WM9081_EQ_7                             0x30
+#define WM9081_EQ_8                             0x31
+#define WM9081_EQ_9                             0x32
+#define WM9081_EQ_10                            0x33
+#define WM9081_EQ_11                            0x34
+#define WM9081_EQ_12                            0x35
+#define WM9081_EQ_13                            0x36
+#define WM9081_EQ_14                            0x37
+#define WM9081_EQ_15                            0x38
+#define WM9081_EQ_16                            0x39
+#define WM9081_EQ_17                            0x3A
+#define WM9081_EQ_18                            0x3B
+#define WM9081_EQ_19                            0x3C
+#define WM9081_EQ_20                            0x3D
+
+#define WM9081_REGISTER_COUNT                   55
+#define WM9081_MAX_REGISTER                     0x3D
+
+/*
+ * Field Definitions.
+ */
+
+/*
+ * R0 (0x00) - Software Reset
+ */
+#define WM9081_SW_RST_DEV_ID1_MASK              0xFFFF  /* SW_RST_DEV_ID1 - [15:0] */
+#define WM9081_SW_RST_DEV_ID1_SHIFT                  0  /* SW_RST_DEV_ID1 - [15:0] */
+#define WM9081_SW_RST_DEV_ID1_WIDTH                 16  /* SW_RST_DEV_ID1 - [15:0] */
+
+/*
+ * R2 (0x02) - Analogue Lineout
+ */
+#define WM9081_LINEOUT_MUTE                     0x0080  /* LINEOUT_MUTE */
+#define WM9081_LINEOUT_MUTE_MASK                0x0080  /* LINEOUT_MUTE */
+#define WM9081_LINEOUT_MUTE_SHIFT                    7  /* LINEOUT_MUTE */
+#define WM9081_LINEOUT_MUTE_WIDTH                    1  /* LINEOUT_MUTE */
+#define WM9081_LINEOUTZC                        0x0040  /* LINEOUTZC */
+#define WM9081_LINEOUTZC_MASK                   0x0040  /* LINEOUTZC */
+#define WM9081_LINEOUTZC_SHIFT                       6  /* LINEOUTZC */
+#define WM9081_LINEOUTZC_WIDTH                       1  /* LINEOUTZC */
+#define WM9081_LINEOUT_VOL_MASK                 0x003F  /* LINEOUT_VOL - [5:0] */
+#define WM9081_LINEOUT_VOL_SHIFT                     0  /* LINEOUT_VOL - [5:0] */
+#define WM9081_LINEOUT_VOL_WIDTH                     6  /* LINEOUT_VOL - [5:0] */
+
+/*
+ * R3 (0x03) - Analogue Speaker PGA
+ */
+#define WM9081_SPKPGA_MUTE                      0x0080  /* SPKPGA_MUTE */
+#define WM9081_SPKPGA_MUTE_MASK                 0x0080  /* SPKPGA_MUTE */
+#define WM9081_SPKPGA_MUTE_SHIFT                     7  /* SPKPGA_MUTE */
+#define WM9081_SPKPGA_MUTE_WIDTH                     1  /* SPKPGA_MUTE */
+#define WM9081_SPKPGAZC                         0x0040  /* SPKPGAZC */
+#define WM9081_SPKPGAZC_MASK                    0x0040  /* SPKPGAZC */
+#define WM9081_SPKPGAZC_SHIFT                        6  /* SPKPGAZC */
+#define WM9081_SPKPGAZC_WIDTH                        1  /* SPKPGAZC */
+#define WM9081_SPKPGA_VOL_MASK                  0x003F  /* SPKPGA_VOL - [5:0] */
+#define WM9081_SPKPGA_VOL_SHIFT                      0  /* SPKPGA_VOL - [5:0] */
+#define WM9081_SPKPGA_VOL_WIDTH                      6  /* SPKPGA_VOL - [5:0] */
+
+/*
+ * R4 (0x04) - VMID Control
+ */
+#define WM9081_VMID_BUF_ENA                     0x0020  /* VMID_BUF_ENA */
+#define WM9081_VMID_BUF_ENA_MASK                0x0020  /* VMID_BUF_ENA */
+#define WM9081_VMID_BUF_ENA_SHIFT                    5  /* VMID_BUF_ENA */
+#define WM9081_VMID_BUF_ENA_WIDTH                    1  /* VMID_BUF_ENA */
+#define WM9081_VMID_RAMP                        0x0008  /* VMID_RAMP */
+#define WM9081_VMID_RAMP_MASK                   0x0008  /* VMID_RAMP */
+#define WM9081_VMID_RAMP_SHIFT                       3  /* VMID_RAMP */
+#define WM9081_VMID_RAMP_WIDTH                       1  /* VMID_RAMP */
+#define WM9081_VMID_SEL_MASK                    0x0006  /* VMID_SEL - [2:1] */
+#define WM9081_VMID_SEL_SHIFT                        1  /* VMID_SEL - [2:1] */
+#define WM9081_VMID_SEL_WIDTH                        2  /* VMID_SEL - [2:1] */
+#define WM9081_VMID_FAST_ST                     0x0001  /* VMID_FAST_ST */
+#define WM9081_VMID_FAST_ST_MASK                0x0001  /* VMID_FAST_ST */
+#define WM9081_VMID_FAST_ST_SHIFT                    0  /* VMID_FAST_ST */
+#define WM9081_VMID_FAST_ST_WIDTH                    1  /* VMID_FAST_ST */
+
+/*
+ * R5 (0x05) - Bias Control 1
+ */
+#define WM9081_BIAS_SRC                         0x0040  /* BIAS_SRC */
+#define WM9081_BIAS_SRC_MASK                    0x0040  /* BIAS_SRC */
+#define WM9081_BIAS_SRC_SHIFT                        6  /* BIAS_SRC */
+#define WM9081_BIAS_SRC_WIDTH                        1  /* BIAS_SRC */
+#define WM9081_STBY_BIAS_LVL                    0x0020  /* STBY_BIAS_LVL */
+#define WM9081_STBY_BIAS_LVL_MASK               0x0020  /* STBY_BIAS_LVL */
+#define WM9081_STBY_BIAS_LVL_SHIFT                   5  /* STBY_BIAS_LVL */
+#define WM9081_STBY_BIAS_LVL_WIDTH                   1  /* STBY_BIAS_LVL */
+#define WM9081_STBY_BIAS_ENA                    0x0010  /* STBY_BIAS_ENA */
+#define WM9081_STBY_BIAS_ENA_MASK               0x0010  /* STBY_BIAS_ENA */
+#define WM9081_STBY_BIAS_ENA_SHIFT                   4  /* STBY_BIAS_ENA */
+#define WM9081_STBY_BIAS_ENA_WIDTH                   1  /* STBY_BIAS_ENA */
+#define WM9081_BIAS_LVL_MASK                    0x000C  /* BIAS_LVL - [3:2] */
+#define WM9081_BIAS_LVL_SHIFT                        2  /* BIAS_LVL - [3:2] */
+#define WM9081_BIAS_LVL_WIDTH                        2  /* BIAS_LVL - [3:2] */
+#define WM9081_BIAS_ENA                         0x0002  /* BIAS_ENA */
+#define WM9081_BIAS_ENA_MASK                    0x0002  /* BIAS_ENA */
+#define WM9081_BIAS_ENA_SHIFT                        1  /* BIAS_ENA */
+#define WM9081_BIAS_ENA_WIDTH                        1  /* BIAS_ENA */
+#define WM9081_STARTUP_BIAS_ENA                 0x0001  /* STARTUP_BIAS_ENA */
+#define WM9081_STARTUP_BIAS_ENA_MASK            0x0001  /* STARTUP_BIAS_ENA */
+#define WM9081_STARTUP_BIAS_ENA_SHIFT                0  /* STARTUP_BIAS_ENA */
+#define WM9081_STARTUP_BIAS_ENA_WIDTH                1  /* STARTUP_BIAS_ENA */
+
+/*
+ * R7 (0x07) - Analogue Mixer
+ */
+#define WM9081_DAC_SEL                          0x0010  /* DAC_SEL */
+#define WM9081_DAC_SEL_MASK                     0x0010  /* DAC_SEL */
+#define WM9081_DAC_SEL_SHIFT                         4  /* DAC_SEL */
+#define WM9081_DAC_SEL_WIDTH                         1  /* DAC_SEL */
+#define WM9081_IN2_VOL                          0x0008  /* IN2_VOL */
+#define WM9081_IN2_VOL_MASK                     0x0008  /* IN2_VOL */
+#define WM9081_IN2_VOL_SHIFT                         3  /* IN2_VOL */
+#define WM9081_IN2_VOL_WIDTH                         1  /* IN2_VOL */
+#define WM9081_IN2_ENA                          0x0004  /* IN2_ENA */
+#define WM9081_IN2_ENA_MASK                     0x0004  /* IN2_ENA */
+#define WM9081_IN2_ENA_SHIFT                         2  /* IN2_ENA */
+#define WM9081_IN2_ENA_WIDTH                         1  /* IN2_ENA */
+#define WM9081_IN1_VOL                          0x0002  /* IN1_VOL */
+#define WM9081_IN1_VOL_MASK                     0x0002  /* IN1_VOL */
+#define WM9081_IN1_VOL_SHIFT                         1  /* IN1_VOL */
+#define WM9081_IN1_VOL_WIDTH                         1  /* IN1_VOL */
+#define WM9081_IN1_ENA                          0x0001  /* IN1_ENA */
+#define WM9081_IN1_ENA_MASK                     0x0001  /* IN1_ENA */
+#define WM9081_IN1_ENA_SHIFT                         0  /* IN1_ENA */
+#define WM9081_IN1_ENA_WIDTH                         1  /* IN1_ENA */
+
+/*
+ * R8 (0x08) - Anti Pop Control
+ */
+#define WM9081_LINEOUT_DISCH                    0x0004  /* LINEOUT_DISCH */
+#define WM9081_LINEOUT_DISCH_MASK               0x0004  /* LINEOUT_DISCH */
+#define WM9081_LINEOUT_DISCH_SHIFT                   2  /* LINEOUT_DISCH */
+#define WM9081_LINEOUT_DISCH_WIDTH                   1  /* LINEOUT_DISCH */
+#define WM9081_LINEOUT_VROI                     0x0002  /* LINEOUT_VROI */
+#define WM9081_LINEOUT_VROI_MASK                0x0002  /* LINEOUT_VROI */
+#define WM9081_LINEOUT_VROI_SHIFT                    1  /* LINEOUT_VROI */
+#define WM9081_LINEOUT_VROI_WIDTH                    1  /* LINEOUT_VROI */
+#define WM9081_LINEOUT_CLAMP                    0x0001  /* LINEOUT_CLAMP */
+#define WM9081_LINEOUT_CLAMP_MASK               0x0001  /* LINEOUT_CLAMP */
+#define WM9081_LINEOUT_CLAMP_SHIFT                   0  /* LINEOUT_CLAMP */
+#define WM9081_LINEOUT_CLAMP_WIDTH                   1  /* LINEOUT_CLAMP */
+
+/*
+ * R9 (0x09) - Analogue Speaker 1
+ */
+#define WM9081_SPK_DCGAIN_MASK                  0x0038  /* SPK_DCGAIN - [5:3] */
+#define WM9081_SPK_DCGAIN_SHIFT                      3  /* SPK_DCGAIN - [5:3] */
+#define WM9081_SPK_DCGAIN_WIDTH                      3  /* SPK_DCGAIN - [5:3] */
+#define WM9081_SPK_ACGAIN_MASK                  0x0007  /* SPK_ACGAIN - [2:0] */
+#define WM9081_SPK_ACGAIN_SHIFT                      0  /* SPK_ACGAIN - [2:0] */
+#define WM9081_SPK_ACGAIN_WIDTH                      3  /* SPK_ACGAIN - [2:0] */
+
+/*
+ * R10 (0x0A) - Analogue Speaker 2
+ */
+#define WM9081_SPK_MODE                         0x0040  /* SPK_MODE */
+#define WM9081_SPK_MODE_MASK                    0x0040  /* SPK_MODE */
+#define WM9081_SPK_MODE_SHIFT                        6  /* SPK_MODE */
+#define WM9081_SPK_MODE_WIDTH                        1  /* SPK_MODE */
+#define WM9081_SPK_INV_MUTE                     0x0010  /* SPK_INV_MUTE */
+#define WM9081_SPK_INV_MUTE_MASK                0x0010  /* SPK_INV_MUTE */
+#define WM9081_SPK_INV_MUTE_SHIFT                    4  /* SPK_INV_MUTE */
+#define WM9081_SPK_INV_MUTE_WIDTH                    1  /* SPK_INV_MUTE */
+#define WM9081_OUT_SPK_CTRL                     0x0008  /* OUT_SPK_CTRL */
+#define WM9081_OUT_SPK_CTRL_MASK                0x0008  /* OUT_SPK_CTRL */
+#define WM9081_OUT_SPK_CTRL_SHIFT                    3  /* OUT_SPK_CTRL */
+#define WM9081_OUT_SPK_CTRL_WIDTH                    1  /* OUT_SPK_CTRL */
+
+/*
+ * R11 (0x0B) - Power Management
+ */
+#define WM9081_TSHUT_ENA                        0x0100  /* TSHUT_ENA */
+#define WM9081_TSHUT_ENA_MASK                   0x0100  /* TSHUT_ENA */
+#define WM9081_TSHUT_ENA_SHIFT                       8  /* TSHUT_ENA */
+#define WM9081_TSHUT_ENA_WIDTH                       1  /* TSHUT_ENA */
+#define WM9081_TSENSE_ENA                       0x0080  /* TSENSE_ENA */
+#define WM9081_TSENSE_ENA_MASK                  0x0080  /* TSENSE_ENA */
+#define WM9081_TSENSE_ENA_SHIFT                      7  /* TSENSE_ENA */
+#define WM9081_TSENSE_ENA_WIDTH                      1  /* TSENSE_ENA */
+#define WM9081_TEMP_SHUT                        0x0040  /* TEMP_SHUT */
+#define WM9081_TEMP_SHUT_MASK                   0x0040  /* TEMP_SHUT */
+#define WM9081_TEMP_SHUT_SHIFT                       6  /* TEMP_SHUT */
+#define WM9081_TEMP_SHUT_WIDTH                       1  /* TEMP_SHUT */
+#define WM9081_LINEOUT_ENA                      0x0010  /* LINEOUT_ENA */
+#define WM9081_LINEOUT_ENA_MASK                 0x0010  /* LINEOUT_ENA */
+#define WM9081_LINEOUT_ENA_SHIFT                     4  /* LINEOUT_ENA */
+#define WM9081_LINEOUT_ENA_WIDTH                     1  /* LINEOUT_ENA */
+#define WM9081_SPKPGA_ENA                       0x0004  /* SPKPGA_ENA */
+#define WM9081_SPKPGA_ENA_MASK                  0x0004  /* SPKPGA_ENA */
+#define WM9081_SPKPGA_ENA_SHIFT                      2  /* SPKPGA_ENA */
+#define WM9081_SPKPGA_ENA_WIDTH                      1  /* SPKPGA_ENA */
+#define WM9081_SPK_ENA                          0x0002  /* SPK_ENA */
+#define WM9081_SPK_ENA_MASK                     0x0002  /* SPK_ENA */
+#define WM9081_SPK_ENA_SHIFT                         1  /* SPK_ENA */
+#define WM9081_SPK_ENA_WIDTH                         1  /* SPK_ENA */
+#define WM9081_DAC_ENA                          0x0001  /* DAC_ENA */
+#define WM9081_DAC_ENA_MASK                     0x0001  /* DAC_ENA */
+#define WM9081_DAC_ENA_SHIFT                         0  /* DAC_ENA */
+#define WM9081_DAC_ENA_WIDTH                         1  /* DAC_ENA */
+
+/*
+ * R12 (0x0C) - Clock Control 1
+ */
+#define WM9081_CLK_OP_DIV_MASK                  0x1C00  /* CLK_OP_DIV - [12:10] */
+#define WM9081_CLK_OP_DIV_SHIFT                     10  /* CLK_OP_DIV - [12:10] */
+#define WM9081_CLK_OP_DIV_WIDTH                      3  /* CLK_OP_DIV - [12:10] */
+#define WM9081_CLK_TO_DIV_MASK                  0x0300  /* CLK_TO_DIV - [9:8] */
+#define WM9081_CLK_TO_DIV_SHIFT                      8  /* CLK_TO_DIV - [9:8] */
+#define WM9081_CLK_TO_DIV_WIDTH                      2  /* CLK_TO_DIV - [9:8] */
+#define WM9081_MCLKDIV2                         0x0080  /* MCLKDIV2 */
+#define WM9081_MCLKDIV2_MASK                    0x0080  /* MCLKDIV2 */
+#define WM9081_MCLKDIV2_SHIFT                        7  /* MCLKDIV2 */
+#define WM9081_MCLKDIV2_WIDTH                        1  /* MCLKDIV2 */
+
+/*
+ * R13 (0x0D) - Clock Control 2
+ */
+#define WM9081_CLK_SYS_RATE_MASK                0x00F0  /* CLK_SYS_RATE - [7:4] */
+#define WM9081_CLK_SYS_RATE_SHIFT                    4  /* CLK_SYS_RATE - [7:4] */
+#define WM9081_CLK_SYS_RATE_WIDTH                    4  /* CLK_SYS_RATE - [7:4] */
+#define WM9081_SAMPLE_RATE_MASK                 0x000F  /* SAMPLE_RATE - [3:0] */
+#define WM9081_SAMPLE_RATE_SHIFT                     0  /* SAMPLE_RATE - [3:0] */
+#define WM9081_SAMPLE_RATE_WIDTH                     4  /* SAMPLE_RATE - [3:0] */
+
+/*
+ * R14 (0x0E) - Clock Control 3
+ */
+#define WM9081_CLK_SRC_SEL                      0x2000  /* CLK_SRC_SEL */
+#define WM9081_CLK_SRC_SEL_MASK                 0x2000  /* CLK_SRC_SEL */
+#define WM9081_CLK_SRC_SEL_SHIFT                    13  /* CLK_SRC_SEL */
+#define WM9081_CLK_SRC_SEL_WIDTH                     1  /* CLK_SRC_SEL */
+#define WM9081_CLK_OP_ENA                       0x0020  /* CLK_OP_ENA */
+#define WM9081_CLK_OP_ENA_MASK                  0x0020  /* CLK_OP_ENA */
+#define WM9081_CLK_OP_ENA_SHIFT                      5  /* CLK_OP_ENA */
+#define WM9081_CLK_OP_ENA_WIDTH                      1  /* CLK_OP_ENA */
+#define WM9081_CLK_TO_ENA                       0x0004  /* CLK_TO_ENA */
+#define WM9081_CLK_TO_ENA_MASK                  0x0004  /* CLK_TO_ENA */
+#define WM9081_CLK_TO_ENA_SHIFT                      2  /* CLK_TO_ENA */
+#define WM9081_CLK_TO_ENA_WIDTH                      1  /* CLK_TO_ENA */
+#define WM9081_CLK_DSP_ENA                      0x0002  /* CLK_DSP_ENA */
+#define WM9081_CLK_DSP_ENA_MASK                 0x0002  /* CLK_DSP_ENA */
+#define WM9081_CLK_DSP_ENA_SHIFT                     1  /* CLK_DSP_ENA */
+#define WM9081_CLK_DSP_ENA_WIDTH                     1  /* CLK_DSP_ENA */
+#define WM9081_CLK_SYS_ENA                      0x0001  /* CLK_SYS_ENA */
+#define WM9081_CLK_SYS_ENA_MASK                 0x0001  /* CLK_SYS_ENA */
+#define WM9081_CLK_SYS_ENA_SHIFT                     0  /* CLK_SYS_ENA */
+#define WM9081_CLK_SYS_ENA_WIDTH                     1  /* CLK_SYS_ENA */
+
+/*
+ * R16 (0x10) - FLL Control 1
+ */
+#define WM9081_FLL_HOLD                         0x0008  /* FLL_HOLD */
+#define WM9081_FLL_HOLD_MASK                    0x0008  /* FLL_HOLD */
+#define WM9081_FLL_HOLD_SHIFT                        3  /* FLL_HOLD */
+#define WM9081_FLL_HOLD_WIDTH                        1  /* FLL_HOLD */
+#define WM9081_FLL_FRAC                         0x0004  /* FLL_FRAC */
+#define WM9081_FLL_FRAC_MASK                    0x0004  /* FLL_FRAC */
+#define WM9081_FLL_FRAC_SHIFT                        2  /* FLL_FRAC */
+#define WM9081_FLL_FRAC_WIDTH                        1  /* FLL_FRAC */
+#define WM9081_FLL_ENA                          0x0001  /* FLL_ENA */
+#define WM9081_FLL_ENA_MASK                     0x0001  /* FLL_ENA */
+#define WM9081_FLL_ENA_SHIFT                         0  /* FLL_ENA */
+#define WM9081_FLL_ENA_WIDTH                         1  /* FLL_ENA */
+
+/*
+ * R17 (0x11) - FLL Control 2
+ */
+#define WM9081_FLL_OUTDIV_MASK                  0x0700  /* FLL_OUTDIV - [10:8] */
+#define WM9081_FLL_OUTDIV_SHIFT                      8  /* FLL_OUTDIV - [10:8] */
+#define WM9081_FLL_OUTDIV_WIDTH                      3  /* FLL_OUTDIV - [10:8] */
+#define WM9081_FLL_CTRL_RATE_MASK               0x0070  /* FLL_CTRL_RATE - [6:4] */
+#define WM9081_FLL_CTRL_RATE_SHIFT                   4  /* FLL_CTRL_RATE - [6:4] */
+#define WM9081_FLL_CTRL_RATE_WIDTH                   3  /* FLL_CTRL_RATE - [6:4] */
+#define WM9081_FLL_FRATIO_MASK                  0x0007  /* FLL_FRATIO - [2:0] */
+#define WM9081_FLL_FRATIO_SHIFT                      0  /* FLL_FRATIO - [2:0] */
+#define WM9081_FLL_FRATIO_WIDTH                      3  /* FLL_FRATIO - [2:0] */
+
+/*
+ * R18 (0x12) - FLL Control 3
+ */
+#define WM9081_FLL_K_MASK                       0xFFFF  /* FLL_K - [15:0] */
+#define WM9081_FLL_K_SHIFT                           0  /* FLL_K - [15:0] */
+#define WM9081_FLL_K_WIDTH                          16  /* FLL_K - [15:0] */
+
+/*
+ * R19 (0x13) - FLL Control 4
+ */
+#define WM9081_FLL_N_MASK                       0x7FE0  /* FLL_N - [14:5] */
+#define WM9081_FLL_N_SHIFT                           5  /* FLL_N - [14:5] */
+#define WM9081_FLL_N_WIDTH                          10  /* FLL_N - [14:5] */
+#define WM9081_FLL_GAIN_MASK                    0x000F  /* FLL_GAIN - [3:0] */
+#define WM9081_FLL_GAIN_SHIFT                        0  /* FLL_GAIN - [3:0] */
+#define WM9081_FLL_GAIN_WIDTH                        4  /* FLL_GAIN - [3:0] */
+
+/*
+ * R20 (0x14) - FLL Control 5
+ */
+#define WM9081_FLL_CLK_REF_DIV_MASK             0x0018  /* FLL_CLK_REF_DIV - [4:3] */
+#define WM9081_FLL_CLK_REF_DIV_SHIFT                 3  /* FLL_CLK_REF_DIV - [4:3] */
+#define WM9081_FLL_CLK_REF_DIV_WIDTH                 2  /* FLL_CLK_REF_DIV - [4:3] */
+#define WM9081_FLL_CLK_SRC_MASK                 0x0003  /* FLL_CLK_SRC - [1:0] */
+#define WM9081_FLL_CLK_SRC_SHIFT                     0  /* FLL_CLK_SRC - [1:0] */
+#define WM9081_FLL_CLK_SRC_WIDTH                     2  /* FLL_CLK_SRC - [1:0] */
+
+/*
+ * R22 (0x16) - Audio Interface 1
+ */
+#define WM9081_AIFDAC_CHAN                      0x0040  /* AIFDAC_CHAN */
+#define WM9081_AIFDAC_CHAN_MASK                 0x0040  /* AIFDAC_CHAN */
+#define WM9081_AIFDAC_CHAN_SHIFT                     6  /* AIFDAC_CHAN */
+#define WM9081_AIFDAC_CHAN_WIDTH                     1  /* AIFDAC_CHAN */
+#define WM9081_AIFDAC_TDM_SLOT_MASK             0x0030  /* AIFDAC_TDM_SLOT - [5:4] */
+#define WM9081_AIFDAC_TDM_SLOT_SHIFT                 4  /* AIFDAC_TDM_SLOT - [5:4] */
+#define WM9081_AIFDAC_TDM_SLOT_WIDTH                 2  /* AIFDAC_TDM_SLOT - [5:4] */
+#define WM9081_AIFDAC_TDM_MODE_MASK             0x000C  /* AIFDAC_TDM_MODE - [3:2] */
+#define WM9081_AIFDAC_TDM_MODE_SHIFT                 2  /* AIFDAC_TDM_MODE - [3:2] */
+#define WM9081_AIFDAC_TDM_MODE_WIDTH                 2  /* AIFDAC_TDM_MODE - [3:2] */
+#define WM9081_DAC_COMP                         0x0002  /* DAC_COMP */
+#define WM9081_DAC_COMP_MASK                    0x0002  /* DAC_COMP */
+#define WM9081_DAC_COMP_SHIFT                        1  /* DAC_COMP */
+#define WM9081_DAC_COMP_WIDTH                        1  /* DAC_COMP */
+#define WM9081_DAC_COMPMODE                     0x0001  /* DAC_COMPMODE */
+#define WM9081_DAC_COMPMODE_MASK                0x0001  /* DAC_COMPMODE */
+#define WM9081_DAC_COMPMODE_SHIFT                    0  /* DAC_COMPMODE */
+#define WM9081_DAC_COMPMODE_WIDTH                    1  /* DAC_COMPMODE */
+
+/*
+ * R23 (0x17) - Audio Interface 2
+ */
+#define WM9081_AIF_TRIS                         0x0200  /* AIF_TRIS */
+#define WM9081_AIF_TRIS_MASK                    0x0200  /* AIF_TRIS */
+#define WM9081_AIF_TRIS_SHIFT                        9  /* AIF_TRIS */
+#define WM9081_AIF_TRIS_WIDTH                        1  /* AIF_TRIS */
+#define WM9081_DAC_DAT_INV                      0x0100  /* DAC_DAT_INV */
+#define WM9081_DAC_DAT_INV_MASK                 0x0100  /* DAC_DAT_INV */
+#define WM9081_DAC_DAT_INV_SHIFT                     8  /* DAC_DAT_INV */
+#define WM9081_DAC_DAT_INV_WIDTH                     1  /* DAC_DAT_INV */
+#define WM9081_AIF_BCLK_INV                     0x0080  /* AIF_BCLK_INV */
+#define WM9081_AIF_BCLK_INV_MASK                0x0080  /* AIF_BCLK_INV */
+#define WM9081_AIF_BCLK_INV_SHIFT                    7  /* AIF_BCLK_INV */
+#define WM9081_AIF_BCLK_INV_WIDTH                    1  /* AIF_BCLK_INV */
+#define WM9081_BCLK_DIR                         0x0040  /* BCLK_DIR */
+#define WM9081_BCLK_DIR_MASK                    0x0040  /* BCLK_DIR */
+#define WM9081_BCLK_DIR_SHIFT                        6  /* BCLK_DIR */
+#define WM9081_BCLK_DIR_WIDTH                        1  /* BCLK_DIR */
+#define WM9081_LRCLK_DIR                        0x0020  /* LRCLK_DIR */
+#define WM9081_LRCLK_DIR_MASK                   0x0020  /* LRCLK_DIR */
+#define WM9081_LRCLK_DIR_SHIFT                       5  /* LRCLK_DIR */
+#define WM9081_LRCLK_DIR_WIDTH                       1  /* LRCLK_DIR */
+#define WM9081_AIF_LRCLK_INV                    0x0010  /* AIF_LRCLK_INV */
+#define WM9081_AIF_LRCLK_INV_MASK               0x0010  /* AIF_LRCLK_INV */
+#define WM9081_AIF_LRCLK_INV_SHIFT                   4  /* AIF_LRCLK_INV */
+#define WM9081_AIF_LRCLK_INV_WIDTH                   1  /* AIF_LRCLK_INV */
+#define WM9081_AIF_WL_MASK                      0x000C  /* AIF_WL - [3:2] */
+#define WM9081_AIF_WL_SHIFT                          2  /* AIF_WL - [3:2] */
+#define WM9081_AIF_WL_WIDTH                          2  /* AIF_WL - [3:2] */
+#define WM9081_AIF_FMT_MASK                     0x0003  /* AIF_FMT - [1:0] */
+#define WM9081_AIF_FMT_SHIFT                         0  /* AIF_FMT - [1:0] */
+#define WM9081_AIF_FMT_WIDTH                         2  /* AIF_FMT - [1:0] */
+
+/*
+ * R24 (0x18) - Audio Interface 3
+ */
+#define WM9081_BCLK_DIV_MASK                    0x001F  /* BCLK_DIV - [4:0] */
+#define WM9081_BCLK_DIV_SHIFT                        0  /* BCLK_DIV - [4:0] */
+#define WM9081_BCLK_DIV_WIDTH                        5  /* BCLK_DIV - [4:0] */
+
+/*
+ * R25 (0x19) - Audio Interface 4
+ */
+#define WM9081_LRCLK_RATE_MASK                  0x07FF  /* LRCLK_RATE - [10:0] */
+#define WM9081_LRCLK_RATE_SHIFT                      0  /* LRCLK_RATE - [10:0] */
+#define WM9081_LRCLK_RATE_WIDTH                     11  /* LRCLK_RATE - [10:0] */
+
+/*
+ * R26 (0x1A) - Interrupt Status
+ */
+#define WM9081_WSEQ_BUSY_EINT                   0x0004  /* WSEQ_BUSY_EINT */
+#define WM9081_WSEQ_BUSY_EINT_MASK              0x0004  /* WSEQ_BUSY_EINT */
+#define WM9081_WSEQ_BUSY_EINT_SHIFT                  2  /* WSEQ_BUSY_EINT */
+#define WM9081_WSEQ_BUSY_EINT_WIDTH                  1  /* WSEQ_BUSY_EINT */
+#define WM9081_TSHUT_EINT                       0x0001  /* TSHUT_EINT */
+#define WM9081_TSHUT_EINT_MASK                  0x0001  /* TSHUT_EINT */
+#define WM9081_TSHUT_EINT_SHIFT                      0  /* TSHUT_EINT */
+#define WM9081_TSHUT_EINT_WIDTH                      1  /* TSHUT_EINT */
+
+/*
+ * R27 (0x1B) - Interrupt Status Mask
+ */
+#define WM9081_IM_WSEQ_BUSY_EINT                0x0004  /* IM_WSEQ_BUSY_EINT */
+#define WM9081_IM_WSEQ_BUSY_EINT_MASK           0x0004  /* IM_WSEQ_BUSY_EINT */
+#define WM9081_IM_WSEQ_BUSY_EINT_SHIFT               2  /* IM_WSEQ_BUSY_EINT */
+#define WM9081_IM_WSEQ_BUSY_EINT_WIDTH               1  /* IM_WSEQ_BUSY_EINT */
+#define WM9081_IM_TSHUT_EINT                    0x0001  /* IM_TSHUT_EINT */
+#define WM9081_IM_TSHUT_EINT_MASK               0x0001  /* IM_TSHUT_EINT */
+#define WM9081_IM_TSHUT_EINT_SHIFT                   0  /* IM_TSHUT_EINT */
+#define WM9081_IM_TSHUT_EINT_WIDTH                   1  /* IM_TSHUT_EINT */
+
+/*
+ * R28 (0x1C) - Interrupt Polarity
+ */
+#define WM9081_TSHUT_INV                        0x0001  /* TSHUT_INV */
+#define WM9081_TSHUT_INV_MASK                   0x0001  /* TSHUT_INV */
+#define WM9081_TSHUT_INV_SHIFT                       0  /* TSHUT_INV */
+#define WM9081_TSHUT_INV_WIDTH                       1  /* TSHUT_INV */
+
+/*
+ * R29 (0x1D) - Interrupt Control
+ */
+#define WM9081_IRQ_POL                          0x8000  /* IRQ_POL */
+#define WM9081_IRQ_POL_MASK                     0x8000  /* IRQ_POL */
+#define WM9081_IRQ_POL_SHIFT                        15  /* IRQ_POL */
+#define WM9081_IRQ_POL_WIDTH                         1  /* IRQ_POL */
+#define WM9081_IRQ_OP_CTRL                      0x0001  /* IRQ_OP_CTRL */
+#define WM9081_IRQ_OP_CTRL_MASK                 0x0001  /* IRQ_OP_CTRL */
+#define WM9081_IRQ_OP_CTRL_SHIFT                     0  /* IRQ_OP_CTRL */
+#define WM9081_IRQ_OP_CTRL_WIDTH                     1  /* IRQ_OP_CTRL */
+
+/*
+ * R30 (0x1E) - DAC Digital 1
+ */
+#define WM9081_DAC_VOL_MASK                     0x00FF  /* DAC_VOL - [7:0] */
+#define WM9081_DAC_VOL_SHIFT                         0  /* DAC_VOL - [7:0] */
+#define WM9081_DAC_VOL_WIDTH                         8  /* DAC_VOL - [7:0] */
+
+/*
+ * R31 (0x1F) - DAC Digital 2
+ */
+#define WM9081_DAC_MUTERATE                     0x0400  /* DAC_MUTERATE */
+#define WM9081_DAC_MUTERATE_MASK                0x0400  /* DAC_MUTERATE */
+#define WM9081_DAC_MUTERATE_SHIFT                   10  /* DAC_MUTERATE */
+#define WM9081_DAC_MUTERATE_WIDTH                    1  /* DAC_MUTERATE */
+#define WM9081_DAC_MUTEMODE                     0x0200  /* DAC_MUTEMODE */
+#define WM9081_DAC_MUTEMODE_MASK                0x0200  /* DAC_MUTEMODE */
+#define WM9081_DAC_MUTEMODE_SHIFT                    9  /* DAC_MUTEMODE */
+#define WM9081_DAC_MUTEMODE_WIDTH                    1  /* DAC_MUTEMODE */
+#define WM9081_DAC_MUTE                         0x0008  /* DAC_MUTE */
+#define WM9081_DAC_MUTE_MASK                    0x0008  /* DAC_MUTE */
+#define WM9081_DAC_MUTE_SHIFT                        3  /* DAC_MUTE */
+#define WM9081_DAC_MUTE_WIDTH                        1  /* DAC_MUTE */
+#define WM9081_DEEMPH_MASK                      0x0006  /* DEEMPH - [2:1] */
+#define WM9081_DEEMPH_SHIFT                          1  /* DEEMPH - [2:1] */
+#define WM9081_DEEMPH_WIDTH                          2  /* DEEMPH - [2:1] */
+
+/*
+ * R32 (0x20) - DRC 1
+ */
+#define WM9081_DRC_ENA                          0x8000  /* DRC_ENA */
+#define WM9081_DRC_ENA_MASK                     0x8000  /* DRC_ENA */
+#define WM9081_DRC_ENA_SHIFT                        15  /* DRC_ENA */
+#define WM9081_DRC_ENA_WIDTH                         1  /* DRC_ENA */
+#define WM9081_DRC_STARTUP_GAIN_MASK            0x07C0  /* DRC_STARTUP_GAIN - [10:6] */
+#define WM9081_DRC_STARTUP_GAIN_SHIFT                6  /* DRC_STARTUP_GAIN - [10:6] */
+#define WM9081_DRC_STARTUP_GAIN_WIDTH                5  /* DRC_STARTUP_GAIN - [10:6] */
+#define WM9081_DRC_FF_DLY                       0x0020  /* DRC_FF_DLY */
+#define WM9081_DRC_FF_DLY_MASK                  0x0020  /* DRC_FF_DLY */
+#define WM9081_DRC_FF_DLY_SHIFT                      5  /* DRC_FF_DLY */
+#define WM9081_DRC_FF_DLY_WIDTH                      1  /* DRC_FF_DLY */
+#define WM9081_DRC_QR                           0x0004  /* DRC_QR */
+#define WM9081_DRC_QR_MASK                      0x0004  /* DRC_QR */
+#define WM9081_DRC_QR_SHIFT                          2  /* DRC_QR */
+#define WM9081_DRC_QR_WIDTH                          1  /* DRC_QR */
+#define WM9081_DRC_ANTICLIP                     0x0002  /* DRC_ANTICLIP */
+#define WM9081_DRC_ANTICLIP_MASK                0x0002  /* DRC_ANTICLIP */
+#define WM9081_DRC_ANTICLIP_SHIFT                    1  /* DRC_ANTICLIP */
+#define WM9081_DRC_ANTICLIP_WIDTH                    1  /* DRC_ANTICLIP */
+
+/*
+ * R33 (0x21) - DRC 2
+ */
+#define WM9081_DRC_ATK_MASK                     0xF000  /* DRC_ATK - [15:12] */
+#define WM9081_DRC_ATK_SHIFT                        12  /* DRC_ATK - [15:12] */
+#define WM9081_DRC_ATK_WIDTH                         4  /* DRC_ATK - [15:12] */
+#define WM9081_DRC_DCY_MASK                     0x0F00  /* DRC_DCY - [11:8] */
+#define WM9081_DRC_DCY_SHIFT                         8  /* DRC_DCY - [11:8] */
+#define WM9081_DRC_DCY_WIDTH                         4  /* DRC_DCY - [11:8] */
+#define WM9081_DRC_QR_THR_MASK                  0x00C0  /* DRC_QR_THR - [7:6] */
+#define WM9081_DRC_QR_THR_SHIFT                      6  /* DRC_QR_THR - [7:6] */
+#define WM9081_DRC_QR_THR_WIDTH                      2  /* DRC_QR_THR - [7:6] */
+#define WM9081_DRC_QR_DCY_MASK                  0x0030  /* DRC_QR_DCY - [5:4] */
+#define WM9081_DRC_QR_DCY_SHIFT                      4  /* DRC_QR_DCY - [5:4] */
+#define WM9081_DRC_QR_DCY_WIDTH                      2  /* DRC_QR_DCY - [5:4] */
+#define WM9081_DRC_MINGAIN_MASK                 0x000C  /* DRC_MINGAIN - [3:2] */
+#define WM9081_DRC_MINGAIN_SHIFT                     2  /* DRC_MINGAIN - [3:2] */
+#define WM9081_DRC_MINGAIN_WIDTH                     2  /* DRC_MINGAIN - [3:2] */
+#define WM9081_DRC_MAXGAIN_MASK                 0x0003  /* DRC_MAXGAIN - [1:0] */
+#define WM9081_DRC_MAXGAIN_SHIFT                     0  /* DRC_MAXGAIN - [1:0] */
+#define WM9081_DRC_MAXGAIN_WIDTH                     2  /* DRC_MAXGAIN - [1:0] */
+
+/*
+ * R34 (0x22) - DRC 3
+ */
+#define WM9081_DRC_HI_COMP_MASK                 0x0038  /* DRC_HI_COMP - [5:3] */
+#define WM9081_DRC_HI_COMP_SHIFT                     3  /* DRC_HI_COMP - [5:3] */
+#define WM9081_DRC_HI_COMP_WIDTH                     3  /* DRC_HI_COMP - [5:3] */
+#define WM9081_DRC_LO_COMP_MASK                 0x0007  /* DRC_LO_COMP - [2:0] */
+#define WM9081_DRC_LO_COMP_SHIFT                     0  /* DRC_LO_COMP - [2:0] */
+#define WM9081_DRC_LO_COMP_WIDTH                     3  /* DRC_LO_COMP - [2:0] */
+
+/*
+ * R35 (0x23) - DRC 4
+ */
+#define WM9081_DRC_KNEE_IP_MASK                 0x07E0  /* DRC_KNEE_IP - [10:5] */
+#define WM9081_DRC_KNEE_IP_SHIFT                     5  /* DRC_KNEE_IP - [10:5] */
+#define WM9081_DRC_KNEE_IP_WIDTH                     6  /* DRC_KNEE_IP - [10:5] */
+#define WM9081_DRC_KNEE_OP_MASK                 0x001F  /* DRC_KNEE_OP - [4:0] */
+#define WM9081_DRC_KNEE_OP_SHIFT                     0  /* DRC_KNEE_OP - [4:0] */
+#define WM9081_DRC_KNEE_OP_WIDTH                     5  /* DRC_KNEE_OP - [4:0] */
+
+/*
+ * R38 (0x26) - Write Sequencer 1
+ */
+#define WM9081_WSEQ_ENA                         0x8000  /* WSEQ_ENA */
+#define WM9081_WSEQ_ENA_MASK                    0x8000  /* WSEQ_ENA */
+#define WM9081_WSEQ_ENA_SHIFT                       15  /* WSEQ_ENA */
+#define WM9081_WSEQ_ENA_WIDTH                        1  /* WSEQ_ENA */
+#define WM9081_WSEQ_ABORT                       0x0200  /* WSEQ_ABORT */
+#define WM9081_WSEQ_ABORT_MASK                  0x0200  /* WSEQ_ABORT */
+#define WM9081_WSEQ_ABORT_SHIFT                      9  /* WSEQ_ABORT */
+#define WM9081_WSEQ_ABORT_WIDTH                      1  /* WSEQ_ABORT */
+#define WM9081_WSEQ_START                       0x0100  /* WSEQ_START */
+#define WM9081_WSEQ_START_MASK                  0x0100  /* WSEQ_START */
+#define WM9081_WSEQ_START_SHIFT                      8  /* WSEQ_START */
+#define WM9081_WSEQ_START_WIDTH                      1  /* WSEQ_START */
+#define WM9081_WSEQ_START_INDEX_MASK            0x007F  /* WSEQ_START_INDEX - [6:0] */
+#define WM9081_WSEQ_START_INDEX_SHIFT                0  /* WSEQ_START_INDEX - [6:0] */
+#define WM9081_WSEQ_START_INDEX_WIDTH                7  /* WSEQ_START_INDEX - [6:0] */
+
+/*
+ * R39 (0x27) - Write Sequencer 2
+ */
+#define WM9081_WSEQ_CURRENT_INDEX_MASK          0x07F0  /* WSEQ_CURRENT_INDEX - [10:4] */
+#define WM9081_WSEQ_CURRENT_INDEX_SHIFT              4  /* WSEQ_CURRENT_INDEX - [10:4] */
+#define WM9081_WSEQ_CURRENT_INDEX_WIDTH              7  /* WSEQ_CURRENT_INDEX - [10:4] */
+#define WM9081_WSEQ_BUSY                        0x0001  /* WSEQ_BUSY */
+#define WM9081_WSEQ_BUSY_MASK                   0x0001  /* WSEQ_BUSY */
+#define WM9081_WSEQ_BUSY_SHIFT                       0  /* WSEQ_BUSY */
+#define WM9081_WSEQ_BUSY_WIDTH                       1  /* WSEQ_BUSY */
+
+/*
+ * R40 (0x28) - MW Slave 1
+ */
+#define WM9081_SPI_CFG                          0x0020  /* SPI_CFG */
+#define WM9081_SPI_CFG_MASK                     0x0020  /* SPI_CFG */
+#define WM9081_SPI_CFG_SHIFT                         5  /* SPI_CFG */
+#define WM9081_SPI_CFG_WIDTH                         1  /* SPI_CFG */
+#define WM9081_SPI_4WIRE                        0x0010  /* SPI_4WIRE */
+#define WM9081_SPI_4WIRE_MASK                   0x0010  /* SPI_4WIRE */
+#define WM9081_SPI_4WIRE_SHIFT                       4  /* SPI_4WIRE */
+#define WM9081_SPI_4WIRE_WIDTH                       1  /* SPI_4WIRE */
+#define WM9081_ARA_ENA                          0x0008  /* ARA_ENA */
+#define WM9081_ARA_ENA_MASK                     0x0008  /* ARA_ENA */
+#define WM9081_ARA_ENA_SHIFT                         3  /* ARA_ENA */
+#define WM9081_ARA_ENA_WIDTH                         1  /* ARA_ENA */
+#define WM9081_AUTO_INC                         0x0002  /* AUTO_INC */
+#define WM9081_AUTO_INC_MASK                    0x0002  /* AUTO_INC */
+#define WM9081_AUTO_INC_SHIFT                        1  /* AUTO_INC */
+#define WM9081_AUTO_INC_WIDTH                        1  /* AUTO_INC */
+
+/*
+ * R42 (0x2A) - EQ 1
+ */
+#define WM9081_EQ_B1_GAIN_MASK                  0xF800  /* EQ_B1_GAIN - [15:11] */
+#define WM9081_EQ_B1_GAIN_SHIFT                     11  /* EQ_B1_GAIN - [15:11] */
+#define WM9081_EQ_B1_GAIN_WIDTH                      5  /* EQ_B1_GAIN - [15:11] */
+#define WM9081_EQ_B2_GAIN_MASK                  0x07C0  /* EQ_B2_GAIN - [10:6] */
+#define WM9081_EQ_B2_GAIN_SHIFT                      6  /* EQ_B2_GAIN - [10:6] */
+#define WM9081_EQ_B2_GAIN_WIDTH                      5  /* EQ_B2_GAIN - [10:6] */
+#define WM9081_EQ_B4_GAIN_MASK                  0x003E  /* EQ_B4_GAIN - [5:1] */
+#define WM9081_EQ_B4_GAIN_SHIFT                      1  /* EQ_B4_GAIN - [5:1] */
+#define WM9081_EQ_B4_GAIN_WIDTH                      5  /* EQ_B4_GAIN - [5:1] */
+#define WM9081_EQ_ENA                           0x0001  /* EQ_ENA */
+#define WM9081_EQ_ENA_MASK                      0x0001  /* EQ_ENA */
+#define WM9081_EQ_ENA_SHIFT                          0  /* EQ_ENA */
+#define WM9081_EQ_ENA_WIDTH                          1  /* EQ_ENA */
+
+/*
+ * R43 (0x2B) - EQ 2
+ */
+#define WM9081_EQ_B3_GAIN_MASK                  0xF800  /* EQ_B3_GAIN - [15:11] */
+#define WM9081_EQ_B3_GAIN_SHIFT                     11  /* EQ_B3_GAIN - [15:11] */
+#define WM9081_EQ_B3_GAIN_WIDTH                      5  /* EQ_B3_GAIN - [15:11] */
+#define WM9081_EQ_B5_GAIN_MASK                  0x07C0  /* EQ_B5_GAIN - [10:6] */
+#define WM9081_EQ_B5_GAIN_SHIFT                      6  /* EQ_B5_GAIN - [10:6] */
+#define WM9081_EQ_B5_GAIN_WIDTH                      5  /* EQ_B5_GAIN - [10:6] */
+
+/*
+ * R44 (0x2C) - EQ 3
+ */
+#define WM9081_EQ_B1_A_MASK                     0xFFFF  /* EQ_B1_A - [15:0] */
+#define WM9081_EQ_B1_A_SHIFT                         0  /* EQ_B1_A - [15:0] */
+#define WM9081_EQ_B1_A_WIDTH                        16  /* EQ_B1_A - [15:0] */
+
+/*
+ * R45 (0x2D) - EQ 4
+ */
+#define WM9081_EQ_B1_B_MASK                     0xFFFF  /* EQ_B1_B - [15:0] */
+#define WM9081_EQ_B1_B_SHIFT                         0  /* EQ_B1_B - [15:0] */
+#define WM9081_EQ_B1_B_WIDTH                        16  /* EQ_B1_B - [15:0] */
+
+/*
+ * R46 (0x2E) - EQ 5
+ */
+#define WM9081_EQ_B1_PG_MASK                    0xFFFF  /* EQ_B1_PG - [15:0] */
+#define WM9081_EQ_B1_PG_SHIFT                        0  /* EQ_B1_PG - [15:0] */
+#define WM9081_EQ_B1_PG_WIDTH                       16  /* EQ_B1_PG - [15:0] */
+
+/*
+ * R47 (0x2F) - EQ 6
+ */
+#define WM9081_EQ_B2_A_MASK                     0xFFFF  /* EQ_B2_A - [15:0] */
+#define WM9081_EQ_B2_A_SHIFT                         0  /* EQ_B2_A - [15:0] */
+#define WM9081_EQ_B2_A_WIDTH                        16  /* EQ_B2_A - [15:0] */
+
+/*
+ * R48 (0x30) - EQ 7
+ */
+#define WM9081_EQ_B2_B_MASK                     0xFFFF  /* EQ_B2_B - [15:0] */
+#define WM9081_EQ_B2_B_SHIFT                         0  /* EQ_B2_B - [15:0] */
+#define WM9081_EQ_B2_B_WIDTH                        16  /* EQ_B2_B - [15:0] */
+
+/*
+ * R49 (0x31) - EQ 8
+ */
+#define WM9081_EQ_B2_C_MASK                     0xFFFF  /* EQ_B2_C - [15:0] */
+#define WM9081_EQ_B2_C_SHIFT                         0  /* EQ_B2_C - [15:0] */
+#define WM9081_EQ_B2_C_WIDTH                        16  /* EQ_B2_C - [15:0] */
+
+/*
+ * R50 (0x32) - EQ 9
+ */
+#define WM9081_EQ_B2_PG_MASK                    0xFFFF  /* EQ_B2_PG - [15:0] */
+#define WM9081_EQ_B2_PG_SHIFT                        0  /* EQ_B2_PG - [15:0] */
+#define WM9081_EQ_B2_PG_WIDTH                       16  /* EQ_B2_PG - [15:0] */
+
+/*
+ * R51 (0x33) - EQ 10
+ */
+#define WM9081_EQ_B4_A_MASK                     0xFFFF  /* EQ_B4_A - [15:0] */
+#define WM9081_EQ_B4_A_SHIFT                         0  /* EQ_B4_A - [15:0] */
+#define WM9081_EQ_B4_A_WIDTH                        16  /* EQ_B4_A - [15:0] */
+
+/*
+ * R52 (0x34) - EQ 11
+ */
+#define WM9081_EQ_B4_B_MASK                     0xFFFF  /* EQ_B4_B - [15:0] */
+#define WM9081_EQ_B4_B_SHIFT                         0  /* EQ_B4_B - [15:0] */
+#define WM9081_EQ_B4_B_WIDTH                        16  /* EQ_B4_B - [15:0] */
+
+/*
+ * R53 (0x35) - EQ 12
+ */
+#define WM9081_EQ_B4_C_MASK                     0xFFFF  /* EQ_B4_C - [15:0] */
+#define WM9081_EQ_B4_C_SHIFT                         0  /* EQ_B4_C - [15:0] */
+#define WM9081_EQ_B4_C_WIDTH                        16  /* EQ_B4_C - [15:0] */
+
+/*
+ * R54 (0x36) - EQ 13
+ */
+#define WM9081_EQ_B4_PG_MASK                    0xFFFF  /* EQ_B4_PG - [15:0] */
+#define WM9081_EQ_B4_PG_SHIFT                        0  /* EQ_B4_PG - [15:0] */
+#define WM9081_EQ_B4_PG_WIDTH                       16  /* EQ_B4_PG - [15:0] */
+
+/*
+ * R55 (0x37) - EQ 14
+ */
+#define WM9081_EQ_B3_A_MASK                     0xFFFF  /* EQ_B3_A - [15:0] */
+#define WM9081_EQ_B3_A_SHIFT                         0  /* EQ_B3_A - [15:0] */
+#define WM9081_EQ_B3_A_WIDTH                        16  /* EQ_B3_A - [15:0] */
+
+/*
+ * R56 (0x38) - EQ 15
+ */
+#define WM9081_EQ_B3_B_MASK                     0xFFFF  /* EQ_B3_B - [15:0] */
+#define WM9081_EQ_B3_B_SHIFT                         0  /* EQ_B3_B - [15:0] */
+#define WM9081_EQ_B3_B_WIDTH                        16  /* EQ_B3_B - [15:0] */
+
+/*
+ * R57 (0x39) - EQ 16
+ */
+#define WM9081_EQ_B3_C_MASK                     0xFFFF  /* EQ_B3_C - [15:0] */
+#define WM9081_EQ_B3_C_SHIFT                         0  /* EQ_B3_C - [15:0] */
+#define WM9081_EQ_B3_C_WIDTH                        16  /* EQ_B3_C - [15:0] */
+
+/*
+ * R58 (0x3A) - EQ 17
+ */
+#define WM9081_EQ_B3_PG_MASK                    0xFFFF  /* EQ_B3_PG - [15:0] */
+#define WM9081_EQ_B3_PG_SHIFT                        0  /* EQ_B3_PG - [15:0] */
+#define WM9081_EQ_B3_PG_WIDTH                       16  /* EQ_B3_PG - [15:0] */
+
+/*
+ * R59 (0x3B) - EQ 18
+ */
+#define WM9081_EQ_B5_A_MASK                     0xFFFF  /* EQ_B5_A - [15:0] */
+#define WM9081_EQ_B5_A_SHIFT                         0  /* EQ_B5_A - [15:0] */
+#define WM9081_EQ_B5_A_WIDTH                        16  /* EQ_B5_A - [15:0] */
+
+/*
+ * R60 (0x3C) - EQ 19
+ */
+#define WM9081_EQ_B5_B_MASK                     0xFFFF  /* EQ_B5_B - [15:0] */
+#define WM9081_EQ_B5_B_SHIFT                         0  /* EQ_B5_B - [15:0] */
+#define WM9081_EQ_B5_B_WIDTH                        16  /* EQ_B5_B - [15:0] */
+
+/*
+ * R61 (0x3D) - EQ 20
+ */
+#define WM9081_EQ_B5_PG_MASK                    0xFFFF  /* EQ_B5_PG - [15:0] */
+#define WM9081_EQ_B5_PG_SHIFT                        0  /* EQ_B5_PG - [15:0] */
+#define WM9081_EQ_B5_PG_WIDTH                       16  /* EQ_B5_PG - [15:0] */
+
+
+#endif
diff --git a/sound/soc/codecs/wm9705.c b/sound/soc/codecs/wm9705.c
index c2d1a7a18fa3..fa88b463e71f 100644
--- a/sound/soc/codecs/wm9705.c
+++ b/sound/soc/codecs/wm9705.c
@@ -282,14 +282,14 @@ struct snd_soc_dai wm9705_dai[] = {
                         .channels_min = 1,
                         .channels_max = 2,
                         .rates = WM9705_AC97_RATES,
-                        .formats = SNDRV_PCM_FMTBIT_S16_LE,
+                        .formats = SND_SOC_STD_AC97_FMTS,
                 },
                 .capture = {
                         .stream_name = "HiFi Capture",
                         .channels_min = 1,
                         .channels_max = 2,
                         .rates = WM9705_AC97_RATES,
-                        .formats = SNDRV_PCM_FMTBIT_S16_LE,
+                        .formats = SND_SOC_STD_AC97_FMTS,
                 },
                 .ops = &wm9705_dai_ops,
         },
diff --git a/sound/soc/codecs/wm9712.c b/sound/soc/codecs/wm9712.c
index 765cf1e7369e..1fd4e88f50cf 100644
--- a/sound/soc/codecs/wm9712.c
+++ b/sound/soc/codecs/wm9712.c
@@ -534,13 +534,13 @@ struct snd_soc_dai wm9712_dai[] = {
                 .channels_min = 1,
                 .channels_max = 2,
                 .rates = WM9712_AC97_RATES,
-                .formats = SNDRV_PCM_FMTBIT_S16_LE,},
+                .formats = SND_SOC_STD_AC97_FMTS,},
         .capture = {
                 .stream_name = "HiFi Capture",
                 .channels_min = 1,
                 .channels_max = 2,
                 .rates = WM9712_AC97_RATES,
-                .formats = SNDRV_PCM_FMTBIT_S16_LE,},
+                .formats = SND_SOC_STD_AC97_FMTS,},
         .ops = &wm9712_dai_ops_hifi,
 },
 {
@@ -550,7 +550,7 @@ struct snd_soc_dai wm9712_dai[] = {
                 .channels_min = 1,
                 .channels_max = 1,
                 .rates = WM9712_AC97_RATES,
-                .formats = SNDRV_PCM_FMTBIT_S16_LE,},
+                .formats = SND_SOC_STD_AC97_FMTS,},
         .ops = &wm9712_dai_ops_aux,
 }
 };
@@ -585,6 +585,8 @@ static int wm9712_reset(struct snd_soc_codec *codec, int try_warm)
         }
 
         soc_ac97_ops.reset(codec->ac97);
+        if (soc_ac97_ops.warm_reset)
+                soc_ac97_ops.warm_reset(codec->ac97);
         if (ac97_read(codec, 0) != wm9712_reg[0])
                 goto err;
         return 0;
diff --git a/sound/soc/codecs/wm9713.c b/sound/soc/codecs/wm9713.c
index 523bad077fa0..abed37acf787 100644
--- a/sound/soc/codecs/wm9713.c
+++ b/sound/soc/codecs/wm9713.c
@@ -189,6 +189,26 @@ SOC_SINGLE("3D Lower Cut-off Switch", AC97_REC_GAIN_MIC, 4, 1, 0),
 SOC_SINGLE("3D Depth", AC97_REC_GAIN_MIC, 0, 15, 1),
 };
 
+static int wm9713_voice_shutdown(struct snd_soc_dapm_widget *w,
+                                 struct snd_kcontrol *kcontrol, int event)
+{
+        struct snd_soc_codec *codec = w->codec;
+        u16 status, rate;
+
+        BUG_ON(event != SND_SOC_DAPM_PRE_PMD);
+
+        /* Gracefully shut down the voice interface. */
+        status = ac97_read(codec, AC97_EXTENDED_MID) | 0x1000;
+        rate = ac97_read(codec, AC97_HANDSET_RATE) & 0xF0FF;
+        ac97_write(codec, AC97_HANDSET_RATE, rate | 0x0200);
+        schedule_timeout_interruptible(msecs_to_jiffies(1));
+        ac97_write(codec, AC97_HANDSET_RATE, rate | 0x0F00);
+        ac97_write(codec, AC97_EXTENDED_MID, status);
+
+        return 0;
+}
+
+
 /* We have to create a fake left and right HP mixers because
  * the codec only has a single control that is shared by both channels.
  * This makes it impossible to determine the audio path using the current
@@ -400,7 +420,8 @@ SND_SOC_DAPM_MIXER("AC97 Mixer", SND_SOC_NOPM, 0, 0, NULL, 0),
 SND_SOC_DAPM_MIXER("HP Mixer", SND_SOC_NOPM, 0, 0, NULL, 0),
 SND_SOC_DAPM_MIXER("Line Mixer", SND_SOC_NOPM, 0, 0, NULL, 0),
 SND_SOC_DAPM_MIXER("Capture Mixer", SND_SOC_NOPM, 0, 0, NULL, 0),
-SND_SOC_DAPM_DAC("Voice DAC", "Voice Playback", AC97_EXTENDED_MID, 12, 1),
+SND_SOC_DAPM_DAC_E("Voice DAC", "Voice Playback", AC97_EXTENDED_MID, 12, 1,
+                   wm9713_voice_shutdown, SND_SOC_DAPM_PRE_PMD),
 SND_SOC_DAPM_DAC("Aux DAC", "Aux Playback", AC97_EXTENDED_MID, 11, 1),
 SND_SOC_DAPM_PGA("Left ADC", AC97_EXTENDED_MID, 5, 1, NULL, 0),
 SND_SOC_DAPM_PGA("Right ADC", AC97_EXTENDED_MID, 4, 1, NULL, 0),
@@ -689,7 +710,7 @@ static void pll_factors(struct _pll_div *pll_div, unsigned int source)
         Ndiv = target / source;
         if ((Ndiv < 5) || (Ndiv > 12))
                 printk(KERN_WARNING
-                        "WM9713 PLL N value %d out of recommended range!\n",
+                        "WM9713 PLL N value %u out of recommended range!\n",
                         Ndiv);
 
         pll_div->n = Ndiv;
@@ -936,21 +957,6 @@ static int wm9713_pcm_hw_params(struct snd_pcm_substream *substream,
         return 0;
 }
 
-static void wm9713_voiceshutdown(struct snd_pcm_substream *substream,
-                                 struct snd_soc_dai *dai)
-{
-        struct snd_soc_codec *codec = dai->codec;
-        u16 status, rate;
-
-        /* Gracefully shut down the voice interface. */
-        status = ac97_read(codec, AC97_EXTENDED_STATUS) | 0x1000;
-        rate = ac97_read(codec, AC97_HANDSET_RATE) & 0xF0FF;
-        ac97_write(codec, AC97_HANDSET_RATE, rate | 0x0200);
-        schedule_timeout_interruptible(msecs_to_jiffies(1));
-        ac97_write(codec, AC97_HANDSET_RATE, rate | 0x0F00);
-        ac97_write(codec, AC97_EXTENDED_MID, status);
-}
-
 static int ac97_hifi_prepare(struct snd_pcm_substream *substream,
                              struct snd_soc_dai *dai)
 {
@@ -1019,7 +1025,6 @@ static struct snd_soc_dai_ops wm9713_dai_ops_aux = {
 
 static struct snd_soc_dai_ops wm9713_dai_ops_voice = {
         .hw_params      = wm9713_pcm_hw_params,
-        .shutdown       = wm9713_voiceshutdown,
         .set_clkdiv     = wm9713_set_dai_clkdiv,
         .set_pll        = wm9713_set_dai_pll,
         .set_fmt        = wm9713_set_dai_fmt,
@@ -1035,13 +1040,13 @@ struct snd_soc_dai wm9713_dai[] = {
                 .channels_min = 1,
                 .channels_max = 2,
                 .rates = WM9713_RATES,
-                .formats = SNDRV_PCM_FMTBIT_S16_LE,},
+                .formats = SND_SOC_STD_AC97_FMTS,},
         .capture = {
                 .stream_name = "HiFi Capture",
                 .channels_min = 1,
                 .channels_max = 2,
                 .rates = WM9713_RATES,
-                .formats = SNDRV_PCM_FMTBIT_S16_LE,},
+                .formats = SND_SOC_STD_AC97_FMTS,},
         .ops = &wm9713_dai_ops_hifi,
         },
         {
@@ -1051,7 +1056,7 @@ struct snd_soc_dai wm9713_dai[] = {
                 .channels_min = 1,
                 .channels_max = 1,
                 .rates = WM9713_RATES,
-                .formats = SNDRV_PCM_FMTBIT_S16_LE,},
+                .formats = SND_SOC_STD_AC97_FMTS,},
         .ops = &wm9713_dai_ops_aux,
         },
         {
@@ -1069,6 +1074,7 @@ struct snd_soc_dai wm9713_dai[] = {
                 .rates = WM9713_PCM_RATES,
                 .formats = WM9713_PCM_FORMATS,},
         .ops = &wm9713_dai_ops_voice,
+        .symmetric_rates = 1,
         },
 };
 EXPORT_SYMBOL_GPL(wm9713_dai);
diff --git a/sound/soc/codecs/wm_hubs.c b/sound/soc/codecs/wm_hubs.c
new file mode 100644
index 000000000000..e8fc474ba5cf
--- /dev/null
+++ b/sound/soc/codecs/wm_hubs.c
@@ -0,0 +1,758 @@
+/*
+ * wm_hubs.c  --  WM8993/4 common code
+ *
+ * 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 <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 "wm8993.h"
+#include "wm_hubs.h"
+
+const DECLARE_TLV_DB_SCALE(wm_hubs_spkmix_tlv, -300, 300, 0);
+EXPORT_SYMBOL_GPL(wm_hubs_spkmix_tlv);
+
+static const DECLARE_TLV_DB_SCALE(inpga_tlv, -1650, 150, 0);
+static const DECLARE_TLV_DB_SCALE(inmix_sw_tlv, 0, 3000, 0);
+static const DECLARE_TLV_DB_SCALE(inmix_tlv, -1500, 300, 1);
+static const DECLARE_TLV_DB_SCALE(earpiece_tlv, -600, 600, 0);
+static const DECLARE_TLV_DB_SCALE(outmix_tlv, -2100, 300, 0);
+static const DECLARE_TLV_DB_SCALE(spkmixout_tlv, -1800, 600, 1);
+static const DECLARE_TLV_DB_SCALE(outpga_tlv, -5700, 100, 0);
+static const unsigned int spkboost_tlv[] = {
+        TLV_DB_RANGE_HEAD(7),
+        0, 6, TLV_DB_SCALE_ITEM(0, 150, 0),
+        7, 7, TLV_DB_SCALE_ITEM(1200, 0, 0),
+};
+static const DECLARE_TLV_DB_SCALE(line_tlv, -600, 600, 0);
+
+static const char *speaker_ref_text[] = {
+        "SPKVDD/2",
+        "VMID",
+};
+
+static const struct soc_enum speaker_ref =
+        SOC_ENUM_SINGLE(WM8993_SPEAKER_MIXER, 8, 2, speaker_ref_text);
+
+static const char *speaker_mode_text[] = {
+        "Class D",
+        "Class AB",
+};
+
+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)
+{
+        unsigned int reg;
+        int count = 0;
+
+        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);
+
+        if ((reg & WM8993_DCS_CAL_COMPLETE_MASK)
+            != WM8993_DCS_CAL_COMPLETE_MASK)
+                dev_err(codec->dev, "Timed out waiting for DC Servo\n");
+}
+
+/*
+ * 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_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+        int ret;
+
+        ret = snd_soc_put_volsw_2r(kcontrol, ucontrol);
+
+        /* 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))
+                snd_soc_update_bits(codec,
+                                    WM8993_DC_SERVO_0,
+                                    WM8993_DCS_TRIG_SINGLE_0 |
+                                    WM8993_DCS_TRIG_SINGLE_1,
+                                    WM8993_DCS_TRIG_SINGLE_0 |
+                                    WM8993_DCS_TRIG_SINGLE_1);
+
+        return ret;
+}
+
+static const struct snd_kcontrol_new analogue_snd_controls[] = {
+SOC_SINGLE_TLV("IN1L Volume", WM8993_LEFT_LINE_INPUT_1_2_VOLUME, 0, 31, 0,
+               inpga_tlv),
+SOC_SINGLE("IN1L Switch", WM8993_LEFT_LINE_INPUT_1_2_VOLUME, 7, 1, 1),
+SOC_SINGLE("IN1L ZC Switch", WM8993_LEFT_LINE_INPUT_1_2_VOLUME, 7, 1, 0),
+
+SOC_SINGLE_TLV("IN1R Volume", WM8993_RIGHT_LINE_INPUT_1_2_VOLUME, 0, 31, 0,
+               inpga_tlv),
+SOC_SINGLE("IN1R Switch", WM8993_RIGHT_LINE_INPUT_1_2_VOLUME, 7, 1, 1),
+SOC_SINGLE("IN1R ZC Switch", WM8993_RIGHT_LINE_INPUT_1_2_VOLUME, 7, 1, 0),
+
+
+SOC_SINGLE_TLV("IN2L Volume", WM8993_LEFT_LINE_INPUT_3_4_VOLUME, 0, 31, 0,
+               inpga_tlv),
+SOC_SINGLE("IN2L Switch", WM8993_LEFT_LINE_INPUT_3_4_VOLUME, 7, 1, 1),
+SOC_SINGLE("IN2L ZC Switch", WM8993_LEFT_LINE_INPUT_3_4_VOLUME, 7, 1, 0),
+
+SOC_SINGLE_TLV("IN2R Volume", WM8993_RIGHT_LINE_INPUT_3_4_VOLUME, 0, 31, 0,
+               inpga_tlv),
+SOC_SINGLE("IN2R Switch", WM8993_RIGHT_LINE_INPUT_3_4_VOLUME, 7, 1, 1),
+SOC_SINGLE("IN2R ZC Switch", WM8993_RIGHT_LINE_INPUT_3_4_VOLUME, 7, 1, 0),
+
+SOC_SINGLE_TLV("MIXINL IN2L Volume", WM8993_INPUT_MIXER3, 7, 1, 0,
+               inmix_sw_tlv),
+SOC_SINGLE_TLV("MIXINL IN1L Volume", WM8993_INPUT_MIXER3, 4, 1, 0,
+               inmix_sw_tlv),
+SOC_SINGLE_TLV("MIXINL Output Record Volume", WM8993_INPUT_MIXER3, 0, 7, 0,
+               inmix_tlv),
+SOC_SINGLE_TLV("MIXINL IN1LP Volume", WM8993_INPUT_MIXER5, 6, 7, 0, inmix_tlv),
+SOC_SINGLE_TLV("MIXINL Direct Voice Volume", WM8993_INPUT_MIXER5, 0, 6, 0,
+               inmix_tlv),
+
+SOC_SINGLE_TLV("MIXINR IN2R Volume", WM8993_INPUT_MIXER4, 7, 1, 0,
+               inmix_sw_tlv),
+SOC_SINGLE_TLV("MIXINR IN1R Volume", WM8993_INPUT_MIXER4, 4, 1, 0,
+               inmix_sw_tlv),
+SOC_SINGLE_TLV("MIXINR Output Record Volume", WM8993_INPUT_MIXER4, 0, 7, 0,
+               inmix_tlv),
+SOC_SINGLE_TLV("MIXINR IN1RP Volume", WM8993_INPUT_MIXER6, 6, 7, 0, inmix_tlv),
+SOC_SINGLE_TLV("MIXINR Direct Voice Volume", WM8993_INPUT_MIXER6, 0, 6, 0,
+               inmix_tlv),
+
+SOC_SINGLE_TLV("Left Output Mixer IN2RN Volume", WM8993_OUTPUT_MIXER5, 6, 7, 1,
+               outmix_tlv),
+SOC_SINGLE_TLV("Left Output Mixer IN2LN Volume", WM8993_OUTPUT_MIXER3, 6, 7, 1,
+               outmix_tlv),
+SOC_SINGLE_TLV("Left Output Mixer IN2LP Volume", WM8993_OUTPUT_MIXER3, 9, 7, 1,
+               outmix_tlv),
+SOC_SINGLE_TLV("Left Output Mixer IN1L Volume", WM8993_OUTPUT_MIXER3, 0, 7, 1,
+               outmix_tlv),
+SOC_SINGLE_TLV("Left Output Mixer IN1R Volume", WM8993_OUTPUT_MIXER3, 3, 7, 1,
+               outmix_tlv),
+SOC_SINGLE_TLV("Left Output Mixer Right Input Volume",
+               WM8993_OUTPUT_MIXER5, 3, 7, 1, outmix_tlv),
+SOC_SINGLE_TLV("Left Output Mixer Left Input Volume",
+               WM8993_OUTPUT_MIXER5, 0, 7, 1, outmix_tlv),
+SOC_SINGLE_TLV("Left Output Mixer DAC Volume", WM8993_OUTPUT_MIXER5, 9, 7, 1,
+               outmix_tlv),
+
+SOC_SINGLE_TLV("Right Output Mixer IN2LN Volume",
+               WM8993_OUTPUT_MIXER6, 6, 7, 1, outmix_tlv),
+SOC_SINGLE_TLV("Right Output Mixer IN2RN Volume",
+               WM8993_OUTPUT_MIXER4, 6, 7, 1, outmix_tlv),
+SOC_SINGLE_TLV("Right Output Mixer IN1L Volume",
+               WM8993_OUTPUT_MIXER4, 3, 7, 1, outmix_tlv),
+SOC_SINGLE_TLV("Right Output Mixer IN1R Volume",
+               WM8993_OUTPUT_MIXER4, 0, 7, 1, outmix_tlv),
+SOC_SINGLE_TLV("Right Output Mixer IN2RP Volume",
+               WM8993_OUTPUT_MIXER4, 9, 7, 1, outmix_tlv),
+SOC_SINGLE_TLV("Right Output Mixer Left Input Volume",
+               WM8993_OUTPUT_MIXER6, 3, 7, 1, outmix_tlv),
+SOC_SINGLE_TLV("Right Output Mixer Right Input Volume",
+               WM8993_OUTPUT_MIXER6, 6, 7, 1, outmix_tlv),
+SOC_SINGLE_TLV("Right Output Mixer DAC Volume",
+               WM8993_OUTPUT_MIXER6, 9, 7, 1, outmix_tlv),
+
+SOC_DOUBLE_R_TLV("Output Volume", WM8993_LEFT_OPGA_VOLUME,
+                 WM8993_RIGHT_OPGA_VOLUME, 0, 63, 0, outpga_tlv),
+SOC_DOUBLE_R("Output Switch", WM8993_LEFT_OPGA_VOLUME,
+             WM8993_RIGHT_OPGA_VOLUME, 6, 1, 0),
+SOC_DOUBLE_R("Output ZC Switch", WM8993_LEFT_OPGA_VOLUME,
+             WM8993_RIGHT_OPGA_VOLUME, 7, 1, 0),
+
+SOC_SINGLE("Earpiece Switch", WM8993_HPOUT2_VOLUME, 5, 1, 1),
+SOC_SINGLE_TLV("Earpiece Volume", WM8993_HPOUT2_VOLUME, 4, 1, 1, earpiece_tlv),
+
+SOC_SINGLE_TLV("SPKL Input Volume", WM8993_SPKMIXL_ATTENUATION,
+               5, 1, 1, wm_hubs_spkmix_tlv),
+SOC_SINGLE_TLV("SPKL IN1LP Volume", WM8993_SPKMIXL_ATTENUATION,
+               4, 1, 1, wm_hubs_spkmix_tlv),
+SOC_SINGLE_TLV("SPKL Output Volume", WM8993_SPKMIXL_ATTENUATION,
+               3, 1, 1, wm_hubs_spkmix_tlv),
+
+SOC_SINGLE_TLV("SPKR Input Volume", WM8993_SPKMIXR_ATTENUATION,
+               5, 1, 1, wm_hubs_spkmix_tlv),
+SOC_SINGLE_TLV("SPKR IN1RP Volume", WM8993_SPKMIXR_ATTENUATION,
+               4, 1, 1, wm_hubs_spkmix_tlv),
+SOC_SINGLE_TLV("SPKR Output Volume", WM8993_SPKMIXR_ATTENUATION,
+               3, 1, 1, wm_hubs_spkmix_tlv),
+
+SOC_DOUBLE_R_TLV("Speaker Mixer Volume",
+                 WM8993_SPKMIXL_ATTENUATION, WM8993_SPKMIXR_ATTENUATION,
+                 0, 3, 1, spkmixout_tlv),
+SOC_DOUBLE_R_TLV("Speaker Volume",
+                 WM8993_SPEAKER_VOLUME_LEFT, WM8993_SPEAKER_VOLUME_RIGHT,
+                 0, 63, 0, outpga_tlv),
+SOC_DOUBLE_R("Speaker Switch",
+             WM8993_SPEAKER_VOLUME_LEFT, WM8993_SPEAKER_VOLUME_RIGHT,
+             6, 1, 0),
+SOC_DOUBLE_R("Speaker ZC Switch",
+             WM8993_SPEAKER_VOLUME_LEFT, WM8993_SPEAKER_VOLUME_RIGHT,
+             7, 1, 0),
+SOC_DOUBLE_TLV("Speaker Boost Volume", WM8993_SPKOUT_BOOST, 0, 3, 7, 0,
+               spkboost_tlv),
+SOC_ENUM("Speaker Reference", speaker_ref),
+SOC_ENUM("Speaker Mode", speaker_mode),
+
+{
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Headphone Volume",
+        .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |
+                 SNDRV_CTL_ELEM_ACCESS_READWRITE,
+        .tlv.p = outpga_tlv,
+        .info = snd_soc_info_volsw_2r,
+        .get = snd_soc_get_volsw_2r, .put = wm8993_put_dc_servo,
+        .private_value = (unsigned long)&(struct soc_mixer_control) {
+                .reg = WM8993_LEFT_OUTPUT_VOLUME,
+                .rreg = WM8993_RIGHT_OUTPUT_VOLUME,
+                .shift = 0, .max = 63
+        },
+},
+SOC_DOUBLE_R("Headphone Switch", WM8993_LEFT_OUTPUT_VOLUME,
+             WM8993_RIGHT_OUTPUT_VOLUME, 6, 1, 0),
+SOC_DOUBLE_R("Headphone ZC Switch", WM8993_LEFT_OUTPUT_VOLUME,
+             WM8993_RIGHT_OUTPUT_VOLUME, 7, 1, 0),
+
+SOC_SINGLE("LINEOUT1N Switch", WM8993_LINE_OUTPUTS_VOLUME, 6, 1, 1),
+SOC_SINGLE("LINEOUT1P Switch", WM8993_LINE_OUTPUTS_VOLUME, 5, 1, 1),
+SOC_SINGLE_TLV("LINEOUT1 Volume", WM8993_LINE_OUTPUTS_VOLUME, 4, 1, 1,
+               line_tlv),
+
+SOC_SINGLE("LINEOUT2N Switch", WM8993_LINE_OUTPUTS_VOLUME, 2, 1, 1),
+SOC_SINGLE("LINEOUT2P Switch", WM8993_LINE_OUTPUTS_VOLUME, 1, 1, 1),
+SOC_SINGLE_TLV("LINEOUT2 Volume", WM8993_LINE_OUTPUTS_VOLUME, 0, 1, 1,
+               line_tlv),
+};
+
+static int hp_event(struct snd_soc_dapm_widget *w,
+                    struct snd_kcontrol *kcontrol, int event)
+{
+        struct snd_soc_codec *codec = w->codec;
+        unsigned int reg = snd_soc_read(codec, WM8993_ANALOGUE_HP_0);
+
+        switch (event) {
+        case SND_SOC_DAPM_POST_PMU:
+                snd_soc_update_bits(codec, WM8993_CHARGE_PUMP_1,
+                                    WM8993_CP_ENA, WM8993_CP_ENA);
+
+                msleep(5);
+
+                snd_soc_update_bits(codec, WM8993_POWER_MANAGEMENT_1,
+                                    WM8993_HPOUT1L_ENA | WM8993_HPOUT1R_ENA,
+                                    WM8993_HPOUT1L_ENA | WM8993_HPOUT1R_ENA);
+
+                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,
+                                    WM8993_DCS_ENA_CHAN_0 |
+                                    WM8993_DCS_ENA_CHAN_1 |
+                                    WM8993_DCS_TRIG_STARTUP_1 |
+                                    WM8993_DCS_TRIG_STARTUP_0,
+                                    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);
+                snd_soc_update_bits(codec, WM8993_DC_SERVO_1,
+                                    WM8993_DCS_TIMER_PERIOD_01_MASK, 0xa);
+
+                reg |= WM8993_HPOUT1R_OUTP | WM8993_HPOUT1R_RMV_SHORT |
+                        WM8993_HPOUT1L_OUTP | WM8993_HPOUT1L_RMV_SHORT;
+                snd_soc_write(codec, WM8993_ANALOGUE_HP_0, reg);
+                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_DC_SERVO_1,
+                                    WM8993_DCS_TIMER_PERIOD_01_MASK, 0);
+                snd_soc_update_bits(codec, WM8993_DC_SERVO_0,
+                                    WM8993_DCS_ENA_CHAN_0 |
+                                    WM8993_DCS_ENA_CHAN_1, 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;
+        }
+
+        return 0;
+}
+
+static int earpiece_event(struct snd_soc_dapm_widget *w,
+                          struct snd_kcontrol *control, int event)
+{
+        struct snd_soc_codec *codec = w->codec;
+        u16 reg = snd_soc_read(codec, WM8993_ANTIPOP1) & ~WM8993_HPOUT2_IN_ENA;
+
+        switch (event) {
+        case SND_SOC_DAPM_PRE_PMU:
+                reg |= WM8993_HPOUT2_IN_ENA;
+                snd_soc_write(codec, WM8993_ANTIPOP1, reg);
+                udelay(50);
+                break;
+
+        case SND_SOC_DAPM_POST_PMD:
+                snd_soc_write(codec, WM8993_ANTIPOP1, reg);
+                break;
+
+        default:
+                BUG();
+                break;
+        }
+
+        return 0;
+}
+
+static const struct snd_kcontrol_new in1l_pga[] = {
+SOC_DAPM_SINGLE("IN1LP Switch", WM8993_INPUT_MIXER2, 5, 1, 0),
+SOC_DAPM_SINGLE("IN1LN Switch", WM8993_INPUT_MIXER2, 4, 1, 0),
+};
+
+static const struct snd_kcontrol_new in1r_pga[] = {
+SOC_DAPM_SINGLE("IN1RP Switch", WM8993_INPUT_MIXER2, 1, 1, 0),
+SOC_DAPM_SINGLE("IN1RN Switch", WM8993_INPUT_MIXER2, 0, 1, 0),
+};
+
+static const struct snd_kcontrol_new in2l_pga[] = {
+SOC_DAPM_SINGLE("IN2LP Switch", WM8993_INPUT_MIXER2, 7, 1, 0),
+SOC_DAPM_SINGLE("IN2LN Switch", WM8993_INPUT_MIXER2, 6, 1, 0),
+};
+
+static const struct snd_kcontrol_new in2r_pga[] = {
+SOC_DAPM_SINGLE("IN2RP Switch", WM8993_INPUT_MIXER2, 3, 1, 0),
+SOC_DAPM_SINGLE("IN2RN Switch", WM8993_INPUT_MIXER2, 2, 1, 0),
+};
+
+static const struct snd_kcontrol_new mixinl[] = {
+SOC_DAPM_SINGLE("IN2L Switch", WM8993_INPUT_MIXER3, 8, 1, 0),
+SOC_DAPM_SINGLE("IN1L Switch", WM8993_INPUT_MIXER3, 5, 1, 0),
+};
+
+static const struct snd_kcontrol_new mixinr[] = {
+SOC_DAPM_SINGLE("IN2R Switch", WM8993_INPUT_MIXER4, 8, 1, 0),
+SOC_DAPM_SINGLE("IN1R Switch", WM8993_INPUT_MIXER4, 5, 1, 0),
+};
+
+static const struct snd_kcontrol_new left_output_mixer[] = {
+SOC_DAPM_SINGLE("Right Input Switch", WM8993_OUTPUT_MIXER1, 7, 1, 0),
+SOC_DAPM_SINGLE("Left Input Switch", WM8993_OUTPUT_MIXER1, 6, 1, 0),
+SOC_DAPM_SINGLE("IN2RN Switch", WM8993_OUTPUT_MIXER1, 5, 1, 0),
+SOC_DAPM_SINGLE("IN2LN Switch", WM8993_OUTPUT_MIXER1, 4, 1, 0),
+SOC_DAPM_SINGLE("IN2LP Switch", WM8993_OUTPUT_MIXER1, 1, 1, 0),
+SOC_DAPM_SINGLE("IN1R Switch", WM8993_OUTPUT_MIXER1, 3, 1, 0),
+SOC_DAPM_SINGLE("IN1L Switch", WM8993_OUTPUT_MIXER1, 2, 1, 0),
+SOC_DAPM_SINGLE("DAC Switch", WM8993_OUTPUT_MIXER1, 0, 1, 0),
+};
+
+static const struct snd_kcontrol_new right_output_mixer[] = {
+SOC_DAPM_SINGLE("Left Input Switch", WM8993_OUTPUT_MIXER2, 7, 1, 0),
+SOC_DAPM_SINGLE("Right Input Switch", WM8993_OUTPUT_MIXER2, 6, 1, 0),
+SOC_DAPM_SINGLE("IN2LN Switch", WM8993_OUTPUT_MIXER2, 5, 1, 0),
+SOC_DAPM_SINGLE("IN2RN Switch", WM8993_OUTPUT_MIXER2, 4, 1, 0),
+SOC_DAPM_SINGLE("IN1L Switch", WM8993_OUTPUT_MIXER2, 3, 1, 0),
+SOC_DAPM_SINGLE("IN1R Switch", WM8993_OUTPUT_MIXER2, 2, 1, 0),
+SOC_DAPM_SINGLE("IN2RP Switch", WM8993_OUTPUT_MIXER2, 1, 1, 0),
+SOC_DAPM_SINGLE("DAC Switch", WM8993_OUTPUT_MIXER2, 0, 1, 0),
+};
+
+static const struct snd_kcontrol_new earpiece_mixer[] = {
+SOC_DAPM_SINGLE("Direct Voice Switch", WM8993_HPOUT2_MIXER, 5, 1, 0),
+SOC_DAPM_SINGLE("Left Output Switch", WM8993_HPOUT2_MIXER, 4, 1, 0),
+SOC_DAPM_SINGLE("Right Output Switch", WM8993_HPOUT2_MIXER, 3, 1, 0),
+};
+
+static const struct snd_kcontrol_new left_speaker_boost[] = {
+SOC_DAPM_SINGLE("Direct Voice Switch", WM8993_SPKOUT_MIXERS, 5, 1, 0),
+SOC_DAPM_SINGLE("SPKL Switch", WM8993_SPKOUT_MIXERS, 4, 1, 0),
+SOC_DAPM_SINGLE("SPKR Switch", WM8993_SPKOUT_MIXERS, 3, 1, 0),
+};
+
+static const struct snd_kcontrol_new right_speaker_boost[] = {
+SOC_DAPM_SINGLE("Direct Voice Switch", WM8993_SPKOUT_MIXERS, 2, 1, 0),
+SOC_DAPM_SINGLE("SPKL Switch", WM8993_SPKOUT_MIXERS, 1, 1, 0),
+SOC_DAPM_SINGLE("SPKR Switch", WM8993_SPKOUT_MIXERS, 0, 1, 0),
+};
+
+static const struct snd_kcontrol_new line1_mix[] = {
+SOC_DAPM_SINGLE("IN1R Switch", WM8993_LINE_MIXER1, 2, 1, 0),
+SOC_DAPM_SINGLE("IN1L Switch", WM8993_LINE_MIXER1, 1, 1, 0),
+SOC_DAPM_SINGLE("Output Switch", WM8993_LINE_MIXER1, 0, 1, 0),
+};
+
+static const struct snd_kcontrol_new line1n_mix[] = {
+SOC_DAPM_SINGLE("Left Output Switch", WM8993_LINE_MIXER1, 6, 1, 0),
+SOC_DAPM_SINGLE("Right Output Switch", WM8993_LINE_MIXER1, 5, 1, 0),
+};
+
+static const struct snd_kcontrol_new line1p_mix[] = {
+SOC_DAPM_SINGLE("Left Output Switch", WM8993_LINE_MIXER1, 0, 1, 0),
+};
+
+static const struct snd_kcontrol_new line2_mix[] = {
+SOC_DAPM_SINGLE("IN2R Switch", WM8993_LINE_MIXER2, 2, 1, 0),
+SOC_DAPM_SINGLE("IN2L Switch", WM8993_LINE_MIXER2, 1, 1, 0),
+SOC_DAPM_SINGLE("Output Switch", WM8993_LINE_MIXER2, 0, 1, 0),
+};
+
+static const struct snd_kcontrol_new line2n_mix[] = {
+SOC_DAPM_SINGLE("Left Output Switch", WM8993_LINE_MIXER2, 6, 1, 0),
+SOC_DAPM_SINGLE("Right Output Switch", WM8993_LINE_MIXER2, 5, 1, 0),
+};
+
+static const struct snd_kcontrol_new line2p_mix[] = {
+SOC_DAPM_SINGLE("Right Output Switch", WM8993_LINE_MIXER2, 0, 1, 0),
+};
+
+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("IN1RN"),
+SND_SOC_DAPM_INPUT("IN1RP"),
+SND_SOC_DAPM_INPUT("IN2RN"),
+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),
+
+SND_SOC_DAPM_MIXER("IN1L PGA", WM8993_POWER_MANAGEMENT_2, 6, 0,
+                   in1l_pga, ARRAY_SIZE(in1l_pga)),
+SND_SOC_DAPM_MIXER("IN1R PGA", WM8993_POWER_MANAGEMENT_2, 4, 0,
+                   in1r_pga, ARRAY_SIZE(in1r_pga)),
+
+SND_SOC_DAPM_MIXER("IN2L PGA", WM8993_POWER_MANAGEMENT_2, 7, 0,
+                   in2l_pga, ARRAY_SIZE(in2l_pga)),
+SND_SOC_DAPM_MIXER("IN2R PGA", WM8993_POWER_MANAGEMENT_2, 5, 0,
+                   in2r_pga, ARRAY_SIZE(in2r_pga)),
+
+/* Dummy widgets to represent differential paths */
+SND_SOC_DAPM_PGA("Direct Voice", SND_SOC_NOPM, 0, 0, NULL, 0),
+
+SND_SOC_DAPM_MIXER("MIXINL", WM8993_POWER_MANAGEMENT_2, 9, 0,
+                   mixinl, ARRAY_SIZE(mixinl)),
+SND_SOC_DAPM_MIXER("MIXINR", WM8993_POWER_MANAGEMENT_2, 8, 0,
+                   mixinr, ARRAY_SIZE(mixinr)),
+
+SND_SOC_DAPM_ADC("ADCL", "Capture", WM8993_POWER_MANAGEMENT_2, 1, 0),
+SND_SOC_DAPM_ADC("ADCR", "Capture", WM8993_POWER_MANAGEMENT_2, 0, 0),
+
+SND_SOC_DAPM_DAC("DACL", "Playback", WM8993_POWER_MANAGEMENT_3, 1, 0),
+SND_SOC_DAPM_DAC("DACR", "Playback", WM8993_POWER_MANAGEMENT_3, 0, 0),
+
+SND_SOC_DAPM_MIXER("Left Output Mixer", WM8993_POWER_MANAGEMENT_3, 5, 0,
+                   left_output_mixer, ARRAY_SIZE(left_output_mixer)),
+SND_SOC_DAPM_MIXER("Right Output Mixer", WM8993_POWER_MANAGEMENT_3, 4, 0,
+                   right_output_mixer, ARRAY_SIZE(right_output_mixer)),
+
+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_PGA_E("Headphone PGA", SND_SOC_NOPM, 0, 0,
+                   NULL, 0,
+                   hp_event, SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
+
+SND_SOC_DAPM_MIXER("Earpiece Mixer", SND_SOC_NOPM, 0, 0,
+                   earpiece_mixer, ARRAY_SIZE(earpiece_mixer)),
+SND_SOC_DAPM_PGA_E("Earpiece Driver", WM8993_POWER_MANAGEMENT_1, 11, 0,
+                   NULL, 0, earpiece_event,
+                   SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
+
+SND_SOC_DAPM_MIXER("SPKL Boost", SND_SOC_NOPM, 0, 0,
+                   left_speaker_boost, ARRAY_SIZE(left_speaker_boost)),
+SND_SOC_DAPM_MIXER("SPKR Boost", SND_SOC_NOPM, 0, 0,
+                   right_speaker_boost, ARRAY_SIZE(right_speaker_boost)),
+
+SND_SOC_DAPM_PGA("SPKL Driver", WM8993_POWER_MANAGEMENT_1, 12, 0,
+                 NULL, 0),
+SND_SOC_DAPM_PGA("SPKR Driver", WM8993_POWER_MANAGEMENT_1, 13, 0,
+                 NULL, 0),
+
+SND_SOC_DAPM_MIXER("LINEOUT1 Mixer", SND_SOC_NOPM, 0, 0,
+                   line1_mix, ARRAY_SIZE(line1_mix)),
+SND_SOC_DAPM_MIXER("LINEOUT2 Mixer", SND_SOC_NOPM, 0, 0,
+                   line2_mix, ARRAY_SIZE(line2_mix)),
+
+SND_SOC_DAPM_MIXER("LINEOUT1N Mixer", SND_SOC_NOPM, 0, 0,
+                   line1n_mix, ARRAY_SIZE(line1n_mix)),
+SND_SOC_DAPM_MIXER("LINEOUT1P Mixer", SND_SOC_NOPM, 0, 0,
+                   line1p_mix, ARRAY_SIZE(line1p_mix)),
+SND_SOC_DAPM_MIXER("LINEOUT2N Mixer", SND_SOC_NOPM, 0, 0,
+                   line2n_mix, ARRAY_SIZE(line2n_mix)),
+SND_SOC_DAPM_MIXER("LINEOUT2P Mixer", SND_SOC_NOPM, 0, 0,
+                   line2p_mix, ARRAY_SIZE(line2p_mix)),
+
+SND_SOC_DAPM_PGA("LINEOUT1N Driver", WM8993_POWER_MANAGEMENT_3, 13, 0,
+                 NULL, 0),
+SND_SOC_DAPM_PGA("LINEOUT1P Driver", WM8993_POWER_MANAGEMENT_3, 12, 0,
+                 NULL, 0),
+SND_SOC_DAPM_PGA("LINEOUT2N Driver", WM8993_POWER_MANAGEMENT_3, 11, 0,
+                 NULL, 0),
+SND_SOC_DAPM_PGA("LINEOUT2P Driver", WM8993_POWER_MANAGEMENT_3, 10, 0,
+                 NULL, 0),
+
+SND_SOC_DAPM_OUTPUT("SPKOUTLP"),
+SND_SOC_DAPM_OUTPUT("SPKOUTLN"),
+SND_SOC_DAPM_OUTPUT("SPKOUTRP"),
+SND_SOC_DAPM_OUTPUT("SPKOUTRN"),
+SND_SOC_DAPM_OUTPUT("HPOUT1L"),
+SND_SOC_DAPM_OUTPUT("HPOUT1R"),
+SND_SOC_DAPM_OUTPUT("HPOUT2P"),
+SND_SOC_DAPM_OUTPUT("HPOUT2N"),
+SND_SOC_DAPM_OUTPUT("LINEOUT1P"),
+SND_SOC_DAPM_OUTPUT("LINEOUT1N"),
+SND_SOC_DAPM_OUTPUT("LINEOUT2P"),
+SND_SOC_DAPM_OUTPUT("LINEOUT2N"),
+};
+
+static const struct snd_soc_dapm_route analogue_routes[] = {
+        { "IN1L PGA", "IN1LP Switch", "IN1LP" },
+        { "IN1L PGA", "IN1LN Switch", "IN1LN" },
+
+        { "IN1R PGA", "IN1RP Switch", "IN1RP" },
+        { "IN1R PGA", "IN1RN Switch", "IN1RN" },
+
+        { "IN2L PGA", "IN2LP Switch", "IN2LP/VXRN" },
+        { "IN2L PGA", "IN2LN Switch", "IN2LN" },
+
+        { "IN2R PGA", "IN2RP Switch", "IN2RP/VXRP" },
+        { "IN2R PGA", "IN2RN Switch", "IN2RN" },
+
+        { "Direct Voice", NULL, "IN2LP/VXRN" },
+        { "Direct Voice", NULL, "IN2RP/VXRP" },
+
+        { "MIXINL", "IN1L Switch", "IN1L PGA" },
+        { "MIXINL", "IN2L Switch", "IN2L PGA" },
+        { "MIXINL", NULL, "Direct Voice" },
+        { "MIXINL", NULL, "IN1LP" },
+        { "MIXINL", NULL, "Left Output Mixer" },
+
+        { "MIXINR", "IN1R Switch", "IN1R PGA" },
+        { "MIXINR", "IN2R Switch", "IN2R PGA" },
+        { "MIXINR", NULL, "Direct Voice" },
+        { "MIXINR", NULL, "IN1RP" },
+        { "MIXINR", NULL, "Right Output Mixer" },
+
+        { "ADCL", NULL, "MIXINL" },
+        { "ADCR", NULL, "MIXINR" },
+
+        { "Left Output Mixer", "Left Input Switch", "MIXINL" },
+        { "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", "IN1L Switch", "IN1L PGA" },
+        { "Left Output Mixer", "IN1R Switch", "IN1R PGA" },
+
+        { "Right Output Mixer", "Left Input Switch", "MIXINL" },
+        { "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", "IN1L Switch", "IN1L PGA" },
+        { "Right Output Mixer", "IN1R Switch", "IN1R PGA" },
+
+        { "Left Output PGA", NULL, "Left Output Mixer" },
+        { "Left Output PGA", NULL, "TOCLK" },
+
+        { "Right Output PGA", NULL, "Right Output Mixer" },
+        { "Right Output PGA", NULL, "TOCLK" },
+
+        { "Earpiece Mixer", "Direct Voice Switch", "Direct Voice" },
+        { "Earpiece Mixer", "Left Output Switch", "Left Output PGA" },
+        { "Earpiece Mixer", "Right Output Switch", "Right Output PGA" },
+
+        { "Earpiece Driver", NULL, "Earpiece Mixer" },
+        { "HPOUT2N", NULL, "Earpiece Driver" },
+        { "HPOUT2P", NULL, "Earpiece Driver" },
+
+        { "SPKL", "Input Switch", "MIXINL" },
+        { "SPKL", "IN1LP Switch", "IN1LP" },
+        { "SPKL", "Output Switch", "Left Output Mixer" },
+        { "SPKL", NULL, "TOCLK" },
+
+        { "SPKR", "Input Switch", "MIXINR" },
+        { "SPKR", "IN1RP Switch", "IN1RP" },
+        { "SPKR", "Output Switch", "Right Output Mixer" },
+        { "SPKR", NULL, "TOCLK" },
+
+        { "SPKL Boost", "Direct Voice Switch", "Direct Voice" },
+        { "SPKL Boost", "SPKL Switch", "SPKL" },
+        { "SPKL Boost", "SPKR Switch", "SPKR" },
+
+        { "SPKR Boost", "Direct Voice Switch", "Direct Voice" },
+        { "SPKR Boost", "SPKR Switch", "SPKR" },
+        { "SPKR Boost", "SPKL Switch", "SPKL" },
+
+        { "SPKL Driver", NULL, "SPKL Boost" },
+        { "SPKL Driver", NULL, "CLK_SYS" },
+
+        { "SPKR Driver", NULL, "SPKR Boost" },
+        { "SPKR Driver", NULL, "CLK_SYS" },
+
+        { "SPKOUTLP", NULL, "SPKL Driver" },
+        { "SPKOUTLN", NULL, "SPKL Driver" },
+        { "SPKOUTRP", NULL, "SPKR Driver" },
+        { "SPKOUTRN", NULL, "SPKR Driver" },
+
+        { "Left Headphone Mux", "Mixer", "Left Output Mixer" },
+        { "Right Headphone Mux", "Mixer", "Right Output Mixer" },
+
+        { "Headphone PGA", NULL, "Left Headphone Mux" },
+        { "Headphone PGA", NULL, "Right Headphone Mux" },
+        { "Headphone PGA", NULL, "CLK_SYS" },
+
+        { "HPOUT1L", NULL, "Headphone PGA" },
+        { "HPOUT1R", NULL, "Headphone PGA" },
+
+        { "LINEOUT1N", NULL, "LINEOUT1N Driver" },
+        { "LINEOUT1P", NULL, "LINEOUT1P Driver" },
+        { "LINEOUT2N", NULL, "LINEOUT2N Driver" },
+        { "LINEOUT2P", NULL, "LINEOUT2P Driver" },
+};
+
+static const struct snd_soc_dapm_route lineout1_diff_routes[] = {
+        { "LINEOUT1 Mixer", "IN1L Switch", "IN1L PGA" },
+        { "LINEOUT1 Mixer", "IN1R Switch", "IN1R PGA" },
+        { "LINEOUT1 Mixer", "Output Switch", "Left Output Mixer" },
+
+        { "LINEOUT1N Driver", NULL, "LINEOUT1 Mixer" },
+        { "LINEOUT1P Driver", NULL, "LINEOUT1 Mixer" },
+};
+
+static const struct snd_soc_dapm_route lineout1_se_routes[] = {
+        { "LINEOUT1N Mixer", "Left Output Switch", "Left Output Mixer" },
+        { "LINEOUT1N Mixer", "Right Output Switch", "Left Output Mixer" },
+
+        { "LINEOUT1P Mixer", "Left Output Switch", "Left Output Mixer" },
+
+        { "LINEOUT1N Driver", NULL, "LINEOUT1N Mixer" },
+        { "LINEOUT1P Driver", NULL, "LINEOUT1P Mixer" },
+};
+
+static const struct snd_soc_dapm_route lineout2_diff_routes[] = {
+        { "LINEOUT2 Mixer", "IN2L Switch", "IN2L PGA" },
+        { "LINEOUT2 Mixer", "IN2R Switch", "IN2R PGA" },
+        { "LINEOUT2 Mixer", "Output Switch", "Right Output Mixer" },
+
+        { "LINEOUT2N Driver", NULL, "LINEOUT2 Mixer" },
+        { "LINEOUT2P Driver", NULL, "LINEOUT2 Mixer" },
+};
+
+static const struct snd_soc_dapm_route lineout2_se_routes[] = {
+        { "LINEOUT2N Mixer", "Left Output Switch", "Left Output Mixer" },
+        { "LINEOUT2N Mixer", "Right Output Switch", "Left Output Mixer" },
+
+        { "LINEOUT2P Mixer", "Right Output Switch", "Right Output Mixer" },
+
+        { "LINEOUT2N Driver", NULL, "LINEOUT2N Mixer" },
+        { "LINEOUT2P Driver", NULL, "LINEOUT2P Mixer" },
+};
+
+int wm_hubs_add_analogue_controls(struct snd_soc_codec *codec)
+{
+        /* Latch volume update bits & default ZC on */
+        snd_soc_update_bits(codec, WM8993_LEFT_LINE_INPUT_1_2_VOLUME,
+                            WM8993_IN1_VU, WM8993_IN1_VU);
+        snd_soc_update_bits(codec, WM8993_RIGHT_LINE_INPUT_1_2_VOLUME,
+                            WM8993_IN1_VU, WM8993_IN1_VU);
+        snd_soc_update_bits(codec, WM8993_LEFT_LINE_INPUT_3_4_VOLUME,
+                            WM8993_IN2_VU, WM8993_IN2_VU);
+        snd_soc_update_bits(codec, WM8993_RIGHT_LINE_INPUT_3_4_VOLUME,
+                            WM8993_IN2_VU, WM8993_IN2_VU);
+
+        snd_soc_update_bits(codec, WM8993_SPEAKER_VOLUME_RIGHT,
+                            WM8993_SPKOUT_VU, WM8993_SPKOUT_VU);
+
+        snd_soc_update_bits(codec, WM8993_LEFT_OUTPUT_VOLUME,
+                            WM8993_HPOUT1L_ZC, WM8993_HPOUT1L_ZC);
+        snd_soc_update_bits(codec, WM8993_RIGHT_OUTPUT_VOLUME,
+                            WM8993_HPOUT1_VU | WM8993_HPOUT1R_ZC,
+                            WM8993_HPOUT1_VU | WM8993_HPOUT1R_ZC);
+
+        snd_soc_update_bits(codec, WM8993_LEFT_OPGA_VOLUME,
+                            WM8993_MIXOUTL_ZC, WM8993_MIXOUTL_ZC);
+        snd_soc_update_bits(codec, WM8993_RIGHT_OPGA_VOLUME,
+                            WM8993_MIXOUTR_ZC | WM8993_MIXOUT_VU,
+                            WM8993_MIXOUTR_ZC | WM8993_MIXOUT_VU);
+
+        snd_soc_add_controls(codec, analogue_snd_controls,
+                             ARRAY_SIZE(analogue_snd_controls));
+
+        snd_soc_dapm_new_controls(codec, analogue_dapm_widgets,
+                                  ARRAY_SIZE(analogue_dapm_widgets));
+        return 0;
+}
+EXPORT_SYMBOL_GPL(wm_hubs_add_analogue_controls);
+
+int wm_hubs_add_analogue_routes(struct snd_soc_codec *codec,
+                                int lineout1_diff, int lineout2_diff)
+{
+        snd_soc_dapm_add_routes(codec, analogue_routes,
+                                ARRAY_SIZE(analogue_routes));
+
+        if (lineout1_diff)
+                snd_soc_dapm_add_routes(codec,
+                                        lineout1_diff_routes,
+                                        ARRAY_SIZE(lineout1_diff_routes));
+        else
+                snd_soc_dapm_add_routes(codec,
+                                        lineout1_se_routes,
+                                        ARRAY_SIZE(lineout1_se_routes));
+
+        if (lineout2_diff)
+                snd_soc_dapm_add_routes(codec,
+                                        lineout2_diff_routes,
+                                        ARRAY_SIZE(lineout2_diff_routes));
+        else
+                snd_soc_dapm_add_routes(codec,
+                                        lineout2_se_routes,
+                                        ARRAY_SIZE(lineout2_se_routes));
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(wm_hubs_add_analogue_routes);
+
+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
new file mode 100644
index 000000000000..ec09cb6a2939
--- /dev/null
+++ b/sound/soc/codecs/wm_hubs.h
@@ -0,0 +1,24 @@
+/*
+ * wm_hubs.h  --  WM899x common code
+ *
+ * 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 _WM_HUBS_H
+#define _WM_HUBS_H
+
+struct snd_soc_codec;
+
+extern const unsigned int wm_hubs_spkmix_tlv[];
+
+extern int wm_hubs_add_analogue_controls(struct snd_soc_codec *);
+extern int wm_hubs_add_analogue_routes(struct snd_soc_codec *, int, int);
+
+#endif