69 files changed, 2869 insertions, 1592 deletions

diff --git a/sound/soc/codecs/Kconfig b/sound/soc/codecs/Kconfig
index 9f8e8594aeb9..3684255e5fba 100644
--- a/sound/soc/codecs/Kconfig
+++ b/sound/soc/codecs/Kconfig
@@ -70,6 +70,7 @@ config SND_SOC_ALL_CODECS
         select SND_SOC_UDA134X
         select SND_SOC_UDA1380 if I2C
         select SND_SOC_WL1273 if MFD_WL1273_CORE
+        select SND_SOC_WM0010 if SPI_MASTER
         select SND_SOC_WM1250_EV1 if I2C
         select SND_SOC_WM2000 if I2C
         select SND_SOC_WM2200 if I2C
@@ -326,6 +327,9 @@ config SND_SOC_UDA1380
 config SND_SOC_WL1273
         tristate
 
+config SND_SOC_WM0010
+        tristate
+
 config SND_SOC_WM1250_EV1
         tristate
 
diff --git a/sound/soc/codecs/Makefile b/sound/soc/codecs/Makefile
index 34148bb59c68..ca508b251df7 100644
--- a/sound/soc/codecs/Makefile
+++ b/sound/soc/codecs/Makefile
@@ -61,6 +61,7 @@ snd-soc-twl6040-objs := twl6040.o
 snd-soc-uda134x-objs := uda134x.o
 snd-soc-uda1380-objs := uda1380.o
 snd-soc-wl1273-objs := wl1273.o
+snd-soc-wm0010-objs := wm0010.o
 snd-soc-wm1250-ev1-objs := wm1250-ev1.o
 snd-soc-wm2000-objs := wm2000.o
 snd-soc-wm2200-objs := wm2200.o
@@ -177,6 +178,7 @@ obj-$(CONFIG_SND_SOC_TWL6040)	+= snd-soc-twl6040.o
 obj-$(CONFIG_SND_SOC_UDA134X)   += snd-soc-uda134x.o
 obj-$(CONFIG_SND_SOC_UDA1380)   += snd-soc-uda1380.o
 obj-$(CONFIG_SND_SOC_WL1273)    += snd-soc-wl1273.o
+obj-$(CONFIG_SND_SOC_WM0010)    += snd-soc-wm0010.o
 obj-$(CONFIG_SND_SOC_WM1250_EV1) += snd-soc-wm1250-ev1.o
 obj-$(CONFIG_SND_SOC_WM2000)    += snd-soc-wm2000.o
 obj-$(CONFIG_SND_SOC_WM2200)    += snd-soc-wm2200.o
diff --git a/sound/soc/codecs/ab8500-codec.c b/sound/soc/codecs/ab8500-codec.c
index 23b40186f9b8..2c1c2524ef8c 100644
--- a/sound/soc/codecs/ab8500-codec.c
+++ b/sound/soc/codecs/ab8500-codec.c
@@ -390,10 +390,10 @@ static const struct snd_soc_dapm_widget ab8500_dapm_widgets[] = {
         SND_SOC_DAPM_CLOCK_SUPPLY("audioclk"),
 
         /* Regulators */
-        SND_SOC_DAPM_REGULATOR_SUPPLY("V-AUD", 0),
-        SND_SOC_DAPM_REGULATOR_SUPPLY("V-AMIC1", 0),
-        SND_SOC_DAPM_REGULATOR_SUPPLY("V-AMIC2", 0),
-        SND_SOC_DAPM_REGULATOR_SUPPLY("V-DMIC", 0),
+        SND_SOC_DAPM_REGULATOR_SUPPLY("V-AUD", 0, 0),
+        SND_SOC_DAPM_REGULATOR_SUPPLY("V-AMIC1", 0, 0),
+        SND_SOC_DAPM_REGULATOR_SUPPLY("V-AMIC2", 0, 0),
+        SND_SOC_DAPM_REGULATOR_SUPPLY("V-DMIC", 0, 0),
 
         /* Power */
         SND_SOC_DAPM_SUPPLY("Audio Power",
@@ -2405,10 +2405,7 @@ static int ab8500_codec_probe(struct snd_soc_codec *codec)
         dev_dbg(dev, "%s: Enter.\n", __func__);
 
         /* Setup AB8500 according to board-settings */
-        pdata = (struct ab8500_platform_data *)dev_get_platdata(dev->parent);
-
-        /* Inform SoC Core that we have our own I/O arrangements. */
-        codec->control_data = (void *)true;
+        pdata = dev_get_platdata(dev->parent);
 
         status = ab8500_audio_setup_mics(codec, &pdata->codec->amics);
         if (status < 0) {
diff --git a/sound/soc/codecs/ad1836.c b/sound/soc/codecs/ad1836.c
index c67b50d8b317..dce6ebeef452 100644
--- a/sound/soc/codecs/ad1836.c
+++ b/sound/soc/codecs/ad1836.c
@@ -19,6 +19,8 @@
 #include <sound/soc.h>
 #include <sound/tlv.h>
 #include <linux/spi/spi.h>
+#include <linux/regmap.h>
+
 #include "ad1836.h"
 
 enum ad1836_type {
@@ -30,6 +32,7 @@ enum ad1836_type {
 /* codec private data */
 struct ad1836_priv {
         enum ad1836_type type;
+        struct regmap *regmap;
 };
 
 /*
@@ -161,8 +164,8 @@ static int ad1836_hw_params(struct snd_pcm_substream *substream,
                 struct snd_pcm_hw_params *params,
                 struct snd_soc_dai *dai)
 {
+        struct ad1836_priv *ad1836 = snd_soc_codec_get_drvdata(dai->codec);
         int word_len = 0;
-        struct snd_soc_codec *codec = dai->codec;
 
         /* bit size */
         switch (params_format(params)) {
@@ -178,10 +181,12 @@ static int ad1836_hw_params(struct snd_pcm_substream *substream,
                 break;
         }
 
-        snd_soc_update_bits(codec, AD1836_DAC_CTRL1, AD1836_DAC_WORD_LEN_MASK,
+        regmap_update_bits(ad1836->regmap, AD1836_DAC_CTRL1,
+                AD1836_DAC_WORD_LEN_MASK,
                 word_len << AD1836_DAC_WORD_LEN_OFFSET);
 
-        snd_soc_update_bits(codec, AD1836_ADC_CTRL2, AD1836_ADC_WORD_LEN_MASK,
+        regmap_update_bits(ad1836->regmap, AD1836_ADC_CTRL2,
+                AD1836_ADC_WORD_LEN_MASK,
                 word_len << AD1836_ADC_WORD_OFFSET);
 
         return 0;
@@ -223,15 +228,17 @@ static struct snd_soc_dai_driver ad183x_dais[] = {
 #ifdef CONFIG_PM
 static int ad1836_suspend(struct snd_soc_codec *codec)
 {
+        struct ad1836_priv *ad1836 = snd_soc_codec_get_drvdata(codec);
         /* reset clock control mode */
-        return snd_soc_update_bits(codec, AD1836_ADC_CTRL2,
+        return regmap_update_bits(ad1836->regmap, AD1836_ADC_CTRL2,
                 AD1836_ADC_SERFMT_MASK, 0);
 }
 
 static int ad1836_resume(struct snd_soc_codec *codec)
 {
+        struct ad1836_priv *ad1836 = snd_soc_codec_get_drvdata(codec);
         /* restore clock control mode */
-        return snd_soc_update_bits(codec, AD1836_ADC_CTRL2,
+        return regmap_update_bits(ad1836->regmap, AD1836_ADC_CTRL2,
                 AD1836_ADC_SERFMT_MASK, AD1836_ADC_AUX);
 }
 #else
@@ -250,37 +257,30 @@ static int ad1836_probe(struct snd_soc_codec *codec)
         num_dacs = ad183x_dais[ad1836->type].playback.channels_max / 2;
         num_adcs = ad183x_dais[ad1836->type].capture.channels_max / 2;
 
-        ret = snd_soc_codec_set_cache_io(codec, 4, 12, SND_SOC_SPI);
-        if (ret < 0) {
-                dev_err(codec->dev, "failed to set cache I/O: %d\n",
-                                ret);
-                return ret;
-        }
-
         /* default setting for ad1836 */
         /* de-emphasis: 48kHz, power-on dac */
-        snd_soc_write(codec, AD1836_DAC_CTRL1, 0x300);
+        regmap_write(ad1836->regmap, AD1836_DAC_CTRL1, 0x300);
         /* unmute dac channels */
-        snd_soc_write(codec, AD1836_DAC_CTRL2, 0x0);
+        regmap_write(ad1836->regmap, AD1836_DAC_CTRL2, 0x0);
         /* high-pass filter enable, power-on adc */
-        snd_soc_write(codec, AD1836_ADC_CTRL1, 0x100);
+        regmap_write(ad1836->regmap, AD1836_ADC_CTRL1, 0x100);
         /* unmute adc channles, adc aux mode */
-        snd_soc_write(codec, AD1836_ADC_CTRL2, 0x180);
+        regmap_write(ad1836->regmap, AD1836_ADC_CTRL2, 0x180);
         /* volume */
         for (i = 1; i <= num_dacs; ++i) {
-                snd_soc_write(codec, AD1836_DAC_L_VOL(i), 0x3FF);
-                snd_soc_write(codec, AD1836_DAC_R_VOL(i), 0x3FF);
+                regmap_write(ad1836->regmap, AD1836_DAC_L_VOL(i), 0x3FF);
+                regmap_write(ad1836->regmap, AD1836_DAC_R_VOL(i), 0x3FF);
         }
 
         if (ad1836->type == AD1836) {
                 /* left/right diff:PGA/MUX */
-                snd_soc_write(codec, AD1836_ADC_CTRL3, 0x3A);
+                regmap_write(ad1836->regmap, AD1836_ADC_CTRL3, 0x3A);
                 ret = snd_soc_add_codec_controls(codec, ad1836_controls,
                                 ARRAY_SIZE(ad1836_controls));
                 if (ret)
                         return ret;
         } else {
-                snd_soc_write(codec, AD1836_ADC_CTRL3, 0x00);
+                regmap_write(ad1836->regmap, AD1836_ADC_CTRL3, 0x00);
         }
 
         ret = snd_soc_add_codec_controls(codec, ad183x_dac_controls, num_dacs * 2);
@@ -313,8 +313,9 @@ static int ad1836_probe(struct snd_soc_codec *codec)
 /* power down chip */
 static int ad1836_remove(struct snd_soc_codec *codec)
 {
+        struct ad1836_priv *ad1836 = snd_soc_codec_get_drvdata(codec);
         /* reset clock control mode */
-        return snd_soc_update_bits(codec, AD1836_ADC_CTRL2,
+        return regmap_update_bits(ad1836->regmap, AD1836_ADC_CTRL2,
                 AD1836_ADC_SERFMT_MASK, 0);
 }
 
@@ -323,8 +324,6 @@ static struct snd_soc_codec_driver soc_codec_dev_ad1836 = {
         .remove = ad1836_remove,
         .suspend = ad1836_suspend,
         .resume = ad1836_resume,
-        .reg_cache_size = AD1836_NUM_REGS,
-        .reg_word_size = sizeof(u16),
 
         .controls = ad183x_controls,
         .num_controls = ARRAY_SIZE(ad183x_controls),
@@ -334,6 +333,33 @@ static struct snd_soc_codec_driver soc_codec_dev_ad1836 = {
         .num_dapm_routes = ARRAY_SIZE(ad183x_dapm_routes),
 };
 
+static const struct reg_default ad1836_reg_defaults[] = {
+        { AD1836_DAC_CTRL1, 0x0000 },
+        { AD1836_DAC_CTRL2, 0x0000 },
+        { AD1836_DAC_L_VOL(0), 0x0000 },
+        { AD1836_DAC_R_VOL(0), 0x0000 },
+        { AD1836_DAC_L_VOL(1), 0x0000 },
+        { AD1836_DAC_R_VOL(1), 0x0000 },
+        { AD1836_DAC_L_VOL(2), 0x0000 },
+        { AD1836_DAC_R_VOL(2), 0x0000 },
+        { AD1836_DAC_L_VOL(3), 0x0000 },
+        { AD1836_DAC_R_VOL(3), 0x0000 },
+        { AD1836_ADC_CTRL1, 0x0000 },
+        { AD1836_ADC_CTRL2, 0x0000 },
+        { AD1836_ADC_CTRL3, 0x0000 },
+};
+
+static const struct regmap_config ad1836_regmap_config = {
+        .val_bits = 12,
+        .reg_bits = 4,
+        .read_flag_mask = 0x08,
+
+        .max_register = AD1836_ADC_CTRL3,
+        .reg_defaults = ad1836_reg_defaults,
+        .num_reg_defaults = ARRAY_SIZE(ad1836_reg_defaults),
+        .cache_type = REGCACHE_RBTREE,
+};
+
 static int __devinit ad1836_spi_probe(struct spi_device *spi)
 {
         struct ad1836_priv *ad1836;
@@ -344,6 +370,10 @@ static int __devinit ad1836_spi_probe(struct spi_device *spi)
         if (ad1836 == NULL)
                 return -ENOMEM;
 
+        ad1836->regmap = devm_regmap_init_spi(spi, &ad1836_regmap_config);
+        if (IS_ERR(ad1836->regmap))
+                return PTR_ERR(ad1836->regmap);
+
         ad1836->type = spi_get_device_id(spi)->driver_data;
 
         spi_set_drvdata(spi, ad1836);
@@ -379,17 +409,7 @@ static struct spi_driver ad1836_spi_driver = {
         .id_table       = ad1836_ids,
 };
 
-static int __init ad1836_init(void)
-{
-        return spi_register_driver(&ad1836_spi_driver);
-}
-module_init(ad1836_init);
-
-static void __exit ad1836_exit(void)
-{
-        spi_unregister_driver(&ad1836_spi_driver);
-}
-module_exit(ad1836_exit);
+module_spi_driver(ad1836_spi_driver);
 
 MODULE_DESCRIPTION("ASoC ad1836 driver");
 MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
diff --git a/sound/soc/codecs/ad193x.c b/sound/soc/codecs/ad193x.c
index 13e62be4f990..2f752660f678 100644
--- a/sound/soc/codecs/ad193x.c
+++ b/sound/soc/codecs/ad193x.c
@@ -381,40 +381,25 @@ static const struct regmap_config ad193x_spi_regmap_config = {
 static int __devinit ad193x_spi_probe(struct spi_device *spi)
 {
         struct ad193x_priv *ad193x;
-        int ret;
 
         ad193x = devm_kzalloc(&spi->dev, sizeof(struct ad193x_priv),
                               GFP_KERNEL);
         if (ad193x == NULL)
                 return -ENOMEM;
 
-        ad193x->regmap = regmap_init_spi(spi, &ad193x_spi_regmap_config);
-        if (IS_ERR(ad193x->regmap)) {
-                ret = PTR_ERR(ad193x->regmap);
-                goto err_out;
-        }
+        ad193x->regmap = devm_regmap_init_spi(spi, &ad193x_spi_regmap_config);
+        if (IS_ERR(ad193x->regmap))
+                return PTR_ERR(ad193x->regmap);
 
         spi_set_drvdata(spi, ad193x);
 
-        ret = snd_soc_register_codec(&spi->dev,
-                        &soc_codec_dev_ad193x, &ad193x_dai, 1);
-        if (ret < 0)
-                goto err_regmap_exit;
-
-        return 0;
-
-err_regmap_exit:
-        regmap_exit(ad193x->regmap);
-err_out:
-        return ret;
+        return snd_soc_register_codec(&spi->dev, &soc_codec_dev_ad193x,
+                        &ad193x_dai, 1);
 }
 
 static int __devexit ad193x_spi_remove(struct spi_device *spi)
 {
-        struct ad193x_priv *ad193x = spi_get_drvdata(spi);
-
         snd_soc_unregister_codec(&spi->dev);
-        regmap_exit(ad193x->regmap);
         return 0;
 }
 
@@ -449,40 +434,25 @@ static int __devinit ad193x_i2c_probe(struct i2c_client *client,
                 const struct i2c_device_id *id)
 {
         struct ad193x_priv *ad193x;
-        int ret;
 
         ad193x = devm_kzalloc(&client->dev, sizeof(struct ad193x_priv),
                               GFP_KERNEL);
         if (ad193x == NULL)
                 return -ENOMEM;
 
-        ad193x->regmap = regmap_init_i2c(client, &ad193x_i2c_regmap_config);
-        if (IS_ERR(ad193x->regmap)) {
-                ret = PTR_ERR(ad193x->regmap);
-                goto err_out;
-        }
+        ad193x->regmap = devm_regmap_init_i2c(client, &ad193x_i2c_regmap_config);
+        if (IS_ERR(ad193x->regmap))
+                return PTR_ERR(ad193x->regmap);
 
         i2c_set_clientdata(client, ad193x);
 
-        ret =  snd_soc_register_codec(&client->dev,
-                        &soc_codec_dev_ad193x, &ad193x_dai, 1);
-        if (ret < 0)
-                goto err_regmap_exit;
-
-        return 0;
-
-err_regmap_exit:
-        regmap_exit(ad193x->regmap);
-err_out:
-        return ret;
+        return snd_soc_register_codec(&client->dev, &soc_codec_dev_ad193x,
+                        &ad193x_dai, 1);
 }
 
 static int __devexit ad193x_i2c_remove(struct i2c_client *client)
 {
-        struct ad193x_priv *ad193x = i2c_get_clientdata(client);
-
         snd_soc_unregister_codec(&client->dev);
-        regmap_exit(ad193x->regmap);
         return 0;
 }
 
diff --git a/sound/soc/codecs/ad1980.c b/sound/soc/codecs/ad1980.c
index 11b1b714b8b5..8c39dddd7d00 100644
--- a/sound/soc/codecs/ad1980.c
+++ b/sound/soc/codecs/ad1980.c
@@ -186,7 +186,6 @@ static int ad1980_soc_probe(struct snd_soc_codec *codec)
 
         printk(KERN_INFO "AD1980 SoC Audio Codec\n");
 
-        codec->control_data = codec;    /* we don't use regmap! */
         ret = snd_soc_new_ac97_codec(codec, &soc_ac97_ops, 0);
         if (ret < 0) {
                 printk(KERN_ERR "ad1980: failed to register AC97 codec\n");
diff --git a/sound/soc/codecs/adau1373.c b/sound/soc/codecs/adau1373.c
index 44f59064d8de..704544bfc90d 100644
--- a/sound/soc/codecs/adau1373.c
+++ b/sound/soc/codecs/adau1373.c
@@ -1392,17 +1392,7 @@ static struct i2c_driver adau1373_i2c_driver = {
         .id_table = adau1373_i2c_id,
 };
 
-static int __init adau1373_init(void)
-{
-        return i2c_add_driver(&adau1373_i2c_driver);
-}
-module_init(adau1373_init);
-
-static void __exit adau1373_exit(void)
-{
-        i2c_del_driver(&adau1373_i2c_driver);
-}
-module_exit(adau1373_exit);
+module_i2c_driver(adau1373_i2c_driver);
 
 MODULE_DESCRIPTION("ASoC ADAU1373 driver");
 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
diff --git a/sound/soc/codecs/adau1701.c b/sound/soc/codecs/adau1701.c
index 3d50fc8646b6..51f2f3cd8136 100644
--- a/sound/soc/codecs/adau1701.c
+++ b/sound/soc/codecs/adau1701.c
@@ -527,17 +527,7 @@ static struct i2c_driver adau1701_i2c_driver = {
         .id_table       = adau1701_i2c_id,
 };
 
-static int __init adau1701_init(void)
-{
-        return i2c_add_driver(&adau1701_i2c_driver);
-}
-module_init(adau1701_init);
-
-static void __exit adau1701_exit(void)
-{
-        i2c_del_driver(&adau1701_i2c_driver);
-}
-module_exit(adau1701_exit);
+module_i2c_driver(adau1701_i2c_driver);
 
 MODULE_DESCRIPTION("ASoC ADAU1701 SigmaDSP driver");
 MODULE_AUTHOR("Cliff Cai <cliff.cai@analog.com>");
diff --git a/sound/soc/codecs/ak4671.c b/sound/soc/codecs/ak4671.c
index 5fb7c2a80e6d..2b457976a7bf 100644
--- a/sound/soc/codecs/ak4671.c
+++ b/sound/soc/codecs/ak4671.c
@@ -696,17 +696,7 @@ static struct i2c_driver ak4671_i2c_driver = {
         .id_table = ak4671_i2c_id,
 };
 
-static int __init ak4671_modinit(void)
-{
-        return i2c_add_driver(&ak4671_i2c_driver);
-}
-module_init(ak4671_modinit);
-
-static void __exit ak4671_exit(void)
-{
-        i2c_del_driver(&ak4671_i2c_driver);
-}
-module_exit(ak4671_exit);
+module_i2c_driver(ak4671_i2c_driver);
 
 MODULE_DESCRIPTION("ASoC AK4671 codec driver");
 MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
diff --git a/sound/soc/codecs/arizona.c b/sound/soc/codecs/arizona.c
index 5c9cacaf2d52..c167c896eaee 100644
--- a/sound/soc/codecs/arizona.c
+++ b/sound/soc/codecs/arizona.c
@@ -229,6 +229,69 @@ int arizona_out_ev(struct snd_soc_dapm_widget *w,
 }
 EXPORT_SYMBOL_GPL(arizona_out_ev);
 
+static unsigned int arizona_sysclk_48k_rates[] = {
+        6144000,
+        12288000,
+        22579200,
+        49152000,
+};
+
+static unsigned int arizona_sysclk_44k1_rates[] = {
+        5644800,
+        11289600,
+        24576000,
+        45158400,
+};
+
+static int arizona_set_opclk(struct snd_soc_codec *codec, unsigned int clk,
+                             unsigned int freq)
+{
+        struct arizona_priv *priv = snd_soc_codec_get_drvdata(codec);
+        unsigned int reg;
+        unsigned int *rates;
+        int ref, div, refclk;
+
+        switch (clk) {
+        case ARIZONA_CLK_OPCLK:
+                reg = ARIZONA_OUTPUT_SYSTEM_CLOCK;
+                refclk = priv->sysclk;
+                break;
+        case ARIZONA_CLK_ASYNC_OPCLK:
+                reg = ARIZONA_OUTPUT_ASYNC_CLOCK;
+                refclk = priv->asyncclk;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        if (refclk % 8000)
+                rates = arizona_sysclk_44k1_rates;
+        else
+                rates = arizona_sysclk_48k_rates;
+
+        for (ref = 0; ref < ARRAY_SIZE(arizona_sysclk_48k_rates) &&
+                     rates[ref] <= refclk; ref++) {
+                div = 1;
+                while (rates[ref] / div >= freq && div < 32) {
+                        if (rates[ref] / div == freq) {
+                                dev_dbg(codec->dev, "Configured %dHz OPCLK\n",
+                                        freq);
+                                snd_soc_update_bits(codec, reg,
+                                                    ARIZONA_OPCLK_DIV_MASK |
+                                                    ARIZONA_OPCLK_SEL_MASK,
+                                                    (div <<
+                                                     ARIZONA_OPCLK_DIV_SHIFT) |
+                                                    ref);
+                                return 0;
+                        }
+                        div++;
+                }
+        }
+
+        dev_err(codec->dev, "Unable to generate %dHz OPCLK\n", freq);
+        return -EINVAL;
+}
+
 int arizona_set_sysclk(struct snd_soc_codec *codec, int clk_id,
                        int source, unsigned int freq, int dir)
 {
@@ -252,6 +315,9 @@ int arizona_set_sysclk(struct snd_soc_codec *codec, int clk_id,
                 reg = ARIZONA_ASYNC_CLOCK_1;
                 clk = &priv->asyncclk;
                 break;
+        case ARIZONA_CLK_OPCLK:
+        case ARIZONA_CLK_ASYNC_OPCLK:
+                return arizona_set_opclk(codec, clk_id, freq);
         default:
                 return -EINVAL;
         }
@@ -426,7 +492,7 @@ static const int arizona_44k1_bclk_rates[] = {
         940800,
         1411200,
         1881600,
-        2882400,
+        2822400,
         3763200,
         5644800,
         7526400,
@@ -666,7 +732,7 @@ static irqreturn_t arizona_fll_lock(int irq, void *data)
 {
         struct arizona_fll *fll = data;
 
-        arizona_fll_dbg(fll, "Locked\n");
+        arizona_fll_dbg(fll, "Lock status changed\n");
 
         complete(&fll->lock);
 
diff --git a/sound/soc/codecs/arizona.h b/sound/soc/codecs/arizona.h
index 59caca8865e8..eb66b52777c9 100644
--- a/sound/soc/codecs/arizona.h
+++ b/sound/soc/codecs/arizona.h
@@ -17,8 +17,10 @@
 
 #include <sound/soc.h>
 
-#define ARIZONA_CLK_SYSCLK   1
-#define ARIZONA_CLK_ASYNCCLK 2
+#define ARIZONA_CLK_SYSCLK         1
+#define ARIZONA_CLK_ASYNCCLK       2
+#define ARIZONA_CLK_OPCLK          3
+#define ARIZONA_CLK_ASYNC_OPCLK    4
 
 #define ARIZONA_CLK_SRC_MCLK1    0x0
 #define ARIZONA_CLK_SRC_MCLK2    0x1
diff --git a/sound/soc/codecs/cs4270.c b/sound/soc/codecs/cs4270.c
index 047917f0b8ae..815b53bc2d27 100644
--- a/sound/soc/codecs/cs4270.c
+++ b/sound/soc/codecs/cs4270.c
@@ -29,6 +29,8 @@
 #include <linux/i2c.h>
 #include <linux/delay.h>
 #include <linux/regulator/consumer.h>
+#include <linux/of_device.h>
+#include <linux/of_gpio.h>
 
 /*
  * The codec isn't really big-endian or little-endian, since the I2S
@@ -110,14 +112,15 @@
  * This array contains the power-on default values of the registers, with the
  * exception of the "CHIPID" register (01h).  The lower four bits of that
  * register contain the hardware revision, so it is treated as volatile.
- *
- * Also note that on the CS4270, the first readable register is 1, but ASoC
- * assumes the first register is 0.  Therfore, the array must have an entry for
- * register 0, but we use cs4270_reg_is_readable() to tell ASoC that it can't
- * be read.
  */
-static const u8 cs4270_default_reg_cache[CS4270_LASTREG + 1] = {
-        0x00, 0x00, 0x00, 0x30, 0x00, 0x60, 0x20, 0x00, 0x00
+static const struct reg_default cs4270_reg_defaults[] = {
+        { 2, 0x00 },
+        { 3, 0x30 },
+        { 4, 0x00 },
+        { 5, 0x60 },
+        { 6, 0x20 },
+        { 7, 0x00 },
+        { 8, 0x00 },
 };
 
 static const char *supply_names[] = {
@@ -126,7 +129,7 @@ static const char *supply_names[] = {
 
 /* Private data for the CS4270 */
 struct cs4270_private {
-        enum snd_soc_control_type control_type;
+        struct regmap *regmap;
         unsigned int mclk; /* Input frequency of the MCLK pin */
         unsigned int mode; /* The mode (I2S or left-justified) */
         unsigned int slave_mode;
@@ -191,12 +194,12 @@ static struct cs4270_mode_ratios cs4270_mode_ratios[] = {
 /* The number of MCLK/LRCK ratios supported by the CS4270 */
 #define NUM_MCLK_RATIOS         ARRAY_SIZE(cs4270_mode_ratios)
 
-static int cs4270_reg_is_readable(struct snd_soc_codec *codec, unsigned int reg)
+static bool cs4270_reg_is_readable(struct device *dev, unsigned int reg)
 {
         return (reg >= CS4270_FIRSTREG) && (reg <= CS4270_LASTREG);
 }
 
-static int cs4270_reg_is_volatile(struct snd_soc_codec *codec, unsigned int reg)
+static bool cs4270_reg_is_volatile(struct device *dev, unsigned int reg)
 {
         /* Unreadable registers are considered volatile */
         if ((reg < CS4270_FIRSTREG) || (reg > CS4270_LASTREG))
@@ -485,12 +488,12 @@ static struct snd_soc_dai_driver cs4270_dai = {
 static int cs4270_probe(struct snd_soc_codec *codec)
 {
         struct cs4270_private *cs4270 = snd_soc_codec_get_drvdata(codec);
-        int i, ret;
+        int ret;
 
         /* Tell ASoC what kind of I/O to use to read the registers.  ASoC will
          * then do the I2C transactions itself.
          */
-        ret = snd_soc_codec_set_cache_io(codec, 8, 8, cs4270->control_type);
+        ret = snd_soc_codec_set_cache_io(codec, 8, 8, SND_SOC_REGMAP);
         if (ret < 0) {
                 dev_err(codec->dev, "failed to set cache I/O (ret=%i)\n", ret);
                 return ret;
@@ -519,33 +522,8 @@ static int cs4270_probe(struct snd_soc_codec *codec)
                 return ret;
         }
 
-        /* Add the non-DAPM controls */
-        ret = snd_soc_add_codec_controls(codec, cs4270_snd_controls,
-                                ARRAY_SIZE(cs4270_snd_controls));
-        if (ret < 0) {
-                dev_err(codec->dev, "failed to add controls\n");
-                return ret;
-        }
-
-        /* get the power supply regulators */
-        for (i = 0; i < ARRAY_SIZE(supply_names); i++)
-                cs4270->supplies[i].supply = supply_names[i];
-
-        ret = regulator_bulk_get(codec->dev, ARRAY_SIZE(cs4270->supplies),
-                                 cs4270->supplies);
-        if (ret < 0)
-                return ret;
-
         ret = regulator_bulk_enable(ARRAY_SIZE(cs4270->supplies),
                                     cs4270->supplies);
-        if (ret < 0)
-                goto error_free_regulators;
-
-        return 0;
-
-error_free_regulators:
-        regulator_bulk_free(ARRAY_SIZE(cs4270->supplies),
-                            cs4270->supplies);
 
         return ret;
 }
@@ -561,7 +539,6 @@ static int cs4270_remove(struct snd_soc_codec *codec)
         struct cs4270_private *cs4270 = snd_soc_codec_get_drvdata(codec);
 
         regulator_bulk_disable(ARRAY_SIZE(cs4270->supplies), cs4270->supplies);
-        regulator_bulk_free(ARRAY_SIZE(cs4270->supplies), cs4270->supplies);
 
         return 0;
 };
@@ -611,7 +588,7 @@ static int cs4270_soc_resume(struct snd_soc_codec *codec)
         ndelay(500);
 
         /* first restore the entire register cache ... */
-        snd_soc_cache_sync(codec);
+        regcache_sync(cs4270->regmap);
 
         /* ... then disable the power-down bits */
         reg = snd_soc_read(codec, CS4270_PWRCTL);
@@ -632,11 +609,30 @@ static const struct snd_soc_codec_driver soc_codec_device_cs4270 = {
         .remove =               cs4270_remove,
         .suspend =              cs4270_soc_suspend,
         .resume =               cs4270_soc_resume,
-        .volatile_register =    cs4270_reg_is_volatile,
-        .readable_register =    cs4270_reg_is_readable,
-        .reg_cache_size =       CS4270_LASTREG + 1,
-        .reg_word_size =        sizeof(u8),
-        .reg_cache_default =    cs4270_default_reg_cache,
+
+        .controls =             cs4270_snd_controls,
+        .num_controls =         ARRAY_SIZE(cs4270_snd_controls),
+};
+
+/*
+ * cs4270_of_match - the device tree bindings
+ */
+static const struct of_device_id cs4270_of_match[] = {
+        { .compatible = "cirrus,cs4270", },
+        { }
+};
+MODULE_DEVICE_TABLE(of, cs4270_of_match);
+
+static const struct regmap_config cs4270_regmap = {
+        .reg_bits =             8,
+        .val_bits =             8,
+        .max_register =         CS4270_LASTREG,
+        .reg_defaults =         cs4270_reg_defaults,
+        .num_reg_defaults =     ARRAY_SIZE(cs4270_reg_defaults),
+        .cache_type =           REGCACHE_RBTREE,
+
+        .readable_reg =         cs4270_reg_is_readable,
+        .volatile_reg =         cs4270_reg_is_volatile,
 };
 
 /**
@@ -650,19 +646,56 @@ static const struct snd_soc_codec_driver soc_codec_device_cs4270 = {
 static int cs4270_i2c_probe(struct i2c_client *i2c_client,
         const struct i2c_device_id *id)
 {
+        struct device_node *np = i2c_client->dev.of_node;
         struct cs4270_private *cs4270;
-        int ret;
+        unsigned int val;
+        int ret, i;
 
-        /* Verify that we have a CS4270 */
+        cs4270 = devm_kzalloc(&i2c_client->dev, sizeof(struct cs4270_private),
+                              GFP_KERNEL);
+        if (!cs4270) {
+                dev_err(&i2c_client->dev, "could not allocate codec\n");
+                return -ENOMEM;
+        }
+
+        /* get the power supply regulators */
+        for (i = 0; i < ARRAY_SIZE(supply_names); i++)
+                cs4270->supplies[i].supply = supply_names[i];
+
+        ret = devm_regulator_bulk_get(&i2c_client->dev,
+                                      ARRAY_SIZE(cs4270->supplies),
+                                      cs4270->supplies);
+        if (ret < 0)
+                return ret;
+
+        /* See if we have a way to bring the codec out of reset */
+        if (np) {
+                enum of_gpio_flags flags;
+                int gpio = of_get_named_gpio_flags(np, "reset-gpio", 0, &flags);
+
+                if (gpio_is_valid(gpio)) {
+                        ret = devm_gpio_request_one(&i2c_client->dev, gpio,
+                                     flags & OF_GPIO_ACTIVE_LOW ?
+                                        GPIOF_OUT_INIT_LOW : GPIOF_OUT_INIT_HIGH,
+                                     "cs4270 reset");
+                        if (ret < 0)
+                                return ret;
+                }
+        }
+
+        cs4270->regmap = devm_regmap_init_i2c(i2c_client, &cs4270_regmap);
+        if (IS_ERR(cs4270->regmap))
+                return PTR_ERR(cs4270->regmap);
 
-        ret = i2c_smbus_read_byte_data(i2c_client, CS4270_CHIPID);
+        /* Verify that we have a CS4270 */
+        ret = regmap_read(cs4270->regmap, CS4270_CHIPID, &val);
         if (ret < 0) {
                 dev_err(&i2c_client->dev, "failed to read i2c at addr %X\n",
                        i2c_client->addr);
                 return ret;
         }
         /* The top four bits of the chip ID should be 1100. */
-        if ((ret & 0xF0) != 0xC0) {
+        if ((val & 0xF0) != 0xC0) {
                 dev_err(&i2c_client->dev, "device at addr %X is not a CS4270\n",
                        i2c_client->addr);
                 return -ENODEV;
@@ -670,17 +703,9 @@ static int cs4270_i2c_probe(struct i2c_client *i2c_client,
 
         dev_info(&i2c_client->dev, "found device at i2c address %X\n",
                 i2c_client->addr);
-        dev_info(&i2c_client->dev, "hardware revision %X\n", ret & 0xF);
-
-        cs4270 = devm_kzalloc(&i2c_client->dev, sizeof(struct cs4270_private),
-                              GFP_KERNEL);
-        if (!cs4270) {
-                dev_err(&i2c_client->dev, "could not allocate codec\n");
-                return -ENOMEM;
-        }
+        dev_info(&i2c_client->dev, "hardware revision %X\n", val & 0xF);
 
         i2c_set_clientdata(i2c_client, cs4270);
-        cs4270->control_type = SND_SOC_I2C;
 
         ret = snd_soc_register_codec(&i2c_client->dev,
                         &soc_codec_device_cs4270, &cs4270_dai, 1);
@@ -718,23 +743,14 @@ static struct i2c_driver cs4270_i2c_driver = {
         .driver = {
                 .name = "cs4270",
                 .owner = THIS_MODULE,
+                .of_match_table = cs4270_of_match,
         },
         .id_table = cs4270_id,
         .probe = cs4270_i2c_probe,
         .remove = cs4270_i2c_remove,
 };
 
-static int __init cs4270_init(void)
-{
-        return i2c_add_driver(&cs4270_i2c_driver);
-}
-module_init(cs4270_init);
-
-static void __exit cs4270_exit(void)
-{
-        i2c_del_driver(&cs4270_i2c_driver);
-}
-module_exit(cs4270_exit);
+module_i2c_driver(cs4270_i2c_driver);
 
 MODULE_AUTHOR("Timur Tabi <timur@freescale.com>");
 MODULE_DESCRIPTION("Cirrus Logic CS4270 ALSA SoC Codec Driver");
diff --git a/sound/soc/codecs/cs42l51.c b/sound/soc/codecs/cs42l51.c
index 091d0193f507..1e0fa3b5f79a 100644
--- a/sound/soc/codecs/cs42l51.c
+++ b/sound/soc/codecs/cs42l51.c
@@ -614,24 +614,7 @@ static struct i2c_driver cs42l51_i2c_driver = {
         .remove = cs42l51_i2c_remove,
 };
 
-static int __init cs42l51_init(void)
-{
-        int ret;
-
-        ret = i2c_add_driver(&cs42l51_i2c_driver);
-        if (ret != 0) {
-                printk(KERN_ERR "%s: can't add i2c driver\n", __func__);
-                return ret;
-        }
-        return 0;
-}
-module_init(cs42l51_init);
-
-static void __exit cs42l51_exit(void)
-{
-        i2c_del_driver(&cs42l51_i2c_driver);
-}
-module_exit(cs42l51_exit);
+module_i2c_driver(cs42l51_i2c_driver);
 
 MODULE_AUTHOR("Arnaud Patard <arnaud.patard@rtp-net.org>");
 MODULE_DESCRIPTION("Cirrus Logic CS42L51 ALSA SoC Codec Driver");
diff --git a/sound/soc/codecs/cs42l52.c b/sound/soc/codecs/cs42l52.c
index 628daf6a1d97..61599298fb26 100644
--- a/sound/soc/codecs/cs42l52.c
+++ b/sound/soc/codecs/cs42l52.c
@@ -24,7 +24,6 @@
 #include <linux/slab.h>
 #include <linux/workqueue.h>
 #include <linux/platform_device.h>
-#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
diff --git a/sound/soc/codecs/isabelle.c b/sound/soc/codecs/isabelle.c
index 5d8f39e32978..1bf55602c9eb 100644
--- a/sound/soc/codecs/isabelle.c
+++ b/sound/soc/codecs/isabelle.c
@@ -13,7 +13,6 @@
  */
 #include <linux/module.h>
 #include <linux/moduleparam.h>
-#include <linux/version.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/delay.h>
diff --git a/sound/soc/codecs/lm4857.c b/sound/soc/codecs/lm4857.c
index ba4fafb93e56..81a328c78838 100644
--- a/sound/soc/codecs/lm4857.c
+++ b/sound/soc/codecs/lm4857.c
@@ -250,17 +250,7 @@ static struct i2c_driver lm4857_i2c_driver = {
         .id_table = lm4857_i2c_id,
 };
 
-static int __init lm4857_init(void)
-{
-        return i2c_add_driver(&lm4857_i2c_driver);
-}
-module_init(lm4857_init);
-
-static void __exit lm4857_exit(void)
-{
-        i2c_del_driver(&lm4857_i2c_driver);
-}
-module_exit(lm4857_exit);
+module_i2c_driver(lm4857_i2c_driver);
 
 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
 MODULE_DESCRIPTION("LM4857 amplifier driver");
diff --git a/sound/soc/codecs/max98088.c b/sound/soc/codecs/max98088.c
index af7324b79dd0..3264a5169306 100644
--- a/sound/soc/codecs/max98088.c
+++ b/sound/soc/codecs/max98088.c
@@ -2107,23 +2107,7 @@ static struct i2c_driver max98088_i2c_driver = {
        .id_table = max98088_i2c_id,
 };
 
-static int __init max98088_init(void)
-{
-       int ret;
-
-       ret = i2c_add_driver(&max98088_i2c_driver);
-       if (ret)
-               pr_err("Failed to register max98088 I2C driver: %d\n", ret);
-
-       return ret;
-}
-module_init(max98088_init);
-
-static void __exit max98088_exit(void)
-{
-       i2c_del_driver(&max98088_i2c_driver);
-}
-module_exit(max98088_exit);
+module_i2c_driver(max98088_i2c_driver);
 
 MODULE_DESCRIPTION("ALSA SoC MAX98088 driver");
 MODULE_AUTHOR("Peter Hsiang, Jesse Marroquin");
diff --git a/sound/soc/codecs/max98095.c b/sound/soc/codecs/max98095.c
index 7cd508e16a5c..38d43c59d3f4 100644
--- a/sound/soc/codecs/max98095.c
+++ b/sound/soc/codecs/max98095.c
@@ -2533,23 +2533,7 @@ static struct i2c_driver max98095_i2c_driver = {
         .id_table = max98095_i2c_id,
 };
 
-static int __init max98095_init(void)
-{
-        int ret;
-
-        ret = i2c_add_driver(&max98095_i2c_driver);
-        if (ret)
-                pr_err("Failed to register max98095 I2C driver: %d\n", ret);
-
-        return ret;
-}
-module_init(max98095_init);
-
-static void __exit max98095_exit(void)
-{
-        i2c_del_driver(&max98095_i2c_driver);
-}
-module_exit(max98095_exit);
+module_i2c_driver(max98095_i2c_driver);
 
 MODULE_DESCRIPTION("ALSA SoC MAX98095 driver");
 MODULE_AUTHOR("Peter Hsiang");
diff --git a/sound/soc/codecs/max9850.c b/sound/soc/codecs/max9850.c
index a1913091f56c..efe535c37b39 100644
--- a/sound/soc/codecs/max9850.c
+++ b/sound/soc/codecs/max9850.c
@@ -369,17 +369,7 @@ static struct i2c_driver max9850_i2c_driver = {
         .id_table = max9850_i2c_id,
 };
 
-static int __init max9850_init(void)
-{
-        return i2c_add_driver(&max9850_i2c_driver);
-}
-module_init(max9850_init);
-
-static void __exit max9850_exit(void)
-{
-        i2c_del_driver(&max9850_i2c_driver);
-}
-module_exit(max9850_exit);
+module_i2c_driver(max9850_i2c_driver);
 
 MODULE_AUTHOR("Christian Glindkamp <christian.glindkamp@taskit.de>");
 MODULE_DESCRIPTION("ASoC MAX9850 codec driver");
diff --git a/sound/soc/codecs/max9877.c b/sound/soc/codecs/max9877.c
index 3a2ba3d8fd6d..d15e5943c85e 100644
--- a/sound/soc/codecs/max9877.c
+++ b/sound/soc/codecs/max9877.c
@@ -291,17 +291,7 @@ static struct i2c_driver max9877_i2c_driver = {
         .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_i2c_driver(max9877_i2c_driver);
 
 MODULE_DESCRIPTION("ASoC MAX9877 amp driver");
 MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
diff --git a/sound/soc/codecs/mc13783.c b/sound/soc/codecs/mc13783.c
index 8f726c063f42..bc955999c8aa 100644
--- a/sound/soc/codecs/mc13783.c
+++ b/sound/soc/codecs/mc13783.c
@@ -426,16 +426,16 @@ static int mc13783_set_tdm_slot_sync(struct snd_soc_dai *dai,
 }
 
 static const struct snd_kcontrol_new mc1l_amp_ctl =
-        SOC_DAPM_SINGLE("Switch", 38, 7, 1, 0);
+        SOC_DAPM_SINGLE("Switch", MC13783_AUDIO_TX, 7, 1, 0);
 
 static const struct snd_kcontrol_new mc1r_amp_ctl =
-        SOC_DAPM_SINGLE("Switch", 38, 5, 1, 0);
+        SOC_DAPM_SINGLE("Switch", MC13783_AUDIO_TX, 5, 1, 0);
 
 static const struct snd_kcontrol_new mc2_amp_ctl =
-        SOC_DAPM_SINGLE("Switch", 38, 9, 1, 0);
+        SOC_DAPM_SINGLE("Switch", MC13783_AUDIO_TX, 9, 1, 0);
 
 static const struct snd_kcontrol_new atx_amp_ctl =
-        SOC_DAPM_SINGLE("Switch", 38, 11, 1, 0);
+        SOC_DAPM_SINGLE("Switch", MC13783_AUDIO_TX, 11, 1, 0);
 
 
 /* Virtual mux. The chip does the input selection automatically
@@ -461,22 +461,22 @@ static const struct snd_kcontrol_new right_input_mux =
         SOC_DAPM_ENUM_VIRT("Route", adcr_enum);
 
 static const struct snd_kcontrol_new samp_ctl =
-        SOC_DAPM_SINGLE("Switch", 36, 3, 1, 0);
+        SOC_DAPM_SINGLE("Switch", MC13783_AUDIO_RX0, 3, 1, 0);
 
 static const struct snd_kcontrol_new lamp_ctl =
-        SOC_DAPM_SINGLE("Switch", 36, 5, 1, 0);
+        SOC_DAPM_SINGLE("Switch", MC13783_AUDIO_RX0, 5, 1, 0);
 
 static const struct snd_kcontrol_new hlamp_ctl =
-        SOC_DAPM_SINGLE("Switch", 36, 10, 1, 0);
+        SOC_DAPM_SINGLE("Switch", MC13783_AUDIO_RX0, 10, 1, 0);
 
 static const struct snd_kcontrol_new hramp_ctl =
-        SOC_DAPM_SINGLE("Switch", 36, 9, 1, 0);
+        SOC_DAPM_SINGLE("Switch", MC13783_AUDIO_RX0, 9, 1, 0);
 
 static const struct snd_kcontrol_new llamp_ctl =
-        SOC_DAPM_SINGLE("Switch", 36, 16, 1, 0);
+        SOC_DAPM_SINGLE("Switch", MC13783_AUDIO_RX0, 16, 1, 0);
 
 static const struct snd_kcontrol_new lramp_ctl =
-        SOC_DAPM_SINGLE("Switch", 36, 15, 1, 0);
+        SOC_DAPM_SINGLE("Switch", MC13783_AUDIO_RX0, 15, 1, 0);
 
 static const struct snd_soc_dapm_widget mc13783_dapm_widgets[] = {
 /* Input */
@@ -487,13 +487,13 @@ static const struct snd_soc_dapm_widget mc13783_dapm_widgets[] = {
         SND_SOC_DAPM_INPUT("RXINL"),
         SND_SOC_DAPM_INPUT("TXIN"),
 
-        SND_SOC_DAPM_SUPPLY("MC1 Bias", 38, 0, 0, NULL, 0),
-        SND_SOC_DAPM_SUPPLY("MC2 Bias", 38, 1, 0, NULL, 0),
+        SND_SOC_DAPM_SUPPLY("MC1 Bias", MC13783_AUDIO_TX, 0, 0, NULL, 0),
+        SND_SOC_DAPM_SUPPLY("MC2 Bias", MC13783_AUDIO_TX, 1, 0, NULL, 0),
 
-        SND_SOC_DAPM_SWITCH("MC1L Amp", 38, 7, 0, &mc1l_amp_ctl),
-        SND_SOC_DAPM_SWITCH("MC1R Amp", 38, 5, 0, &mc1r_amp_ctl),
-        SND_SOC_DAPM_SWITCH("MC2 Amp", 38, 9, 0, &mc2_amp_ctl),
-        SND_SOC_DAPM_SWITCH("TXIN Amp", 38, 11, 0, &atx_amp_ctl),
+        SND_SOC_DAPM_SWITCH("MC1L Amp", MC13783_AUDIO_TX, 7, 0, &mc1l_amp_ctl),
+        SND_SOC_DAPM_SWITCH("MC1R Amp", MC13783_AUDIO_TX, 5, 0, &mc1r_amp_ctl),
+        SND_SOC_DAPM_SWITCH("MC2 Amp", MC13783_AUDIO_TX, 9, 0, &mc2_amp_ctl),
+        SND_SOC_DAPM_SWITCH("TXIN Amp", MC13783_AUDIO_TX, 11, 0, &atx_amp_ctl),
 
         SND_SOC_DAPM_VIRT_MUX("PGA Left Input Mux", SND_SOC_NOPM, 0, 0,
                               &left_input_mux),
@@ -503,12 +503,12 @@ static const struct snd_soc_dapm_widget mc13783_dapm_widgets[] = {
         SND_SOC_DAPM_PGA("PGA Left Input", SND_SOC_NOPM, 0, 0, NULL, 0),
         SND_SOC_DAPM_PGA("PGA Right Input", SND_SOC_NOPM, 0, 0, NULL, 0),
 
-        SND_SOC_DAPM_ADC("ADC", "Capture", 40, 11, 0),
-        SND_SOC_DAPM_SUPPLY("ADC_Reset", 40, 15, 0, NULL, 0),
+        SND_SOC_DAPM_ADC("ADC", "Capture", MC13783_AUDIO_CODEC, 11, 0),
+        SND_SOC_DAPM_SUPPLY("ADC_Reset", MC13783_AUDIO_CODEC, 15, 0, NULL, 0),
 
 /* Output */
-        SND_SOC_DAPM_SUPPLY("DAC_E", 41, 11, 0, NULL, 0),
-        SND_SOC_DAPM_SUPPLY("DAC_Reset", 41, 15, 0, NULL, 0),
+        SND_SOC_DAPM_SUPPLY("DAC_E", MC13783_AUDIO_DAC, 11, 0, NULL, 0),
+        SND_SOC_DAPM_SUPPLY("DAC_Reset", MC13783_AUDIO_DAC, 15, 0, NULL, 0),
         SND_SOC_DAPM_OUTPUT("RXOUTL"),
         SND_SOC_DAPM_OUTPUT("RXOUTR"),
         SND_SOC_DAPM_OUTPUT("HSL"),
@@ -516,14 +516,18 @@ static const struct snd_soc_dapm_widget mc13783_dapm_widgets[] = {
         SND_SOC_DAPM_OUTPUT("LSP"),
         SND_SOC_DAPM_OUTPUT("SP"),
 
-        SND_SOC_DAPM_SWITCH("Speaker Amp", 36, 3, 0, &samp_ctl),
+        SND_SOC_DAPM_SWITCH("Speaker Amp", MC13783_AUDIO_RX0, 3, 0, &samp_ctl),
         SND_SOC_DAPM_SWITCH("Loudspeaker Amp", SND_SOC_NOPM, 0, 0, &lamp_ctl),
-        SND_SOC_DAPM_SWITCH("Headset Amp Left", 36, 10, 0, &hlamp_ctl),
-        SND_SOC_DAPM_SWITCH("Headset Amp Right", 36, 9, 0, &hramp_ctl),
-        SND_SOC_DAPM_SWITCH("Line out Amp Left", 36, 16, 0, &llamp_ctl),
-        SND_SOC_DAPM_SWITCH("Line out Amp Right", 36, 15, 0, &lramp_ctl),
-        SND_SOC_DAPM_DAC("DAC", "Playback", 36, 22, 0),
-        SND_SOC_DAPM_PGA("DAC PGA", 37, 5, 0, NULL, 0),
+        SND_SOC_DAPM_SWITCH("Headset Amp Left", MC13783_AUDIO_RX0, 10, 0,
+                        &hlamp_ctl),
+        SND_SOC_DAPM_SWITCH("Headset Amp Right", MC13783_AUDIO_RX0, 9, 0,
+                        &hramp_ctl),
+        SND_SOC_DAPM_SWITCH("Line out Amp Left", MC13783_AUDIO_RX0, 16, 0,
+                        &llamp_ctl),
+        SND_SOC_DAPM_SWITCH("Line out Amp Right", MC13783_AUDIO_RX0, 15, 0,
+                        &lramp_ctl),
+        SND_SOC_DAPM_DAC("DAC", "Playback", MC13783_AUDIO_RX0, 22, 0),
+        SND_SOC_DAPM_PGA("DAC PGA", MC13783_AUDIO_RX1, 5, 0, NULL, 0),
 };
 
 static struct snd_soc_dapm_route mc13783_routes[] = {
@@ -581,8 +585,6 @@ static int mc13783_probe(struct snd_soc_codec *codec)
 {
         struct mc13783_priv *priv = snd_soc_codec_get_drvdata(codec);
 
-        codec->control_data = priv->mc13xxx;
-
         mc13xxx_lock(priv->mc13xxx);
 
         /* these are the reset values */
@@ -659,7 +661,7 @@ static struct snd_soc_dai_driver mc13783_dai_async[] = {
                 .id = MC13783_ID_STEREO_DAC,
                 .playback = {
                         .stream_name = "Playback",
-                        .channels_min = 1,
+                        .channels_min = 2,
                         .channels_max = 2,
                         .rates = SNDRV_PCM_RATE_8000_96000,
                         .formats = MC13783_FORMATS,
@@ -670,7 +672,7 @@ static struct snd_soc_dai_driver mc13783_dai_async[] = {
                 .id = MC13783_ID_STEREO_CODEC,
                 .capture = {
                         .stream_name = "Capture",
-                        .channels_min = 1,
+                        .channels_min = 2,
                         .channels_max = 2,
                         .rates = MC13783_RATES_RECORD,
                         .formats = MC13783_FORMATS,
@@ -692,14 +694,14 @@ static struct snd_soc_dai_driver mc13783_dai_sync[] = {
                 .id = MC13783_ID_SYNC,
                 .playback = {
                         .stream_name = "Playback",
-                        .channels_min = 1,
+                        .channels_min = 2,
                         .channels_max = 2,
                         .rates = SNDRV_PCM_RATE_8000_96000,
                         .formats = MC13783_FORMATS,
                 },
                 .capture = {
                         .stream_name = "Capture",
-                        .channels_min = 1,
+                        .channels_min = 2,
                         .channels_max = 2,
                         .rates = MC13783_RATES_RECORD,
                         .formats = MC13783_FORMATS,
diff --git a/sound/soc/codecs/sta32x.c b/sound/soc/codecs/sta32x.c
index 8d717f4b5a87..0935bfe62471 100644
--- a/sound/soc/codecs/sta32x.c
+++ b/sound/soc/codecs/sta32x.c
@@ -24,6 +24,7 @@
 #include <linux/delay.h>
 #include <linux/pm.h>
 #include <linux/i2c.h>
+#include <linux/regmap.h>
 #include <linux/regulator/consumer.h>
 #include <linux/slab.h>
 #include <linux/workqueue.h>
@@ -55,12 +56,50 @@
          SNDRV_PCM_FMTBIT_S32_LE  | SNDRV_PCM_FMTBIT_S32_BE)
 
 /* Power-up register defaults */
-static const u8 sta32x_regs[STA32X_REGISTER_COUNT] = {
-        0x63, 0x80, 0xc2, 0x40, 0xc2, 0x5c, 0x10, 0xff, 0x60, 0x60,
-        0x60, 0x80, 0x00, 0x00, 0x00, 0x40, 0x80, 0x77, 0x6a, 0x69,
-        0x6a, 0x69, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2d,
-        0xc0, 0xf3, 0x33, 0x00, 0x0c,
+static const struct reg_default sta32x_regs[] = {
+        {  0x0, 0x63 },
+        {  0x1, 0x80 },
+        {  0x2, 0xc2 },
+        {  0x3, 0x40 },
+        {  0x4, 0xc2 },
+        {  0x5, 0x5c },
+        {  0x6, 0x10 },
+        {  0x7, 0xff },
+        {  0x8, 0x60 },
+        {  0x9, 0x60 },
+        {  0xa, 0x60 },
+        {  0xb, 0x80 },
+        {  0xc, 0x00 },
+        {  0xd, 0x00 },
+        {  0xe, 0x00 },
+        {  0xf, 0x40 },
+        { 0x10, 0x80 },
+        { 0x11, 0x77 },
+        { 0x12, 0x6a },
+        { 0x13, 0x69 },
+        { 0x14, 0x6a },
+        { 0x15, 0x69 },
+        { 0x16, 0x00 },
+        { 0x17, 0x00 },
+        { 0x18, 0x00 },
+        { 0x19, 0x00 },
+        { 0x1a, 0x00 },
+        { 0x1b, 0x00 },
+        { 0x1c, 0x00 },
+        { 0x1d, 0x00 },
+        { 0x1e, 0x00 },
+        { 0x1f, 0x00 },
+        { 0x20, 0x00 },
+        { 0x21, 0x00 },
+        { 0x22, 0x00 },
+        { 0x23, 0x00 },
+        { 0x24, 0x00 },
+        { 0x25, 0x00 },
+        { 0x26, 0x00 },
+        { 0x27, 0x2d },
+        { 0x28, 0xc0 },
+        { 0x2b, 0x00 },
+        { 0x2c, 0x0c },
 };
 
 /* regulator power supply names */
@@ -72,6 +111,7 @@ static const char *sta32x_supply_names[] = {
 
 /* codec private data */
 struct sta32x_priv {
+        struct regmap *regmap;
         struct regulator_bulk_data supplies[ARRAY_SIZE(sta32x_supply_names)];
         struct snd_soc_codec *codec;
         struct sta32x_platform_data *pdata;
@@ -291,17 +331,15 @@ static int sta32x_sync_coef_shadow(struct snd_soc_codec *codec)
 
 static int sta32x_cache_sync(struct snd_soc_codec *codec)
 {
+        struct sta32x_priv *sta32x = codec->control_data;
         unsigned int mute;
         int rc;
 
-        if (!codec->cache_sync)
-                return 0;
-
         /* mute during register sync */
         mute = snd_soc_read(codec, STA32X_MMUTE);
         snd_soc_write(codec, STA32X_MMUTE, mute | STA32X_MMUTE_MMUTE);
         sta32x_sync_coef_shadow(codec);
-        rc = snd_soc_cache_sync(codec);
+        rc = regcache_sync(sta32x->regmap);
         snd_soc_write(codec, STA32X_MMUTE, mute);
         return rc;
 }
@@ -316,11 +354,11 @@ static void sta32x_watchdog(struct work_struct *work)
 
         /* check if sta32x has reset itself */
         confa_cached = snd_soc_read(codec, STA32X_CONFA);
-        codec->cache_bypass = 1;
+        regcache_cache_bypass(sta32x->regmap, true);
         confa = snd_soc_read(codec, STA32X_CONFA);
-        codec->cache_bypass = 0;
+        regcache_cache_bypass(sta32x->regmap, false);
         if (confa != confa_cached) {
-                codec->cache_sync = 1;
+                regcache_mark_dirty(sta32x->regmap);
                 sta32x_cache_sync(codec);
         }
 
@@ -825,31 +863,21 @@ static int sta32x_probe(struct snd_soc_codec *codec)
         sta32x->codec = codec;
         sta32x->pdata = dev_get_platdata(codec->dev);
 
-        /* regulators */
-        for (i = 0; i < ARRAY_SIZE(sta32x->supplies); i++)
-                sta32x->supplies[i].supply = sta32x_supply_names[i];
-
-        ret = regulator_bulk_get(codec->dev, ARRAY_SIZE(sta32x->supplies),
-                                 sta32x->supplies);
-        if (ret != 0) {
-                dev_err(codec->dev, "Failed to request supplies: %d\n", ret);
-                goto err;
-        }
-
         ret = regulator_bulk_enable(ARRAY_SIZE(sta32x->supplies),
                                     sta32x->supplies);
         if (ret != 0) {
                 dev_err(codec->dev, "Failed to enable supplies: %d\n", ret);
-                goto err_get;
+                return ret;
         }
 
         /* Tell ASoC what kind of I/O to use to read the registers.  ASoC will
          * then do the I2C transactions itself.
          */
-        ret = snd_soc_codec_set_cache_io(codec, 8, 8, SND_SOC_I2C);
+        codec->control_data = sta32x->regmap;
+        ret = snd_soc_codec_set_cache_io(codec, 8, 8, SND_SOC_REGMAP);
         if (ret < 0) {
                 dev_err(codec->dev, "failed to set cache I/O (ret=%i)\n", ret);
-                return ret;
+                goto err;
         }
 
         /* Chip documentation explicitly requires that the reset values
@@ -858,13 +886,15 @@ static int sta32x_probe(struct snd_soc_codec *codec)
          * so the write to the these registers are suppressed by the cache
          * restore code when it skips writes of default registers.
          */
-        snd_soc_cache_write(codec, STA32X_CONFC, 0xc2);
-        snd_soc_cache_write(codec, STA32X_CONFE, 0xc2);
-        snd_soc_cache_write(codec, STA32X_CONFF, 0x5c);
-        snd_soc_cache_write(codec, STA32X_MMUTE, 0x10);
-        snd_soc_cache_write(codec, STA32X_AUTO1, 0x60);
-        snd_soc_cache_write(codec, STA32X_AUTO3, 0x00);
-        snd_soc_cache_write(codec, STA32X_C3CFG, 0x40);
+        regcache_cache_only(sta32x->regmap, true);
+        snd_soc_write(codec, STA32X_CONFC, 0xc2);
+        snd_soc_write(codec, STA32X_CONFE, 0xc2);
+        snd_soc_write(codec, STA32X_CONFF, 0x5c);
+        snd_soc_write(codec, STA32X_MMUTE, 0x10);
+        snd_soc_write(codec, STA32X_AUTO1, 0x60);
+        snd_soc_write(codec, STA32X_AUTO3, 0x00);
+        snd_soc_write(codec, STA32X_C3CFG, 0x40);
+        regcache_cache_only(sta32x->regmap, false);
 
         /* set thermal warning adjustment and recovery */
         if (!(sta32x->pdata->thermal_conf & STA32X_THERMAL_ADJUSTMENT_ENABLE))
@@ -915,9 +945,8 @@ static int sta32x_probe(struct snd_soc_codec *codec)
 
         return 0;
 
-err_get:
-        regulator_bulk_free(ARRAY_SIZE(sta32x->supplies), sta32x->supplies);
 err:
+        regulator_bulk_disable(ARRAY_SIZE(sta32x->supplies), sta32x->supplies);
         return ret;
 }
 
@@ -928,13 +957,11 @@ static int sta32x_remove(struct snd_soc_codec *codec)
         sta32x_watchdog_stop(sta32x);
         sta32x_set_bias_level(codec, SND_SOC_BIAS_OFF);
         regulator_bulk_disable(ARRAY_SIZE(sta32x->supplies), sta32x->supplies);
-        regulator_bulk_free(ARRAY_SIZE(sta32x->supplies), sta32x->supplies);
 
         return 0;
 }
 
-static int sta32x_reg_is_volatile(struct snd_soc_codec *codec,
-                                  unsigned int reg)
+static bool sta32x_reg_is_volatile(struct device *dev, unsigned int reg)
 {
         switch (reg) {
         case STA32X_CONFA ... STA32X_L2ATRT:
@@ -949,10 +976,6 @@ static const struct snd_soc_codec_driver sta32x_codec = {
         .remove =               sta32x_remove,
         .suspend =              sta32x_suspend,
         .resume =               sta32x_resume,
-        .reg_cache_size =       STA32X_REGISTER_COUNT,
-        .reg_word_size =        sizeof(u8),
-        .reg_cache_default =    sta32x_regs,
-        .volatile_register =    sta32x_reg_is_volatile,
         .set_bias_level =       sta32x_set_bias_level,
         .controls =             sta32x_snd_controls,
         .num_controls =         ARRAY_SIZE(sta32x_snd_controls),
@@ -962,17 +985,45 @@ static const struct snd_soc_codec_driver sta32x_codec = {
         .num_dapm_routes =      ARRAY_SIZE(sta32x_dapm_routes),
 };
 
+static const struct regmap_config sta32x_regmap = {
+        .reg_bits =             8,
+        .val_bits =             8,
+        .max_register =         STA32X_FDRC2,
+        .reg_defaults =         sta32x_regs,
+        .num_reg_defaults =     ARRAY_SIZE(sta32x_regs),
+        .cache_type =           REGCACHE_RBTREE,
+        .volatile_reg =         sta32x_reg_is_volatile,
+};
+
 static __devinit int sta32x_i2c_probe(struct i2c_client *i2c,
                                       const struct i2c_device_id *id)
 {
         struct sta32x_priv *sta32x;
-        int ret;
+        int ret, i;
 
         sta32x = devm_kzalloc(&i2c->dev, sizeof(struct sta32x_priv),
                               GFP_KERNEL);
         if (!sta32x)
                 return -ENOMEM;
 
+        /* regulators */
+        for (i = 0; i < ARRAY_SIZE(sta32x->supplies); i++)
+                sta32x->supplies[i].supply = sta32x_supply_names[i];
+
+        ret = devm_regulator_bulk_get(&i2c->dev, ARRAY_SIZE(sta32x->supplies),
+                                      sta32x->supplies);
+        if (ret != 0) {
+                dev_err(&i2c->dev, "Failed to request supplies: %d\n", ret);
+                return ret;
+        }
+
+        sta32x->regmap = devm_regmap_init_i2c(i2c, &sta32x_regmap);
+        if (IS_ERR(sta32x->regmap)) {
+                ret = PTR_ERR(sta32x->regmap);
+                dev_err(&i2c->dev, "Failed to init regmap: %d\n", ret);
+                return ret;
+        }
+
         i2c_set_clientdata(i2c, sta32x);
 
         ret = snd_soc_register_codec(&i2c->dev, &sta32x_codec, &sta32x_dai, 1);
@@ -1006,17 +1057,7 @@ static struct i2c_driver sta32x_i2c_driver = {
         .id_table = sta32x_i2c_id,
 };
 
-static int __init sta32x_init(void)
-{
-        return i2c_add_driver(&sta32x_i2c_driver);
-}
-module_init(sta32x_init);
-
-static void __exit sta32x_exit(void)
-{
-        i2c_del_driver(&sta32x_i2c_driver);
-}
-module_exit(sta32x_exit);
+module_i2c_driver(sta32x_i2c_driver);
 
 MODULE_DESCRIPTION("ASoC STA32X driver");
 MODULE_AUTHOR("Johannes Stezenbach <js@sig21.net>");
diff --git a/sound/soc/codecs/sta529.c b/sound/soc/codecs/sta529.c
index 0c225cd569d2..9e3144862386 100644
--- a/sound/soc/codecs/sta529.c
+++ b/sound/soc/codecs/sta529.c
@@ -358,7 +358,7 @@ static int sta529_resume(struct snd_soc_codec *codec)
         return 0;
 }
 
-struct snd_soc_codec_driver sta529_codec_driver = {
+static const struct snd_soc_codec_driver sta529_codec_driver = {
         .probe = sta529_probe,
         .remove = sta529_remove,
         .set_bias_level = sta529_set_bias_level,
diff --git a/sound/soc/codecs/stac9766.c b/sound/soc/codecs/stac9766.c
index 33c0f3d39c87..982e437799a8 100644
--- a/sound/soc/codecs/stac9766.c
+++ b/sound/soc/codecs/stac9766.c
@@ -340,7 +340,6 @@ static int stac9766_codec_probe(struct snd_soc_codec *codec)
 
         printk(KERN_INFO "STAC9766 SoC Audio Codec %s\n", STAC9766_VERSION);
 
-        codec->control_data = codec;    /* we don't use regmap! */
         ret = snd_soc_new_ac97_codec(codec, &soc_ac97_ops, 0);
         if (ret < 0)
                 goto codec_err;
diff --git a/sound/soc/codecs/tlv320aic26.c b/sound/soc/codecs/tlv320aic26.c
index 85944e953578..b1f6982c7c9c 100644
--- a/sound/soc/codecs/tlv320aic26.c
+++ b/sound/soc/codecs/tlv320aic26.c
@@ -444,14 +444,4 @@ static struct spi_driver aic26_spi = {
         .remove = aic26_spi_remove,
 };
 
-static int __init aic26_init(void)
-{
-        return spi_register_driver(&aic26_spi);
-}
-module_init(aic26_init);
-
-static void __exit aic26_exit(void)
-{
-        spi_unregister_driver(&aic26_spi);
-}
-module_exit(aic26_exit);
+module_spi_driver(aic26_spi);
diff --git a/sound/soc/codecs/tlv320aic32x4.c b/sound/soc/codecs/tlv320aic32x4.c
index b0a73d37ed52..f230292ba96b 100644
--- a/sound/soc/codecs/tlv320aic32x4.c
+++ b/sound/soc/codecs/tlv320aic32x4.c
@@ -746,24 +746,7 @@ static struct i2c_driver aic32x4_i2c_driver = {
         .id_table = aic32x4_i2c_id,
 };
 
-static int __init aic32x4_modinit(void)
-{
-        int ret = 0;
-
-        ret = i2c_add_driver(&aic32x4_i2c_driver);
-        if (ret != 0) {
-                printk(KERN_ERR "Failed to register aic32x4 I2C driver: %d\n",
-                       ret);
-        }
-        return ret;
-}
-module_init(aic32x4_modinit);
-
-static void __exit aic32x4_exit(void)
-{
-        i2c_del_driver(&aic32x4_i2c_driver);
-}
-module_exit(aic32x4_exit);
+module_i2c_driver(aic32x4_i2c_driver);
 
 MODULE_DESCRIPTION("ASoC tlv320aic32x4 codec driver");
 MODULE_AUTHOR("Javier Martin <javier.martin@vista-silicon.com>");
diff --git a/sound/soc/codecs/tlv320aic3x.c b/sound/soc/codecs/tlv320aic3x.c
index dc78f5a4bcbf..5708a973a776 100644
--- a/sound/soc/codecs/tlv320aic3x.c
+++ b/sound/soc/codecs/tlv320aic3x.c
@@ -40,6 +40,7 @@
 #include <linux/i2c.h>
 #include <linux/gpio.h>
 #include <linux/regulator/consumer.h>
+#include <linux/of_gpio.h>
 #include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
@@ -1457,6 +1458,8 @@ static int aic3x_i2c_probe(struct i2c_client *i2c,
 {
         struct aic3x_pdata *pdata = i2c->dev.platform_data;
         struct aic3x_priv *aic3x;
+        struct aic3x_setup_data *ai3x_setup;
+        struct device_node *np = i2c->dev.of_node;
         int ret;
 
         aic3x = devm_kzalloc(&i2c->dev, sizeof(struct aic3x_priv), GFP_KERNEL);
@@ -1471,6 +1474,25 @@ static int aic3x_i2c_probe(struct i2c_client *i2c,
         if (pdata) {
                 aic3x->gpio_reset = pdata->gpio_reset;
                 aic3x->setup = pdata->setup;
+        } else if (np) {
+                ai3x_setup = devm_kzalloc(&i2c->dev, sizeof(*ai3x_setup),
+                                                                GFP_KERNEL);
+                if (ai3x_setup == NULL) {
+                        dev_err(&i2c->dev, "failed to create private data\n");
+                        return -ENOMEM;
+                }
+
+                ret = of_get_named_gpio(np, "gpio-reset", 0);
+                if (ret >= 0)
+                        aic3x->gpio_reset = ret;
+                else
+                        aic3x->gpio_reset = -1;
+
+                if (of_property_read_u32_array(np, "ai3x-gpio-func",
+                                        ai3x_setup->gpio_func, 2) >= 0) {
+                        aic3x->setup = ai3x_setup;
+                }
+
         } else {
                 aic3x->gpio_reset = -1;
         }
@@ -1488,34 +1510,27 @@ static int aic3x_i2c_remove(struct i2c_client *client)
         return 0;
 }
 
+#if defined(CONFIG_OF)
+static const struct of_device_id tlv320aic3x_of_match[] = {
+        { .compatible = "ti,tlv320aic3x", },
+        {},
+};
+MODULE_DEVICE_TABLE(of, tlv320aic3x_of_match);
+#endif
+
 /* machine i2c codec control layer */
 static struct i2c_driver aic3x_i2c_driver = {
         .driver = {
                 .name = "tlv320aic3x-codec",
                 .owner = THIS_MODULE,
+                .of_match_table = of_match_ptr(tlv320aic3x_of_match),
         },
         .probe  = aic3x_i2c_probe,
         .remove = aic3x_i2c_remove,
         .id_table = aic3x_i2c_id,
 };
 
-static int __init aic3x_modinit(void)
-{
-        int ret = 0;
-        ret = i2c_add_driver(&aic3x_i2c_driver);
-        if (ret != 0) {
-                printk(KERN_ERR "Failed to register TLV320AIC3x I2C driver: %d\n",
-                       ret);
-        }
-        return ret;
-}
-module_init(aic3x_modinit);
-
-static void __exit aic3x_exit(void)
-{
-        i2c_del_driver(&aic3x_i2c_driver);
-}
-module_exit(aic3x_exit);
+module_i2c_driver(aic3x_i2c_driver);
 
 MODULE_DESCRIPTION("ASoC TLV320AIC3X codec driver");
 MODULE_AUTHOR("Vladimir Barinov");
diff --git a/sound/soc/codecs/tlv320dac33.c b/sound/soc/codecs/tlv320dac33.c
index 0dd41077ab79..d2e16c5d7d1f 100644
--- a/sound/soc/codecs/tlv320dac33.c
+++ b/sound/soc/codecs/tlv320dac33.c
@@ -1621,24 +1621,7 @@ static struct i2c_driver tlv320dac33_i2c_driver = {
         .id_table       = tlv320dac33_i2c_id,
 };
 
-static int __init dac33_module_init(void)
-{
-        int r;
-        r = i2c_add_driver(&tlv320dac33_i2c_driver);
-        if (r < 0) {
-                printk(KERN_ERR "DAC33: driver registration failed\n");
-                return r;
-        }
-        return 0;
-}
-module_init(dac33_module_init);
-
-static void __exit dac33_module_exit(void)
-{
-        i2c_del_driver(&tlv320dac33_i2c_driver);
-}
-module_exit(dac33_module_exit);
-
+module_i2c_driver(tlv320dac33_i2c_driver);
 
 MODULE_DESCRIPTION("ASoC TLV320DAC33 codec driver");
 MODULE_AUTHOR("Peter Ujfalusi <peter.ujfalusi@ti.com>");
diff --git a/sound/soc/codecs/tpa6130a2.c b/sound/soc/codecs/tpa6130a2.c
index 6fe4aa3ac544..565ff39ad3a3 100644
--- a/sound/soc/codecs/tpa6130a2.c
+++ b/sound/soc/codecs/tpa6130a2.c
@@ -487,19 +487,8 @@ static struct i2c_driver tpa6130a2_i2c_driver = {
         .id_table = tpa6130a2_id,
 };
 
-static int __init tpa6130a2_init(void)
-{
-        return i2c_add_driver(&tpa6130a2_i2c_driver);
-}
-
-static void __exit tpa6130a2_exit(void)
-{
-        i2c_del_driver(&tpa6130a2_i2c_driver);
-}
+module_i2c_driver(tpa6130a2_i2c_driver);
 
 MODULE_AUTHOR("Peter Ujfalusi <peter.ujfalusi@ti.com>");
 MODULE_DESCRIPTION("TPA6130A2 Headphone amplifier driver");
 MODULE_LICENSE("GPL");
-
-module_init(tpa6130a2_init);
-module_exit(tpa6130a2_exit);
diff --git a/sound/soc/codecs/twl4030.c b/sound/soc/codecs/twl4030.c
index 391fcfc7b63b..e7f608996c41 100644
--- a/sound/soc/codecs/twl4030.c
+++ b/sound/soc/codecs/twl4030.c
@@ -26,8 +26,11 @@
 #include <linux/pm.h>
 #include <linux/i2c.h>
 #include <linux/platform_device.h>
+#include <linux/of.h>
+#include <linux/of_gpio.h>
 #include <linux/i2c/twl.h>
 #include <linux/slab.h>
+#include <linux/gpio.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
@@ -152,8 +155,7 @@ struct twl4030_priv {
         u8 predrivel_enabled, predriver_enabled;
         u8 carkitl_enabled, carkitr_enabled;
 
-        /* Delay needed after enabling the digimic interface */
-        unsigned int digimic_delay;
+        struct twl4030_codec_data *pdata;
 };
 
 /*
@@ -295,13 +297,73 @@ static inline void twl4030_reset_registers(struct snd_soc_codec *codec)
 
 }
 
-static void twl4030_init_chip(struct snd_soc_codec *codec)
+static void twl4030_setup_pdata_of(struct twl4030_codec_data *pdata,
+                                   struct device_node *node)
+{
+        int value;
+
+        of_property_read_u32(node, "ti,digimic_delay",
+                             &pdata->digimic_delay);
+        of_property_read_u32(node, "ti,ramp_delay_value",
+                             &pdata->ramp_delay_value);
+        of_property_read_u32(node, "ti,offset_cncl_path",
+                             &pdata->offset_cncl_path);
+        if (!of_property_read_u32(node, "ti,hs_extmute", &value))
+                pdata->hs_extmute = value;
+
+        pdata->hs_extmute_gpio = of_get_named_gpio(node,
+                                                   "ti,hs_extmute_gpio", 0);
+        if (gpio_is_valid(pdata->hs_extmute_gpio))
+                pdata->hs_extmute = 1;
+}
+
+static struct twl4030_codec_data *twl4030_get_pdata(struct snd_soc_codec *codec)
 {
         struct twl4030_codec_data *pdata = dev_get_platdata(codec->dev);
+        struct device_node *twl4030_codec_node = NULL;
+
+        twl4030_codec_node = of_find_node_by_name(codec->dev->parent->of_node,
+                                                  "codec");
+
+        if (!pdata && twl4030_codec_node) {
+                pdata = devm_kzalloc(codec->dev,
+                                     sizeof(struct twl4030_codec_data),
+                                     GFP_KERNEL);
+                if (!pdata) {
+                        dev_err(codec->dev, "Can not allocate memory\n");
+                        return NULL;
+                }
+                twl4030_setup_pdata_of(pdata, twl4030_codec_node);
+        }
+
+        return pdata;
+}
+
+static void twl4030_init_chip(struct snd_soc_codec *codec)
+{
+        struct twl4030_codec_data *pdata;
         struct twl4030_priv *twl4030 = snd_soc_codec_get_drvdata(codec);
         u8 reg, byte;
         int i = 0;
 
+        pdata = twl4030_get_pdata(codec);
+
+        if (pdata && pdata->hs_extmute &&
+            gpio_is_valid(pdata->hs_extmute_gpio)) {
+                int ret;
+
+                if (!pdata->hs_extmute_gpio)
+                        dev_warn(codec->dev,
+                                 "Extmute GPIO is 0 is this correct?\n");
+
+                ret = gpio_request_one(pdata->hs_extmute_gpio,
+                                       GPIOF_OUT_INIT_LOW, "hs_extmute");
+                if (ret) {
+                        dev_err(codec->dev, "Failed to get hs_extmute GPIO\n");
+                        pdata->hs_extmute_gpio = -1;
+                }
+        }
+
         /* Check defaults, if instructed before anything else */
         if (pdata && pdata->check_defaults)
                 twl4030_check_defaults(codec);
@@ -331,7 +393,7 @@ static void twl4030_init_chip(struct snd_soc_codec *codec)
         if (!pdata)
                 return;
 
-        twl4030->digimic_delay = pdata->digimic_delay;
+        twl4030->pdata = pdata;
 
         reg = twl4030_read_reg_cache(codec, TWL4030_REG_HS_POPN_SET);
         reg &= ~TWL4030_RAMP_DELAY;
@@ -732,9 +794,9 @@ static int aif_event(struct snd_soc_dapm_widget *w,
 
 static void headset_ramp(struct snd_soc_codec *codec, int ramp)
 {
-        struct twl4030_codec_data *pdata = codec->dev->platform_data;
         unsigned char hs_gain, hs_pop;
         struct twl4030_priv *twl4030 = snd_soc_codec_get_drvdata(codec);
+        struct twl4030_codec_data *pdata = twl4030->pdata;
         /* Base values for ramp delay calculation: 2^19 - 2^26 */
         unsigned int ramp_base[] = {524288, 1048576, 2097152, 4194304,
                                     8388608, 16777216, 33554432, 67108864};
@@ -748,8 +810,8 @@ static void headset_ramp(struct snd_soc_codec *codec, int ramp)
         /* Enable external mute control, this dramatically reduces
          * the pop-noise */
         if (pdata && pdata->hs_extmute) {
-                if (pdata->set_hs_extmute) {
-                        pdata->set_hs_extmute(1);
+                if (gpio_is_valid(pdata->hs_extmute_gpio)) {
+                        gpio_set_value(pdata->hs_extmute_gpio, 1);
                 } else {
                         hs_pop |= TWL4030_EXTMUTE;
                         twl4030_write(codec, TWL4030_REG_HS_POPN_SET, hs_pop);
@@ -786,8 +848,8 @@ static void headset_ramp(struct snd_soc_codec *codec, int ramp)
 
         /* Disable external mute */
         if (pdata && pdata->hs_extmute) {
-                if (pdata->set_hs_extmute) {
-                        pdata->set_hs_extmute(0);
+                if (gpio_is_valid(pdata->hs_extmute_gpio)) {
+                        gpio_set_value(pdata->hs_extmute_gpio, 0);
                 } else {
                         hs_pop &= ~TWL4030_EXTMUTE;
                         twl4030_write(codec, TWL4030_REG_HS_POPN_SET, hs_pop);
@@ -847,9 +909,10 @@ static int digimic_event(struct snd_soc_dapm_widget *w,
                 struct snd_kcontrol *kcontrol, int event)
 {
         struct twl4030_priv *twl4030 = snd_soc_codec_get_drvdata(w->codec);
+        struct twl4030_codec_data *pdata = twl4030->pdata;
 
-        if (twl4030->digimic_delay)
-                twl4030_wait_ms(twl4030->digimic_delay);
+        if (pdata && pdata->digimic_delay)
+                twl4030_wait_ms(pdata->digimic_delay);
         return 0;
 }
 
@@ -999,7 +1062,7 @@ static int snd_soc_put_twl4030_opmode_enum_double(struct snd_kcontrol *kcontrol,
         struct twl4030_priv *twl4030 = snd_soc_codec_get_drvdata(codec);
         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
         unsigned short val;
-        unsigned short mask, bitmask;
+        unsigned short mask;
 
         if (twl4030->configured) {
                 dev_err(codec->dev,
@@ -1007,18 +1070,16 @@ static int snd_soc_put_twl4030_opmode_enum_double(struct snd_kcontrol *kcontrol,
                 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;
+        mask = e->mask << 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;
+                mask |= e->mask << e->shift_r;
         }
 
         return snd_soc_update_bits(codec, e->reg, mask, val);
@@ -1239,16 +1300,11 @@ static const struct snd_soc_dapm_widget twl4030_dapm_widgets[] = {
         SND_SOC_DAPM_OUTPUT("Virtual Voice OUT"),
 
         /* DACs */
-        SND_SOC_DAPM_DAC("DAC Right1", "Right Front HiFi Playback",
-                        SND_SOC_NOPM, 0, 0),
-        SND_SOC_DAPM_DAC("DAC Left1", "Left Front HiFi Playback",
-                        SND_SOC_NOPM, 0, 0),
-        SND_SOC_DAPM_DAC("DAC Right2", "Right Rear HiFi Playback",
-                        SND_SOC_NOPM, 0, 0),
-        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),
+        SND_SOC_DAPM_DAC("DAC Right1", NULL, SND_SOC_NOPM, 0, 0),
+        SND_SOC_DAPM_DAC("DAC Left1", NULL, SND_SOC_NOPM, 0, 0),
+        SND_SOC_DAPM_DAC("DAC Right2", NULL, SND_SOC_NOPM, 0, 0),
+        SND_SOC_DAPM_DAC("DAC Left2", NULL, SND_SOC_NOPM, 0, 0),
+        SND_SOC_DAPM_DAC("DAC Voice", NULL, SND_SOC_NOPM, 0, 0),
 
         /* Analog bypasses */
         SND_SOC_DAPM_SWITCH("Right1 Analog Loopback", SND_SOC_NOPM, 0, 0,
@@ -1377,14 +1433,10 @@ static const struct snd_soc_dapm_widget twl4030_dapm_widgets[] = {
 
         /* Introducing four virtual ADC, since TWL4030 have four channel for
            capture */
-        SND_SOC_DAPM_ADC("ADC Virtual Left1", "Left Front Capture",
-                SND_SOC_NOPM, 0, 0),
-        SND_SOC_DAPM_ADC("ADC Virtual Right1", "Right Front Capture",
-                SND_SOC_NOPM, 0, 0),
-        SND_SOC_DAPM_ADC("ADC Virtual Left2", "Left Rear Capture",
-                SND_SOC_NOPM, 0, 0),
-        SND_SOC_DAPM_ADC("ADC Virtual Right2", "Right Rear Capture",
-                SND_SOC_NOPM, 0, 0),
+        SND_SOC_DAPM_ADC("ADC Virtual Left1", NULL, SND_SOC_NOPM, 0, 0),
+        SND_SOC_DAPM_ADC("ADC Virtual Right1", NULL, SND_SOC_NOPM, 0, 0),
+        SND_SOC_DAPM_ADC("ADC Virtual Left2", NULL, SND_SOC_NOPM, 0, 0),
+        SND_SOC_DAPM_ADC("ADC Virtual Right2", NULL, SND_SOC_NOPM, 0, 0),
 
         /* Analog/Digital mic path selection.
            TX1 Left/Right: either analog Left/Right or Digimic0
@@ -1428,6 +1480,23 @@ static const struct snd_soc_dapm_widget twl4030_dapm_widgets[] = {
 };
 
 static const struct snd_soc_dapm_route intercon[] = {
+        /* Stream -> DAC mapping */
+        {"DAC Right1", NULL, "HiFi Playback"},
+        {"DAC Left1", NULL, "HiFi Playback"},
+        {"DAC Right2", NULL, "HiFi Playback"},
+        {"DAC Left2", NULL, "HiFi Playback"},
+        {"DAC Voice", NULL, "Voice Playback"},
+
+        /* ADC -> Stream mapping */
+        {"HiFi Capture", NULL, "ADC Virtual Left1"},
+        {"HiFi Capture", NULL, "ADC Virtual Right1"},
+        {"HiFi Capture", NULL, "ADC Virtual Left2"},
+        {"HiFi Capture", NULL, "ADC Virtual Right2"},
+        {"Voice Capture", NULL, "ADC Virtual Left1"},
+        {"Voice Capture", NULL, "ADC Virtual Right1"},
+        {"Voice Capture", NULL, "ADC Virtual Left2"},
+        {"Voice Capture", NULL, "ADC Virtual Right2"},
+
         {"Digital L1 Playback Mixer", NULL, "DAC Left1"},
         {"Digital R1 Playback Mixer", NULL, "DAC Right1"},
         {"Digital L2 Playback Mixer", NULL, "DAC Left2"},
@@ -2172,7 +2241,7 @@ static struct snd_soc_dai_driver twl4030_dai[] = {
                 .formats = TWL4030_FORMATS,
                 .sig_bits = 24,},
         .capture = {
-                .stream_name = "Capture",
+                .stream_name = "HiFi Capture",
                 .channels_min = 2,
                 .channels_max = 4,
                 .rates = TWL4030_RATES,
@@ -2189,7 +2258,7 @@ static struct snd_soc_dai_driver twl4030_dai[] = {
                 .rates = SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_16000,
                 .formats = SNDRV_PCM_FMTBIT_S16_LE,},
         .capture = {
-                .stream_name = "Capture",
+                .stream_name = "Voice Capture",
                 .channels_min = 1,
                 .channels_max = 2,
                 .rates = SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_16000,
@@ -2214,7 +2283,8 @@ static int twl4030_soc_probe(struct snd_soc_codec *codec)
 {
         struct twl4030_priv *twl4030;
 
-        twl4030 = kzalloc(sizeof(struct twl4030_priv), GFP_KERNEL);
+        twl4030 = devm_kzalloc(codec->dev, sizeof(struct twl4030_priv),
+                               GFP_KERNEL);
         if (twl4030 == NULL) {
                 dev_err(codec->dev, "Can not allocate memory\n");
                 return -ENOMEM;
@@ -2231,11 +2301,15 @@ static int twl4030_soc_probe(struct snd_soc_codec *codec)
 static int twl4030_soc_remove(struct snd_soc_codec *codec)
 {
         struct twl4030_priv *twl4030 = snd_soc_codec_get_drvdata(codec);
+        struct twl4030_codec_data *pdata = twl4030->pdata;
 
         /* Reset registers to their chip default before leaving */
         twl4030_reset_registers(codec);
         twl4030_set_bias_level(codec, SND_SOC_BIAS_OFF);
-        kfree(twl4030);
+
+        if (pdata && pdata->hs_extmute && gpio_is_valid(pdata->hs_extmute_gpio))
+                gpio_free(pdata->hs_extmute_gpio);
+
         return 0;
 }
 
@@ -2262,13 +2336,6 @@ static struct snd_soc_codec_driver soc_codec_dev_twl4030 = {
 
 static int __devinit twl4030_codec_probe(struct platform_device *pdev)
 {
-        struct twl4030_codec_data *pdata = pdev->dev.platform_data;
-
-        if (!pdata) {
-                dev_err(&pdev->dev, "platform_data is missing\n");
-                return -EINVAL;
-        }
-
         return snd_soc_register_codec(&pdev->dev, &soc_codec_dev_twl4030,
                         twl4030_dai, ARRAY_SIZE(twl4030_dai));
 }
diff --git a/sound/soc/codecs/twl6040.c b/sound/soc/codecs/twl6040.c
index c084c549942e..e8f97af75928 100644
--- a/sound/soc/codecs/twl6040.c
+++ b/sound/soc/codecs/twl6040.c
@@ -727,10 +727,8 @@ static const struct snd_soc_dapm_widget twl6040_dapm_widgets[] = {
                         TWL6040_REG_MICRCTL, 1, 0, NULL, 0),
 
         /* ADCs */
-        SND_SOC_DAPM_ADC("ADC Left", "Left Front Capture",
-                        TWL6040_REG_MICLCTL, 2, 0),
-        SND_SOC_DAPM_ADC("ADC Right", "Right Front Capture",
-                        TWL6040_REG_MICRCTL, 2, 0),
+        SND_SOC_DAPM_ADC("ADC Left", NULL, TWL6040_REG_MICLCTL, 2, 0),
+        SND_SOC_DAPM_ADC("ADC Right", NULL, TWL6040_REG_MICRCTL, 2, 0),
 
         /* Microphone bias */
         SND_SOC_DAPM_SUPPLY("Headset Mic Bias",
@@ -743,15 +741,12 @@ static const struct snd_soc_dapm_widget twl6040_dapm_widgets[] = {
                             TWL6040_REG_DMICBCTL, 4, 0, NULL, 0),
 
         /* DACs */
-        SND_SOC_DAPM_DAC("HSDAC Left", "Headset Playback", SND_SOC_NOPM, 0, 0),
-        SND_SOC_DAPM_DAC("HSDAC Right", "Headset Playback", SND_SOC_NOPM, 0, 0),
-        SND_SOC_DAPM_DAC("HFDAC Left", "Handsfree Playback",
-                         TWL6040_REG_HFLCTL, 0, 0),
-        SND_SOC_DAPM_DAC("HFDAC Right", "Handsfree Playback",
-                         TWL6040_REG_HFRCTL, 0, 0),
+        SND_SOC_DAPM_DAC("HSDAC Left", NULL, SND_SOC_NOPM, 0, 0),
+        SND_SOC_DAPM_DAC("HSDAC Right", NULL, SND_SOC_NOPM, 0, 0),
+        SND_SOC_DAPM_DAC("HFDAC Left", NULL, TWL6040_REG_HFLCTL, 0, 0),
+        SND_SOC_DAPM_DAC("HFDAC Right", NULL, TWL6040_REG_HFRCTL, 0, 0),
         /* Virtual DAC for vibra path (DL4 channel) */
-        SND_SOC_DAPM_DAC("VIBRA DAC", "Vibra Playback",
-                        SND_SOC_NOPM, 0, 0),
+        SND_SOC_DAPM_DAC("VIBRA DAC", NULL, SND_SOC_NOPM, 0, 0),
 
         SND_SOC_DAPM_MUX("Handsfree Left Playback",
                         SND_SOC_NOPM, 0, 0, &hfl_mux_controls),
@@ -810,6 +805,26 @@ static const struct snd_soc_dapm_widget twl6040_dapm_widgets[] = {
 };
 
 static const struct snd_soc_dapm_route intercon[] = {
+        /* Stream -> DAC mapping */
+        {"HSDAC Left", NULL, "Legacy Playback"},
+        {"HSDAC Left", NULL, "Headset Playback"},
+        {"HSDAC Right", NULL, "Legacy Playback"},
+        {"HSDAC Right", NULL, "Headset Playback"},
+
+        {"HFDAC Left", NULL, "Legacy Playback"},
+        {"HFDAC Left", NULL, "Handsfree Playback"},
+        {"HFDAC Right", NULL, "Legacy Playback"},
+        {"HFDAC Right", NULL, "Handsfree Playback"},
+
+        {"VIBRA DAC", NULL, "Legacy Playback"},
+        {"VIBRA DAC", NULL, "Vibra Playback"},
+
+        /* ADC -> Stream mapping */
+        {"ADC Left", NULL, "Legacy Capture"},
+        {"ADC Left", NULL, "Capture"},
+        {"ADC Right", NULL, "Legacy Capture"},
+        {"ADC Right", NULL, "Capture"},
+
         /* Capture path */
         {"Analog Left Capture Route", "Headset Mic", "HSMIC"},
         {"Analog Left Capture Route", "Main Mic", "MAINMIC"},
@@ -1028,14 +1043,14 @@ static struct snd_soc_dai_driver twl6040_dai[] = {
 {
         .name = "twl6040-legacy",
         .playback = {
-                .stream_name = "Playback",
+                .stream_name = "Legacy Playback",
                 .channels_min = 1,
                 .channels_max = 5,
                 .rates = TWL6040_RATES,
                 .formats = TWL6040_FORMATS,
         },
         .capture = {
-                .stream_name = "Capture",
+                .stream_name = "Legacy Capture",
                 .channels_min = 1,
                 .channels_max = 2,
                 .rates = TWL6040_RATES,
diff --git a/sound/soc/codecs/wm0010.c b/sound/soc/codecs/wm0010.c
new file mode 100644
index 000000000000..f8d6c31db870
--- /dev/null
+++ b/sound/soc/codecs/wm0010.c
@@ -0,0 +1,944 @@
+/*
+ * wm0010.c  --  WM0010 DSP Driver
+ *
+ * Copyright 2012 Wolfson Microelectronics PLC.
+ *
+ * Authors: Mark Brown <broonie@opensource.wolfsonmicro.com>
+ *          Dimitris Papastamos <dp@opensource.wolfsonmicro.com>
+ *          Scott Ling <sl@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/irqreturn.h>
+#include <linux/init.h>
+#include <linux/spi/spi.h>
+#include <linux/firmware.h>
+#include <linux/delay.h>
+#include <linux/fs.h>
+#include <linux/miscdevice.h>
+#include <linux/gpio.h>
+#include <linux/regulator/consumer.h>
+#include <linux/mutex.h>
+#include <linux/workqueue.h>
+
+#include <sound/soc.h>
+#include <sound/wm0010.h>
+
+#define DEVICE_ID_WM0010        10
+
+enum dfw_cmd {
+        DFW_CMD_FUSE = 0x01,
+        DFW_CMD_CODE_HDR,
+        DFW_CMD_CODE_DATA,
+        DFW_CMD_PLL,
+        DFW_CMD_INFO = 0xff
+};
+
+struct dfw_binrec {
+        u8 command;
+        u32 length:24;
+        u32 address;
+        uint8_t data[0];
+} __packed;
+
+struct dfw_pllrec {
+        u8 command;
+        u32 length:24;
+        u32 address;
+        u32 clkctrl1;
+        u32 clkctrl2;
+        u32 clkctrl3;
+        u32 ldetctrl;
+        u32 uart_div;
+        u32 spi_div;
+} __packed;
+
+static struct pll_clock_map {
+        int max_sysclk;
+        int max_pll_spi_speed;
+        u32 pll_clkctrl1;
+} pll_clock_map[] = {                      /* Dividers */
+        { 22000000, 26000000, 0x00201f11 }, /* 2,32,2  */
+        { 18000000, 26000000, 0x00203f21 }, /* 2,64,4  */
+        { 14000000, 26000000, 0x00202620 }, /* 1,39,4  */
+        { 10000000, 22000000, 0x00203120 }, /* 1,50,4  */
+        {  6500000, 22000000, 0x00204520 }, /* 1,70,4  */
+        {  5500000, 22000000, 0x00103f10 }, /* 1,64,2  */
+};
+
+enum wm0010_state {
+        WM0010_POWER_OFF,
+        WM0010_OUT_OF_RESET,
+        WM0010_BOOTROM,
+        WM0010_STAGE2,
+        WM0010_FIRMWARE,
+};
+
+struct wm0010_priv {
+        struct snd_soc_codec *codec;
+
+        struct mutex lock;
+        struct device *dev;
+
+        struct wm0010_pdata pdata;
+
+        int gpio_reset;
+        int gpio_reset_value;
+
+        struct regulator_bulk_data core_supplies[2];
+        struct regulator *dbvdd;
+
+        int sysclk;
+
+        enum wm0010_state state;
+        bool boot_failed;
+        int boot_done;
+        bool ready;
+        bool pll_running;
+        int max_spi_freq;
+        int board_max_spi_speed;
+        u32 pll_clkctrl1;
+
+        spinlock_t irq_lock;
+        int irq;
+
+        struct completion boot_completion;
+};
+
+struct wm0010_spi_msg {
+        struct spi_message m;
+        struct spi_transfer t;
+        u8 *tx_buf;
+        u8 *rx_buf;
+        size_t len;
+};
+
+static const struct snd_soc_dapm_widget wm0010_dapm_widgets[] = {
+SND_SOC_DAPM_SUPPLY("CLKIN",  SND_SOC_NOPM, 0, 0, NULL, 0),
+};
+
+static const struct snd_soc_dapm_route wm0010_dapm_routes[] = {
+        { "SDI2 Capture", NULL, "SDI1 Playback" },
+        { "SDI1 Capture", NULL, "SDI2 Playback" },
+
+        { "SDI1 Capture", NULL, "CLKIN" },
+        { "SDI2 Capture", NULL, "CLKIN" },
+        { "SDI1 Playback", NULL, "CLKIN" },
+        { "SDI2 Playback", NULL, "CLKIN" },
+};
+
+static const char *wm0010_state_to_str(enum wm0010_state state)
+{
+        const char *state_to_str[] = {
+                "Power off",
+                "Out of reset",
+                "Boot ROM",
+                "Stage2",
+                "Firmware"
+        };
+
+        if (state < 0 || state >= ARRAY_SIZE(state_to_str))
+                return "null";
+        return state_to_str[state];
+}
+
+/* Called with wm0010->lock held */
+static void wm0010_halt(struct snd_soc_codec *codec)
+{
+        struct wm0010_priv *wm0010 = snd_soc_codec_get_drvdata(codec);
+        unsigned long flags;
+        enum wm0010_state state;
+
+        /* Fetch the wm0010 state */
+        spin_lock_irqsave(&wm0010->irq_lock, flags);
+        state = wm0010->state;
+        spin_unlock_irqrestore(&wm0010->irq_lock, flags);
+
+        switch (state) {
+        case WM0010_POWER_OFF:
+                /* If there's nothing to do, bail out */
+                return;
+        case WM0010_OUT_OF_RESET:
+        case WM0010_BOOTROM:
+        case WM0010_STAGE2:
+        case WM0010_FIRMWARE:
+                /* Remember to put chip back into reset */
+                gpio_set_value(wm0010->gpio_reset, wm0010->gpio_reset_value);
+                /* Disable the regulators */
+                regulator_disable(wm0010->dbvdd);
+                regulator_bulk_disable(ARRAY_SIZE(wm0010->core_supplies),
+                                       wm0010->core_supplies);
+                break;
+        }
+
+        spin_lock_irqsave(&wm0010->irq_lock, flags);
+        wm0010->state = WM0010_POWER_OFF;
+        spin_unlock_irqrestore(&wm0010->irq_lock, flags);
+}
+
+struct wm0010_boot_xfer {
+        struct list_head list;
+        struct snd_soc_codec *codec;
+        struct completion *done;
+        struct spi_message m;
+        struct spi_transfer t;
+};
+
+/* Called with wm0010->lock held */
+static void wm0010_mark_boot_failure(struct wm0010_priv *wm0010)
+{
+        enum wm0010_state state;
+        unsigned long flags;
+
+        spin_lock_irqsave(&wm0010->irq_lock, flags);
+        state = wm0010->state;
+        spin_unlock_irqrestore(&wm0010->irq_lock, flags);
+
+        dev_err(wm0010->dev, "Failed to transition from `%s' state to `%s' state\n",
+                wm0010_state_to_str(state), wm0010_state_to_str(state + 1));
+
+        wm0010->boot_failed = true;
+}
+
+static void wm0010_boot_xfer_complete(void *data)
+{
+        struct wm0010_boot_xfer *xfer = data;
+        struct snd_soc_codec *codec = xfer->codec;
+        struct wm0010_priv *wm0010 = snd_soc_codec_get_drvdata(codec);
+        u32 *out32 = xfer->t.rx_buf;
+        int i;
+
+        if (xfer->m.status != 0) {
+                dev_err(codec->dev, "SPI transfer failed: %d\n",
+                        xfer->m.status);
+                wm0010_mark_boot_failure(wm0010);
+                if (xfer->done)
+                        complete(xfer->done);
+                return;
+        }
+
+        for (i = 0; i < xfer->t.len / 4; i++) {
+                dev_dbg(codec->dev, "%d: %04x\n", i, out32[i]);
+
+                switch (be32_to_cpu(out32[i])) {
+                case 0xe0e0e0e0:
+                        dev_err(codec->dev,
+                                "%d: ROM error reported in stage 2\n", i);
+                        wm0010_mark_boot_failure(wm0010);
+                        break;
+
+                case 0x55555555:
+                        if (wm0010->boot_done == 0)
+                                break;
+                        dev_err(codec->dev,
+                                "%d: ROM bootloader running in stage 2\n", i);
+                        wm0010_mark_boot_failure(wm0010);
+                        break;
+
+                case 0x0fed0000:
+                        dev_dbg(codec->dev, "Stage2 loader running\n");
+                        break;
+
+                case 0x0fed0007:
+                        dev_dbg(codec->dev, "CODE_HDR packet received\n");
+                        break;
+
+                case 0x0fed0008:
+                        dev_dbg(codec->dev, "CODE_DATA packet received\n");
+                        break;
+
+                case 0x0fed0009:
+                        dev_dbg(codec->dev, "Download complete\n");
+                        break;
+
+                case 0x0fed000c:
+                        dev_dbg(codec->dev, "Application start\n");
+                        break;
+
+                case 0x0fed000e:
+                        dev_dbg(codec->dev, "PLL packet received\n");
+                        wm0010->pll_running = true;
+                        break;
+
+                case 0x0fed0025:
+                        dev_err(codec->dev, "Device reports image too long\n");
+                        wm0010_mark_boot_failure(wm0010);
+                        break;
+
+                case 0x0fed002c:
+                        dev_err(codec->dev, "Device reports bad SPI packet\n");
+                        wm0010_mark_boot_failure(wm0010);
+                        break;
+
+                case 0x0fed0031:
+                        dev_err(codec->dev, "Device reports SPI read overflow\n");
+                        wm0010_mark_boot_failure(wm0010);
+                        break;
+
+                case 0x0fed0032:
+                        dev_err(codec->dev, "Device reports SPI underclock\n");
+                        wm0010_mark_boot_failure(wm0010);
+                        break;
+
+                case 0x0fed0033:
+                        dev_err(codec->dev, "Device reports bad header packet\n");
+                        wm0010_mark_boot_failure(wm0010);
+                        break;
+
+                case 0x0fed0034:
+                        dev_err(codec->dev, "Device reports invalid packet type\n");
+                        wm0010_mark_boot_failure(wm0010);
+                        break;
+
+                case 0x0fed0035:
+                        dev_err(codec->dev, "Device reports data before header error\n");
+                        wm0010_mark_boot_failure(wm0010);
+                        break;
+
+                case 0x0fed0038:
+                        dev_err(codec->dev, "Device reports invalid PLL packet\n");
+                        break;
+
+                case 0x0fed003a:
+                        dev_err(codec->dev, "Device reports packet alignment error\n");
+                        wm0010_mark_boot_failure(wm0010);
+                        break;
+
+                default:
+                        dev_err(codec->dev, "Unrecognised return 0x%x\n",
+                            be32_to_cpu(out32[i]));
+                        wm0010_mark_boot_failure(wm0010);
+                        break;
+                }
+
+                if (wm0010->boot_failed)
+                        break;
+        }
+
+        wm0010->boot_done++;
+        if (xfer->done)
+                complete(xfer->done);
+}
+
+static void byte_swap_64(u64 *data_in, u64 *data_out, u32 len)
+{
+        int i;
+
+        for (i = 0; i < len / 8; i++)
+                data_out[i] = cpu_to_be64(le64_to_cpu(data_in[i]));
+}
+
+static int wm0010_boot(struct snd_soc_codec *codec)
+{
+        struct spi_device *spi = to_spi_device(codec->dev);
+        struct wm0010_priv *wm0010 = snd_soc_codec_get_drvdata(codec);
+        unsigned long flags;
+        struct list_head xfer_list;
+        struct wm0010_boot_xfer *xfer;
+        int ret;
+        struct completion done;
+        const struct firmware *fw;
+        const struct dfw_binrec *rec;
+        struct spi_message m;
+        struct spi_transfer t;
+        struct dfw_pllrec pll_rec;
+        u32 *img, *p;
+        u64 *img_swap;
+        u8 *out;
+        u32 len, offset;
+        int i;
+
+        spin_lock_irqsave(&wm0010->irq_lock, flags);
+        if (wm0010->state != WM0010_POWER_OFF)
+                dev_warn(wm0010->dev, "DSP already powered up!\n");
+        spin_unlock_irqrestore(&wm0010->irq_lock, flags);
+
+        if (wm0010->sysclk > 26000000) {
+                dev_err(codec->dev, "Max DSP clock frequency is 26MHz\n");
+                ret = -ECANCELED;
+                goto err;
+        }
+
+        INIT_LIST_HEAD(&xfer_list);
+
+        mutex_lock(&wm0010->lock);
+        wm0010->pll_running = false;
+
+        dev_dbg(codec->dev, "max_spi_freq: %d\n", wm0010->max_spi_freq);
+
+        ret = regulator_bulk_enable(ARRAY_SIZE(wm0010->core_supplies),
+                                    wm0010->core_supplies);
+        if (ret != 0) {
+                dev_err(&spi->dev, "Failed to enable core supplies: %d\n",
+                        ret);
+                mutex_unlock(&wm0010->lock);
+                goto err;
+        }
+
+        ret = regulator_enable(wm0010->dbvdd);
+        if (ret != 0) {
+                dev_err(&spi->dev, "Failed to enable DBVDD: %d\n", ret);
+                goto err_core;
+        }
+
+        /* Release reset */
+        gpio_set_value(wm0010->gpio_reset, !wm0010->gpio_reset_value);
+        spin_lock_irqsave(&wm0010->irq_lock, flags);
+        wm0010->state = WM0010_OUT_OF_RESET;
+        spin_unlock_irqrestore(&wm0010->irq_lock, flags);
+
+        /* First the bootloader */
+        ret = request_firmware(&fw, "wm0010_stage2.bin", codec->dev);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to request stage2 loader: %d\n",
+                        ret);
+                goto abort;
+        }
+
+        if (!wait_for_completion_timeout(&wm0010->boot_completion,
+                                         msecs_to_jiffies(10)))
+                dev_err(codec->dev, "Failed to get interrupt from DSP\n");
+
+        spin_lock_irqsave(&wm0010->irq_lock, flags);
+        wm0010->state = WM0010_BOOTROM;
+        spin_unlock_irqrestore(&wm0010->irq_lock, flags);
+
+        dev_dbg(codec->dev, "Downloading %zu byte stage 2 loader\n", fw->size);
+
+        /* Copy to local buffer first as vmalloc causes problems for dma */
+        img = kzalloc(fw->size, GFP_KERNEL);
+        if (!img) {
+                dev_err(codec->dev, "Failed to allocate image buffer\n");
+                goto abort;
+        }
+
+        out = kzalloc(fw->size, GFP_KERNEL);
+        if (!out) {
+                dev_err(codec->dev, "Failed to allocate output buffer\n");
+                goto abort;
+        }
+
+        memcpy(img, &fw->data[0], fw->size);
+
+        spi_message_init(&m);
+        memset(&t, 0, sizeof(t));
+        t.rx_buf = out;
+        t.tx_buf = img;
+        t.len = fw->size;
+        t.bits_per_word = 8;
+        t.speed_hz = wm0010->sysclk / 10;
+        spi_message_add_tail(&t, &m);
+
+        dev_dbg(codec->dev, "Starting initial download at %dHz\n",
+                t.speed_hz);
+
+        ret = spi_sync(spi, &m);
+        if (ret != 0) {
+                dev_err(codec->dev, "Initial download failed: %d\n", ret);
+                goto abort;
+        }
+
+        /* Look for errors from the boot ROM */
+        for (i = 0; i < fw->size; i++) {
+                if (out[i] != 0x55) {
+                        ret = -EBUSY;
+                        dev_err(codec->dev, "Boot ROM error: %x in %d\n",
+                                out[i], i);
+                        wm0010_mark_boot_failure(wm0010);
+                        goto abort;
+                }
+        }
+
+        release_firmware(fw);
+        kfree(img);
+        kfree(out);
+
+        if (!wait_for_completion_timeout(&wm0010->boot_completion,
+                                         msecs_to_jiffies(10)))
+                dev_err(codec->dev, "Failed to get interrupt from DSP loader.\n");
+
+        spin_lock_irqsave(&wm0010->irq_lock, flags);
+        wm0010->state = WM0010_STAGE2;
+        spin_unlock_irqrestore(&wm0010->irq_lock, flags);
+
+        /* Only initialise PLL if max_spi_freq initialised */
+        if (wm0010->max_spi_freq) {
+
+                /* Initialise a PLL record */
+                memset(&pll_rec, 0, sizeof(pll_rec));
+                pll_rec.command = DFW_CMD_PLL;
+                pll_rec.length = (sizeof(pll_rec) - 8);
+
+                /* On wm0010 only the CLKCTRL1 value is used */
+                pll_rec.clkctrl1 = wm0010->pll_clkctrl1;
+
+                len = pll_rec.length + 8;
+                out = kzalloc(len, GFP_KERNEL);
+                if (!out) {
+                        dev_err(codec->dev,
+                                "Failed to allocate RX buffer\n");
+                        goto abort;
+                }
+
+                img_swap = kzalloc(len, GFP_KERNEL);
+                if (!img_swap) {
+                        dev_err(codec->dev,
+                                "Failed to allocate image buffer\n");
+                        goto abort;
+                }
+
+                /* We need to re-order for 0010 */
+                byte_swap_64((u64 *)&pll_rec, img_swap, len);
+
+                spi_message_init(&m);
+                memset(&t, 0, sizeof(t));
+                t.rx_buf = out;
+                t.tx_buf = img_swap;
+                t.len = len;
+                t.bits_per_word = 8;
+                t.speed_hz = wm0010->sysclk / 6;
+                spi_message_add_tail(&t, &m);
+
+                ret = spi_sync(spi, &m);
+                if (ret != 0) {
+                        dev_err(codec->dev, "First PLL write failed: %d\n", ret);
+                        goto abort;
+                }
+
+                /* Use a second send of the message to get the return status */
+                ret = spi_sync(spi, &m);
+                if (ret != 0) {
+                        dev_err(codec->dev, "Second PLL write failed: %d\n", ret);
+                        goto abort;
+                }
+
+                p = (u32 *)out;
+
+                /* Look for PLL active code from the DSP */
+                for (i = 0; i < len / 4; i++) {
+                        if (*p == 0x0e00ed0f) {
+                                dev_dbg(codec->dev, "PLL packet received\n");
+                                wm0010->pll_running = true;
+                                break;
+                        }
+                        p++;
+                }
+
+                kfree(img_swap);
+                kfree(out);
+        } else
+                dev_dbg(codec->dev, "Not enabling DSP PLL.");
+
+        ret = request_firmware(&fw, "wm0010.dfw", codec->dev);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to request application: %d\n",
+                        ret);
+                goto abort;
+        }
+
+        rec = (const struct dfw_binrec *)fw->data;
+        offset = 0;
+        wm0010->boot_done = 0;
+        wm0010->boot_failed = false;
+        BUG_ON(!list_empty(&xfer_list));
+        init_completion(&done);
+
+        /* First record should be INFO */
+        if (rec->command != DFW_CMD_INFO) {
+                dev_err(codec->dev, "First record not INFO\r\n");
+                goto abort;
+        }
+
+        /* Check it's a 0010 file */
+        if (rec->data[0] != DEVICE_ID_WM0010) {
+                dev_err(codec->dev, "Not a WM0010 firmware file.\r\n");
+                goto abort;
+        }
+
+        /* Skip the info record as we don't need to send it */
+        offset += ((rec->length) + 8);
+        rec = (void *)&rec->data[rec->length];
+
+        while (offset < fw->size) {
+                dev_dbg(codec->dev,
+                        "Packet: command %d, data length = 0x%x\r\n",
+                        rec->command, rec->length);
+                len = rec->length + 8;
+
+                out = kzalloc(len, GFP_KERNEL);
+                if (!out) {
+                        dev_err(codec->dev,
+                                "Failed to allocate RX buffer\n");
+                        goto abort;
+                }
+
+                img_swap = kzalloc(len, GFP_KERNEL);
+                if (!img_swap) {
+                        dev_err(codec->dev,
+                                "Failed to allocate image buffer\n");
+                        goto abort;
+                }
+
+                /* We need to re-order for 0010 */
+                byte_swap_64((u64 *)&rec->command, img_swap, len);
+
+                xfer = kzalloc(sizeof(*xfer), GFP_KERNEL);
+                if (!xfer) {
+                        dev_err(codec->dev, "Failed to allocate xfer\n");
+                        goto abort;
+                }
+
+                xfer->codec = codec;
+                list_add_tail(&xfer->list, &xfer_list);
+
+                spi_message_init(&xfer->m);
+                xfer->m.complete = wm0010_boot_xfer_complete;
+                xfer->m.context = xfer;
+                xfer->t.tx_buf = img_swap;
+                xfer->t.rx_buf = out;
+                xfer->t.len = len;
+                xfer->t.bits_per_word = 8;
+
+                if (!wm0010->pll_running) {
+                        xfer->t.speed_hz = wm0010->sysclk / 6;
+                } else {
+                        xfer->t.speed_hz = wm0010->max_spi_freq;
+
+                        if (wm0010->board_max_spi_speed &&
+                           (wm0010->board_max_spi_speed < wm0010->max_spi_freq))
+                                        xfer->t.speed_hz = wm0010->board_max_spi_speed;
+                }
+
+                /* Store max usable spi frequency for later use */
+                wm0010->max_spi_freq = xfer->t.speed_hz;
+
+                spi_message_add_tail(&xfer->t, &xfer->m);
+
+                offset += ((rec->length) + 8);
+                rec = (void *)&rec->data[rec->length];
+
+                if (offset >= fw->size) {
+                        dev_dbg(codec->dev, "All transfers scheduled\n");
+                        xfer->done = &done;
+                }
+
+                ret = spi_async(spi, &xfer->m);
+                if (ret != 0) {
+                        dev_err(codec->dev, "Write failed: %d\n", ret);
+                        goto abort;
+                }
+
+                if (wm0010->boot_failed)
+                        goto abort;
+        }
+
+        wait_for_completion(&done);
+
+        spin_lock_irqsave(&wm0010->irq_lock, flags);
+        wm0010->state = WM0010_FIRMWARE;
+        spin_unlock_irqrestore(&wm0010->irq_lock, flags);
+
+        mutex_unlock(&wm0010->lock);
+
+        release_firmware(fw);
+
+        while (!list_empty(&xfer_list)) {
+                xfer = list_first_entry(&xfer_list, struct wm0010_boot_xfer,
+                                        list);
+                kfree(xfer->t.rx_buf);
+                kfree(xfer->t.tx_buf);
+                list_del(&xfer->list);
+                kfree(xfer);
+        }
+
+        return 0;
+
+abort:
+        /* Put the chip back into reset */
+        wm0010_halt(codec);
+        mutex_unlock(&wm0010->lock);
+        return ret;
+
+err_core:
+        mutex_unlock(&wm0010->lock);
+        regulator_bulk_disable(ARRAY_SIZE(wm0010->core_supplies),
+                               wm0010->core_supplies);
+err:
+        return ret;
+}
+
+static int wm0010_set_bias_level(struct snd_soc_codec *codec,
+                                 enum snd_soc_bias_level level)
+{
+        struct wm0010_priv *wm0010 = snd_soc_codec_get_drvdata(codec);
+
+        switch (level) {
+        case SND_SOC_BIAS_ON:
+                if (codec->dapm.bias_level == SND_SOC_BIAS_PREPARE)
+                        wm0010_boot(codec);
+                break;
+        case SND_SOC_BIAS_PREPARE:
+                break;
+        case SND_SOC_BIAS_STANDBY:
+                if (codec->dapm.bias_level == SND_SOC_BIAS_PREPARE) {
+                        mutex_lock(&wm0010->lock);
+                        wm0010_halt(codec);
+                        mutex_unlock(&wm0010->lock);
+                }
+                break;
+        case SND_SOC_BIAS_OFF:
+                break;
+        }
+
+        codec->dapm.bias_level = level;
+
+        return 0;
+}
+
+static int wm0010_set_sysclk(struct snd_soc_codec *codec, int source,
+                             int clk_id, unsigned int freq, int dir)
+{
+        struct wm0010_priv *wm0010 = snd_soc_codec_get_drvdata(codec);
+        unsigned int i;
+
+        wm0010->sysclk = freq;
+
+        if (freq < pll_clock_map[ARRAY_SIZE(pll_clock_map)-1].max_sysclk) {
+                wm0010->max_spi_freq = 0;
+        } else {
+                for (i = 0; i < ARRAY_SIZE(pll_clock_map); i++)
+                        if (freq >= pll_clock_map[i].max_sysclk)
+                                break;
+
+                wm0010->max_spi_freq = pll_clock_map[i].max_pll_spi_speed;
+                wm0010->pll_clkctrl1 = pll_clock_map[i].pll_clkctrl1;
+        }
+
+        return 0;
+}
+
+static int wm0010_probe(struct snd_soc_codec *codec);
+
+static struct snd_soc_codec_driver soc_codec_dev_wm0010 = {
+        .probe = wm0010_probe,
+        .set_bias_level = wm0010_set_bias_level,
+        .set_sysclk = wm0010_set_sysclk,
+        .idle_bias_off = true,
+
+        .dapm_widgets = wm0010_dapm_widgets,
+        .num_dapm_widgets = ARRAY_SIZE(wm0010_dapm_widgets),
+        .dapm_routes = wm0010_dapm_routes,
+        .num_dapm_routes = ARRAY_SIZE(wm0010_dapm_routes),
+};
+
+#define WM0010_RATES (SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000)
+#define WM0010_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_driver wm0010_dai[] = {
+        {
+                .name = "wm0010-sdi1",
+                .playback = {
+                        .stream_name = "SDI1 Playback",
+                        .channels_min = 1,
+                        .channels_max = 2,
+                        .rates = WM0010_RATES,
+                        .formats = WM0010_FORMATS,
+                },
+                .capture = {
+                         .stream_name = "SDI1 Capture",
+                         .channels_min = 1,
+                         .channels_max = 2,
+                         .rates = WM0010_RATES,
+                         .formats = WM0010_FORMATS,
+                 },
+        },
+        {
+                .name = "wm0010-sdi2",
+                .playback = {
+                        .stream_name = "SDI2 Playback",
+                        .channels_min = 1,
+                        .channels_max = 2,
+                        .rates = WM0010_RATES,
+                        .formats = WM0010_FORMATS,
+                },
+                .capture = {
+                         .stream_name = "SDI2 Capture",
+                         .channels_min = 1,
+                         .channels_max = 2,
+                         .rates = WM0010_RATES,
+                         .formats = WM0010_FORMATS,
+                 },
+        },
+};
+
+static irqreturn_t wm0010_irq(int irq, void *data)
+{
+        struct wm0010_priv *wm0010 = data;
+
+        switch (wm0010->state) {
+        case WM0010_POWER_OFF:
+        case WM0010_OUT_OF_RESET:
+        case WM0010_BOOTROM:
+        case WM0010_STAGE2:
+                spin_lock(&wm0010->irq_lock);
+                complete(&wm0010->boot_completion);
+                spin_unlock(&wm0010->irq_lock);
+                return IRQ_HANDLED;
+        default:
+                return IRQ_NONE;
+        }
+
+        return IRQ_NONE;
+}
+
+static int wm0010_probe(struct snd_soc_codec *codec)
+{
+        struct wm0010_priv *wm0010 = snd_soc_codec_get_drvdata(codec);
+
+        wm0010->codec = codec;
+
+        return 0;
+}
+
+static int __devinit wm0010_spi_probe(struct spi_device *spi)
+{
+        unsigned long flags;
+        unsigned long gpio_flags;
+        int ret;
+        int trigger;
+        int irq;
+        struct wm0010_priv *wm0010;
+
+        wm0010 = devm_kzalloc(&spi->dev, sizeof(*wm0010),
+                              GFP_KERNEL);
+        if (!wm0010)
+                return -ENOMEM;
+
+        mutex_init(&wm0010->lock);
+        spin_lock_init(&wm0010->irq_lock);
+
+        spi_set_drvdata(spi, wm0010);
+        wm0010->dev = &spi->dev;
+
+        if (dev_get_platdata(&spi->dev))
+                memcpy(&wm0010->pdata, dev_get_platdata(&spi->dev),
+                       sizeof(wm0010->pdata));
+
+        init_completion(&wm0010->boot_completion);
+
+        wm0010->core_supplies[0].supply = "AVDD";
+        wm0010->core_supplies[1].supply = "DCVDD";
+        ret = devm_regulator_bulk_get(wm0010->dev, ARRAY_SIZE(wm0010->core_supplies),
+                                      wm0010->core_supplies);
+        if (ret != 0) {
+                dev_err(wm0010->dev, "Failed to obtain core supplies: %d\n",
+                        ret);
+                return ret;
+        }
+
+        wm0010->dbvdd = devm_regulator_get(wm0010->dev, "DBVDD");
+        if (IS_ERR(wm0010->dbvdd)) {
+                ret = PTR_ERR(wm0010->dbvdd);
+                dev_err(wm0010->dev, "Failed to obtain DBVDD: %d\n", ret);
+                return ret;
+        }
+
+        if (wm0010->pdata.gpio_reset) {
+                wm0010->gpio_reset = wm0010->pdata.gpio_reset;
+
+                if (wm0010->pdata.reset_active_high)
+                        wm0010->gpio_reset_value = 1;
+                else
+                        wm0010->gpio_reset_value = 0;
+
+                if (wm0010->gpio_reset_value)
+                        gpio_flags = GPIOF_OUT_INIT_HIGH;
+                else
+                        gpio_flags = GPIOF_OUT_INIT_LOW;
+
+                ret = devm_gpio_request_one(wm0010->dev, wm0010->gpio_reset,
+                                            gpio_flags, "wm0010 reset");
+                if (ret < 0) {
+                        dev_err(wm0010->dev,
+                                "Failed to request GPIO for DSP reset: %d\n",
+                                ret);
+                        return ret;
+                }
+        } else {
+                dev_err(wm0010->dev, "No reset GPIO configured\n");
+                return -EINVAL;
+        }
+
+        irq = spi->irq;
+        if (wm0010->pdata.irq_flags)
+                trigger = wm0010->pdata.irq_flags;
+        else
+                trigger = IRQF_TRIGGER_FALLING;
+        trigger |= IRQF_ONESHOT;
+
+        ret = request_threaded_irq(irq, NULL, wm0010_irq, trigger | IRQF_ONESHOT,
+                                   "wm0010", wm0010);
+        if (ret) {
+                dev_err(wm0010->dev, "Failed to request IRQ %d: %d\n",
+                        irq, ret);
+                return ret;
+        }
+        wm0010->irq = irq;
+
+        if (spi->max_speed_hz)
+                wm0010->board_max_spi_speed = spi->max_speed_hz;
+        else
+                wm0010->board_max_spi_speed = 0;
+
+        spin_lock_irqsave(&wm0010->irq_lock, flags);
+        wm0010->state = WM0010_POWER_OFF;
+        spin_unlock_irqrestore(&wm0010->irq_lock, flags);
+
+        ret = snd_soc_register_codec(&spi->dev,
+                                     &soc_codec_dev_wm0010, wm0010_dai,
+                                     ARRAY_SIZE(wm0010_dai));
+        if (ret < 0)
+                return ret;
+
+        return 0;
+}
+
+static int __devexit wm0010_spi_remove(struct spi_device *spi)
+{
+        struct wm0010_priv *wm0010 = spi_get_drvdata(spi);
+
+        snd_soc_unregister_codec(&spi->dev);
+
+        if (wm0010->gpio_reset) {
+                /* Remember to put chip back into reset */
+                gpio_set_value(wm0010->gpio_reset, wm0010->gpio_reset_value);
+        }
+
+        if (wm0010->irq)
+                free_irq(wm0010->irq, wm0010);
+
+        return 0;
+}
+
+static struct spi_driver wm0010_spi_driver = {
+        .driver = {
+                .name   = "wm0010",
+                .bus    = &spi_bus_type,
+                .owner  = THIS_MODULE,
+        },
+        .probe          = wm0010_spi_probe,
+        .remove         = __devexit_p(wm0010_spi_remove),
+};
+
+module_spi_driver(wm0010_spi_driver);
+
+MODULE_DESCRIPTION("ASoC WM0010 driver");
+MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/codecs/wm2000.c b/sound/soc/codecs/wm2000.c
index 3fd5b29dc933..89cd6fcad015 100644
--- a/sound/soc/codecs/wm2000.c
+++ b/sound/soc/codecs/wm2000.c
@@ -858,17 +858,7 @@ static struct i2c_driver wm2000_i2c_driver = {
         .id_table = wm2000_i2c_id,
 };
 
-static int __init wm2000_init(void)
-{
-        return i2c_add_driver(&wm2000_i2c_driver);
-}
-module_init(wm2000_init);
-
-static void __exit wm2000_exit(void)
-{
-        i2c_del_driver(&wm2000_i2c_driver);
-}
-module_exit(wm2000_exit);
+module_i2c_driver(wm2000_i2c_driver);
 
 MODULE_DESCRIPTION("ASoC WM2000 driver");
 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfonmicro.com>");
diff --git a/sound/soc/codecs/wm2200.c b/sound/soc/codecs/wm2200.c
index 32682c1b7cde..efa93dbb0191 100644
--- a/sound/soc/codecs/wm2200.c
+++ b/sound/soc/codecs/wm2200.c
@@ -1117,8 +1117,8 @@ SND_SOC_DAPM_SUPPLY("MICBIAS1", WM2200_MIC_BIAS_CTRL_1, WM2200_MICB1_ENA_SHIFT,
                     0, NULL, 0),
 SND_SOC_DAPM_SUPPLY("MICBIAS2", WM2200_MIC_BIAS_CTRL_2, WM2200_MICB2_ENA_SHIFT,
                     0, NULL, 0),
-SND_SOC_DAPM_REGULATOR_SUPPLY("CPVDD", 20),
-SND_SOC_DAPM_REGULATOR_SUPPLY("AVDD", 20),
+SND_SOC_DAPM_REGULATOR_SUPPLY("CPVDD", 20, 0),
+SND_SOC_DAPM_REGULATOR_SUPPLY("AVDD", 20, 0),
 
 SND_SOC_DAPM_INPUT("IN1L"),
 SND_SOC_DAPM_INPUT("IN1R"),
@@ -2270,17 +2270,7 @@ static struct i2c_driver wm2200_i2c_driver = {
         .id_table = wm2200_i2c_id,
 };
 
-static int __init wm2200_modinit(void)
-{
-        return i2c_add_driver(&wm2200_i2c_driver);
-}
-module_init(wm2200_modinit);
-
-static void __exit wm2200_exit(void)
-{
-        i2c_del_driver(&wm2200_i2c_driver);
-}
-module_exit(wm2200_exit);
+module_i2c_driver(wm2200_i2c_driver);
 
 MODULE_DESCRIPTION("ASoC WM2200 driver");
 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
diff --git a/sound/soc/codecs/wm5100.c b/sound/soc/codecs/wm5100.c
index f4817292ef45..4da1b92b22c2 100644
--- a/sound/soc/codecs/wm5100.c
+++ b/sound/soc/codecs/wm5100.c
@@ -848,9 +848,9 @@ SND_SOC_DAPM_SUPPLY("SYSCLK", WM5100_CLOCKING_3, WM5100_SYSCLK_ENA_SHIFT, 0,
 SND_SOC_DAPM_SUPPLY("ASYNCCLK", WM5100_CLOCKING_6, WM5100_ASYNC_CLK_ENA_SHIFT,
                     0, NULL, 0),
 
-SND_SOC_DAPM_REGULATOR_SUPPLY("CPVDD", 20),
-SND_SOC_DAPM_REGULATOR_SUPPLY("DBVDD2", 0),
-SND_SOC_DAPM_REGULATOR_SUPPLY("DBVDD3", 0),
+SND_SOC_DAPM_REGULATOR_SUPPLY("CPVDD", 20, 0),
+SND_SOC_DAPM_REGULATOR_SUPPLY("DBVDD2", 0, 0),
+SND_SOC_DAPM_REGULATOR_SUPPLY("DBVDD3", 0, 0),
 
 SND_SOC_DAPM_SUPPLY("CP1", WM5100_HP_CHARGE_PUMP_1, WM5100_CP1_ENA_SHIFT, 0,
                     NULL, 0),
diff --git a/sound/soc/codecs/wm5102.c b/sound/soc/codecs/wm5102.c
index e33d327396ad..4a2db4e10885 100644
--- a/sound/soc/codecs/wm5102.c
+++ b/sound/soc/codecs/wm5102.c
@@ -274,18 +274,43 @@ ARIZONA_MIXER_ENUMS(ASRC1R, ARIZONA_ASRC1RMIX_INPUT_1_SOURCE);
 ARIZONA_MIXER_ENUMS(ASRC2L, ARIZONA_ASRC2LMIX_INPUT_1_SOURCE);
 ARIZONA_MIXER_ENUMS(ASRC2R, ARIZONA_ASRC2RMIX_INPUT_1_SOURCE);
 
+
+static const char *wm5102_aec_loopback_texts[] = {
+        "HPOUT1L", "HPOUT1R", "HPOUT2L", "HPOUT2R", "EPOUT",
+        "SPKOUTL", "SPKOUTR", "SPKDAT1L", "SPKDAT1R",
+};
+
+static const unsigned int wm5102_aec_loopback_values[] = {
+        0, 1, 2, 3, 4, 6, 7, 8, 9,
+};
+
+static const struct soc_enum wm5102_aec_loopback =
+        SOC_VALUE_ENUM_SINGLE(ARIZONA_DAC_AEC_CONTROL_1,
+                              ARIZONA_AEC_LOOPBACK_SRC_SHIFT,
+                              ARIZONA_AEC_LOOPBACK_SRC_MASK,
+                              ARRAY_SIZE(wm5102_aec_loopback_texts),
+                              wm5102_aec_loopback_texts,
+                              wm5102_aec_loopback_values);
+
+static const struct snd_kcontrol_new wm5102_aec_loopback_mux =
+        SOC_DAPM_VALUE_ENUM("AEC Loopback", wm5102_aec_loopback);
+
 static const struct snd_soc_dapm_widget wm5102_dapm_widgets[] = {
 SND_SOC_DAPM_SUPPLY("SYSCLK", ARIZONA_SYSTEM_CLOCK_1, ARIZONA_SYSCLK_ENA_SHIFT,
                     0, NULL, 0),
 SND_SOC_DAPM_SUPPLY("ASYNCCLK", ARIZONA_ASYNC_CLOCK_1,
                     ARIZONA_ASYNC_CLK_ENA_SHIFT, 0, NULL, 0),
-
-SND_SOC_DAPM_REGULATOR_SUPPLY("DBVDD2", 0),
-SND_SOC_DAPM_REGULATOR_SUPPLY("DBVDD3", 0),
-SND_SOC_DAPM_REGULATOR_SUPPLY("CPVDD", 20),
-SND_SOC_DAPM_REGULATOR_SUPPLY("MICVDD", 0),
-SND_SOC_DAPM_REGULATOR_SUPPLY("SPKVDDL", 0),
-SND_SOC_DAPM_REGULATOR_SUPPLY("SPKVDDR", 0),
+SND_SOC_DAPM_SUPPLY("OPCLK", ARIZONA_OUTPUT_SYSTEM_CLOCK,
+                    ARIZONA_OPCLK_ENA_SHIFT, 0, NULL, 0),
+SND_SOC_DAPM_SUPPLY("ASYNCOPCLK", ARIZONA_OUTPUT_ASYNC_CLOCK,
+                    ARIZONA_OPCLK_ASYNC_ENA_SHIFT, 0, NULL, 0),
+
+SND_SOC_DAPM_REGULATOR_SUPPLY("DBVDD2", 0, 0),
+SND_SOC_DAPM_REGULATOR_SUPPLY("DBVDD3", 0, 0),
+SND_SOC_DAPM_REGULATOR_SUPPLY("CPVDD", 20, 0),
+SND_SOC_DAPM_REGULATOR_SUPPLY("MICVDD", 0, 0),
+SND_SOC_DAPM_REGULATOR_SUPPLY("SPKVDDL", 0, 0),
+SND_SOC_DAPM_REGULATOR_SUPPLY("SPKVDDR", 0, 0),
 
 SND_SOC_DAPM_SIGGEN("TONE"),
 SND_SOC_DAPM_SIGGEN("NOISE"),
@@ -421,6 +446,9 @@ SND_SOC_DAPM_AIF_IN("AIF3RX1", NULL, 0,
 SND_SOC_DAPM_AIF_IN("AIF3RX2", NULL, 0,
                     ARIZONA_AIF3_RX_ENABLES, ARIZONA_AIF3RX2_ENA_SHIFT, 0),
 
+SND_SOC_DAPM_VALUE_MUX("AEC Loopback", ARIZONA_DAC_AEC_CONTROL_1,
+                       ARIZONA_AEC_LOOPBACK_ENA, 0, &wm5102_aec_loopback_mux),
+
 SND_SOC_DAPM_PGA_E("OUT1L", ARIZONA_OUTPUT_ENABLES_1,
                    ARIZONA_OUT1L_ENA_SHIFT, 0, NULL, 0, arizona_out_ev,
                    SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
@@ -516,6 +544,7 @@ SND_SOC_DAPM_OUTPUT("SPKDAT1R"),
         { name, "Noise Generator", "Noise Generator" }, \
         { name, "Tone Generator 1", "Tone Generator 1" }, \
         { name, "Tone Generator 2", "Tone Generator 2" }, \
+        { name, "AEC", "AEC Loopback" }, \
         { name, "IN1L", "IN1L PGA" }, \
         { name, "IN1R", "IN1R PGA" }, \
         { name, "IN2L", "IN2L PGA" }, \
@@ -681,21 +710,30 @@ static const struct snd_soc_dapm_route wm5102_dapm_routes[] = {
         ARIZONA_MIXER_ROUTES("ASRC2L", "ASRC2L"),
         ARIZONA_MIXER_ROUTES("ASRC2R", "ASRC2R"),
 
+        { "AEC Loopback", "HPOUT1L", "OUT1L" },
+        { "AEC Loopback", "HPOUT1R", "OUT1R" },
         { "HPOUT1L", NULL, "OUT1L" },
         { "HPOUT1R", NULL, "OUT1R" },
 
+        { "AEC Loopback", "HPOUT2L", "OUT2L" },
+        { "AEC Loopback", "HPOUT2R", "OUT2R" },
         { "HPOUT2L", NULL, "OUT2L" },
         { "HPOUT2R", NULL, "OUT2R" },
 
+        { "AEC Loopback", "EPOUT", "OUT3L" },
         { "EPOUTN", NULL, "OUT3L" },
         { "EPOUTP", NULL, "OUT3L" },
 
+        { "AEC Loopback", "SPKOUTL", "OUT4L" },
         { "SPKOUTLN", NULL, "OUT4L" },
         { "SPKOUTLP", NULL, "OUT4L" },
 
+        { "AEC Loopback", "SPKOUTR", "OUT4R" },
         { "SPKOUTRN", NULL, "OUT4R" },
         { "SPKOUTRP", NULL, "OUT4R" },
 
+        { "AEC Loopback", "SPKDAT1L", "OUT5L" },
+        { "AEC Loopback", "SPKDAT1R", "OUT5R" },
         { "SPKDAT1L", NULL, "OUT5L" },
         { "SPKDAT1R", NULL, "OUT5R" },
 };
diff --git a/sound/soc/codecs/wm5110.c b/sound/soc/codecs/wm5110.c
index 01ebbcc5c6a4..bf47914234b3 100644
--- a/sound/soc/codecs/wm5110.c
+++ b/sound/soc/codecs/wm5110.c
@@ -305,13 +305,17 @@ SND_SOC_DAPM_SUPPLY("SYSCLK", ARIZONA_SYSTEM_CLOCK_1, ARIZONA_SYSCLK_ENA_SHIFT,
                     0, NULL, 0),
 SND_SOC_DAPM_SUPPLY("ASYNCCLK", ARIZONA_ASYNC_CLOCK_1,
                     ARIZONA_ASYNC_CLK_ENA_SHIFT, 0, NULL, 0),
-
-SND_SOC_DAPM_REGULATOR_SUPPLY("DBVDD2", 0),
-SND_SOC_DAPM_REGULATOR_SUPPLY("DBVDD3", 0),
-SND_SOC_DAPM_REGULATOR_SUPPLY("CPVDD", 20),
-SND_SOC_DAPM_REGULATOR_SUPPLY("MICVDD", 0),
-SND_SOC_DAPM_REGULATOR_SUPPLY("SPKVDDL", 0),
-SND_SOC_DAPM_REGULATOR_SUPPLY("SPKVDDR", 0),
+SND_SOC_DAPM_SUPPLY("OPCLK", ARIZONA_OUTPUT_SYSTEM_CLOCK,
+                    ARIZONA_OPCLK_ENA_SHIFT, 0, NULL, 0),
+SND_SOC_DAPM_SUPPLY("ASYNCOPCLK", ARIZONA_OUTPUT_ASYNC_CLOCK,
+                    ARIZONA_OPCLK_ASYNC_ENA_SHIFT, 0, NULL, 0),
+
+SND_SOC_DAPM_REGULATOR_SUPPLY("DBVDD2", 0, 0),
+SND_SOC_DAPM_REGULATOR_SUPPLY("DBVDD3", 0, 0),
+SND_SOC_DAPM_REGULATOR_SUPPLY("CPVDD", 20, 0),
+SND_SOC_DAPM_REGULATOR_SUPPLY("MICVDD", 0, 0),
+SND_SOC_DAPM_REGULATOR_SUPPLY("SPKVDDL", 0, 0),
+SND_SOC_DAPM_REGULATOR_SUPPLY("SPKVDDR", 0, 0),
 
 SND_SOC_DAPM_SIGGEN("TONE"),
 SND_SOC_DAPM_SIGGEN("NOISE"),
diff --git a/sound/soc/codecs/wm8510.c b/sound/soc/codecs/wm8510.c
index 56a049555e2c..c12a54e72e89 100644
--- a/sound/soc/codecs/wm8510.c
+++ b/sound/soc/codecs/wm8510.c
@@ -20,6 +20,7 @@
 #include <linux/spi/spi.h>
 #include <linux/slab.h>
 #include <linux/of_device.h>
+#include <linux/regmap.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
@@ -33,24 +34,75 @@
  * We can't read the WM8510 register space when we are
  * using 2 wire for device control, so we cache them instead.
  */
-static const u16 wm8510_reg[WM8510_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, 0x0001, 0x0000,
-        0x0000, 0x0000, 0x0039, 0x0000,
-        0x0001,
+static const struct reg_default wm8510_reg_defaults[] = {
+        {  1, 0x0000 },
+        {  2, 0x0000 },
+        {  3, 0x0000 },
+        {  4, 0x0050 },
+        {  5, 0x0000 },
+        {  6, 0x0140 },
+        {  7, 0x0000 },
+        {  8, 0x0000 },
+        {  9, 0x0000 },
+        { 10, 0x0000 },
+        { 11, 0x00ff },
+        { 12, 0x0000 },
+        { 13, 0x0000 },
+        { 14, 0x0100 },
+        { 15, 0x00ff },
+        { 16, 0x0000 },
+        { 17, 0x0000 },
+        { 18, 0x012c },
+        { 19, 0x002c },
+        { 20, 0x002c },
+        { 21, 0x002c },
+        { 22, 0x002c },
+        { 23, 0x0000 },
+        { 24, 0x0032 },
+        { 25, 0x0000 },
+        { 26, 0x0000 },
+        { 27, 0x0000 },
+        { 28, 0x0000 },
+        { 29, 0x0000 },
+        { 30, 0x0000 },
+        { 31, 0x0000 },
+        { 32, 0x0038 },
+        { 33, 0x000b },
+        { 34, 0x0032 },
+        { 35, 0x0000 },
+        { 36, 0x0008 },
+        { 37, 0x000c },
+        { 38, 0x0093 },
+        { 39, 0x00e9 },
+        { 40, 0x0000 },
+        { 41, 0x0000 },
+        { 42, 0x0000 },
+        { 43, 0x0000 },
+        { 44, 0x0003 },
+        { 45, 0x0010 },
+        { 46, 0x0000 },
+        { 47, 0x0000 },
+        { 48, 0x0000 },
+        { 49, 0x0002 },
+        { 50, 0x0001 },
+        { 51, 0x0000 },
+        { 52, 0x0000 },
+        { 53, 0x0000 },
+        { 54, 0x0039 },
+        { 55, 0x0000 },
+        { 56, 0x0001 },
 };
 
+static bool wm8510_volatile(struct device *dev, unsigned int reg)
+{
+        switch (reg) {
+        case WM8510_RESET:
+                return true;
+        default:
+                return false;
+        }
+}
+
 #define WM8510_POWER1_BIASEN  0x08
 #define WM8510_POWER1_BUFIOEN 0x10
 
@@ -58,7 +110,7 @@ static const u16 wm8510_reg[WM8510_CACHEREGNUM] = {
 
 /* codec private data */
 struct wm8510_priv {
-        enum snd_soc_control_type control_type;
+        struct regmap *regmap;
 };
 
 static const char *wm8510_companding[] = { "Off", "NC", "u-law", "A-law" };
@@ -454,6 +506,7 @@ 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)
 {
+        struct wm8510_priv *wm8510 = snd_soc_codec_get_drvdata(codec);
         u16 power1 = snd_soc_read(codec, WM8510_POWER1) & ~0x3;
 
         switch (level) {
@@ -467,7 +520,7 @@ static int wm8510_set_bias_level(struct snd_soc_codec *codec,
                 power1 |= WM8510_POWER1_BIASEN | WM8510_POWER1_BUFIOEN;
 
                 if (codec->dapm.bias_level == SND_SOC_BIAS_OFF) {
-                        snd_soc_cache_sync(codec);
+                        regcache_sync(wm8510->regmap);
 
                         /* Initial cap charge at VMID 5k */
                         snd_soc_write(codec, WM8510_POWER1, power1 | 0x3);
@@ -536,10 +589,9 @@ static int wm8510_resume(struct snd_soc_codec *codec)
 
 static int wm8510_probe(struct snd_soc_codec *codec)
 {
-        struct wm8510_priv *wm8510 = snd_soc_codec_get_drvdata(codec);
         int ret;
 
-        ret = snd_soc_codec_set_cache_io(codec, 7, 9,  wm8510->control_type);
+        ret = snd_soc_codec_set_cache_io(codec, 7, 9, SND_SOC_REGMAP);
         if (ret < 0) {
                 printk(KERN_ERR "wm8510: failed to set cache I/O: %d\n", ret);
                 return ret;
@@ -569,9 +621,6 @@ static struct snd_soc_codec_driver soc_codec_dev_wm8510 = {
         .suspend =      wm8510_suspend,
         .resume =       wm8510_resume,
         .set_bias_level = wm8510_set_bias_level,
-        .reg_cache_size = ARRAY_SIZE(wm8510_reg),
-        .reg_word_size = sizeof(u16),
-        .reg_cache_default =wm8510_reg,
 
         .controls = wm8510_snd_controls,
         .num_controls = ARRAY_SIZE(wm8510_snd_controls),
@@ -586,23 +635,38 @@ static const struct of_device_id wm8510_of_match[] = {
         { },
 };
 
+static const struct regmap_config wm8510_regmap = {
+        .reg_bits = 7,
+        .val_bits = 9,
+        .max_register = WM8510_MONOMIX,
+
+        .reg_defaults = wm8510_reg_defaults,
+        .num_reg_defaults = ARRAY_SIZE(wm8510_reg_defaults),
+        .cache_type = REGCACHE_RBTREE,
+
+        .volatile_reg = wm8510_volatile,
+};
+
 #if defined(CONFIG_SPI_MASTER)
 static int __devinit wm8510_spi_probe(struct spi_device *spi)
 {
         struct wm8510_priv *wm8510;
         int ret;
 
-        wm8510 = kzalloc(sizeof(struct wm8510_priv), GFP_KERNEL);
+        wm8510 = devm_kzalloc(&spi->dev, sizeof(struct wm8510_priv),
+                              GFP_KERNEL);
         if (wm8510 == NULL)
                 return -ENOMEM;
 
-        wm8510->control_type = SND_SOC_SPI;
+        wm8510->regmap = devm_regmap_init_spi(spi, &wm8510_regmap);
+        if (IS_ERR(wm8510->regmap))
+                return PTR_ERR(wm8510->regmap);
+
         spi_set_drvdata(spi, wm8510);
 
         ret = snd_soc_register_codec(&spi->dev,
                         &soc_codec_dev_wm8510, &wm8510_dai, 1);
-        if (ret < 0)
-                kfree(wm8510);
+
         return ret;
 }
 
@@ -630,17 +694,20 @@ static __devinit int wm8510_i2c_probe(struct i2c_client *i2c,
         struct wm8510_priv *wm8510;
         int ret;
 
-        wm8510 = kzalloc(sizeof(struct wm8510_priv), GFP_KERNEL);
+        wm8510 = devm_kzalloc(&i2c->dev, sizeof(struct wm8510_priv),
+                              GFP_KERNEL);
         if (wm8510 == NULL)
                 return -ENOMEM;
 
+        wm8510->regmap = devm_regmap_init_i2c(i2c, &wm8510_regmap);
+        if (IS_ERR(wm8510->regmap))
+                return PTR_ERR(wm8510->regmap);
+
         i2c_set_clientdata(i2c, wm8510);
-        wm8510->control_type = SND_SOC_I2C;
 
         ret =  snd_soc_register_codec(&i2c->dev,
                         &soc_codec_dev_wm8510, &wm8510_dai, 1);
-        if (ret < 0)
-                kfree(wm8510);
+
         return ret;
 }
 
diff --git a/sound/soc/codecs/wm8523.c b/sound/soc/codecs/wm8523.c
index 1c3ffb290cdc..8d5c27673501 100644
--- a/sound/soc/codecs/wm8523.c
+++ b/sound/soc/codecs/wm8523.c
@@ -17,6 +17,7 @@
 #include <linux/delay.h>
 #include <linux/pm.h>
 #include <linux/i2c.h>
+#include <linux/regmap.h>
 #include <linux/regulator/consumer.h>
 #include <linux/slab.h>
 #include <linux/of_device.h>
@@ -39,41 +40,34 @@ static const char *wm8523_supply_names[WM8523_NUM_SUPPLIES] = {
 
 /* codec private data */
 struct wm8523_priv {
-        enum snd_soc_control_type control_type;
+        struct regmap *regmap;
         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 const struct reg_default wm8523_reg_defaults[] = {
+        { 2, 0x0000 },     /* R2 - PSCTRL1 */
+        { 3, 0x1812 },     /* R3 - AIF_CTRL1 */
+        { 4, 0x0000 },     /* R4 - AIF_CTRL2 */
+        { 5, 0x0001 },     /* R5 - DAC_CTRL3 */
+        { 6, 0x0190 },     /* R6 - DAC_GAINL */
+        { 7, 0x0190 },     /* R7 - DAC_GAINR */
+        { 8, 0x0000 },     /* R8 - ZERO_DETECT */
 };
 
-static int wm8523_volatile_register(struct snd_soc_codec *codec, unsigned int reg)
+static bool wm8523_volatile_register(struct device *dev, unsigned int reg)
 {
         switch (reg) {
         case WM8523_DEVICE_ID:
         case WM8523_REVISION:
-                return 1;
+                return true;
         default:
-                return 0;
+                return false;
         }
 }
 
-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[] = {
@@ -301,8 +295,7 @@ static int wm8523_set_bias_level(struct snd_soc_codec *codec,
                                  enum snd_soc_bias_level level)
 {
         struct wm8523_priv *wm8523 = snd_soc_codec_get_drvdata(codec);
-        u16 *reg_cache = codec->reg_cache;
-        int ret, i;
+        int ret;
 
         switch (level) {
         case SND_SOC_BIAS_ON:
@@ -325,16 +318,13 @@ static int wm8523_set_bias_level(struct snd_soc_codec *codec,
                                 return ret;
                         }
 
+                        /* Sync back default/cached values */
+                        regcache_sync(wm8523->regmap);
+
                         /* 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, reg_cache[i]);
-
-
                         msleep(100);
                 }
 
@@ -402,60 +392,18 @@ static int wm8523_resume(struct snd_soc_codec *codec)
 static int wm8523_probe(struct snd_soc_codec *codec)
 {
         struct wm8523_priv *wm8523 = snd_soc_codec_get_drvdata(codec);
-        int ret, i;
+        int ret;
 
         wm8523->rate_constraint.list = &wm8523->rate_constraint_list[0];
         wm8523->rate_constraint.count =
                 ARRAY_SIZE(wm8523->rate_constraint_list);
 
-        ret = snd_soc_codec_set_cache_io(codec, 8, 16, wm8523->control_type);
+        ret = snd_soc_codec_set_cache_io(codec, 8, 16, SND_SOC_REGMAP);
         if (ret != 0) {
                 dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
                 return ret;
         }
 
-        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);
-                return ret;
-        }
-
-        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;
-        }
-
         /* Change some default settings - latch VU and enable ZC */
         snd_soc_update_bits(codec, WM8523_DAC_GAINR,
                             WM8523_DACR_VU, WM8523_DACR_VU);
@@ -463,25 +411,12 @@ static int wm8523_probe(struct snd_soc_codec *codec)
 
         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);
-
         return 0;
-
-err_enable:
-        regulator_bulk_disable(ARRAY_SIZE(wm8523->supplies), wm8523->supplies);
-err_get:
-        regulator_bulk_free(ARRAY_SIZE(wm8523->supplies), wm8523->supplies);
-
-        return ret;
 }
 
 static int wm8523_remove(struct snd_soc_codec *codec)
 {
-        struct wm8523_priv *wm8523 = snd_soc_codec_get_drvdata(codec);
-
         wm8523_set_bias_level(codec, SND_SOC_BIAS_OFF);
-        regulator_bulk_free(ARRAY_SIZE(wm8523->supplies), wm8523->supplies);
         return 0;
 }
 
@@ -491,10 +426,6 @@ static struct snd_soc_codec_driver soc_codec_dev_wm8523 = {
         .suspend =      wm8523_suspend,
         .resume =       wm8523_resume,
         .set_bias_level = wm8523_set_bias_level,
-        .reg_cache_size = WM8523_REGISTER_COUNT,
-        .reg_word_size = sizeof(u16),
-        .reg_cache_default = wm8523_reg,
-        .volatile_register = wm8523_volatile_register,
 
         .controls = wm8523_controls,
         .num_controls = ARRAY_SIZE(wm8523_controls),
@@ -509,32 +440,97 @@ static const struct of_device_id wm8523_of_match[] = {
         { },
 };
 
+static const struct regmap_config wm8523_regmap = {
+        .reg_bits = 8,
+        .val_bits = 16,
+        .max_register = WM8523_ZERO_DETECT,
+
+        .reg_defaults = wm8523_reg_defaults,
+        .num_reg_defaults = ARRAY_SIZE(wm8523_reg_defaults),
+        .cache_type = REGCACHE_RBTREE,
+
+        .volatile_reg = wm8523_volatile_register,
+};
+
 #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;
-        int ret;
+        unsigned int val;
+        int ret, i;
 
-        wm8523 = kzalloc(sizeof(struct wm8523_priv), GFP_KERNEL);
+        wm8523 = devm_kzalloc(&i2c->dev, sizeof(struct wm8523_priv),
+                              GFP_KERNEL);
         if (wm8523 == NULL)
                 return -ENOMEM;
 
+        wm8523->regmap = devm_regmap_init_i2c(i2c, &wm8523_regmap);
+        if (IS_ERR(wm8523->regmap)) {
+                ret = PTR_ERR(wm8523->regmap);
+                dev_err(&i2c->dev, "Failed to create regmap: %d\n", ret);
+                return ret;
+        }
+
+        for (i = 0; i < ARRAY_SIZE(wm8523->supplies); i++)
+                wm8523->supplies[i].supply = wm8523_supply_names[i];
+
+        ret = devm_regulator_bulk_get(&i2c->dev, ARRAY_SIZE(wm8523->supplies),
+                                      wm8523->supplies);
+        if (ret != 0) {
+                dev_err(&i2c->dev, "Failed to request supplies: %d\n", ret);
+                return ret;
+        }
+
+        ret = regulator_bulk_enable(ARRAY_SIZE(wm8523->supplies),
+                                    wm8523->supplies);
+        if (ret != 0) {
+                dev_err(&i2c->dev, "Failed to enable supplies: %d\n", ret);
+                return ret;
+        }
+
+        ret = regmap_read(wm8523->regmap, WM8523_DEVICE_ID, &val);
+        if (ret < 0) {
+                dev_err(&i2c->dev, "Failed to read ID register\n");
+                goto err_enable;
+        }
+        if (val != 0x8523) {
+                dev_err(&i2c->dev, "Device is not a WM8523, ID is %x\n", ret);
+                ret = -EINVAL;
+                goto err_enable;
+        }
+
+        ret = regmap_read(wm8523->regmap, WM8523_REVISION, &val);
+        if (ret < 0) {
+                dev_err(&i2c->dev, "Failed to read revision register\n");
+                goto err_enable;
+        }
+        dev_info(&i2c->dev, "revision %c\n",
+                 (val & WM8523_CHIP_REV_MASK) + 'A');
+
+        ret = regmap_write(wm8523->regmap, WM8523_DEVICE_ID, 0x8523);
+        if (ret != 0) {
+                dev_err(&i2c->dev, "Failed to reset device: %d\n", ret);
+                goto err_enable;
+        }
+
+        regulator_bulk_disable(ARRAY_SIZE(wm8523->supplies), wm8523->supplies);
+
         i2c_set_clientdata(i2c, wm8523);
-        wm8523->control_type = SND_SOC_I2C;
 
         ret =  snd_soc_register_codec(&i2c->dev,
                         &soc_codec_dev_wm8523, &wm8523_dai, 1);
-        if (ret < 0)
-                kfree(wm8523);
+
         return ret;
 
+err_enable:
+        regulator_bulk_disable(ARRAY_SIZE(wm8523->supplies), wm8523->supplies);
+        return ret;
 }
 
 static __devexit int wm8523_i2c_remove(struct i2c_client *client)
 {
         snd_soc_unregister_codec(&client->dev);
-        kfree(i2c_get_clientdata(client));
         return 0;
 }
 
diff --git a/sound/soc/codecs/wm8580.c b/sound/soc/codecs/wm8580.c
index 7c68226376e4..5e9c40fa7eb2 100644
--- a/sound/soc/codecs/wm8580.c
+++ b/sound/soc/codecs/wm8580.c
@@ -1,7 +1,7 @@
 /*
  * wm8580.c  --  WM8580 ALSA Soc Audio driver
  *
- * Copyright 2008-11 Wolfson Microelectronics PLC.
+ * Copyright 2008-12 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 as published by the
@@ -23,6 +23,7 @@
 #include <linux/delay.h>
 #include <linux/pm.h>
 #include <linux/i2c.h>
+#include <linux/regmap.h>
 #include <linux/regulator/consumer.h>
 #include <linux/slab.h>
 #include <linux/of_device.h>
@@ -157,23 +158,72 @@
  * We can't read the WM8580 register space when we
  * are using 2 wire for device control, so we cache them instead.
  */
-static const u16 wm8580_reg[] = {
-        0x0121, 0x017e, 0x007d, 0x0014, /*R3*/
-        0x0121, 0x017e, 0x007d, 0x0194, /*R7*/
-        0x0010, 0x0002, 0x0002, 0x00c2, /*R11*/
-        0x0182, 0x0082, 0x000a, 0x0024, /*R15*/
-        0x0009, 0x0000, 0x00ff, 0x0000, /*R19*/
-        0x00ff, 0x00ff, 0x00ff, 0x00ff, /*R23*/
-        0x00ff, 0x00ff, 0x00ff, 0x00ff, /*R27*/
-        0x01f0, 0x0040, 0x0000, 0x0000, /*R31(0x1F)*/
-        0x0000, 0x0000, 0x0031, 0x000b, /*R35*/
-        0x0039, 0x0000, 0x0010, 0x0032, /*R39*/
-        0x0054, 0x0076, 0x0098, 0x0000, /*R43(0x2B)*/
-        0x0000, 0x0000, 0x0000, 0x0000, /*R47*/
-        0x0000, 0x0000, 0x005e, 0x003e, /*R51(0x33)*/
-        0x0000, 0x0000 /*R53*/
+static const struct reg_default wm8580_reg_defaults[] = {
+        {  0, 0x0121 },
+        {  1, 0x017e },
+        {  2, 0x007d },
+        {  3, 0x0014 },
+        {  4, 0x0121 },
+        {  5, 0x017e },
+        {  6, 0x007d },
+        {  7, 0x0194 },
+        {  8, 0x0010 },
+        {  9, 0x0002 },
+        { 10, 0x0002 },
+        { 11, 0x00c2 },
+        { 12, 0x0182 },
+        { 13, 0x0082 },
+        { 14, 0x000a },
+        { 15, 0x0024 },
+        { 16, 0x0009 },
+        { 17, 0x0000 },
+        { 18, 0x00ff },
+        { 19, 0x0000 },
+        { 20, 0x00ff },
+        { 21, 0x00ff },
+        { 22, 0x00ff },
+        { 23, 0x00ff },
+        { 24, 0x00ff },
+        { 25, 0x00ff },
+        { 26, 0x00ff },
+        { 27, 0x00ff },
+        { 28, 0x01f0 },
+        { 29, 0x0040 },
+        { 30, 0x0000 },
+        { 31, 0x0000 },
+        { 32, 0x0000 },
+        { 33, 0x0000 },
+        { 34, 0x0031 },
+        { 35, 0x000b },
+        { 36, 0x0039 },
+        { 37, 0x0000 },
+        { 38, 0x0010 },
+        { 39, 0x0032 },
+        { 40, 0x0054 },
+        { 41, 0x0076 },
+        { 42, 0x0098 },
+        { 43, 0x0000 },
+        { 44, 0x0000 },
+        { 45, 0x0000 },
+        { 46, 0x0000 },
+        { 47, 0x0000 },
+        { 48, 0x0000 },
+        { 49, 0x0000 },
+        { 50, 0x005e },
+        { 51, 0x003e },
+        { 52, 0x0000 },
 };
 
+static bool wm8580_volatile(struct device *dev, unsigned int reg)
+{
+        switch (reg) {
+        case WM8580_RESET:
+                return true;
+        default:
+                return false;
+        }
+}
+
 struct pll_state {
         unsigned int in;
         unsigned int out;
@@ -188,7 +238,7 @@ static const char *wm8580_supply_names[WM8580_NUM_SUPPLIES] = {
 
 /* codec private data */
 struct wm8580_priv {
-        enum snd_soc_control_type control_type;
+        struct regmap *regmap;
         struct regulator_bulk_data supplies[WM8580_NUM_SUPPLIES];
         struct pll_state a;
         struct pll_state b;
@@ -203,14 +253,16 @@ 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;
+        struct wm8580_priv *wm8580 = snd_soc_codec_get_drvdata(codec);
         unsigned int reg = mc->reg;
         unsigned int reg2 = mc->rreg;
         int ret;
 
-        /* Clear the register cache so we write without VU set */
-        reg_cache[reg] = 0;
-        reg_cache[reg2] = 0;
+        /* Clear the register cache VU so we write without VU set */
+        regcache_cache_only(wm8580->regmap, true);
+        regmap_update_bits(wm8580->regmap, reg, 0x100, 0x000);
+        regmap_update_bits(wm8580->regmap, reg2, 0x100, 0x000);
+        regcache_cache_only(wm8580->regmap, false);
 
         ret = snd_soc_put_volsw(kcontrol, ucontrol);
         if (ret < 0)
@@ -815,24 +867,14 @@ static struct snd_soc_dai_driver wm8580_dai[] = {
 static int wm8580_probe(struct snd_soc_codec *codec)
 {
         struct wm8580_priv *wm8580 = snd_soc_codec_get_drvdata(codec);
-        int ret = 0,i;
+        int ret = 0;
 
-        ret = snd_soc_codec_set_cache_io(codec, 7, 9, wm8580->control_type);
+        ret = snd_soc_codec_set_cache_io(codec, 7, 9, SND_SOC_REGMAP);
         if (ret < 0) {
                 dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
                 return ret;
         }
 
-        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);
-                return ret;
-        }
-
         ret = regulator_bulk_enable(ARRAY_SIZE(wm8580->supplies),
                                     wm8580->supplies);
         if (ret != 0) {
@@ -854,7 +896,6 @@ static int wm8580_probe(struct snd_soc_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);
         return ret;
 }
 
@@ -866,7 +907,6 @@ static int wm8580_remove(struct snd_soc_codec *codec)
         wm8580_set_bias_level(codec, SND_SOC_BIAS_OFF);
 
         regulator_bulk_disable(ARRAY_SIZE(wm8580->supplies), wm8580->supplies);
-        regulator_bulk_free(ARRAY_SIZE(wm8580->supplies), wm8580->supplies);
 
         return 0;
 }
@@ -875,9 +915,6 @@ static struct snd_soc_codec_driver soc_codec_dev_wm8580 = {
         .probe =        wm8580_probe,
         .remove =       wm8580_remove,
         .set_bias_level = wm8580_set_bias_level,
-        .reg_cache_size = ARRAY_SIZE(wm8580_reg),
-        .reg_word_size = sizeof(u16),
-        .reg_cache_default = wm8580_reg,
 
         .controls = wm8580_snd_controls,
         .num_controls = ARRAY_SIZE(wm8580_snd_controls),
@@ -892,31 +929,55 @@ static const struct of_device_id wm8580_of_match[] = {
         { },
 };
 
+static const struct regmap_config wm8580_regmap = {
+        .reg_bits = 7,
+        .val_bits = 9,
+        .max_register = WM8580_MAX_REGISTER,
+
+        .reg_defaults = wm8580_reg_defaults,
+        .num_reg_defaults = ARRAY_SIZE(wm8580_reg_defaults),
+        .cache_type = REGCACHE_RBTREE,
+
+        .volatile_reg = wm8580_volatile,
+};
+
 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
 static int wm8580_i2c_probe(struct i2c_client *i2c,
                             const struct i2c_device_id *id)
 {
         struct wm8580_priv *wm8580;
-        int ret;
+        int ret, i;
 
-        wm8580 = kzalloc(sizeof(struct wm8580_priv), GFP_KERNEL);
+        wm8580 = devm_kzalloc(&i2c->dev, sizeof(struct wm8580_priv),
+                              GFP_KERNEL);
         if (wm8580 == NULL)
                 return -ENOMEM;
 
+        wm8580->regmap = devm_regmap_init_i2c(i2c, &wm8580_regmap);
+        if (IS_ERR(wm8580->regmap))
+                return PTR_ERR(wm8580->regmap);
+
+        for (i = 0; i < ARRAY_SIZE(wm8580->supplies); i++)
+                wm8580->supplies[i].supply = wm8580_supply_names[i];
+
+        ret = devm_regulator_bulk_get(&i2c->dev, ARRAY_SIZE(wm8580->supplies),
+                                      wm8580->supplies);
+        if (ret != 0) {
+                dev_err(&i2c->dev, "Failed to request supplies: %d\n", ret);
+                return ret;
+        }
+
         i2c_set_clientdata(i2c, wm8580);
-        wm8580->control_type = SND_SOC_I2C;
 
         ret =  snd_soc_register_codec(&i2c->dev,
                         &soc_codec_dev_wm8580, wm8580_dai, ARRAY_SIZE(wm8580_dai));
-        if (ret < 0)
-                kfree(wm8580);
+
         return ret;
 }
 
 static int wm8580_i2c_remove(struct i2c_client *client)
 {
         snd_soc_unregister_codec(&client->dev);
-        kfree(i2c_get_clientdata(client));
         return 0;
 }
 
diff --git a/sound/soc/codecs/wm8711.c b/sound/soc/codecs/wm8711.c
index 0b76d1dca5ea..8b8bb70f1eb9 100644
--- a/sound/soc/codecs/wm8711.c
+++ b/sound/soc/codecs/wm8711.c
@@ -18,6 +18,7 @@
 #include <linux/delay.h>
 #include <linux/pm.h>
 #include <linux/i2c.h>
+#include <linux/regmap.h>
 #include <linux/spi/spi.h>
 #include <linux/slab.h>
 #include <linux/of_device.h>
@@ -32,7 +33,7 @@
 
 /* codec private data */
 struct wm8711_priv {
-        enum snd_soc_control_type bus_type;
+        struct regmap *regmap;
         unsigned int sysclk;
 };
 
@@ -42,11 +43,21 @@ struct wm8711_priv {
  * using 2 wire for device control, so we cache them instead.
  * There is no point in caching the reset register
  */
-static const u16 wm8711_reg[WM8711_CACHEREGNUM] = {
-        0x0079, 0x0079, 0x000a, 0x0008,
-        0x009f, 0x000a, 0x0000, 0x0000
+static const struct reg_default wm8711_reg_defaults[] = {
+        { 0, 0x0079 }, { 1, 0x0079 }, { 2, 0x000a }, { 3, 0x0008 },
+        { 4, 0x009f }, { 5, 0x000a }, { 6, 0x0000 }, { 7, 0x0000 },
 };
 
+static bool wm8711_volatile(struct device *dev, unsigned int reg)
+{
+        switch (reg) {
+        case WM8711_RESET:
+                return true;
+        default:
+                return false;
+        }
+}
+
 #define wm8711_reset(c) snd_soc_write(c, WM8711_RESET, 0)
 
 static const DECLARE_TLV_DB_SCALE(out_tlv, -12100, 100, 1);
@@ -289,6 +300,7 @@ static int wm8711_set_dai_fmt(struct snd_soc_dai *codec_dai,
 static int wm8711_set_bias_level(struct snd_soc_codec *codec,
         enum snd_soc_bias_level level)
 {
+        struct wm8711_priv *wm8711 = snd_soc_codec_get_drvdata(codec);
         u16 reg = snd_soc_read(codec, WM8711_PWR) & 0xff7f;
 
         switch (level) {
@@ -299,7 +311,7 @@ static int wm8711_set_bias_level(struct snd_soc_codec *codec,
                 break;
         case SND_SOC_BIAS_STANDBY:
                 if (codec->dapm.bias_level == SND_SOC_BIAS_OFF)
-                        snd_soc_cache_sync(codec);
+                        regcache_sync(wm8711->regmap);
 
                 snd_soc_write(codec, WM8711_PWR, reg | 0x0040);
                 break;
@@ -353,10 +365,9 @@ static int wm8711_resume(struct snd_soc_codec *codec)
 
 static int wm8711_probe(struct snd_soc_codec *codec)
 {
-        struct wm8711_priv *wm8711 = snd_soc_codec_get_drvdata(codec);
         int ret;
 
-        ret = snd_soc_codec_set_cache_io(codec, 7, 9, wm8711->bus_type);
+        ret = snd_soc_codec_set_cache_io(codec, 7, 9, SND_SOC_REGMAP);
         if (ret < 0) {
                 dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
                 return ret;
@@ -391,9 +402,6 @@ static struct snd_soc_codec_driver soc_codec_dev_wm8711 = {
         .suspend =      wm8711_suspend,
         .resume =       wm8711_resume,
         .set_bias_level = wm8711_set_bias_level,
-        .reg_cache_size = ARRAY_SIZE(wm8711_reg),
-        .reg_word_size = sizeof(u16),
-        .reg_cache_default = wm8711_reg,
         .controls = wm8711_snd_controls,
         .num_controls = ARRAY_SIZE(wm8711_snd_controls),
         .dapm_widgets = wm8711_dapm_widgets,
@@ -408,30 +416,45 @@ static const struct of_device_id wm8711_of_match[] = {
 };
 MODULE_DEVICE_TABLE(of, wm8711_of_match);
 
+static const struct regmap_config wm8711_regmap = {
+        .reg_bits = 7,
+        .val_bits = 9,
+        .max_register = WM8711_RESET,
+
+        .reg_defaults = wm8711_reg_defaults,
+        .num_reg_defaults = ARRAY_SIZE(wm8711_reg_defaults),
+        .cache_type = REGCACHE_RBTREE,
+
+        .volatile_reg = wm8711_volatile,
+};
+
 #if defined(CONFIG_SPI_MASTER)
 static int __devinit wm8711_spi_probe(struct spi_device *spi)
 {
         struct wm8711_priv *wm8711;
         int ret;
 
-        wm8711 = kzalloc(sizeof(struct wm8711_priv), GFP_KERNEL);
+        wm8711 = devm_kzalloc(&spi->dev, sizeof(struct wm8711_priv),
+                              GFP_KERNEL);
         if (wm8711 == NULL)
                 return -ENOMEM;
 
+        wm8711->regmap = devm_regmap_init_spi(spi, &wm8711_regmap);
+        if (IS_ERR(wm8711->regmap))
+                return PTR_ERR(wm8711->regmap);
+
         spi_set_drvdata(spi, wm8711);
-        wm8711->bus_type = SND_SOC_SPI;
 
         ret = snd_soc_register_codec(&spi->dev,
                         &soc_codec_dev_wm8711, &wm8711_dai, 1);
-        if (ret < 0)
-                kfree(wm8711);
+
         return ret;
 }
 
 static int __devexit wm8711_spi_remove(struct spi_device *spi)
 {
         snd_soc_unregister_codec(&spi->dev);
-        kfree(spi_get_drvdata(spi));
+
         return 0;
 }
 
@@ -453,24 +476,26 @@ static __devinit int wm8711_i2c_probe(struct i2c_client *client,
         struct wm8711_priv *wm8711;
         int ret;
 
-        wm8711 = kzalloc(sizeof(struct wm8711_priv), GFP_KERNEL);
+        wm8711 = devm_kzalloc(&client->dev, sizeof(struct wm8711_priv),
+                              GFP_KERNEL);
         if (wm8711 == NULL)
                 return -ENOMEM;
 
+        wm8711->regmap = devm_regmap_init_i2c(client, &wm8711_regmap);
+        if (IS_ERR(wm8711->regmap))
+                return PTR_ERR(wm8711->regmap);
+
         i2c_set_clientdata(client, wm8711);
-        wm8711->bus_type = SND_SOC_I2C;
 
         ret =  snd_soc_register_codec(&client->dev,
                         &soc_codec_dev_wm8711, &wm8711_dai, 1);
-        if (ret < 0)
-                kfree(wm8711);
+
         return ret;
 }
 
 static __devexit int wm8711_i2c_remove(struct i2c_client *client)
 {
         snd_soc_unregister_codec(&client->dev);
-        kfree(i2c_get_clientdata(client));
         return 0;
 }
 
diff --git a/sound/soc/codecs/wm8728.c b/sound/soc/codecs/wm8728.c
index 1467f97dce21..00a12a0c3919 100644
--- a/sound/soc/codecs/wm8728.c
+++ b/sound/soc/codecs/wm8728.c
@@ -17,6 +17,7 @@
 #include <linux/pm.h>
 #include <linux/i2c.h>
 #include <linux/platform_device.h>
+#include <linux/regmap.h>
 #include <linux/spi/spi.h>
 #include <linux/slab.h>
 #include <linux/of_device.h>
@@ -35,16 +36,16 @@
  * the volume update bits, mute the output and enable infinite zero
  * detect.
  */
-static const u16 wm8728_reg_defaults[] = {
-        0x1ff,
-        0x1ff,
-        0x001,
-        0x100,
+static const struct reg_default wm8728_reg_defaults[] = {
+        { 0, 0x1ff },
+        { 1, 0x1ff },
+        { 2, 0x001 },
+        { 3, 0x100 },
 };
 
 /* codec private data */
 struct wm8728_priv {
-        enum snd_soc_control_type control_type;
+        struct regmap *regmap;
 };
 
 static const DECLARE_TLV_DB_SCALE(wm8728_tlv, -12750, 50, 1);
@@ -162,8 +163,8 @@ static int wm8728_set_dai_fmt(struct snd_soc_dai *codec_dai,
 static int wm8728_set_bias_level(struct snd_soc_codec *codec,
                                  enum snd_soc_bias_level level)
 {
+        struct wm8728_priv *wm8728 = snd_soc_codec_get_drvdata(codec);
         u16 reg;
-        int i;
 
         switch (level) {
         case SND_SOC_BIAS_ON:
@@ -175,9 +176,7 @@ static int wm8728_set_bias_level(struct snd_soc_codec *codec,
                         snd_soc_write(codec, WM8728_DACCTL, reg & ~0x4);
 
                         /* ..then sync in the register cache. */
-                        for (i = 0; i < ARRAY_SIZE(wm8728_reg_defaults); i++)
-                                snd_soc_write(codec, i,
-                                             snd_soc_read(codec, i));
+                        regcache_sync(wm8728->regmap);
                 }
                 break;
 
@@ -229,10 +228,9 @@ static int wm8728_resume(struct snd_soc_codec *codec)
 
 static int wm8728_probe(struct snd_soc_codec *codec)
 {
-        struct wm8728_priv *wm8728 = snd_soc_codec_get_drvdata(codec);
         int ret;
 
-        ret = snd_soc_codec_set_cache_io(codec, 7, 9, wm8728->control_type);
+        ret = snd_soc_codec_set_cache_io(codec, 7, 9, SND_SOC_REGMAP);
         if (ret < 0) {
                 printk(KERN_ERR "wm8728: failed to configure cache I/O: %d\n",
                        ret);
@@ -257,9 +255,6 @@ static struct snd_soc_codec_driver soc_codec_dev_wm8728 = {
         .suspend =      wm8728_suspend,
         .resume =       wm8728_resume,
         .set_bias_level = wm8728_set_bias_level,
-        .reg_cache_size = ARRAY_SIZE(wm8728_reg_defaults),
-        .reg_word_size = sizeof(u16),
-        .reg_cache_default = wm8728_reg_defaults,
         .controls = wm8728_snd_controls,
         .num_controls = ARRAY_SIZE(wm8728_snd_controls),
         .dapm_widgets = wm8728_dapm_widgets,
@@ -274,30 +269,43 @@ static const struct of_device_id wm8728_of_match[] = {
 };
 MODULE_DEVICE_TABLE(of, wm8728_of_match);
 
+static const struct regmap_config wm8728_regmap = {
+        .reg_bits = 7,
+        .val_bits = 9,
+        .max_register = WM8728_IFCTL,
+
+        .reg_defaults = wm8728_reg_defaults,
+        .num_reg_defaults = ARRAY_SIZE(wm8728_reg_defaults),
+        .cache_type = REGCACHE_RBTREE,
+};
+
 #if defined(CONFIG_SPI_MASTER)
 static int __devinit wm8728_spi_probe(struct spi_device *spi)
 {
         struct wm8728_priv *wm8728;
         int ret;
 
-        wm8728 = kzalloc(sizeof(struct wm8728_priv), GFP_KERNEL);
+        wm8728 = devm_kzalloc(&spi->dev, sizeof(struct wm8728_priv),
+                              GFP_KERNEL);
         if (wm8728 == NULL)
                 return -ENOMEM;
 
-        wm8728->control_type = SND_SOC_SPI;
+        wm8728->regmap = devm_regmap_init_spi(spi, &wm8728_regmap);
+        if (IS_ERR(wm8728->regmap))
+                return PTR_ERR(wm8728->regmap);
+
         spi_set_drvdata(spi, wm8728);
 
         ret = snd_soc_register_codec(&spi->dev,
                         &soc_codec_dev_wm8728, &wm8728_dai, 1);
-        if (ret < 0)
-                kfree(wm8728);
+
         return ret;
 }
 
 static int __devexit wm8728_spi_remove(struct spi_device *spi)
 {
         snd_soc_unregister_codec(&spi->dev);
-        kfree(spi_get_drvdata(spi));
+
         return 0;
 }
 
@@ -319,24 +327,26 @@ static __devinit int wm8728_i2c_probe(struct i2c_client *i2c,
         struct wm8728_priv *wm8728;
         int ret;
 
-        wm8728 = kzalloc(sizeof(struct wm8728_priv), GFP_KERNEL);
+        wm8728 = devm_kzalloc(&i2c->dev, sizeof(struct wm8728_priv),
+                              GFP_KERNEL);
         if (wm8728 == NULL)
                 return -ENOMEM;
 
+        wm8728->regmap = devm_regmap_init_i2c(i2c, &wm8728_regmap);
+        if (IS_ERR(wm8728->regmap))
+                return PTR_ERR(wm8728->regmap);
+
         i2c_set_clientdata(i2c, wm8728);
-        wm8728->control_type = SND_SOC_I2C;
 
         ret =  snd_soc_register_codec(&i2c->dev,
                         &soc_codec_dev_wm8728, &wm8728_dai, 1);
-        if (ret < 0)
-                kfree(wm8728);
+
         return ret;
 }
 
 static __devexit int wm8728_i2c_remove(struct i2c_client *client)
 {
         snd_soc_unregister_codec(&client->dev);
-        kfree(i2c_get_clientdata(client));
         return 0;
 }
 
diff --git a/sound/soc/codecs/wm8737.c b/sound/soc/codecs/wm8737.c
index d0520124616d..5c9634f4c1f0 100644
--- a/sound/soc/codecs/wm8737.c
+++ b/sound/soc/codecs/wm8737.c
@@ -16,6 +16,7 @@
 #include <linux/delay.h>
 #include <linux/pm.h>
 #include <linux/i2c.h>
+#include <linux/regmap.h>
 #include <linux/regulator/consumer.h>
 #include <linux/spi/spi.h>
 #include <linux/slab.h>
@@ -40,29 +41,39 @@ static const char *wm8737_supply_names[WM8737_NUM_SUPPLIES] = {
 
 /* codec private data */
 struct wm8737_priv {
-        enum snd_soc_control_type control_type;
+        struct regmap *regmap;
         struct regulator_bulk_data supplies[WM8737_NUM_SUPPLIES];
         unsigned int mclk;
 };
 
-static const u16 wm8737_reg[WM8737_REGISTER_COUNT] = {
-        0x00C3,     /* R0  - Left PGA volume */
-        0x00C3,     /* R1  - Right PGA volume */
-        0x0007,     /* R2  - AUDIO path L */
-        0x0007,     /* R3  - AUDIO path R */
-        0x0000,     /* R4  - 3D Enhance */
-        0x0000,     /* R5  - ADC Control */
-        0x0000,     /* R6  - Power Management */
-        0x000A,     /* R7  - Audio Format */
-        0x0000,     /* R8  - Clocking */
-        0x000F,     /* R9  - MIC Preamp Control */
-        0x0003,     /* R10 - Misc Bias Control */
-        0x0000,     /* R11 - Noise Gate */
-        0x007C,     /* R12 - ALC1 */
-        0x0000,     /* R13 - ALC2 */
-        0x0032,     /* R14 - ALC3 */
+static const struct reg_default wm8737_reg_defaults[] = {
+        {  0, 0x00C3 },     /* R0  - Left PGA volume */
+        {  1, 0x00C3 },     /* R1  - Right PGA volume */
+        {  2, 0x0007 },     /* R2  - AUDIO path L */
+        {  3, 0x0007 },     /* R3  - AUDIO path R */
+        {  4, 0x0000 },     /* R4  - 3D Enhance */
+        {  5, 0x0000 },     /* R5  - ADC Control */
+        {  6, 0x0000 },     /* R6  - Power Management */
+        {  7, 0x000A },     /* R7  - Audio Format */
+        {  8, 0x0000 },     /* R8  - Clocking */
+        {  9, 0x000F },     /* R9  - MIC Preamp Control */
+        { 10, 0x0003 },     /* R10 - Misc Bias Control */
+        { 11, 0x0000 },     /* R11 - Noise Gate */
+        { 12, 0x007C },     /* R12 - ALC1 */
+        { 13, 0x0000 },     /* R13 - ALC2 */
+        { 14, 0x0032 },     /* R14 - ALC3 */
 };
 
+static bool wm8737_volatile(struct device *dev, unsigned int reg)
+{
+        switch (reg) {
+        case WM8737_RESET:
+                return true;
+        default:
+                return false;
+        }
+}
+
 static int wm8737_reset(struct snd_soc_codec *codec)
 {
         return snd_soc_write(codec, WM8737_RESET, 0);
@@ -479,7 +490,7 @@ static int wm8737_set_bias_level(struct snd_soc_codec *codec,
                                 return ret;
                         }
 
-                        snd_soc_cache_sync(codec);
+                        regcache_sync(wm8737->regmap);
 
                         /* Fast VMID ramp at 2*2.5k */
                         snd_soc_update_bits(codec, WM8737_MISC_BIAS_CONTROL,
@@ -557,24 +568,14 @@ static int wm8737_resume(struct snd_soc_codec *codec)
 static int wm8737_probe(struct snd_soc_codec *codec)
 {
         struct wm8737_priv *wm8737 = snd_soc_codec_get_drvdata(codec);
-        int ret, i;
+        int ret;
 
-        ret = snd_soc_codec_set_cache_io(codec, 7, 9, wm8737->control_type);
+        ret = snd_soc_codec_set_cache_io(codec, 7, 9, SND_SOC_REGMAP);
         if (ret != 0) {
                 dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
                 return ret;
         }
 
-        for (i = 0; i < ARRAY_SIZE(wm8737->supplies); i++)
-                wm8737->supplies[i].supply = wm8737_supply_names[i];
-
-        ret = regulator_bulk_get(codec->dev, ARRAY_SIZE(wm8737->supplies),
-                                 wm8737->supplies);
-        if (ret != 0) {
-                dev_err(codec->dev, "Failed to request supplies: %d\n", ret);
-                return ret;
-        }
-
         ret = regulator_bulk_enable(ARRAY_SIZE(wm8737->supplies),
                                     wm8737->supplies);
         if (ret != 0) {
@@ -607,17 +608,12 @@ static int wm8737_probe(struct snd_soc_codec *codec)
 err_enable:
         regulator_bulk_disable(ARRAY_SIZE(wm8737->supplies), wm8737->supplies);
 err_get:
-        regulator_bulk_free(ARRAY_SIZE(wm8737->supplies), wm8737->supplies);
-
         return ret;
 }
 
 static int wm8737_remove(struct snd_soc_codec *codec)
 {
-        struct wm8737_priv *wm8737 = snd_soc_codec_get_drvdata(codec);
-
         wm8737_set_bias_level(codec, SND_SOC_BIAS_OFF);
-        regulator_bulk_free(ARRAY_SIZE(wm8737->supplies), wm8737->supplies);
         return 0;
 }
 
@@ -627,10 +623,6 @@ static struct snd_soc_codec_driver soc_codec_dev_wm8737 = {
         .suspend        = wm8737_suspend,
         .resume         = wm8737_resume,
         .set_bias_level = wm8737_set_bias_level,
-
-        .reg_cache_size = WM8737_REGISTER_COUNT - 1, /* Skip reset */
-        .reg_word_size  = sizeof(u16),
-        .reg_cache_default = wm8737_reg,
 };
 
 static const struct of_device_id wm8737_of_match[] = {
@@ -640,24 +632,49 @@ static const struct of_device_id wm8737_of_match[] = {
 
 MODULE_DEVICE_TABLE(of, wm8737_of_match);
 
+static const struct regmap_config wm8737_regmap = {
+        .reg_bits = 7,
+        .val_bits = 9,
+        .max_register = WM8737_MAX_REGISTER,
+
+        .reg_defaults = wm8737_reg_defaults,
+        .num_reg_defaults = ARRAY_SIZE(wm8737_reg_defaults),
+        .cache_type = REGCACHE_RBTREE,
+
+        .volatile_reg = wm8737_volatile,
+};
+
 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
 static __devinit int wm8737_i2c_probe(struct i2c_client *i2c,
                                       const struct i2c_device_id *id)
 {
         struct wm8737_priv *wm8737;
-        int ret;
+        int ret, i;
 
-        wm8737 = kzalloc(sizeof(struct wm8737_priv), GFP_KERNEL);
+        wm8737 = devm_kzalloc(&i2c->dev, sizeof(struct wm8737_priv),
+                              GFP_KERNEL);
         if (wm8737 == NULL)
                 return -ENOMEM;
 
+        for (i = 0; i < ARRAY_SIZE(wm8737->supplies); i++)
+                wm8737->supplies[i].supply = wm8737_supply_names[i];
+
+        ret = devm_regulator_bulk_get(&i2c->dev, ARRAY_SIZE(wm8737->supplies),
+                                      wm8737->supplies);
+        if (ret != 0) {
+                dev_err(&i2c->dev, "Failed to request supplies: %d\n", ret);
+                return ret;
+        }
+
+        wm8737->regmap = devm_regmap_init_i2c(i2c, &wm8737_regmap);
+        if (IS_ERR(wm8737->regmap))
+                return PTR_ERR(wm8737->regmap);
+
         i2c_set_clientdata(i2c, wm8737);
-        wm8737->control_type = SND_SOC_I2C;
 
         ret =  snd_soc_register_codec(&i2c->dev,
                                       &soc_codec_dev_wm8737, &wm8737_dai, 1);
-        if (ret < 0)
-                kfree(wm8737);
+
         return ret;
 
 }
@@ -665,7 +682,7 @@ static __devinit int wm8737_i2c_probe(struct i2c_client *i2c,
 static __devexit int wm8737_i2c_remove(struct i2c_client *client)
 {
         snd_soc_unregister_codec(&client->dev);
-        kfree(i2c_get_clientdata(client));
+
         return 0;
 }
 
@@ -691,26 +708,39 @@ static struct i2c_driver wm8737_i2c_driver = {
 static int __devinit wm8737_spi_probe(struct spi_device *spi)
 {
         struct wm8737_priv *wm8737;
-        int ret;
+        int ret, i;
 
-        wm8737 = kzalloc(sizeof(struct wm8737_priv), GFP_KERNEL);
+        wm8737 = devm_kzalloc(&spi->dev, sizeof(struct wm8737_priv),
+                              GFP_KERNEL);
         if (wm8737 == NULL)
                 return -ENOMEM;
 
-        wm8737->control_type = SND_SOC_SPI;
+        for (i = 0; i < ARRAY_SIZE(wm8737->supplies); i++)
+                wm8737->supplies[i].supply = wm8737_supply_names[i];
+
+        ret = devm_regulator_bulk_get(&spi->dev, ARRAY_SIZE(wm8737->supplies),
+                                      wm8737->supplies);
+        if (ret != 0) {
+                dev_err(&spi->dev, "Failed to request supplies: %d\n", ret);
+                return ret;
+        }
+
+        wm8737->regmap = devm_regmap_init_spi(spi, &wm8737_regmap);
+        if (IS_ERR(wm8737->regmap))
+                return PTR_ERR(wm8737->regmap);
+
         spi_set_drvdata(spi, wm8737);
 
         ret = snd_soc_register_codec(&spi->dev,
                                      &soc_codec_dev_wm8737, &wm8737_dai, 1);
-        if (ret < 0)
-                kfree(wm8737);
+
         return ret;
 }
 
 static int __devexit wm8737_spi_remove(struct spi_device *spi)
 {
         snd_soc_unregister_codec(&spi->dev);
-        kfree(spi_get_drvdata(spi));
+
         return 0;
 }
 
diff --git a/sound/soc/codecs/wm8741.c b/sound/soc/codecs/wm8741.c
index 35f3d23200e0..4281a0802138 100644
--- a/sound/soc/codecs/wm8741.c
+++ b/sound/soc/codecs/wm8741.c
@@ -18,6 +18,7 @@
 #include <linux/pm.h>
 #include <linux/i2c.h>
 #include <linux/spi/spi.h>
+#include <linux/regmap.h>
 #include <linux/regulator/consumer.h>
 #include <linux/slab.h>
 #include <linux/of_device.h>
@@ -40,26 +41,43 @@ static const char *wm8741_supply_names[WM8741_NUM_SUPPLIES] = {
 
 /* codec private data */
 struct wm8741_priv {
-        enum snd_soc_control_type control_type;
+        struct regmap *regmap;
         struct regulator_bulk_data supplies[WM8741_NUM_SUPPLIES];
         unsigned int sysclk;
         struct snd_pcm_hw_constraint_list *sysclk_constraints;
 };
 
-static const u16 wm8741_reg_defaults[WM8741_REGISTER_COUNT] = {
-        0x0000,     /* R0  - DACLLSB Attenuation */
-        0x0000,     /* R1  - DACLMSB Attenuation */
-        0x0000,     /* R2  - DACRLSB Attenuation */
-        0x0000,     /* R3  - DACRMSB Attenuation */
-        0x0000,     /* R4  - Volume Control */
-        0x000A,     /* R5  - Format Control */
-        0x0000,     /* R6  - Filter Control */
-        0x0000,     /* R7  - Mode Control 1 */
-        0x0002,     /* R8  - Mode Control 2 */
-        0x0000,     /* R9  - Reset */
-        0x0002,     /* R32 - ADDITONAL_CONTROL_1 */
+static const struct reg_default wm8741_reg_defaults[] = {
+        {  0, 0x0000 },     /* R0  - DACLLSB Attenuation */
+        {  1, 0x0000 },     /* R1  - DACLMSB Attenuation */
+        {  2, 0x0000 },     /* R2  - DACRLSB Attenuation */
+        {  3, 0x0000 },     /* R3  - DACRMSB Attenuation */
+        {  4, 0x0000 },     /* R4  - Volume Control */
+        {  5, 0x000A },     /* R5  - Format Control */
+        {  6, 0x0000 },     /* R6  - Filter Control */
+        {  7, 0x0000 },     /* R7  - Mode Control 1 */
+        {  8, 0x0002 },     /* R8  - Mode Control 2 */
+        { 32, 0x0002 },     /* R32 - ADDITONAL_CONTROL_1 */
 };
 
+static bool wm8741_readable(struct device *dev, unsigned int reg)
+{
+        switch (reg) {
+        case WM8741_DACLLSB_ATTENUATION:
+        case WM8741_DACLMSB_ATTENUATION:
+        case WM8741_DACRLSB_ATTENUATION:
+        case WM8741_DACRMSB_ATTENUATION:
+        case WM8741_VOLUME_CONTROL:
+        case WM8741_FORMAT_CONTROL:
+        case WM8741_FILTER_CONTROL:
+        case WM8741_MODE_CONTROL_1:
+        case WM8741_MODE_CONTROL_2:
+        case WM8741_ADDITIONAL_CONTROL_1:
+                return true;
+        default:
+                return false;
+        }
+}
 
 static int wm8741_reset(struct snd_soc_codec *codec)
 {
@@ -403,17 +421,6 @@ static int wm8741_probe(struct snd_soc_codec *codec)
 {
         struct wm8741_priv *wm8741 = snd_soc_codec_get_drvdata(codec);
         int ret = 0;
-        int i;
-
-        for (i = 0; i < ARRAY_SIZE(wm8741->supplies); i++)
-                wm8741->supplies[i].supply = wm8741_supply_names[i];
-
-        ret = regulator_bulk_get(codec->dev, ARRAY_SIZE(wm8741->supplies),
-                                 wm8741->supplies);
-        if (ret != 0) {
-                dev_err(codec->dev, "Failed to request supplies: %d\n", ret);
-                goto err;
-        }
 
         ret = regulator_bulk_enable(ARRAY_SIZE(wm8741->supplies),
                                     wm8741->supplies);
@@ -422,7 +429,7 @@ static int wm8741_probe(struct snd_soc_codec *codec)
                 goto err_get;
         }
 
-        ret = snd_soc_codec_set_cache_io(codec, 7, 9, wm8741->control_type);
+        ret = snd_soc_codec_set_cache_io(codec, 7, 9, SND_SOC_REGMAP);
         if (ret != 0) {
                 dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
                 goto err_enable;
@@ -450,8 +457,6 @@ static int wm8741_probe(struct snd_soc_codec *codec)
 err_enable:
         regulator_bulk_disable(ARRAY_SIZE(wm8741->supplies), wm8741->supplies);
 err_get:
-        regulator_bulk_free(ARRAY_SIZE(wm8741->supplies), wm8741->supplies);
-err:
         return ret;
 }
 
@@ -460,7 +465,6 @@ static int wm8741_remove(struct snd_soc_codec *codec)
         struct wm8741_priv *wm8741 = snd_soc_codec_get_drvdata(codec);
 
         regulator_bulk_disable(ARRAY_SIZE(wm8741->supplies), wm8741->supplies);
-        regulator_bulk_free(ARRAY_SIZE(wm8741->supplies), wm8741->supplies);
 
         return 0;
 }
@@ -469,9 +473,6 @@ static struct snd_soc_codec_driver soc_codec_dev_wm8741 = {
         .probe =        wm8741_probe,
         .remove =       wm8741_remove,
         .resume =       wm8741_resume,
-        .reg_cache_size = ARRAY_SIZE(wm8741_reg_defaults),
-        .reg_word_size = sizeof(u16),
-        .reg_cache_default = wm8741_reg_defaults,
 
         .controls = wm8741_snd_controls,
         .num_controls = ARRAY_SIZE(wm8741_snd_controls),
@@ -487,20 +488,48 @@ static const struct of_device_id wm8741_of_match[] = {
 };
 MODULE_DEVICE_TABLE(of, wm8741_of_match);
 
+static const struct regmap_config wm8741_regmap = {
+        .reg_bits = 7,
+        .val_bits = 9,
+        .max_register = WM8741_MAX_REGISTER,
+
+        .reg_defaults = wm8741_reg_defaults,
+        .num_reg_defaults = ARRAY_SIZE(wm8741_reg_defaults),
+        .cache_type = REGCACHE_RBTREE,
+
+        .readable_reg = wm8741_readable,
+};
+
 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
 static int wm8741_i2c_probe(struct i2c_client *i2c,
                             const struct i2c_device_id *id)
 {
         struct wm8741_priv *wm8741;
-        int ret;
+        int ret, i;
 
         wm8741 = devm_kzalloc(&i2c->dev, sizeof(struct wm8741_priv),
                               GFP_KERNEL);
         if (wm8741 == NULL)
                 return -ENOMEM;
 
+        for (i = 0; i < ARRAY_SIZE(wm8741->supplies); i++)
+                wm8741->supplies[i].supply = wm8741_supply_names[i];
+
+        ret = devm_regulator_bulk_get(&i2c->dev, ARRAY_SIZE(wm8741->supplies),
+                                      wm8741->supplies);
+        if (ret != 0) {
+                dev_err(&i2c->dev, "Failed to request supplies: %d\n", ret);
+                return ret;
+        }
+
+        wm8741->regmap = regmap_init_i2c(i2c, &wm8741_regmap);
+        if (IS_ERR(wm8741->regmap)) {
+                ret = PTR_ERR(wm8741->regmap);
+                dev_err(&i2c->dev, "Failed to init regmap: %d\n", ret);
+                return ret;
+        }
+
         i2c_set_clientdata(i2c, wm8741);
-        wm8741->control_type = SND_SOC_I2C;
 
         ret = snd_soc_register_codec(&i2c->dev,
                                      &soc_codec_dev_wm8741, &wm8741_dai, 1);
@@ -536,14 +565,30 @@ static struct i2c_driver wm8741_i2c_driver = {
 static int __devinit wm8741_spi_probe(struct spi_device *spi)
 {
         struct wm8741_priv *wm8741;
-        int ret;
+        int ret, i;
 
         wm8741 = devm_kzalloc(&spi->dev, sizeof(struct wm8741_priv),
                              GFP_KERNEL);
         if (wm8741 == NULL)
                 return -ENOMEM;
 
-        wm8741->control_type = SND_SOC_SPI;
+        for (i = 0; i < ARRAY_SIZE(wm8741->supplies); i++)
+                wm8741->supplies[i].supply = wm8741_supply_names[i];
+
+        ret = devm_regulator_bulk_get(&spi->dev, ARRAY_SIZE(wm8741->supplies),
+                                      wm8741->supplies);
+        if (ret != 0) {
+                dev_err(&spi->dev, "Failed to request supplies: %d\n", ret);
+                return ret;
+        }
+
+        wm8741->regmap = regmap_init_spi(spi, &wm8741_regmap);
+        if (IS_ERR(wm8741->regmap)) {
+                ret = PTR_ERR(wm8741->regmap);
+                dev_err(&spi->dev, "Failed to init regmap: %d\n", ret);
+                return ret;
+        }
+
         spi_set_drvdata(spi, wm8741);
 
         ret = snd_soc_register_codec(&spi->dev,
diff --git a/sound/soc/codecs/wm8770.c b/sound/soc/codecs/wm8770.c
index a5127b4ff9e1..c7c0034d3966 100644
--- a/sound/soc/codecs/wm8770.c
+++ b/sound/soc/codecs/wm8770.c
@@ -724,24 +724,7 @@ static struct spi_driver wm8770_spi_driver = {
         .remove = __devexit_p(wm8770_spi_remove)
 };
 
-static int __init wm8770_modinit(void)
-{
-        int ret = 0;
-
-        ret = spi_register_driver(&wm8770_spi_driver);
-        if (ret) {
-                printk(KERN_ERR "Failed to register wm8770 SPI driver: %d\n",
-                       ret);
-        }
-        return ret;
-}
-module_init(wm8770_modinit);
-
-static void __exit wm8770_exit(void)
-{
-        spi_unregister_driver(&wm8770_spi_driver);
-}
-module_exit(wm8770_exit);
+module_spi_driver(wm8770_spi_driver);
 
 MODULE_DESCRIPTION("ASoC WM8770 driver");
 MODULE_AUTHOR("Dimitris Papastamos <dp@opensource.wolfsonmicro.com>");
diff --git a/sound/soc/codecs/wm8776.c b/sound/soc/codecs/wm8776.c
index 879c356a9045..c32249ddb2e0 100644
--- a/sound/soc/codecs/wm8776.c
+++ b/sound/soc/codecs/wm8776.c
@@ -19,6 +19,7 @@
 #include <linux/pm.h>
 #include <linux/i2c.h>
 #include <linux/of_device.h>
+#include <linux/regmap.h>
 #include <linux/spi/spi.h>
 #include <linux/slab.h>
 #include <sound/core.h>
@@ -37,18 +38,46 @@ enum wm8776_chip_type {
 
 /* codec private data */
 struct wm8776_priv {
-        enum snd_soc_control_type control_type;
+        struct regmap *regmap;
         int sysclk[2];
 };
 
-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 const struct reg_default wm8776_reg_defaults[] = {
+        {  0, 0x79 },
+        {  1, 0x79 },
+        {  2, 0x79 },
+        {  3, 0xff },
+        {  4, 0xff },
+        {  5, 0xff },
+        {  6, 0x00 },
+        {  7, 0x90 },
+        {  8, 0x00 },
+        {  9, 0x00 },
+        { 10, 0x22 },
+        { 11, 0x22 },
+        { 12, 0x22 },
+        { 13, 0x08 },
+        { 14, 0xcf },
+        { 15, 0xcf },
+        { 16, 0x7b },
+        { 17, 0x00 },
+        { 18, 0x32 },
+        { 19, 0x00 },
+        { 20, 0xa6 },
+        { 21, 0x01 },
+        { 22, 0x01 },
 };
 
+static bool wm8776_volatile(struct device *dev, unsigned int reg)
+{
+        switch (reg) {
+        case WM8776_RESET:
+                return true;
+        default:
+                return false;
+        }
+}
+
 static int wm8776_reset(struct snd_soc_codec *codec)
 {
         return snd_soc_write(codec, WM8776_RESET, 0);
@@ -306,6 +335,8 @@ static int wm8776_set_sysclk(struct snd_soc_dai *dai,
 static int wm8776_set_bias_level(struct snd_soc_codec *codec,
                                  enum snd_soc_bias_level level)
 {
+        struct wm8776_priv *wm8776 = snd_soc_codec_get_drvdata(codec);
+
         switch (level) {
         case SND_SOC_BIAS_ON:
                 break;
@@ -313,7 +344,7 @@ static int wm8776_set_bias_level(struct snd_soc_codec *codec,
                 break;
         case SND_SOC_BIAS_STANDBY:
                 if (codec->dapm.bias_level == SND_SOC_BIAS_OFF) {
-                        snd_soc_cache_sync(codec);
+                        regcache_sync(wm8776->regmap);
 
                         /* Disable the global powerdown; DAPM does the rest */
                         snd_soc_update_bits(codec, WM8776_PWRDOWN, 1, 0);
@@ -396,10 +427,9 @@ static int wm8776_resume(struct snd_soc_codec *codec)
 
 static int wm8776_probe(struct snd_soc_codec *codec)
 {
-        struct wm8776_priv *wm8776 = snd_soc_codec_get_drvdata(codec);
         int ret = 0;
 
-        ret = snd_soc_codec_set_cache_io(codec, 7, 9, wm8776->control_type);
+        ret = snd_soc_codec_set_cache_io(codec, 7, 9, SND_SOC_REGMAP);
         if (ret < 0) {
                 dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
                 return ret;
@@ -434,9 +464,6 @@ static struct snd_soc_codec_driver soc_codec_dev_wm8776 = {
         .suspend =      wm8776_suspend,
         .resume =       wm8776_resume,
         .set_bias_level = wm8776_set_bias_level,
-        .reg_cache_size = ARRAY_SIZE(wm8776_reg),
-        .reg_word_size = sizeof(u16),
-        .reg_cache_default = wm8776_reg,
 
         .controls = wm8776_snd_controls,
         .num_controls = ARRAY_SIZE(wm8776_snd_controls),
@@ -452,6 +479,18 @@ static const struct of_device_id wm8776_of_match[] = {
 };
 MODULE_DEVICE_TABLE(of, wm8776_of_match);
 
+static const struct regmap_config wm8776_regmap = {
+        .reg_bits = 7,
+        .val_bits = 9,
+        .max_register = WM8776_RESET,
+
+        .reg_defaults = wm8776_reg_defaults,
+        .num_reg_defaults = ARRAY_SIZE(wm8776_reg_defaults),
+        .cache_type = REGCACHE_RBTREE,
+
+        .volatile_reg = wm8776_volatile,
+};
+
 #if defined(CONFIG_SPI_MASTER)
 static int __devinit wm8776_spi_probe(struct spi_device *spi)
 {
@@ -463,7 +502,10 @@ static int __devinit wm8776_spi_probe(struct spi_device *spi)
         if (wm8776 == NULL)
                 return -ENOMEM;
 
-        wm8776->control_type = SND_SOC_SPI;
+        wm8776->regmap = devm_regmap_init_spi(spi, &wm8776_regmap);
+        if (IS_ERR(wm8776->regmap))
+                return PTR_ERR(wm8776->regmap);
+
         spi_set_drvdata(spi, wm8776);
 
         ret = snd_soc_register_codec(&spi->dev,
@@ -501,8 +543,11 @@ static __devinit int wm8776_i2c_probe(struct i2c_client *i2c,
         if (wm8776 == NULL)
                 return -ENOMEM;
 
+        wm8776->regmap = devm_regmap_init_i2c(i2c, &wm8776_regmap);
+        if (IS_ERR(wm8776->regmap))
+                return PTR_ERR(wm8776->regmap);
+
         i2c_set_clientdata(i2c, wm8776);
-        wm8776->control_type = SND_SOC_I2C;
 
         ret =  snd_soc_register_codec(&i2c->dev,
                         &soc_codec_dev_wm8776, wm8776_dai, ARRAY_SIZE(wm8776_dai));
diff --git a/sound/soc/codecs/wm8900.c b/sound/soc/codecs/wm8900.c
index 077c9628c70d..e781f865e5d7 100644
--- a/sound/soc/codecs/wm8900.c
+++ b/sound/soc/codecs/wm8900.c
@@ -23,6 +23,7 @@
 #include <linux/delay.h>
 #include <linux/pm.h>
 #include <linux/i2c.h>
+#include <linux/regmap.h>
 #include <linux/spi/spi.h>
 #include <linux/slab.h>
 #include <sound/core.h>
@@ -137,7 +138,7 @@
 #define WM8900_LRC_MASK 0x03ff
 
 struct wm8900_priv {
-        enum snd_soc_control_type control_type;
+        struct regmap *regmap;
 
         u32 fll_in; /* FLL input frequency */
         u32 fll_out; /* FLL output frequency */
@@ -147,54 +148,77 @@ struct wm8900_priv {
  * wm8900 register cache.  We can't read the entire register space and we
  * have slow control buses so we cache the registers.
  */
-static const u16 wm8900_reg_defaults[WM8900_MAXREG] = {
-        0x8900, 0x0000,
-        0xc000, 0x0000,
-        0x4050, 0x4000,
-        0x0008, 0x0000,
-        0x0040, 0x0040,
-        0x1004, 0x00c0,
-        0x00c0, 0x0000,
-        0x0100, 0x00c0,
-        0x00c0, 0x0000,
-        0xb001, 0x0000,
-        0x0000, 0x0044,
-        0x004c, 0x004c,
-        0x0044, 0x0044,
-        0x0000, 0x0044,
-        0x0000, 0x0000,
-        0x0002, 0x0000,
-        0x0000, 0x0000,
-        0x0000, 0x0000,
-        0x0008, 0x0000,
-        0x0000, 0x0008,
-        0x0097, 0x0100,
-        0x0000, 0x0000,
-        0x0050, 0x0050,
-        0x0055, 0x0055,
-        0x0055, 0x0000,
-        0x0000, 0x0079,
-        0x0079, 0x0079,
-        0x0079, 0x0000,
-        /* Remaining registers all zero */
+static const struct reg_default wm8900_reg_defaults[] = {
+        {  1, 0x0000 },
+        {  2, 0xc000 },
+        {  3, 0x0000 },
+        {  4, 0x4050 },
+        {  5, 0x4000 },
+        {  6, 0x0008 },
+        {  7, 0x0000 },
+        {  8, 0x0040 },
+        {  9, 0x0040 },
+        { 10, 0x1004 },
+        { 11, 0x00c0 },
+        { 12, 0x00c0 },
+        { 13, 0x0000 },
+        { 14, 0x0100 },
+        { 15, 0x00c0 },
+        { 16, 0x00c0 },
+        { 17, 0x0000 },
+        { 18, 0xb001 },
+        { 19, 0x0000 },
+        { 20, 0x0000 },
+        { 21, 0x0044 },
+        { 22, 0x004c },
+        { 23, 0x004c },
+        { 24, 0x0044 },
+        { 25, 0x0044 },
+        { 26, 0x0000 },
+        { 27, 0x0044 },
+        { 28, 0x0000 },
+        { 29, 0x0000 },
+        { 30, 0x0002 },
+        { 31, 0x0000 },
+        { 32, 0x0000 },
+        { 33, 0x0000 },
+        { 34, 0x0000 },
+        { 35, 0x0000 },
+        { 36, 0x0008 },
+        { 37, 0x0000 },
+        { 38, 0x0000 },
+        { 39, 0x0008 },
+        { 40, 0x0097 },
+        { 41, 0x0100 },
+        { 42, 0x0000 },
+        { 43, 0x0000 },
+        { 44, 0x0050 },
+        { 45, 0x0050 },
+        { 46, 0x0055 },
+        { 47, 0x0055 },
+        { 48, 0x0055 },
+        { 49, 0x0000 },
+        { 50, 0x0000 },
+        { 51, 0x0079 },
+        { 52, 0x0079 },
+        { 53, 0x0079 },
+        { 54, 0x0079 },
+        { 55, 0x0000 },
 };
 
-static int wm8900_volatile_register(struct snd_soc_codec *codec, unsigned int reg)
+static bool wm8900_volatile_register(struct device *dev, unsigned int reg)
 {
         switch (reg) {
         case WM8900_REG_ID:
-                return 1;
+                return true;
         default:
-                return 0;
+                return false;
         }
 }
 
 static void wm8900_reset(struct snd_soc_codec *codec)
 {
         snd_soc_write(codec, WM8900_REG_RESET, 0);
-
-        memcpy(codec->reg_cache, wm8900_reg_defaults,
-               sizeof(wm8900_reg_defaults));
 }
 
 static int wm8900_hp_event(struct snd_soc_dapm_widget *w,
@@ -469,10 +493,10 @@ SOC_DAPM_SINGLE("RINPUT2 Switch", WM8900_REG_INCTL, 1, 1, 0),
 SOC_DAPM_SINGLE("RINPUT3 Switch", WM8900_REG_INCTL, 0, 1, 0),
 };
 
-static const char *wm9700_lp_mux[] = { "Disabled", "Enabled" };
+static const char *wm8900_lp_mux[] = { "Disabled", "Enabled" };
 
 static const struct soc_enum wm8900_lineout2_lp_mux =
-SOC_ENUM_SINGLE(WM8900_REG_LOUTMIXCTL1, 1, 2, wm9700_lp_mux);
+SOC_ENUM_SINGLE(WM8900_REG_LOUTMIXCTL1, 1, 2, wm8900_lp_mux);
 
 static const struct snd_kcontrol_new wm8900_lineout2_lp =
 SOC_DAPM_ENUM("Route", wm8900_lineout2_lp_mux);
@@ -1119,13 +1143,16 @@ static int wm8900_suspend(struct snd_soc_codec *codec)
 static int wm8900_resume(struct snd_soc_codec *codec)
 {
         struct wm8900_priv *wm8900 = snd_soc_codec_get_drvdata(codec);
-        u16 *cache;
-        int i, ret;
-
-        cache = kmemdup(codec->reg_cache, sizeof(wm8900_reg_defaults),
-                        GFP_KERNEL);
+        int ret;
 
         wm8900_reset(codec);
+
+        ret = regcache_sync(wm8900->regmap);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to restore cache: %d\n", ret);
+                return ret;
+        }
+
         wm8900_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
 
         /* Restart the FLL? */
@@ -1139,27 +1166,18 @@ static int wm8900_resume(struct snd_soc_codec *codec)
                 ret = wm8900_set_fll(codec, 0, fll_in, fll_out);
                 if (ret != 0) {
                         dev_err(codec->dev, "Failed to restart FLL\n");
-                        kfree(cache);
                         return ret;
                 }
         }
 
-        if (cache) {
-                for (i = 0; i < WM8900_MAXREG; i++)
-                        snd_soc_write(codec, i, cache[i]);
-                kfree(cache);
-        } else
-                dev_err(codec->dev, "Unable to allocate register cache\n");
-
         return 0;
 }
 
 static int wm8900_probe(struct snd_soc_codec *codec)
 {
-        struct wm8900_priv *wm8900 = snd_soc_codec_get_drvdata(codec);
         int ret = 0, reg;
 
-        ret = snd_soc_codec_set_cache_io(codec, 8, 16, wm8900->control_type);
+        ret = snd_soc_codec_set_cache_io(codec, 8, 16, SND_SOC_REGMAP);
         if (ret != 0) {
                 dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
                 return ret;
@@ -1207,10 +1225,6 @@ static struct snd_soc_codec_driver soc_codec_dev_wm8900 = {
         .suspend =      wm8900_suspend,
         .resume =       wm8900_resume,
         .set_bias_level = wm8900_set_bias_level,
-        .volatile_register = wm8900_volatile_register,
-        .reg_cache_size = ARRAY_SIZE(wm8900_reg_defaults),
-        .reg_word_size = sizeof(u16),
-        .reg_cache_default = wm8900_reg_defaults,
 
         .controls = wm8900_snd_controls,
         .num_controls = ARRAY_SIZE(wm8900_snd_controls),
@@ -1220,30 +1234,44 @@ static struct snd_soc_codec_driver soc_codec_dev_wm8900 = {
         .num_dapm_routes = ARRAY_SIZE(wm8900_dapm_routes),
 };
 
+static const struct regmap_config wm8900_regmap = {
+        .reg_bits = 8,
+        .val_bits = 16,
+        .max_register = WM8900_MAXREG,
+
+        .reg_defaults = wm8900_reg_defaults,
+        .num_reg_defaults = ARRAY_SIZE(wm8900_reg_defaults),
+        .cache_type = REGCACHE_RBTREE,
+
+        .volatile_reg = wm8900_volatile_register,
+};
+
 #if defined(CONFIG_SPI_MASTER)
 static int __devinit wm8900_spi_probe(struct spi_device *spi)
 {
         struct wm8900_priv *wm8900;
         int ret;
 
-        wm8900 = kzalloc(sizeof(struct wm8900_priv), GFP_KERNEL);
+        wm8900 = devm_kzalloc(&spi->dev, sizeof(struct wm8900_priv),
+                              GFP_KERNEL);
         if (wm8900 == NULL)
                 return -ENOMEM;
 
-        wm8900->control_type = SND_SOC_SPI;
+        wm8900->regmap = devm_regmap_init_spi(spi, &wm8900_regmap);
+        if (IS_ERR(wm8900->regmap))
+                return PTR_ERR(wm8900->regmap);
+
         spi_set_drvdata(spi, wm8900);
 
         ret = snd_soc_register_codec(&spi->dev,
                         &soc_codec_dev_wm8900, &wm8900_dai, 1);
-        if (ret < 0)
-                kfree(wm8900);
+
         return ret;
 }
 
 static int __devexit wm8900_spi_remove(struct spi_device *spi)
 {
         snd_soc_unregister_codec(&spi->dev);
-        kfree(spi_get_drvdata(spi));
         return 0;
 }
 
@@ -1264,24 +1292,26 @@ static __devinit int wm8900_i2c_probe(struct i2c_client *i2c,
         struct wm8900_priv *wm8900;
         int ret;
 
-        wm8900 = kzalloc(sizeof(struct wm8900_priv), GFP_KERNEL);
+        wm8900 = devm_kzalloc(&i2c->dev, sizeof(struct wm8900_priv),
+                              GFP_KERNEL);
         if (wm8900 == NULL)
                 return -ENOMEM;
 
+        wm8900->regmap = devm_regmap_init_i2c(i2c, &wm8900_regmap);
+        if (IS_ERR(wm8900->regmap))
+                return PTR_ERR(wm8900->regmap);
+
         i2c_set_clientdata(i2c, wm8900);
-        wm8900->control_type = SND_SOC_I2C;
 
         ret =  snd_soc_register_codec(&i2c->dev,
                         &soc_codec_dev_wm8900, &wm8900_dai, 1);
-        if (ret < 0)
-                kfree(wm8900);
+
         return ret;
 }
 
 static __devexit int wm8900_i2c_remove(struct i2c_client *client)
 {
         snd_soc_unregister_codec(&client->dev);
-        kfree(i2c_get_clientdata(client));
         return 0;
 }
 
diff --git a/sound/soc/codecs/wm8903.c b/sound/soc/codecs/wm8903.c
index 73f1c8d7bafb..839414f9e2ed 100644
--- a/sound/soc/codecs/wm8903.c
+++ b/sound/soc/codecs/wm8903.c
@@ -2241,23 +2241,7 @@ static struct i2c_driver wm8903_i2c_driver = {
         .id_table = wm8903_i2c_id,
 };
 
-static int __init wm8903_modinit(void)
-{
-        int ret = 0;
-        ret = i2c_add_driver(&wm8903_i2c_driver);
-        if (ret != 0) {
-                printk(KERN_ERR "Failed to register wm8903 I2C driver: %d\n",
-                       ret);
-        }
-        return ret;
-}
-module_init(wm8903_modinit);
-
-static void __exit wm8903_exit(void)
-{
-        i2c_del_driver(&wm8903_i2c_driver);
-}
-module_exit(wm8903_exit);
+module_i2c_driver(wm8903_i2c_driver);
 
 MODULE_DESCRIPTION("ASoC WM8903 driver");
 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.cm>");
diff --git a/sound/soc/codecs/wm8904.c b/sound/soc/codecs/wm8904.c
index 0013afe48e66..7c8df52a8d9d 100644
--- a/sound/soc/codecs/wm8904.c
+++ b/sound/soc/codecs/wm8904.c
@@ -100,7 +100,7 @@ static const struct reg_default wm8904_reg_defaults[] = {
         { 14,  0x0000 },     /* R14  - Power Management 2 */
         { 15,  0x0000 },     /* R15  - Power Management 3 */
         { 18,  0x0000 },     /* R18  - Power Management 6 */
-        { 19,  0x945E },     /* R20  - Clock Rates 0 */
+        { 20,  0x945E },     /* R20  - Clock Rates 0 */
         { 21,  0x0C05 },     /* R21  - Clock Rates 1 */
         { 22,  0x0006 },     /* R22  - Clock Rates 2 */
         { 24,  0x0050 },     /* R24  - Audio Interface 0 */
@@ -1185,8 +1185,6 @@ static int wm8904_add_widgets(struct snd_soc_codec *codec)
                 snd_soc_dapm_new_controls(dapm, wm8904_dapm_widgets,
                                           ARRAY_SIZE(wm8904_dapm_widgets));
 
-                snd_soc_dapm_add_routes(dapm, core_intercon,
-                                        ARRAY_SIZE(core_intercon));
                 snd_soc_dapm_add_routes(dapm, adc_intercon,
                                         ARRAY_SIZE(adc_intercon));
                 snd_soc_dapm_add_routes(dapm, dac_intercon,
diff --git a/sound/soc/codecs/wm8940.c b/sound/soc/codecs/wm8940.c
index 481a3d9cfe48..b20aa4e7c3f9 100644
--- a/sound/soc/codecs/wm8940.c
+++ b/sound/soc/codecs/wm8940.c
@@ -785,23 +785,7 @@ static struct i2c_driver wm8940_i2c_driver = {
         .id_table = wm8940_i2c_id,
 };
 
-static int __init wm8940_modinit(void)
-{
-        int ret = 0;
-        ret = i2c_add_driver(&wm8940_i2c_driver);
-        if (ret != 0) {
-                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_i2c_driver(wm8940_i2c_driver);
 
 MODULE_DESCRIPTION("ASoC WM8940 driver");
 MODULE_AUTHOR("Jonathan Cameron");
diff --git a/sound/soc/codecs/wm8955.c b/sound/soc/codecs/wm8955.c
index 61fe97433e73..2f1c075755b1 100644
--- a/sound/soc/codecs/wm8955.c
+++ b/sound/soc/codecs/wm8955.c
@@ -1071,23 +1071,7 @@ static struct i2c_driver wm8955_i2c_driver = {
         .id_table = wm8955_i2c_id,
 };
 
-static int __init wm8955_modinit(void)
-{
-        int ret = 0;
-        ret = i2c_add_driver(&wm8955_i2c_driver);
-        if (ret != 0) {
-                printk(KERN_ERR "Failed to register WM8955 I2C driver: %d\n",
-                       ret);
-        }
-        return ret;
-}
-module_init(wm8955_modinit);
-
-static void __exit wm8955_exit(void)
-{
-        i2c_del_driver(&wm8955_i2c_driver);
-}
-module_exit(wm8955_exit);
+module_i2c_driver(wm8955_i2c_driver);
 
 MODULE_DESCRIPTION("ASoC WM8955 driver");
 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
diff --git a/sound/soc/codecs/wm8958-dsp2.c b/sound/soc/codecs/wm8958-dsp2.c
index 1332692ef81b..00121ba36597 100644
--- a/sound/soc/codecs/wm8958-dsp2.c
+++ b/sound/soc/codecs/wm8958-dsp2.c
@@ -946,7 +946,7 @@ void wm8958_dsp2_init(struct snd_soc_codec *codec)
                 wm8994->mbc_texts = kmalloc(sizeof(char *)
                                             * pdata->num_mbc_cfgs, GFP_KERNEL);
                 if (!wm8994->mbc_texts) {
-                        dev_err(wm8994->codec->dev,
+                        dev_err(wm8994->hubs.codec->dev,
                                 "Failed to allocate %d MBC config texts\n",
                                 pdata->num_mbc_cfgs);
                         return;
@@ -958,9 +958,10 @@ void wm8958_dsp2_init(struct snd_soc_codec *codec)
                 wm8994->mbc_enum.max = pdata->num_mbc_cfgs;
                 wm8994->mbc_enum.texts = wm8994->mbc_texts;
 
-                ret = snd_soc_add_codec_controls(wm8994->codec, control, 1);
+                ret = snd_soc_add_codec_controls(wm8994->hubs.codec,
+                                                 control, 1);
                 if (ret != 0)
-                        dev_err(wm8994->codec->dev,
+                        dev_err(wm8994->hubs.codec->dev,
                                 "Failed to add MBC mode controls: %d\n", ret);
         }
 
@@ -974,7 +975,7 @@ void wm8958_dsp2_init(struct snd_soc_codec *codec)
                 wm8994->vss_texts = kmalloc(sizeof(char *)
                                             * pdata->num_vss_cfgs, GFP_KERNEL);
                 if (!wm8994->vss_texts) {
-                        dev_err(wm8994->codec->dev,
+                        dev_err(wm8994->hubs.codec->dev,
                                 "Failed to allocate %d VSS config texts\n",
                                 pdata->num_vss_cfgs);
                         return;
@@ -986,9 +987,10 @@ void wm8958_dsp2_init(struct snd_soc_codec *codec)
                 wm8994->vss_enum.max = pdata->num_vss_cfgs;
                 wm8994->vss_enum.texts = wm8994->vss_texts;
 
-                ret = snd_soc_add_codec_controls(wm8994->codec, control, 1);
+                ret = snd_soc_add_codec_controls(wm8994->hubs.codec,
+                                                 control, 1);
                 if (ret != 0)
-                        dev_err(wm8994->codec->dev,
+                        dev_err(wm8994->hubs.codec->dev,
                                 "Failed to add VSS mode controls: %d\n", ret);
         }
 
@@ -1003,7 +1005,7 @@ void wm8958_dsp2_init(struct snd_soc_codec *codec)
                 wm8994->vss_hpf_texts = kmalloc(sizeof(char *)
                                                 * pdata->num_vss_hpf_cfgs, GFP_KERNEL);
                 if (!wm8994->vss_hpf_texts) {
-                        dev_err(wm8994->codec->dev,
+                        dev_err(wm8994->hubs.codec->dev,
                                 "Failed to allocate %d VSS HPF config texts\n",
                                 pdata->num_vss_hpf_cfgs);
                         return;
@@ -1015,9 +1017,10 @@ void wm8958_dsp2_init(struct snd_soc_codec *codec)
                 wm8994->vss_hpf_enum.max = pdata->num_vss_hpf_cfgs;
                 wm8994->vss_hpf_enum.texts = wm8994->vss_hpf_texts;
 
-                ret = snd_soc_add_codec_controls(wm8994->codec, control, 1);
+                ret = snd_soc_add_codec_controls(wm8994->hubs.codec,
+                                                 control, 1);
                 if (ret != 0)
-                        dev_err(wm8994->codec->dev,
+                        dev_err(wm8994->hubs.codec->dev,
                                 "Failed to add VSS HPFmode controls: %d\n",
                                 ret);
         }
@@ -1033,7 +1036,7 @@ void wm8958_dsp2_init(struct snd_soc_codec *codec)
                 wm8994->enh_eq_texts = kmalloc(sizeof(char *)
                                                 * pdata->num_enh_eq_cfgs, GFP_KERNEL);
                 if (!wm8994->enh_eq_texts) {
-                        dev_err(wm8994->codec->dev,
+                        dev_err(wm8994->hubs.codec->dev,
                                 "Failed to allocate %d enhanced EQ config texts\n",
                                 pdata->num_enh_eq_cfgs);
                         return;
@@ -1045,9 +1048,10 @@ void wm8958_dsp2_init(struct snd_soc_codec *codec)
                 wm8994->enh_eq_enum.max = pdata->num_enh_eq_cfgs;
                 wm8994->enh_eq_enum.texts = wm8994->enh_eq_texts;
 
-                ret = snd_soc_add_codec_controls(wm8994->codec, control, 1);
+                ret = snd_soc_add_codec_controls(wm8994->hubs.codec,
+                                                 control, 1);
                 if (ret != 0)
-                        dev_err(wm8994->codec->dev,
+                        dev_err(wm8994->hubs.codec->dev,
                                 "Failed to add enhanced EQ controls: %d\n",
                                 ret);
         }
diff --git a/sound/soc/codecs/wm8960.c b/sound/soc/codecs/wm8960.c
index 96518ac8e24c..f0f6f6601785 100644
--- a/sound/soc/codecs/wm8960.c
+++ b/sound/soc/codecs/wm8960.c
@@ -52,25 +52,72 @@
  * 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,
+static const struct reg_default wm8960_reg_defaults[] = {
+        {  0x0, 0x0097 },
+        {  0x1, 0x0097 },
+        {  0x2, 0x0000 },
+        {  0x3, 0x0000 },
+        {  0x4, 0x0000 },
+        {  0x5, 0x0008 },
+        {  0x6, 0x0000 },
+        {  0x7, 0x000a },
+        {  0x8, 0x01c0 },
+        {  0x9, 0x0000 },
+        {  0xa, 0x00ff },
+        {  0xb, 0x00ff },
+
+        { 0x10, 0x0000 },
+        { 0x11, 0x007b },
+        { 0x12, 0x0100 },
+        { 0x13, 0x0032 },
+        { 0x14, 0x0000 },
+        { 0x15, 0x00c3 },
+        { 0x16, 0x00c3 },
+        { 0x17, 0x01c0 },
+        { 0x18, 0x0000 },
+        { 0x19, 0x0000 },
+        { 0x1a, 0x0000 },
+        { 0x1b, 0x0000 },
+        { 0x1c, 0x0000 },
+        { 0x1d, 0x0000 },
+
+        { 0x20, 0x0100 },
+        { 0x21, 0x0100 },
+        { 0x22, 0x0050 },
+
+        { 0x25, 0x0050 },
+        { 0x26, 0x0000 },
+        { 0x27, 0x0000 },
+        { 0x28, 0x0000 },
+        { 0x29, 0x0000 },
+        { 0x2a, 0x0040 },
+        { 0x2b, 0x0000 },
+        { 0x2c, 0x0000 },
+        { 0x2d, 0x0050 },
+        { 0x2e, 0x0050 },
+        { 0x2f, 0x0000 },
+        { 0x30, 0x0002 },
+        { 0x31, 0x0037 },
+
+        { 0x33, 0x0080 },
+        { 0x34, 0x0008 },
+        { 0x35, 0x0031 },
+        { 0x36, 0x0026 },
+        { 0x37, 0x00e9 },
 };
 
+static bool wm8960_volatile(struct device *dev, unsigned int reg)
+{
+        switch (reg) {
+        case WM8960_RESET:
+                return true;
+        default:
+                return false;
+        }
+}
+
 struct wm8960_priv {
-        enum snd_soc_control_type control_type;
+        struct regmap *regmap;
         int (*set_bias_level)(struct snd_soc_codec *,
                               enum snd_soc_bias_level level);
         struct snd_soc_dapm_widget *lout1;
@@ -510,18 +557,25 @@ static int wm8960_hw_params(struct snd_pcm_substream *substream,
         struct snd_soc_codec *codec = dai->codec;
         struct wm8960_priv *wm8960 = snd_soc_codec_get_drvdata(codec);
         u16 iface = snd_soc_read(codec, WM8960_IFACE1) & 0xfff3;
+        snd_pcm_format_t format = params_format(params);
         int i;
 
         /* bit size */
-        switch (params_format(params)) {
+        switch (format) {
         case SNDRV_PCM_FORMAT_S16_LE:
+        case SNDRV_PCM_FORMAT_S16_BE:
                 break;
         case SNDRV_PCM_FORMAT_S20_3LE:
+        case SNDRV_PCM_FORMAT_S20_3BE:
                 iface |= 0x0004;
                 break;
         case SNDRV_PCM_FORMAT_S24_LE:
+        case SNDRV_PCM_FORMAT_S24_BE:
                 iface |= 0x0008;
                 break;
+        default:
+                dev_err(codec->dev, "unsupported format %i\n", format);
+                return -EINVAL;
         }
 
         /* Update filters for the new rate */
@@ -555,6 +609,8 @@ static int wm8960_mute(struct snd_soc_dai *dai, int mute)
 static int wm8960_set_bias_level_out3(struct snd_soc_codec *codec,
                                       enum snd_soc_bias_level level)
 {
+        struct wm8960_priv *wm8960 = snd_soc_codec_get_drvdata(codec);
+
         switch (level) {
         case SND_SOC_BIAS_ON:
                 break;
@@ -566,7 +622,7 @@ static int wm8960_set_bias_level_out3(struct snd_soc_codec *codec,
 
         case SND_SOC_BIAS_STANDBY:
                 if (codec->dapm.bias_level == SND_SOC_BIAS_OFF) {
-                        snd_soc_cache_sync(codec);
+                        regcache_sync(wm8960->regmap);
 
                         /* Enable anti-pop features */
                         snd_soc_write(codec, WM8960_APOP1,
@@ -667,7 +723,7 @@ static int wm8960_set_bias_level_capless(struct snd_soc_codec *codec,
                         break;
 
                 case SND_SOC_BIAS_OFF:
-                        snd_soc_cache_sync(codec);
+                        regcache_sync(wm8960->regmap);
                         break;
                 default:
                         break;
@@ -906,16 +962,11 @@ static int wm8960_probe(struct snd_soc_codec *codec)
         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;
-                }
-
                 if (pdata->capless)
                         wm8960->set_bias_level = wm8960_set_bias_level_capless;
         }
 
-        ret = snd_soc_codec_set_cache_io(codec, 7, 9, wm8960->control_type);
+        ret = snd_soc_codec_set_cache_io(codec, 7, 9, SND_SOC_REGMAP);
         if (ret < 0) {
                 dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
                 return ret;
@@ -963,14 +1014,24 @@ static struct snd_soc_codec_driver soc_codec_dev_wm8960 = {
         .suspend =      wm8960_suspend,
         .resume =       wm8960_resume,
         .set_bias_level = wm8960_set_bias_level,
-        .reg_cache_size = ARRAY_SIZE(wm8960_reg),
-        .reg_word_size = sizeof(u16),
-        .reg_cache_default = wm8960_reg,
+};
+
+static const struct regmap_config wm8960_regmap = {
+        .reg_bits = 7,
+        .val_bits = 9,
+        .max_register = WM8960_PLL4,
+
+        .reg_defaults = wm8960_reg_defaults,
+        .num_reg_defaults = ARRAY_SIZE(wm8960_reg_defaults),
+        .cache_type = REGCACHE_RBTREE,
+
+        .volatile_reg = wm8960_volatile,
 };
 
 static __devinit int wm8960_i2c_probe(struct i2c_client *i2c,
                                       const struct i2c_device_id *id)
 {
+        struct wm8960_data *pdata = dev_get_platdata(&i2c->dev);
         struct wm8960_priv *wm8960;
         int ret;
 
@@ -979,8 +1040,21 @@ static __devinit int wm8960_i2c_probe(struct i2c_client *i2c,
         if (wm8960 == NULL)
                 return -ENOMEM;
 
+        wm8960->regmap = regmap_init_i2c(i2c, &wm8960_regmap);
+        if (IS_ERR(wm8960->regmap))
+                return PTR_ERR(wm8960->regmap);
+
+        if (pdata && pdata->shared_lrclk) {
+                ret = regmap_update_bits(wm8960->regmap, WM8960_ADDCTL2,
+                                         0x4, 0x4);
+                if (ret != 0) {
+                        dev_err(&i2c->dev, "Failed to enable LRCM: %d\n",
+                                ret);
+                        return ret;
+                }
+        }
+
         i2c_set_clientdata(i2c, wm8960);
-        wm8960->control_type = SND_SOC_I2C;
 
         ret = snd_soc_register_codec(&i2c->dev,
                         &soc_codec_dev_wm8960, &wm8960_dai, 1);
@@ -1010,23 +1084,7 @@ static struct i2c_driver wm8960_i2c_driver = {
         .id_table = wm8960_i2c_id,
 };
 
-static int __init wm8960_modinit(void)
-{
-        int ret = 0;
-        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_i2c_driver(wm8960_i2c_driver);
 
 MODULE_DESCRIPTION("ASoC WM8960 driver");
 MODULE_AUTHOR("Liam Girdwood");
diff --git a/sound/soc/codecs/wm8961.c b/sound/soc/codecs/wm8961.c
index 01edbcc754d2..f387670d0d75 100644
--- a/sound/soc/codecs/wm8961.c
+++ b/sound/soc/codecs/wm8961.c
@@ -19,6 +19,7 @@
 #include <linux/delay.h>
 #include <linux/pm.h>
 #include <linux/i2c.h>
+#include <linux/regmap.h>
 #include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
@@ -31,283 +32,159 @@
 
 #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 */
+static const struct reg_default wm8961_reg_defaults[] = {
+        {  0, 0x009F },     /* R0   - Left Input volume */
+        {  1, 0x009F },     /* R1   - Right Input volume */
+        {  2, 0x0000 },     /* R2   - LOUT1 volume */
+        {  3, 0x0000 },     /* R3   - ROUT1 volume */
+        {  4, 0x0020 },     /* R4   - Clocking1 */
+        {  5, 0x0008 },     /* R5   - ADC & DAC Control 1 */
+        {  6, 0x0000 },     /* R6   - ADC & DAC Control 2 */
+        {  7, 0x000A },     /* R7   - Audio Interface 0 */
+        {  8, 0x01F4 },     /* R8   - Clocking2 */
+        {  9, 0x0000 },     /* R9   - Audio Interface 1 */
+        { 10, 0x00FF },     /* R10  - Left DAC volume */
+        { 11, 0x00FF },     /* R11  - Right DAC volume */
+
+        { 14, 0x0040 },     /* R14  - Audio Interface 2 */
+
+        { 17, 0x007B },     /* R17  - ALC1 */
+        { 18, 0x0000 },     /* R18  - ALC2 */
+        { 19, 0x0032 },     /* R19  - ALC3 */
+        { 20, 0x0000 },     /* R20  - Noise Gate */
+        { 21, 0x00C0 },     /* R21  - Left ADC volume */
+        { 22, 0x00C0 },     /* R22  - Right ADC volume */
+        { 23, 0x0120 },     /* R23  - Additional control(1) */
+        { 24, 0x0000 },     /* R24  - Additional control(2) */
+        { 25, 0x0000 },     /* R25  - Pwr Mgmt (1) */
+        { 26, 0x0000 },     /* R26  - Pwr Mgmt (2) */
+        { 27, 0x0000 },     /* R27  - Additional Control (3) */
+        { 28, 0x0000 },     /* R28  - Anti-pop */
+
+        { 30, 0x005F },     /* R30  - Clocking 3 */
+
+        { 32, 0x0000 },     /* R32  - ADCL signal path */
+        { 33, 0x0000 },     /* R33  - ADCR signal path */
+
+        { 40, 0x0000 },     /* R40  - LOUT2 volume */
+        { 41, 0x0000 },     /* R41  - ROUT2 volume */
+
+        { 47, 0x0000 },     /* R47  - Pwr Mgmt (3) */
+        { 48, 0x0023 },     /* R48  - Additional Control (4) */
+        { 49, 0x0000 },     /* R49  - Class D Control 1 */
+
+        { 51, 0x0003 },     /* R51  - Class D Control 2 */
+
+        { 56, 0x0106 },     /* R56  - Clocking 4 */
+        { 57, 0x0000 },     /* R57  - DSP Sidetone 0 */
+        { 58, 0x0000 },     /* R58  - DSP Sidetone 1 */
+
+        { 60, 0x0000 },     /* R60  - DC Servo 0 */
+        { 61, 0x0000 },     /* R61  - DC Servo 1 */
+
+        { 63, 0x015E },     /* R63  - DC Servo 3 */
+
+        { 65, 0x0010 },     /* R65  - DC Servo 5 */
+
+        { 68, 0x0003 },     /* R68  - Analogue PGA Bias */
+        { 69, 0x0000 },     /* R69  - Analogue HP 0 */
+
+        { 71, 0x01FB },     /* R71  - Analogue HP 2 */
+        { 72, 0x0000 },     /* R72  - Charge Pump 1 */
+
+        { 82, 0x0000 },     /* R82  - Charge Pump B */
+
+        { 87, 0x0000 },     /* R87  - Write Sequencer 1 */
+        { 88, 0x0000 },     /* R88  - Write Sequencer 2 */
+        { 89, 0x0000 },     /* R89  - Write Sequencer 3 */
+        { 90, 0x0000 },     /* R90  - Write Sequencer 4 */
+        { 91, 0x0000 },     /* R91  - Write Sequencer 5 */
+        { 92, 0x0000 },     /* R92  - Write Sequencer 6 */
+        { 93, 0x0000 },     /* R93  - Write Sequencer 7 */
+
+        { 252, 0x0001 },     /* R252 - General test 1 */
 };
 
 struct wm8961_priv {
-        enum snd_soc_control_type control_type;
+        struct regmap *regmap;
         int sysclk;
 };
 
-static int wm8961_volatile_register(struct snd_soc_codec *codec, unsigned int reg)
+static bool wm8961_volatile(struct device *dev, unsigned int reg)
 {
         switch (reg) {
         case WM8961_SOFTWARE_RESET:
         case WM8961_WRITE_SEQUENCER_7:
         case WM8961_DC_SERVO_1:
-                return 1;
+                return true;
 
         default:
-                return 0;
+                return false;
         }
 }
 
-static int wm8961_reset(struct snd_soc_codec *codec)
+static bool wm8961_readable(struct device *dev, unsigned int reg)
 {
-        return snd_soc_write(codec, WM8961_SOFTWARE_RESET, 0);
+        switch (reg) {
+        case WM8961_LEFT_INPUT_VOLUME:
+        case WM8961_RIGHT_INPUT_VOLUME:
+        case WM8961_LOUT1_VOLUME:
+        case WM8961_ROUT1_VOLUME:
+        case WM8961_CLOCKING1:
+        case WM8961_ADC_DAC_CONTROL_1:
+        case WM8961_ADC_DAC_CONTROL_2:
+        case WM8961_AUDIO_INTERFACE_0:
+        case WM8961_CLOCKING2:
+        case WM8961_AUDIO_INTERFACE_1:
+        case WM8961_LEFT_DAC_VOLUME:
+        case WM8961_RIGHT_DAC_VOLUME:
+        case WM8961_AUDIO_INTERFACE_2:
+        case WM8961_SOFTWARE_RESET:
+        case WM8961_ALC1:
+        case WM8961_ALC2:
+        case WM8961_ALC3:
+        case WM8961_NOISE_GATE:
+        case WM8961_LEFT_ADC_VOLUME:
+        case WM8961_RIGHT_ADC_VOLUME:
+        case WM8961_ADDITIONAL_CONTROL_1:
+        case WM8961_ADDITIONAL_CONTROL_2:
+        case WM8961_PWR_MGMT_1:
+        case WM8961_PWR_MGMT_2:
+        case WM8961_ADDITIONAL_CONTROL_3:
+        case WM8961_ANTI_POP:
+        case WM8961_CLOCKING_3:
+        case WM8961_ADCL_SIGNAL_PATH:
+        case WM8961_ADCR_SIGNAL_PATH:
+        case WM8961_LOUT2_VOLUME:
+        case WM8961_ROUT2_VOLUME:
+        case WM8961_PWR_MGMT_3:
+        case WM8961_ADDITIONAL_CONTROL_4:
+        case WM8961_CLASS_D_CONTROL_1:
+        case WM8961_CLASS_D_CONTROL_2:
+        case WM8961_CLOCKING_4:
+        case WM8961_DSP_SIDETONE_0:
+        case WM8961_DSP_SIDETONE_1:
+        case WM8961_DC_SERVO_0:
+        case WM8961_DC_SERVO_1:
+        case WM8961_DC_SERVO_3:
+        case WM8961_DC_SERVO_5:
+        case WM8961_ANALOGUE_PGA_BIAS:
+        case WM8961_ANALOGUE_HP_0:
+        case WM8961_ANALOGUE_HP_2:
+        case WM8961_CHARGE_PUMP_1:
+        case WM8961_CHARGE_PUMP_B:
+        case WM8961_WRITE_SEQUENCER_1:
+        case WM8961_WRITE_SEQUENCER_2:
+        case WM8961_WRITE_SEQUENCER_3:
+        case WM8961_WRITE_SEQUENCER_4:
+        case WM8961_WRITE_SEQUENCER_5:
+        case WM8961_WRITE_SEQUENCER_6:
+        case WM8961_WRITE_SEQUENCER_7:
+        case WM8961_GENERAL_TEST_1:
+                return true;
+        default:
+                return false;
+        }
 }
 
 /*
@@ -962,33 +839,12 @@ static int wm8961_probe(struct snd_soc_codec *codec)
         int ret = 0;
         u16 reg;
 
-        ret = snd_soc_codec_set_cache_io(codec, 8, 16, SND_SOC_I2C);
+        ret = snd_soc_codec_set_cache_io(codec, 8, 16, SND_SOC_REGMAP);
         if (ret != 0) {
                 dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
                 return ret;
         }
 
-        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);
-                return -EINVAL;
-        }
-
-        /* This isn't volatile - readback doesn't correspond to write */
-        codec->cache_bypass = 1;
-        reg = snd_soc_read(codec, WM8961_RIGHT_INPUT_VOLUME);
-        codec->cache_bypass = 0;
-        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;
@@ -1066,16 +922,26 @@ static struct snd_soc_codec_driver soc_codec_dev_wm8961 = {
         .suspend =      wm8961_suspend,
         .resume =       wm8961_resume,
         .set_bias_level = wm8961_set_bias_level,
-        .reg_cache_size = ARRAY_SIZE(wm8961_reg_defaults),
-        .reg_word_size = sizeof(u16),
-        .reg_cache_default = wm8961_reg_defaults,
-        .volatile_register = wm8961_volatile_register,
+};
+
+static const struct regmap_config wm8961_regmap = {
+        .reg_bits = 8,
+        .val_bits = 16,
+        .max_register = WM8961_MAX_REGISTER,
+
+        .reg_defaults = wm8961_reg_defaults,
+        .num_reg_defaults = ARRAY_SIZE(wm8961_reg_defaults),
+        .cache_type = REGCACHE_RBTREE,
+
+        .volatile_reg = wm8961_volatile,
+        .readable_reg = wm8961_readable,
 };
 
 static __devinit int wm8961_i2c_probe(struct i2c_client *i2c,
                                       const struct i2c_device_id *id)
 {
         struct wm8961_priv *wm8961;
+        unsigned int val;
         int ret;
 
         wm8961 = devm_kzalloc(&i2c->dev, sizeof(struct wm8961_priv),
@@ -1083,6 +949,42 @@ static __devinit int wm8961_i2c_probe(struct i2c_client *i2c,
         if (wm8961 == NULL)
                 return -ENOMEM;
 
+        wm8961->regmap = devm_regmap_init_i2c(i2c, &wm8961_regmap);
+        if (IS_ERR(wm8961->regmap))
+                return PTR_ERR(wm8961->regmap);
+
+        ret = regmap_read(wm8961->regmap, WM8961_SOFTWARE_RESET, &val);
+        if (ret != 0) {
+                dev_err(&i2c->dev, "Failed to read chip ID: %d\n", ret);
+                return ret;
+        }
+
+        if (val != 0x1801) {
+                dev_err(&i2c->dev, "Device is not a WM8961: ID=0x%x\n", val);
+                return -EINVAL;
+        }
+
+        /* This isn't volatile - readback doesn't correspond to write */
+        regcache_cache_bypass(wm8961->regmap, true);
+        ret = regmap_read(wm8961->regmap, WM8961_RIGHT_INPUT_VOLUME, &val);
+        regcache_cache_bypass(wm8961->regmap, false);
+
+        if (ret != 0) {
+                dev_err(&i2c->dev, "Failed to read chip revision: %d\n", ret);
+                return ret;
+        }
+
+        dev_info(&i2c->dev, "WM8961 family %d revision %c\n",
+                 (val & WM8961_DEVICE_ID_MASK) >> WM8961_DEVICE_ID_SHIFT,
+                 ((val & WM8961_CHIP_REV_MASK) >> WM8961_CHIP_REV_SHIFT)
+                 + 'A');
+
+        ret = regmap_write(wm8961->regmap, WM8961_SOFTWARE_RESET, 0x1801);
+        if (ret != 0) {
+                dev_err(&i2c->dev, "Failed to issue reset: %d\n", ret);
+                return ret;
+        }
+
         i2c_set_clientdata(i2c, wm8961);
 
         ret = snd_soc_register_codec(&i2c->dev,
@@ -1114,23 +1016,7 @@ static struct i2c_driver wm8961_i2c_driver = {
         .id_table = wm8961_i2c_id,
 };
 
-static int __init wm8961_modinit(void)
-{
-        int ret = 0;
-        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_i2c_driver(wm8961_i2c_driver);
 
 MODULE_DESCRIPTION("ASoC WM8961 driver");
 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
diff --git a/sound/soc/codecs/wm8971.c b/sound/soc/codecs/wm8971.c
index eef783f6b6d6..5ce647758443 100644
--- a/sound/soc/codecs/wm8971.c
+++ b/sound/soc/codecs/wm8971.c
@@ -721,23 +721,7 @@ static struct i2c_driver wm8971_i2c_driver = {
         .id_table = wm8971_i2c_id,
 };
 
-static int __init wm8971_modinit(void)
-{
-        int ret = 0;
-        ret = i2c_add_driver(&wm8971_i2c_driver);
-        if (ret != 0) {
-                printk(KERN_ERR "Failed to register WM8971 I2C driver: %d\n",
-                       ret);
-        }
-        return ret;
-}
-module_init(wm8971_modinit);
-
-static void __exit wm8971_exit(void)
-{
-        i2c_del_driver(&wm8971_i2c_driver);
-}
-module_exit(wm8971_exit);
+module_i2c_driver(wm8971_i2c_driver);
 
 MODULE_DESCRIPTION("ASoC WM8971 driver");
 MODULE_AUTHOR("Lab126");
diff --git a/sound/soc/codecs/wm8974.c b/sound/soc/codecs/wm8974.c
index d93c03f820c9..9a39511af52a 100644
--- a/sound/soc/codecs/wm8974.c
+++ b/sound/soc/codecs/wm8974.c
@@ -659,23 +659,7 @@ static struct i2c_driver wm8974_i2c_driver = {
         .id_table = wm8974_i2c_id,
 };
 
-static int __init wm8974_modinit(void)
-{
-        int ret = 0;
-        ret = i2c_add_driver(&wm8974_i2c_driver);
-        if (ret != 0) {
-                printk(KERN_ERR "Failed to register wm8974 I2C driver: %d\n",
-                       ret);
-        }
-        return ret;
-}
-module_init(wm8974_modinit);
-
-static void __exit wm8974_exit(void)
-{
-        i2c_del_driver(&wm8974_i2c_driver);
-}
-module_exit(wm8974_exit);
+module_i2c_driver(wm8974_i2c_driver);
 
 MODULE_DESCRIPTION("ASoC WM8974 driver");
 MODULE_AUTHOR("Liam Girdwood");
diff --git a/sound/soc/codecs/wm8978.c b/sound/soc/codecs/wm8978.c
index a5be3adecf75..5421fd9fbcb5 100644
--- a/sound/soc/codecs/wm8978.c
+++ b/sound/soc/codecs/wm8978.c
@@ -1105,23 +1105,7 @@ static struct i2c_driver wm8978_i2c_driver = {
         .id_table = wm8978_i2c_id,
 };
 
-static int __init wm8978_modinit(void)
-{
-        int ret = 0;
-        ret = i2c_add_driver(&wm8978_i2c_driver);
-        if (ret != 0) {
-                printk(KERN_ERR "Failed to register WM8978 I2C driver: %d\n",
-                       ret);
-        }
-        return ret;
-}
-module_init(wm8978_modinit);
-
-static void __exit wm8978_exit(void)
-{
-        i2c_del_driver(&wm8978_i2c_driver);
-}
-module_exit(wm8978_exit);
+module_i2c_driver(wm8978_i2c_driver);
 
 MODULE_DESCRIPTION("ASoC WM8978 codec driver");
 MODULE_AUTHOR("Guennadi Liakhovetski <g.liakhovetski@gmx.de>");
diff --git a/sound/soc/codecs/wm8983.c b/sound/soc/codecs/wm8983.c
index 367388fdc486..d8879f262d27 100644
--- a/sound/soc/codecs/wm8983.c
+++ b/sound/soc/codecs/wm8983.c
@@ -16,6 +16,7 @@
 #include <linux/delay.h>
 #include <linux/pm.h>
 #include <linux/i2c.h>
+#include <linux/regmap.h>
 #include <linux/spi/spi.h>
 #include <linux/slab.h>
 #include <sound/core.h>
@@ -27,61 +28,60 @@
 
 #include "wm8983.h"
 
-static const u16 wm8983_reg_defs[WM8983_MAX_REGISTER + 1] = {
-        [0x00] = 0x0000,     /* R0  - Software Reset */
-        [0x01] = 0x0000,     /* R1  - Power management 1 */
-        [0x02] = 0x0000,     /* R2  - Power management 2 */
-        [0x03] = 0x0000,     /* R3  - Power management 3 */
-        [0x04] = 0x0050,     /* R4  - Audio Interface */
-        [0x05] = 0x0000,     /* R5  - Companding control */
-        [0x06] = 0x0140,     /* R6  - Clock Gen control */
-        [0x07] = 0x0000,     /* R7  - Additional control */
-        [0x08] = 0x0000,     /* R8  - GPIO Control */
-        [0x09] = 0x0000,     /* R9  - Jack Detect Control 1 */
-        [0x0A] = 0x0000,     /* R10 - DAC Control */
-        [0x0B] = 0x00FF,     /* R11 - Left DAC digital Vol */
-        [0x0C] = 0x00FF,     /* R12 - Right DAC digital vol */
-        [0x0D] = 0x0000,     /* R13 - Jack Detect Control 2 */
-        [0x0E] = 0x0100,     /* R14 - ADC Control */
-        [0x0F] = 0x00FF,     /* R15 - Left ADC Digital Vol */
-        [0x10] = 0x00FF,     /* R16 - Right ADC Digital Vol */
-        [0x12] = 0x012C,     /* R18 - EQ1 - low shelf */
-        [0x13] = 0x002C,     /* R19 - EQ2 - peak 1 */
-        [0x14] = 0x002C,     /* R20 - EQ3 - peak 2 */
-        [0x15] = 0x002C,     /* R21 - EQ4 - peak 3 */
-        [0x16] = 0x002C,     /* R22 - EQ5 - high shelf */
-        [0x18] = 0x0032,     /* R24 - DAC Limiter 1 */
-        [0x19] = 0x0000,     /* R25 - DAC Limiter 2 */
-        [0x1B] = 0x0000,     /* R27 - Notch Filter 1 */
-        [0x1C] = 0x0000,     /* R28 - Notch Filter 2 */
-        [0x1D] = 0x0000,     /* R29 - Notch Filter 3 */
-        [0x1E] = 0x0000,     /* R30 - Notch Filter 4 */
-        [0x20] = 0x0038,     /* R32 - ALC control 1 */
-        [0x21] = 0x000B,     /* R33 - ALC control 2 */
-        [0x22] = 0x0032,     /* R34 - ALC control 3 */
-        [0x23] = 0x0000,     /* R35 - Noise Gate */
-        [0x24] = 0x0008,     /* R36 - PLL N */
-        [0x25] = 0x000C,     /* R37 - PLL K 1 */
-        [0x26] = 0x0093,     /* R38 - PLL K 2 */
-        [0x27] = 0x00E9,     /* R39 - PLL K 3 */
-        [0x29] = 0x0000,     /* R41 - 3D control */
-        [0x2A] = 0x0000,     /* R42 - OUT4 to ADC */
-        [0x2B] = 0x0000,     /* R43 - Beep control */
-        [0x2C] = 0x0033,     /* R44 - Input ctrl */
-        [0x2D] = 0x0010,     /* R45 - Left INP PGA gain ctrl */
-        [0x2E] = 0x0010,     /* R46 - Right INP PGA gain ctrl */
-        [0x2F] = 0x0100,     /* R47 - Left ADC BOOST ctrl */
-        [0x30] = 0x0100,     /* R48 - Right ADC BOOST ctrl */
-        [0x31] = 0x0002,     /* R49 - Output ctrl */
-        [0x32] = 0x0001,     /* R50 - Left mixer ctrl */
-        [0x33] = 0x0001,     /* R51 - Right mixer ctrl */
-        [0x34] = 0x0039,     /* R52 - LOUT1 (HP) volume ctrl */
-        [0x35] = 0x0039,     /* R53 - ROUT1 (HP) volume ctrl */
-        [0x36] = 0x0039,     /* R54 - LOUT2 (SPK) volume ctrl */
-        [0x37] = 0x0039,     /* R55 - ROUT2 (SPK) volume ctrl */
-        [0x38] = 0x0001,     /* R56 - OUT3 mixer ctrl */
-        [0x39] = 0x0001,     /* R57 - OUT4 (MONO) mix ctrl */
-        [0x3D] = 0x0000      /* R61 - BIAS CTRL */
+static const struct reg_default wm8983_defaults[] = {
+        { 0x01, 0x0000 },     /* R1  - Power management 1 */
+        { 0x02, 0x0000 },     /* R2  - Power management 2 */
+        { 0x03, 0x0000 },     /* R3  - Power management 3 */
+        { 0x04, 0x0050 },     /* R4  - Audio Interface */
+        { 0x05, 0x0000 },     /* R5  - Companding control */
+        { 0x06, 0x0140 },     /* R6  - Clock Gen control */
+        { 0x07, 0x0000 },     /* R7  - Additional control */
+        { 0x08, 0x0000 },     /* R8  - GPIO Control */
+        { 0x09, 0x0000 },     /* R9  - Jack Detect Control 1 */
+        { 0x0A, 0x0000 },     /* R10 - DAC Control */
+        { 0x0B, 0x00FF },     /* R11 - Left DAC digital Vol */
+        { 0x0C, 0x00FF },     /* R12 - Right DAC digital vol */
+        { 0x0D, 0x0000 },     /* R13 - Jack Detect Control 2 */
+        { 0x0E, 0x0100 },     /* R14 - ADC Control */
+        { 0x0F, 0x00FF },     /* R15 - Left ADC Digital Vol */
+        { 0x10, 0x00FF },     /* R16 - Right ADC Digital Vol */
+        { 0x12, 0x012C },     /* R18 - EQ1 - low shelf */
+        { 0x13, 0x002C },     /* R19 - EQ2 - peak 1 */
+        { 0x14, 0x002C },     /* R20 - EQ3 - peak 2 */
+        { 0x15, 0x002C },     /* R21 - EQ4 - peak 3 */
+        { 0x16, 0x002C },     /* R22 - EQ5 - high shelf */
+        { 0x18, 0x0032 },     /* R24 - DAC Limiter 1 */
+        { 0x19, 0x0000 },     /* R25 - DAC Limiter 2 */
+        { 0x1B, 0x0000 },     /* R27 - Notch Filter 1 */
+        { 0x1C, 0x0000 },     /* R28 - Notch Filter 2 */
+        { 0x1D, 0x0000 },     /* R29 - Notch Filter 3 */
+        { 0x1E, 0x0000 },     /* R30 - Notch Filter 4 */
+        { 0x20, 0x0038 },     /* R32 - ALC control 1 */
+        { 0x21, 0x000B },     /* R33 - ALC control 2 */
+        { 0x22, 0x0032 },     /* R34 - ALC control 3 */
+        { 0x23, 0x0000 },     /* R35 - Noise Gate */
+        { 0x24, 0x0008 },     /* R36 - PLL N */
+        { 0x25, 0x000C },     /* R37 - PLL K 1 */
+        { 0x26, 0x0093 },     /* R38 - PLL K 2 */
+        { 0x27, 0x00E9 },     /* R39 - PLL K 3 */
+        { 0x29, 0x0000 },     /* R41 - 3D control */
+        { 0x2A, 0x0000 },     /* R42 - OUT4 to ADC */
+        { 0x2B, 0x0000 },     /* R43 - Beep control */
+        { 0x2C, 0x0033 },     /* R44 - Input ctrl */
+        { 0x2D, 0x0010 },     /* R45 - Left INP PGA gain ctrl */
+        { 0x2E, 0x0010 },     /* R46 - Right INP PGA gain ctrl */
+        { 0x2F, 0x0100 },     /* R47 - Left ADC BOOST ctrl */
+        { 0x30, 0x0100 },     /* R48 - Right ADC BOOST ctrl */
+        { 0x31, 0x0002 },     /* R49 - Output ctrl */
+        { 0x32, 0x0001 },     /* R50 - Left mixer ctrl */
+        { 0x33, 0x0001 },     /* R51 - Right mixer ctrl */
+        { 0x34, 0x0039 },     /* R52 - LOUT1 (HP) volume ctrl */
+        { 0x35, 0x0039 },     /* R53 - ROUT1 (HP) volume ctrl */
+        { 0x36, 0x0039 },     /* R54 - LOUT2 (SPK) volume ctrl */
+        { 0x37, 0x0039 },     /* R55 - ROUT2 (SPK) volume ctrl */
+        { 0x38, 0x0001 },     /* R56 - OUT3 mixer ctrl */
+        { 0x39, 0x0001 },     /* R57 - OUT4 (MONO) mix ctrl */
+        { 0x3D, 0x0000 },      /* R61 - BIAS CTRL */
 };
 
 static const struct wm8983_reg_access {
@@ -159,7 +159,7 @@ static const int vol_update_regs[] = {
 };
 
 struct wm8983_priv {
-        enum snd_soc_control_type control_type;
+        struct regmap *regmap;
         u32 sysclk;
         u32 bclk;
 };
@@ -610,7 +610,7 @@ static int eqmode_put(struct snd_kcontrol *kcontrol,
         return 0;
 }
 
-static int wm8983_readable(struct snd_soc_codec *codec, unsigned int reg)
+static bool wm8983_readable(struct device *dev, unsigned int reg)
 {
         if (reg > WM8983_MAX_REGISTER)
                 return 0;
@@ -905,6 +905,7 @@ static int wm8983_set_sysclk(struct snd_soc_dai *dai,
 static int wm8983_set_bias_level(struct snd_soc_codec *codec,
                                  enum snd_soc_bias_level level)
 {
+        struct wm8983_priv *wm8983 = snd_soc_codec_get_drvdata(codec);
         int ret;
 
         switch (level) {
@@ -917,7 +918,7 @@ static int wm8983_set_bias_level(struct snd_soc_codec *codec,
                 break;
         case SND_SOC_BIAS_STANDBY:
                 if (codec->dapm.bias_level == SND_SOC_BIAS_OFF) {
-                        ret = snd_soc_cache_sync(codec);
+                        ret = regcache_sync(wm8983->regmap);
                         if (ret < 0) {
                                 dev_err(codec->dev, "Failed to sync cache: %d\n", ret);
                                 return ret;
@@ -994,10 +995,9 @@ static int wm8983_remove(struct snd_soc_codec *codec)
 static int wm8983_probe(struct snd_soc_codec *codec)
 {
         int ret;
-        struct wm8983_priv *wm8983 = snd_soc_codec_get_drvdata(codec);
         int i;
 
-        ret = snd_soc_codec_set_cache_io(codec, 7, 9, wm8983->control_type);
+        ret = snd_soc_codec_set_cache_io(codec, 7, 9, SND_SOC_REGMAP);
         if (ret < 0) {
                 dev_err(codec->dev, "Failed to set cache i/o: %d\n", ret);
                 return ret;
@@ -1067,16 +1067,23 @@ static struct snd_soc_codec_driver soc_codec_dev_wm8983 = {
         .suspend = wm8983_suspend,
         .resume = wm8983_resume,
         .set_bias_level = wm8983_set_bias_level,
-        .reg_cache_size = ARRAY_SIZE(wm8983_reg_defs),
-        .reg_word_size = sizeof(u16),
-        .reg_cache_default = wm8983_reg_defs,
         .controls = wm8983_snd_controls,
         .num_controls = ARRAY_SIZE(wm8983_snd_controls),
         .dapm_widgets = wm8983_dapm_widgets,
         .num_dapm_widgets = ARRAY_SIZE(wm8983_dapm_widgets),
         .dapm_routes = wm8983_audio_map,
         .num_dapm_routes = ARRAY_SIZE(wm8983_audio_map),
-        .readable_register = wm8983_readable
+};
+
+static const struct regmap_config wm8983_regmap = {
+        .reg_bits = 7,
+        .val_bits = 9,
+
+        .reg_defaults = wm8983_defaults,
+        .num_reg_defaults = ARRAY_SIZE(wm8983_defaults),
+        .cache_type = REGCACHE_RBTREE,
+
+        .readable_reg = wm8983_readable,
 };
 
 #if defined(CONFIG_SPI_MASTER)
@@ -1085,24 +1092,27 @@ static int __devinit wm8983_spi_probe(struct spi_device *spi)
         struct wm8983_priv *wm8983;
         int ret;
 
-        wm8983 = kzalloc(sizeof *wm8983, GFP_KERNEL);
+        wm8983 = devm_kzalloc(&spi->dev, sizeof *wm8983, GFP_KERNEL);
         if (!wm8983)
                 return -ENOMEM;
 
-        wm8983->control_type = SND_SOC_SPI;
+        wm8983->regmap = devm_regmap_init_spi(spi, &wm8983_regmap);
+        if (IS_ERR(wm8983->regmap)) {
+                ret = PTR_ERR(wm8983->regmap);
+                dev_err(&spi->dev, "Failed to init regmap: %d\n", ret);
+                return ret;
+        }
+
         spi_set_drvdata(spi, wm8983);
 
         ret = snd_soc_register_codec(&spi->dev,
                                      &soc_codec_dev_wm8983, &wm8983_dai, 1);
-        if (ret < 0)
-                kfree(wm8983);
         return ret;
 }
 
 static int __devexit wm8983_spi_remove(struct spi_device *spi)
 {
         snd_soc_unregister_codec(&spi->dev);
-        kfree(spi_get_drvdata(spi));
         return 0;
 }
 
@@ -1123,24 +1133,28 @@ static __devinit int wm8983_i2c_probe(struct i2c_client *i2c,
         struct wm8983_priv *wm8983;
         int ret;
 
-        wm8983 = kzalloc(sizeof *wm8983, GFP_KERNEL);
+        wm8983 = devm_kzalloc(&i2c->dev, sizeof *wm8983, GFP_KERNEL);
         if (!wm8983)
                 return -ENOMEM;
 
-        wm8983->control_type = SND_SOC_I2C;
+        wm8983->regmap = devm_regmap_init_i2c(i2c, &wm8983_regmap);
+        if (IS_ERR(wm8983->regmap)) {
+                ret = PTR_ERR(wm8983->regmap);
+                dev_err(&i2c->dev, "Failed to init regmap: %d\n", ret);
+                return ret;
+        }
+
         i2c_set_clientdata(i2c, wm8983);
 
         ret = snd_soc_register_codec(&i2c->dev,
                                      &soc_codec_dev_wm8983, &wm8983_dai, 1);
-        if (ret < 0)
-                kfree(wm8983);
+
         return ret;
 }
 
 static __devexit int wm8983_i2c_remove(struct i2c_client *client)
 {
         snd_soc_unregister_codec(&client->dev);
-        kfree(i2c_get_clientdata(client));
         return 0;
 }
 
diff --git a/sound/soc/codecs/wm8990.c b/sound/soc/codecs/wm8990.c
index db63c97ddf51..c28c83e5395d 100644
--- a/sound/soc/codecs/wm8990.c
+++ b/sound/soc/codecs/wm8990.c
@@ -1388,7 +1388,8 @@ static __devinit int wm8990_i2c_probe(struct i2c_client *i2c,
         struct wm8990_priv *wm8990;
         int ret;
 
-        wm8990 = kzalloc(sizeof(struct wm8990_priv), GFP_KERNEL);
+        wm8990 = devm_kzalloc(&i2c->dev, sizeof(struct wm8990_priv),
+                              GFP_KERNEL);
         if (wm8990 == NULL)
                 return -ENOMEM;
 
@@ -1396,15 +1397,14 @@ static __devinit int wm8990_i2c_probe(struct i2c_client *i2c,
 
         ret = snd_soc_register_codec(&i2c->dev,
                         &soc_codec_dev_wm8990, &wm8990_dai, 1);
-        if (ret < 0)
-                kfree(wm8990);
+
         return ret;
 }
 
 static __devexit int wm8990_i2c_remove(struct i2c_client *client)
 {
         snd_soc_unregister_codec(&client->dev);
-        kfree(i2c_get_clientdata(client));
+
         return 0;
 }
 
diff --git a/sound/soc/codecs/wm8991.c b/sound/soc/codecs/wm8991.c
index 9ac31ba9b82e..fe439f027e10 100644
--- a/sound/soc/codecs/wm8991.c
+++ b/sound/soc/codecs/wm8991.c
@@ -1363,7 +1363,7 @@ static __devinit int wm8991_i2c_probe(struct i2c_client *i2c,
         struct wm8991_priv *wm8991;
         int ret;
 
-        wm8991 = kzalloc(sizeof *wm8991, GFP_KERNEL);
+        wm8991 = devm_kzalloc(&i2c->dev, sizeof(*wm8991), GFP_KERNEL);
         if (!wm8991)
                 return -ENOMEM;
 
@@ -1372,15 +1372,14 @@ static __devinit int wm8991_i2c_probe(struct i2c_client *i2c,
 
         ret = snd_soc_register_codec(&i2c->dev,
                                      &soc_codec_dev_wm8991, &wm8991_dai, 1);
-        if (ret < 0)
-                kfree(wm8991);
+
         return ret;
 }
 
 static __devexit int wm8991_i2c_remove(struct i2c_client *client)
 {
         snd_soc_unregister_codec(&client->dev);
-        kfree(i2c_get_clientdata(client));
+
         return 0;
 }
 
@@ -1400,23 +1399,7 @@ static struct i2c_driver wm8991_i2c_driver = {
         .id_table = wm8991_i2c_id,
 };
 
-static int __init wm8991_modinit(void)
-{
-        int ret;
-        ret = i2c_add_driver(&wm8991_i2c_driver);
-        if (ret != 0) {
-                printk(KERN_ERR "Failed to register WM8991 I2C driver: %d\n",
-                       ret);
-        }
-        return 0;
-}
-module_init(wm8991_modinit);
-
-static void __exit wm8991_exit(void)
-{
-        i2c_del_driver(&wm8991_i2c_driver);
-}
-module_exit(wm8991_exit);
+module_i2c_driver(wm8991_i2c_driver);
 
 MODULE_DESCRIPTION("ASoC WM8991 driver");
 MODULE_AUTHOR("Graeme Gregory");
diff --git a/sound/soc/codecs/wm8993.c b/sound/soc/codecs/wm8993.c
index 9fd80d688979..94737a30716b 100644
--- a/sound/soc/codecs/wm8993.c
+++ b/sound/soc/codecs/wm8993.c
@@ -1520,6 +1520,8 @@ static int wm8993_probe(struct snd_soc_codec *codec)
                                       wm8993->pdata.lineout2fb,
                                       wm8993->pdata.jd_scthr,
                                       wm8993->pdata.jd_thr,
+                                      wm8993->pdata.micbias1_delay,
+                                      wm8993->pdata.micbias2_delay,
                                       wm8993->pdata.micbias1_lvl,
                                       wm8993->pdata.micbias2_lvl);
 
diff --git a/sound/soc/codecs/wm8994.c b/sound/soc/codecs/wm8994.c
index 6c9eeca85b95..2b2dadc54dac 100644
--- a/sound/soc/codecs/wm8994.c
+++ b/sound/soc/codecs/wm8994.c
@@ -671,6 +671,18 @@ SOC_SINGLE_TLV("AIF2 EQ5 Volume", WM8994_AIF2_EQ_GAINS_2, 6, 31, 0,
                eq_tlv),
 };
 
+static const struct snd_kcontrol_new wm8994_drc_controls[] = {
+SND_SOC_BYTES_MASK("AIF1.1 DRC", WM8994_AIF1_DRC1_1, 5,
+                   WM8994_AIF1DAC1_DRC_ENA | WM8994_AIF1ADC1L_DRC_ENA |
+                   WM8994_AIF1ADC1R_DRC_ENA),
+SND_SOC_BYTES_MASK("AIF1.2 DRC", WM8994_AIF1_DRC2_1, 5,
+                   WM8994_AIF1DAC2_DRC_ENA | WM8994_AIF1ADC2L_DRC_ENA |
+                   WM8994_AIF1ADC2R_DRC_ENA),
+SND_SOC_BYTES_MASK("AIF2 DRC", WM8994_AIF2_DRC_1, 5,
+                   WM8994_AIF2DAC_DRC_ENA | WM8994_AIF2ADCL_DRC_ENA |
+                   WM8994_AIF2ADCR_DRC_ENA),
+};
+
 static const char *wm8958_ng_text[] = {
         "30ms", "125ms", "250ms", "500ms",
 };
@@ -789,11 +801,27 @@ 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 wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
 
         switch (event) {
         case SND_SOC_DAPM_PRE_PMU:
                 return configure_clock(codec);
 
+        case SND_SOC_DAPM_POST_PMU:
+                /*
+                 * JACKDET won't run until we start the clock and it
+                 * only reports deltas, make sure we notify the state
+                 * up the stack on startup.  Use a *very* generous
+                 * timeout for paranoia, there's no urgency and we
+                 * don't want false reports.
+                 */
+                if (wm8994->jackdet && !wm8994->clk_has_run) {
+                        schedule_delayed_work(&wm8994->jackdet_bootstrap,
+                                              msecs_to_jiffies(1000));
+                        wm8994->clk_has_run = true;
+                }
+                break;
+
         case SND_SOC_DAPM_POST_PMD:
                 configure_clock(codec);
                 break;
@@ -1632,7 +1660,8 @@ SND_SOC_DAPM_SUPPLY("VMID", SND_SOC_NOPM, 0, 0, vmid_event,
                     SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
 
 SND_SOC_DAPM_SUPPLY("CLK_SYS", SND_SOC_NOPM, 0, 0, clk_sys_event,
-                    SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
+                    SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
+                    SND_SOC_DAPM_PRE_PMD),
 
 SND_SOC_DAPM_SUPPLY("DSP1CLK", SND_SOC_NOPM, 3, 0, NULL, 0),
 SND_SOC_DAPM_SUPPLY("DSP2CLK", SND_SOC_NOPM, 2, 0, NULL, 0),
@@ -2102,6 +2131,10 @@ static int _wm8994_set_fll(struct snd_soc_codec *codec, int id, int src,
         case WM8994_FLL_SRC_LRCLK:
         case WM8994_FLL_SRC_BCLK:
                 break;
+        case WM8994_FLL_SRC_INTERNAL:
+                freq_in = 12000000;
+                freq_out = 12000000;
+                break;
         default:
                 return -EINVAL;
         }
@@ -2161,12 +2194,14 @@ static int _wm8994_set_fll(struct snd_soc_codec *codec, int id, int src,
 
         snd_soc_update_bits(codec, WM8994_FLL1_CONTROL_4 + reg_offset,
                             WM8994_FLL1_N_MASK,
-                                    fll.n << WM8994_FLL1_N_SHIFT);
+                            fll.n << WM8994_FLL1_N_SHIFT);
 
         snd_soc_update_bits(codec, WM8994_FLL1_CONTROL_5 + reg_offset,
-                            WM8958_FLL1_BYP |
+                            WM8994_FLL1_FRC_NCO | WM8958_FLL1_BYP |
                             WM8994_FLL1_REFCLK_DIV_MASK |
                             WM8994_FLL1_REFCLK_SRC_MASK,
+                            ((src == WM8994_FLL_SRC_INTERNAL)
+                             << WM8994_FLL1_FRC_NCO_SHIFT) |
                             (fll.clk_ref_div << WM8994_FLL1_REFCLK_DIV_SHIFT) |
                             (src - 1));
 
@@ -2192,13 +2227,16 @@ static int _wm8994_set_fll(struct snd_soc_codec *codec, int id, int src,
                         }
                 }
 
+                reg = WM8994_FLL1_ENA;
+
                 if (fll.k)
-                        reg = WM8994_FLL1_ENA | WM8994_FLL1_FRAC;
-                else
-                        reg = WM8994_FLL1_ENA;
+                        reg |= WM8994_FLL1_FRAC;
+                if (src == WM8994_FLL_SRC_INTERNAL)
+                        reg |= WM8994_FLL1_OSC_ENA;
+
                 snd_soc_update_bits(codec, WM8994_FLL1_CONTROL_1 + reg_offset,
-                                    WM8994_FLL1_ENA | WM8994_FLL1_FRAC,
-                                    reg);
+                                    WM8994_FLL1_ENA | WM8994_FLL1_OSC_ENA |
+                                    WM8994_FLL1_FRAC, reg);
 
                 if (wm8994->fll_locked_irq) {
                         timeout = wait_for_completion_timeout(&wm8994->fll_locked[id],
@@ -3027,7 +3065,7 @@ static int wm8994_codec_resume(struct snd_soc_codec *codec)
 
 static void wm8994_handle_retune_mobile_pdata(struct wm8994_priv *wm8994)
 {
-        struct snd_soc_codec *codec = wm8994->codec;
+        struct snd_soc_codec *codec = wm8994->hubs.codec;
         struct wm8994_pdata *pdata = wm8994->pdata;
         struct snd_kcontrol_new controls[] = {
                 SOC_ENUM_EXT("AIF1.1 EQ Mode",
@@ -3085,16 +3123,16 @@ static void wm8994_handle_retune_mobile_pdata(struct wm8994_priv *wm8994)
         wm8994->retune_mobile_enum.max = wm8994->num_retune_mobile_texts;
         wm8994->retune_mobile_enum.texts = wm8994->retune_mobile_texts;
 
-        ret = snd_soc_add_codec_controls(wm8994->codec, controls,
+        ret = snd_soc_add_codec_controls(wm8994->hubs.codec, controls,
                                    ARRAY_SIZE(controls));
         if (ret != 0)
-                dev_err(wm8994->codec->dev,
+                dev_err(wm8994->hubs.codec->dev,
                         "Failed to add ReTune Mobile controls: %d\n", ret);
 }
 
 static void wm8994_handle_pdata(struct wm8994_priv *wm8994)
 {
-        struct snd_soc_codec *codec = wm8994->codec;
+        struct snd_soc_codec *codec = wm8994->hubs.codec;
         struct wm8994_pdata *pdata = wm8994->pdata;
         int ret, i;
 
@@ -3107,6 +3145,8 @@ static void wm8994_handle_pdata(struct wm8994_priv *wm8994)
                                       pdata->lineout2fb,
                                       pdata->jd_scthr,
                                       pdata->jd_thr,
+                                      pdata->micb1_delay,
+                                      pdata->micb2_delay,
                                       pdata->micbias1_lvl,
                                       pdata->micbias2_lvl);
 
@@ -3123,10 +3163,10 @@ static void wm8994_handle_pdata(struct wm8994_priv *wm8994)
                 };
 
                 /* We need an array of texts for the enum API */
-                wm8994->drc_texts = devm_kzalloc(wm8994->codec->dev,
+                wm8994->drc_texts = devm_kzalloc(wm8994->hubs.codec->dev,
                             sizeof(char *) * pdata->num_drc_cfgs, GFP_KERNEL);
                 if (!wm8994->drc_texts) {
-                        dev_err(wm8994->codec->dev,
+                        dev_err(wm8994->hubs.codec->dev,
                                 "Failed to allocate %d DRC config texts\n",
                                 pdata->num_drc_cfgs);
                         return;
@@ -3138,23 +3178,28 @@ static void wm8994_handle_pdata(struct wm8994_priv *wm8994)
                 wm8994->drc_enum.max = pdata->num_drc_cfgs;
                 wm8994->drc_enum.texts = wm8994->drc_texts;
 
-                ret = snd_soc_add_codec_controls(wm8994->codec, controls,
+                ret = snd_soc_add_codec_controls(wm8994->hubs.codec, controls,
                                            ARRAY_SIZE(controls));
-                if (ret != 0)
-                        dev_err(wm8994->codec->dev,
-                                "Failed to add DRC mode controls: %d\n", ret);
-
                 for (i = 0; i < WM8994_NUM_DRC; i++)
                         wm8994_set_drc(codec, i);
+        } else {
+                ret = snd_soc_add_codec_controls(wm8994->hubs.codec,
+                                                 wm8994_drc_controls,
+                                                 ARRAY_SIZE(wm8994_drc_controls));
         }
 
+        if (ret != 0)
+                dev_err(wm8994->hubs.codec->dev,
+                        "Failed to add DRC mode controls: %d\n", ret);
+
+
         dev_dbg(codec->dev, "%d ReTune Mobile configurations\n",
                 pdata->num_retune_mobile_cfgs);
 
         if (pdata->num_retune_mobile_cfgs)
                 wm8994_handle_retune_mobile_pdata(wm8994);
         else
-                snd_soc_add_codec_controls(wm8994->codec, wm8994_eq_controls,
+                snd_soc_add_codec_controls(wm8994->hubs.codec, wm8994_eq_controls,
                                      ARRAY_SIZE(wm8994_eq_controls));
 
         for (i = 0; i < ARRAY_SIZE(pdata->micbias); i++) {
@@ -3236,6 +3281,12 @@ int wm8994_mic_detect(struct snd_soc_codec *codec, struct snd_soc_jack *jack,
 
         snd_soc_update_bits(codec, WM8994_MICBIAS, WM8994_MICD_ENA, reg);
 
+        /* enable MICDET and MICSHRT deboune */
+        snd_soc_update_bits(codec, WM8994_IRQ_DEBOUNCE,
+                            WM8994_MIC1_DET_DB_MASK | WM8994_MIC1_SHRT_DB_MASK |
+                            WM8994_MIC2_DET_DB_MASK | WM8994_MIC2_SHRT_DB_MASK,
+                            WM8994_MIC1_DET_DB | WM8994_MIC1_SHRT_DB);
+
         snd_soc_dapm_sync(&codec->dapm);
 
         return 0;
@@ -3309,7 +3360,7 @@ static void wm8994_mic_work(struct work_struct *work)
 static irqreturn_t wm8994_mic_irq(int irq, void *data)
 {
         struct wm8994_priv *priv = data;
-        struct snd_soc_codec *codec = priv->codec;
+        struct snd_soc_codec *codec = priv->hubs.codec;
 
 #ifndef CONFIG_SND_SOC_WM8994_MODULE
         trace_snd_soc_jack_irq(dev_name(codec->dev));
@@ -3345,7 +3396,7 @@ static void wm8958_default_micdet(u16 status, void *data)
 
                         snd_soc_jack_report(wm8994->micdet[0].jack, 0,
                                             wm8994->btn_mask |
-                                             SND_JACK_HEADSET);
+                                            SND_JACK_HEADSET);
                 }
                 return;
         }
@@ -3422,7 +3473,7 @@ static void wm8958_default_micdet(u16 status, void *data)
 static irqreturn_t wm1811_jackdet_irq(int irq, void *data)
 {
         struct wm8994_priv *wm8994 = data;
-        struct snd_soc_codec *codec = wm8994->codec;
+        struct snd_soc_codec *codec = wm8994->hubs.codec;
         int reg;
         bool present;
 
@@ -3499,10 +3550,22 @@ static irqreturn_t wm1811_jackdet_irq(int irq, void *data)
                                     SND_JACK_MECHANICAL | SND_JACK_HEADSET |
                                     wm8994->btn_mask);
 
+        /* Since we only report deltas force an update, ensures we
+         * avoid bootstrapping issues with the core. */
+        snd_soc_jack_report(wm8994->micdet[0].jack, 0, 0);
+
         pm_runtime_put(codec->dev);
         return IRQ_HANDLED;
 }
 
+static void wm1811_jackdet_bootstrap(struct work_struct *work)
+{
+        struct wm8994_priv *wm8994 = container_of(work,
+                                                struct wm8994_priv,
+                                                jackdet_bootstrap.work);
+        wm1811_jackdet_irq(0, wm8994);
+}
+
 /**
  * wm8958_mic_detect - Enable microphone detection via the WM8958 IRQ
  *
@@ -3573,6 +3636,10 @@ int wm8958_mic_detect(struct snd_soc_codec *codec, struct snd_soc_jack *jack,
                  * otherwise jump straight to microphone detection.
                  */
                 if (wm8994->jackdet) {
+                        /* Disable debounce for the initial detect */
+                        snd_soc_update_bits(codec, WM1811_JACKDET_CTRL,
+                                            WM1811_JACKDET_DB, 0);
+
                         snd_soc_update_bits(codec, WM8958_MICBIAS2,
                                             WM8958_MICB2_DISCH,
                                             WM8958_MICB2_DISCH);
@@ -3600,7 +3667,7 @@ EXPORT_SYMBOL_GPL(wm8958_mic_detect);
 static irqreturn_t wm8958_mic_irq(int irq, void *data)
 {
         struct wm8994_priv *wm8994 = data;
-        struct snd_soc_codec *codec = wm8994->codec;
+        struct snd_soc_codec *codec = wm8994->hubs.codec;
         int reg, count;
 
         /*
@@ -3690,15 +3757,15 @@ static int wm8994_codec_probe(struct snd_soc_codec *codec)
         unsigned int reg;
         int ret, i;
 
-        wm8994->codec = codec;
+        wm8994->hubs.codec = codec;
         codec->control_data = control->regmap;
 
         snd_soc_codec_set_cache_io(codec, 16, 16, SND_SOC_REGMAP);
 
-        wm8994->codec = codec;
-
         mutex_init(&wm8994->accdet_lock);
         INIT_DELAYED_WORK(&wm8994->mic_work, wm8994_mic_work);
+        INIT_DELAYED_WORK(&wm8994->jackdet_bootstrap,
+                          wm1811_jackdet_bootstrap);
 
         for (i = 0; i < ARRAY_SIZE(wm8994->fll_locked); i++)
                 init_completion(&wm8994->fll_locked[i]);
@@ -3756,14 +3823,17 @@ static int wm8994_codec_probe(struct snd_soc_codec *codec)
                 wm8994->hubs.no_cache_dac_hp_direct = true;
                 wm8994->fll_byp = true;
 
-                switch (wm8994->revision) {
+                switch (control->cust_id) {
                 case 0:
-                case 1:
                 case 2:
-                case 3:
                         wm8994->hubs.dcs_codes_l = -9;
                         wm8994->hubs.dcs_codes_r = -7;
                         break;
+                case 1:
+                case 3:
+                        wm8994->hubs.dcs_codes_l = -8;
+                        wm8994->hubs.dcs_codes_r = -7;
+                        break;
                 default:
                         break;
                 }
@@ -3852,7 +3922,7 @@ static int wm8994_codec_probe(struct snd_soc_codec *codec)
 
         switch (control->type) {
         case WM1811:
-                if (wm8994->revision > 1) {
+                if (control->cust_id > 1 || wm8994->revision > 1) {
                         ret = wm8994_request_irq(wm8994->wm8994,
                                                  WM8994_IRQ_GPIO(6),
                                                  wm1811_jackdet_irq, "JACKDET",
diff --git a/sound/soc/codecs/wm8994.h b/sound/soc/codecs/wm8994.h
index d77e06f0a675..f142ec198db3 100644
--- a/sound/soc/codecs/wm8994.h
+++ b/sound/soc/codecs/wm8994.h
@@ -28,10 +28,11 @@
 #define WM8994_FLL1 1
 #define WM8994_FLL2 2
 
-#define WM8994_FLL_SRC_MCLK1  1
-#define WM8994_FLL_SRC_MCLK2  2
-#define WM8994_FLL_SRC_LRCLK  3
-#define WM8994_FLL_SRC_BCLK   4
+#define WM8994_FLL_SRC_MCLK1    1
+#define WM8994_FLL_SRC_MCLK2    2
+#define WM8994_FLL_SRC_LRCLK    3
+#define WM8994_FLL_SRC_BCLK     4
+#define WM8994_FLL_SRC_INTERNAL 5
 
 enum wm8994_vmid_mode {
         WM8994_VMID_NORMAL,
@@ -72,7 +73,6 @@ struct wm8994;
 struct wm8994_priv {
         struct wm_hubs_data hubs;
         struct wm8994 *wm8994;
-        struct snd_soc_codec *codec;
         int sysclk[2];
         int sysclk_rate[2];
         int mclk[2];
@@ -81,6 +81,7 @@ struct wm8994_priv {
         struct completion fll_locked[2];
         bool fll_locked_irq;
         bool fll_byp;
+        bool clk_has_run;
 
         int vmid_refcount;
         int active_refcount;
@@ -134,6 +135,7 @@ struct wm8994_priv {
         int btn_mask;
         bool jackdet;
         int jackdet_mode;
+        struct delayed_work jackdet_bootstrap;
 
         wm8958_micdet_cb jack_cb;
         void *jack_cb_data;
diff --git a/sound/soc/codecs/wm8996.c b/sound/soc/codecs/wm8996.c
index 00f183dfa454..6dcb02c3666f 100644
--- a/sound/soc/codecs/wm8996.c
+++ b/sound/soc/codecs/wm8996.c
@@ -931,7 +931,7 @@ SND_SOC_DAPM_INPUT("IN2RP"),
 SND_SOC_DAPM_INPUT("DMIC1DAT"),
 SND_SOC_DAPM_INPUT("DMIC2DAT"),
 
-SND_SOC_DAPM_REGULATOR_SUPPLY("CPVDD", 20),
+SND_SOC_DAPM_REGULATOR_SUPPLY("CPVDD", 20, 0),
 SND_SOC_DAPM_SUPPLY_S("SYSCLK", 1, WM8996_AIF_CLOCKING_1, 0, 0, NULL, 0),
 SND_SOC_DAPM_SUPPLY_S("SYSDSPCLK", 2, WM8996_CLOCKING_1, 1, 0, NULL, 0),
 SND_SOC_DAPM_SUPPLY_S("AIFCLK", 2, WM8996_CLOCKING_1, 2, 0, NULL, 0),
diff --git a/sound/soc/codecs/wm9090.c b/sound/soc/codecs/wm9090.c
index 2c2346fdd637..c7ddc56175d1 100644
--- a/sound/soc/codecs/wm9090.c
+++ b/sound/soc/codecs/wm9090.c
@@ -695,17 +695,7 @@ static struct i2c_driver wm9090_i2c_driver = {
         .id_table = wm9090_id,
 };
 
-static int __init wm9090_init(void)
-{
-        return i2c_add_driver(&wm9090_i2c_driver);
-}
-module_init(wm9090_init);
-
-static void __exit wm9090_exit(void)
-{
-        i2c_del_driver(&wm9090_i2c_driver);
-}
-module_exit(wm9090_exit);
+module_i2c_driver(wm9090_i2c_driver);
 
 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
 MODULE_DESCRIPTION("WM9090 ASoC driver");
diff --git a/sound/soc/codecs/wm9712.c b/sound/soc/codecs/wm9712.c
index c6d2076a796b..4dd73ea08d0b 100644
--- a/sound/soc/codecs/wm9712.c
+++ b/sound/soc/codecs/wm9712.c
@@ -132,8 +132,9 @@ SOC_SINGLE("Aux Playback Phone Volume", AC97_CD, 4, 7, 1),
 SOC_SINGLE("Phone Volume", AC97_PHONE, 0, 15, 1),
 SOC_DOUBLE("Line Capture Volume", AC97_LINE, 8, 0, 31, 1),
 
-SOC_SINGLE("Capture 20dB Boost Switch", AC97_REC_SEL, 14, 1, 0),
-SOC_SINGLE("Capture to Phone 20dB Boost Switch", AC97_REC_SEL, 11, 1, 1),
+SOC_SINGLE_TLV("Capture Boost Switch", AC97_REC_SEL, 14, 1, 0, boost_tlv),
+SOC_SINGLE_TLV("Capture to Phone Boost Switch", AC97_REC_SEL, 11, 1, 1,
+               boost_tlv),
 
 SOC_SINGLE("3D Upper Cut-off Switch", AC97_3D_CONTROL, 5, 1, 1),
 SOC_SINGLE("3D Lower Cut-off Switch", AC97_3D_CONTROL, 4, 1, 1),
@@ -146,7 +147,7 @@ SOC_SINGLE("Playback Attenuate (-6dB) Switch", AC97_MASTER_TONE, 6, 1, 0),
 SOC_SINGLE("Bass Volume", AC97_MASTER_TONE, 8, 15, 1),
 SOC_SINGLE("Treble Volume", AC97_MASTER_TONE, 0, 15, 1),
 
-SOC_SINGLE("Capture ADC Switch", AC97_REC_GAIN, 15, 1, 1),
+SOC_SINGLE("Capture Switch", AC97_REC_GAIN, 15, 1, 1),
 SOC_ENUM("Capture Volume Steps", wm9712_enum[6]),
 SOC_DOUBLE("Capture Volume", AC97_REC_GAIN, 8, 0, 63, 0),
 SOC_SINGLE("Capture ZC Switch", AC97_REC_GAIN, 7, 1, 0),
@@ -634,7 +635,6 @@ static int wm9712_soc_probe(struct snd_soc_codec *codec)
 {
         int ret = 0;
 
-        codec->control_data = codec;    /* we don't use regmap! */
         ret = snd_soc_new_ac97_codec(codec, &soc_ac97_ops, 0);
         if (ret < 0) {
                 printk(KERN_ERR "wm9712: failed to register AC97 codec\n");
@@ -699,8 +699,8 @@ static int __devexit wm9712_remove(struct platform_device *pdev)
 
 static struct platform_driver wm9712_codec_driver = {
         .driver = {
-                        .name = "wm9712-codec",
-                        .owner = THIS_MODULE,
+                .name = "wm9712-codec",
+                .owner = THIS_MODULE,
         },
 
         .probe = wm9712_probe,
diff --git a/sound/soc/codecs/wm9713.c b/sound/soc/codecs/wm9713.c
index d0b8a3287a85..3eb19fb71d17 100644
--- a/sound/soc/codecs/wm9713.c
+++ b/sound/soc/codecs/wm9713.c
@@ -1196,7 +1196,6 @@ static int wm9713_soc_probe(struct snd_soc_codec *codec)
         if (wm9713 == NULL)
                 return -ENOMEM;
         snd_soc_codec_set_drvdata(codec, wm9713);
-        codec->control_data = wm9713;   /* we don't use regmap! */
 
         ret = snd_soc_new_ac97_codec(codec, &soc_ac97_ops, 0);
         if (ret < 0)
diff --git a/sound/soc/codecs/wm_hubs.c b/sound/soc/codecs/wm_hubs.c
index 61baa48823cb..7a773a835b8e 100644
--- a/sound/soc/codecs/wm_hubs.c
+++ b/sound/soc/codecs/wm_hubs.c
@@ -199,15 +199,56 @@ static void wm_hubs_dcs_cache_set(struct snd_soc_codec *codec, u16 dcs_cfg)
         list_add_tail(&cache->list, &hubs->dcs_cache);
 }
 
+static void wm_hubs_read_dc_servo(struct snd_soc_codec *codec,
+                                  u16 *reg_l, u16 *reg_r)
+{
+        struct wm_hubs_data *hubs = snd_soc_codec_get_drvdata(codec);
+        u16 dcs_reg, reg;
+
+        switch (hubs->dcs_readback_mode) {
+        case 2:
+                dcs_reg = WM8994_DC_SERVO_4E;
+                break;
+        case 1:
+                dcs_reg = WM8994_DC_SERVO_READBACK;
+                break;
+        default:
+                dcs_reg = WM8993_DC_SERVO_3;
+                break;
+        }
+
+        /* Different chips in the family support different readback
+         * methods.
+         */
+        switch (hubs->dcs_readback_mode) {
+        case 0:
+                *reg_l = snd_soc_read(codec, WM8993_DC_SERVO_READBACK_1)
+                        & WM8993_DCS_INTEG_CHAN_0_MASK;
+                *reg_r = snd_soc_read(codec, WM8993_DC_SERVO_READBACK_2)
+                        & WM8993_DCS_INTEG_CHAN_1_MASK;
+                break;
+        case 2:
+        case 1:
+                reg = snd_soc_read(codec, dcs_reg);
+                *reg_r = (reg & WM8993_DCS_DAC_WR_VAL_1_MASK)
+                        >> WM8993_DCS_DAC_WR_VAL_1_SHIFT;
+                *reg_l = reg & WM8993_DCS_DAC_WR_VAL_0_MASK;
+                break;
+        default:
+                WARN(1, "Unknown DCS readback method\n");
+                return;
+        }
+}
+
 /*
  * Startup calibration of the DC servo
  */
-static void calibrate_dc_servo(struct snd_soc_codec *codec)
+static void enable_dc_servo(struct snd_soc_codec *codec)
 {
         struct wm_hubs_data *hubs = snd_soc_codec_get_drvdata(codec);
         struct wm_hubs_dcs_cache *cache;
         s8 offset;
-        u16 reg, reg_l, reg_r, dcs_cfg, dcs_reg;
+        u16 reg_l, reg_r, dcs_cfg, dcs_reg;
 
         switch (hubs->dcs_readback_mode) {
         case 2:
@@ -245,27 +286,7 @@ static void calibrate_dc_servo(struct snd_soc_codec *codec)
                                   WM8993_DCS_TRIG_STARTUP_1);
         }
 
-        /* Different chips in the family support different readback
-         * methods.
-         */
-        switch (hubs->dcs_readback_mode) {
-        case 0:
-                reg_l = snd_soc_read(codec, WM8993_DC_SERVO_READBACK_1)
-                        & WM8993_DCS_INTEG_CHAN_0_MASK;
-                reg_r = snd_soc_read(codec, WM8993_DC_SERVO_READBACK_2)
-                        & WM8993_DCS_INTEG_CHAN_1_MASK;
-                break;
-        case 2:
-        case 1:
-                reg = snd_soc_read(codec, dcs_reg);
-                reg_r = (reg & WM8993_DCS_DAC_WR_VAL_1_MASK)
-                        >> WM8993_DCS_DAC_WR_VAL_1_SHIFT;
-                reg_l = reg & WM8993_DCS_DAC_WR_VAL_0_MASK;
-                break;
-        default:
-                WARN(1, "Unknown DCS readback method\n");
-                return;
-        }
+        wm_hubs_read_dc_servo(codec, &reg_l, &reg_r);
 
         dev_dbg(codec->dev, "DCS input: %x %x\n", reg_l, reg_r);
 
@@ -276,12 +297,16 @@ static void calibrate_dc_servo(struct snd_soc_codec *codec)
                         hubs->dcs_codes_l, hubs->dcs_codes_r);
 
                 /* HPOUT1R */
-                offset = reg_r;
+                offset = (s8)reg_r;
+                dev_dbg(codec->dev, "DCS right %d->%d\n", offset,
+                        offset + hubs->dcs_codes_r);
                 offset += hubs->dcs_codes_r;
                 dcs_cfg = (u8)offset << WM8993_DCS_DAC_WR_VAL_1_SHIFT;
 
                 /* HPOUT1L */
-                offset = reg_l;
+                offset = (s8)reg_l;
+                dev_dbg(codec->dev, "DCS left %d->%d\n", offset,
+                        offset + hubs->dcs_codes_l);
                 offset += hubs->dcs_codes_l;
                 dcs_cfg |= (u8)offset;
 
@@ -535,7 +560,7 @@ static int hp_event(struct snd_soc_dapm_widget *w,
                 snd_soc_update_bits(codec, WM8993_DC_SERVO_1,
                                     WM8993_DCS_TIMER_PERIOD_01_MASK, 0);
 
-                calibrate_dc_servo(codec);
+                enable_dc_servo(codec);
 
                 reg |= WM8993_HPOUT1R_OUTP | WM8993_HPOUT1R_RMV_SHORT |
                         WM8993_HPOUT1L_OUTP | WM8993_HPOUT1L_RMV_SHORT;
@@ -619,6 +644,28 @@ static int lineout_event(struct snd_soc_dapm_widget *w,
         return 0;
 }
 
+static int micbias_event(struct snd_soc_dapm_widget *w,
+                         struct snd_kcontrol *kcontrol, int event)
+{
+        struct snd_soc_codec *codec = w->codec;
+        struct wm_hubs_data *hubs = snd_soc_codec_get_drvdata(codec);
+
+        switch (w->shift) {
+        case WM8993_MICB1_ENA_SHIFT:
+                if (hubs->micb1_delay)
+                        msleep(hubs->micb1_delay);
+                break;
+        case WM8993_MICB2_ENA_SHIFT:
+                if (hubs->micb2_delay)
+                        msleep(hubs->micb2_delay);
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
 void wm_hubs_update_class_w(struct snd_soc_codec *codec)
 {
         struct wm_hubs_data *hubs = snd_soc_codec_get_drvdata(codec);
@@ -809,8 +856,10 @@ SND_SOC_DAPM_INPUT("IN1RP"),
 SND_SOC_DAPM_INPUT("IN2RN"),
 SND_SOC_DAPM_INPUT("IN2RP:VXRP"),
 
-SND_SOC_DAPM_SUPPLY("MICBIAS2", WM8993_POWER_MANAGEMENT_1, 5, 0, NULL, 0),
-SND_SOC_DAPM_SUPPLY("MICBIAS1", WM8993_POWER_MANAGEMENT_1, 4, 0, NULL, 0),
+SND_SOC_DAPM_SUPPLY("MICBIAS2", WM8993_POWER_MANAGEMENT_1, 5, 0,
+                    micbias_event, SND_SOC_DAPM_POST_PMU),
+SND_SOC_DAPM_SUPPLY("MICBIAS1", WM8993_POWER_MANAGEMENT_1, 4, 0,
+                    micbias_event, SND_SOC_DAPM_POST_PMU),
 
 SND_SOC_DAPM_MIXER("IN1L PGA", WM8993_POWER_MANAGEMENT_2, 6, 0,
                    in1l_pga, ARRAY_SIZE(in1l_pga)),
@@ -1112,6 +1161,8 @@ int wm_hubs_add_analogue_routes(struct snd_soc_codec *codec,
         struct wm_hubs_data *hubs = snd_soc_codec_get_drvdata(codec);
         struct snd_soc_dapm_context *dapm = &codec->dapm;
 
+        hubs->codec = codec;
+
         INIT_LIST_HEAD(&hubs->dcs_cache);
         init_completion(&hubs->dcs_done);
 
@@ -1143,13 +1194,16 @@ EXPORT_SYMBOL_GPL(wm_hubs_add_analogue_routes);
 int wm_hubs_handle_analogue_pdata(struct snd_soc_codec *codec,
                                   int lineout1_diff, int lineout2_diff,
                                   int lineout1fb, int lineout2fb,
-                                  int jd_scthr, int jd_thr, int micbias1_lvl,
-                                  int micbias2_lvl)
+                                  int jd_scthr, int jd_thr,
+                                  int micbias1_delay, int micbias2_delay,
+                                  int micbias1_lvl, int micbias2_lvl)
 {
         struct wm_hubs_data *hubs = snd_soc_codec_get_drvdata(codec);
 
         hubs->lineout1_se = !lineout1_diff;
         hubs->lineout2_se = !lineout2_diff;
+        hubs->micb1_delay = micbias1_delay;
+        hubs->micb2_delay = micbias2_delay;
 
         if (!lineout1_diff)
                 snd_soc_update_bits(codec, WM8993_LINE_MIXER1,
diff --git a/sound/soc/codecs/wm_hubs.h b/sound/soc/codecs/wm_hubs.h
index da2dc899ce6d..24c763df21f9 100644
--- a/sound/soc/codecs/wm_hubs.h
+++ b/sound/soc/codecs/wm_hubs.h
@@ -36,6 +36,9 @@ struct wm_hubs_data {
         struct list_head dcs_cache;
         bool (*check_class_w_digital)(struct snd_soc_codec *);
 
+        int micb1_delay;
+        int micb2_delay;
+
         bool lineout1_se;
         bool lineout1n_ena;
         bool lineout1p_ena;
@@ -46,6 +49,8 @@ struct wm_hubs_data {
 
         bool dcs_done_irq;
         struct completion dcs_done;
+
+        struct snd_soc_codec *codec;
 };
 
 extern int wm_hubs_add_analogue_controls(struct snd_soc_codec *);
@@ -54,6 +59,7 @@ extern int wm_hubs_handle_analogue_pdata(struct snd_soc_codec *,
                                          int lineout1_diff, int lineout2_diff,
                                          int lineout1fb, int lineout2fb,
                                          int jd_scthr, int jd_thr,
+                                         int micbias1_dly, int micbias2_dly,
                                          int micbias1_lvl, int micbias2_lvl);
 
 extern irqreturn_t wm_hubs_dcs_done(int irq, void *data);