Merge tag 'asoc-v4.1-2' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/sound into for-linus

ASoC: Updates for v4.1 More updates for v4.1, pretty much all drivers: - Lots of cleanups from Lars, mainly moving things from the CODEC level to the card level. - Continuing improvements to rcar from Morimoto-san, pcm512x from Howard and Peter, the Intel platforms from Vinod, Jie, Jin and Han, and to rt5670 from Bard. - Support for some non-DSP Qualcomm platforms, Google's Storm platform, Maxmim MAX98925 CODECs and the Ingenic JZ4780 SoC.
author: Takashi Iwai <tiwai@suse.de> 2015-04-13 08:14:29 -0400
committer: Takashi Iwai <tiwai@suse.de> 2015-04-13 08:14:29 -0400
commit: ce4524e5a78123fbf2db5b1549798c91a6d98294 (patch)
tree: fc6450c80af14542f8bdb6b4726674669d259969 /sound
parent: f2aa111041ce36b94e651d882458dea502e76721 (diff)
parent: 7667428f80526d908124e0647ac5dbe3dad88900 (diff)
130 files changed, 7429 insertions, 1978 deletions
diff --git a/sound/soc/Kconfig b/sound/soc/Kconfig
index dcc79aa0236b..3ba52da18bc6 100644
--- a/sound/soc/Kconfig
+++ b/sound/soc/Kconfig
@@ -47,6 +47,7 @@ source "sound/soc/kirkwood/Kconfig"
 source "sound/soc/intel/Kconfig"
 source "sound/soc/mxs/Kconfig"
 source "sound/soc/pxa/Kconfig"
+source "sound/soc/qcom/Kconfig"
 source "sound/soc/rockchip/Kconfig"
 source "sound/soc/samsung/Kconfig"
 source "sound/soc/sh/Kconfig"
diff --git a/sound/soc/Makefile b/sound/soc/Makefile
index 5b3c8f67c8db..974ba708b482 100644
--- a/sound/soc/Makefile
+++ b/sound/soc/Makefile
@@ -28,6 +28,7 @@ obj-$(CONFIG_SND_SOC)	+= nuc900/
 obj-$(CONFIG_SND_SOC)   += omap/
 obj-$(CONFIG_SND_SOC)   += kirkwood/
 obj-$(CONFIG_SND_SOC)   += pxa/
+obj-$(CONFIG_SND_SOC)   += qcom/
 obj-$(CONFIG_SND_SOC)   += rockchip/
 obj-$(CONFIG_SND_SOC)   += samsung/
 obj-$(CONFIG_SND_SOC)   += sh/
diff --git a/sound/soc/atmel/Kconfig b/sound/soc/atmel/Kconfig
index 1579e994acf8..e7d08806f3e9 100644
--- a/sound/soc/atmel/Kconfig
+++ b/sound/soc/atmel/Kconfig
@@ -25,7 +25,8 @@ config SND_ATMEL_SOC_SSC
 config SND_AT91_SOC_SAM9G20_WM8731
        tristate "SoC Audio support for WM8731-based At91sam9g20 evaluation board"
-        depends on ARCH_AT91 && ATMEL_SSC && SND_ATMEL_SOC
+        depends on ARCH_AT91 || COMPILE_TEST
+        depends on ATMEL_SSC && SND_ATMEL_SOC && SND_SOC_I2C_AND_SPI
        select SND_ATMEL_SOC_PDC
        select SND_ATMEL_SOC_SSC
        select SND_SOC_WM8731
@@ -35,7 +36,8 @@ config SND_AT91_SOC_SAM9G20_WM8731
 config SND_ATMEL_SOC_WM8904
        tristate "Atmel ASoC driver for boards using WM8904 codec"
-        depends on ARCH_AT91 && ATMEL_SSC && SND_ATMEL_SOC && I2C
+        depends on ARCH_AT91 || COMPILE_TEST
+        depends on ATMEL_SSC && SND_ATMEL_SOC && I2C
        select SND_ATMEL_SOC_SSC
        select SND_ATMEL_SOC_DMA
        select SND_SOC_WM8904
@@ -45,7 +47,8 @@ config SND_ATMEL_SOC_WM8904
 config SND_AT91_SOC_SAM9X5_WM8731
        tristate "SoC Audio support for WM8731-based at91sam9x5 board"
-        depends on ARCH_AT91 && ATMEL_SSC && SND_ATMEL_SOC
+        depends on ARCH_AT91 || COMPILE_TEST
+        depends on ATMEL_SSC && SND_ATMEL_SOC && SND_SOC_I2C_AND_SPI
        select SND_ATMEL_SOC_SSC
        select SND_ATMEL_SOC_DMA
        select SND_SOC_WM8731
diff --git a/sound/soc/atmel/Makefile b/sound/soc/atmel/Makefile
index 466a821da98c..b327e5cc8de3 100644
--- a/sound/soc/atmel/Makefile
+++ b/sound/soc/atmel/Makefile
@@ -1,10 +1,8 @@
 # AT91 Platform Support
-snd-soc-atmel-pcm-objs := atmel-pcm.o
 snd-soc-atmel-pcm-pdc-objs := atmel-pcm-pdc.o
 snd-soc-atmel-pcm-dma-objs := atmel-pcm-dma.o
 snd-soc-atmel_ssc_dai-objs := atmel_ssc_dai.o
-obj-$(CONFIG_SND_ATMEL_SOC) += snd-soc-atmel-pcm.o
 obj-$(CONFIG_SND_ATMEL_SOC_PDC) += snd-soc-atmel-pcm-pdc.o
 obj-$(CONFIG_SND_ATMEL_SOC_DMA) += snd-soc-atmel-pcm-dma.o
 obj-$(CONFIG_SND_ATMEL_SOC_SSC) += snd-soc-atmel_ssc_dai.o
diff --git a/sound/soc/atmel/atmel-pcm-dma.c b/sound/soc/atmel/atmel-pcm-dma.c
index b8e7bad05eb1..b6625c8c411b 100644
--- a/sound/soc/atmel/atmel-pcm-dma.c
+++ b/sound/soc/atmel/atmel-pcm-dma.c
@@ -54,7 +54,7 @@ static const struct snd_pcm_hardware atmel_pcm_dma_hardware = {
        .period_bytes_max       = 2 * 0xffff,   /* if 2 bytes format */
        .periods_min            = 8,
        .periods_max            = 1024,         /* no limit */
-        .buffer_bytes_max       = ATMEL_SSC_DMABUF_SIZE,
+        .buffer_bytes_max       = 512 * 1024,
 };
 /**
@@ -119,7 +119,7 @@ static int atmel_pcm_configure_dma(struct snd_pcm_substream *substream,
 static const struct snd_dmaengine_pcm_config atmel_dmaengine_pcm_config = {
        .prepare_slave_config = atmel_pcm_configure_dma,
        .pcm_hardware = &atmel_pcm_dma_hardware,
-        .prealloc_buffer_size = ATMEL_SSC_DMABUF_SIZE,
+        .prealloc_buffer_size = 64 * 1024,
 };
 int atmel_pcm_dma_platform_register(struct device *dev)
diff --git a/sound/soc/atmel/atmel-pcm-pdc.c b/sound/soc/atmel/atmel-pcm-pdc.c
index a366b3503c28..da861b44413f 100644
--- a/sound/soc/atmel/atmel-pcm-pdc.c
+++ b/sound/soc/atmel/atmel-pcm-pdc.c
@@ -47,6 +47,85 @@
 #include "atmel-pcm.h"
+static int atmel_pcm_preallocate_dma_buffer(struct snd_pcm *pcm,
+        int stream)
+{
+        struct snd_pcm_substream *substream = pcm->streams[stream].substream;
+        struct snd_dma_buffer *buf = &substream->dma_buffer;
+        size_t size = ATMEL_SSC_DMABUF_SIZE;
+        buf->dev.type = SNDRV_DMA_TYPE_DEV;
+        buf->dev.dev = pcm->card->dev;
+        buf->private_data = NULL;
+        buf->area = dma_alloc_coherent(pcm->card->dev, size,
+                        &buf->addr, GFP_KERNEL);
+        pr_debug("atmel-pcm: alloc dma buffer: area=%p, addr=%p, size=%zu\n",
+                        (void *)buf->area, (void *)(long)buf->addr, size);
+        if (!buf->area)
+                return -ENOMEM;
+        buf->bytes = size;
+        return 0;
+}
+static int atmel_pcm_mmap(struct snd_pcm_substream *substream,
+        struct vm_area_struct *vma)
+{
+        return remap_pfn_range(vma, vma->vm_start,
+                       substream->dma_buffer.addr >> PAGE_SHIFT,
+                       vma->vm_end - vma->vm_start, vma->vm_page_prot);
+}
+static int atmel_pcm_new(struct snd_soc_pcm_runtime *rtd)
+{
+        struct snd_card *card = rtd->card->snd_card;
+        struct snd_pcm *pcm = rtd->pcm;
+        int ret;
+        ret = dma_coerce_mask_and_coherent(card->dev, DMA_BIT_MASK(32));
+        if (ret)
+                return ret;
+        if (pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream) {
+                pr_debug("atmel-pcm: allocating PCM playback DMA buffer\n");
+                ret = atmel_pcm_preallocate_dma_buffer(pcm,
+                        SNDRV_PCM_STREAM_PLAYBACK);
+                if (ret)
+                        goto out;
+        }
+        if (pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream) {
+                pr_debug("atmel-pcm: allocating PCM capture DMA buffer\n");
+                ret = atmel_pcm_preallocate_dma_buffer(pcm,
+                        SNDRV_PCM_STREAM_CAPTURE);
+                if (ret)
+                        goto out;
+        }
+ out:
+        return ret;
+}
+static void atmel_pcm_free(struct snd_pcm *pcm)
+{
+        struct snd_pcm_substream *substream;
+        struct snd_dma_buffer *buf;
+        int stream;
+        for (stream = 0; stream < 2; stream++) {
+                substream = pcm->streams[stream].substream;
+                if (!substream)
+                        continue;
+                buf = &substream->dma_buffer;
+                if (!buf->area)
+                        continue;
+                dma_free_coherent(pcm->card->dev, buf->bytes,
+                                  buf->area, buf->addr);
+                buf->area = NULL;
+        }
+}
 /*--------------------------------------------------------------------------*\
 * Hardware definition
 \*--------------------------------------------------------------------------*/
diff --git a/sound/soc/atmel/atmel-pcm.c b/sound/soc/atmel/atmel-pcm.c
deleted file mode 100644
index 8ae3fa5ac60a..000000000000
--- a/sound/soc/atmel/atmel-pcm.c
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
- * atmel-pcm.c  --  ALSA PCM interface for the Atmel atmel SoC.
- *
- *  Copyright (C) 2005 SAN People
- *  Copyright (C) 2008 Atmel
- *
- * Authors: Sedji Gaouaou <sedji.gaouaou@atmel.com>
- *
- * Based on at91-pcm. by:
- * Frank Mandarino <fmandarino@endrelia.com>
- * Copyright 2006 Endrelia Technologies Inc.
- *
- * Based on pxa2xx-pcm.c by:
- *
- * Author:      Nicolas Pitre
- * Created:     Nov 30, 2004
- * Copyright:   (C) 2004 MontaVista Software, Inc.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- */
-#include <linux/module.h>
-#include <linux/dma-mapping.h>
-#include <sound/pcm.h>
-#include <sound/soc.h>
-#include "atmel-pcm.h"
-static int atmel_pcm_preallocate_dma_buffer(struct snd_pcm *pcm,
-        int stream)
-{
-        struct snd_pcm_substream *substream = pcm->streams[stream].substream;
-        struct snd_dma_buffer *buf = &substream->dma_buffer;
-        size_t size = ATMEL_SSC_DMABUF_SIZE;
-        buf->dev.type = SNDRV_DMA_TYPE_DEV;
-        buf->dev.dev = pcm->card->dev;
-        buf->private_data = NULL;
-        buf->area = dma_alloc_coherent(pcm->card->dev, size,
-                        &buf->addr, GFP_KERNEL);
-        pr_debug("atmel-pcm: alloc dma buffer: area=%p, addr=%p, size=%zu\n",
-                        (void *)buf->area, (void *)(long)buf->addr, size);
-        if (!buf->area)
-                return -ENOMEM;
-        buf->bytes = size;
-        return 0;
-}
-int atmel_pcm_mmap(struct snd_pcm_substream *substream,
-        struct vm_area_struct *vma)
-{
-        return remap_pfn_range(vma, vma->vm_start,
-                       substream->dma_buffer.addr >> PAGE_SHIFT,
-                       vma->vm_end - vma->vm_start, vma->vm_page_prot);
-}
-EXPORT_SYMBOL_GPL(atmel_pcm_mmap);
-int atmel_pcm_new(struct snd_soc_pcm_runtime *rtd)
-{
-        struct snd_card *card = rtd->card->snd_card;
-        struct snd_pcm *pcm = rtd->pcm;
-        int ret;
-        ret = dma_coerce_mask_and_coherent(card->dev, DMA_BIT_MASK(32));
-        if (ret)
-                return ret;
-        if (pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream) {
-                pr_debug("atmel-pcm: allocating PCM playback DMA buffer\n");
-                ret = atmel_pcm_preallocate_dma_buffer(pcm,
-                        SNDRV_PCM_STREAM_PLAYBACK);
-                if (ret)
-                        goto out;
-        }
-        if (pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream) {
-                pr_debug("atmel-pcm: allocating PCM capture DMA buffer\n");
-                ret = atmel_pcm_preallocate_dma_buffer(pcm,
-                        SNDRV_PCM_STREAM_CAPTURE);
-                if (ret)
-                        goto out;
-        }
- out:
-        return ret;
-}
-EXPORT_SYMBOL_GPL(atmel_pcm_new);
-void atmel_pcm_free(struct snd_pcm *pcm)
-{
-        struct snd_pcm_substream *substream;
-        struct snd_dma_buffer *buf;
-        int stream;
-        for (stream = 0; stream < 2; stream++) {
-                substream = pcm->streams[stream].substream;
-                if (!substream)
-                        continue;
-                buf = &substream->dma_buffer;
-                if (!buf->area)
-                        continue;
-                dma_free_coherent(pcm->card->dev, buf->bytes,
-                                  buf->area, buf->addr);
-                buf->area = NULL;
-        }
-}
-EXPORT_SYMBOL_GPL(atmel_pcm_free);
diff --git a/sound/soc/atmel/atmel-pcm.h b/sound/soc/atmel/atmel-pcm.h
index 12ae814eff21..6eaf081cad50 100644
--- a/sound/soc/atmel/atmel-pcm.h
+++ b/sound/soc/atmel/atmel-pcm.h
@@ -83,11 +83,6 @@ struct atmel_pcm_dma_params {
 #define ssc_readx(base, reg)            (__raw_readl((base) + (reg)))
 #define ssc_writex(base, reg, value)    __raw_writel((value), (base) + (reg))
-int atmel_pcm_new(struct snd_soc_pcm_runtime *rtd);
-void atmel_pcm_free(struct snd_pcm *pcm);
-int atmel_pcm_mmap(struct snd_pcm_substream *substream,
-                struct vm_area_struct *vma);
 #if defined(CONFIG_SND_ATMEL_SOC_PDC) || \
        defined(CONFIG_SND_ATMEL_SOC_PDC_MODULE)
 int atmel_pcm_pdc_platform_register(struct device *dev);
diff --git a/sound/soc/codecs/Kconfig b/sound/soc/codecs/Kconfig
index 0bddd929837f..061c46587628 100644
--- a/sound/soc/codecs/Kconfig
+++ b/sound/soc/codecs/Kconfig
@@ -70,6 +70,7 @@ config SND_SOC_ALL_CODECS
        select SND_SOC_MAX98090 if I2C
        select SND_SOC_MAX98095 if I2C
        select SND_SOC_MAX98357A if GPIOLIB
+        select SND_SOC_MAX98925 if I2C
        select SND_SOC_MAX9850 if I2C
        select SND_SOC_MAX9768 if I2C
        select SND_SOC_MAX9877 if I2C
@@ -461,6 +462,9 @@ config SND_SOC_MAX98095
 config SND_SOC_MAX98357A
       tristate
+config SND_SOC_MAX98925
+       tristate
 config SND_SOC_MAX9850
        tristate
diff --git a/sound/soc/codecs/Makefile b/sound/soc/codecs/Makefile
index 7acb6c174cb4..abe2d7edf65c 100644
--- a/sound/soc/codecs/Makefile
+++ b/sound/soc/codecs/Makefile
@@ -65,6 +65,7 @@ snd-soc-max98088-objs := max98088.o
 snd-soc-max98090-objs := max98090.o
 snd-soc-max98095-objs := max98095.o
 snd-soc-max98357a-objs := max98357a.o
+snd-soc-max98925-objs := max98925.o
 snd-soc-max9850-objs := max9850.o
 snd-soc-mc13783-objs := mc13783.o
 snd-soc-ml26124-objs := ml26124.o
@@ -249,6 +250,7 @@ obj-$(CONFIG_SND_SOC_MAX98088)	+= snd-soc-max98088.o
 obj-$(CONFIG_SND_SOC_MAX98090)  += snd-soc-max98090.o
 obj-$(CONFIG_SND_SOC_MAX98095)  += snd-soc-max98095.o
 obj-$(CONFIG_SND_SOC_MAX98357A) += snd-soc-max98357a.o
+obj-$(CONFIG_SND_SOC_MAX98925)  += snd-soc-max98925.o
 obj-$(CONFIG_SND_SOC_MAX9850)   += snd-soc-max9850.o
 obj-$(CONFIG_SND_SOC_MC13783)   += snd-soc-mc13783.o
 obj-$(CONFIG_SND_SOC_ML26124)   += snd-soc-ml26124.o
diff --git a/sound/soc/codecs/ab8500-codec.c b/sound/soc/codecs/ab8500-codec.c
index 7895689588da..88ca9cb0ce79 100644
--- a/sound/soc/codecs/ab8500-codec.c
+++ b/sound/soc/codecs/ab8500-codec.c
@@ -2003,7 +2003,6 @@ static int ab8500_audio_setup_mics(struct snd_soc_codec *codec,
        return 0;
 }
-EXPORT_SYMBOL_GPL(ab8500_audio_setup_mics);
 static int ab8500_audio_set_ear_cmv(struct snd_soc_codec *codec,
                                enum ear_cm_voltage ear_cmv)
@@ -2036,7 +2035,6 @@ static int ab8500_audio_set_ear_cmv(struct snd_soc_codec *codec,
        return 0;
 }
-EXPORT_SYMBOL_GPL(ab8500_audio_set_ear_cmv);
 static int ab8500_audio_set_bit_delay(struct snd_soc_dai *dai,
                                unsigned int delay)
diff --git a/sound/soc/codecs/ak4554.c b/sound/soc/codecs/ak4554.c
index 16ce9f9fefa1..298dedc05140 100644
--- a/sound/soc/codecs/ak4554.c
+++ b/sound/soc/codecs/ak4554.c
@@ -84,7 +84,7 @@ static int ak4554_soc_remove(struct platform_device *pdev)
        return 0;
 }
-static struct of_device_id ak4554_of_match[] = {
+static const struct of_device_id ak4554_of_match[] = {
        { .compatible = "asahi-kasei,ak4554" },
        {},
 };
diff --git a/sound/soc/codecs/ak4642.c b/sound/soc/codecs/ak4642.c
index dde8b49c19ad..13585e88f597 100644
--- a/sound/soc/codecs/ak4642.c
+++ b/sound/soc/codecs/ak4642.c
@@ -97,6 +97,9 @@
 #define PMMP            (1 << 2) /* MPWR pin Power Management */
 #define MGAIN0          (1 << 0) /* MIC amp gain*/
+/* SG_SL2 */
+#define LOPS            (1 << 6) /* Stero Line-out Power Save Mode */
 /* TIMER */
 #define ZTM(param)      ((param & 0x3) << 4) /* ALC Zero Crossing TimeOut */
 #define WTM(param)      (((param & 0x4) << 4) | ((param & 0x3) << 2))
@@ -168,6 +171,29 @@ static const struct snd_kcontrol_new ak4642_lout_mixer_controls[] = {
        SOC_DAPM_SINGLE("DACL", SG_SL1, 4, 1, 0),
 };
+/* event handlers */
+static int ak4642_lout_event(struct snd_soc_dapm_widget *w,
+                             struct snd_kcontrol *kcontrol, int event)
+{
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
+        switch (event) {
+        case SND_SOC_DAPM_PRE_PMD:
+        case SND_SOC_DAPM_PRE_PMU:
+                /* Power save mode ON */
+                snd_soc_update_bits(codec, SG_SL2, LOPS, LOPS);
+                break;
+        case SND_SOC_DAPM_POST_PMU:
+        case SND_SOC_DAPM_POST_PMD:
+                /* Power save mode OFF */
+                mdelay(300);
+                snd_soc_update_bits(codec, SG_SL2, LOPS, 0);
+                break;
+        }
+        return 0;
+}
 static const struct snd_soc_dapm_widget ak4642_dapm_widgets[] = {
        /* Outputs */
@@ -182,12 +208,15 @@ static const struct snd_soc_dapm_widget ak4642_dapm_widgets[] = {
        SND_SOC_DAPM_PGA("DACH", MD_CTL4, 0, 0, NULL, 0),
-        SND_SOC_DAPM_MIXER("LINEOUT Mixer", PW_MGMT1, 3, 0,
+        SND_SOC_DAPM_MIXER_E("LINEOUT Mixer", PW_MGMT1, 3, 0,
                           &ak4642_lout_mixer_controls[0],
-                           ARRAY_SIZE(ak4642_lout_mixer_controls)),
+                           ARRAY_SIZE(ak4642_lout_mixer_controls),
+                           ak4642_lout_event,
+                           SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
+                           SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMD),
        /* DAC */
-        SND_SOC_DAPM_DAC("DAC", "HiFi Playback", PW_MGMT1, 2, 0),
+        SND_SOC_DAPM_DAC("DAC", NULL, PW_MGMT1, 2, 0),
 };
 static const struct snd_soc_dapm_route ak4642_intercon[] = {
@@ -205,6 +234,8 @@ static const struct snd_soc_dapm_route ak4642_intercon[] = {
        {"DACH", NULL, "DAC"},
        {"LINEOUT Mixer", "DACL", "DAC"},
+        { "DAC", NULL, "Playback" },
 };
 /*
@@ -468,13 +499,13 @@ static struct snd_soc_dai_driver ak4642_dai = {
        .name = "ak4642-hifi",
        .playback = {
                .stream_name = "Playback",
-                .channels_min = 1,
+                .channels_min = 2,
                .channels_max = 2,
                .rates = SNDRV_PCM_RATE_8000_48000,
                .formats = SNDRV_PCM_FMTBIT_S16_LE },
        .capture = {
                .stream_name = "Capture",
-                .channels_min = 1,
+                .channels_min = 2,
                .channels_max = 2,
                .rates = SNDRV_PCM_RATE_8000_48000,
                .formats = SNDRV_PCM_FMTBIT_S16_LE },
diff --git a/sound/soc/codecs/arizona.c b/sound/soc/codecs/arizona.c
index 29202610dd0d..9015b44a9e11 100644
--- a/sound/soc/codecs/arizona.c
+++ b/sound/soc/codecs/arizona.c
@@ -1901,7 +1901,7 @@ static int arizona_is_enabled_fll(struct arizona_fll *fll)
 static int arizona_enable_fll(struct arizona_fll *fll)
 {
        struct arizona *arizona = fll->arizona;
-        int ret;
+        unsigned long time_left;
        bool use_sync = false;
        int already_enabled = arizona_is_enabled_fll(fll);
        struct arizona_fll_cfg cfg;
@@ -1977,9 +1977,9 @@ static int arizona_enable_fll(struct arizona_fll *fll)
                regmap_update_bits_async(arizona->regmap, fll->base + 1,
                                         ARIZONA_FLL1_FREERUN, 0);
-        ret = wait_for_completion_timeout(&fll->ok,
+        time_left = wait_for_completion_timeout(&fll->ok,
                                          msecs_to_jiffies(250));
-        if (ret == 0)
+        if (time_left == 0)
                arizona_fll_warn(fll, "Timed out waiting for lock\n");
        return 0;
diff --git a/sound/soc/codecs/cs4271.c b/sound/soc/codecs/cs4271.c
index 7d3a6accaf9a..e770ee6f36da 100644
--- a/sound/soc/codecs/cs4271.c
+++ b/sound/soc/codecs/cs4271.c
@@ -561,10 +561,10 @@ static int cs4271_codec_probe(struct snd_soc_codec *codec)
        if (gpio_is_valid(cs4271->gpio_nreset)) {
                /* Reset codec */
                gpio_direction_output(cs4271->gpio_nreset, 0);
-                udelay(1);
+                mdelay(1);
                gpio_set_value(cs4271->gpio_nreset, 1);
                /* Give the codec time to wake up */
-                udelay(1);
+                mdelay(1);
        }
        ret = regmap_update_bits(cs4271->regmap, CS4271_MODE2,
diff --git a/sound/soc/codecs/cx20442.c b/sound/soc/codecs/cx20442.c
index 0b10979513c4..0f334bc1b63c 100644
--- a/sound/soc/codecs/cx20442.c
+++ b/sound/soc/codecs/cx20442.c
@@ -420,7 +420,7 @@ static int cx20442_platform_probe(struct platform_device *pdev)
                        &cx20442_codec_dev, &cx20442_dai, 1);
 }
-static int __exit cx20442_platform_remove(struct platform_device *pdev)
+static int cx20442_platform_remove(struct platform_device *pdev)
 {
        snd_soc_unregister_codec(&pdev->dev);
        return 0;
@@ -431,7 +431,7 @@ static struct platform_driver cx20442_platform_driver = {
                .name = "cx20442-codec",
                },
        .probe = cx20442_platform_probe,
-        .remove = __exit_p(cx20442_platform_remove),
+        .remove = cx20442_platform_remove,
 };
 module_platform_driver(cx20442_platform_driver);
diff --git a/sound/soc/codecs/max98090.c b/sound/soc/codecs/max98090.c
index b112b1c2c394..3e33ef2acf3c 100644
--- a/sound/soc/codecs/max98090.c
+++ b/sound/soc/codecs/max98090.c
@@ -2605,8 +2605,24 @@ err_enable:
        return ret;
 }
+static void max98090_i2c_shutdown(struct i2c_client *i2c)
+{
+        struct max98090_priv *max98090 = dev_get_drvdata(&i2c->dev);
+        /*
+         * Enable volume smoothing, disable zero cross.  This will cause
+         * a quick 40ms ramp to mute on shutdown.
+         */
+        regmap_write(max98090->regmap,
+                M98090_REG_LEVEL_CONTROL, M98090_VSENN_MASK);
+        regmap_write(max98090->regmap,
+                M98090_REG_DEVICE_SHUTDOWN, 0x00);
+        msleep(40);
+}
 static int max98090_i2c_remove(struct i2c_client *client)
 {
+        max98090_i2c_shutdown(client);
        snd_soc_unregister_codec(&client->dev);
        return 0;
 }
@@ -2696,6 +2712,7 @@ static struct i2c_driver max98090_i2c_driver = {
                .acpi_match_table = ACPI_PTR(max98090_acpi_match),
        },
        .probe  = max98090_i2c_probe,
+        .shutdown = max98090_i2c_shutdown,
        .remove = max98090_i2c_remove,
        .id_table = max98090_i2c_id,
 };
diff --git a/sound/soc/codecs/max98925.c b/sound/soc/codecs/max98925.c
new file mode 100644
index 000000000000..9b5a17de4690
--- /dev/null
+++ b/sound/soc/codecs/max98925.c
@@ -0,0 +1,655 @@
+/*
+ * max98925.c -- ALSA SoC Stereo MAX98925 driver
+ * Copyright 2013-15 Maxim Integrated Products
+ * 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/delay.h>
+#include <linux/i2c.h>
+#include <linux/module.h>
+#include <linux/regmap.h>
+#include <linux/slab.h>
+#include <linux/cdev.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/soc.h>
+#include <sound/tlv.h>
+#include "max98925.h"
+static const char *const dai_text[] = {
+        "Left", "Right", "LeftRight", "LeftRightDiv2",
+};
+static const char * const max98925_boost_voltage_text[] = {
+        "8.5V", "8.25V", "8.0V", "7.75V", "7.5V", "7.25V", "7.0V", "6.75V",
+        "6.5V", "6.5V", "6.5V", "6.5V", "6.5V", "6.5V", "6.5V", "6.5V"
+};
+static SOC_ENUM_SINGLE_DECL(max98925_boost_voltage,
+        MAX98925_CONFIGURATION, M98925_BST_VOUT_SHIFT,
+        max98925_boost_voltage_text);
+static const char *const hpf_text[] = {
+        "Disable", "DC Block", "100Hz", "200Hz", "400Hz", "800Hz",
+};
+static const struct reg_default max98925_reg[] = {
+        { 0x0B, 0x00 }, /* IRQ Enable0 */
+        { 0x0C, 0x00 }, /* IRQ Enable1 */
+        { 0x0D, 0x00 }, /* IRQ Enable2 */
+        { 0x0E, 0x00 }, /* IRQ Clear0 */
+        { 0x0F, 0x00 }, /* IRQ Clear1 */
+        { 0x10, 0x00 }, /* IRQ Clear2 */
+        { 0x11, 0xC0 }, /* Map0 */
+        { 0x12, 0x00 }, /* Map1 */
+        { 0x13, 0x00 }, /* Map2 */
+        { 0x14, 0xF0 }, /* Map3 */
+        { 0x15, 0x00 }, /* Map4 */
+        { 0x16, 0xAB }, /* Map5 */
+        { 0x17, 0x89 }, /* Map6 */
+        { 0x18, 0x00 }, /* Map7 */
+        { 0x19, 0x00 }, /* Map8 */
+        { 0x1A, 0x06 }, /* DAI Clock Mode 1 */
+        { 0x1B, 0xC0 }, /* DAI Clock Mode 2 */
+        { 0x1C, 0x00 }, /* DAI Clock Divider Denominator MSBs */
+        { 0x1D, 0x00 }, /* DAI Clock Divider Denominator LSBs */
+        { 0x1E, 0xF0 }, /* DAI Clock Divider Numerator MSBs */
+        { 0x1F, 0x00 }, /* DAI Clock Divider Numerator LSBs */
+        { 0x20, 0x50 }, /* Format */
+        { 0x21, 0x00 }, /* TDM Slot Select */
+        { 0x22, 0x00 }, /* DOUT Configuration VMON */
+        { 0x23, 0x00 }, /* DOUT Configuration IMON */
+        { 0x24, 0x00 }, /* DOUT Configuration VBAT */
+        { 0x25, 0x00 }, /* DOUT Configuration VBST */
+        { 0x26, 0x00 }, /* DOUT Configuration FLAG */
+        { 0x27, 0xFF }, /* DOUT HiZ Configuration 1 */
+        { 0x28, 0xFF }, /* DOUT HiZ Configuration 2 */
+        { 0x29, 0xFF }, /* DOUT HiZ Configuration 3 */
+        { 0x2A, 0xFF }, /* DOUT HiZ Configuration 4 */
+        { 0x2B, 0x02 }, /* DOUT Drive Strength */
+        { 0x2C, 0x90 }, /* Filters */
+        { 0x2D, 0x00 }, /* Gain */
+        { 0x2E, 0x02 }, /* Gain Ramping */
+        { 0x2F, 0x00 }, /* Speaker Amplifier */
+        { 0x30, 0x0A }, /* Threshold */
+        { 0x31, 0x00 }, /* ALC Attack */
+        { 0x32, 0x80 }, /* ALC Atten and Release */
+        { 0x33, 0x00 }, /* ALC Infinite Hold Release */
+        { 0x34, 0x92 }, /* ALC Configuration */
+        { 0x35, 0x01 }, /* Boost Converter */
+        { 0x36, 0x00 }, /* Block Enable */
+        { 0x37, 0x00 }, /* Configuration */
+        { 0x38, 0x00 }, /* Global Enable */
+        { 0x3A, 0x00 }, /* Boost Limiter */
+};
+static const struct soc_enum max98925_dai_enum =
+        SOC_ENUM_SINGLE(MAX98925_GAIN, 5, ARRAY_SIZE(dai_text), dai_text);
+static const struct soc_enum max98925_hpf_enum =
+        SOC_ENUM_SINGLE(MAX98925_FILTERS, 0, ARRAY_SIZE(hpf_text), hpf_text);
+static const struct snd_kcontrol_new max98925_hpf_sel_mux =
+        SOC_DAPM_ENUM("Rc Filter MUX Mux", max98925_hpf_enum);
+static const struct snd_kcontrol_new max98925_dai_sel_mux =
+        SOC_DAPM_ENUM("DAI IN MUX Mux", max98925_dai_enum);
+static int max98925_dac_event(struct snd_soc_dapm_widget *w,
+                struct snd_kcontrol *kcontrol, int event)
+{
+        struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
+        struct max98925_priv *max98925 = snd_soc_codec_get_drvdata(codec);
+        switch (event) {
+        case SND_SOC_DAPM_PRE_PMU:
+                regmap_update_bits(max98925->regmap,
+                        MAX98925_BLOCK_ENABLE,
+                        M98925_BST_EN_MASK |
+                        M98925_ADC_IMON_EN_MASK | M98925_ADC_VMON_EN_MASK,
+                        M98925_BST_EN_MASK |
+                        M98925_ADC_IMON_EN_MASK | M98925_ADC_VMON_EN_MASK);
+                break;
+        case SND_SOC_DAPM_POST_PMD:
+                regmap_update_bits(max98925->regmap,
+                        MAX98925_BLOCK_ENABLE, M98925_BST_EN_MASK |
+                        M98925_ADC_IMON_EN_MASK | M98925_ADC_VMON_EN_MASK, 0);
+                break;
+        default:
+                return 0;
+        }
+        return 0;
+}
+static const struct snd_soc_dapm_widget max98925_dapm_widgets[] = {
+        SND_SOC_DAPM_AIF_IN("DAI_OUT", "HiFi Playback", 0, SND_SOC_NOPM, 0, 0),
+        SND_SOC_DAPM_MUX("DAI IN MUX", SND_SOC_NOPM, 0, 0,
+                                &max98925_dai_sel_mux),
+        SND_SOC_DAPM_MUX("Rc Filter MUX", SND_SOC_NOPM, 0, 0,
+                                &max98925_hpf_sel_mux),
+        SND_SOC_DAPM_DAC_E("Amp Enable", NULL, MAX98925_BLOCK_ENABLE,
+                        M98925_SPK_EN_SHIFT, 0, max98925_dac_event,
+                        SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
+        SND_SOC_DAPM_SUPPLY("Global Enable", MAX98925_GLOBAL_ENABLE,
+                        M98925_EN_SHIFT, 0, NULL, 0),
+        SND_SOC_DAPM_OUTPUT("BE_OUT"),
+};
+static const struct snd_soc_dapm_route max98925_audio_map[] = {
+        {"DAI IN MUX", "Left", "DAI_OUT"},
+        {"DAI IN MUX", "Right", "DAI_OUT"},
+        {"DAI IN MUX", "LeftRight", "DAI_OUT"},
+        {"DAI IN MUX", "LeftRightDiv2", "DAI_OUT"},
+        {"Rc Filter MUX", "Disable", "DAI IN MUX"},
+        {"Rc Filter MUX", "DC Block", "DAI IN MUX"},
+        {"Rc Filter MUX", "100Hz", "DAI IN MUX"},
+        {"Rc Filter MUX", "200Hz", "DAI IN MUX"},
+        {"Rc Filter MUX", "400Hz", "DAI IN MUX"},
+        {"Rc Filter MUX", "800Hz", "DAI IN MUX"},
+        {"Amp Enable", NULL, "Rc Filter MUX"},
+        {"BE_OUT", NULL, "Amp Enable"},
+        {"BE_OUT", NULL, "Global Enable"},
+};
+static bool max98925_volatile_register(struct device *dev, unsigned int reg)
+{
+        switch (reg) {
+        case MAX98925_VBAT_DATA:
+        case MAX98925_VBST_DATA:
+        case MAX98925_LIVE_STATUS0:
+        case MAX98925_LIVE_STATUS1:
+        case MAX98925_LIVE_STATUS2:
+        case MAX98925_STATE0:
+        case MAX98925_STATE1:
+        case MAX98925_STATE2:
+        case MAX98925_FLAG0:
+        case MAX98925_FLAG1:
+        case MAX98925_FLAG2:
+        case MAX98925_REV_VERSION:
+                return true;
+        default:
+                return false;
+        }
+}
+static bool max98925_readable_register(struct device *dev, unsigned int reg)
+{
+        switch (reg) {
+        case MAX98925_IRQ_CLEAR0:
+        case MAX98925_IRQ_CLEAR1:
+        case MAX98925_IRQ_CLEAR2:
+        case MAX98925_ALC_HOLD_RLS:
+                return false;
+        default:
+                return true;
+        }
+}
+static DECLARE_TLV_DB_SCALE(max98925_spk_tlv, -600, 100, 0);
+static const struct snd_kcontrol_new max98925_snd_controls[] = {
+        SOC_SINGLE_TLV("Speaker Volume", MAX98925_GAIN,
+                M98925_SPK_GAIN_SHIFT, (1<<M98925_SPK_GAIN_WIDTH)-1, 0,
+                max98925_spk_tlv),
+        SOC_SINGLE("Ramp Switch", MAX98925_GAIN_RAMPING,
+                                M98925_SPK_RMP_EN_SHIFT, 1, 0),
+        SOC_SINGLE("ZCD Switch", MAX98925_GAIN_RAMPING,
+                                M98925_SPK_ZCD_EN_SHIFT, 1, 0),
+        SOC_SINGLE("ALC Switch", MAX98925_THRESHOLD,
+                                M98925_ALC_EN_SHIFT, 1, 0),
+        SOC_SINGLE("ALC Threshold", MAX98925_THRESHOLD, M98925_ALC_TH_SHIFT,
+                                (1<<M98925_ALC_TH_WIDTH)-1, 0),
+        SOC_ENUM("Boost Output Voltage", max98925_boost_voltage),
+};
+/* codec sample rate and n/m dividers parameter table */
+static const struct {
+        int rate;
+        int  sr;
+        int divisors[3][2];
+} rate_table[] = {
+        {
+                .rate = 8000,
+                .sr = 0,
+                .divisors = { {1, 375}, {5, 1764}, {1, 384} }
+        },
+        {
+                .rate = 11025,
+                .sr = 1,
+                .divisors = { {147, 40000}, {1, 256}, {147, 40960} }
+        },
+        {
+                .rate = 12000,
+                .sr = 2,
+                .divisors = { {1, 250}, {5, 1176}, {1, 256} }
+        },
+        {
+                .rate = 16000,
+                .sr = 3,
+                .divisors = { {2, 375}, {5, 882}, {1, 192} }
+        },
+        {
+                .rate = 22050,
+                .sr = 4,
+                .divisors = { {147, 20000}, {1, 128}, {147, 20480} }
+        },
+        {
+                .rate = 24000,
+                .sr = 5,
+                .divisors = { {1, 125}, {5, 588}, {1, 128} }
+        },
+        {
+                .rate = 32000,
+                .sr = 6,
+                .divisors = { {4, 375}, {5, 441}, {1, 96} }
+        },
+        {
+                .rate = 44100,
+                .sr = 7,
+                .divisors = { {147, 10000}, {1, 64}, {147, 10240} }
+        },
+        {
+                .rate = 48000,
+                .sr = 8,
+                .divisors = { {2, 125}, {5, 294}, {1, 64} }
+        },
+};
+static inline int max98925_rate_value(struct snd_soc_codec *codec,
+                int rate, int clock, int *value, int *n, int *m)
+{
+        int ret = -EINVAL;
+        int i;
+        for (i = 0; i < ARRAY_SIZE(rate_table); i++) {
+                if (rate_table[i].rate >= rate) {
+                        *value = rate_table[i].sr;
+                        *n = rate_table[i].divisors[clock][0];
+                        *m = rate_table[i].divisors[clock][1];
+                        ret = 0;
+                        break;
+                }
+        }
+        dev_dbg(codec->dev, "%s: sample rate is %d, returning %d\n",
+                                __func__, rate_table[i].rate, *value);
+        return ret;
+}
+static void max98925_set_sense_data(struct max98925_priv *max98925)
+{
+        /* set VMON slots */
+        regmap_update_bits(max98925->regmap,
+                MAX98925_DOUT_CFG_VMON,
+                M98925_DAI_VMON_EN_MASK, M98925_DAI_VMON_EN_MASK);
+        regmap_update_bits(max98925->regmap,
+                MAX98925_DOUT_CFG_VMON,
+                M98925_DAI_VMON_SLOT_MASK,
+                max98925->v_slot << M98925_DAI_VMON_SLOT_SHIFT);
+        /* set IMON slots */
+        regmap_update_bits(max98925->regmap,
+                MAX98925_DOUT_CFG_IMON,
+                M98925_DAI_IMON_EN_MASK, M98925_DAI_IMON_EN_MASK);
+        regmap_update_bits(max98925->regmap,
+                MAX98925_DOUT_CFG_IMON,
+                M98925_DAI_IMON_SLOT_MASK,
+                max98925->i_slot << M98925_DAI_IMON_SLOT_SHIFT);
+}
+static int max98925_dai_set_fmt(struct snd_soc_dai *codec_dai,
+                                 unsigned int fmt)
+{
+        struct snd_soc_codec *codec = codec_dai->codec;
+        struct max98925_priv *max98925 = snd_soc_codec_get_drvdata(codec);
+        unsigned int invert = 0;
+        dev_dbg(codec->dev, "%s: fmt 0x%08X\n", __func__, fmt);
+        switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
+        case SND_SOC_DAIFMT_CBS_CFS:
+                /* set DAI to slave mode */
+                regmap_update_bits(max98925->regmap,
+                        MAX98925_DAI_CLK_MODE2,
+                        M98925_DAI_MAS_MASK, 0);
+                max98925_set_sense_data(max98925);
+                break;
+        case SND_SOC_DAIFMT_CBM_CFM:
+                /*
+                 * set left channel DAI to master mode,
+                 * right channel always slave
+                 */
+                regmap_update_bits(max98925->regmap,
+                        MAX98925_DAI_CLK_MODE2,
+                        M98925_DAI_MAS_MASK, M98925_DAI_MAS_MASK);
+                break;
+        case SND_SOC_DAIFMT_CBS_CFM:
+        case SND_SOC_DAIFMT_CBM_CFS:
+        default:
+                dev_err(codec->dev, "DAI clock mode unsupported");
+                return -EINVAL;
+        }
+        switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
+        case SND_SOC_DAIFMT_NB_NF:
+                break;
+        case SND_SOC_DAIFMT_NB_IF:
+                invert = M98925_DAI_WCI_MASK;
+                break;
+        case SND_SOC_DAIFMT_IB_NF:
+                invert = M98925_DAI_BCI_MASK;
+                break;
+        case SND_SOC_DAIFMT_IB_IF:
+                invert = M98925_DAI_BCI_MASK | M98925_DAI_WCI_MASK;
+                break;
+        default:
+                dev_err(codec->dev, "DAI invert mode unsupported");
+                return -EINVAL;
+        }
+        regmap_update_bits(max98925->regmap, MAX98925_FORMAT,
+                        M98925_DAI_BCI_MASK, invert);
+        return 0;
+}
+static int max98925_set_clock(struct max98925_priv *max98925,
+                struct snd_pcm_hw_params *params)
+{
+        unsigned int dai_sr = 0, clock, mdll, n, m;
+        struct snd_soc_codec *codec = max98925->codec;
+        int rate = params_rate(params);
+        /* BCLK/LRCLK ratio calculation */
+        int blr_clk_ratio = params_channels(params) * max98925->ch_size;
+        switch (blr_clk_ratio) {
+        case 32:
+                regmap_update_bits(max98925->regmap,
+                        MAX98925_DAI_CLK_MODE2,
+                        M98925_DAI_BSEL_MASK, M98925_DAI_BSEL_32);
+                break;
+        case 48:
+                regmap_update_bits(max98925->regmap,
+                        MAX98925_DAI_CLK_MODE2,
+                        M98925_DAI_BSEL_MASK, M98925_DAI_BSEL_48);
+                break;
+        case 64:
+                regmap_update_bits(max98925->regmap,
+                        MAX98925_DAI_CLK_MODE2,
+                        M98925_DAI_BSEL_MASK, M98925_DAI_BSEL_64);
+                break;
+        default:
+                return -EINVAL;
+        }
+        switch (max98925->sysclk) {
+        case 6000000:
+                clock = 0;
+                mdll  = M98925_MDLL_MULT_MCLKx16;
+                break;
+        case 11289600:
+                clock = 1;
+                mdll  = M98925_MDLL_MULT_MCLKx8;
+                break;
+        case 12000000:
+                clock = 0;
+                mdll  = M98925_MDLL_MULT_MCLKx8;
+                break;
+        case 12288000:
+                clock = 2;
+                mdll  = M98925_MDLL_MULT_MCLKx8;
+                break;
+        default:
+                dev_info(max98925->codec->dev, "unsupported sysclk %d\n",
+                                        max98925->sysclk);
+                return -EINVAL;
+        }
+        if (max98925_rate_value(codec, rate, clock, &dai_sr, &n, &m))
+                return -EINVAL;
+        /* set DAI_SR to correct LRCLK frequency */
+        regmap_update_bits(max98925->regmap,
+                        MAX98925_DAI_CLK_MODE2,
+                        M98925_DAI_SR_MASK, dai_sr << M98925_DAI_SR_SHIFT);
+        /* set DAI m divider */
+        regmap_write(max98925->regmap,
+                MAX98925_DAI_CLK_DIV_M_MSBS, m >> 8);
+        regmap_write(max98925->regmap,
+                MAX98925_DAI_CLK_DIV_M_LSBS, m & 0xFF);
+        /* set DAI n divider */
+        regmap_write(max98925->regmap,
+                MAX98925_DAI_CLK_DIV_N_MSBS, n >> 8);
+        regmap_write(max98925->regmap,
+                MAX98925_DAI_CLK_DIV_N_LSBS, n & 0xFF);
+        /* set MDLL */
+        regmap_update_bits(max98925->regmap, MAX98925_DAI_CLK_MODE1,
+                        M98925_MDLL_MULT_MASK, mdll << M98925_MDLL_MULT_SHIFT);
+        return 0;
+}
+static int max98925_dai_hw_params(struct snd_pcm_substream *substream,
+                                   struct snd_pcm_hw_params *params,
+                                   struct snd_soc_dai *dai)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        struct max98925_priv *max98925 = snd_soc_codec_get_drvdata(codec);
+        switch (snd_pcm_format_width(params_format(params))) {
+        case 16:
+                regmap_update_bits(max98925->regmap,
+                                MAX98925_FORMAT,
+                                M98925_DAI_CHANSZ_MASK, M98925_DAI_CHANSZ_16);
+                max98925->ch_size = 16;
+                break;
+        case 24:
+                regmap_update_bits(max98925->regmap,
+                                MAX98925_FORMAT,
+                                M98925_DAI_CHANSZ_MASK, M98925_DAI_CHANSZ_24);
+                max98925->ch_size = 24;
+                break;
+        case 32:
+                regmap_update_bits(max98925->regmap,
+                                MAX98925_FORMAT,
+                                M98925_DAI_CHANSZ_MASK, M98925_DAI_CHANSZ_32);
+                max98925->ch_size = 32;
+                break;
+        default:
+                pr_err("%s: format unsupported %d",
+                                __func__, params_format(params));
+                return -EINVAL;
+        }
+        dev_dbg(codec->dev, "%s: format supported %d",
+                                __func__, params_format(params));
+        return max98925_set_clock(max98925, params);
+}
+static int max98925_dai_set_sysclk(struct snd_soc_dai *dai,
+                                   int clk_id, unsigned int freq, int dir)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        struct max98925_priv *max98925 = snd_soc_codec_get_drvdata(codec);
+        switch (clk_id) {
+        case 0:
+                /* use MCLK for Left channel, right channel always BCLK */
+                regmap_update_bits(max98925->regmap,
+                                MAX98925_DAI_CLK_MODE1,
+                                M98925_DAI_CLK_SOURCE_MASK, 0);
+                break;
+        case 1:
+                /* configure dai clock source to BCLK instead of MCLK */
+                regmap_update_bits(max98925->regmap,
+                                MAX98925_DAI_CLK_MODE1,
+                                M98925_DAI_CLK_SOURCE_MASK,
+                                M98925_DAI_CLK_SOURCE_MASK);
+                break;
+        default:
+                return -EINVAL;
+        }
+        max98925->sysclk = freq;
+        return 0;
+}
+#define MAX98925_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | \
+                        SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32_LE)
+static const struct snd_soc_dai_ops max98925_dai_ops = {
+        .set_sysclk = max98925_dai_set_sysclk,
+        .set_fmt = max98925_dai_set_fmt,
+        .hw_params = max98925_dai_hw_params,
+};
+static struct snd_soc_dai_driver max98925_dai[] = {
+        {
+                .name = "max98925-aif1",
+                .playback = {
+                        .stream_name = "HiFi Playback",
+                        .channels_min = 1,
+                        .channels_max = 2,
+                        .rates = SNDRV_PCM_RATE_8000_48000,
+                        .formats = MAX98925_FORMATS,
+                },
+                .capture = {
+                        .stream_name = "HiFi Capture",
+                        .channels_min = 1,
+                        .channels_max = 2,
+                        .rates = SNDRV_PCM_RATE_8000_48000,
+                        .formats = MAX98925_FORMATS,
+                },
+                .ops = &max98925_dai_ops,
+        }
+};
+static int max98925_probe(struct snd_soc_codec *codec)
+{
+        struct max98925_priv *max98925 = snd_soc_codec_get_drvdata(codec);
+        max98925->codec = codec;
+        codec->control_data = max98925->regmap;
+        regmap_write(max98925->regmap, MAX98925_GLOBAL_ENABLE, 0x00);
+        /* It's not the default but we need to set DAI_DLY */
+        regmap_write(max98925->regmap,
+                        MAX98925_FORMAT, M98925_DAI_DLY_MASK);
+        regmap_write(max98925->regmap, MAX98925_TDM_SLOT_SELECT, 0xC8);
+        regmap_write(max98925->regmap, MAX98925_DOUT_HIZ_CFG1, 0xFF);
+        regmap_write(max98925->regmap, MAX98925_DOUT_HIZ_CFG2, 0xFF);
+        regmap_write(max98925->regmap, MAX98925_DOUT_HIZ_CFG3, 0xFF);
+        regmap_write(max98925->regmap, MAX98925_DOUT_HIZ_CFG4, 0xF0);
+        regmap_write(max98925->regmap, MAX98925_FILTERS, 0xD8);
+        regmap_write(max98925->regmap, MAX98925_ALC_CONFIGURATION, 0xF8);
+        regmap_write(max98925->regmap, MAX98925_CONFIGURATION, 0xF0);
+        /* Disable ALC muting */
+        regmap_write(max98925->regmap, MAX98925_BOOST_LIMITER, 0xF8);
+        return 0;
+}
+static const struct snd_soc_codec_driver soc_codec_dev_max98925 = {
+        .probe            = max98925_probe,
+        .controls = max98925_snd_controls,
+        .num_controls = ARRAY_SIZE(max98925_snd_controls),
+        .dapm_routes = max98925_audio_map,
+        .num_dapm_routes = ARRAY_SIZE(max98925_audio_map),
+        .dapm_widgets = max98925_dapm_widgets,
+        .num_dapm_widgets = ARRAY_SIZE(max98925_dapm_widgets),
+};
+static const struct regmap_config max98925_regmap = {
+        .reg_bits         = 8,
+        .val_bits         = 8,
+        .max_register     = MAX98925_REV_VERSION,
+        .reg_defaults     = max98925_reg,
+        .num_reg_defaults = ARRAY_SIZE(max98925_reg),
+        .volatile_reg     = max98925_volatile_register,
+        .readable_reg     = max98925_readable_register,
+        .cache_type       = REGCACHE_RBTREE,
+};
+static int max98925_i2c_probe(struct i2c_client *i2c,
+                             const struct i2c_device_id *id)
+{
+        int ret, reg;
+        u32 value;
+        struct max98925_priv *max98925;
+        max98925 = devm_kzalloc(&i2c->dev,
+                        sizeof(*max98925), GFP_KERNEL);
+        if (!max98925)
+                return -ENOMEM;
+        i2c_set_clientdata(i2c, max98925);
+        max98925->regmap = devm_regmap_init_i2c(i2c, &max98925_regmap);
+        if (IS_ERR(max98925->regmap)) {
+                ret = PTR_ERR(max98925->regmap);
+                dev_err(&i2c->dev,
+                                "Failed to allocate regmap: %d\n", ret);
+                goto err_out;
+        }
+        if (!of_property_read_u32(i2c->dev.of_node, "vmon-slot-no", &value)) {
+                if (value > M98925_DAI_VMON_SLOT_1E_1F) {
+                        dev_err(&i2c->dev, "vmon slot number is wrong:\n");
+                        return -EINVAL;
+                }
+                max98925->v_slot = value;
+        }
+        if (!of_property_read_u32(i2c->dev.of_node, "imon-slot-no", &value)) {
+                if (value > M98925_DAI_IMON_SLOT_1E_1F) {
+                        dev_err(&i2c->dev, "imon slot number is wrong:\n");
+                        return -EINVAL;
+                }
+                max98925->i_slot = value;
+        }
+        ret = regmap_read(max98925->regmap,
+                        MAX98925_REV_VERSION, &reg);
+        if ((ret < 0) ||
+                ((reg != MAX98925_VERSION) &&
+                (reg != MAX98925_VERSION1))) {
+                dev_err(&i2c->dev,
+                        "device initialization error (%d 0x%02X)\n",
+                        ret, reg);
+                goto err_out;
+        }
+        dev_info(&i2c->dev, "device version 0x%02X\n", reg);
+        ret = snd_soc_register_codec(&i2c->dev, &soc_codec_dev_max98925,
+                        max98925_dai, ARRAY_SIZE(max98925_dai));
+        if (ret < 0)
+                dev_err(&i2c->dev,
+                                "Failed to register codec: %d\n", ret);
+err_out:
+        return ret;
+}
+static int max98925_i2c_remove(struct i2c_client *client)
+{
+        snd_soc_unregister_codec(&client->dev);
+        return 0;
+}
+static const struct i2c_device_id max98925_i2c_id[] = {
+        { "max98925", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, max98925_i2c_id);
+static const struct of_device_id max98925_of_match[] = {
+        { .compatible = "maxim,max98925", },
+        { }
+};
+MODULE_DEVICE_TABLE(of, max98925_of_match);
+static struct i2c_driver max98925_i2c_driver = {
+        .driver = {
+                .name = "max98925",
+                .owner = THIS_MODULE,
+                .of_match_table = of_match_ptr(max98925_of_match),
+                .pm = NULL,
+        },
+        .probe  = max98925_i2c_probe,
+        .remove = max98925_i2c_remove,
+        .id_table = max98925_i2c_id,
+};
+module_i2c_driver(max98925_i2c_driver)
+MODULE_DESCRIPTION("ALSA SoC MAX98925 driver");
+MODULE_AUTHOR("Ralph Birt <rdbirt@gmail.com>, Anish kumar <anish.kumar@maximintegrated.com>");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/codecs/max98925.h b/sound/soc/codecs/max98925.h
new file mode 100644
index 000000000000..3783248f2780
--- /dev/null
+++ b/sound/soc/codecs/max98925.h
@@ -0,0 +1,832 @@
+/*
+ * max98925.h -- MAX98925 ALSA SoC Audio driver
+ *
+ * Copyright 2013-2015 Maxim Integrated Products
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#ifndef _MAX98925_H
+#define _MAX98925_H
+#define MAX98925_VERSION        0x51
+#define MAX98925_VERSION1       0x80
+#define MAX98925_VBAT_DATA              0x00
+#define MAX98925_VBST_DATA              0x01
+#define MAX98925_LIVE_STATUS0           0x02
+#define MAX98925_LIVE_STATUS1           0x03
+#define MAX98925_LIVE_STATUS2           0x04
+#define MAX98925_STATE0                 0x05
+#define MAX98925_STATE1                 0x06
+#define MAX98925_STATE2                 0x07
+#define MAX98925_FLAG0                  0x08
+#define MAX98925_FLAG1                  0x09
+#define MAX98925_FLAG2                  0x0A
+#define MAX98925_IRQ_ENABLE0            0x0B
+#define MAX98925_IRQ_ENABLE1            0x0C
+#define MAX98925_IRQ_ENABLE2            0x0D
+#define MAX98925_IRQ_CLEAR0             0x0E
+#define MAX98925_IRQ_CLEAR1             0x0F
+#define MAX98925_IRQ_CLEAR2             0x10
+#define MAX98925_MAP0                   0x11
+#define MAX98925_MAP1                   0x12
+#define MAX98925_MAP2                   0x13
+#define MAX98925_MAP3                   0x14
+#define MAX98925_MAP4                   0x15
+#define MAX98925_MAP5                   0x16
+#define MAX98925_MAP6                   0x17
+#define MAX98925_MAP7                   0x18
+#define MAX98925_MAP8                   0x19
+#define MAX98925_DAI_CLK_MODE1          0x1A
+#define MAX98925_DAI_CLK_MODE2          0x1B
+#define MAX98925_DAI_CLK_DIV_M_MSBS     0x1C
+#define MAX98925_DAI_CLK_DIV_M_LSBS     0x1D
+#define MAX98925_DAI_CLK_DIV_N_MSBS     0x1E
+#define MAX98925_DAI_CLK_DIV_N_LSBS     0x1F
+#define MAX98925_FORMAT                 0x20
+#define MAX98925_TDM_SLOT_SELECT        0x21
+#define MAX98925_DOUT_CFG_VMON          0x22
+#define MAX98925_DOUT_CFG_IMON          0x23
+#define MAX98925_DOUT_CFG_VBAT          0x24
+#define MAX98925_DOUT_CFG_VBST          0x25
+#define MAX98925_DOUT_CFG_FLAG          0x26
+#define MAX98925_DOUT_HIZ_CFG1          0x27
+#define MAX98925_DOUT_HIZ_CFG2          0x28
+#define MAX98925_DOUT_HIZ_CFG3          0x29
+#define MAX98925_DOUT_HIZ_CFG4          0x2A
+#define MAX98925_DOUT_DRV_STRENGTH      0x2B
+#define MAX98925_FILTERS                0x2C
+#define MAX98925_GAIN                   0x2D
+#define MAX98925_GAIN_RAMPING           0x2E
+#define MAX98925_SPK_AMP                0x2F
+#define MAX98925_THRESHOLD              0x30
+#define MAX98925_ALC_ATTACK             0x31
+#define MAX98925_ALC_ATTEN_RLS          0x32
+#define MAX98925_ALC_HOLD_RLS           0x33
+#define MAX98925_ALC_CONFIGURATION      0x34
+#define MAX98925_BOOST_CONVERTER        0x35
+#define MAX98925_BLOCK_ENABLE           0x36
+#define MAX98925_CONFIGURATION          0x37
+#define MAX98925_GLOBAL_ENABLE          0x38
+#define MAX98925_BOOST_LIMITER          0x3A
+#define MAX98925_REV_VERSION            0xFF
+#define MAX98925_REG_CNT               (MAX98925_R03A_BOOST_LIMITER+1)
+/* MAX98925 Register Bit Fields */
+/* MAX98925_R002_LIVE_STATUS0 */
+#define M98925_THERMWARN_STATUS_MASK                    (1<<3)
+#define M98925_THERMWARN_STATUS_SHIFT                   3
+#define M98925_THERMWARN_STATUS_WIDTH                   1
+#define M98925_THERMSHDN_STATUS_MASK                    (1<<1)
+#define M98925_THERMSHDN_STATUS_SHIFT                   1
+#define M98925_THERMSHDN_STATUS_WIDTH                   1
+/* MAX98925_R003_LIVE_STATUS1 */
+#define M98925_SPKCURNT_STATUS_MASK                     (1<<5)
+#define M98925_SPKCURNT_STATUS_SHIFT                    5
+#define M98925_SPKCURNT_STATUS_WIDTH                    1
+#define M98925_WATCHFAIL_STATUS_MASK                    (1<<4)
+#define M98925_WATCHFAIL_STATUS_SHIFT                   4
+#define M98925_WATCHFAIL_STATUS_WIDTH                   1
+#define M98925_ALCINFH_STATUS_MASK                      (1<<3)
+#define M98925_ALCINFH_STATUS_SHIFT                     3
+#define M98925_ALCINFH_STATUS_WIDTH                     1
+#define M98925_ALCACT_STATUS_MASK                       (1<<2)
+#define M98925_ALCACT_STATUS_SHIFT                      2
+#define M98925_ALCACT_STATUS_WIDTH                      1
+#define M98925_ALCMUT_STATUS_MASK                       (1<<1)
+#define M98925_ALCMUT_STATUS_SHIFT                      1
+#define M98925_ALCMUT_STATUS_WIDTH                      1
+#define M98925_ACLP_STATUS_MASK                         (1<<0)
+#define M98925_ACLP_STATUS_SHIFT                        0
+#define M98925_ACLP_STATUS_WIDTH                        1
+/* MAX98925_R004_LIVE_STATUS2 */
+#define M98925_SLOTOVRN_STATUS_MASK                     (1<<6)
+#define M98925_SLOTOVRN_STATUS_SHIFT                    6
+#define M98925_SLOTOVRN_STATUS_WIDTH                    1
+#define M98925_INVALSLOT_STATUS_MASK                    (1<<5)
+#define M98925_INVALSLOT_STATUS_SHIFT                   5
+#define M98925_INVALSLOT_STATUS_WIDTH                   1
+#define M98925_SLOTCNFLT_STATUS_MASK                    (1<<4)
+#define M98925_SLOTCNFLT_STATUS_SHIFT                   4
+#define M98925_SLOTCNFLT_STATUS_WIDTH                   1
+#define M98925_VBSTOVFL_STATUS_MASK                     (1<<3)
+#define M98925_VBSTOVFL_STATUS_SHIFT                    3
+#define M98925_VBSTOVFL_STATUS_WIDTH                    1
+#define M98925_VBATOVFL_STATUS_MASK                     (1<<2)
+#define M98925_VBATOVFL_STATUS_SHIFT                    2
+#define M98925_VBATOVFL_STATUS_WIDTH                    1
+#define M98925_IMONOVFL_STATUS_MASK                     (1<<1)
+#define M98925_IMONOVFL_STATUS_SHIFT                    1
+#define M98925_IMONOVFL_STATUS_WIDTH                    1
+#define M98925_VMONOVFL_STATUS_MASK                     (1<<0)
+#define M98925_VMONOVFL_STATUS_SHIFT                    0
+#define M98925_VMONOVFL_STATUS_WIDTH                    1
+/* MAX98925_R005_STATE0 */
+#define M98925_THERMWARN_END_STATE_MASK                 (1<<3)
+#define M98925_THERMWARN_END_STATE_SHIFT                3
+#define M98925_THERMWARN_END_STATE_WIDTH                1
+#define M98925_THERMWARN_BGN_STATE_MASK                 (1<<2)
+#define M98925_THERMWARN_BGN_STATE_SHIFT                1
+#define M98925_THERMWARN_BGN_STATE_WIDTH                1
+#define M98925_THERMSHDN_END_STATE_MASK                 (1<<1)
+#define M98925_THERMSHDN_END_STATE_SHIFT                1
+#define M98925_THERMSHDN_END_STATE_WIDTH                1
+#define M98925_THERMSHDN_BGN_STATE_MASK                 (1<<0)
+#define M98925_THERMSHDN_BGN_STATE_SHIFT                0
+#define M98925_THERMSHDN_BGN_STATE_WIDTH                1
+/* MAX98925_R006_STATE1 */
+#define M98925_SPRCURNT_STATE_MASK                      (1<<5)
+#define M98925_SPRCURNT_STATE_SHIFT                     5
+#define M98925_SPRCURNT_STATE_WIDTH                     1
+#define M98925_WATCHFAIL_STATE_MASK                     (1<<4)
+#define M98925_WATCHFAIL_STATE_SHIFT                    4
+#define M98925_WATCHFAIL_STATE_WIDTH                    1
+#define M98925_ALCINFH_STATE_MASK                       (1<<3)
+#define M98925_ALCINFH_STATE_SHIFT                      3
+#define M98925_ALCINFH_STATE_WIDTH                      1
+#define M98925_ALCACT_STATE_MASK                        (1<<2)
+#define M98925_ALCACT_STATE_SHIFT                       2
+#define M98925_ALCACT_STATE_WIDTH                       1
+#define M98925_ALCMUT_STATE_MASK                        (1<<1)
+#define M98925_ALCMUT_STATE_SHIFT                       1
+#define M98925_ALCMUT_STATE_WIDTH                       1
+#define M98925_ALCP_STATE_MASK                          (1<<0)
+#define M98925_ALCP_STATE_SHIFT                         0
+#define M98925_ALCP_STATE_WIDTH                         1
+/* MAX98925_R007_STATE2 */
+#define M98925_SLOTOVRN_STATE_MASK                      (1<<6)
+#define M98925_SLOTOVRN_STATE_SHIFT                     6
+#define M98925_SLOTOVRN_STATE_WIDTH                     1
+#define M98925_INVALSLOT_STATE_MASK                     (1<<5)
+#define M98925_INVALSLOT_STATE_SHIFT                    5
+#define M98925_INVALSLOT_STATE_WIDTH                    1
+#define M98925_SLOTCNFLT_STATE_MASK                     (1<<4)
+#define M98925_SLOTCNFLT_STATE_SHIFT                    4
+#define M98925_SLOTCNFLT_STATE_WIDTH                    1
+#define M98925_VBSTOVFL_STATE_MASK                      (1<<3)
+#define M98925_VBSTOVFL_STATE_SHIFT                     3
+#define M98925_VBSTOVFL_STATE_WIDTH                     1
+#define M98925_VBATOVFL_STATE_MASK                      (1<<2)
+#define M98925_VBATOVFL_STATE_SHIFT                     2
+#define M98925_VBATOVFL_STATE_WIDTH                     1
+#define M98925_IMONOVFL_STATE_MASK                      (1<<1)
+#define M98925_IMONOVFL_STATE_SHIFT                     1
+#define M98925_IMONOVFL_STATE_WIDTH                     1
+#define M98925_VMONOVFL_STATE_MASK                      (1<<0)
+#define M98925_VMONOVFL_STATE_SHIFT                     0
+#define M98925_VMONOVFL_STATE_WIDTH                     1
+/* MAX98925_R008_FLAG0 */
+#define M98925_THERMWARN_END_FLAG_MASK                  (1<<3)
+#define M98925_THERMWARN_END_FLAG_SHIFT                 3
+#define M98925_THERMWARN_END_FLAG_WIDTH                 1
+#define M98925_THERMWARN_BGN_FLAG_MASK                  (1<<2)
+#define M98925_THERMWARN_BGN_FLAG_SHIFT                 2
+#define M98925_THERMWARN_BGN_FLAG_WIDTH                 1
+#define M98925_THERMSHDN_END_FLAG_MASK                  (1<<1)
+#define M98925_THERMSHDN_END_FLAG_SHIFT                 1
+#define M98925_THERMSHDN_END_FLAG_WIDTH                 1
+#define M98925_THERMSHDN_BGN_FLAG_MASK                  (1<<0)
+#define M98925_THERMSHDN_BGN_FLAG_SHIFT                 0
+#define M98925_THERMSHDN_BGN_FLAG_WIDTH                 1
+/* MAX98925_R009_FLAG1 */
+#define M98925_SPKCURNT_FLAG_MASK                       (1<<5)
+#define M98925_SPKCURNT_FLAG_SHIFT                      5
+#define M98925_SPKCURNT_FLAG_WIDTH                      1
+#define M98925_WATCHFAIL_FLAG_MASK                      (1<<4)
+#define M98925_WATCHFAIL_FLAG_SHIFT                     4
+#define M98925_WATCHFAIL_FLAG_WIDTH                     1
+#define M98925_ALCINFH_FLAG_MASK                        (1<<3)
+#define M98925_ALCINFH_FLAG_SHIFT                       3
+#define M98925_ALCINFH_FLAG_WIDTH                       1
+#define M98925_ALCACT_FLAG_MASK                         (1<<2)
+#define M98925_ALCACT_FLAG_SHIFT                        2
+#define M98925_ALCACT_FLAG_WIDTH                        1
+#define M98925_ALCMUT_FLAG_MASK                         (1<<1)
+#define M98925_ALCMUT_FLAG_SHIFT                        1
+#define M98925_ALCMUT_FLAG_WIDTH                        1
+#define M98925_ALCP_FLAG_MASK                           (1<<0)
+#define M98925_ALCP_FLAG_SHIFT                          0
+#define M98925_ALCP_FLAG_WIDTH                          1
+/* MAX98925_R00A_FLAG2 */
+#define M98925_SLOTOVRN_FLAG_MASK                       (1<<6)
+#define M98925_SLOTOVRN_FLAG_SHIFT                      6
+#define M98925_SLOTOVRN_FLAG_WIDTH                      1
+#define M98925_INVALSLOT_FLAG_MASK                      (1<<5)
+#define M98925_INVALSLOT_FLAG_SHIFT                     5
+#define M98925_INVALSLOT_FLAG_WIDTH                     1
+#define M98925_SLOTCNFLT_FLAG_MASK                      (1<<4)
+#define M98925_SLOTCNFLT_FLAG_SHIFT                     4
+#define M98925_SLOTCNFLT_FLAG_WIDTH                     1
+#define M98925_VBSTOVFL_FLAG_MASK                       (1<<3)
+#define M98925_VBSTOVFL_FLAG_SHIFT                      3
+#define M98925_VBSTOVFL_FLAG_WIDTH                      1
+#define M98925_VBATOVFL_FLAG_MASK                       (1<<2)
+#define M98925_VBATOVFL_FLAG_SHIFT                      2
+#define M98925_VBATOVFL_FLAG_WIDTH                      1
+#define M98925_IMONOVFL_FLAG_MASK                       (1<<1)
+#define M98925_IMONOVFL_FLAG_SHIFT                      1
+#define M98925_IMONOVFL_FLAG_WIDTH                      1
+#define M98925_VMONOVFL_FLAG_MASK                       (1<<0)
+#define M98925_VMONOVFL_FLAG_SHIFT                      0
+#define M98925_VMONOVFL_FLAG_WIDTH                      1
+/* MAX98925_R00B_IRQ_ENABLE0 */
+#define M98925_THERMWARN_END_EN_MASK                    (1<<3)
+#define M98925_THERMWARN_END_EN_SHIFT                   3
+#define M98925_THERMWARN_END_EN_WIDTH                   1
+#define M98925_THERMWARN_BGN_EN_MASK                    (1<<2)
+#define M98925_THERMWARN_BGN_EN_SHIFT                   2
+#define M98925_THERMWARN_BGN_EN_WIDTH                   1
+#define M98925_THERMSHDN_END_EN_MASK                    (1<<1)
+#define M98925_THERMSHDN_END_EN_SHIFT                   1
+#define M98925_THERMSHDN_END_EN_WIDTH                   1
+#define M98925_THERMSHDN_BGN_EN_MASK                    (1<<0)
+#define M98925_THERMSHDN_BGN_EN_SHIFT                   0
+#define M98925_THERMSHDN_BGN_EN_WIDTH                   1
+/* MAX98925_R00C_IRQ_ENABLE1 */
+#define M98925_SPKCURNT_EN_MASK                         (1<<5)
+#define M98925_SPKCURNT_EN_SHIFT                        5
+#define M98925_SPKCURNT_EN_WIDTH                        1
+#define M98925_WATCHFAIL_EN_MASK                        (1<<4)
+#define M98925_WATCHFAIL_EN_SHIFT                       4
+#define M98925_WATCHFAIL_EN_WIDTH                       1
+#define M98925_ALCINFH_EN_MASK                          (1<<3)
+#define M98925_ALCINFH_EN_SHIFT                         3
+#define M98925_ALCINFH_EN_WIDTH                         1
+#define M98925_ALCACT_EN_MASK                           (1<<2)
+#define M98925_ALCACT_EN_SHIFT                          2
+#define M98925_ALCACT_EN_WIDTH                          1
+#define M98925_ALCMUT_EN_MASK                           (1<<1)
+#define M98925_ALCMUT_EN_SHIFT                          1
+#define M98925_ALCMUT_EN_WIDTH                          1
+#define M98925_ALCP_EN_MASK                                     (1<<0)
+#define M98925_ALCP_EN_SHIFT                            0
+#define M98925_ALCP_EN_WIDTH                            1
+/* MAX98925_R00D_IRQ_ENABLE2 */
+#define M98925_SLOTOVRN_EN_MASK                                 (1<<6)
+#define M98925_SLOTOVRN_EN_SHIFT                                6
+#define M98925_SLOTOVRN_EN_WIDTH                                1
+#define M98925_INVALSLOT_EN_MASK                                (1<<5)
+#define M98925_INVALSLOT_EN_SHIFT                               5
+#define M98925_INVALSLOT_EN_WIDTH                               1
+#define M98925_SLOTCNFLT_EN_MASK                                (1<<4)
+#define M98925_SLOTCNFLT_EN_SHIFT                               4
+#define M98925_SLOTCNFLT_EN_WIDTH                               1
+#define M98925_VBSTOVFL_EN_MASK                                 (1<<3)
+#define M98925_VBSTOVFL_EN_SHIFT                                3
+#define M98925_VBSTOVFL_EN_WIDTH                                1
+#define M98925_VBATOVFL_EN_MASK                                 (1<<2)
+#define M98925_VBATOVFL_EN_SHIFT                                2
+#define M98925_VBATOVFL_EN_WIDTH                                1
+#define M98925_IMONOVFL_EN_MASK                                 (1<<1)
+#define M98925_IMONOVFL_EN_SHIFT                                1
+#define M98925_IMONOVFL_EN_WIDTH                                1
+#define M98925_VMONOVFL_EN_MASK                                 (1<<0)
+#define M98925_VMONOVFL_EN_SHIFT                                0
+#define M98925_VMONOVFL_EN_WIDTH                                1
+/* MAX98925_R00E_IRQ_CLEAR0 */
+#define M98925_THERMWARN_END_CLR_MASK                   (1<<3)
+#define M98925_THERMWARN_END_CLR_SHIFT                  3
+#define M98925_THERMWARN_END_CLR_WIDTH                  1
+#define M98925_THERMWARN_BGN_CLR_MASK                   (1<<2)
+#define M98925_THERMWARN_BGN_CLR_SHIFT                  2
+#define M98925_THERMWARN_BGN_CLR_WIDTH                  1
+#define M98925_THERMSHDN_END_CLR_MASK                   (1<<1)
+#define M98925_THERMSHDN_END_CLR_SHIFT                  1
+#define M98925_THERMSHDN_END_CLR_WIDTH                  1
+#define M98925_THERMSHDN_BGN_CLR_MASK                   (1<<0)
+#define M98925_THERMSHDN_BGN_CLR_SHIFT                  0
+#define M98925_THERMSHDN_BGN_CLR_WIDTH                  1
+/* MAX98925_R00F_IRQ_CLEAR1 */
+#define M98925_SPKCURNT_CLR_MASK                                (1<<5)
+#define M98925_SPKCURNT_CLR_SHIFT                               5
+#define M98925_SPKCURNT_CLR_WIDTH                               1
+#define M98925_WATCHFAIL_CLR_MASK                               (1<<4)
+#define M98925_WATCHFAIL_CLR_SHIFT                              4
+#define M98925_WATCHFAIL_CLR_WIDTH                              1
+#define M98925_ALCINFH_CLR_MASK                                 (1<<3)
+#define M98925_ALCINFH_CLR_SHIFT                                3
+#define M98925_ALCINFH_CLR_WIDTH                                1
+#define M98925_ALCACT_CLR_MASK                                  (1<<2)
+#define M98925_ALCACT_CLR_SHIFT                                 2
+#define M98925_ALCACT_CLR_WIDTH                                 1
+#define M98925_ALCMUT_CLR_MASK                                  (1<<1)
+#define M98925_ALCMUT_CLR_SHIFT                                 1
+#define M98925_ALCMUT_CLR_WIDTH                                 1
+#define M98925_ALCP_CLR_MASK                                    (1<<0)
+#define M98925_ALCP_CLR_SHIFT                                   0
+#define M98925_ALCP_CLR_WIDTH                                   1
+/* MAX98925_R010_IRQ_CLEAR2 */
+#define M98925_SLOTOVRN_CLR_MASK                                (1<<6)
+#define M98925_SLOTOVRN_CLR_SHIFT                               6
+#define M98925_SLOTOVRN_CLR_WIDTH                               1
+#define M98925_INVALSLOT_CLR_MASK                               (1<<5)
+#define M98925_INVALSLOT_CLR_SHIFT                              5
+#define M98925_INVALSLOT_CLR_WIDTH                              1
+#define M98925_SLOTCNFLT_CLR_MASK                               (1<<4)
+#define M98925_SLOTCNFLT_CLR_SHIFT                              4
+#define M98925_SLOTCNFLT_CLR_WIDTH                              1
+#define M98925_VBSTOVFL_CLR_MASK                                (1<<3)
+#define M98925_VBSTOVFL_CLR_SHIFT                               3
+#define M98925_VBSTOVFL_CLR_WIDTH                               1
+#define M98925_VBATOVFL_CLR_MASK                                (1<<2)
+#define M98925_VBATOVFL_CLR_SHIFT                               2
+#define M98925_VBATOVFL_CLR_WIDTH                               1
+#define M98925_IMONOVFL_CLR_MASK                                (1<<1)
+#define M98925_IMONOVFL_CLR_SHIFT                               1
+#define M98925_IMONOVFL_CLR_WIDTH                               1
+#define M98925_VMONOVFL_CLR_MASK                                (1<<0)
+#define M98925_VMONOVFL_CLR_SHIFT                               0
+#define M98925_VMONOVFL_CLR_WIDTH                               1
+/* MAX98925_R011_MAP0 */
+#define M98925_ER_THERMWARN_EN_MASK                             (1<<7)
+#define M98925_ER_THERMWARN_EN_SHIFT                    7
+#define M98925_ER_THERMWARN_EN_WIDTH                    1
+#define M98925_ER_THERMWARN_MAP_MASK                    (0x07<<4)
+#define M98925_ER_THERMWARN_MAP_SHIFT                   4
+#define M98925_ER_THERMWARN_MAP_WIDTH                   3
+/* MAX98925_R012_MAP1 */
+#define M98925_ER_ALCMUT_EN_MASK                                (1<<7)
+#define M98925_ER_ALCMUT_EN_SHIFT                               7
+#define M98925_ER_ALCMUT_EN_WIDTH                               1
+#define M98925_ER_ALCMUT_MAP_MASK                               (0x07<<4)
+#define M98925_ER_ALCMUT_MAP_SHIFT                              4
+#define M98925_ER_ALCMUT_MAP_WIDTH                              3
+#define M98925_ER_ALCP_EN_MASK                                  (1<<3)
+#define M98925_ER_ALCP_EN_SHIFT                                 3
+#define M98925_ER_ALCP_EN_WIDTH                                 1
+#define M98925_ER_ALCP_MAP_MASK                                 (0x07<<0)
+#define M98925_ER_ALCP_MAP_SHIFT                                0
+#define M98925_ER_ALCP_MAP_WIDTH                                3
+/* MAX98925_R013_MAP2 */
+#define M98925_ER_ALCINFH_EN_MASK                               (1<<7)
+#define M98925_ER_ALCINFH_EN_SHIFT                              7
+#define M98925_ER_ALCINFH_EN_WIDTH                              1
+#define M98925_ER_ALCINFH_MAP_MASK                              (0x07<<4)
+#define M98925_ER_ALCINFH_MAP_SHIFT                             4
+#define M98925_ER_ALCINFH_MAP_WIDTH                             3
+#define M98925_ER_ALCACT_EN_MASK                                (1<<3)
+#define M98925_ER_ALCACT_EN_SHIFT                               3
+#define M98925_ER_ALCACT_EN_WIDTH                               1
+#define M98925_ER_ALCACT_MAP_MASK                               (0x07<<0)
+#define M98925_ER_ALCACT_MAP_SHIFT                              0
+#define M98925_ER_ALCACT_MAP_WIDTH                              3
+/* MAX98925_R014_MAP3 */
+#define M98925_ER_SPKCURNT_EN_MASK                              (1<<7)
+#define M98925_ER_SPKCURNT_EN_SHIFT                             7
+#define M98925_ER_SPKCURNT_EN_WIDTH                             1
+#define M98925_ER_SPKCURNT_MAP_MASK                             (0x07<<4)
+#define M98925_ER_SPKCURNT_MAP_SHIFT                    4
+#define M98925_ER_SPKCURNT_MAP_WIDTH                    3
+/* MAX98925_R015_MAP4 */
+/* RESERVED */
+/* MAX98925_R016_MAP5 */
+#define M98925_ER_IMONOVFL_EN_MASK                              (1<<7)
+#define M98925_ER_IMONOVFL_EN_SHIFT                             7
+#define M98925_ER_IMONOVFL_EN_WIDTH                             1
+#define M98925_ER_IMONOVFL_MAP_MASK                             (0x07<<4)
+#define M98925_ER_IMONOVFL_MAP_SHIFT                    4
+#define M98925_ER_IMONOVFL_MAP_WIDTH                    3
+#define M98925_ER_VMONOVFL_EN_MASK                              (1<<3)
+#define M98925_ER_VMONOVFL_EN_SHIFT                             3
+#define M98925_ER_VMONOVFL_EN_WIDTH                             1
+#define M98925_ER_VMONOVFL_MAP_MASK                             (0x07<<0)
+#define M98925_ER_VMONOVFL_MAP_SHIFT                    0
+#define M98925_ER_VMONOVFL_MAP_WIDTH                    3
+/* MAX98925_R017_MAP6 */
+#define M98925_ER_VBSTOVFL_EN_MASK                              (1<<7)
+#define M98925_ER_VBSTOVFL_EN_SHIFT                             7
+#define M98925_ER_VBSTOVFL_EN_WIDTH                             1
+#define M98925_ER_VBSTOVFL_MAP_MASK                             (0x07<<4)
+#define M98925_ER_VBSTOVFL_MAP_SHIFT                    4
+#define M98925_ER_VBSTOVFL_MAP_WIDTH                    3
+#define M98925_ER_VBATOVFL_EN_MASK                              (1<<3)
+#define M98925_ER_VBATOVFL_EN_SHIFT                             3
+#define M98925_ER_VBATOVFL_EN_WIDTH                             1
+#define M98925_ER_VBATOVFL_MAP_MASK                             (0x07<<0)
+#define M98925_ER_VBATOVFL_MAP_SHIFT                    0
+#define M98925_ER_VBATOVFL_MAP_WIDTH                    3
+/* MAX98925_R018_MAP7 */
+#define M98925_ER_INVALSLOT_EN_MASK                             (1<<7)
+#define M98925_ER_INVALSLOT_EN_SHIFT                    7
+#define M98925_ER_INVALSLOT_EN_WIDTH                    1
+#define M98925_ER_INVALSLOT_MAP_MASK                    (0x07<<4)
+#define M98925_ER_INVALSLOT_MAP_SHIFT                   4
+#define M98925_ER_INVALSLOT_MAP_WIDTH                   3
+#define M98925_ER_SLOTCNFLT_EN_MASK                             (1<<3)
+#define M98925_ER_SLOTCNFLT_EN_SHIFT                    3
+#define M98925_ER_SLOTCNFLT_EN_WIDTH                    1
+#define M98925_ER_SLOTCNFLT_MAP_MASK                    (0x07<<0)
+#define M98925_ER_SLOTCNFLT_MAP_SHIFT                   0
+#define M98925_ER_SLOTCNFLT_MAP_WIDTH                   3
+/* MAX98925_R019_MAP8 */
+#define M98925_ER_SLOTOVRN_EN_MASK      (1<<3)
+#define M98925_ER_SLOTOVRN_EN_SHIFT     3
+#define M98925_ER_SLOTOVRN_EN_WIDTH     1
+#define M98925_ER_SLOTOVRN_MAP_MASK     (0x07<<0)
+#define M98925_ER_SLOTOVRN_MAP_SHIFT    0
+#define M98925_ER_SLOTOVRN_MAP_WIDTH    3
+/* MAX98925_R01A_DAI_CLK_MODE1 */
+#define M98925_DAI_CLK_SOURCE_MASK      (1<<6)
+#define M98925_DAI_CLK_SOURCE_SHIFT     6
+#define M98925_DAI_CLK_SOURCE_WIDTH     1
+#define M98925_MDLL_MULT_MASK           (0x0F<<0)
+#define M98925_MDLL_MULT_SHIFT          0
+#define M98925_MDLL_MULT_WIDTH          4
+#define M98925_MDLL_MULT_MCLKx8         6
+#define M98925_MDLL_MULT_MCLKx16        8
+/* MAX98925_R01B_DAI_CLK_MODE2 */
+#define M98925_DAI_SR_MASK                      (0x0F<<4)
+#define M98925_DAI_SR_SHIFT                     4
+#define M98925_DAI_SR_WIDTH                     4
+#define M98925_DAI_MAS_MASK                     (1<<3)
+#define M98925_DAI_MAS_SHIFT                    3
+#define M98925_DAI_MAS_WIDTH                    1
+#define M98925_DAI_BSEL_MASK                    (0x07<<0)
+#define M98925_DAI_BSEL_SHIFT                   0
+#define M98925_DAI_BSEL_WIDTH                   3
+#define M98925_DAI_BSEL_32 (0 << M98925_DAI_BSEL_SHIFT)
+#define M98925_DAI_BSEL_48 (1 << M98925_DAI_BSEL_SHIFT)
+#define M98925_DAI_BSEL_64 (2 << M98925_DAI_BSEL_SHIFT)
+#define M98925_DAI_BSEL_256 (6 << M98925_DAI_BSEL_SHIFT)
+/* MAX98925_R01C_DAI_CLK_DIV_M_MSBS */
+#define M98925_DAI_M_MSBS_MASK                                  (0xFF<<0)
+#define M98925_DAI_M_MSBS_SHIFT                                 0
+#define M98925_DAI_M_MSBS_WIDTH                                 8
+/* MAX98925_R01D_DAI_CLK_DIV_M_LSBS */
+#define M98925_DAI_M_LSBS_MASK                                  (0xFF<<0)
+#define M98925_DAI_M_LSBS_SHIFT                                 0
+#define M98925_DAI_M_LSBS_WIDTH                                 8
+/* MAX98925_R01E_DAI_CLK_DIV_N_MSBS */
+#define M98925_DAI_N_MSBS_MASK                                  (0x7F<<0)
+#define M98925_DAI_N_MSBS_SHIFT                                 0
+#define M98925_DAI_N_MSBS_WIDTH                                 7
+/* MAX98925_R01F_DAI_CLK_DIV_N_LSBS */
+#define M98925_DAI_N_LSBS_MASK                                  (0xFF<<0)
+#define M98925_DAI_N_LSBS_SHIFT                                 0
+#define M98925_DAI_N_LSBS_WIDTH                                 8
+/* MAX98925_R020_FORMAT */
+#define M98925_DAI_CHANSZ_MASK                                  (0x03<<6)
+#define M98925_DAI_CHANSZ_SHIFT                                 6
+#define M98925_DAI_CHANSZ_WIDTH                                 2
+#define M98925_DAI_EXTBCLK_HIZ_MASK                             (1<<4)
+#define M98925_DAI_EXTBCLK_HIZ_SHIFT                    4
+#define M98925_DAI_EXTBCLK_HIZ_WIDTH                    1
+#define M98925_DAI_WCI_MASK                                             (1<<3)
+#define M98925_DAI_WCI_SHIFT                                    3
+#define M98925_DAI_WCI_WIDTH                                    1
+#define M98925_DAI_BCI_MASK                                             (1<<2)
+#define M98925_DAI_BCI_SHIFT                                    2
+#define M98925_DAI_BCI_WIDTH                                    1
+#define M98925_DAI_DLY_MASK                                             (1<<1)
+#define M98925_DAI_DLY_SHIFT                                    1
+#define M98925_DAI_DLY_WIDTH                                    1
+#define M98925_DAI_TDM_MASK                                             (1<<0)
+#define M98925_DAI_TDM_SHIFT                                    0
+#define M98925_DAI_TDM_WIDTH                                    1
+#define M98925_DAI_CHANSZ_16 (1 << M98925_DAI_CHANSZ_SHIFT)
+#define M98925_DAI_CHANSZ_24 (2 << M98925_DAI_CHANSZ_SHIFT)
+#define M98925_DAI_CHANSZ_32 (3 << M98925_DAI_CHANSZ_SHIFT)
+/* MAX98925_R021_TDM_SLOT_SELECT */
+#define M98925_DAI_DO_EN_MASK                                   (1<<7)
+#define M98925_DAI_DO_EN_SHIFT                                  7
+#define M98925_DAI_DO_EN_WIDTH                                  1
+#define M98925_DAI_DIN_EN_MASK                                  (1<<6)
+#define M98925_DAI_DIN_EN_SHIFT                                 6
+#define M98925_DAI_DIN_EN_WIDTH                                 1
+#define M98925_DAI_INR_SOURCE_MASK                              (0x07<<3)
+#define M98925_DAI_INR_SOURCE_SHIFT                             3
+#define M98925_DAI_INR_SOURCE_WIDTH                             3
+#define M98925_DAI_INL_SOURCE_MASK                              (0x07<<0)
+#define M98925_DAI_INL_SOURCE_SHIFT                             0
+#define M98925_DAI_INL_SOURCE_WIDTH                             3
+/* MAX98925_R022_DOUT_CFG_VMON */
+#define M98925_DAI_VMON_EN_MASK                                 (1<<5)
+#define M98925_DAI_VMON_EN_SHIFT                                5
+#define M98925_DAI_VMON_EN_WIDTH                                1
+#define M98925_DAI_VMON_SLOT_MASK                               (0x1F<<0)
+#define M98925_DAI_VMON_SLOT_SHIFT                              0
+#define M98925_DAI_VMON_SLOT_WIDTH                              5
+#define M98925_DAI_VMON_SLOT_00_01 (0 << M98925_DAI_VMON_SLOT_SHIFT)
+#define M98925_DAI_VMON_SLOT_01_02 (1 << M98925_DAI_VMON_SLOT_SHIFT)
+#define M98925_DAI_VMON_SLOT_02_03 (2 << M98925_DAI_VMON_SLOT_SHIFT)
+#define M98925_DAI_VMON_SLOT_03_04 (3 << M98925_DAI_VMON_SLOT_SHIFT)
+#define M98925_DAI_VMON_SLOT_04_05 (4 << M98925_DAI_VMON_SLOT_SHIFT)
+#define M98925_DAI_VMON_SLOT_05_06 (5 << M98925_DAI_VMON_SLOT_SHIFT)
+#define M98925_DAI_VMON_SLOT_06_07 (6 << M98925_DAI_VMON_SLOT_SHIFT)
+#define M98925_DAI_VMON_SLOT_07_08 (7 << M98925_DAI_VMON_SLOT_SHIFT)
+#define M98925_DAI_VMON_SLOT_08_09 (8 << M98925_DAI_VMON_SLOT_SHIFT)
+#define M98925_DAI_VMON_SLOT_09_0A (9 << M98925_DAI_VMON_SLOT_SHIFT)
+#define M98925_DAI_VMON_SLOT_0A_0B (10 << M98925_DAI_VMON_SLOT_SHIFT)
+#define M98925_DAI_VMON_SLOT_0B_0C (11 << M98925_DAI_VMON_SLOT_SHIFT)
+#define M98925_DAI_VMON_SLOT_0C_0D (12 << M98925_DAI_VMON_SLOT_SHIFT)
+#define M98925_DAI_VMON_SLOT_0D_0E (13 << M98925_DAI_VMON_SLOT_SHIFT)
+#define M98925_DAI_VMON_SLOT_0E_0F (14 << M98925_DAI_VMON_SLOT_SHIFT)
+#define M98925_DAI_VMON_SLOT_0F_10 (15 << M98925_DAI_VMON_SLOT_SHIFT)
+#define M98925_DAI_VMON_SLOT_10_11 (16 << M98925_DAI_VMON_SLOT_SHIFT)
+#define M98925_DAI_VMON_SLOT_11_12 (17 << M98925_DAI_VMON_SLOT_SHIFT)
+#define M98925_DAI_VMON_SLOT_12_13 (18 << M98925_DAI_VMON_SLOT_SHIFT)
+#define M98925_DAI_VMON_SLOT_13_14 (19 << M98925_DAI_VMON_SLOT_SHIFT)
+#define M98925_DAI_VMON_SLOT_14_15 (20 << M98925_DAI_VMON_SLOT_SHIFT)
+#define M98925_DAI_VMON_SLOT_15_16 (21 << M98925_DAI_VMON_SLOT_SHIFT)
+#define M98925_DAI_VMON_SLOT_16_17 (22 << M98925_DAI_VMON_SLOT_SHIFT)
+#define M98925_DAI_VMON_SLOT_17_18 (23 << M98925_DAI_VMON_SLOT_SHIFT)
+#define M98925_DAI_VMON_SLOT_18_19 (24 << M98925_DAI_VMON_SLOT_SHIFT)
+#define M98925_DAI_VMON_SLOT_19_1A (25 << M98925_DAI_VMON_SLOT_SHIFT)
+#define M98925_DAI_VMON_SLOT_1A_1B (26 << M98925_DAI_VMON_SLOT_SHIFT)
+#define M98925_DAI_VMON_SLOT_1B_1C (27 << M98925_DAI_VMON_SLOT_SHIFT)
+#define M98925_DAI_VMON_SLOT_1C_1D (28 << M98925_DAI_VMON_SLOT_SHIFT)
+#define M98925_DAI_VMON_SLOT_1D_1E (29 << M98925_DAI_VMON_SLOT_SHIFT)
+#define M98925_DAI_VMON_SLOT_1E_1F (30 << M98925_DAI_VMON_SLOT_SHIFT)
+/* MAX98925_R023_DOUT_CFG_IMON */
+#define M98925_DAI_IMON_EN_MASK                                 (1<<5)
+#define M98925_DAI_IMON_EN_SHIFT                                5
+#define M98925_DAI_IMON_EN_WIDTH                                1
+#define M98925_DAI_IMON_SLOT_MASK                               (0x1F<<0)
+#define M98925_DAI_IMON_SLOT_SHIFT                              0
+#define M98925_DAI_IMON_SLOT_WIDTH                              5
+#define M98925_DAI_IMON_SLOT_00_01 (0 << M98925_DAI_IMON_SLOT_SHIFT)
+#define M98925_DAI_IMON_SLOT_01_02 (1 << M98925_DAI_IMON_SLOT_SHIFT)
+#define M98925_DAI_IMON_SLOT_02_03 (2 << M98925_DAI_IMON_SLOT_SHIFT)
+#define M98925_DAI_IMON_SLOT_03_04 (3 << M98925_DAI_IMON_SLOT_SHIFT)
+#define M98925_DAI_IMON_SLOT_04_05 (4 << M98925_DAI_IMON_SLOT_SHIFT)
+#define M98925_DAI_IMON_SLOT_05_06 (5 << M98925_DAI_IMON_SLOT_SHIFT)
+#define M98925_DAI_IMON_SLOT_06_07 (6 << M98925_DAI_IMON_SLOT_SHIFT)
+#define M98925_DAI_IMON_SLOT_07_08 (7 << M98925_DAI_IMON_SLOT_SHIFT)
+#define M98925_DAI_IMON_SLOT_08_09 (8 << M98925_DAI_IMON_SLOT_SHIFT)
+#define M98925_DAI_IMON_SLOT_09_0A (9 << M98925_DAI_IMON_SLOT_SHIFT)
+#define M98925_DAI_IMON_SLOT_0A_0B (10 << M98925_DAI_IMON_SLOT_SHIFT)
+#define M98925_DAI_IMON_SLOT_0B_0C (11 << M98925_DAI_IMON_SLOT_SHIFT)
+#define M98925_DAI_IMON_SLOT_0C_0D (12 << M98925_DAI_IMON_SLOT_SHIFT)
+#define M98925_DAI_IMON_SLOT_0D_0E (13 << M98925_DAI_IMON_SLOT_SHIFT)
+#define M98925_DAI_IMON_SLOT_0E_0F (14 << M98925_DAI_IMON_SLOT_SHIFT)
+#define M98925_DAI_IMON_SLOT_0F_10 (15 << M98925_DAI_IMON_SLOT_SHIFT)
+#define M98925_DAI_IMON_SLOT_10_11 (16 << M98925_DAI_IMON_SLOT_SHIFT)
+#define M98925_DAI_IMON_SLOT_11_12 (17 << M98925_DAI_IMON_SLOT_SHIFT)
+#define M98925_DAI_IMON_SLOT_12_13 (18 << M98925_DAI_IMON_SLOT_SHIFT)
+#define M98925_DAI_IMON_SLOT_13_14 (19 << M98925_DAI_IMON_SLOT_SHIFT)
+#define M98925_DAI_IMON_SLOT_14_15 (20 << M98925_DAI_IMON_SLOT_SHIFT)
+#define M98925_DAI_IMON_SLOT_15_16 (21 << M98925_DAI_IMON_SLOT_SHIFT)
+#define M98925_DAI_IMON_SLOT_16_17 (22 << M98925_DAI_IMON_SLOT_SHIFT)
+#define M98925_DAI_IMON_SLOT_17_18 (23 << M98925_DAI_IMON_SLOT_SHIFT)
+#define M98925_DAI_IMON_SLOT_18_19 (24 << M98925_DAI_IMON_SLOT_SHIFT)
+#define M98925_DAI_IMON_SLOT_19_1A (25 << M98925_DAI_IMON_SLOT_SHIFT)
+#define M98925_DAI_IMON_SLOT_1A_1B (26 << M98925_DAI_IMON_SLOT_SHIFT)
+#define M98925_DAI_IMON_SLOT_1B_1C (27 << M98925_DAI_IMON_SLOT_SHIFT)
+#define M98925_DAI_IMON_SLOT_1C_1D (28 << M98925_DAI_IMON_SLOT_SHIFT)
+#define M98925_DAI_IMON_SLOT_1D_1E (29 << M98925_DAI_IMON_SLOT_SHIFT)
+#define M98925_DAI_IMON_SLOT_1E_1F (30 << M98925_DAI_IMON_SLOT_SHIFT)
+/* MAX98925_R024_DOUT_CFG_VBAT */
+#define M98925_DAI_VBAT_EN_MASK                                 (1<<5)
+#define M98925_DAI_VBAT_EN_SHIFT                                5
+#define M98925_DAI_VBAT_EN_WIDTH                                1
+#define M98925_DAI_VBAT_SLOT_MASK                               (0x1F<<0)
+#define M98925_DAI_VBAT_SLOT_SHIFT                              0
+#define M98925_DAI_VBAT_SLOT_WIDTH                              5
+/* MAX98925_R025_DOUT_CFG_VBST */
+#define M98925_DAI_VBST_EN_MASK                                 (1<<5)
+#define M98925_DAI_VBST_EN_SHIFT                                5
+#define M98925_DAI_VBST_EN_WIDTH                                1
+#define M98925_DAI_VBST_SLOT_MASK                               (0x1F<<0)
+#define M98925_DAI_VBST_SLOT_SHIFT                              0
+#define M98925_DAI_VBST_SLOT_WIDTH                              5
+/* MAX98925_R026_DOUT_CFG_FLAG */
+#define M98925_DAI_FLAG_EN_MASK                                 (1<<5)
+#define M98925_DAI_FLAG_EN_SHIFT                                5
+#define M98925_DAI_FLAG_EN_WIDTH                                1
+#define M98925_DAI_FLAG_SLOT_MASK                               (0x1F<<0)
+#define M98925_DAI_FLAG_SLOT_SHIFT                              0
+#define M98925_DAI_FLAG_SLOT_WIDTH                              5
+/* MAX98925_R027_DOUT_HIZ_CFG1 */
+#define M98925_DAI_SLOT_HIZ_CFG1_MASK                   (0xFF<<0)
+#define M98925_DAI_SLOT_HIZ_CFG1_SHIFT                  0
+#define M98925_DAI_SLOT_HIZ_CFG1_WIDTH                  8
+/* MAX98925_R028_DOUT_HIZ_CFG2 */
+#define M98925_DAI_SLOT_HIZ_CFG2_MASK                   (0xFF<<0)
+#define M98925_DAI_SLOT_HIZ_CFG2_SHIFT                  0
+#define M98925_DAI_SLOT_HIZ_CFG2_WIDTH                  8
+/* MAX98925_R029_DOUT_HIZ_CFG3 */
+#define M98925_DAI_SLOT_HIZ_CFG3_MASK                   (0xFF<<0)
+#define M98925_DAI_SLOT_HIZ_CFG3_SHIFT                  0
+#define M98925_DAI_SLOT_HIZ_CFG3_WIDTH                  8
+/* MAX98925_R02A_DOUT_HIZ_CFG4 */
+#define M98925_DAI_SLOT_HIZ_CFG4_MASK                   (0xFF<<0)
+#define M98925_DAI_SLOT_HIZ_CFG4_SHIFT                  0
+#define M98925_DAI_SLOT_HIZ_CFG4_WIDTH                  8
+/* MAX98925_R02B_DOUT_DRV_STRENGTH */
+#define M98925_DAI_OUT_DRIVE_MASK                               (0x03<<0)
+#define M98925_DAI_OUT_DRIVE_SHIFT                              0
+#define M98925_DAI_OUT_DRIVE_WIDTH                              2
+/* MAX98925_R02C_FILTERS */
+#define M98925_ADC_DITHER_EN_MASK                               (1<<7)
+#define M98925_ADC_DITHER_EN_SHIFT                              7
+#define M98925_ADC_DITHER_EN_WIDTH                              1
+#define M98925_IV_DCB_EN_MASK                                   (1<<6)
+#define M98925_IV_DCB_EN_SHIFT                                  6
+#define M98925_IV_DCB_EN_WIDTH                                  1
+#define M98925_DAC_DITHER_EN_MASK                               (1<<4)
+#define M98925_DAC_DITHER_EN_SHIFT                              4
+#define M98925_DAC_DITHER_EN_WIDTH                              1
+#define M98925_DAC_FILTER_MODE_MASK                             (1<<3)
+#define M98925_DAC_FILTER_MODE_SHIFT                    3
+#define M98925_DAC_FILTER_MODE_WIDTH                    1
+#define M98925_DAC_HPF_MASK                             (0x07<<0)
+#define M98925_DAC_HPF_SHIFT                                    0
+#define M98925_DAC_HPF_WIDTH                                    3
+#define M98925_DAC_HPF_DISABLE          (0 << M98925_DAC_HPF_SHIFT)
+#define M98925_DAC_HPF_DC_BLOCK         (1 << M98925_DAC_HPF_SHIFT)
+#define M98925_DAC_HPF_EN_100           (2 << M98925_DAC_HPF_SHIFT)
+#define M98925_DAC_HPF_EN_200           (3 << M98925_DAC_HPF_SHIFT)
+#define M98925_DAC_HPF_EN_400           (4 << M98925_DAC_HPF_SHIFT)
+#define M98925_DAC_HPF_EN_800           (5 << M98925_DAC_HPF_SHIFT)
+/* MAX98925_R02D_GAIN */
+#define M98925_DAC_IN_SEL_MASK                                  (0x03<<5)
+#define M98925_DAC_IN_SEL_SHIFT                                 5
+#define M98925_DAC_IN_SEL_WIDTH                                 2
+#define M98925_SPK_GAIN_MASK                                    (0x1F<<0)
+#define M98925_SPK_GAIN_SHIFT                                   0
+#define M98925_SPK_GAIN_WIDTH                                   5
+#define M98925_DAC_IN_SEL_LEFT_DAI (0 << M98925_DAC_IN_SEL_SHIFT)
+#define M98925_DAC_IN_SEL_RIGHT_DAI (1 << M98925_DAC_IN_SEL_SHIFT)
+#define M98925_DAC_IN_SEL_SUMMED_DAI (2 << M98925_DAC_IN_SEL_SHIFT)
+#define M98925_DAC_IN_SEL_DIV2_SUMMED_DAI (3 << M98925_DAC_IN_SEL_SHIFT)
+/* MAX98925_R02E_GAIN_RAMPING */
+#define M98925_SPK_RMP_EN_MASK          (1<<1)
+#define M98925_SPK_RMP_EN_SHIFT         1
+#define M98925_SPK_RMP_EN_WIDTH         1
+#define M98925_SPK_ZCD_EN_MASK          (1<<0)
+#define M98925_SPK_ZCD_EN_SHIFT         0
+#define M98925_SPK_ZCD_EN_WIDTH         1
+/* MAX98925_R02F_SPK_AMP */
+#define M98925_SPK_MODE_MASK            (1<<0)
+#define M98925_SPK_MODE_SHIFT           0
+#define M98925_SPK_MODE_WIDTH           1
+/* MAX98925_R030_THRESHOLD */
+#define M98925_ALC_EN_MASK                      (1<<5)
+#define M98925_ALC_EN_SHIFT                     5
+#define M98925_ALC_EN_WIDTH                     1
+#define M98925_ALC_TH_MASK                      (0x1F<<0)
+#define M98925_ALC_TH_SHIFT                     0
+#define M98925_ALC_TH_WIDTH                     5
+/* MAX98925_R031_ALC_ATTACK */
+#define M98925_ALC_ATK_STEP_MASK        (0x0F<<4)
+#define M98925_ALC_ATK_STEP_SHIFT       4
+#define M98925_ALC_ATK_STEP_WIDTH       4
+#define M98925_ALC_ATK_RATE_MASK        (0x7<<0)
+#define M98925_ALC_ATK_RATE_SHIFT       0
+#define M98925_ALC_ATK_RATE_WIDTH       3
+/* MAX98925_R032_ALC_ATTEN_RLS */
+#define M98925_ALC_MAX_ATTEN_MASK       (0x0F<<4)
+#define M98925_ALC_MAX_ATTEN_SHIFT      4
+#define M98925_ALC_MAX_ATTEN_WIDTH      4
+#define M98925_ALC_RLS_RATE_MASK        (0x7<<0)
+#define M98925_ALC_RLS_RATE_SHIFT       0
+#define M98925_ALC_RLS_RATE_WIDTH       3
+/* MAX98925_R033_ALC_HOLD_RLS */
+#define M98925_ALC_RLS_TGR_MASK         (1<<0)
+#define M98925_ALC_RLS_TGR_SHIFT        0
+#define M98925_ALC_RLS_TGR_WIDTH        1
+/* MAX98925_R034_ALC_CONFIGURATION */
+#define M98925_ALC_MUTE_EN_MASK         (1<<7)
+#define M98925_ALC_MUTE_EN_SHIFT        7
+#define M98925_ALC_MUTE_EN_WIDTH        1
+#define M98925_ALC_MUTE_DLY_MASK        (0x07<<4)
+#define M98925_ALC_MUTE_DLY_SHIFT       4
+#define M98925_ALC_MUTE_DLY_WIDTH       3
+#define M98925_ALC_RLS_DBT_MASK         (0x07<<0)
+#define M98925_ALC_RLS_DBT_SHIFT        0
+#define M98925_ALC_RLS_DBT_WIDTH        3
+/* MAX98925_R035_BOOST_CONVERTER */
+#define M98925_BST_SYNC_MASK            (1<<7)
+#define M98925_BST_SYNC_SHIFT           7
+#define M98925_BST_SYNC_WIDTH           1
+#define M98925_BST_PHASE_MASK           (0x03<<4)
+#define M98925_BST_PHASE_SHIFT          4
+#define M98925_BST_PHASE_WIDTH          2
+#define M98925_BST_SKIP_MODE_MASK       (0x03<<0)
+#define M98925_BST_SKIP_MODE_SHIFT      0
+#define M98925_BST_SKIP_MODE_WIDTH      2
+/* MAX98925_R036_BLOCK_ENABLE */
+#define M98925_BST_EN_MASK                      (1<<7)
+#define M98925_BST_EN_SHIFT                     7
+#define M98925_BST_EN_WIDTH                     1
+#define M98925_WATCH_EN_MASK            (1<<6)
+#define M98925_WATCH_EN_SHIFT           6
+#define M98925_WATCH_EN_WIDTH           1
+#define M98925_CLKMON_EN_MASK           (1<<5)
+#define M98925_CLKMON_EN_SHIFT          5
+#define M98925_CLKMON_EN_WIDTH          1
+#define M98925_SPK_EN_MASK                      (1<<4)
+#define M98925_SPK_EN_SHIFT                     4
+#define M98925_SPK_EN_WIDTH                     1
+#define M98925_ADC_VBST_EN_MASK         (1<<3)
+#define M98925_ADC_VBST_EN_SHIFT        3
+#define M98925_ADC_VBST_EN_WIDTH        1
+#define M98925_ADC_VBAT_EN_MASK         (1<<2)
+#define M98925_ADC_VBAT_EN_SHIFT        2
+#define M98925_ADC_VBAT_EN_WIDTH        1
+#define M98925_ADC_IMON_EN_MASK         (1<<1)
+#define M98925_ADC_IMON_EN_SHIFT        1
+#define M98925_ADC_IMON_EN_WIDTH        1
+#define M98925_ADC_VMON_EN_MASK         (1<<0)
+#define M98925_ADC_VMON_EN_SHIFT        0
+#define M98925_ADC_VMON_EN_WIDTH        1
+/* MAX98925_R037_CONFIGURATION */
+#define M98925_BST_VOUT_MASK            (0x0F<<4)
+#define M98925_BST_VOUT_SHIFT           4
+#define M98925_BST_VOUT_WIDTH           4
+#define M98925_THERMWARN_LEVEL_MASK     (0x03<<2)
+#define M98925_THERMWARN_LEVEL_SHIFT                    2
+#define M98925_THERMWARN_LEVEL_WIDTH                    2
+#define M98925_WATCH_TIME_MASK                  (0x03<<0)
+#define M98925_WATCH_TIME_SHIFT                 0
+#define M98925_WATCH_TIME_WIDTH                 2
+/* MAX98925_R038_GLOBAL_ENABLE */
+#define M98925_EN_MASK                  (1<<7)
+#define M98925_EN_SHIFT                 7
+#define M98925_EN_WIDTH                 1
+/* MAX98925_R03A_BOOST_LIMITER */
+#define M98925_BST_ILIM_MASK    (0x1F<<3)
+#define M98925_BST_ILIM_SHIFT   3
+#define M98925_BST_ILIM_WIDTH   5
+/* MAX98925_R0FF_VERSION */
+#define M98925_REV_ID_MASK      (0xFF<<0)
+#define M98925_REV_ID_SHIFT     0
+#define M98925_REV_ID_WIDTH     8
+struct max98925_priv {
+        struct regmap *regmap;
+        struct snd_soc_codec *codec;
+        struct max98925_pdata *pdata;
+        unsigned int sysclk;
+        unsigned int v_slot;
+        unsigned int i_slot;
+        unsigned int spk_gain;
+        unsigned int ch_size;
+};
+#endif
diff --git a/sound/soc/codecs/pcm512x.c b/sound/soc/codecs/pcm512x.c
index 4b5f1fe9be97..5a30fdd0da00 100644
--- a/sound/soc/codecs/pcm512x.c
+++ b/sound/soc/codecs/pcm512x.c
@@ -391,9 +391,9 @@ static const struct soc_enum pcm512x_veds =
 static const struct snd_kcontrol_new pcm512x_controls[] = {
 SOC_DOUBLE_R_TLV("Digital Playback Volume", PCM512x_DIGITAL_VOLUME_2,
                 PCM512x_DIGITAL_VOLUME_3, 0, 255, 1, digital_tlv),
-SOC_DOUBLE_TLV("Playback Volume", PCM512x_ANALOG_GAIN_CTRL,
+SOC_DOUBLE_TLV("Analogue Playback Volume", PCM512x_ANALOG_GAIN_CTRL,
               PCM512x_LAGN_SHIFT, PCM512x_RAGN_SHIFT, 1, 1, analog_tlv),
-SOC_DOUBLE_TLV("Playback Boost Volume", PCM512x_ANALOG_GAIN_BOOST,
+SOC_DOUBLE_TLV("Analogue Playback Boost Volume", PCM512x_ANALOG_GAIN_BOOST,
               PCM512x_AGBL_SHIFT, PCM512x_AGBR_SHIFT, 1, 0, boost_tlv),
 SOC_DOUBLE("Digital Playback Switch", PCM512x_MUTE, PCM512x_RQML_SHIFT,
           PCM512x_RQMR_SHIFT, 1, 1),
@@ -713,8 +713,8 @@ static int pcm512x_find_pll_coeff(struct snd_soc_dai *dai,
        /* pllin_rate / P (or here, den) cannot be greater than 20 MHz */
        if (pllin_rate / den > 20000000 && num < 8) {
-                num *= 20000000 / (pllin_rate / den);
+                num *= DIV_ROUND_UP(pllin_rate / den, 20000000);
-                den *= 20000000 / (pllin_rate / den);
+                den *= DIV_ROUND_UP(pllin_rate / den, 20000000);
        }
        dev_dbg(dev, "num / den = %lu / %lu\n", num, den);
@@ -1296,25 +1296,6 @@ static int pcm512x_hw_params(struct snd_pcm_substream *substream,
                                ret, pcm512x->pll_out);
                        return ret;
                }
-                gpio = PCM512x_G1OE << (4 - 1);
-                ret = regmap_update_bits(pcm512x->regmap, PCM512x_GPIO_EN,
-                                         gpio, gpio);
-                if (ret != 0) {
-                        dev_err(codec->dev, "Failed to enable gpio %d: %d\n",
-                                4, ret);
-                        return ret;
-                }
-                gpio = PCM512x_GPIO_OUTPUT_1 + 4 - 1;
-                ret = regmap_update_bits(pcm512x->regmap, gpio,
-                                         PCM512x_GxSL, PCM512x_GxSL_PLLLK);
-                if (ret != 0) {
-                        dev_err(codec->dev,
-                                "Failed to output pll lock on %d: %d\n",
-                                ret, 4);
-                        return ret;
-                }
        }
        ret = regmap_update_bits(pcm512x->regmap, PCM512x_SYNCHRONIZE,
diff --git a/sound/soc/codecs/rt286.c b/sound/soc/codecs/rt286.c
index 826037090c83..0fcda35a3a93 100644
--- a/sound/soc/codecs/rt286.c
+++ b/sound/soc/codecs/rt286.c
@@ -397,7 +397,7 @@ int rt286_mic_detect(struct snd_soc_codec *codec, struct snd_soc_jack *jack)
        if (jack) {
                /* enable IRQ */
-                if (rt286->jack->status | SND_JACK_HEADPHONE)
+                if (rt286->jack->status & SND_JACK_HEADPHONE)
                        snd_soc_dapm_force_enable_pin(&codec->dapm, "LDO1");
                regmap_update_bits(rt286->regmap, RT286_IRQ_CTRL, 0x2, 0x2);
                /* Send an initial empty report */
@@ -1048,7 +1048,6 @@ static int rt286_probe(struct snd_soc_codec *codec)
        struct rt286_priv *rt286 = snd_soc_codec_get_drvdata(codec);
        rt286->codec = codec;
-        codec->dapm.bias_level = SND_SOC_BIAS_OFF;
        if (rt286->i2c->irq) {
                regmap_update_bits(rt286->regmap,
@@ -1220,7 +1219,7 @@ static int rt286_i2c_probe(struct i2c_client *i2c,
 {
        struct rt286_platform_data *pdata = dev_get_platdata(&i2c->dev);
        struct rt286_priv *rt286;
-        int i, ret;
+        int i, ret, val;
        rt286 = devm_kzalloc(&i2c->dev, sizeof(*rt286),
                                GFP_KERNEL);
@@ -1235,11 +1234,15 @@ static int rt286_i2c_probe(struct i2c_client *i2c,
                return ret;
        }
-        regmap_read(rt286->regmap,
+        ret = regmap_read(rt286->regmap,
-                RT286_GET_PARAM(AC_NODE_ROOT, AC_PAR_VENDOR_ID), &ret);
+                RT286_GET_PARAM(AC_NODE_ROOT, AC_PAR_VENDOR_ID), &val);
-        if (ret != RT286_VENDOR_ID && ret != RT288_VENDOR_ID) {
+        if (ret != 0) {
+                dev_err(&i2c->dev, "I2C error %d\n", ret);
+                return ret;
+        }
+        if (val != RT286_VENDOR_ID && val != RT288_VENDOR_ID) {
                dev_err(&i2c->dev,
-                        "Device with ID register %x is not rt286\n", ret);
+                        "Device with ID register %x is not rt286\n", val);
                return -ENODEV;
        }
@@ -1247,6 +1250,14 @@ static int rt286_i2c_probe(struct i2c_client *i2c,
        rt286->i2c = i2c;
        i2c_set_clientdata(i2c, rt286);
+        /* restore codec default */
+        for (i = 0; i < INDEX_CACHE_SIZE; i++)
+                regmap_write(rt286->regmap, rt286->index_cache[i].reg,
+                                rt286->index_cache[i].def);
+        for (i = 0; i < ARRAY_SIZE(rt286_reg); i++)
+                regmap_write(rt286->regmap, rt286_reg[i].reg,
+                                rt286_reg[i].def);
        if (pdata)
                rt286->pdata = *pdata;
diff --git a/sound/soc/codecs/rt5631.c b/sound/soc/codecs/rt5631.c
index c61852742ee3..2c10d77727af 100644
--- a/sound/soc/codecs/rt5631.c
+++ b/sound/soc/codecs/rt5631.c
@@ -1675,7 +1675,7 @@ static const struct i2c_device_id rt5631_i2c_id[] = {
 MODULE_DEVICE_TABLE(i2c, rt5631_i2c_id);
 #ifdef CONFIG_OF
-static struct of_device_id rt5631_i2c_dt_ids[] = {
+static const struct of_device_id rt5631_i2c_dt_ids[] = {
        { .compatible = "realtek,rt5631"},
        { .compatible = "realtek,alc5631"},
        { }
diff --git a/sound/soc/codecs/rt5645.c b/sound/soc/codecs/rt5645.c
index c9a4c5be083b..69528ae5410c 100644
--- a/sound/soc/codecs/rt5645.c
+++ b/sound/soc/codecs/rt5645.c
@@ -1270,6 +1270,8 @@ static void hp_amp_power(struct snd_soc_codec *codec, int on)
                        snd_soc_update_bits(codec, RT5645_PWR_ANLG1,
                                RT5645_PWR_HP_L | RT5645_PWR_HP_R |
                                RT5645_PWR_HA, 0);
+                        snd_soc_update_bits(codec, RT5645_DEPOP_M2,
+                                RT5645_DEPOP_MASK, 0);
                }
        }
 }
@@ -1538,8 +1540,6 @@ static const struct snd_soc_dapm_widget rt5645_dapm_widgets[] = {
        SND_SOC_DAPM_SUPPLY_S("adc stereo1 filter", 1, RT5645_PWR_DIG2,
                RT5645_PWR_ADC_S1F_BIT, 0, NULL, 0),
-        SND_SOC_DAPM_SUPPLY_S("adc stereo2 filter", 1, RT5645_PWR_DIG2,
-                RT5645_PWR_ADC_S2F_BIT, 0, NULL, 0),
        SND_SOC_DAPM_MIXER_E("Sto1 ADC MIXL", SND_SOC_NOPM, 0, 0,
                rt5645_sto1_adc_l_mix, ARRAY_SIZE(rt5645_sto1_adc_l_mix),
                NULL, 0),
@@ -1729,7 +1729,6 @@ static const struct snd_soc_dapm_widget rt5650_specific_dapm_widgets[] = {
 static const struct snd_soc_dapm_route rt5645_dapm_routes[] = {
        { "adc stereo1 filter", NULL, "ADC STO1 ASRC", is_using_asrc },
-        { "adc stereo2 filter", NULL, "ADC STO2 ASRC", is_using_asrc },
        { "adc mono left filter", NULL, "ADC MONO L ASRC", is_using_asrc },
        { "adc mono right filter", NULL, "ADC MONO R ASRC", is_using_asrc },
        { "dac mono left filter", NULL, "DAC MONO L ASRC", is_using_asrc },
@@ -2052,7 +2051,7 @@ static int rt5645_hw_params(struct snd_pcm_substream *substream,
 {
        struct snd_soc_codec *codec = dai->codec;
        struct rt5645_priv *rt5645 = snd_soc_codec_get_drvdata(codec);
-        unsigned int val_len = 0, val_clk, mask_clk;
+        unsigned int val_len = 0, val_clk, mask_clk, dl_sft;
        int pre_div, bclk_ms, frame_size;
        rt5645->lrck[dai->id] = params_rate(params);
@@ -2066,6 +2065,16 @@ static int rt5645_hw_params(struct snd_pcm_substream *substream,
                dev_err(codec->dev, "Unsupported frame size: %d\n", frame_size);
                return -EINVAL;
        }
+        switch (rt5645->codec_type) {
+        case CODEC_TYPE_RT5650:
+                dl_sft = 4;
+                break;
+        default:
+                dl_sft = 2;
+                break;
+        }
        bclk_ms = frame_size > 32;
        rt5645->bclk[dai->id] = rt5645->lrck[dai->id] * (32 << bclk_ms);
@@ -2078,13 +2087,13 @@ static int rt5645_hw_params(struct snd_pcm_substream *substream,
        case 16:
                break;
        case 20:
-                val_len |= RT5645_I2S_DL_20;
+                val_len = 0x1;
                break;
        case 24:
-                val_len |= RT5645_I2S_DL_24;
+                val_len = 0x2;
                break;
        case 8:
-                val_len |= RT5645_I2S_DL_8;
+                val_len = 0x3;
                break;
        default:
                return -EINVAL;
@@ -2096,7 +2105,7 @@ static int rt5645_hw_params(struct snd_pcm_substream *substream,
                val_clk = bclk_ms << RT5645_I2S_BCLK_MS1_SFT |
                        pre_div << RT5645_I2S_PD1_SFT;
                snd_soc_update_bits(codec, RT5645_I2S1_SDP,
-                        RT5645_I2S_DL_MASK, val_len);
+                        (0x3 << dl_sft), (val_len << dl_sft));
                snd_soc_update_bits(codec, RT5645_ADDA_CLK1, mask_clk, val_clk);
                break;
        case  RT5645_AIF2:
@@ -2104,7 +2113,7 @@ static int rt5645_hw_params(struct snd_pcm_substream *substream,
                val_clk = bclk_ms << RT5645_I2S_BCLK_MS2_SFT |
                        pre_div << RT5645_I2S_PD2_SFT;
                snd_soc_update_bits(codec, RT5645_I2S2_SDP,
-                        RT5645_I2S_DL_MASK, val_len);
+                        (0x3 << dl_sft), (val_len << dl_sft));
                snd_soc_update_bits(codec, RT5645_ADDA_CLK1, mask_clk, val_clk);
                break;
        default:
@@ -2119,7 +2128,16 @@ static int rt5645_set_dai_fmt(struct snd_soc_dai *dai, unsigned int fmt)
 {
        struct snd_soc_codec *codec = dai->codec;
        struct rt5645_priv *rt5645 = snd_soc_codec_get_drvdata(codec);
-        unsigned int reg_val = 0;
+        unsigned int reg_val = 0, pol_sft;
+        switch (rt5645->codec_type) {
+        case CODEC_TYPE_RT5650:
+                pol_sft = 8;
+                break;
+        default:
+                pol_sft = 7;
+                break;
+        }
        switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
        case SND_SOC_DAIFMT_CBM_CFM:
@@ -2137,7 +2155,7 @@ static int rt5645_set_dai_fmt(struct snd_soc_dai *dai, unsigned int fmt)
        case SND_SOC_DAIFMT_NB_NF:
                break;
        case SND_SOC_DAIFMT_IB_NF:
-                reg_val |= RT5645_I2S_BP_INV;
+                reg_val |= (1 << pol_sft);
                break;
        default:
                return -EINVAL;
@@ -2161,12 +2179,12 @@ static int rt5645_set_dai_fmt(struct snd_soc_dai *dai, unsigned int fmt)
        switch (dai->id) {
        case RT5645_AIF1:
                snd_soc_update_bits(codec, RT5645_I2S1_SDP,
-                        RT5645_I2S_MS_MASK | RT5645_I2S_BP_MASK |
+                        RT5645_I2S_MS_MASK | (1 << pol_sft) |
                        RT5645_I2S_DF_MASK, reg_val);
                break;
        case RT5645_AIF2:
                snd_soc_update_bits(codec, RT5645_I2S2_SDP,
-                        RT5645_I2S_MS_MASK | RT5645_I2S_BP_MASK |
+                        RT5645_I2S_MS_MASK | (1 << pol_sft) |
                        RT5645_I2S_DF_MASK, reg_val);
                break;
        default:
@@ -2285,23 +2303,42 @@ static int rt5645_set_tdm_slot(struct snd_soc_dai *dai, unsigned int tx_mask,
                        unsigned int rx_mask, int slots, int slot_width)
 {
        struct snd_soc_codec *codec = dai->codec;
-        unsigned int val = 0;
+        struct rt5645_priv *rt5645 = snd_soc_codec_get_drvdata(codec);
+        unsigned int i_slot_sft, o_slot_sft, i_width_sht, o_width_sht, en_sft;
+        unsigned int mask, val = 0;
+        switch (rt5645->codec_type) {
+        case CODEC_TYPE_RT5650:
+                en_sft = 15;
+                i_slot_sft = 10;
+                o_slot_sft = 8;
+                i_width_sht = 6;
+                o_width_sht = 4;
+                mask = 0x8ff0;
+                break;
+        default:
+                en_sft = 14;
+                i_slot_sft = o_slot_sft = 12;
+                i_width_sht = o_width_sht = 10;
+                mask = 0x7c00;
+                break;
+        }
        if (rx_mask || tx_mask) {
-                val |= (1 << 14);
+                val |= (1 << en_sft);
-                snd_soc_update_bits(codec, RT5645_BASS_BACK,
+                if (rt5645->codec_type == CODEC_TYPE_RT5645)
-                        RT5645_G_BB_BST_MASK, RT5645_G_BB_BST_25DB);
+                        snd_soc_update_bits(codec, RT5645_BASS_BACK,
+                                RT5645_G_BB_BST_MASK, RT5645_G_BB_BST_25DB);
        }
        switch (slots) {
        case 4:
-                val |= (1 << 12);
+                val |= (1 << i_slot_sft) | (1 << o_slot_sft);
                break;
        case 6:
-                val |= (2 << 12);
+                val |= (2 << i_slot_sft) | (2 << o_slot_sft);
                break;
        case 8:
-                val |= (3 << 12);
+                val |= (3 << i_slot_sft) | (3 << o_slot_sft);
                break;
        case 2:
        default:
@@ -2310,20 +2347,20 @@ static int rt5645_set_tdm_slot(struct snd_soc_dai *dai, unsigned int tx_mask,
        switch (slot_width) {
        case 20:
-                val |= (1 << 10);
+                val |= (1 << i_width_sht) | (1 << o_width_sht);
                break;
        case 24:
-                val |= (2 << 10);
+                val |= (2 << i_width_sht) | (2 << o_width_sht);
                break;
        case 32:
-                val |= (3 << 10);
+                val |= (3 << i_width_sht) | (3 << o_width_sht);
                break;
        case 16:
        default:
                break;
        }
-        snd_soc_update_bits(codec, RT5645_TDM_CTRL_1, 0x7c00, val);
+        snd_soc_update_bits(codec, RT5645_TDM_CTRL_1, mask, val);
        return 0;
 }
@@ -2361,7 +2398,8 @@ static int rt5645_set_bias_level(struct snd_soc_codec *codec,
        case SND_SOC_BIAS_OFF:
                snd_soc_write(codec, RT5645_DEPOP_M2, 0x1100);
-                snd_soc_write(codec, RT5645_GEN_CTRL1, 0x0128);
+                snd_soc_update_bits(codec, RT5645_GEN_CTRL1,
+                                RT5645_DIG_GATE_CTRL, 0);
                snd_soc_update_bits(codec, RT5645_PWR_ANLG1,
                                RT5645_PWR_VREF1 | RT5645_PWR_MB |
                                RT5645_PWR_BG | RT5645_PWR_VREF2 |
@@ -2598,7 +2636,7 @@ static struct snd_soc_codec_driver soc_codec_dev_rt5645 = {
 static const struct regmap_config rt5645_regmap = {
        .reg_bits = 8,
        .val_bits = 16,
+        .use_single_rw = true,
        .max_register = RT5645_VENDOR_ID2 + 1 + (ARRAY_SIZE(rt5645_ranges) *
                                               RT5645_PR_SPACING),
        .volatile_reg = rt5645_volatile_register,
diff --git a/sound/soc/codecs/rt5645.h b/sound/soc/codecs/rt5645.h
index dbfd98c22f4d..db78e9462876 100644
--- a/sound/soc/codecs/rt5645.h
+++ b/sound/soc/codecs/rt5645.h
@@ -804,8 +804,6 @@
 #define RT5645_PWR_DAC_MF_L_BIT                 10
 #define RT5645_PWR_DAC_MF_R                     (0x1 << 9)
 #define RT5645_PWR_DAC_MF_R_BIT                 9
-#define RT5645_PWR_ADC_S2F                      (0x1 << 8)
-#define RT5645_PWR_ADC_S2F_BIT                  8
 #define RT5645_PWR_PDM1                         (0x1 << 7)
 #define RT5645_PWR_PDM1_BIT                     7
 #define RT5645_PWR_PDM2                         (0x1 << 6)
diff --git a/sound/soc/codecs/rt5670.c b/sound/soc/codecs/rt5670.c
index fd102613d20d..cc7f84a150a7 100644
--- a/sound/soc/codecs/rt5670.c
+++ b/sound/soc/codecs/rt5670.c
@@ -403,6 +403,189 @@ static bool rt5670_readable_register(struct device *dev, unsigned int reg)
        }
 }
+/**
+ * rt5670_headset_detect - Detect headset.
+ * @codec: SoC audio codec device.
+ * @jack_insert: Jack insert or not.
+ *
+ * Detect whether is headset or not when jack inserted.
+ *
+ * Returns detect status.
+ */
+static int rt5670_headset_detect(struct snd_soc_codec *codec, int jack_insert)
+{
+        int val;
+        struct rt5670_priv *rt5670 = snd_soc_codec_get_drvdata(codec);
+        if (jack_insert) {
+                snd_soc_dapm_force_enable_pin(&codec->dapm,
+                                                       "Mic Det Power");
+                snd_soc_dapm_sync(&codec->dapm);
+                snd_soc_update_bits(codec, RT5670_GEN_CTRL3, 0x4, 0x0);
+                snd_soc_update_bits(codec, RT5670_CJ_CTRL2,
+                        RT5670_CBJ_DET_MODE | RT5670_CBJ_MN_JD,
+                        RT5670_CBJ_MN_JD);
+                snd_soc_write(codec, RT5670_GPIO_CTRL2, 0x0004);
+                snd_soc_update_bits(codec, RT5670_GPIO_CTRL1,
+                        RT5670_GP1_PIN_MASK, RT5670_GP1_PIN_IRQ);
+                snd_soc_update_bits(codec, RT5670_CJ_CTRL1,
+                        RT5670_CBJ_BST1_EN, RT5670_CBJ_BST1_EN);
+                snd_soc_write(codec, RT5670_JD_CTRL3, 0x00f0);
+                snd_soc_update_bits(codec, RT5670_CJ_CTRL2,
+                        RT5670_CBJ_MN_JD, RT5670_CBJ_MN_JD);
+                snd_soc_update_bits(codec, RT5670_CJ_CTRL2,
+                        RT5670_CBJ_MN_JD, 0);
+                msleep(300);
+                val = snd_soc_read(codec, RT5670_CJ_CTRL3) & 0x7;
+                if (val == 0x1 || val == 0x2) {
+                        rt5670->jack_type = SND_JACK_HEADSET;
+                        /* for push button */
+                        snd_soc_update_bits(codec, RT5670_INT_IRQ_ST, 0x8, 0x8);
+                        snd_soc_update_bits(codec, RT5670_IL_CMD, 0x40, 0x40);
+                        snd_soc_read(codec, RT5670_IL_CMD);
+                } else {
+                        snd_soc_update_bits(codec, RT5670_GEN_CTRL3, 0x4, 0x4);
+                        rt5670->jack_type = SND_JACK_HEADPHONE;
+                        snd_soc_dapm_disable_pin(&codec->dapm, "Mic Det Power");
+                        snd_soc_dapm_sync(&codec->dapm);
+                }
+        } else {
+                snd_soc_update_bits(codec, RT5670_INT_IRQ_ST, 0x8, 0x0);
+                snd_soc_update_bits(codec, RT5670_GEN_CTRL3, 0x4, 0x4);
+                rt5670->jack_type = 0;
+                snd_soc_dapm_disable_pin(&codec->dapm, "Mic Det Power");
+                snd_soc_dapm_sync(&codec->dapm);
+        }
+        return rt5670->jack_type;
+}
+void rt5670_jack_suspend(struct snd_soc_codec *codec)
+{
+        struct rt5670_priv *rt5670 = snd_soc_codec_get_drvdata(codec);
+        rt5670->jack_type_saved = rt5670->jack_type;
+        rt5670_headset_detect(codec, 0);
+}
+EXPORT_SYMBOL_GPL(rt5670_jack_suspend);
+void rt5670_jack_resume(struct snd_soc_codec *codec)
+{
+        struct rt5670_priv *rt5670 = snd_soc_codec_get_drvdata(codec);
+        if (rt5670->jack_type_saved)
+                rt5670_headset_detect(codec, 1);
+}
+EXPORT_SYMBOL_GPL(rt5670_jack_resume);
+static int rt5670_button_detect(struct snd_soc_codec *codec)
+{
+        int btn_type, val;
+        val = snd_soc_read(codec, RT5670_IL_CMD);
+        btn_type = val & 0xff80;
+        snd_soc_write(codec, RT5670_IL_CMD, val);
+        if (btn_type != 0) {
+                msleep(20);
+                val = snd_soc_read(codec, RT5670_IL_CMD);
+                snd_soc_write(codec, RT5670_IL_CMD, val);
+        }
+        return btn_type;
+}
+static int rt5670_irq_detection(void *data)
+{
+        struct rt5670_priv *rt5670 = (struct rt5670_priv *)data;
+        struct snd_soc_jack_gpio *gpio = &rt5670->hp_gpio;
+        struct snd_soc_jack *jack = rt5670->jack;
+        int val, btn_type, report = jack->status;
+        if (rt5670->pdata.jd_mode == 1) /* 2 port */
+                val = snd_soc_read(rt5670->codec, RT5670_A_JD_CTRL1) & 0x0070;
+        else
+                val = snd_soc_read(rt5670->codec, RT5670_A_JD_CTRL1) & 0x0020;
+        switch (val) {
+        /* jack in */
+        case 0x30: /* 2 port */
+        case 0x0: /* 1 port or 2 port */
+                if (rt5670->jack_type == 0) {
+                        report = rt5670_headset_detect(rt5670->codec, 1);
+                        /* for push button and jack out */
+                        gpio->debounce_time = 25;
+                        break;
+                }
+                btn_type = 0;
+                if (snd_soc_read(rt5670->codec, RT5670_INT_IRQ_ST) & 0x4) {
+                        /* button pressed */
+                        report = SND_JACK_HEADSET;
+                        btn_type = rt5670_button_detect(rt5670->codec);
+                        switch (btn_type) {
+                        case 0x2000: /* up */
+                                report |= SND_JACK_BTN_1;
+                                break;
+                        case 0x0400: /* center */
+                                report |= SND_JACK_BTN_0;
+                                break;
+                        case 0x0080: /* down */
+                                report |= SND_JACK_BTN_2;
+                                break;
+                        default:
+                                dev_err(rt5670->codec->dev,
+                                        "Unexpected button code 0x%04x\n",
+                                        btn_type);
+                                break;
+                        }
+                }
+                if (btn_type == 0)/* button release */
+                        report =  rt5670->jack_type;
+                break;
+        /* jack out */
+        case 0x70: /* 2 port */
+        case 0x10: /* 2 port */
+        case 0x20: /* 1 port */
+                report = 0;
+                snd_soc_update_bits(rt5670->codec, RT5670_INT_IRQ_ST, 0x1, 0x0);
+                rt5670_headset_detect(rt5670->codec, 0);
+                gpio->debounce_time = 150; /* for jack in */
+                break;
+        default:
+                break;
+        }
+        return report;
+}
+int rt5670_set_jack_detect(struct snd_soc_codec *codec,
+        struct snd_soc_jack *jack)
+{
+        struct rt5670_priv *rt5670 = snd_soc_codec_get_drvdata(codec);
+        int ret;
+        rt5670->jack = jack;
+        rt5670->hp_gpio.gpiod_dev = codec->dev;
+        rt5670->hp_gpio.name = "headphone detect";
+        rt5670->hp_gpio.report = SND_JACK_HEADSET |
+                SND_JACK_BTN_0 | SND_JACK_BTN_1 | SND_JACK_BTN_2;
+        rt5670->hp_gpio.debounce_time = 150;
+        rt5670->hp_gpio.wake = true;
+        rt5670->hp_gpio.data = (struct rt5670_priv *)rt5670;
+        rt5670->hp_gpio.jack_status_check = rt5670_irq_detection;
+        ret = snd_soc_jack_add_gpios(rt5670->jack, 1,
+                        &rt5670->hp_gpio);
+        if (ret) {
+                dev_err(codec->dev, "Adding jack GPIO failed\n");
+                return ret;
+        }
+        return 0;
+}
+EXPORT_SYMBOL_GPL(rt5670_set_jack_detect);
 static const DECLARE_TLV_DB_SCALE(out_vol_tlv, -4650, 150, 0);
 static const DECLARE_TLV_DB_SCALE(dac_vol_tlv, -65625, 375, 0);
 static const DECLARE_TLV_DB_SCALE(in_vol_tlv, -3450, 150, 0);
@@ -517,11 +700,9 @@ static int is_sys_clk_from_pll(struct snd_soc_dapm_widget *source,
                         struct snd_soc_dapm_widget *sink)
 {
        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(source->dapm);
-        unsigned int val;
+        struct rt5670_priv *rt5670 = snd_soc_codec_get_drvdata(codec);
-        val = snd_soc_read(codec, RT5670_GLB_CLK);
+        if (rt5670->sysclk_src == RT5670_SCLK_S_PLL1)
-        val &= RT5670_SCLK_SRC_MASK;
-        if (val == RT5670_SCLK_SRC_PLL1)
                return 1;
        else
                return 0;
@@ -2271,16 +2452,6 @@ static int rt5670_set_dai_sysclk(struct snd_soc_dai *dai,
        struct rt5670_priv *rt5670 = snd_soc_codec_get_drvdata(codec);
        unsigned int reg_val = 0;
-        if (freq == rt5670->sysclk && clk_id == rt5670->sysclk_src)
-                return 0;
-        if (rt5670->pdata.jd_mode) {
-                if (clk_id == RT5670_SCLK_S_PLL1)
-                        snd_soc_dapm_force_enable_pin(&codec->dapm, "PLL1");
-                else
-                        snd_soc_dapm_disable_pin(&codec->dapm, "PLL1");
-                snd_soc_dapm_sync(&codec->dapm);
-        }
        switch (clk_id) {
        case RT5670_SCLK_S_MCLK:
                reg_val |= RT5670_SCLK_SRC_MCLK;
@@ -2298,7 +2469,8 @@ static int rt5670_set_dai_sysclk(struct snd_soc_dai *dai,
        snd_soc_update_bits(codec, RT5670_GLB_CLK,
                RT5670_SCLK_SRC_MASK, reg_val);
        rt5670->sysclk = freq;
-        rt5670->sysclk_src = clk_id;
+        if (clk_id != RT5670_SCLK_S_RCCLK)
+                rt5670->sysclk_src = clk_id;
        dev_dbg(dai->dev, "Sysclk is %dHz and clock id is %d\n", freq, clk_id);
@@ -2517,6 +2689,7 @@ static int rt5670_remove(struct snd_soc_codec *codec)
        struct rt5670_priv *rt5670 = snd_soc_codec_get_drvdata(codec);
        regmap_write(rt5670->regmap, RT5670_RESET, 0);
+        snd_soc_jack_free_gpios(rt5670->jack, 1, &rt5670->hp_gpio);
        return 0;
 }
@@ -2676,6 +2849,7 @@ static int rt5670_i2c_probe(struct i2c_client *i2c,
        if (dmi_check_system(dmi_platform_intel_braswell)) {
                rt5670->pdata.dmic_en = true;
                rt5670->pdata.dmic1_data_pin = RT5670_DMIC_DATA_IN2P;
+                rt5670->pdata.dev_gpio = true;
                rt5670->pdata.jd_mode = 1;
        }
@@ -2717,12 +2891,17 @@ static int rt5670_i2c_probe(struct i2c_client *i2c,
                regmap_update_bits(rt5670->regmap, RT5670_IN2,
                                        RT5670_IN_DF2, RT5670_IN_DF2);
-        if (i2c->irq) {
+        if (rt5670->pdata.dev_gpio) {
+                /* for push button */
+                regmap_write(rt5670->regmap, RT5670_IL_CMD, 0x0000);
+                regmap_write(rt5670->regmap, RT5670_IL_CMD2, 0x0010);
+                regmap_write(rt5670->regmap, RT5670_IL_CMD3, 0x0014);
+                /* for irq */
                regmap_update_bits(rt5670->regmap, RT5670_GPIO_CTRL1,
                                   RT5670_GP1_PIN_MASK, RT5670_GP1_PIN_IRQ);
                regmap_update_bits(rt5670->regmap, RT5670_GPIO_CTRL2,
                                   RT5670_GP1_PF_MASK, RT5670_GP1_PF_OUT);
+                regmap_update_bits(rt5670->regmap, RT5670_DIG_MISC, 0x8, 0x8);
        }
        if (rt5670->pdata.jd_mode) {
diff --git a/sound/soc/codecs/rt5670.h b/sound/soc/codecs/rt5670.h
index 0a67adbcfbc3..dc2b46236c5c 100644
--- a/sound/soc/codecs/rt5670.h
+++ b/sound/soc/codecs/rt5670.h
@@ -1988,6 +1988,8 @@ struct rt5670_priv {
        struct snd_soc_codec *codec;
        struct rt5670_platform_data pdata;
        struct regmap *regmap;
+        struct snd_soc_jack *jack;
+        struct snd_soc_jack_gpio hp_gpio;
        int sysclk;
        int sysclk_src;
@@ -2002,6 +2004,11 @@ struct rt5670_priv {
        int dsp_sw; /* expected parameter setting */
        int dsp_rate;
        int jack_type;
+        int jack_type_saved;
 };
+void rt5670_jack_suspend(struct snd_soc_codec *codec);
+void rt5670_jack_resume(struct snd_soc_codec *codec);
+int rt5670_set_jack_detect(struct snd_soc_codec *codec,
+        struct snd_soc_jack *jack);
 #endif /* __RT5670_H__ */
diff --git a/sound/soc/codecs/rt5677.c b/sound/soc/codecs/rt5677.c
index c2a6e4091357..af182586712d 100644
--- a/sound/soc/codecs/rt5677.c
+++ b/sound/soc/codecs/rt5677.c
@@ -1034,6 +1034,169 @@ static int can_use_asrc(struct snd_soc_dapm_widget *source,
        return 0;
 }
+/**
+ * rt5677_sel_asrc_clk_src - select ASRC clock source for a set of filters
+ * @codec: SoC audio codec device.
+ * @filter_mask: mask of filters.
+ * @clk_src: clock source
+ *
+ * The ASRC function is for asynchronous MCLK and LRCK. Also, since RT5677 can
+ * only support standard 32fs or 64fs i2s format, ASRC should be enabled to
+ * support special i2s clock format such as Intel's 100fs(100 * sampling rate).
+ * ASRC function will track i2s clock and generate a corresponding system clock
+ * for codec. This function provides an API to select the clock source for a
+ * set of filters specified by the mask. And the codec driver will turn on ASRC
+ * for these filters if ASRC is selected as their clock source.
+ */
+int rt5677_sel_asrc_clk_src(struct snd_soc_codec *codec,
+                unsigned int filter_mask, unsigned int clk_src)
+{
+        struct rt5677_priv *rt5677 = snd_soc_codec_get_drvdata(codec);
+        unsigned int asrc3_mask = 0, asrc3_value = 0;
+        unsigned int asrc4_mask = 0, asrc4_value = 0;
+        unsigned int asrc5_mask = 0, asrc5_value = 0;
+        unsigned int asrc6_mask = 0, asrc6_value = 0;
+        unsigned int asrc7_mask = 0, asrc7_value = 0;
+        switch (clk_src) {
+        case RT5677_CLK_SEL_SYS:
+        case RT5677_CLK_SEL_I2S1_ASRC:
+        case RT5677_CLK_SEL_I2S2_ASRC:
+        case RT5677_CLK_SEL_I2S3_ASRC:
+        case RT5677_CLK_SEL_I2S4_ASRC:
+        case RT5677_CLK_SEL_I2S5_ASRC:
+        case RT5677_CLK_SEL_I2S6_ASRC:
+        case RT5677_CLK_SEL_SYS2:
+        case RT5677_CLK_SEL_SYS3:
+        case RT5677_CLK_SEL_SYS4:
+        case RT5677_CLK_SEL_SYS5:
+        case RT5677_CLK_SEL_SYS6:
+        case RT5677_CLK_SEL_SYS7:
+                break;
+        default:
+                return -EINVAL;
+        }
+        /* ASRC 3 */
+        if (filter_mask & RT5677_DA_STEREO_FILTER) {
+                asrc3_mask |= RT5677_DA_STO_CLK_SEL_MASK;
+                asrc3_value = (asrc3_value & ~RT5677_DA_STO_CLK_SEL_MASK)
+                        | (clk_src << RT5677_DA_STO_CLK_SEL_SFT);
+        }
+        if (filter_mask & RT5677_DA_MONO2_L_FILTER) {
+                asrc3_mask |= RT5677_DA_MONO2L_CLK_SEL_MASK;
+                asrc3_value = (asrc3_value & ~RT5677_DA_MONO2L_CLK_SEL_MASK)
+                        | (clk_src << RT5677_DA_MONO2L_CLK_SEL_SFT);
+        }
+        if (filter_mask & RT5677_DA_MONO2_R_FILTER) {
+                asrc3_mask |= RT5677_DA_MONO2R_CLK_SEL_MASK;
+                asrc3_value = (asrc3_value & ~RT5677_DA_MONO2R_CLK_SEL_MASK)
+                        | (clk_src << RT5677_DA_MONO2R_CLK_SEL_SFT);
+        }
+        if (asrc3_mask)
+                regmap_update_bits(rt5677->regmap, RT5677_ASRC_3, asrc3_mask,
+                        asrc3_value);
+        /* ASRC 4 */
+        if (filter_mask & RT5677_DA_MONO3_L_FILTER) {
+                asrc4_mask |= RT5677_DA_MONO3L_CLK_SEL_MASK;
+                asrc4_value = (asrc4_value & ~RT5677_DA_MONO3L_CLK_SEL_MASK)
+                        | (clk_src << RT5677_DA_MONO3L_CLK_SEL_SFT);
+        }
+        if (filter_mask & RT5677_DA_MONO3_R_FILTER) {
+                asrc4_mask |= RT5677_DA_MONO3R_CLK_SEL_MASK;
+                asrc4_value = (asrc4_value & ~RT5677_DA_MONO3R_CLK_SEL_MASK)
+                        | (clk_src << RT5677_DA_MONO3R_CLK_SEL_SFT);
+        }
+        if (filter_mask & RT5677_DA_MONO4_L_FILTER) {
+                asrc4_mask |= RT5677_DA_MONO4L_CLK_SEL_MASK;
+                asrc4_value = (asrc4_value & ~RT5677_DA_MONO4L_CLK_SEL_MASK)
+                        | (clk_src << RT5677_DA_MONO4L_CLK_SEL_SFT);
+        }
+        if (filter_mask & RT5677_DA_MONO4_R_FILTER) {
+                asrc4_mask |= RT5677_DA_MONO4R_CLK_SEL_MASK;
+                asrc4_value = (asrc4_value & ~RT5677_DA_MONO4R_CLK_SEL_MASK)
+                        | (clk_src << RT5677_DA_MONO4R_CLK_SEL_SFT);
+        }
+        if (asrc4_mask)
+                regmap_update_bits(rt5677->regmap, RT5677_ASRC_4, asrc4_mask,
+                        asrc4_value);
+        /* ASRC 5 */
+        if (filter_mask & RT5677_AD_STEREO1_FILTER) {
+                asrc5_mask |= RT5677_AD_STO1_CLK_SEL_MASK;
+                asrc5_value = (asrc5_value & ~RT5677_AD_STO1_CLK_SEL_MASK)
+                        | (clk_src << RT5677_AD_STO1_CLK_SEL_SFT);
+        }
+        if (filter_mask & RT5677_AD_STEREO2_FILTER) {
+                asrc5_mask |= RT5677_AD_STO2_CLK_SEL_MASK;
+                asrc5_value = (asrc5_value & ~RT5677_AD_STO2_CLK_SEL_MASK)
+                        | (clk_src << RT5677_AD_STO2_CLK_SEL_SFT);
+        }
+        if (filter_mask & RT5677_AD_STEREO3_FILTER) {
+                asrc5_mask |= RT5677_AD_STO3_CLK_SEL_MASK;
+                asrc5_value = (asrc5_value & ~RT5677_AD_STO3_CLK_SEL_MASK)
+                        | (clk_src << RT5677_AD_STO3_CLK_SEL_SFT);
+        }
+        if (filter_mask & RT5677_AD_STEREO4_FILTER) {
+                asrc5_mask |= RT5677_AD_STO4_CLK_SEL_MASK;
+                asrc5_value = (asrc5_value & ~RT5677_AD_STO4_CLK_SEL_MASK)
+                        | (clk_src << RT5677_AD_STO4_CLK_SEL_SFT);
+        }
+        if (asrc5_mask)
+                regmap_update_bits(rt5677->regmap, RT5677_ASRC_5, asrc5_mask,
+                        asrc5_value);
+        /* ASRC 6 */
+        if (filter_mask & RT5677_AD_MONO_L_FILTER) {
+                asrc6_mask |= RT5677_AD_MONOL_CLK_SEL_MASK;
+                asrc6_value = (asrc6_value & ~RT5677_AD_MONOL_CLK_SEL_MASK)
+                        | (clk_src << RT5677_AD_MONOL_CLK_SEL_SFT);
+        }
+        if (filter_mask & RT5677_AD_MONO_R_FILTER) {
+                asrc6_mask |= RT5677_AD_MONOR_CLK_SEL_MASK;
+                asrc6_value = (asrc6_value & ~RT5677_AD_MONOR_CLK_SEL_MASK)
+                        | (clk_src << RT5677_AD_MONOR_CLK_SEL_SFT);
+        }
+        if (asrc6_mask)
+                regmap_update_bits(rt5677->regmap, RT5677_ASRC_6, asrc6_mask,
+                        asrc6_value);
+        /* ASRC 7 */
+        if (filter_mask & RT5677_DSP_OB_0_3_FILTER) {
+                asrc7_mask |= RT5677_DSP_OB_0_3_CLK_SEL_MASK;
+                asrc7_value = (asrc7_value & ~RT5677_DSP_OB_0_3_CLK_SEL_MASK)
+                        | (clk_src << RT5677_DSP_OB_0_3_CLK_SEL_SFT);
+        }
+        if (filter_mask & RT5677_DSP_OB_4_7_FILTER) {
+                asrc7_mask |= RT5677_DSP_OB_4_7_CLK_SEL_MASK;
+                asrc7_value = (asrc7_value & ~RT5677_DSP_OB_4_7_CLK_SEL_MASK)
+                        | (clk_src << RT5677_DSP_OB_4_7_CLK_SEL_SFT);
+        }
+        if (asrc7_mask)
+                regmap_update_bits(rt5677->regmap, RT5677_ASRC_7, asrc7_mask,
+                        asrc7_value);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(rt5677_sel_asrc_clk_src);
 /* Digital Mixer */
 static const struct snd_kcontrol_new rt5677_sto1_adc_l_mix[] = {
        SOC_DAPM_SINGLE("ADC1 Switch", RT5677_STO1_ADC_MIXER,
diff --git a/sound/soc/codecs/rt5677.h b/sound/soc/codecs/rt5677.h
index 07df96b43f59..9dceb41d18ea 100644
--- a/sound/soc/codecs/rt5677.h
+++ b/sound/soc/codecs/rt5677.h
@@ -1406,6 +1406,46 @@
 #define RT5677_DSP_CLK_SRC_PLL2                 (0x0 << 7)
 #define RT5677_DSP_CLK_SRC_BYPASS               (0x1 << 7)
+/* ASRC Control 3 (0x85) */
+#define RT5677_DA_STO_CLK_SEL_MASK              (0xf << 12)
+#define RT5677_DA_STO_CLK_SEL_SFT               12
+#define RT5677_DA_MONO2L_CLK_SEL_MASK           (0xf << 4)
+#define RT5677_DA_MONO2L_CLK_SEL_SFT            4
+#define RT5677_DA_MONO2R_CLK_SEL_MASK           (0xf << 0)
+#define RT5677_DA_MONO2R_CLK_SEL_SFT            0
+/* ASRC Control 4 (0x86) */
+#define RT5677_DA_MONO3L_CLK_SEL_MASK           (0xf << 12)
+#define RT5677_DA_MONO3L_CLK_SEL_SFT            12
+#define RT5677_DA_MONO3R_CLK_SEL_MASK           (0xf << 8)
+#define RT5677_DA_MONO3R_CLK_SEL_SFT            8
+#define RT5677_DA_MONO4L_CLK_SEL_MASK           (0xf << 4)
+#define RT5677_DA_MONO4L_CLK_SEL_SFT            4
+#define RT5677_DA_MONO4R_CLK_SEL_MASK           (0xf << 0)
+#define RT5677_DA_MONO4R_CLK_SEL_SFT            0
+/* ASRC Control 5 (0x87) */
+#define RT5677_AD_STO1_CLK_SEL_MASK             (0xf << 12)
+#define RT5677_AD_STO1_CLK_SEL_SFT              12
+#define RT5677_AD_STO2_CLK_SEL_MASK             (0xf << 8)
+#define RT5677_AD_STO2_CLK_SEL_SFT              8
+#define RT5677_AD_STO3_CLK_SEL_MASK             (0xf << 4)
+#define RT5677_AD_STO3_CLK_SEL_SFT              4
+#define RT5677_AD_STO4_CLK_SEL_MASK             (0xf << 0)
+#define RT5677_AD_STO4_CLK_SEL_SFT              0
+/* ASRC Control 6 (0x88) */
+#define RT5677_AD_MONOL_CLK_SEL_MASK            (0xf << 12)
+#define RT5677_AD_MONOL_CLK_SEL_SFT             12
+#define RT5677_AD_MONOR_CLK_SEL_MASK            (0xf << 8)
+#define RT5677_AD_MONOR_CLK_SEL_SFT             8
+/* ASRC Control 7 (0x89) */
+#define RT5677_DSP_OB_0_3_CLK_SEL_MASK          (0xf << 12)
+#define RT5677_DSP_OB_0_3_CLK_SEL_SFT           12
+#define RT5677_DSP_OB_4_7_CLK_SEL_MASK          (0xf << 8)
+#define RT5677_DSP_OB_4_7_CLK_SEL_SFT           8
 /* VAD Function Control 4 (0x9f) */
 #define RT5677_VAD_SRC_MASK                     (0x7 << 8)
 #define RT5677_VAD_SRC_SFT                      8
@@ -1670,6 +1710,42 @@ enum rt5677_type {
        RT5676,
 };
+/* ASRC clock source selection */
+enum {
+        RT5677_CLK_SEL_SYS,
+        RT5677_CLK_SEL_I2S1_ASRC,
+        RT5677_CLK_SEL_I2S2_ASRC,
+        RT5677_CLK_SEL_I2S3_ASRC,
+        RT5677_CLK_SEL_I2S4_ASRC,
+        RT5677_CLK_SEL_I2S5_ASRC,
+        RT5677_CLK_SEL_I2S6_ASRC,
+        RT5677_CLK_SEL_SYS2,
+        RT5677_CLK_SEL_SYS3,
+        RT5677_CLK_SEL_SYS4,
+        RT5677_CLK_SEL_SYS5,
+        RT5677_CLK_SEL_SYS6,
+        RT5677_CLK_SEL_SYS7,
+};
+/* filter mask */
+enum {
+        RT5677_DA_STEREO_FILTER = 0x1,
+        RT5677_DA_MONO2_L_FILTER = (0x1 << 1),
+        RT5677_DA_MONO2_R_FILTER = (0x1 << 2),
+        RT5677_DA_MONO3_L_FILTER = (0x1 << 3),
+        RT5677_DA_MONO3_R_FILTER = (0x1 << 4),
+        RT5677_DA_MONO4_L_FILTER = (0x1 << 5),
+        RT5677_DA_MONO4_R_FILTER = (0x1 << 6),
+        RT5677_AD_STEREO1_FILTER = (0x1 << 7),
+        RT5677_AD_STEREO2_FILTER = (0x1 << 8),
+        RT5677_AD_STEREO3_FILTER = (0x1 << 9),
+        RT5677_AD_STEREO4_FILTER = (0x1 << 10),
+        RT5677_AD_MONO_L_FILTER = (0x1 << 11),
+        RT5677_AD_MONO_R_FILTER = (0x1 << 12),
+        RT5677_DSP_OB_0_3_FILTER = (0x1 << 13),
+        RT5677_DSP_OB_4_7_FILTER = (0x1 << 14),
+};
 struct rt5677_priv {
        struct snd_soc_codec *codec;
        struct rt5677_platform_data pdata;
@@ -1696,4 +1772,7 @@ struct rt5677_priv {
        bool is_vref_slow;
 };
+int rt5677_sel_asrc_clk_src(struct snd_soc_codec *codec,
+                unsigned int filter_mask, unsigned int clk_src);
 #endif /* __RT5677_H__ */
diff --git a/sound/soc/codecs/tlv320aic23-i2c.c b/sound/soc/codecs/tlv320aic23-i2c.c
index f13701995482..78a94af65518 100644
--- a/sound/soc/codecs/tlv320aic23-i2c.c
+++ b/sound/soc/codecs/tlv320aic23-i2c.c
@@ -31,7 +31,7 @@ static int tlv320aic23_i2c_probe(struct i2c_client *i2c,
        return tlv320aic23_probe(&i2c->dev, regmap);
 }
-static int __exit tlv320aic23_i2c_remove(struct i2c_client *i2c)
+static int tlv320aic23_i2c_remove(struct i2c_client *i2c)
 {
        snd_soc_unregister_codec(&i2c->dev);
        return 0;
@@ -56,7 +56,7 @@ static struct i2c_driver tlv320aic23_i2c_driver = {
                   .of_match_table = of_match_ptr(tlv320aic23_of_match),
                   },
        .probe = tlv320aic23_i2c_probe,
-        .remove = __exit_p(tlv320aic23_i2c_remove),
+        .remove = tlv320aic23_i2c_remove,
        .id_table = tlv320aic23_id,
 };
diff --git a/sound/soc/codecs/wm2200.c b/sound/soc/codecs/wm2200.c
index 15599845a660..5a9da28f4f33 100644
--- a/sound/soc/codecs/wm2200.c
+++ b/sound/soc/codecs/wm2200.c
@@ -1554,7 +1554,6 @@ static int wm2200_probe(struct snd_soc_codec *codec)
        int ret;
        wm2200->codec = codec;
-        codec->dapm.bias_level = SND_SOC_BIAS_OFF;
        ret = snd_soc_add_codec_controls(codec, wm_adsp1_fw_controls, 2);
        if (ret != 0)
@@ -1942,6 +1941,7 @@ static int wm2200_set_fll(struct snd_soc_codec *codec, int fll_id, int source,
        struct wm2200_priv *wm2200 = snd_soc_codec_get_drvdata(codec);
        struct _fll_div factors;
        int ret, i, timeout;
+        unsigned long time_left;
        if (!Fout) {
                dev_dbg(codec->dev, "FLL disabled");
@@ -2021,9 +2021,10 @@ static int wm2200_set_fll(struct snd_soc_codec *codec, int fll_id, int source,
        /* Poll for the lock; will use the interrupt to exit quickly */
        for (i = 0; i < timeout; i++) {
                if (i2c->irq) {
-                        ret = wait_for_completion_timeout(&wm2200->fll_lock,
+                        time_left = wait_for_completion_timeout(
-                                                          msecs_to_jiffies(25));
+                                                        &wm2200->fll_lock,
-                        if (ret > 0)
+                                                        msecs_to_jiffies(25));
+                        if (time_left > 0)
                                break;
                } else {
                        msleep(1);
diff --git a/sound/soc/codecs/wm5100.c b/sound/soc/codecs/wm5100.c
index ea09db585aa1..96740379b711 100644
--- a/sound/soc/codecs/wm5100.c
+++ b/sound/soc/codecs/wm5100.c
@@ -1762,6 +1762,7 @@ static int wm5100_set_fll(struct snd_soc_codec *codec, int fll_id, int source,
        struct _fll_div factors;
        struct wm5100_fll *fll;
        int ret, base, lock, i, timeout;
+        unsigned long time_left;
        switch (fll_id) {
        case WM5100_FLL1:
@@ -1842,9 +1843,9 @@ static int wm5100_set_fll(struct snd_soc_codec *codec, int fll_id, int source,
        /* Poll for the lock; will use interrupt when we can test */
        for (i = 0; i < timeout; i++) {
                if (i2c->irq) {
-                        ret = wait_for_completion_timeout(&fll->lock,
+                        time_left = wait_for_completion_timeout(&fll->lock,
-                                                          msecs_to_jiffies(25));
+                                                        msecs_to_jiffies(25));
-                        if (ret > 0)
+                        if (time_left > 0)
                                break;
                } else {
                        msleep(1);
diff --git a/sound/soc/codecs/wm5102.c b/sound/soc/codecs/wm5102.c
index 6d0fe0ac95a3..0c6d1bc0526e 100644
--- a/sound/soc/codecs/wm5102.c
+++ b/sound/soc/codecs/wm5102.c
@@ -1861,7 +1861,6 @@ static unsigned int wm5102_digital_vu[] = {
        ARIZONA_DAC_DIGITAL_VOLUME_2L,
        ARIZONA_DAC_DIGITAL_VOLUME_2R,
        ARIZONA_DAC_DIGITAL_VOLUME_3L,
-        ARIZONA_DAC_DIGITAL_VOLUME_3R,
        ARIZONA_DAC_DIGITAL_VOLUME_4L,
        ARIZONA_DAC_DIGITAL_VOLUME_4R,
        ARIZONA_DAC_DIGITAL_VOLUME_5L,
diff --git a/sound/soc/codecs/wm8350.c b/sound/soc/codecs/wm8350.c
index c81a9eab3e3e..c65e5a75fc1a 100644
--- a/sound/soc/codecs/wm8350.c
+++ b/sound/soc/codecs/wm8350.c
@@ -69,14 +69,14 @@ struct wm8350_data {
        struct regulator_bulk_data supplies[ARRAY_SIZE(supply_names)];
        int fll_freq_out;
        int fll_freq_in;
+        struct delayed_work pga_work;
 };
 /*
 * Ramp OUT1 PGA volume to minimise pops at stream startup and shutdown.
 */
-static inline int wm8350_out1_ramp_step(struct snd_soc_codec *codec)
+static inline int wm8350_out1_ramp_step(struct wm8350_data *wm8350_data)
 {
-        struct wm8350_data *wm8350_data = snd_soc_codec_get_drvdata(codec);
        struct wm8350_output *out1 = &wm8350_data->out1;
        struct wm8350 *wm8350 = wm8350_data->wm8350;
        int left_complete = 0, right_complete = 0;
@@ -140,9 +140,8 @@ static inline int wm8350_out1_ramp_step(struct snd_soc_codec *codec)
 /*
 * Ramp OUT2 PGA volume to minimise pops at stream startup and shutdown.
 */
-static inline int wm8350_out2_ramp_step(struct snd_soc_codec *codec)
+static inline int wm8350_out2_ramp_step(struct wm8350_data *wm8350_data)
 {
-        struct wm8350_data *wm8350_data = snd_soc_codec_get_drvdata(codec);
        struct wm8350_output *out2 = &wm8350_data->out2;
        struct wm8350 *wm8350 = wm8350_data->wm8350;
        int left_complete = 0, right_complete = 0;
@@ -210,10 +209,8 @@ static inline int wm8350_out2_ramp_step(struct snd_soc_codec *codec)
 */
 static void wm8350_pga_work(struct work_struct *work)
 {
-        struct snd_soc_dapm_context *dapm =
+        struct wm8350_data *wm8350_data =
-            container_of(work, struct snd_soc_dapm_context, delayed_work.work);
+                container_of(work, struct wm8350_data, pga_work.work);
-        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(dapm);
-        struct wm8350_data *wm8350_data = snd_soc_codec_get_drvdata(codec);
        struct wm8350_output *out1 = &wm8350_data->out1,
            *out2 = &wm8350_data->out2;
        int i, out1_complete, out2_complete;
@@ -226,9 +223,9 @@ static void wm8350_pga_work(struct work_struct *work)
        for (i = 0; i <= 63; i++) {
                out1_complete = 1, out2_complete = 1;
                if (out1->ramp != WM8350_RAMP_NONE)
-                        out1_complete = wm8350_out1_ramp_step(codec);
+                        out1_complete = wm8350_out1_ramp_step(wm8350_data);
                if (out2->ramp != WM8350_RAMP_NONE)
-                        out2_complete = wm8350_out2_ramp_step(codec);
+                        out2_complete = wm8350_out2_ramp_step(wm8350_data);
                /* ramp finished ? */
                if (out1_complete && out2_complete)
@@ -283,7 +280,7 @@ static int pga_event(struct snd_soc_dapm_widget *w,
                out->ramp = WM8350_RAMP_UP;
                out->active = 1;
-                schedule_delayed_work(&codec->dapm.delayed_work,
+                schedule_delayed_work(&wm8350_data->pga_work,
                                      msecs_to_jiffies(1));
                break;
@@ -291,7 +288,7 @@ static int pga_event(struct snd_soc_dapm_widget *w,
                out->ramp = WM8350_RAMP_DOWN;
                out->active = 0;
-                schedule_delayed_work(&codec->dapm.delayed_work,
+                schedule_delayed_work(&wm8350_data->pga_work,
                                      msecs_to_jiffies(1));
                break;
        }
@@ -1492,7 +1489,7 @@ static  int wm8350_codec_probe(struct snd_soc_codec *codec)
        /* Put the codec into reset if it wasn't already */
        wm8350_clear_bits(wm8350, WM8350_POWER_MGMT_5, WM8350_CODEC_ENA);
-        INIT_DELAYED_WORK(&codec->dapm.delayed_work, wm8350_pga_work);
+        INIT_DELAYED_WORK(&priv->pga_work, wm8350_pga_work);
        INIT_DELAYED_WORK(&priv->hpl.work, wm8350_hpl_work);
        INIT_DELAYED_WORK(&priv->hpr.work, wm8350_hpr_work);
@@ -1578,7 +1575,7 @@ static int  wm8350_codec_remove(struct snd_soc_codec *codec)
        /* if there was any work waiting then we run it now and
         * wait for its completion */
-        flush_delayed_work(&codec->dapm.delayed_work);
+        flush_delayed_work(&priv->pga_work);
        wm8350_clear_bits(wm8350, WM8350_POWER_MGMT_5, WM8350_CODEC_ENA);
diff --git a/sound/soc/codecs/wm8731.c b/sound/soc/codecs/wm8731.c
index c6d10533e2bd..2245b6a32f3d 100644
--- a/sound/soc/codecs/wm8731.c
+++ b/sound/soc/codecs/wm8731.c
@@ -25,6 +25,7 @@
 #include <linux/spi/spi.h>
 #include <linux/of_device.h>
 #include <linux/mutex.h>
+#include <linux/clk.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
@@ -45,6 +46,7 @@ static const char *wm8731_supply_names[WM8731_NUM_SUPPLIES] = {
 /* codec private data */
 struct wm8731_priv {
        struct regmap *regmap;
+        struct clk *mclk;
        struct regulator_bulk_data supplies[WM8731_NUM_SUPPLIES];
        const struct snd_pcm_hw_constraint_list *constraints;
        unsigned int sysclk;
@@ -390,6 +392,8 @@ static int wm8731_set_dai_sysclk(struct snd_soc_dai *codec_dai,
        switch (clk_id) {
        case WM8731_SYSCLK_XTAL:
        case WM8731_SYSCLK_MCLK:
+                if (wm8731->mclk && clk_set_rate(wm8731->mclk, freq))
+                        return -EINVAL;
                wm8731->sysclk_type = clk_id;
                break;
        default:
@@ -491,6 +495,8 @@ static int wm8731_set_bias_level(struct snd_soc_codec *codec,
        switch (level) {
        case SND_SOC_BIAS_ON:
+                if (wm8731->mclk)
+                        clk_prepare_enable(wm8731->mclk);
                break;
        case SND_SOC_BIAS_PREPARE:
                break;
@@ -509,6 +515,8 @@ static int wm8731_set_bias_level(struct snd_soc_codec *codec,
                snd_soc_write(codec, WM8731_PWR, reg | 0x0040);
                break;
        case SND_SOC_BIAS_OFF:
+                if (wm8731->mclk)
+                        clk_disable_unprepare(wm8731->mclk);
                snd_soc_write(codec, WM8731_PWR, 0xffff);
                regulator_bulk_disable(ARRAY_SIZE(wm8731->supplies),
                                       wm8731->supplies);
@@ -667,6 +675,19 @@ static int wm8731_spi_probe(struct spi_device *spi)
        if (wm8731 == NULL)
                return -ENOMEM;
+        wm8731->mclk = devm_clk_get(&spi->dev, "mclk");
+        if (IS_ERR(wm8731->mclk)) {
+                ret = PTR_ERR(wm8731->mclk);
+                if (ret == -ENOENT) {
+                        wm8731->mclk = NULL;
+                        dev_warn(&spi->dev, "Assuming static MCLK\n");
+                } else {
+                        dev_err(&spi->dev, "Failed to get MCLK: %d\n",
+                                ret);
+                        return ret;
+                }
+        }
        mutex_init(&wm8731->lock);
        wm8731->regmap = devm_regmap_init_spi(spi, &wm8731_regmap);
@@ -718,6 +739,19 @@ static int wm8731_i2c_probe(struct i2c_client *i2c,
        if (wm8731 == NULL)
                return -ENOMEM;
+        wm8731->mclk = devm_clk_get(&i2c->dev, "mclk");
+        if (IS_ERR(wm8731->mclk)) {
+                ret = PTR_ERR(wm8731->mclk);
+                if (ret == -ENOENT) {
+                        wm8731->mclk = NULL;
+                        dev_warn(&i2c->dev, "Assuming static MCLK\n");
+                } else {
+                        dev_err(&i2c->dev, "Failed to get MCLK: %d\n",
+                                ret);
+                        return ret;
+                }
+        }
        mutex_init(&wm8731->lock);
        wm8731->regmap = devm_regmap_init_i2c(i2c, &wm8731_regmap);
diff --git a/sound/soc/codecs/wm8741.c b/sound/soc/codecs/wm8741.c
index 31bb4801a005..9e71c768966f 100644
--- a/sound/soc/codecs/wm8741.c
+++ b/sound/soc/codecs/wm8741.c
@@ -123,7 +123,7 @@ static struct {
 };
 static const unsigned int rates_11289[] = {
-        44100, 88235,
+        44100, 88200,
 };
 static const struct snd_pcm_hw_constraint_list constraints_11289 = {
@@ -150,7 +150,7 @@ static const struct snd_pcm_hw_constraint_list constraints_16384 = {
 };
 static const unsigned int rates_16934[] = {
-        44100, 88235,
+        44100, 88200,
 };
 static const struct snd_pcm_hw_constraint_list constraints_16934 = {
@@ -168,7 +168,7 @@ static const struct snd_pcm_hw_constraint_list constraints_18432 = {
 };
 static const unsigned int rates_22579[] = {
-        44100, 88235, 1764000
+        44100, 88200, 176400
 };
 static const struct snd_pcm_hw_constraint_list constraints_22579 = {
@@ -186,7 +186,7 @@ static const struct snd_pcm_hw_constraint_list constraints_24576 = {
 };
 static const unsigned int rates_36864[] = {
-        48000, 96000, 19200
+        48000, 96000, 192000
 };
 static const struct snd_pcm_hw_constraint_list constraints_36864 = {
diff --git a/sound/soc/codecs/wm8753.c b/sound/soc/codecs/wm8753.c
index 21ca3a94fc96..c50a5959345f 100644
--- a/sound/soc/codecs/wm8753.c
+++ b/sound/soc/codecs/wm8753.c
@@ -153,6 +153,7 @@ struct wm8753_priv {
        unsigned int hifi_fmt;
        int dai_func;
+        struct delayed_work charge_work;
 };
 #define wm8753_reset(c) snd_soc_write(c, WM8753_RESET, 0)
@@ -1326,9 +1327,19 @@ static int wm8753_mute(struct snd_soc_dai *dai, int mute)
        return 0;
 }
+static void wm8753_charge_work(struct work_struct *work)
+{
+        struct wm8753_priv *wm8753 =
+                container_of(work, struct wm8753_priv, charge_work.work);
+        /* Set to 500k */
+        regmap_update_bits(wm8753->regmap, WM8753_PWR1, 0x0180, 0x0100);
+}
 static int wm8753_set_bias_level(struct snd_soc_codec *codec,
                                 enum snd_soc_bias_level level)
 {
+        struct wm8753_priv *wm8753 = snd_soc_codec_get_drvdata(codec);
        u16 pwr_reg = snd_soc_read(codec, WM8753_PWR1) & 0xfe3e;
        switch (level) {
@@ -1337,14 +1348,22 @@ static int wm8753_set_bias_level(struct snd_soc_codec *codec,
                snd_soc_write(codec, WM8753_PWR1, pwr_reg | 0x00c0);
                break;
        case SND_SOC_BIAS_PREPARE:
-                /* set vmid to 5k for quick power up */
+                /* Wait until fully charged */
-                snd_soc_write(codec, WM8753_PWR1, pwr_reg | 0x01c1);
+                flush_delayed_work(&wm8753->charge_work);
                break;
        case SND_SOC_BIAS_STANDBY:
-                /* mute dac and set vmid to 500k, enable VREF */
+                if (codec->dapm.bias_level == SND_SOC_BIAS_OFF) {
-                snd_soc_write(codec, WM8753_PWR1, pwr_reg | 0x0141);
+                        /* set vmid to 5k for quick power up */
+                        snd_soc_write(codec, WM8753_PWR1, pwr_reg | 0x01c1);
+                        schedule_delayed_work(&wm8753->charge_work,
+                                msecs_to_jiffies(caps_charge));
+                } else {
+                        /* mute dac and set vmid to 500k, enable VREF */
+                        snd_soc_write(codec, WM8753_PWR1, pwr_reg | 0x0141);
+                }
                break;
        case SND_SOC_BIAS_OFF:
+                cancel_delayed_work_sync(&wm8753->charge_work);
                snd_soc_write(codec, WM8753_PWR1, 0x0001);
                break;
        }
@@ -1428,38 +1447,12 @@ static struct snd_soc_dai_driver wm8753_dai[] = {
 },
 };
-static void wm8753_work(struct work_struct *work)
-{
-        struct snd_soc_dapm_context *dapm =
-                container_of(work, struct snd_soc_dapm_context,
-                             delayed_work.work);
-        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(dapm);
-        wm8753_set_bias_level(codec, dapm->bias_level);
-}
-static int wm8753_suspend(struct snd_soc_codec *codec)
-{
-        wm8753_set_bias_level(codec, SND_SOC_BIAS_OFF);
-        return 0;
-}
 static int wm8753_resume(struct snd_soc_codec *codec)
 {
        struct wm8753_priv *wm8753 = snd_soc_codec_get_drvdata(codec);
        regcache_sync(wm8753->regmap);
-        wm8753_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
-        /* charge wm8753 caps */
-        if (codec->dapm.suspend_bias_level == SND_SOC_BIAS_ON) {
-                wm8753_set_bias_level(codec, SND_SOC_BIAS_PREPARE);
-                codec->dapm.bias_level = SND_SOC_BIAS_ON;
-                queue_delayed_work(system_power_efficient_wq,
-                                   &codec->dapm.delayed_work,
-                                   msecs_to_jiffies(caps_charge));
-        }
        return 0;
 }
@@ -1468,7 +1461,7 @@ static int wm8753_probe(struct snd_soc_codec *codec)
        struct wm8753_priv *wm8753 = snd_soc_codec_get_drvdata(codec);
        int ret;
-        INIT_DELAYED_WORK(&codec->dapm.delayed_work, wm8753_work);
+        INIT_DELAYED_WORK(&wm8753->charge_work, wm8753_charge_work);
        ret = wm8753_reset(codec);
        if (ret < 0) {
@@ -1476,14 +1469,8 @@ static int wm8753_probe(struct snd_soc_codec *codec)
                return ret;
        }
-        wm8753_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
        wm8753->dai_func = 0;
-        /* charge output caps */
-        wm8753_set_bias_level(codec, SND_SOC_BIAS_PREPARE);
-        schedule_delayed_work(&codec->dapm.delayed_work,
-                              msecs_to_jiffies(caps_charge));
        /* set the update bits */
        snd_soc_update_bits(codec, WM8753_LDAC, 0x0100, 0x0100);
        snd_soc_update_bits(codec, WM8753_RDAC, 0x0100, 0x0100);
@@ -1499,21 +1486,11 @@ static int wm8753_probe(struct snd_soc_codec *codec)
        return 0;
 }
-/* power down chip */
-static int wm8753_remove(struct snd_soc_codec *codec)
-{
-        flush_delayed_work(&codec->dapm.delayed_work);
-        wm8753_set_bias_level(codec, SND_SOC_BIAS_OFF);
-        return 0;
-}
 static struct snd_soc_codec_driver soc_codec_dev_wm8753 = {
        .probe =        wm8753_probe,
-        .remove =       wm8753_remove,
-        .suspend =      wm8753_suspend,
        .resume =       wm8753_resume,
        .set_bias_level = wm8753_set_bias_level,
+        .suspend_bias_off = true,
        .controls = wm8753_snd_controls,
        .num_controls = ARRAY_SIZE(wm8753_snd_controls),
diff --git a/sound/soc/codecs/wm8804-i2c.c b/sound/soc/codecs/wm8804-i2c.c
index 5bd4af2b4059..6596f5f3a0c3 100644
--- a/sound/soc/codecs/wm8804-i2c.c
+++ b/sound/soc/codecs/wm8804-i2c.c
@@ -50,6 +50,7 @@ static struct i2c_driver wm8804_i2c_driver = {
        .driver = {
                .name = "wm8804",
                .owner = THIS_MODULE,
+                .pm = &wm8804_pm,
                .of_match_table = wm8804_of_match,
        },
        .probe = wm8804_i2c_probe,
diff --git a/sound/soc/codecs/wm8804-spi.c b/sound/soc/codecs/wm8804-spi.c
index 287e11e90794..407a3cf391e5 100644
--- a/sound/soc/codecs/wm8804-spi.c
+++ b/sound/soc/codecs/wm8804-spi.c
@@ -43,6 +43,7 @@ static struct spi_driver wm8804_spi_driver = {
        .driver = {
                .name = "wm8804",
                .owner = THIS_MODULE,
+                .pm = &wm8804_pm,
                .of_match_table = wm8804_of_match,
        },
        .probe = wm8804_spi_probe,
diff --git a/sound/soc/codecs/wm8804.c b/sound/soc/codecs/wm8804.c
index 1bd4ace29594..1e403f67cf16 100644
--- a/sound/soc/codecs/wm8804.c
+++ b/sound/soc/codecs/wm8804.c
@@ -13,8 +13,10 @@
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/init.h>
+#include <linux/gpio/consumer.h>
 #include <linux/delay.h>
 #include <linux/pm.h>
+#include <linux/pm_runtime.h>
 #include <linux/of_device.h>
 #include <linux/regulator/consumer.h>
 #include <linux/slab.h>
@@ -24,6 +26,7 @@
 #include <sound/soc.h>
 #include <sound/initval.h>
 #include <sound/tlv.h>
+#include <sound/soc-dapm.h>
 #include "wm8804.h"
@@ -57,18 +60,23 @@ static const struct reg_default wm8804_reg_defaults[] = {
 };
 struct wm8804_priv {
+        struct device *dev;
        struct regmap *regmap;
        struct regulator_bulk_data supplies[WM8804_NUM_SUPPLIES];
        struct notifier_block disable_nb[WM8804_NUM_SUPPLIES];
        int mclk_div;
-};
-static int txsrc_get(struct snd_kcontrol *kcontrol,
+        struct gpio_desc *reset;
-                     struct snd_ctl_elem_value *ucontrol);
+        int aif_pwr;
+};
 static int txsrc_put(struct snd_kcontrol *kcontrol,
                     struct snd_ctl_elem_value *ucontrol);
+static int wm8804_aif_event(struct snd_soc_dapm_widget *w,
+                            struct snd_kcontrol *kcontrol, int event);
 /*
 * We can't use the same notifier block for more than one supply and
 * there's no way I can see to get from a callback to the caller
@@ -90,26 +98,62 @@ WM8804_REGULATOR_EVENT(0)
 WM8804_REGULATOR_EVENT(1)
 static const char *txsrc_text[] = { "S/PDIF RX", "AIF" };
-static SOC_ENUM_SINGLE_EXT_DECL(txsrc, txsrc_text);
+static const SOC_ENUM_SINGLE_DECL(txsrc, WM8804_SPDTX4, 6, txsrc_text);
-static const struct snd_kcontrol_new wm8804_snd_controls[] = {
+static const struct snd_kcontrol_new wm8804_tx_source_mux[] = {
-        SOC_ENUM_EXT("Input Source", txsrc, txsrc_get, txsrc_put),
+        SOC_DAPM_ENUM_EXT("Input Source", txsrc,
-        SOC_SINGLE("TX Playback Switch", WM8804_PWRDN, 2, 1, 1),
+                          snd_soc_dapm_get_enum_double, txsrc_put),
-        SOC_SINGLE("AIF Playback Switch", WM8804_PWRDN, 4, 1, 1)
 };
-static int txsrc_get(struct snd_kcontrol *kcontrol,
+static const struct snd_soc_dapm_widget wm8804_dapm_widgets[] = {
-                     struct snd_ctl_elem_value *ucontrol)
+SND_SOC_DAPM_OUTPUT("SPDIF Out"),
-{
+SND_SOC_DAPM_INPUT("SPDIF In"),
-        struct snd_soc_codec *codec;
-        unsigned int src;
+SND_SOC_DAPM_PGA("SPDIFTX", WM8804_PWRDN, 2, 1, NULL, 0),
+SND_SOC_DAPM_PGA("SPDIFRX", WM8804_PWRDN, 1, 1, NULL, 0),
+SND_SOC_DAPM_MUX("Tx Source", SND_SOC_NOPM, 6, 0, wm8804_tx_source_mux),
+SND_SOC_DAPM_AIF_OUT_E("AIFTX", NULL, 0, SND_SOC_NOPM, 0, 0, wm8804_aif_event,
+                       SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
+SND_SOC_DAPM_AIF_IN_E("AIFRX", NULL, 0, SND_SOC_NOPM, 0, 0, wm8804_aif_event,
+                      SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
+};
+static const struct snd_soc_dapm_route wm8804_dapm_routes[] = {
+        { "AIFRX", NULL, "Playback" },
+        { "Tx Source", "AIF", "AIFRX" },
+        { "SPDIFRX", NULL, "SPDIF In" },
+        { "Tx Source", "S/PDIF RX", "SPDIFRX" },
-        codec = snd_soc_kcontrol_codec(kcontrol);
+        { "SPDIFTX", NULL, "Tx Source" },
-        src = snd_soc_read(codec, WM8804_SPDTX4);
+        { "SPDIF Out", NULL, "SPDIFTX" },
-        if (src & 0x40)
-                ucontrol->value.integer.value[0] = 1;
+        { "AIFTX", NULL, "SPDIFRX" },
-        else
+        { "Capture", NULL, "AIFTX" },
-                ucontrol->value.integer.value[0] = 0;
+};
+static int wm8804_aif_event(struct snd_soc_dapm_widget *w,
+                            struct snd_kcontrol *kcontrol, int event)
+{
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
+        struct wm8804_priv *wm8804 = snd_soc_codec_get_drvdata(codec);
+        switch (event) {
+        case SND_SOC_DAPM_POST_PMU:
+                /* power up the aif */
+                if (!wm8804->aif_pwr)
+                        snd_soc_update_bits(codec, WM8804_PWRDN, 0x10, 0x0);
+                wm8804->aif_pwr++;
+                break;
+        case SND_SOC_DAPM_POST_PMD:
+                /* power down only both paths are disabled */
+                wm8804->aif_pwr--;
+                if (!wm8804->aif_pwr)
+                        snd_soc_update_bits(codec, WM8804_PWRDN, 0x10, 0x10);
+                break;
+        }
        return 0;
 }
@@ -117,48 +161,33 @@ static int txsrc_get(struct snd_kcontrol *kcontrol,
 static int txsrc_put(struct snd_kcontrol *kcontrol,
                     struct snd_ctl_elem_value *ucontrol)
 {
-        struct snd_soc_codec *codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_kcontrol_codec(kcontrol);
-        unsigned int src, txpwr;
+        struct snd_soc_dapm_context *dapm = &codec->dapm;
+        struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
+        unsigned int val = ucontrol->value.enumerated.item[0] << e->shift_l;
+        unsigned int mask = 1 << e->shift_l;
+        unsigned int txpwr;
+        if (val != 0 && val != mask)
+                return -EINVAL;
-        codec = snd_soc_kcontrol_codec(kcontrol);
+        snd_soc_dapm_mutex_lock(dapm);
-        if (ucontrol->value.integer.value[0] != 0
+        if (snd_soc_test_bits(codec, e->reg, mask, val)) {
-                        && ucontrol->value.integer.value[0] != 1)
+                /* save the current power state of the transmitter */
-                return -EINVAL;
+                txpwr = snd_soc_read(codec, WM8804_PWRDN) & 0x4;
-        src = snd_soc_read(codec, WM8804_SPDTX4);
+                /* power down the transmitter */
-        switch ((src & 0x40) >> 6) {
+                snd_soc_update_bits(codec, WM8804_PWRDN, 0x4, 0x4);
-        case 0:
-                if (!ucontrol->value.integer.value[0])
-                        return 0;
-                break;
-        case 1:
-                if (ucontrol->value.integer.value[1])
-                        return 0;
-                break;
-        }
-        /* save the current power state of the transmitter */
+                /* set the tx source */
-        txpwr = snd_soc_read(codec, WM8804_PWRDN) & 0x4;
+                snd_soc_update_bits(codec, e->reg, mask, val);
-        /* power down the transmitter */
-        snd_soc_update_bits(codec, WM8804_PWRDN, 0x4, 0x4);
+                /* restore the transmitter's configuration */
-        /* set the tx source */
+                snd_soc_update_bits(codec, WM8804_PWRDN, 0x4, txpwr);
-        snd_soc_update_bits(codec, WM8804_SPDTX4, 0x40,
-                            ucontrol->value.integer.value[0] << 6);
-        if (ucontrol->value.integer.value[0]) {
-                /* power down the receiver */
-                snd_soc_update_bits(codec, WM8804_PWRDN, 0x2, 0x2);
-                /* power up the AIF */
-                snd_soc_update_bits(codec, WM8804_PWRDN, 0x10, 0);
-        } else {
-                /* don't power down the AIF -- may be used as an output */
-                /* power up the receiver */
-                snd_soc_update_bits(codec, WM8804_PWRDN, 0x2, 0);
        }
-        /* restore the transmitter's configuration */
+        snd_soc_dapm_mutex_unlock(dapm);
-        snd_soc_update_bits(codec, WM8804_PWRDN, 0x4, txpwr);
        return 0;
 }
@@ -182,7 +211,7 @@ static bool wm8804_volatile(struct device *dev, unsigned int reg)
        }
 }
-static int wm8804_reset(struct wm8804_priv *wm8804)
+static int wm8804_soft_reset(struct wm8804_priv *wm8804)
 {
        return regmap_write(wm8804->regmap, WM8804_RST_DEVID1, 0x0);
 }
@@ -376,19 +405,19 @@ static int wm8804_set_pll(struct snd_soc_dai *dai, int pll_id,
                          int source, unsigned int freq_in,
                          unsigned int freq_out)
 {
-        struct snd_soc_codec *codec;
+        struct snd_soc_codec *codec = dai->codec;
+        struct wm8804_priv *wm8804 = snd_soc_codec_get_drvdata(codec);
+        bool change;
-        codec = dai->codec;
        if (!freq_in || !freq_out) {
                /* disable the PLL */
-                snd_soc_update_bits(codec, WM8804_PWRDN, 0x1, 0x1);
+                regmap_update_bits_check(wm8804->regmap, WM8804_PWRDN,
-                return 0;
+                                         0x1, 0x1, &change);
+                if (change)
+                        pm_runtime_put(wm8804->dev);
        } else {
                int ret;
                struct pll_div pll_div;
-                struct wm8804_priv *wm8804;
-                wm8804 = snd_soc_codec_get_drvdata(codec);
                ret = pll_factors(&pll_div, freq_out, freq_in,
                                  wm8804->mclk_div);
@@ -396,7 +425,10 @@ static int wm8804_set_pll(struct snd_soc_dai *dai, int pll_id,
                        return ret;
                /* power down the PLL before reprogramming it */
-                snd_soc_update_bits(codec, WM8804_PWRDN, 0x1, 0x1);
+                regmap_update_bits_check(wm8804->regmap, WM8804_PWRDN,
+                                         0x1, 0x1, &change);
+                if (!change)
+                        pm_runtime_get_sync(wm8804->dev);
                /* set PLLN and PRESCALE */
                snd_soc_update_bits(codec, WM8804_PLL4, 0xf | 0x10,
@@ -474,47 +506,6 @@ static int wm8804_set_clkdiv(struct snd_soc_dai *dai,
        return 0;
 }
-static int wm8804_set_bias_level(struct snd_soc_codec *codec,
-                                 enum snd_soc_bias_level level)
-{
-        int ret;
-        struct wm8804_priv *wm8804;
-        wm8804 = snd_soc_codec_get_drvdata(codec);
-        switch (level) {
-        case SND_SOC_BIAS_ON:
-                break;
-        case SND_SOC_BIAS_PREPARE:
-                /* power up the OSC and the PLL */
-                snd_soc_update_bits(codec, WM8804_PWRDN, 0x9, 0);
-                break;
-        case SND_SOC_BIAS_STANDBY:
-                if (codec->dapm.bias_level == SND_SOC_BIAS_OFF) {
-                        ret = regulator_bulk_enable(ARRAY_SIZE(wm8804->supplies),
-                                                    wm8804->supplies);
-                        if (ret) {
-                                dev_err(codec->dev,
-                                        "Failed to enable supplies: %d\n",
-                                        ret);
-                                return ret;
-                        }
-                        regcache_sync(wm8804->regmap);
-                }
-                /* power down the OSC and the PLL */
-                snd_soc_update_bits(codec, WM8804_PWRDN, 0x9, 0x9);
-                break;
-        case SND_SOC_BIAS_OFF:
-                /* power down the OSC and the PLL */
-                snd_soc_update_bits(codec, WM8804_PWRDN, 0x9, 0x9);
-                regulator_bulk_disable(ARRAY_SIZE(wm8804->supplies),
-                                       wm8804->supplies);
-                break;
-        }
-        codec->dapm.bias_level = level;
-        return 0;
-}
 static const struct snd_soc_dai_ops wm8804_dai_ops = {
        .hw_params = wm8804_hw_params,
        .set_fmt = wm8804_set_fmt,
@@ -552,11 +543,12 @@ static struct snd_soc_dai_driver wm8804_dai = {
 };
 static const struct snd_soc_codec_driver soc_codec_dev_wm8804 = {
-        .set_bias_level = wm8804_set_bias_level,
        .idle_bias_off = true,
-        .controls = wm8804_snd_controls,
+        .dapm_widgets = wm8804_dapm_widgets,
-        .num_controls = ARRAY_SIZE(wm8804_snd_controls),
+        .num_dapm_widgets = ARRAY_SIZE(wm8804_dapm_widgets),
+        .dapm_routes = wm8804_dapm_routes,
+        .num_dapm_routes = ARRAY_SIZE(wm8804_dapm_routes),
 };
 const struct regmap_config wm8804_regmap_config = {
@@ -584,8 +576,17 @@ int wm8804_probe(struct device *dev, struct regmap *regmap)
        dev_set_drvdata(dev, wm8804);
+        wm8804->dev = dev;
        wm8804->regmap = regmap;
+        wm8804->reset = devm_gpiod_get_optional(dev, "wlf,reset",
+                                                GPIOD_OUT_LOW);
+        if (IS_ERR(wm8804->reset)) {
+                ret = PTR_ERR(wm8804->reset);
+                dev_err(dev, "Failed to get reset line: %d\n", ret);
+                return ret;
+        }
        for (i = 0; i < ARRAY_SIZE(wm8804->supplies); i++)
                wm8804->supplies[i].supply = wm8804_supply_names[i];
@@ -601,12 +602,15 @@ int wm8804_probe(struct device *dev, struct regmap *regmap)
        /* This should really be moved into the regulator core */
        for (i = 0; i < ARRAY_SIZE(wm8804->supplies); i++) {
-                ret = regulator_register_notifier(wm8804->supplies[i].consumer,
+                struct regulator *regulator = wm8804->supplies[i].consumer;
-                                                  &wm8804->disable_nb[i]);
+                ret = devm_regulator_register_notifier(regulator,
+                                                       &wm8804->disable_nb[i]);
                if (ret != 0) {
                        dev_err(dev,
                                "Failed to register regulator notifier: %d\n",
                                ret);
+                        return ret;
                }
        }
@@ -614,9 +618,12 @@ int wm8804_probe(struct device *dev, struct regmap *regmap)
                                    wm8804->supplies);
        if (ret) {
                dev_err(dev, "Failed to enable supplies: %d\n", ret);
-                goto err_reg_enable;
+                return ret;
        }
+        if (wm8804->reset)
+                gpiod_set_value_cansleep(wm8804->reset, 1);
        ret = regmap_read(regmap, WM8804_RST_DEVID1, &id1);
        if (ret < 0) {
                dev_err(dev, "Failed to read device ID: %d\n", ret);
@@ -645,14 +652,26 @@ int wm8804_probe(struct device *dev, struct regmap *regmap)
        }
        dev_info(dev, "revision %c\n", id1 + 'A');
-        ret = wm8804_reset(wm8804);
+        if (!wm8804->reset) {
+                ret = wm8804_soft_reset(wm8804);
+                if (ret < 0) {
+                        dev_err(dev, "Failed to issue reset: %d\n", ret);
+                        goto err_reg_enable;
+                }
+        }
+        ret = snd_soc_register_codec(dev, &soc_codec_dev_wm8804,
+                                     &wm8804_dai, 1);
        if (ret < 0) {
-                dev_err(dev, "Failed to issue reset: %d\n", ret);
+                dev_err(dev, "Failed to register CODEC: %d\n", ret);
                goto err_reg_enable;
        }
-        return snd_soc_register_codec(dev, &soc_codec_dev_wm8804,
+        pm_runtime_set_active(dev);
-                                      &wm8804_dai, 1);
+        pm_runtime_enable(dev);
+        pm_runtime_idle(dev);
+        return 0;
 err_reg_enable:
        regulator_bulk_disable(ARRAY_SIZE(wm8804->supplies), wm8804->supplies);
@@ -662,18 +681,50 @@ EXPORT_SYMBOL_GPL(wm8804_probe);
 void wm8804_remove(struct device *dev)
 {
-        struct wm8804_priv *wm8804;
+        pm_runtime_disable(dev);
-        int i;
+        snd_soc_unregister_codec(dev);
+}
+EXPORT_SYMBOL_GPL(wm8804_remove);
-        wm8804 = dev_get_drvdata(dev);
+#if IS_ENABLED(CONFIG_PM)
+static int wm8804_runtime_resume(struct device *dev)
+{
+        struct wm8804_priv *wm8804 = dev_get_drvdata(dev);
+        int ret;
-        for (i = 0; i < ARRAY_SIZE(wm8804->supplies); ++i)
+        ret = regulator_bulk_enable(ARRAY_SIZE(wm8804->supplies),
-                regulator_unregister_notifier(wm8804->supplies[i].consumer,
+                                    wm8804->supplies);
-                                              &wm8804->disable_nb[i]);
+        if (ret) {
+                dev_err(wm8804->dev, "Failed to enable supplies: %d\n", ret);
+                return ret;
+        }
-        snd_soc_unregister_codec(dev);
+        regcache_sync(wm8804->regmap);
+        /* Power up OSCCLK */
+        regmap_update_bits(wm8804->regmap, WM8804_PWRDN, 0x8, 0x0);
+        return 0;
 }
-EXPORT_SYMBOL_GPL(wm8804_remove);
+static int wm8804_runtime_suspend(struct device *dev)
+{
+        struct wm8804_priv *wm8804 = dev_get_drvdata(dev);
+        /* Power down OSCCLK */
+        regmap_update_bits(wm8804->regmap, WM8804_PWRDN, 0x8, 0x8);
+        regulator_bulk_disable(ARRAY_SIZE(wm8804->supplies),
+                               wm8804->supplies);
+        return 0;
+}
+#endif
+const struct dev_pm_ops wm8804_pm = {
+        SET_RUNTIME_PM_OPS(wm8804_runtime_suspend, wm8804_runtime_resume, NULL)
+};
+EXPORT_SYMBOL_GPL(wm8804_pm);
 MODULE_DESCRIPTION("ASoC WM8804 driver");
 MODULE_AUTHOR("Dimitris Papastamos <dp@opensource.wolfsonmicro.com>");
diff --git a/sound/soc/codecs/wm8804.h b/sound/soc/codecs/wm8804.h
index a39a2563dc67..aa72fa66c932 100644
--- a/sound/soc/codecs/wm8804.h
+++ b/sound/soc/codecs/wm8804.h
@@ -65,6 +65,7 @@
 #define WM8804_MCLKDIV_128FS                    1
 extern const struct regmap_config wm8804_regmap_config;
+extern const struct dev_pm_ops wm8804_pm;
 int wm8804_probe(struct device *dev, struct regmap *regmap);
 void wm8804_remove(struct device *dev);
diff --git a/sound/soc/codecs/wm8971.c b/sound/soc/codecs/wm8971.c
index 39ddb9b8834c..f9cbabdc6238 100644
--- a/sound/soc/codecs/wm8971.c
+++ b/sound/soc/codecs/wm8971.c
@@ -31,11 +31,11 @@
 #define WM8971_REG_COUNT                43
-static struct workqueue_struct *wm8971_workq = NULL;
 /* codec private data */
 struct wm8971_priv {
        unsigned int sysclk;
+        struct delayed_work charge_work;
+        struct regmap *regmap;
 };
 /*
@@ -552,9 +552,19 @@ static int wm8971_mute(struct snd_soc_dai *dai, int mute)
        return 0;
 }
+static void wm8971_charge_work(struct work_struct *work)
+{
+        struct wm8971_priv *wm8971 =
+                container_of(work, struct wm8971_priv, charge_work.work);
+        /* Set to 500k */
+        regmap_update_bits(wm8971->regmap, WM8971_PWR1, 0x0180, 0x0100);
+}
 static int wm8971_set_bias_level(struct snd_soc_codec *codec,
        enum snd_soc_bias_level level)
 {
+        struct wm8971_priv *wm8971 = snd_soc_codec_get_drvdata(codec);
        u16 pwr_reg = snd_soc_read(codec, WM8971_PWR1) & 0xfe3e;
        switch (level) {
@@ -563,15 +573,24 @@ static int wm8971_set_bias_level(struct snd_soc_codec *codec,
                snd_soc_write(codec, WM8971_PWR1, pwr_reg | 0x00c1);
                break;
        case SND_SOC_BIAS_PREPARE:
+                /* Wait until fully charged */
+                flush_delayed_work(&wm8971->charge_work);
                break;
        case SND_SOC_BIAS_STANDBY:
-                if (codec->dapm.bias_level == SND_SOC_BIAS_OFF)
+                if (codec->dapm.bias_level == SND_SOC_BIAS_OFF) {
                        snd_soc_cache_sync(codec);
+                        /* charge output caps - set vmid to 5k for quick power up */
+                        snd_soc_write(codec, WM8971_PWR1, pwr_reg | 0x01c0);
+                        queue_delayed_work(system_power_efficient_wq,
+                                &wm8971->charge_work, msecs_to_jiffies(1000));
+                } else {
+                        /* mute dac and set vmid to 500k, enable VREF */
+                        snd_soc_write(codec, WM8971_PWR1, pwr_reg | 0x0140);
+                }
-                /* mute dac and set vmid to 500k, enable VREF */
-                snd_soc_write(codec, WM8971_PWR1, pwr_reg | 0x0140);
                break;
        case SND_SOC_BIAS_OFF:
+                cancel_delayed_work_sync(&wm8971->charge_work);
                snd_soc_write(codec, WM8971_PWR1, 0x0001);
                break;
        }
@@ -610,58 +629,14 @@ static struct snd_soc_dai_driver wm8971_dai = {
        .ops = &wm8971_dai_ops,
 };
-static void wm8971_work(struct work_struct *work)
-{
-        struct snd_soc_dapm_context *dapm =
-                container_of(work, struct snd_soc_dapm_context,
-                             delayed_work.work);
-        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(dapm);
-        wm8971_set_bias_level(codec, codec->dapm.bias_level);
-}
-static int wm8971_suspend(struct snd_soc_codec *codec)
-{
-        wm8971_set_bias_level(codec, SND_SOC_BIAS_OFF);
-        return 0;
-}
-static int wm8971_resume(struct snd_soc_codec *codec)
-{
-        u16 reg;
-        wm8971_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
-        /* charge wm8971 caps */
-        if (codec->dapm.suspend_bias_level == SND_SOC_BIAS_ON) {
-                reg = snd_soc_read(codec, WM8971_PWR1) & 0xfe3e;
-                snd_soc_write(codec, WM8971_PWR1, reg | 0x01c0);
-                codec->dapm.bias_level = SND_SOC_BIAS_ON;
-                queue_delayed_work(wm8971_workq, &codec->dapm.delayed_work,
-                        msecs_to_jiffies(1000));
-        }
-        return 0;
-}
 static int wm8971_probe(struct snd_soc_codec *codec)
 {
-        int ret = 0;
+        struct wm8971_priv *wm8971 = snd_soc_codec_get_drvdata(codec);
-        u16 reg;
-        INIT_DELAYED_WORK(&codec->dapm.delayed_work, wm8971_work);
+        INIT_DELAYED_WORK(&wm8971->charge_work, wm8971_charge_work);
-        wm8971_workq = create_workqueue("wm8971");
-        if (wm8971_workq == NULL)
-                return -ENOMEM;
        wm8971_reset(codec);
-        /* charge output caps - set vmid to 5k for quick power up */
-        reg = snd_soc_read(codec, WM8971_PWR1) & 0xfe3e;
-        snd_soc_write(codec, WM8971_PWR1, reg | 0x01c0);
-        codec->dapm.bias_level = SND_SOC_BIAS_STANDBY;
-        queue_delayed_work(wm8971_workq, &codec->dapm.delayed_work,
-                msecs_to_jiffies(1000));
        /* set the update bits */
        snd_soc_update_bits(codec, WM8971_LDAC, 0x0100, 0x0100);
        snd_soc_update_bits(codec, WM8971_RDAC, 0x0100, 0x0100);
@@ -672,26 +647,13 @@ static int wm8971_probe(struct snd_soc_codec *codec)
        snd_soc_update_bits(codec, WM8971_LINVOL, 0x0100, 0x0100);
        snd_soc_update_bits(codec, WM8971_RINVOL, 0x0100, 0x0100);
-        return ret;
-}
-/* power down chip */
-static int wm8971_remove(struct snd_soc_codec *codec)
-{
-        wm8971_set_bias_level(codec, SND_SOC_BIAS_OFF);
-        if (wm8971_workq)
-                destroy_workqueue(wm8971_workq);
        return 0;
 }
 static struct snd_soc_codec_driver soc_codec_dev_wm8971 = {
        .probe =        wm8971_probe,
-        .remove =       wm8971_remove,
-        .suspend =      wm8971_suspend,
-        .resume =       wm8971_resume,
        .set_bias_level = wm8971_set_bias_level,
+        .suspend_bias_off = true,
        .controls = wm8971_snd_controls,
        .num_controls = ARRAY_SIZE(wm8971_snd_controls),
@@ -715,7 +677,6 @@ static int wm8971_i2c_probe(struct i2c_client *i2c,
                            const struct i2c_device_id *id)
 {
        struct wm8971_priv *wm8971;
-        struct regmap *regmap;
        int ret;
        wm8971 = devm_kzalloc(&i2c->dev, sizeof(struct wm8971_priv),
@@ -723,9 +684,9 @@ static int wm8971_i2c_probe(struct i2c_client *i2c,
        if (wm8971 == NULL)
                return -ENOMEM;
-        regmap = devm_regmap_init_i2c(i2c, &wm8971_regmap);
+        wm8971->regmap = devm_regmap_init_i2c(i2c, &wm8971_regmap);
-        if (IS_ERR(regmap))
+        if (IS_ERR(wm8971->regmap))
-                return PTR_ERR(regmap);
+                return PTR_ERR(wm8971->regmap);
        i2c_set_clientdata(i2c, wm8971);
diff --git a/sound/soc/codecs/wm8996.c b/sound/soc/codecs/wm8996.c
index dc92d5e4e942..308748a022c5 100644
--- a/sound/soc/codecs/wm8996.c
+++ b/sound/soc/codecs/wm8996.c
@@ -2009,7 +2009,7 @@ static int wm8996_set_fll(struct snd_soc_codec *codec, int fll_id, int source,
        struct wm8996_priv *wm8996 = snd_soc_codec_get_drvdata(codec);
        struct i2c_client *i2c = to_i2c_client(codec->dev);
        struct _fll_div fll_div;
-        unsigned long timeout;
+        unsigned long timeout, time_left;
        int ret, reg, retry;
        /* Any change? */
@@ -2110,13 +2110,15 @@ static int wm8996_set_fll(struct snd_soc_codec *codec, int fll_id, int source,
        if (i2c->irq)
                timeout *= 10;
        else
-                timeout /= 2;
+                /* ensure timeout of atleast 1 jiffies */
+                timeout = timeout/2 ? : 1;
        for (retry = 0; retry < 10; retry++) {
-                ret = wait_for_completion_timeout(&wm8996->fll_lock,
+                time_left = wait_for_completion_timeout(&wm8996->fll_lock,
-                                                  timeout);
+                                                        timeout);
-                if (ret != 0) {
+                if (time_left != 0) {
                        WARN_ON(!i2c->irq);
+                        ret = 1;
                        break;
                }
diff --git a/sound/soc/davinci/davinci-evm.c b/sound/soc/davinci/davinci-evm.c
index b6bb5947a8a8..731fb0d86c6a 100644
--- a/sound/soc/davinci/davinci-evm.c
+++ b/sound/soc/davinci/davinci-evm.c
@@ -117,7 +117,6 @@ static const struct snd_soc_dapm_route audio_map[] = {
 static int evm_aic3x_init(struct snd_soc_pcm_runtime *rtd)
 {
        struct snd_soc_card *card = rtd->card;
-        struct snd_soc_codec *codec = rtd->codec;
        struct device_node *np = card->dev->of_node;
        int ret;
@@ -136,9 +135,9 @@ static int evm_aic3x_init(struct snd_soc_pcm_runtime *rtd)
        }
        /* not connected */
-        snd_soc_dapm_nc_pin(&codec->dapm, "MONO_LOUT");
+        snd_soc_dapm_nc_pin(&card->dapm, "MONO_LOUT");
-        snd_soc_dapm_nc_pin(&codec->dapm, "HPLCOM");
+        snd_soc_dapm_nc_pin(&card->dapm, "HPLCOM");
-        snd_soc_dapm_nc_pin(&codec->dapm, "HPRCOM");
+        snd_soc_dapm_nc_pin(&card->dapm, "HPRCOM");
        return 0;
 }
@@ -425,18 +424,8 @@ static int davinci_evm_probe(struct platform_device *pdev)
        return ret;
 }
-static int davinci_evm_remove(struct platform_device *pdev)
-{
-        struct snd_soc_card *card = platform_get_drvdata(pdev);
-        snd_soc_unregister_card(card);
-        return 0;
-}
 static struct platform_driver davinci_evm_driver = {
        .probe          = davinci_evm_probe,
-        .remove         = davinci_evm_remove,
        .driver         = {
                .name   = "davinci_evm",
                .pm     = &snd_soc_pm_ops,
diff --git a/sound/soc/davinci/davinci-mcasp.c b/sound/soc/davinci/davinci-mcasp.c
index 0c882995a357..bb4b78eada58 100644
--- a/sound/soc/davinci/davinci-mcasp.c
+++ b/sound/soc/davinci/davinci-mcasp.c
@@ -27,6 +27,7 @@
 #include <linux/of_platform.h>
 #include <linux/of_device.h>
 #include <linux/platform_data/davinci_asp.h>
+#include <linux/math64.h>
 #include <sound/asoundef.h>
 #include <sound/core.h>
@@ -62,6 +63,12 @@ struct davinci_mcasp_context {
        u32     config_regs[ARRAY_SIZE(context_regs)];
        u32     afifo_regs[2]; /* for read/write fifo control registers */
        u32     *xrsr_regs; /* for serializer configuration */
+        bool    pm_state;
+};
+struct davinci_mcasp_ruledata {
+        struct davinci_mcasp *mcasp;
+        int serializers;
 };
 struct davinci_mcasp {
@@ -98,6 +105,8 @@ struct davinci_mcasp {
 #ifdef CONFIG_PM_SLEEP
        struct davinci_mcasp_context context;
 #endif
+        struct davinci_mcasp_ruledata ruledata[2];
 };
 static inline void mcasp_set_bits(struct davinci_mcasp *mcasp, u32 offset,
@@ -519,7 +528,7 @@ static int davinci_mcasp_set_dai_fmt(struct snd_soc_dai *cpu_dai,
                mcasp_set_bits(mcasp, DAVINCI_MCASP_RXFMCTL_REG, FSRPOL);
        }
 out:
-        pm_runtime_put_sync(mcasp->dev);
+        pm_runtime_put(mcasp->dev);
        return ret;
 }
@@ -528,6 +537,7 @@ static int __davinci_mcasp_set_clkdiv(struct snd_soc_dai *dai, int div_id,
 {
        struct davinci_mcasp *mcasp = snd_soc_dai_get_drvdata(dai);
+        pm_runtime_get_sync(mcasp->dev);
        switch (div_id) {
        case 0:         /* MCLK divider */
                mcasp_mod_bits(mcasp, DAVINCI_MCASP_AHCLKXCTL_REG,
@@ -553,6 +563,7 @@ static int __davinci_mcasp_set_clkdiv(struct snd_soc_dai *dai, int div_id,
                return -EINVAL;
        }
+        pm_runtime_put(mcasp->dev);
        return 0;
 }
@@ -567,6 +578,7 @@ static int davinci_mcasp_set_sysclk(struct snd_soc_dai *dai, int clk_id,
 {
        struct davinci_mcasp *mcasp = snd_soc_dai_get_drvdata(dai);
+        pm_runtime_get_sync(mcasp->dev);
        if (dir == SND_SOC_CLOCK_OUT) {
                mcasp_set_bits(mcasp, DAVINCI_MCASP_AHCLKXCTL_REG, AHCLKXE);
                mcasp_set_bits(mcasp, DAVINCI_MCASP_AHCLKRCTL_REG, AHCLKRE);
@@ -579,6 +591,7 @@ static int davinci_mcasp_set_sysclk(struct snd_soc_dai *dai, int clk_id,
        mcasp->sysclk_freq = freq;
+        pm_runtime_put(mcasp->dev);
        return 0;
 }
@@ -863,6 +876,30 @@ static int mcasp_dit_hw_param(struct davinci_mcasp *mcasp,
        return 0;
 }
+static int davinci_mcasp_calc_clk_div(struct davinci_mcasp *mcasp,
+                                      unsigned int bclk_freq,
+                                      int *error_ppm)
+{
+        int div = mcasp->sysclk_freq / bclk_freq;
+        int rem = mcasp->sysclk_freq % bclk_freq;
+        if (rem != 0) {
+                if (div == 0 ||
+                    ((mcasp->sysclk_freq / div) - bclk_freq) >
+                    (bclk_freq - (mcasp->sysclk_freq / (div+1)))) {
+                        div++;
+                        rem = rem - bclk_freq;
+                }
+        }
+        if (error_ppm)
+                *error_ppm =
+                        (div*1000000 + (int)div64_long(1000000LL*rem,
+                                                       (int)bclk_freq))
+                        /div - 1000000;
+        return div;
+}
 static int davinci_mcasp_hw_params(struct snd_pcm_substream *substream,
                                        struct snd_pcm_hw_params *params,
                                        struct snd_soc_dai *cpu_dai)
@@ -878,16 +915,20 @@ static int davinci_mcasp_hw_params(struct snd_pcm_substream *substream,
         * the machine driver, we need to calculate the ratio.
         */
        if (mcasp->bclk_master && mcasp->bclk_div == 0 && mcasp->sysclk_freq) {
-                unsigned int bclk_freq = snd_soc_params_to_bclk(params);
+                int channels = params_channels(params);
-                unsigned int div = mcasp->sysclk_freq / bclk_freq;
+                int rate = params_rate(params);
-                if (mcasp->sysclk_freq % bclk_freq != 0) {
+                int sbits = params_width(params);
-                        if (((mcasp->sysclk_freq / div) - bclk_freq) >
+                int ppm, div;
-                            (bclk_freq - (mcasp->sysclk_freq / (div+1))))
-                                div++;
+                if (channels > mcasp->tdm_slots)
-                        dev_warn(mcasp->dev,
+                        channels = mcasp->tdm_slots;
-                                 "Inaccurate BCLK: %u Hz / %u != %u Hz\n",
-                                 mcasp->sysclk_freq, div, bclk_freq);
+                div = davinci_mcasp_calc_clk_div(mcasp, rate*sbits*channels,
-                }
+                                                 &ppm);
+                if (ppm)
+                        dev_info(mcasp->dev, "Sample-rate is off by %d PPM\n",
+                                 ppm);
                __davinci_mcasp_set_clkdiv(cpu_dai, 1, div, 0);
        }
@@ -969,10 +1010,126 @@ static int davinci_mcasp_trigger(struct snd_pcm_substream *substream,
        return ret;
 }
+static const unsigned int davinci_mcasp_dai_rates[] = {
+        8000, 11025, 16000, 22050, 32000, 44100, 48000, 64000,
+        88200, 96000, 176400, 192000,
+};
+#define DAVINCI_MAX_RATE_ERROR_PPM 1000
+static int davinci_mcasp_hw_rule_rate(struct snd_pcm_hw_params *params,
+                                      struct snd_pcm_hw_rule *rule)
+{
+        struct davinci_mcasp_ruledata *rd = rule->private;
+        struct snd_interval *ri =
+                hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
+        int sbits = params_width(params);
+        int channels = params_channels(params);
+        unsigned int list[ARRAY_SIZE(davinci_mcasp_dai_rates)];
+        int i, count = 0;
+        if (channels > rd->mcasp->tdm_slots)
+                channels = rd->mcasp->tdm_slots;
+        for (i = 0; i < ARRAY_SIZE(davinci_mcasp_dai_rates); i++) {
+                if (ri->min <= davinci_mcasp_dai_rates[i] &&
+                    ri->max >= davinci_mcasp_dai_rates[i]) {
+                        uint bclk_freq = sbits*channels*
+                                davinci_mcasp_dai_rates[i];
+                        int ppm;
+                        davinci_mcasp_calc_clk_div(rd->mcasp, bclk_freq, &ppm);
+                        if (abs(ppm) < DAVINCI_MAX_RATE_ERROR_PPM)
+                                list[count++] = davinci_mcasp_dai_rates[i];
+                }
+        }
+        dev_dbg(rd->mcasp->dev,
+                "%d frequencies (%d-%d) for %d sbits and %d channels\n",
+                count, ri->min, ri->max, sbits, channels);
+        return snd_interval_list(hw_param_interval(params, rule->var),
+                                 count, list, 0);
+}
+static int davinci_mcasp_hw_rule_format(struct snd_pcm_hw_params *params,
+                                        struct snd_pcm_hw_rule *rule)
+{
+        struct davinci_mcasp_ruledata *rd = rule->private;
+        struct snd_mask *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
+        struct snd_mask nfmt;
+        int rate = params_rate(params);
+        int channels = params_channels(params);
+        int i, count = 0;
+        snd_mask_none(&nfmt);
+        if (channels > rd->mcasp->tdm_slots)
+                channels = rd->mcasp->tdm_slots;
+        for (i = 0; i < SNDRV_PCM_FORMAT_LAST; i++) {
+                if (snd_mask_test(fmt, i)) {
+                        uint bclk_freq = snd_pcm_format_width(i)*channels*rate;
+                        int ppm;
+                        davinci_mcasp_calc_clk_div(rd->mcasp, bclk_freq, &ppm);
+                        if (abs(ppm) < DAVINCI_MAX_RATE_ERROR_PPM) {
+                                snd_mask_set(&nfmt, i);
+                                count++;
+                        }
+                }
+        }
+        dev_dbg(rd->mcasp->dev,
+                "%d possible sample format for %d Hz and %d channels\n",
+                count, rate, channels);
+        return snd_mask_refine(fmt, &nfmt);
+}
+static int davinci_mcasp_hw_rule_channels(struct snd_pcm_hw_params *params,
+                                          struct snd_pcm_hw_rule *rule)
+{
+        struct davinci_mcasp_ruledata *rd = rule->private;
+        struct snd_interval *ci =
+                hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
+        int sbits = params_width(params);
+        int rate = params_rate(params);
+        int max_chan_per_wire = rd->mcasp->tdm_slots < ci->max ?
+                rd->mcasp->tdm_slots : ci->max;
+        unsigned int list[ci->max - ci->min + 1];
+        int c1, c, count = 0;
+        for (c1 = ci->min; c1 <= max_chan_per_wire; c1++) {
+                uint bclk_freq = c1*sbits*rate;
+                int ppm;
+                davinci_mcasp_calc_clk_div(rd->mcasp, bclk_freq, &ppm);
+                if (abs(ppm) < DAVINCI_MAX_RATE_ERROR_PPM) {
+                        /* If we can use all tdm_slots, we can put any
+                           amount of channels to remaining wires as
+                           long as they fit in. */
+                        if (c1 == rd->mcasp->tdm_slots) {
+                                for (c = c1; c <= rd->serializers*c1 &&
+                                             c <= ci->max; c++)
+                                        list[count++] = c;
+                        } else {
+                                list[count++] = c1;
+                        }
+                }
+        }
+        dev_dbg(rd->mcasp->dev,
+                "%d possible channel counts (%d-%d) for %d Hz and %d sbits\n",
+                count, ci->min, ci->max, rate, sbits);
+        return snd_interval_list(hw_param_interval(params, rule->var),
+                                 count, list, 0);
+}
 static int davinci_mcasp_startup(struct snd_pcm_substream *substream,
                                 struct snd_soc_dai *cpu_dai)
 {
        struct davinci_mcasp *mcasp = snd_soc_dai_get_drvdata(cpu_dai);
+        struct davinci_mcasp_ruledata *ruledata =
+                                        &mcasp->ruledata[substream->stream];
        u32 max_channels = 0;
        int i, dir;
@@ -994,6 +1151,7 @@ static int davinci_mcasp_startup(struct snd_pcm_substream *substream,
                if (mcasp->serial_dir[i] == dir)
                        max_channels++;
        }
+        ruledata->serializers = max_channels;
        max_channels *= mcasp->tdm_slots;
        /*
         * If the already active stream has less channels than the calculated
@@ -1008,6 +1166,42 @@ static int davinci_mcasp_startup(struct snd_pcm_substream *substream,
        snd_pcm_hw_constraint_minmax(substream->runtime,
                                     SNDRV_PCM_HW_PARAM_CHANNELS,
                                     2, max_channels);
+        /*
+         * If we rely on implicit BCLK divider setting we should
+         * set constraints based on what we can provide.
+         */
+        if (mcasp->bclk_master && mcasp->bclk_div == 0 && mcasp->sysclk_freq) {
+                int ret;
+                ruledata->mcasp = mcasp;
+                ret = snd_pcm_hw_rule_add(substream->runtime, 0,
+                                          SNDRV_PCM_HW_PARAM_RATE,
+                                          davinci_mcasp_hw_rule_rate,
+                                          ruledata,
+                                          SNDRV_PCM_HW_PARAM_FORMAT,
+                                          SNDRV_PCM_HW_PARAM_CHANNELS, -1);
+                if (ret)
+                        return ret;
+                ret = snd_pcm_hw_rule_add(substream->runtime, 0,
+                                          SNDRV_PCM_HW_PARAM_FORMAT,
+                                          davinci_mcasp_hw_rule_format,
+                                          ruledata,
+                                          SNDRV_PCM_HW_PARAM_RATE,
+                                          SNDRV_PCM_HW_PARAM_CHANNELS, -1);
+                if (ret)
+                        return ret;
+                ret = snd_pcm_hw_rule_add(substream->runtime, 0,
+                                          SNDRV_PCM_HW_PARAM_CHANNELS,
+                                          davinci_mcasp_hw_rule_channels,
+                                          ruledata,
+                                          SNDRV_PCM_HW_PARAM_RATE,
+                                          SNDRV_PCM_HW_PARAM_FORMAT, -1);
+                if (ret)
+                        return ret;
+        }
        return 0;
 }
@@ -1053,6 +1247,10 @@ static int davinci_mcasp_suspend(struct snd_soc_dai *dai)
        u32 reg;
        int i;
+        context->pm_state = pm_runtime_enabled(mcasp->dev);
+        if (!context->pm_state)
+                pm_runtime_get_sync(mcasp->dev);
        for (i = 0; i < ARRAY_SIZE(context_regs); i++)
                context->config_regs[i] = mcasp_get_reg(mcasp, context_regs[i]);
@@ -1069,6 +1267,8 @@ static int davinci_mcasp_suspend(struct snd_soc_dai *dai)
                context->xrsr_regs[i] = mcasp_get_reg(mcasp,
                                                DAVINCI_MCASP_XRSRCTL_REG(i));
+        pm_runtime_put_sync(mcasp->dev);
        return 0;
 }
@@ -1079,6 +1279,8 @@ static int davinci_mcasp_resume(struct snd_soc_dai *dai)
        u32 reg;
        int i;
+        pm_runtime_get_sync(mcasp->dev);
        for (i = 0; i < ARRAY_SIZE(context_regs); i++)
                mcasp_set_reg(mcasp, context_regs[i], context->config_regs[i]);
@@ -1095,6 +1297,9 @@ static int davinci_mcasp_resume(struct snd_soc_dai *dai)
                mcasp_set_reg(mcasp, DAVINCI_MCASP_XRSRCTL_REG(i),
                              context->xrsr_regs[i]);
+        if (!context->pm_state)
+                pm_runtime_put_sync(mcasp->dev);
        return 0;
 }
 #else
@@ -1398,13 +1603,6 @@ static int davinci_mcasp_probe(struct platform_device *pdev)
        pm_runtime_enable(&pdev->dev);
-        ret = pm_runtime_get_sync(&pdev->dev);
-        if (IS_ERR_VALUE(ret)) {
-                dev_err(&pdev->dev, "pm_runtime_get_sync() failed\n");
-                pm_runtime_disable(&pdev->dev);
-                return ret;
-        }
        mcasp->base = devm_ioremap(&pdev->dev, mem->start, resource_size(mem));
        if (!mcasp->base) {
                dev_err(&pdev->dev, "ioremap failed\n");
@@ -1584,14 +1782,12 @@ static int davinci_mcasp_probe(struct platform_device *pdev)
        return 0;
 err:
-        pm_runtime_put_sync(&pdev->dev);
        pm_runtime_disable(&pdev->dev);
        return ret;
 }
 static int davinci_mcasp_remove(struct platform_device *pdev)
 {
-        pm_runtime_put_sync(&pdev->dev);
        pm_runtime_disable(&pdev->dev);
        return 0;
diff --git a/sound/soc/fsl/Kconfig b/sound/soc/fsl/Kconfig
index 081e406b3713..19c302b0d763 100644
--- a/sound/soc/fsl/Kconfig
+++ b/sound/soc/fsl/Kconfig
@@ -24,7 +24,7 @@ config SND_SOC_FSL_SAI
          in-tree drivers select it automatically.
 config SND_SOC_FSL_SSI
-        tristate "Synchronous Serial Interface module support"
+        tristate "Synchronous Serial Interface module (SSI) support"
        select SND_SOC_IMX_PCM_DMA if SND_IMX_SOC != n
        select SND_SOC_IMX_PCM_FIQ if SND_IMX_SOC != n && (MXC_TZIC || MXC_AVIC)
        select REGMAP_MMIO
@@ -35,7 +35,7 @@ config SND_SOC_FSL_SSI
          in-tree drivers select it automatically.
 config SND_SOC_FSL_SPDIF
-        tristate "Sony/Philips Digital Interface module support"
+        tristate "Sony/Philips Digital Interface (S/PDIF) module support"
        select REGMAP_MMIO
        select SND_SOC_IMX_PCM_DMA if SND_IMX_SOC != n
        select SND_SOC_IMX_PCM_FIQ if SND_IMX_SOC != n && (MXC_TZIC || MXC_AVIC)
diff --git a/sound/soc/fsl/fsl_ssi.c b/sound/soc/fsl/fsl_ssi.c
index 6b0c8f717ec2..e8bb8eef1d16 100644
--- a/sound/soc/fsl/fsl_ssi.c
+++ b/sound/soc/fsl/fsl_ssi.c
@@ -1288,7 +1288,7 @@ static int fsl_ssi_probe(struct platform_device *pdev)
        const struct of_device_id *of_id;
        const char *p, *sprop;
        const uint32_t *iprop;
-        struct resource res;
+        struct resource *res;
        void __iomem *iomem;
        char name[64];
@@ -1335,19 +1335,11 @@ static int fsl_ssi_probe(struct platform_device *pdev)
        }
        ssi_private->cpu_dai_drv.name = dev_name(&pdev->dev);
-        /* Get the addresses and IRQ */
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        ret = of_address_to_resource(np, 0, &res);
+        iomem = devm_ioremap_resource(&pdev->dev, res);
-        if (ret) {
+        if (IS_ERR(iomem))
-                dev_err(&pdev->dev, "could not determine device resources\n");
+                return PTR_ERR(iomem);
-                return ret;
+        ssi_private->ssi_phys = res->start;
-        }
-        ssi_private->ssi_phys = res.start;
-        iomem = devm_ioremap(&pdev->dev, res.start, resource_size(&res));
-        if (!iomem) {
-                dev_err(&pdev->dev, "could not map device resources\n");
-                return -ENOMEM;
-        }
        ret = of_property_match_string(np, "clock-names", "ipg");
        if (ret < 0) {
@@ -1393,8 +1385,8 @@ static int fsl_ssi_probe(struct platform_device *pdev)
                        return ret;
        }
-        ret = snd_soc_register_component(&pdev->dev, &fsl_ssi_component,
+        ret = devm_snd_soc_register_component(&pdev->dev, &fsl_ssi_component,
-                                         &ssi_private->cpu_dai_drv, 1);
+                                              &ssi_private->cpu_dai_drv, 1);
        if (ret) {
                dev_err(&pdev->dev, "failed to register DAI: %d\n", ret);
                goto error_asoc_register;
@@ -1407,13 +1399,13 @@ static int fsl_ssi_probe(struct platform_device *pdev)
                if (ret < 0) {
                        dev_err(&pdev->dev, "could not claim irq %u\n",
                                        ssi_private->irq);
-                        goto error_irq;
+                        goto error_asoc_register;
                }
        }
        ret = fsl_ssi_debugfs_create(&ssi_private->dbg_stats, &pdev->dev);
        if (ret)
-                goto error_irq;
+                goto error_asoc_register;
        /*
         * If codec-handle property is missing from SSI node, we assume
@@ -1454,9 +1446,6 @@ done:
 error_sound_card:
        fsl_ssi_debugfs_remove(&ssi_private->dbg_stats);
-error_irq:
-        snd_soc_unregister_component(&pdev->dev);
 error_asoc_register:
        if (ssi_private->soc->imx)
                fsl_ssi_imx_clean(pdev, ssi_private);
@@ -1472,7 +1461,6 @@ static int fsl_ssi_remove(struct platform_device *pdev)
        if (ssi_private->pdev)
                platform_device_unregister(ssi_private->pdev);
-        snd_soc_unregister_component(&pdev->dev);
        if (ssi_private->soc->imx)
                fsl_ssi_imx_clean(pdev, ssi_private);
diff --git a/sound/soc/fsl/mpc5200_psc_ac97.c b/sound/soc/fsl/mpc5200_psc_ac97.c
index 08d2a8069b0a..0bab76051fd8 100644
--- a/sound/soc/fsl/mpc5200_psc_ac97.c
+++ b/sound/soc/fsl/mpc5200_psc_ac97.c
@@ -326,7 +326,7 @@ static int psc_ac97_of_remove(struct platform_device *op)
 }
 /* Match table for of_platform binding */
-static struct of_device_id psc_ac97_match[] = {
+static const struct of_device_id psc_ac97_match[] = {
        { .compatible = "fsl,mpc5200-psc-ac97", },
        { .compatible = "fsl,mpc5200b-psc-ac97", },
        {}
diff --git a/sound/soc/fsl/mpc5200_psc_i2s.c b/sound/soc/fsl/mpc5200_psc_i2s.c
index 51fb0c00fe73..d8232943ccb6 100644
--- a/sound/soc/fsl/mpc5200_psc_i2s.c
+++ b/sound/soc/fsl/mpc5200_psc_i2s.c
@@ -217,7 +217,7 @@ static int psc_i2s_of_remove(struct platform_device *op)
 }
 /* Match table for of_platform binding */
-static struct of_device_id psc_i2s_match[] = {
+static const struct of_device_id psc_i2s_match[] = {
        { .compatible = "fsl,mpc5200-psc-i2s", },
        { .compatible = "fsl,mpc5200b-psc-i2s", },
        {}
diff --git a/sound/soc/fsl/pcm030-audio-fabric.c b/sound/soc/fsl/pcm030-audio-fabric.c
index c44459d24c50..ec731223cab3 100644
--- a/sound/soc/fsl/pcm030-audio-fabric.c
+++ b/sound/soc/fsl/pcm030-audio-fabric.c
@@ -113,7 +113,7 @@ static int pcm030_fabric_remove(struct platform_device *op)
        return ret;
 }
-static struct of_device_id pcm030_audio_match[] = {
+static const struct of_device_id pcm030_audio_match[] = {
        { .compatible = "phytec,pcm030-audio-fabric", },
        {}
 };
diff --git a/sound/soc/fsl/wm1133-ev1.c b/sound/soc/fsl/wm1133-ev1.c
index 0653aa83c927..b454972dce35 100644
--- a/sound/soc/fsl/wm1133-ev1.c
+++ b/sound/soc/fsl/wm1133-ev1.c
@@ -202,7 +202,6 @@ static struct snd_soc_jack_pin mic_jack_pins[] = {
 static int wm1133_ev1_init(struct snd_soc_pcm_runtime *rtd)
 {
        struct snd_soc_codec *codec = rtd->codec;
-        struct snd_soc_dapm_context *dapm = &codec->dapm;
        /* Headphone jack detection */
        snd_soc_card_jack_new(rtd->card, "Headphone", SND_JACK_HEADPHONE,
@@ -216,7 +215,7 @@ static int wm1133_ev1_init(struct snd_soc_pcm_runtime *rtd)
        wm8350_mic_jack_detect(codec, &mic_jack, SND_JACK_MICROPHONE,
                               SND_JACK_BTN_0);
-        snd_soc_dapm_force_enable_pin(dapm, "Mic Bias");
+        snd_soc_dapm_force_enable_pin(&rtd->card->dapm, "Mic Bias");
        return 0;
 }
diff --git a/sound/soc/generic/simple-card.c b/sound/soc/generic/simple-card.c
index c49a408fc7a6..33feee9ca8c3 100644
--- a/sound/soc/generic/simple-card.c
+++ b/sound/soc/generic/simple-card.c
@@ -125,14 +125,6 @@ static int __asoc_simple_card_dai_init(struct snd_soc_dai *dai,
 {
        int ret;
-        if (set->fmt) {
-                ret = snd_soc_dai_set_fmt(dai, set->fmt);
-                if (ret && ret != -ENOTSUPP) {
-                        dev_err(dai->dev, "simple-card: set_fmt error\n");
-                        goto err;
-                }
-        }
        if (set->sysclk) {
                ret = snd_soc_dai_set_sysclk(dai, 0, set->sysclk, 0);
                if (ret && ret != -ENOTSUPP) {
@@ -269,12 +261,10 @@ static int asoc_simple_card_parse_daifmt(struct device_node *node,
                                         struct device_node *codec,
                                         char *prefix, int idx)
 {
+        struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, idx);
        struct device *dev = simple_priv_to_dev(priv);
        struct device_node *bitclkmaster = NULL;
        struct device_node *framemaster = NULL;
-        struct simple_dai_props *dai_props = simple_priv_to_props(priv, idx);
-        struct asoc_simple_dai *cpu_dai = &dai_props->cpu_dai;
-        struct asoc_simple_dai *codec_dai = &dai_props->codec_dai;
        unsigned int daifmt;
        daifmt = snd_soc_of_parse_daifmt(node, prefix,
@@ -289,8 +279,7 @@ static int asoc_simple_card_parse_daifmt(struct device_node *node,
                 */
                dev_dbg(dev, "Revert to legacy daifmt parsing\n");
-                cpu_dai->fmt = codec_dai->fmt =
+                daifmt = snd_soc_of_parse_daifmt(codec, NULL, NULL, NULL) |
-                        snd_soc_of_parse_daifmt(codec, NULL, NULL, NULL) |
                        (daifmt & ~SND_SOC_DAIFMT_CLOCK_MASK);
        } else {
                if (codec == bitclkmaster)
@@ -299,11 +288,10 @@ static int asoc_simple_card_parse_daifmt(struct device_node *node,
                else
                        daifmt |= (codec == framemaster) ?
                                SND_SOC_DAIFMT_CBS_CFM : SND_SOC_DAIFMT_CBS_CFS;
-                cpu_dai->fmt    = daifmt;
-                codec_dai->fmt  = daifmt;
        }
+        dai_link->dai_fmt = daifmt;
        of_node_put(bitclkmaster);
        of_node_put(framemaster);
@@ -384,13 +372,12 @@ static int asoc_simple_card_dai_link_of(struct device_node *node,
        dai_link->init = asoc_simple_card_dai_init;
        dev_dbg(dev, "\tname : %s\n", dai_link->stream_name);
-        dev_dbg(dev, "\tcpu : %s / %04x / %d\n",
+        dev_dbg(dev, "\tformat : %04x\n", dai_link->dai_fmt);
+        dev_dbg(dev, "\tcpu : %s / %d\n",
                dai_link->cpu_dai_name,
-                dai_props->cpu_dai.fmt,
                dai_props->cpu_dai.sysclk);
-        dev_dbg(dev, "\tcodec : %s / %04x / %d\n",
+        dev_dbg(dev, "\tcodec : %s / %d\n",
                dai_link->codec_dai_name,
-                dai_props->codec_dai.fmt,
                dai_props->codec_dai.sysclk);
        /*
@@ -577,14 +564,13 @@ static int asoc_simple_card_probe(struct platform_device *pdev)
                dai_link->codec_name    = cinfo->codec;
                dai_link->cpu_dai_name  = cinfo->cpu_dai.name;
                dai_link->codec_dai_name = cinfo->codec_dai.name;
+                dai_link->dai_fmt       = cinfo->daifmt;
                dai_link->init          = asoc_simple_card_dai_init;
                memcpy(&priv->dai_props->cpu_dai, &cinfo->cpu_dai,
                                        sizeof(priv->dai_props->cpu_dai));
                memcpy(&priv->dai_props->codec_dai, &cinfo->codec_dai,
                                        sizeof(priv->dai_props->codec_dai));
-                priv->dai_props->cpu_dai.fmt    |= cinfo->daifmt;
-                priv->dai_props->codec_dai.fmt  |= cinfo->daifmt;
        }
        snd_soc_card_set_drvdata(&priv->snd_card, priv);
diff --git a/sound/soc/intel/Makefile b/sound/soc/intel/Makefile
index a8e53c45c6b6..cd9aee9871a3 100644
--- a/sound/soc/intel/Makefile
+++ b/sound/soc/intel/Makefile
@@ -1,42 +1,10 @@
 # Core support
-snd-soc-sst-dsp-objs := sst-dsp.o sst-firmware.o
+obj-$(CONFIG_SND_SOC_INTEL_SST) += common/
-snd-soc-sst-acpi-objs := sst-acpi.o
-snd-soc-sst-mfld-platform-objs := sst-mfld-platform-pcm.o \
-        sst-mfld-platform-compress.o sst-atom-controls.o
-snd-soc-mfld-machine-objs := mfld_machine.o
-obj-$(CONFIG_SND_SST_MFLD_PLATFORM) += snd-soc-sst-mfld-platform.o
-obj-$(CONFIG_SND_MFLD_MACHINE) += snd-soc-mfld-machine.o
-obj-$(CONFIG_SND_SOC_INTEL_SST) += snd-soc-sst-dsp.o
-obj-$(CONFIG_SND_SOC_INTEL_SST_ACPI) += snd-soc-sst-acpi.o
 # Platform Support
-snd-soc-sst-haswell-pcm-objs := \
+obj-$(CONFIG_SND_SOC_INTEL_HASWELL) += haswell/
-        sst-haswell-ipc.o sst-haswell-pcm.o sst-haswell-dsp.o
+obj-$(CONFIG_SND_SOC_INTEL_BAYTRAIL) += baytrail/
-snd-soc-sst-baytrail-pcm-objs := \
+obj-$(CONFIG_SND_SOC_INTEL_BAYTRAIL) += atom/
-        sst-baytrail-ipc.o sst-baytrail-pcm.o sst-baytrail-dsp.o
-obj-$(CONFIG_SND_SOC_INTEL_HASWELL) += snd-soc-sst-haswell-pcm.o
-obj-$(CONFIG_SND_SOC_INTEL_BAYTRAIL) += snd-soc-sst-baytrail-pcm.o
 # Machine support
-snd-soc-sst-haswell-objs := haswell.o
+obj-$(CONFIG_SND_SOC_INTEL_SST) += boards/
-snd-soc-sst-byt-rt5640-mach-objs := byt-rt5640.o
-snd-soc-sst-byt-max98090-mach-objs := byt-max98090.o
-snd-soc-sst-broadwell-objs := broadwell.o
-snd-soc-sst-bytcr-dpcm-rt5640-objs := bytcr_dpcm_rt5640.o
-snd-soc-sst-cht-bsw-rt5672-objs := cht_bsw_rt5672.o
-snd-soc-sst-cht-bsw-rt5645-objs := cht_bsw_rt5645.o
-obj-$(CONFIG_SND_SOC_INTEL_HASWELL_MACH) += snd-soc-sst-haswell.o
-obj-$(CONFIG_SND_SOC_INTEL_BYT_RT5640_MACH) += snd-soc-sst-byt-rt5640-mach.o
-obj-$(CONFIG_SND_SOC_INTEL_BYT_MAX98090_MACH) += snd-soc-sst-byt-max98090-mach.o
-obj-$(CONFIG_SND_SOC_INTEL_BROADWELL_MACH) += snd-soc-sst-broadwell.o
-obj-$(CONFIG_SND_SOC_INTEL_BYTCR_RT5640_MACH) += snd-soc-sst-bytcr-dpcm-rt5640.o
-obj-$(CONFIG_SND_SOC_INTEL_CHT_BSW_RT5672_MACH) += snd-soc-sst-cht-bsw-rt5672.o
-obj-$(CONFIG_SND_SOC_INTEL_CHT_BSW_RT5645_MACH) += snd-soc-sst-cht-bsw-rt5645.o
-# DSP driver
-obj-$(CONFIG_SND_SST_IPC) += sst/
diff --git a/sound/soc/intel/atom/Makefile b/sound/soc/intel/atom/Makefile
new file mode 100644
index 000000000000..ce8074fa6d66
--- /dev/null
+++ b/sound/soc/intel/atom/Makefile
@@ -0,0 +1,7 @@
+snd-soc-sst-mfld-platform-objs := sst-mfld-platform-pcm.o \
+                sst-mfld-platform-compress.o sst-atom-controls.o
+obj-$(CONFIG_SND_SST_MFLD_PLATFORM) += snd-soc-sst-mfld-platform.o
+# DSP driver
+obj-$(CONFIG_SND_SST_IPC) += sst/
diff --git a/sound/soc/intel/sst-atom-controls.c b/sound/soc/intel/atom/sst-atom-controls.c
index 90aa5c0476f3..90aa5c0476f3 100644
--- a/sound/soc/intel/sst-atom-controls.c
+++ b/sound/soc/intel/atom/sst-atom-controls.c
diff --git a/sound/soc/intel/sst-atom-controls.h b/sound/soc/intel/atom/sst-atom-controls.h
index daecc58f28af..daecc58f28af 100644
--- a/sound/soc/intel/sst-atom-controls.h
+++ b/sound/soc/intel/atom/sst-atom-controls.h
diff --git a/sound/soc/intel/sst-mfld-dsp.h b/sound/soc/intel/atom/sst-mfld-dsp.h
index 4257263157cd..4257263157cd 100644
--- a/sound/soc/intel/sst-mfld-dsp.h
+++ b/sound/soc/intel/atom/sst-mfld-dsp.h
diff --git a/sound/soc/intel/sst-mfld-platform-compress.c b/sound/soc/intel/atom/sst-mfld-platform-compress.c
index 395168986462..395168986462 100644
--- a/sound/soc/intel/sst-mfld-platform-compress.c
+++ b/sound/soc/intel/atom/sst-mfld-platform-compress.c
diff --git a/sound/soc/intel/sst-mfld-platform-pcm.c b/sound/soc/intel/atom/sst-mfld-platform-pcm.c
index 2fbaf2c75d17..2fbaf2c75d17 100644
--- a/sound/soc/intel/sst-mfld-platform-pcm.c
+++ b/sound/soc/intel/atom/sst-mfld-platform-pcm.c
diff --git a/sound/soc/intel/sst-mfld-platform.h b/sound/soc/intel/atom/sst-mfld-platform.h
index 9094314be2b0..9094314be2b0 100644
--- a/sound/soc/intel/sst-mfld-platform.h
+++ b/sound/soc/intel/atom/sst-mfld-platform.h
diff --git a/sound/soc/intel/sst/Makefile b/sound/soc/intel/atom/sst/Makefile
index fd21726361b5..fd21726361b5 100644
--- a/sound/soc/intel/sst/Makefile
+++ b/sound/soc/intel/atom/sst/Makefile
diff --git a/sound/soc/intel/sst/sst.c b/sound/soc/intel/atom/sst/sst.c
index 1a7eeec444b1..96c2e420cce6 100644
--- a/sound/soc/intel/sst/sst.c
+++ b/sound/soc/intel/atom/sst/sst.c
@@ -32,7 +32,7 @@
 #include <asm/platform_sst_audio.h>
 #include "../sst-mfld-platform.h"
 #include "sst.h"
-#include "../sst-dsp.h"
+#include "../../common/sst-dsp.h"
 MODULE_AUTHOR("Vinod Koul <vinod.koul@intel.com>");
 MODULE_AUTHOR("Harsha Priya <priya.harsha@intel.com>");
diff --git a/sound/soc/intel/sst/sst.h b/sound/soc/intel/atom/sst/sst.h
index 3f493862e98d..3f493862e98d 100644
--- a/sound/soc/intel/sst/sst.h
+++ b/sound/soc/intel/atom/sst/sst.h
diff --git a/sound/soc/intel/sst/sst_acpi.c b/sound/soc/intel/atom/sst/sst_acpi.c
index b782dfdcdbba..05f693083911 100644
--- a/sound/soc/intel/sst/sst_acpi.c
+++ b/sound/soc/intel/atom/sst/sst_acpi.c
@@ -39,7 +39,7 @@
 #include <acpi/actypes.h>
 #include <acpi/acpi_bus.h>
 #include "../sst-mfld-platform.h"
-#include "../sst-dsp.h"
+#include "../../common/sst-dsp.h"
 #include "sst.h"
 struct sst_machines {
@@ -309,7 +309,7 @@ static int sst_acpi_probe(struct platform_device *pdev)
        ctx->shim_regs64 = devm_kzalloc(ctx->dev, sizeof(*ctx->shim_regs64),
                                        GFP_KERNEL);
        if (!ctx->shim_regs64) {
-                return -ENOMEM;
+                ret = -ENOMEM;
                goto do_sst_cleanup;
        }
diff --git a/sound/soc/intel/sst/sst_drv_interface.c b/sound/soc/intel/atom/sst/sst_drv_interface.c
index f0e4b99b3aeb..7b50a9d17ec1 100644
--- a/sound/soc/intel/sst/sst_drv_interface.c
+++ b/sound/soc/intel/atom/sst/sst_drv_interface.c
@@ -32,7 +32,7 @@
 #include <asm/platform_sst_audio.h>
 #include "../sst-mfld-platform.h"
 #include "sst.h"
-#include "../sst-dsp.h"
+#include "../../common/sst-dsp.h"
@@ -381,7 +381,7 @@ static int sst_cdev_tstamp(struct device *dev, unsigned int str_id,
        tstamp->copied_total = fw_tstamp.ring_buffer_counter;
        tstamp->pcm_frames = fw_tstamp.frames_decoded;
        tstamp->pcm_io_frames = div_u64(fw_tstamp.hardware_counter,
-                        (u64)((stream->num_ch) * SST_GET_BYTES_PER_SAMPLE(24)));
+                        (u64)stream->num_ch * SST_GET_BYTES_PER_SAMPLE(24));
        tstamp->sampling_rate = fw_tstamp.sampling_frequency;
        dev_dbg(dev, "PCM  = %u\n", tstamp->pcm_io_frames);
diff --git a/sound/soc/intel/sst/sst_ipc.c b/sound/soc/intel/atom/sst/sst_ipc.c
index 484e60978477..5a278618466c 100644
--- a/sound/soc/intel/sst/sst_ipc.c
+++ b/sound/soc/intel/atom/sst/sst_ipc.c
@@ -32,7 +32,7 @@
 #include <asm/platform_sst_audio.h>
 #include "../sst-mfld-platform.h"
 #include "sst.h"
-#include "../sst-dsp.h"
+#include "../../common/sst-dsp.h"
 struct sst_block *sst_create_block(struct intel_sst_drv *ctx,
                                        u32 msg_id, u32 drv_id)
diff --git a/sound/soc/intel/sst/sst_loader.c b/sound/soc/intel/atom/sst/sst_loader.c
index e88907ae8b15..33917146d9c4 100644
--- a/sound/soc/intel/sst/sst_loader.c
+++ b/sound/soc/intel/atom/sst/sst_loader.c
@@ -37,7 +37,7 @@
 #include <asm/platform_sst_audio.h>
 #include "../sst-mfld-platform.h"
 #include "sst.h"
-#include "../sst-dsp.h"
+#include "../../common/sst-dsp.h"
 void memcpy32_toio(void __iomem *dst, const void *src, int count)
 {
diff --git a/sound/soc/intel/sst/sst_pci.c b/sound/soc/intel/atom/sst/sst_pci.c
index 3a0b3bf0af97..3a0b3bf0af97 100644
--- a/sound/soc/intel/sst/sst_pci.c
+++ b/sound/soc/intel/atom/sst/sst_pci.c
diff --git a/sound/soc/intel/sst/sst_pvt.c b/sound/soc/intel/atom/sst/sst_pvt.c
index 4b7720864492..adb32fefd693 100644
--- a/sound/soc/intel/sst/sst_pvt.c
+++ b/sound/soc/intel/atom/sst/sst_pvt.c
@@ -34,7 +34,7 @@
 #include <asm/platform_sst_audio.h>
 #include "../sst-mfld-platform.h"
 #include "sst.h"
-#include "../sst-dsp.h"
+#include "../../common/sst-dsp.h"
 int sst_shim_write(void __iomem *addr, int offset, int value)
 {
@@ -111,30 +111,6 @@ int sst_wait_interruptible(struct intel_sst_drv *sst_drv_ctx,
 }
-unsigned long long read_shim_data(struct intel_sst_drv *sst, int addr)
-{
-        unsigned long long val = 0;
-        switch (sst->dev_id) {
-        case SST_MRFLD_PCI_ID:
-        case SST_BYT_ACPI_ID:
-                val = sst_shim_read64(sst->shim, addr);
-                break;
-        }
-        return val;
-}
-void write_shim_data(struct intel_sst_drv *sst, int addr,
-                                unsigned long long data)
-{
-        switch (sst->dev_id) {
-        case SST_MRFLD_PCI_ID:
-        case SST_BYT_ACPI_ID:
-                sst_shim_write64(sst->shim, addr, (u64) data);
-                break;
-        }
-}
 /*
 * sst_wait_timeout - wait on event for timeout
 *
diff --git a/sound/soc/intel/sst/sst_stream.c b/sound/soc/intel/atom/sst/sst_stream.c
index dae2a41997aa..a74c64c7053c 100644
--- a/sound/soc/intel/sst/sst_stream.c
+++ b/sound/soc/intel/atom/sst/sst_stream.c
@@ -31,7 +31,7 @@
 #include <asm/platform_sst_audio.h>
 #include "../sst-mfld-platform.h"
 #include "sst.h"
-#include "../sst-dsp.h"
+#include "../../common/sst-dsp.h"
 int sst_alloc_stream_mrfld(struct intel_sst_drv *sst_drv_ctx, void *params)
 {
diff --git a/sound/soc/intel/baytrail/Makefile b/sound/soc/intel/baytrail/Makefile
new file mode 100644
index 000000000000..488408cadf6d
--- /dev/null
+++ b/sound/soc/intel/baytrail/Makefile
@@ -0,0 +1,4 @@
+snd-soc-sst-baytrail-pcm-objs := \
+                sst-baytrail-ipc.o sst-baytrail-pcm.o sst-baytrail-dsp.o
+obj-$(CONFIG_SND_SOC_INTEL_BAYTRAIL) += snd-soc-sst-baytrail-pcm.o
diff --git a/sound/soc/intel/sst-baytrail-dsp.c b/sound/soc/intel/baytrail/sst-baytrail-dsp.c
index 5a9e56700f31..01d023cc05dd 100644
--- a/sound/soc/intel/sst-baytrail-dsp.c
+++ b/sound/soc/intel/baytrail/sst-baytrail-dsp.c
@@ -22,8 +22,8 @@
 #include <linux/platform_device.h>
 #include <linux/firmware.h>
-#include "sst-dsp.h"
+#include "../common/sst-dsp.h"
-#include "sst-dsp-priv.h"
+#include "../common/sst-dsp-priv.h"
 #include "sst-baytrail-ipc.h"
 #define SST_BYT_FW_SIGNATURE_SIZE       4
diff --git a/sound/soc/intel/sst-baytrail-ipc.c b/sound/soc/intel/baytrail/sst-baytrail-ipc.c
index b4ad98c43e5c..1efb33b36303 100644
--- a/sound/soc/intel/sst-baytrail-ipc.c
+++ b/sound/soc/intel/baytrail/sst-baytrail-ipc.c
@@ -29,8 +29,9 @@
 #include <asm/div64.h>
 #include "sst-baytrail-ipc.h"
-#include "sst-dsp.h"
+#include "../common/sst-dsp.h"
-#include "sst-dsp-priv.h"
+#include "../common/sst-dsp-priv.h"
+#include "../common/sst-ipc.h"
 /* IPC message timeout */
 #define IPC_TIMEOUT_MSECS       300
@@ -142,23 +143,6 @@ struct sst_byt_fw_init {
        u8 debug_info;
 } __packed;
-/* driver internal IPC message structure */
-struct ipc_message {
-        struct list_head list;
-        u64 header;
-        /* direction wrt host CPU */
-        char tx_data[SST_BYT_IPC_MAX_PAYLOAD_SIZE];
-        size_t tx_size;
-        char rx_data[SST_BYT_IPC_MAX_PAYLOAD_SIZE];
-        size_t rx_size;
-        wait_queue_head_t waitq;
-        bool complete;
-        bool wait;
-        int errno;
-};
 struct sst_byt_stream;
 struct sst_byt;
@@ -195,14 +179,7 @@ struct sst_byt {
        struct sst_fw *fw;
        /* IPC messaging */
-        struct list_head tx_list;
+        struct sst_generic_ipc ipc;
-        struct list_head rx_list;
-        struct list_head empty_list;
-        wait_queue_head_t wait_txq;
-        struct task_struct *tx_thread;
-        struct kthread_worker kworker;
-        struct kthread_work kwork;
-        struct ipc_message *msg;
 };
 static inline u64 sst_byt_header(int msg_id, int data, bool large, int str_id)
@@ -246,209 +223,6 @@ static struct sst_byt_stream *sst_byt_get_stream(struct sst_byt *byt,
        return NULL;
 }
-static void sst_byt_ipc_shim_dbg(struct sst_byt *byt, const char *text)
-{
-        struct sst_dsp *sst = byt->dsp;
-        u64 isr, ipcd, imrx, ipcx;
-        ipcx = sst_dsp_shim_read64_unlocked(sst, SST_IPCX);
-        isr = sst_dsp_shim_read64_unlocked(sst, SST_ISRX);
-        ipcd = sst_dsp_shim_read64_unlocked(sst, SST_IPCD);
-        imrx = sst_dsp_shim_read64_unlocked(sst, SST_IMRX);
-        dev_err(byt->dev,
-                "ipc: --%s-- ipcx 0x%llx isr 0x%llx ipcd 0x%llx imrx 0x%llx\n",
-                text, ipcx, isr, ipcd, imrx);
-}
-/* locks held by caller */
-static struct ipc_message *sst_byt_msg_get_empty(struct sst_byt *byt)
-{
-        struct ipc_message *msg = NULL;
-        if (!list_empty(&byt->empty_list)) {
-                msg = list_first_entry(&byt->empty_list,
-                                       struct ipc_message, list);
-                list_del(&msg->list);
-        }
-        return msg;
-}
-static void sst_byt_ipc_tx_msgs(struct kthread_work *work)
-{
-        struct sst_byt *byt =
-                container_of(work, struct sst_byt, kwork);
-        struct ipc_message *msg;
-        u64 ipcx;
-        unsigned long flags;
-        spin_lock_irqsave(&byt->dsp->spinlock, flags);
-        if (list_empty(&byt->tx_list)) {
-                spin_unlock_irqrestore(&byt->dsp->spinlock, flags);
-                return;
-        }
-        /* if the DSP is busy we will TX messages after IRQ */
-        ipcx = sst_dsp_shim_read64_unlocked(byt->dsp, SST_IPCX);
-        if (ipcx & SST_BYT_IPCX_BUSY) {
-                spin_unlock_irqrestore(&byt->dsp->spinlock, flags);
-                return;
-        }
-        msg = list_first_entry(&byt->tx_list, struct ipc_message, list);
-        list_move(&msg->list, &byt->rx_list);
-        /* send the message */
-        if (msg->header & IPC_HEADER_LARGE(true))
-                sst_dsp_outbox_write(byt->dsp, msg->tx_data, msg->tx_size);
-        sst_dsp_shim_write64_unlocked(byt->dsp, SST_IPCX, msg->header);
-        spin_unlock_irqrestore(&byt->dsp->spinlock, flags);
-}
-static inline void sst_byt_tx_msg_reply_complete(struct sst_byt *byt,
-                                                 struct ipc_message *msg)
-{
-        msg->complete = true;
-        if (!msg->wait)
-                list_add_tail(&msg->list, &byt->empty_list);
-        else
-                wake_up(&msg->waitq);
-}
-static void sst_byt_drop_all(struct sst_byt *byt)
-{
-        struct ipc_message *msg, *tmp;
-        unsigned long flags;
-        /* drop all TX and Rx messages before we stall + reset DSP */
-        spin_lock_irqsave(&byt->dsp->spinlock, flags);
-        list_for_each_entry_safe(msg, tmp, &byt->tx_list, list) {
-                list_move(&msg->list, &byt->empty_list);
-        }
-        list_for_each_entry_safe(msg, tmp, &byt->rx_list, list) {
-                list_move(&msg->list, &byt->empty_list);
-        }
-        spin_unlock_irqrestore(&byt->dsp->spinlock, flags);
-}
-static int sst_byt_tx_wait_done(struct sst_byt *byt, struct ipc_message *msg,
-                                void *rx_data)
-{
-        unsigned long flags;
-        int ret;
-        /* wait for DSP completion */
-        ret = wait_event_timeout(msg->waitq, msg->complete,
-                                 msecs_to_jiffies(IPC_TIMEOUT_MSECS));
-        spin_lock_irqsave(&byt->dsp->spinlock, flags);
-        if (ret == 0) {
-                list_del(&msg->list);
-                sst_byt_ipc_shim_dbg(byt, "message timeout");
-                ret = -ETIMEDOUT;
-        } else {
-                /* copy the data returned from DSP */
-                if (msg->rx_size)
-                        memcpy(rx_data, msg->rx_data, msg->rx_size);
-                ret = msg->errno;
-        }
-        list_add_tail(&msg->list, &byt->empty_list);
-        spin_unlock_irqrestore(&byt->dsp->spinlock, flags);
-        return ret;
-}
-static int sst_byt_ipc_tx_message(struct sst_byt *byt, u64 header,
-                                  void *tx_data, size_t tx_bytes,
-                                  void *rx_data, size_t rx_bytes, int wait)
-{
-        unsigned long flags;
-        struct ipc_message *msg;
-        spin_lock_irqsave(&byt->dsp->spinlock, flags);
-        msg = sst_byt_msg_get_empty(byt);
-        if (msg == NULL) {
-                spin_unlock_irqrestore(&byt->dsp->spinlock, flags);
-                return -EBUSY;
-        }
-        msg->header = header;
-        msg->tx_size = tx_bytes;
-        msg->rx_size = rx_bytes;
-        msg->wait = wait;
-        msg->errno = 0;
-        msg->complete = false;
-        if (tx_bytes) {
-                /* msg content = lower 32-bit of the header + data */
-                *(u32 *)msg->tx_data = (u32)(header & (u32)-1);
-                memcpy(msg->tx_data + sizeof(u32), tx_data, tx_bytes);
-                msg->tx_size += sizeof(u32);
-        }
-        list_add_tail(&msg->list, &byt->tx_list);
-        spin_unlock_irqrestore(&byt->dsp->spinlock, flags);
-        queue_kthread_work(&byt->kworker, &byt->kwork);
-        if (wait)
-                return sst_byt_tx_wait_done(byt, msg, rx_data);
-        else
-                return 0;
-}
-static inline int sst_byt_ipc_tx_msg_wait(struct sst_byt *byt, u64 header,
-                                          void *tx_data, size_t tx_bytes,
-                                          void *rx_data, size_t rx_bytes)
-{
-        return sst_byt_ipc_tx_message(byt, header, tx_data, tx_bytes,
-                                      rx_data, rx_bytes, 1);
-}
-static inline int sst_byt_ipc_tx_msg_nowait(struct sst_byt *byt, u64 header,
-                                                void *tx_data, size_t tx_bytes)
-{
-        return sst_byt_ipc_tx_message(byt, header, tx_data, tx_bytes,
-                                      NULL, 0, 0);
-}
-static struct ipc_message *sst_byt_reply_find_msg(struct sst_byt *byt,
-                                                  u64 header)
-{
-        struct ipc_message *msg = NULL, *_msg;
-        u64 mask;
-        /* match reply to message sent based on msg and stream IDs */
-        mask = IPC_HEADER_MSG_ID_MASK |
-               IPC_HEADER_STR_ID_MASK << IPC_HEADER_STR_ID_SHIFT;
-        header &= mask;
-        if (list_empty(&byt->rx_list)) {
-                dev_err(byt->dev,
-                        "ipc: rx list is empty but received 0x%llx\n", header);
-                goto out;
-        }
-        list_for_each_entry(_msg, &byt->rx_list, list) {
-                if ((_msg->header & mask) == header) {
-                        msg = _msg;
-                        break;
-                }
-        }
-out:
-        return msg;
-}
 static void sst_byt_stream_update(struct sst_byt *byt, struct ipc_message *msg)
 {
        struct sst_byt_stream *stream;
@@ -477,7 +251,7 @@ static int sst_byt_process_reply(struct sst_byt *byt, u64 header)
 {
        struct ipc_message *msg;
-        msg = sst_byt_reply_find_msg(byt, header);
+        msg = sst_ipc_reply_find_msg(&byt->ipc, header);
        if (msg == NULL)
                return 1;
@@ -491,7 +265,7 @@ static int sst_byt_process_reply(struct sst_byt *byt, u64 header)
        list_del(&msg->list);
        /* wake up */
-        sst_byt_tx_msg_reply_complete(byt, msg);
+        sst_ipc_tx_msg_reply_complete(&byt->ipc, msg);
        return 1;
 }
@@ -538,6 +312,7 @@ static irqreturn_t sst_byt_irq_thread(int irq, void *context)
 {
        struct sst_dsp *sst = (struct sst_dsp *) context;
        struct sst_byt *byt = sst_dsp_get_thread_context(sst);
+        struct sst_generic_ipc *ipc = &byt->ipc;
        u64 header;
        unsigned long flags;
@@ -569,7 +344,7 @@ static irqreturn_t sst_byt_irq_thread(int irq, void *context)
        spin_unlock_irqrestore(&sst->spinlock, flags);
        /* continue to send any remaining messages... */
-        queue_kthread_work(&byt->kworker, &byt->kwork);
+        queue_kthread_work(&ipc->kworker, &ipc->kwork);
        return IRQ_HANDLED;
 }
@@ -656,7 +431,8 @@ int sst_byt_stream_commit(struct sst_byt *byt, struct sst_byt_stream *stream)
        header = sst_byt_header(IPC_IA_ALLOC_STREAM,
                                sizeof(*str_req) + sizeof(u32),
                                true, stream->str_id);
-        ret = sst_byt_ipc_tx_msg_wait(byt, header, str_req, sizeof(*str_req),
+        ret = sst_ipc_tx_message_wait(&byt->ipc, header, str_req,
+                                      sizeof(*str_req),
                                      reply, sizeof(*reply));
        if (ret < 0) {
                dev_err(byt->dev, "ipc: error stream commit failed\n");
@@ -679,7 +455,7 @@ int sst_byt_stream_free(struct sst_byt *byt, struct sst_byt_stream *stream)
                goto out;
        header = sst_byt_header(IPC_IA_FREE_STREAM, 0, false, stream->str_id);
-        ret = sst_byt_ipc_tx_msg_wait(byt, header, NULL, 0, NULL, 0);
+        ret = sst_ipc_tx_message_wait(&byt->ipc, header, NULL, 0, NULL, 0);
        if (ret < 0) {
                dev_err(byt->dev, "ipc: free stream %d failed\n",
                        stream->str_id);
@@ -703,9 +479,11 @@ static int sst_byt_stream_operations(struct sst_byt *byt, int type,
        header = sst_byt_header(type, 0, false, stream_id);
        if (wait)
-                return sst_byt_ipc_tx_msg_wait(byt, header, NULL, 0, NULL, 0);
+                return sst_ipc_tx_message_wait(&byt->ipc, header, NULL,
+                                                0, NULL, 0);
        else
-                return sst_byt_ipc_tx_msg_nowait(byt, header, NULL, 0);
+                return sst_ipc_tx_message_nowait(&byt->ipc, header,
+                                                NULL, 0);
 }
 /* stream ALSA trigger operations */
@@ -725,7 +503,7 @@ int sst_byt_stream_start(struct sst_byt *byt, struct sst_byt_stream *stream,
        tx_msg = &start_stream;
        size = sizeof(start_stream);
-        ret = sst_byt_ipc_tx_msg_nowait(byt, header, tx_msg, size);
+        ret = sst_ipc_tx_message_nowait(&byt->ipc, header, tx_msg, size);
        if (ret < 0)
                dev_err(byt->dev, "ipc: error failed to start stream %d\n",
                        stream->str_id);
@@ -790,23 +568,6 @@ int sst_byt_get_dsp_position(struct sst_byt *byt,
        return do_div(fw_tstamp.ring_buffer_counter, buffer_size);
 }
-static int msg_empty_list_init(struct sst_byt *byt)
-{
-        struct ipc_message *msg;
-        int i;
-        byt->msg = kzalloc(sizeof(*msg) * IPC_EMPTY_LIST_SIZE, GFP_KERNEL);
-        if (byt->msg == NULL)
-                return -ENOMEM;
-        for (i = 0; i < IPC_EMPTY_LIST_SIZE; i++) {
-                init_waitqueue_head(&byt->msg[i].waitq);
-                list_add(&byt->msg[i].list, &byt->empty_list);
-        }
-        return 0;
-}
 struct sst_dsp *sst_byt_get_dsp(struct sst_byt *byt)
 {
        return byt->dsp;
@@ -823,7 +584,7 @@ int sst_byt_dsp_suspend_late(struct device *dev, struct sst_pdata *pdata)
        dev_dbg(byt->dev, "dsp reset\n");
        sst_dsp_reset(byt->dsp);
-        sst_byt_drop_all(byt);
+        sst_ipc_drop_all(&byt->ipc);
        dev_dbg(byt->dev, "dsp in reset\n");
        dev_dbg(byt->dev, "free all blocks and unload fw\n");
@@ -876,9 +637,52 @@ int sst_byt_dsp_wait_for_ready(struct device *dev, struct sst_pdata *pdata)
 }
 EXPORT_SYMBOL_GPL(sst_byt_dsp_wait_for_ready);
+static void byt_tx_msg(struct sst_generic_ipc *ipc, struct ipc_message *msg)
+{
+        if (msg->header & IPC_HEADER_LARGE(true))
+                sst_dsp_outbox_write(ipc->dsp, msg->tx_data, msg->tx_size);
+        sst_dsp_shim_write64_unlocked(ipc->dsp, SST_IPCX, msg->header);
+}
+static void byt_shim_dbg(struct sst_generic_ipc *ipc, const char *text)
+{
+        struct sst_dsp *sst = ipc->dsp;
+        u64 isr, ipcd, imrx, ipcx;
+        ipcx = sst_dsp_shim_read64_unlocked(sst, SST_IPCX);
+        isr = sst_dsp_shim_read64_unlocked(sst, SST_ISRX);
+        ipcd = sst_dsp_shim_read64_unlocked(sst, SST_IPCD);
+        imrx = sst_dsp_shim_read64_unlocked(sst, SST_IMRX);
+        dev_err(ipc->dev,
+                "ipc: --%s-- ipcx 0x%llx isr 0x%llx ipcd 0x%llx imrx 0x%llx\n",
+                text, ipcx, isr, ipcd, imrx);
+}
+static void byt_tx_data_copy(struct ipc_message *msg, char *tx_data,
+        size_t tx_size)
+{
+        /* msg content = lower 32-bit of the header + data */
+        *(u32 *)msg->tx_data = (u32)(msg->header & (u32)-1);
+        memcpy(msg->tx_data + sizeof(u32), tx_data, tx_size);
+        msg->tx_size += sizeof(u32);
+}
+static u64 byt_reply_msg_match(u64 header, u64 *mask)
+{
+        /* match reply to message sent based on msg and stream IDs */
+        *mask = IPC_HEADER_MSG_ID_MASK |
+               IPC_HEADER_STR_ID_MASK << IPC_HEADER_STR_ID_SHIFT;
+        header &= *mask;
+        return header;
+}
 int sst_byt_dsp_init(struct device *dev, struct sst_pdata *pdata)
 {
        struct sst_byt *byt;
+        struct sst_generic_ipc *ipc;
        struct sst_fw *byt_sst_fw;
        struct sst_byt_fw_init init;
        int err;
@@ -889,39 +693,30 @@ int sst_byt_dsp_init(struct device *dev, struct sst_pdata *pdata)
        if (byt == NULL)
                return -ENOMEM;
-        byt->dev = dev;
+        ipc = &byt->ipc;
-        INIT_LIST_HEAD(&byt->stream_list);
+        ipc->dev = dev;
-        INIT_LIST_HEAD(&byt->tx_list);
+        ipc->ops.tx_msg = byt_tx_msg;
-        INIT_LIST_HEAD(&byt->rx_list);
+        ipc->ops.shim_dbg = byt_shim_dbg;
-        INIT_LIST_HEAD(&byt->empty_list);
+        ipc->ops.tx_data_copy = byt_tx_data_copy;
-        init_waitqueue_head(&byt->boot_wait);
+        ipc->ops.reply_msg_match = byt_reply_msg_match;
-        init_waitqueue_head(&byt->wait_txq);
-        err = msg_empty_list_init(byt);
+        err = sst_ipc_init(ipc);
-        if (err < 0)
+        if (err != 0)
-                return -ENOMEM;
+                goto ipc_init_err;
-        /* start the IPC message thread */
-        init_kthread_worker(&byt->kworker);
-        byt->tx_thread = kthread_run(kthread_worker_fn,
-                                     &byt->kworker, "%s",
-                                     dev_name(byt->dev));
-        if (IS_ERR(byt->tx_thread)) {
-                err = PTR_ERR(byt->tx_thread);
-                dev_err(byt->dev, "error failed to create message TX task\n");
-                goto err_free_msg;
-        }
-        init_kthread_work(&byt->kwork, sst_byt_ipc_tx_msgs);
+        INIT_LIST_HEAD(&byt->stream_list);
+        init_waitqueue_head(&byt->boot_wait);
        byt_dev.thread_context = byt;
        /* init SST shim */
        byt->dsp = sst_dsp_new(dev, &byt_dev, pdata);
        if (byt->dsp == NULL) {
                err = -ENODEV;
-                goto dsp_err;
+                goto dsp_new_err;
        }
+        ipc->dsp = byt->dsp;
        /* keep the DSP in reset state for base FW loading */
        sst_dsp_reset(byt->dsp);
@@ -961,10 +756,10 @@ boot_err:
        sst_fw_free(byt_sst_fw);
 fw_err:
        sst_dsp_free(byt->dsp);
-dsp_err:
+dsp_new_err:
-        kthread_stop(byt->tx_thread);
+        sst_ipc_fini(ipc);
-err_free_msg:
+ipc_init_err:
-        kfree(byt->msg);
+        kfree(byt);
        return err;
 }
@@ -977,7 +772,6 @@ void sst_byt_dsp_free(struct device *dev, struct sst_pdata *pdata)
        sst_dsp_reset(byt->dsp);
        sst_fw_free_all(byt->dsp);
        sst_dsp_free(byt->dsp);
-        kthread_stop(byt->tx_thread);
+        sst_ipc_fini(&byt->ipc);
-        kfree(byt->msg);
 }
 EXPORT_SYMBOL_GPL(sst_byt_dsp_free);
diff --git a/sound/soc/intel/sst-baytrail-ipc.h b/sound/soc/intel/baytrail/sst-baytrail-ipc.h
index 8faff6dcf25d..8faff6dcf25d 100644
--- a/sound/soc/intel/sst-baytrail-ipc.h
+++ b/sound/soc/intel/baytrail/sst-baytrail-ipc.h
diff --git a/sound/soc/intel/sst-baytrail-pcm.c b/sound/soc/intel/baytrail/sst-baytrail-pcm.c
index 224c49c9f135..79547bec558b 100644
--- a/sound/soc/intel/sst-baytrail-pcm.c
+++ b/sound/soc/intel/baytrail/sst-baytrail-pcm.c
@@ -20,8 +20,8 @@
 #include <sound/pcm_params.h>
 #include <sound/soc.h>
 #include "sst-baytrail-ipc.h"
-#include "sst-dsp-priv.h"
+#include "../common/sst-dsp-priv.h"
-#include "sst-dsp.h"
+#include "../common/sst-dsp.h"
 #define BYT_PCM_COUNT           2
diff --git a/sound/soc/intel/boards/Makefile b/sound/soc/intel/boards/Makefile
new file mode 100644
index 000000000000..f8237f0044eb
--- /dev/null
+++ b/sound/soc/intel/boards/Makefile
@@ -0,0 +1,15 @@
+snd-soc-sst-haswell-objs := haswell.o
+snd-soc-sst-byt-rt5640-mach-objs := byt-rt5640.o
+snd-soc-sst-byt-max98090-mach-objs := byt-max98090.o
+snd-soc-sst-broadwell-objs := broadwell.o
+snd-soc-sst-bytcr-rt5640-objs := bytcr_rt5640.o
+snd-soc-sst-cht-bsw-rt5672-objs := cht_bsw_rt5672.o
+snd-soc-sst-cht-bsw-rt5645-objs := cht_bsw_rt5645.o
+obj-$(CONFIG_SND_SOC_INTEL_HASWELL_MACH) += snd-soc-sst-haswell.o
+obj-$(CONFIG_SND_SOC_INTEL_BYT_RT5640_MACH) += snd-soc-sst-byt-rt5640-mach.o
+obj-$(CONFIG_SND_SOC_INTEL_BYT_MAX98090_MACH) += snd-soc-sst-byt-max98090-mach.o
+obj-$(CONFIG_SND_SOC_INTEL_BROADWELL_MACH) += snd-soc-sst-broadwell.o
+obj-$(CONFIG_SND_SOC_INTEL_BYTCR_RT5640_MACH) += snd-soc-sst-bytcr-rt5640.o
+obj-$(CONFIG_SND_SOC_INTEL_CHT_BSW_RT5672_MACH) += snd-soc-sst-cht-bsw-rt5672.o
+obj-$(CONFIG_SND_SOC_INTEL_CHT_BSW_RT5645_MACH) += snd-soc-sst-cht-bsw-rt5645.o
diff --git a/sound/soc/intel/broadwell.c b/sound/soc/intel/boards/broadwell.c
index fc5542034b9b..8bafaf6ceab1 100644
--- a/sound/soc/intel/broadwell.c
+++ b/sound/soc/intel/boards/broadwell.c
@@ -22,10 +22,10 @@
 #include <sound/jack.h>
 #include <sound/pcm_params.h>
-#include "sst-dsp.h"
+#include "../common/sst-dsp.h"
-#include "sst-haswell-ipc.h"
+#include "../haswell/sst-haswell-ipc.h"
-#include "../codecs/rt286.h"
+#include "../../codecs/rt286.h"
 static struct snd_soc_jack broadwell_headset;
 /* Headset jack detection DAPM pins */
@@ -219,6 +219,32 @@ static struct snd_soc_dai_link broadwell_rt286_dais[] = {
        },
 };
+static int broadwell_suspend(struct snd_soc_card *card){
+        struct snd_soc_codec *codec;
+        list_for_each_entry(codec, &card->codec_dev_list, card_list) {
+                if (!strcmp(codec->component.name, "i2c-INT343A:00")) {
+                        dev_dbg(codec->dev, "disabling jack detect before going to suspend.\n");
+                        rt286_mic_detect(codec, NULL);
+                        break;
+                }
+        }
+        return 0;
+}
+static int broadwell_resume(struct snd_soc_card *card){
+        struct snd_soc_codec *codec;
+        list_for_each_entry(codec, &card->codec_dev_list, card_list) {
+                if (!strcmp(codec->component.name, "i2c-INT343A:00")) {
+                        dev_dbg(codec->dev, "enabling jack detect for resume.\n");
+                        rt286_mic_detect(codec, &broadwell_headset);
+                        break;
+                }
+        }
+        return 0;
+}
 /* broadwell audio machine driver for WPT + RT286S */
 static struct snd_soc_card broadwell_rt286 = {
        .name = "broadwell-rt286",
@@ -232,6 +258,8 @@ static struct snd_soc_card broadwell_rt286 = {
        .dapm_routes = broadwell_rt286_map,
        .num_dapm_routes = ARRAY_SIZE(broadwell_rt286_map),
        .fully_routed = true,
+        .suspend_pre = broadwell_suspend,
+        .resume_post = broadwell_resume,
 };
 static int broadwell_audio_probe(struct platform_device *pdev)
diff --git a/sound/soc/intel/byt-max98090.c b/sound/soc/intel/boards/byt-max98090.c
index d8b1f038da1c..7ab8cc9fbfd5 100644
--- a/sound/soc/intel/byt-max98090.c
+++ b/sound/soc/intel/boards/byt-max98090.c
@@ -24,7 +24,7 @@
 #include <sound/pcm_params.h>
 #include <sound/soc.h>
 #include <sound/jack.h>
-#include "../codecs/max98090.h"
+#include "../../codecs/max98090.h"
 struct byt_max98090_private {
        struct snd_soc_jack jack;
diff --git a/sound/soc/intel/byt-rt5640.c b/sound/soc/intel/boards/byt-rt5640.c
index 354eaad886e1..ae89b9b966d9 100644
--- a/sound/soc/intel/byt-rt5640.c
+++ b/sound/soc/intel/boards/byt-rt5640.c
@@ -23,9 +23,9 @@
 #include <sound/pcm_params.h>
 #include <sound/soc.h>
 #include <sound/jack.h>
-#include "../codecs/rt5640.h"
+#include "../../codecs/rt5640.h"
-#include "sst-dsp.h"
+#include "../common/sst-dsp.h"
 static const struct snd_soc_dapm_widget byt_rt5640_widgets[] = {
        SND_SOC_DAPM_HP("Headphone", NULL),
diff --git a/sound/soc/intel/bytcr_dpcm_rt5640.c b/sound/soc/intel/boards/bytcr_rt5640.c
index 3b262d01c1b3..7f55d59024a8 100644
--- a/sound/soc/intel/bytcr_dpcm_rt5640.c
+++ b/sound/soc/intel/boards/bytcr_rt5640.c
@@ -26,8 +26,8 @@
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
 #include <sound/soc.h>
-#include "../codecs/rt5640.h"
+#include "../../codecs/rt5640.h"
-#include "sst-atom-controls.h"
+#include "../atom/sst-atom-controls.h"
 static const struct snd_soc_dapm_widget byt_dapm_widgets[] = {
        SND_SOC_DAPM_HP("Headphone", NULL),
diff --git a/sound/soc/intel/cht_bsw_rt5645.c b/sound/soc/intel/boards/cht_bsw_rt5645.c
index 012227997ed9..20a28b22e30f 100644
--- a/sound/soc/intel/cht_bsw_rt5645.c
+++ b/sound/soc/intel/boards/cht_bsw_rt5645.c
@@ -27,8 +27,8 @@
 #include <sound/pcm_params.h>
 #include <sound/soc.h>
 #include <sound/jack.h>
-#include "../codecs/rt5645.h"
+#include "../../codecs/rt5645.h"
-#include "sst-atom-controls.h"
+#include "../atom/sst-atom-controls.h"
 #define CHT_PLAT_CLK_3_HZ       19200000
 #define CHT_CODEC_DAI   "rt5645-aif1"
diff --git a/sound/soc/intel/cht_bsw_rt5672.c b/sound/soc/intel/boards/cht_bsw_rt5672.c
index bc8dcacd5e6a..2c9cc5be439e 100644
--- a/sound/soc/intel/cht_bsw_rt5672.c
+++ b/sound/soc/intel/boards/cht_bsw_rt5672.c
@@ -22,13 +22,28 @@
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
 #include <sound/soc.h>
-#include "../codecs/rt5670.h"
+#include <sound/jack.h>
-#include "sst-atom-controls.h"
+#include "../../codecs/rt5670.h"
+#include "../atom/sst-atom-controls.h"
 /* The platform clock #3 outputs 19.2Mhz clock to codec as I2S MCLK */
 #define CHT_PLAT_CLK_3_HZ       19200000
 #define CHT_CODEC_DAI   "rt5670-aif1"
+static struct snd_soc_jack cht_bsw_headset;
+/* Headset jack detection DAPM pins */
+static struct snd_soc_jack_pin cht_bsw_headset_pins[] = {
+        {
+                .pin = "Headset Mic",
+                .mask = SND_JACK_MICROPHONE,
+        },
+        {
+                .pin = "Headphone",
+                .mask = SND_JACK_HEADPHONE,
+        },
+};
 static inline struct snd_soc_dai *cht_get_codec_dai(struct snd_soc_card *card)
 {
        int i;
@@ -50,6 +65,7 @@ static int platform_clock_control(struct snd_soc_dapm_widget *w,
        struct snd_soc_dapm_context *dapm = w->dapm;
        struct snd_soc_card *card = dapm->card;
        struct snd_soc_dai *codec_dai;
+        int ret;
        codec_dai = cht_get_codec_dai(card);
        if (!codec_dai) {
@@ -57,17 +73,31 @@ static int platform_clock_control(struct snd_soc_dapm_widget *w,
                return -EIO;
        }
-        if (!SND_SOC_DAPM_EVENT_OFF(event))
+        if (SND_SOC_DAPM_EVENT_ON(event)) {
-                return 0;
+                /* set codec PLL source to the 19.2MHz platform clock (MCLK) */
+                ret = snd_soc_dai_set_pll(codec_dai, 0, RT5670_PLL1_S_MCLK,
-        /* Set codec sysclk source to its internal clock because codec PLL will
+                                CHT_PLAT_CLK_3_HZ, 48000 * 512);
-         * be off when idle and MCLK will also be off by ACPI when codec is
+                if (ret < 0) {
-         * runtime suspended. Codec needs clock for jack detection and button
+                        dev_err(card->dev, "can't set codec pll: %d\n", ret);
-         * press.
+                        return ret;
-         */
+                }
-        snd_soc_dai_set_sysclk(codec_dai, RT5670_SCLK_S_RCCLK,
-                               0, SND_SOC_CLOCK_IN);
+                /* set codec sysclk source to PLL */
+                ret = snd_soc_dai_set_sysclk(codec_dai, RT5670_SCLK_S_PLL1,
+                        48000 * 512, SND_SOC_CLOCK_IN);
+                if (ret < 0) {
+                        dev_err(card->dev, "can't set codec sysclk: %d\n", ret);
+                        return ret;
+                }
+        } else {
+                /* Set codec sysclk source to its internal clock because codec
+                 * PLL will be off when idle and MCLK will also be off by ACPI
+                 * when codec is runtime suspended. Codec needs clock for jack
+                 * detection and button press.
+                 */
+                snd_soc_dai_set_sysclk(codec_dai, RT5670_SCLK_S_RCCLK,
+                                       48000 * 512, SND_SOC_CLOCK_IN);
+        }
        return 0;
 }
@@ -77,7 +107,8 @@ static const struct snd_soc_dapm_widget cht_dapm_widgets[] = {
        SND_SOC_DAPM_MIC("Int Mic", NULL),
        SND_SOC_DAPM_SPK("Ext Spk", NULL),
        SND_SOC_DAPM_SUPPLY("Platform Clock", SND_SOC_NOPM, 0, 0,
-                        platform_clock_control, SND_SOC_DAPM_POST_PMD),
+                        platform_clock_control, SND_SOC_DAPM_PRE_PMU |
+                        SND_SOC_DAPM_POST_PMD),
 };
 static const struct snd_soc_dapm_route cht_audio_map[] = {
@@ -162,6 +193,15 @@ static int cht_codec_init(struct snd_soc_pcm_runtime *runtime)
                                | RT5670_AD_MONO_L_FILTER
                                | RT5670_AD_MONO_R_FILTER,
                                RT5670_CLK_SEL_I2S1_ASRC);
+        ret = snd_soc_card_jack_new(runtime->card, "Headset",
+                SND_JACK_HEADSET | SND_JACK_BTN_0 |
+                SND_JACK_BTN_1 | SND_JACK_BTN_2, &cht_bsw_headset,
+                cht_bsw_headset_pins, ARRAY_SIZE(cht_bsw_headset_pins));
+        if (ret)
+                return ret;
+        rt5670_set_jack_detect(codec, &cht_bsw_headset);
        return 0;
 }
@@ -251,6 +291,35 @@ static struct snd_soc_dai_link cht_dailink[] = {
        },
 };
+static int cht_suspend_pre(struct snd_soc_card *card)
+{
+        struct snd_soc_codec *codec;
+        list_for_each_entry(codec, &card->codec_dev_list, card_list) {
+                if (!strcmp(codec->component.name, "i2c-10EC5670:00")) {
+                        dev_dbg(codec->dev, "disabling jack detect before going to suspend.\n");
+                        rt5670_jack_suspend(codec);
+                        break;
+                }
+        }
+        return 0;
+}
+static int cht_resume_post(struct snd_soc_card *card)
+{
+        struct snd_soc_codec *codec;
+        list_for_each_entry(codec, &card->codec_dev_list, card_list) {
+                if (!strcmp(codec->component.name, "i2c-10EC5670:00")) {
+                        dev_dbg(codec->dev, "enabling jack detect for resume.\n");
+                        rt5670_jack_resume(codec);
+                        break;
+                }
+        }
+        return 0;
+}
 /* SoC card */
 static struct snd_soc_card snd_soc_card_cht = {
        .name = "cherrytrailcraudio",
@@ -262,6 +331,8 @@ static struct snd_soc_card snd_soc_card_cht = {
        .num_dapm_routes = ARRAY_SIZE(cht_audio_map),
        .controls = cht_mc_controls,
        .num_controls = ARRAY_SIZE(cht_mc_controls),
+        .suspend_pre = cht_suspend_pre,
+        .resume_post = cht_resume_post,
 };
 static int snd_cht_mc_probe(struct platform_device *pdev)
diff --git a/sound/soc/intel/haswell.c b/sound/soc/intel/boards/haswell.c
index 00fddd3f5dfb..22558572cb9c 100644
--- a/sound/soc/intel/haswell.c
+++ b/sound/soc/intel/boards/haswell.c
@@ -21,10 +21,10 @@
 #include <sound/soc.h>
 #include <sound/pcm_params.h>
-#include "sst-dsp.h"
+#include "../common/sst-dsp.h"
-#include "sst-haswell-ipc.h"
+#include "../haswell/sst-haswell-ipc.h"
-#include "../codecs/rt5640.h"
+#include "../../codecs/rt5640.h"
 /* Haswell ULT platforms have a Headphone and Mic jack */
 static const struct snd_soc_dapm_widget haswell_widgets[] = {
diff --git a/sound/soc/intel/mfld_machine.c b/sound/soc/intel/boards/mfld_machine.c
index 49c09a0add79..49c09a0add79 100644
--- a/sound/soc/intel/mfld_machine.c
+++ b/sound/soc/intel/boards/mfld_machine.c
diff --git a/sound/soc/intel/common/Makefile b/sound/soc/intel/common/Makefile
new file mode 100644
index 000000000000..f24154ca4e98
--- /dev/null
+++ b/sound/soc/intel/common/Makefile
@@ -0,0 +1,7 @@
+snd-soc-sst-dsp-objs := sst-dsp.o sst-firmware.o
+snd-soc-sst-acpi-objs := sst-acpi.o
+snd-soc-sst-ipc-objs := sst-ipc.o
+obj-$(CONFIG_SND_SOC_INTEL_SST) += snd-soc-sst-dsp.o snd-soc-sst-ipc.o
+obj-$(CONFIG_SND_SOC_INTEL_SST_ACPI) += snd-soc-sst-acpi.o
diff --git a/sound/soc/intel/sst-acpi.c b/sound/soc/intel/common/sst-acpi.c
index b3d84560fbb5..42f293f9c6e2 100644
--- a/sound/soc/intel/sst-acpi.c
+++ b/sound/soc/intel/common/sst-acpi.c
@@ -142,6 +142,7 @@ static int sst_acpi_probe(struct platform_device *pdev)
        sst_acpi->desc = desc;
        sst_acpi->mach = mach;
+        sst_pdata->resindex_dma_base = desc->resindex_dma_base;
        if (desc->resindex_dma_base >= 0) {
                sst_pdata->dma_engine = desc->dma_engine;
                sst_pdata->dma_base = desc->resindex_dma_base;
diff --git a/sound/soc/intel/sst-dsp-priv.h b/sound/soc/intel/common/sst-dsp-priv.h
index b9da030e312d..396d54510350 100644
--- a/sound/soc/intel/sst-dsp-priv.h
+++ b/sound/soc/intel/common/sst-dsp-priv.h
@@ -173,6 +173,16 @@ struct sst_module_runtime_context {
 };
 /*
+ * Audio DSP Module State
+ */
+enum sst_module_state {
+        SST_MODULE_STATE_UNLOADED = 0,  /* default state */
+        SST_MODULE_STATE_LOADED,
+        SST_MODULE_STATE_INITIALIZED,   /* and inactive */
+        SST_MODULE_STATE_ACTIVE,
+};
+/*
 * Audio DSP Generic Module.
 *
 * Each Firmware file can consist of 1..N modules. A module can span multiple
@@ -203,6 +213,9 @@ struct sst_module {
        struct list_head list;          /* DSP list of modules */
        struct list_head list_fw;       /* FW list of modules */
        struct list_head runtime_list;  /* list of runtime module objects*/
+        /* state */
+        enum sst_module_state state;
 };
 /*
diff --git a/sound/soc/intel/sst-dsp.c b/sound/soc/intel/common/sst-dsp.c
index 64e94212d2d2..64e94212d2d2 100644
--- a/sound/soc/intel/sst-dsp.c
+++ b/sound/soc/intel/common/sst-dsp.c
diff --git a/sound/soc/intel/sst-dsp.h b/sound/soc/intel/common/sst-dsp.h
index f291e32f0077..96aeb2556ad4 100644
--- a/sound/soc/intel/sst-dsp.h
+++ b/sound/soc/intel/common/sst-dsp.h
@@ -28,7 +28,6 @@
 /* Supported SST DMA Devices */
 #define SST_DMA_TYPE_DW         1
-#define SST_DMA_TYPE_MID        2
 /* autosuspend delay 5s*/
 #define SST_RUNTIME_SUSPEND_DELAY       (5 * 1000)
@@ -206,6 +205,7 @@ struct sst_pdata {
        const struct firmware *fw;
        /* DMA */
+        int resindex_dma_base; /* other fields invalid if equals to -1 */
        u32 dma_base;
        u32 dma_size;
        int dma_engine;
diff --git a/sound/soc/intel/sst-firmware.c b/sound/soc/intel/common/sst-firmware.c
index 5f71ef607a57..ebcca6dc48d1 100644
--- a/sound/soc/intel/sst-firmware.c
+++ b/sound/soc/intel/common/sst-firmware.c
@@ -221,8 +221,6 @@ int sst_dsp_dma_get_channel(struct sst_dsp *dsp, int chan_id)
        dma_cap_mask_t mask;
        int ret;
-        /* The Intel MID DMA engine driver needs the slave config set but
-         * Synopsis DMA engine driver safely ignores the slave config */
        dma_cap_zero(mask);
        dma_cap_set(DMA_SLAVE, mask);
        dma_cap_set(DMA_MEMCPY, mask);
@@ -271,15 +269,16 @@ int sst_dma_new(struct sst_dsp *sst)
        const char *dma_dev_name;
        int ret = 0;
+        if (sst->pdata->resindex_dma_base == -1)
+                /* DMA is not used, return and squelsh error messages */
+                return 0;
        /* configure the correct platform data for whatever DMA engine
        * is attached to the ADSP IP. */
        switch (sst->pdata->dma_engine) {
        case SST_DMA_TYPE_DW:
                dma_dev_name = "dw_dmac";
                break;
-        case SST_DMA_TYPE_MID:
-                dma_dev_name = "Intel MID DMA";
-                break;
        default:
                dev_err(sst->dev, "error: invalid DMA engine %d\n",
                        sst->pdata->dma_engine);
@@ -498,6 +497,7 @@ struct sst_module *sst_module_new(struct sst_fw *sst_fw,
        sst_module->scratch_size = template->scratch_size;
        sst_module->persistent_size = template->persistent_size;
        sst_module->entry = template->entry;
+        sst_module->state = SST_MODULE_STATE_UNLOADED;
        INIT_LIST_HEAD(&sst_module->block_list);
        INIT_LIST_HEAD(&sst_module->runtime_list);
diff --git a/sound/soc/intel/common/sst-ipc.c b/sound/soc/intel/common/sst-ipc.c
new file mode 100644
index 000000000000..4b62a553823c
--- /dev/null
+++ b/sound/soc/intel/common/sst-ipc.c
@@ -0,0 +1,294 @@
+/*
+ * Intel SST generic IPC Support
+ *
+ * Copyright (C) 2015, Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License version
+ * 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/list.h>
+#include <linux/wait.h>
+#include <linux/module.h>
+#include <linux/spinlock.h>
+#include <linux/device.h>
+#include <linux/slab.h>
+#include <linux/workqueue.h>
+#include <linux/sched.h>
+#include <linux/delay.h>
+#include <linux/platform_device.h>
+#include <linux/kthread.h>
+#include <sound/asound.h>
+#include "sst-dsp.h"
+#include "sst-dsp-priv.h"
+#include "sst-ipc.h"
+/* IPC message timeout (msecs) */
+#define IPC_TIMEOUT_MSECS       300
+#define IPC_EMPTY_LIST_SIZE     8
+/* locks held by caller */
+static struct ipc_message *msg_get_empty(struct sst_generic_ipc *ipc)
+{
+        struct ipc_message *msg = NULL;
+        if (!list_empty(&ipc->empty_list)) {
+                msg = list_first_entry(&ipc->empty_list, struct ipc_message,
+                        list);
+                list_del(&msg->list);
+        }
+        return msg;
+}
+static int tx_wait_done(struct sst_generic_ipc *ipc,
+        struct ipc_message *msg, void *rx_data)
+{
+        unsigned long flags;
+        int ret;
+        /* wait for DSP completion (in all cases atm inc pending) */
+        ret = wait_event_timeout(msg->waitq, msg->complete,
+                msecs_to_jiffies(IPC_TIMEOUT_MSECS));
+        spin_lock_irqsave(&ipc->dsp->spinlock, flags);
+        if (ret == 0) {
+                if (ipc->ops.shim_dbg != NULL)
+                        ipc->ops.shim_dbg(ipc, "message timeout");
+                list_del(&msg->list);
+                ret = -ETIMEDOUT;
+        } else {
+                /* copy the data returned from DSP */
+                if (msg->rx_size)
+                        memcpy(rx_data, msg->rx_data, msg->rx_size);
+                ret = msg->errno;
+        }
+        list_add_tail(&msg->list, &ipc->empty_list);
+        spin_unlock_irqrestore(&ipc->dsp->spinlock, flags);
+        return ret;
+}
+static int ipc_tx_message(struct sst_generic_ipc *ipc, u64 header,
+        void *tx_data, size_t tx_bytes, void *rx_data,
+        size_t rx_bytes, int wait)
+{
+        struct ipc_message *msg;
+        unsigned long flags;
+        spin_lock_irqsave(&ipc->dsp->spinlock, flags);
+        msg = msg_get_empty(ipc);
+        if (msg == NULL) {
+                spin_unlock_irqrestore(&ipc->dsp->spinlock, flags);
+                return -EBUSY;
+        }
+        msg->header = header;
+        msg->tx_size = tx_bytes;
+        msg->rx_size = rx_bytes;
+        msg->wait = wait;
+        msg->errno = 0;
+        msg->pending = false;
+        msg->complete = false;
+        if ((tx_bytes) && (ipc->ops.tx_data_copy != NULL))
+                ipc->ops.tx_data_copy(msg, tx_data, tx_bytes);
+        list_add_tail(&msg->list, &ipc->tx_list);
+        spin_unlock_irqrestore(&ipc->dsp->spinlock, flags);
+        queue_kthread_work(&ipc->kworker, &ipc->kwork);
+        if (wait)
+                return tx_wait_done(ipc, msg, rx_data);
+        else
+                return 0;
+}
+static int msg_empty_list_init(struct sst_generic_ipc *ipc)
+{
+        int i;
+        ipc->msg = kzalloc(sizeof(struct ipc_message) *
+                IPC_EMPTY_LIST_SIZE, GFP_KERNEL);
+        if (ipc->msg == NULL)
+                return -ENOMEM;
+        for (i = 0; i < IPC_EMPTY_LIST_SIZE; i++) {
+                init_waitqueue_head(&ipc->msg[i].waitq);
+                list_add(&ipc->msg[i].list, &ipc->empty_list);
+        }
+        return 0;
+}
+static void ipc_tx_msgs(struct kthread_work *work)
+{
+        struct sst_generic_ipc *ipc =
+                container_of(work, struct sst_generic_ipc, kwork);
+        struct ipc_message *msg;
+        unsigned long flags;
+        u64 ipcx;
+        spin_lock_irqsave(&ipc->dsp->spinlock, flags);
+        if (list_empty(&ipc->tx_list) || ipc->pending) {
+                spin_unlock_irqrestore(&ipc->dsp->spinlock, flags);
+                return;
+        }
+        /* if the DSP is busy, we will TX messages after IRQ.
+         * also postpone if we are in the middle of procesing completion irq*/
+        ipcx = sst_dsp_shim_read_unlocked(ipc->dsp, SST_IPCX);
+        if (ipcx & (SST_IPCX_BUSY | SST_IPCX_DONE)) {
+                spin_unlock_irqrestore(&ipc->dsp->spinlock, flags);
+                return;
+        }
+        msg = list_first_entry(&ipc->tx_list, struct ipc_message, list);
+        list_move(&msg->list, &ipc->rx_list);
+        if (ipc->ops.tx_msg != NULL)
+                ipc->ops.tx_msg(ipc, msg);
+        spin_unlock_irqrestore(&ipc->dsp->spinlock, flags);
+}
+int sst_ipc_tx_message_wait(struct sst_generic_ipc *ipc, u64 header,
+        void *tx_data, size_t tx_bytes, void *rx_data, size_t rx_bytes)
+{
+        return ipc_tx_message(ipc, header, tx_data, tx_bytes,
+                rx_data, rx_bytes, 1);
+}
+EXPORT_SYMBOL_GPL(sst_ipc_tx_message_wait);
+int sst_ipc_tx_message_nowait(struct sst_generic_ipc *ipc, u64 header,
+        void *tx_data, size_t tx_bytes)
+{
+        return ipc_tx_message(ipc, header, tx_data, tx_bytes,
+                NULL, 0, 0);
+}
+EXPORT_SYMBOL_GPL(sst_ipc_tx_message_nowait);
+struct ipc_message *sst_ipc_reply_find_msg(struct sst_generic_ipc *ipc,
+        u64 header)
+{
+        struct ipc_message *msg;
+        u64 mask;
+        if (ipc->ops.reply_msg_match != NULL)
+                header = ipc->ops.reply_msg_match(header, &mask);
+        if (list_empty(&ipc->rx_list)) {
+                dev_err(ipc->dev, "error: rx list empty but received 0x%llx\n",
+                        header);
+                return NULL;
+        }
+        list_for_each_entry(msg, &ipc->rx_list, list) {
+                if ((msg->header & mask) == header)
+                        return msg;
+        }
+        return NULL;
+}
+EXPORT_SYMBOL_GPL(sst_ipc_reply_find_msg);
+/* locks held by caller */
+void sst_ipc_tx_msg_reply_complete(struct sst_generic_ipc *ipc,
+        struct ipc_message *msg)
+{
+        msg->complete = true;
+        if (!msg->wait)
+                list_add_tail(&msg->list, &ipc->empty_list);
+        else
+                wake_up(&msg->waitq);
+}
+EXPORT_SYMBOL_GPL(sst_ipc_tx_msg_reply_complete);
+void sst_ipc_drop_all(struct sst_generic_ipc *ipc)
+{
+        struct ipc_message *msg, *tmp;
+        unsigned long flags;
+        int tx_drop_cnt = 0, rx_drop_cnt = 0;
+        /* drop all TX and Rx messages before we stall + reset DSP */
+        spin_lock_irqsave(&ipc->dsp->spinlock, flags);
+        list_for_each_entry_safe(msg, tmp, &ipc->tx_list, list) {
+                list_move(&msg->list, &ipc->empty_list);
+                tx_drop_cnt++;
+        }
+        list_for_each_entry_safe(msg, tmp, &ipc->rx_list, list) {
+                list_move(&msg->list, &ipc->empty_list);
+                rx_drop_cnt++;
+        }
+        spin_unlock_irqrestore(&ipc->dsp->spinlock, flags);
+        if (tx_drop_cnt || rx_drop_cnt)
+                dev_err(ipc->dev, "dropped IPC msg RX=%d, TX=%d\n",
+                        tx_drop_cnt, rx_drop_cnt);
+}
+EXPORT_SYMBOL_GPL(sst_ipc_drop_all);
+int sst_ipc_init(struct sst_generic_ipc *ipc)
+{
+        int ret;
+        INIT_LIST_HEAD(&ipc->tx_list);
+        INIT_LIST_HEAD(&ipc->rx_list);
+        INIT_LIST_HEAD(&ipc->empty_list);
+        init_waitqueue_head(&ipc->wait_txq);
+        ret = msg_empty_list_init(ipc);
+        if (ret < 0)
+                return -ENOMEM;
+        /* start the IPC message thread */
+        init_kthread_worker(&ipc->kworker);
+        ipc->tx_thread = kthread_run(kthread_worker_fn,
+                                        &ipc->kworker, "%s",
+                                        dev_name(ipc->dev));
+        if (IS_ERR(ipc->tx_thread)) {
+                dev_err(ipc->dev, "error: failed to create message TX task\n");
+                ret = PTR_ERR(ipc->tx_thread);
+                kfree(ipc->msg);
+                return ret;
+        }
+        init_kthread_work(&ipc->kwork, ipc_tx_msgs);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(sst_ipc_init);
+void sst_ipc_fini(struct sst_generic_ipc *ipc)
+{
+        if (ipc->tx_thread)
+                kthread_stop(ipc->tx_thread);
+        if (ipc->msg)
+                kfree(ipc->msg);
+}
+EXPORT_SYMBOL_GPL(sst_ipc_fini);
+/* Module information */
+MODULE_AUTHOR("Jin Yao");
+MODULE_DESCRIPTION("Intel SST IPC generic");
+MODULE_LICENSE("GPL v2");
diff --git a/sound/soc/intel/common/sst-ipc.h b/sound/soc/intel/common/sst-ipc.h
new file mode 100644
index 000000000000..125ea451a373
--- /dev/null
+++ b/sound/soc/intel/common/sst-ipc.h
@@ -0,0 +1,91 @@
+/*
+ * Intel SST generic IPC Support
+ *
+ * Copyright (C) 2015, Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License version
+ * 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+#ifndef __SST_GENERIC_IPC_H
+#define __SST_GENERIC_IPC_H
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/wait.h>
+#include <linux/list.h>
+#include <linux/workqueue.h>
+#include <linux/sched.h>
+#include <linux/kthread.h>
+#define IPC_MAX_MAILBOX_BYTES   256
+struct ipc_message {
+        struct list_head list;
+        u64 header;
+        /* direction wrt host CPU */
+        char tx_data[IPC_MAX_MAILBOX_BYTES];
+        size_t tx_size;
+        char rx_data[IPC_MAX_MAILBOX_BYTES];
+        size_t rx_size;
+        wait_queue_head_t waitq;
+        bool pending;
+        bool complete;
+        bool wait;
+        int errno;
+};
+struct sst_generic_ipc;
+struct sst_plat_ipc_ops {
+        void (*tx_msg)(struct sst_generic_ipc *, struct ipc_message *);
+        void (*shim_dbg)(struct sst_generic_ipc *, const char *);
+        void (*tx_data_copy)(struct ipc_message *, char *, size_t);
+        u64  (*reply_msg_match)(u64 header, u64 *mask);
+};
+/* SST generic IPC data */
+struct sst_generic_ipc {
+        struct device *dev;
+        struct sst_dsp *dsp;
+        /* IPC messaging */
+        struct list_head tx_list;
+        struct list_head rx_list;
+        struct list_head empty_list;
+        wait_queue_head_t wait_txq;
+        struct task_struct *tx_thread;
+        struct kthread_worker kworker;
+        struct kthread_work kwork;
+        bool pending;
+        struct ipc_message *msg;
+        struct sst_plat_ipc_ops ops;
+};
+int sst_ipc_tx_message_wait(struct sst_generic_ipc *ipc, u64 header,
+        void *tx_data, size_t tx_bytes, void *rx_data, size_t rx_bytes);
+int sst_ipc_tx_message_nowait(struct sst_generic_ipc *ipc, u64 header,
+        void *tx_data, size_t tx_bytes);
+struct ipc_message *sst_ipc_reply_find_msg(struct sst_generic_ipc *ipc,
+        u64 header);
+void sst_ipc_tx_msg_reply_complete(struct sst_generic_ipc *ipc,
+        struct ipc_message *msg);
+void sst_ipc_drop_all(struct sst_generic_ipc *ipc);
+int sst_ipc_init(struct sst_generic_ipc *ipc);
+void sst_ipc_fini(struct sst_generic_ipc *ipc);
+#endif
diff --git a/sound/soc/intel/haswell/Makefile b/sound/soc/intel/haswell/Makefile
new file mode 100644
index 000000000000..9c1723112d22
--- /dev/null
+++ b/sound/soc/intel/haswell/Makefile
@@ -0,0 +1,4 @@
+snd-soc-sst-haswell-pcm-objs := \
+                sst-haswell-ipc.o sst-haswell-pcm.o sst-haswell-dsp.o
+obj-$(CONFIG_SND_SOC_INTEL_HASWELL) += snd-soc-sst-haswell-pcm.o
diff --git a/sound/soc/intel/sst-haswell-dsp.c b/sound/soc/intel/haswell/sst-haswell-dsp.c
index 402b728c0a06..7f94920c8a4d 100644
--- a/sound/soc/intel/sst-haswell-dsp.c
+++ b/sound/soc/intel/haswell/sst-haswell-dsp.c
@@ -28,9 +28,9 @@
 #include <linux/firmware.h>
 #include <linux/pm_runtime.h>
-#include "sst-dsp.h"
+#include "../common/sst-dsp.h"
-#include "sst-dsp-priv.h"
+#include "../common/sst-dsp-priv.h"
-#include "sst-haswell-ipc.h"
+#include "../haswell/sst-haswell-ipc.h"
 #include <trace/events/hswadsp.h>
@@ -100,6 +100,7 @@ static int hsw_parse_module(struct sst_dsp *dsp, struct sst_fw *fw,
                && module->type != SST_HSW_MODULE_PCM
                && module->type != SST_HSW_MODULE_PCM_REFERENCE
                && module->type != SST_HSW_MODULE_PCM_CAPTURE
+                && module->type != SST_HSW_MODULE_WAVES
                && module->type != SST_HSW_MODULE_LPAL)
                return 0;
@@ -139,6 +140,7 @@ static int hsw_parse_module(struct sst_dsp *dsp, struct sst_fw *fw,
                        mod->type = SST_MEM_IRAM;
                        break;
                case SST_HSW_DRAM:
+                case SST_HSW_REGS:
                        ram = dsp->addr.lpe;
                        mod->offset = block->ram_offset;
                        mod->type = SST_MEM_DRAM;
@@ -169,6 +171,7 @@ static int hsw_parse_module(struct sst_dsp *dsp, struct sst_fw *fw,
                block = (void *)block + sizeof(*block) + block->size;
        }
+        mod->state = SST_MODULE_STATE_LOADED;
        return 0;
 }
diff --git a/sound/soc/intel/sst-haswell-ipc.c b/sound/soc/intel/haswell/sst-haswell-ipc.c
index 863a9ca34b8e..344a1e9bbce5 100644
--- a/sound/soc/intel/sst-haswell-ipc.c
+++ b/sound/soc/intel/haswell/sst-haswell-ipc.c
@@ -34,8 +34,9 @@
 #include <sound/asound.h>
 #include "sst-haswell-ipc.h"
-#include "sst-dsp.h"
+#include "../common/sst-dsp.h"
-#include "sst-dsp-priv.h"
+#include "../common/sst-dsp-priv.h"
+#include "../common/sst-ipc.h"
 /* Global Message - Generic */
 #define IPC_GLB_TYPE_SHIFT      24
@@ -79,6 +80,15 @@
 #define IPC_LOG_ID_MASK         (0xf << IPC_LOG_ID_SHIFT)
 #define IPC_LOG_ID(x)           (x << IPC_LOG_ID_SHIFT)
+/* Module Message */
+#define IPC_MODULE_OPERATION_SHIFT      20
+#define IPC_MODULE_OPERATION_MASK       (0xf << IPC_MODULE_OPERATION_SHIFT)
+#define IPC_MODULE_OPERATION(x) (x << IPC_MODULE_OPERATION_SHIFT)
+#define IPC_MODULE_ID_SHIFT     16
+#define IPC_MODULE_ID_MASK      (0xf << IPC_MODULE_ID_SHIFT)
+#define IPC_MODULE_ID(x)        (x << IPC_MODULE_ID_SHIFT)
 /* IPC message timeout (msecs) */
 #define IPC_TIMEOUT_MSECS       300
 #define IPC_BOOT_MSECS          200
@@ -115,6 +125,7 @@ enum ipc_glb_type {
        IPC_GLB_ENTER_DX_STATE = 12,
        IPC_GLB_GET_MIXER_STREAM_INFO = 13,     /* Request mixer stream params */
        IPC_GLB_DEBUG_LOG_MESSAGE = 14,         /* Message to or from the debug logger. */
+        IPC_GLB_MODULE_OPERATION = 15,          /* Message to loadable fw module */
        IPC_GLB_REQUEST_TRANSFER = 16,          /* < Request Transfer for host */
        IPC_GLB_MAX_IPC_MESSAGE_TYPE = 17,      /* Maximum message number */
 };
@@ -133,6 +144,16 @@ enum ipc_glb_reply {
        IPC_GLB_REPLY_SOURCE_NOT_STARTED = 10,  /* Source was not started. */
 };
+enum ipc_module_operation {
+        IPC_MODULE_NOTIFICATION = 0,
+        IPC_MODULE_ENABLE = 1,
+        IPC_MODULE_DISABLE = 2,
+        IPC_MODULE_GET_PARAMETER = 3,
+        IPC_MODULE_SET_PARAMETER = 4,
+        IPC_MODULE_GET_INFO = 5,
+        IPC_MODULE_MAX_MESSAGE
+};
 /* Stream Message - Types */
 enum ipc_str_operation {
        IPC_STR_RESET = 0,
@@ -190,23 +211,6 @@ struct sst_hsw_ipc_fw_ready {
        u8 fw_info[IPC_MAX_MAILBOX_BYTES - 5 * sizeof(u32)];
 } __attribute__((packed));
-struct ipc_message {
-        struct list_head list;
-        u32 header;
-        /* direction wrt host CPU */
-        char tx_data[IPC_MAX_MAILBOX_BYTES];
-        size_t tx_size;
-        char rx_data[IPC_MAX_MAILBOX_BYTES];
-        size_t rx_size;
-        wait_queue_head_t waitq;
-        bool pending;
-        bool complete;
-        bool wait;
-        int errno;
-};
 struct sst_hsw_stream;
 struct sst_hsw;
@@ -305,18 +309,19 @@ struct sst_hsw {
        bool shutdown;
        /* IPC messaging */
-        struct list_head tx_list;
+        struct sst_generic_ipc ipc;
-        struct list_head rx_list;
-        struct list_head empty_list;
-        wait_queue_head_t wait_txq;
-        struct task_struct *tx_thread;
-        struct kthread_worker kworker;
-        struct kthread_work kwork;
-        bool pending;
-        struct ipc_message *msg;
        /* FW log stream */
        struct sst_hsw_log_stream log_stream;
+        /* flags bit field to track module state when resume from RTD3,
+         * each bit represent state (enabled/disabled) of single module */
+        u32 enabled_modules_rtd3;
+        /* buffer to store parameter lines */
+        u32 param_idx_w;        /* write index */
+        u32 param_idx_r;        /* read index */
+        u8 param_buf[WAVES_PARAM_LINES][WAVES_PARAM_COUNT];
 };
 #define CREATE_TRACE_POINTS
@@ -352,6 +357,16 @@ static inline u32 msg_get_notify_reason(u32 msg)
        return (msg & IPC_STG_TYPE_MASK) >> IPC_STG_TYPE_SHIFT;
 }
+static inline u32 msg_get_module_operation(u32 msg)
+{
+        return (msg & IPC_MODULE_OPERATION_MASK) >> IPC_MODULE_OPERATION_SHIFT;
+}
+static inline u32 msg_get_module_id(u32 msg)
+{
+        return (msg & IPC_MODULE_ID_MASK) >> IPC_MODULE_ID_SHIFT;
+}
 u32 create_channel_map(enum sst_hsw_channel_config config)
 {
        switch (config) {
@@ -417,159 +432,6 @@ static struct sst_hsw_stream *get_stream_by_id(struct sst_hsw *hsw,
        return NULL;
 }
-static void ipc_shim_dbg(struct sst_hsw *hsw, const char *text)
-{
-        struct sst_dsp *sst = hsw->dsp;
-        u32 isr, ipcd, imrx, ipcx;
-        ipcx = sst_dsp_shim_read_unlocked(sst, SST_IPCX);
-        isr = sst_dsp_shim_read_unlocked(sst, SST_ISRX);
-        ipcd = sst_dsp_shim_read_unlocked(sst, SST_IPCD);
-        imrx = sst_dsp_shim_read_unlocked(sst, SST_IMRX);
-        dev_err(hsw->dev, "ipc: --%s-- ipcx 0x%8.8x isr 0x%8.8x ipcd 0x%8.8x imrx 0x%8.8x\n",
-                text, ipcx, isr, ipcd, imrx);
-}
-/* locks held by caller */
-static struct ipc_message *msg_get_empty(struct sst_hsw *hsw)
-{
-        struct ipc_message *msg = NULL;
-        if (!list_empty(&hsw->empty_list)) {
-                msg = list_first_entry(&hsw->empty_list, struct ipc_message,
-                        list);
-                list_del(&msg->list);
-        }
-        return msg;
-}
-static void ipc_tx_msgs(struct kthread_work *work)
-{
-        struct sst_hsw *hsw =
-                container_of(work, struct sst_hsw, kwork);
-        struct ipc_message *msg;
-        unsigned long flags;
-        u32 ipcx;
-        spin_lock_irqsave(&hsw->dsp->spinlock, flags);
-        if (list_empty(&hsw->tx_list) || hsw->pending) {
-                spin_unlock_irqrestore(&hsw->dsp->spinlock, flags);
-                return;
-        }
-        /* if the DSP is busy, we will TX messages after IRQ.
-         * also postpone if we are in the middle of procesing completion irq*/
-        ipcx = sst_dsp_shim_read_unlocked(hsw->dsp, SST_IPCX);
-        if (ipcx & (SST_IPCX_BUSY | SST_IPCX_DONE)) {
-                spin_unlock_irqrestore(&hsw->dsp->spinlock, flags);
-                return;
-        }
-        msg = list_first_entry(&hsw->tx_list, struct ipc_message, list);
-        list_move(&msg->list, &hsw->rx_list);
-        /* send the message */
-        sst_dsp_outbox_write(hsw->dsp, msg->tx_data, msg->tx_size);
-        sst_dsp_ipc_msg_tx(hsw->dsp, msg->header | SST_IPCX_BUSY);
-        spin_unlock_irqrestore(&hsw->dsp->spinlock, flags);
-}
-/* locks held by caller */
-static void tx_msg_reply_complete(struct sst_hsw *hsw, struct ipc_message *msg)
-{
-        msg->complete = true;
-        trace_ipc_reply("completed", msg->header);
-        if (!msg->wait)
-                list_add_tail(&msg->list, &hsw->empty_list);
-        else
-                wake_up(&msg->waitq);
-}
-static int tx_wait_done(struct sst_hsw *hsw, struct ipc_message *msg,
-        void *rx_data)
-{
-        unsigned long flags;
-        int ret;
-        /* wait for DSP completion (in all cases atm inc pending) */
-        ret = wait_event_timeout(msg->waitq, msg->complete,
-                msecs_to_jiffies(IPC_TIMEOUT_MSECS));
-        spin_lock_irqsave(&hsw->dsp->spinlock, flags);
-        if (ret == 0) {
-                ipc_shim_dbg(hsw, "message timeout");
-                trace_ipc_error("error message timeout for", msg->header);
-                list_del(&msg->list);
-                ret = -ETIMEDOUT;
-        } else {
-                /* copy the data returned from DSP */
-                if (msg->rx_size)
-                        memcpy(rx_data, msg->rx_data, msg->rx_size);
-                ret = msg->errno;
-        }
-        list_add_tail(&msg->list, &hsw->empty_list);
-        spin_unlock_irqrestore(&hsw->dsp->spinlock, flags);
-        return ret;
-}
-static int ipc_tx_message(struct sst_hsw *hsw, u32 header, void *tx_data,
-        size_t tx_bytes, void *rx_data, size_t rx_bytes, int wait)
-{
-        struct ipc_message *msg;
-        unsigned long flags;
-        spin_lock_irqsave(&hsw->dsp->spinlock, flags);
-        msg = msg_get_empty(hsw);
-        if (msg == NULL) {
-                spin_unlock_irqrestore(&hsw->dsp->spinlock, flags);
-                return -EBUSY;
-        }
-        if (tx_bytes)
-                memcpy(msg->tx_data, tx_data, tx_bytes);
-        msg->header = header;
-        msg->tx_size = tx_bytes;
-        msg->rx_size = rx_bytes;
-        msg->wait = wait;
-        msg->errno = 0;
-        msg->pending = false;
-        msg->complete = false;
-        list_add_tail(&msg->list, &hsw->tx_list);
-        spin_unlock_irqrestore(&hsw->dsp->spinlock, flags);
-        queue_kthread_work(&hsw->kworker, &hsw->kwork);
-        if (wait)
-                return tx_wait_done(hsw, msg, rx_data);
-        else
-                return 0;
-}
-static inline int ipc_tx_message_wait(struct sst_hsw *hsw, u32 header,
-        void *tx_data, size_t tx_bytes, void *rx_data, size_t rx_bytes)
-{
-        return ipc_tx_message(hsw, header, tx_data, tx_bytes, rx_data,
-                rx_bytes, 1);
-}
-static inline int ipc_tx_message_nowait(struct sst_hsw *hsw, u32 header,
-        void *tx_data, size_t tx_bytes)
-{
-        return ipc_tx_message(hsw, header, tx_data, tx_bytes, NULL, 0, 0);
-}
 static void hsw_fw_ready(struct sst_hsw *hsw, u32 header)
 {
        struct sst_hsw_ipc_fw_ready fw_ready;
@@ -604,7 +466,7 @@ static void hsw_fw_ready(struct sst_hsw *hsw, u32 header)
                /* log the FW version info got from the mailbox here. */
                memcpy(fw_info, fw_ready.fw_info, fw_ready.fw_info_size);
                pinfo = &fw_info[0];
-                for (i = 0; i < sizeof(tmp) / sizeof(char *); i++)
+                for (i = 0; i < ARRAY_SIZE(tmp); i++)
                        tmp[i] = strsep(&pinfo, " ");
                dev_info(hsw->dev, "FW loaded, mailbox readback FW info: type %s, - "
                        "version: %s.%s, build %s, source commit id: %s\n",
@@ -657,27 +519,6 @@ static void hsw_notification_work(struct work_struct *work)
        sst_dsp_shim_update_bits(hsw->dsp, SST_IMRX, SST_IMRX_BUSY, 0);
 }
-static struct ipc_message *reply_find_msg(struct sst_hsw *hsw, u32 header)
-{
-        struct ipc_message *msg;
-        /* clear reply bits & status bits */
-        header &= ~(IPC_STATUS_MASK | IPC_GLB_REPLY_MASK);
-        if (list_empty(&hsw->rx_list)) {
-                dev_err(hsw->dev, "error: rx list empty but received 0x%x\n",
-                        header);
-                return NULL;
-        }
-        list_for_each_entry(msg, &hsw->rx_list, list) {
-                if (msg->header == header)
-                        return msg;
-        }
-        return NULL;
-}
 static void hsw_stream_update(struct sst_hsw *hsw, struct ipc_message *msg)
 {
        struct sst_hsw_stream *stream;
@@ -716,7 +557,7 @@ static int hsw_process_reply(struct sst_hsw *hsw, u32 header)
        trace_ipc_reply("processing -->", header);
-        msg = reply_find_msg(hsw, header);
+        msg = sst_ipc_reply_find_msg(&hsw->ipc, header);
        if (msg == NULL) {
                trace_ipc_error("error: can't find message header", header);
                return -EIO;
@@ -727,14 +568,14 @@ static int hsw_process_reply(struct sst_hsw *hsw, u32 header)
        case IPC_GLB_REPLY_PENDING:
                trace_ipc_pending_reply("received", header);
                msg->pending = true;
-                hsw->pending = true;
+                hsw->ipc.pending = true;
                return 1;
        case IPC_GLB_REPLY_SUCCESS:
                if (msg->pending) {
                        trace_ipc_pending_reply("completed", header);
                        sst_dsp_inbox_read(hsw->dsp, msg->rx_data,
                                msg->rx_size);
-                        hsw->pending = false;
+                        hsw->ipc.pending = false;
                } else {
                        /* copy data from the DSP */
                        sst_dsp_outbox_read(hsw->dsp, msg->rx_data,
@@ -790,11 +631,36 @@ static int hsw_process_reply(struct sst_hsw *hsw, u32 header)
        /* wake up and return the error if we have waiters on this message ? */
        list_del(&msg->list);
-        tx_msg_reply_complete(hsw, msg);
+        sst_ipc_tx_msg_reply_complete(&hsw->ipc, msg);
        return 1;
 }
+static int hsw_module_message(struct sst_hsw *hsw, u32 header)
+{
+        u32 operation, module_id;
+        int handled = 0;
+        operation = msg_get_module_operation(header);
+        module_id = msg_get_module_id(header);
+        dev_dbg(hsw->dev, "received module message header: 0x%8.8x\n",
+                        header);
+        dev_dbg(hsw->dev, "operation: 0x%8.8x module_id: 0x%8.8x\n",
+                        operation, module_id);
+        switch (operation) {
+        case IPC_MODULE_NOTIFICATION:
+                dev_dbg(hsw->dev, "module notification received");
+                handled = 1;
+                break;
+        default:
+                handled = hsw_process_reply(hsw, header);
+                break;
+        }
+        return handled;
+}
 static int hsw_stream_message(struct sst_hsw *hsw, u32 header)
 {
        u32 stream_msg, stream_id, stage_type;
@@ -890,6 +756,9 @@ static int hsw_process_notification(struct sst_hsw *hsw)
        case IPC_GLB_DEBUG_LOG_MESSAGE:
                handled = hsw_log_message(hsw, header);
                break;
+        case IPC_GLB_MODULE_OPERATION:
+                handled = hsw_module_message(hsw, header);
+                break;
        default:
                dev_err(hsw->dev, "error: unexpected type %d hdr 0x%8.8x\n",
                        type, header);
@@ -903,6 +772,7 @@ static irqreturn_t hsw_irq_thread(int irq, void *context)
 {
        struct sst_dsp *sst = (struct sst_dsp *) context;
        struct sst_hsw *hsw = sst_dsp_get_thread_context(sst);
+        struct sst_generic_ipc *ipc = &hsw->ipc;
        u32 ipcx, ipcd;
        int handled;
        unsigned long flags;
@@ -949,7 +819,7 @@ static irqreturn_t hsw_irq_thread(int irq, void *context)
        spin_unlock_irqrestore(&sst->spinlock, flags);
        /* continue to send any remaining messages... */
-        queue_kthread_work(&hsw->kworker, &hsw->kwork);
+        queue_kthread_work(&ipc->kworker, &ipc->kwork);
        return IRQ_HANDLED;
 }
@@ -959,7 +829,8 @@ int sst_hsw_fw_get_version(struct sst_hsw *hsw,
 {
        int ret;
-        ret = ipc_tx_message_wait(hsw, IPC_GLB_TYPE(IPC_GLB_GET_FW_VERSION),
+        ret = sst_ipc_tx_message_wait(&hsw->ipc,
+                IPC_GLB_TYPE(IPC_GLB_GET_FW_VERSION),
                NULL, 0, version, sizeof(*version));
        if (ret < 0)
                dev_err(hsw->dev, "error: get version failed\n");
@@ -1023,7 +894,8 @@ int sst_hsw_stream_set_volume(struct sst_hsw *hsw,
                req->channel = channel;
        }
-        ret = ipc_tx_message_wait(hsw, header, req, sizeof(*req), NULL, 0);
+        ret = sst_ipc_tx_message_wait(&hsw->ipc, header, req,
+                sizeof(*req), NULL, 0);
        if (ret < 0) {
                dev_err(hsw->dev, "error: set stream volume failed\n");
                return ret;
@@ -1088,7 +960,8 @@ int sst_hsw_mixer_set_volume(struct sst_hsw *hsw, u32 stage_id, u32 channel,
        req.curve_type = hsw->curve_type;
        req.target_volume = volume;
-        ret = ipc_tx_message_wait(hsw, header, &req, sizeof(req), NULL, 0);
+        ret = sst_ipc_tx_message_wait(&hsw->ipc, header, &req,
+                sizeof(req), NULL, 0);
        if (ret < 0) {
                dev_err(hsw->dev, "error: set mixer volume failed\n");
                return ret;
@@ -1146,7 +1019,7 @@ int sst_hsw_stream_free(struct sst_hsw *hsw, struct sst_hsw_stream *stream)
        stream->free_req.stream_id = stream->reply.stream_hw_id;
        header = IPC_GLB_TYPE(IPC_GLB_FREE_STREAM);
-        ret = ipc_tx_message_wait(hsw, header, &stream->free_req,
+        ret = sst_ipc_tx_message_wait(&hsw->ipc, header, &stream->free_req,
                sizeof(stream->free_req), NULL, 0);
        if (ret < 0) {
                dev_err(hsw->dev, "error: free stream %d failed\n",
@@ -1338,8 +1211,8 @@ int sst_hsw_stream_commit(struct sst_hsw *hsw, struct sst_hsw_stream *stream)
        header = IPC_GLB_TYPE(IPC_GLB_ALLOCATE_STREAM);
-        ret = ipc_tx_message_wait(hsw, header, str_req, sizeof(*str_req),
+        ret = sst_ipc_tx_message_wait(&hsw->ipc, header, str_req,
-                reply, sizeof(*reply));
+                sizeof(*str_req), reply, sizeof(*reply));
        if (ret < 0) {
                dev_err(hsw->dev, "error: stream commit failed\n");
                return ret;
@@ -1388,7 +1261,8 @@ int sst_hsw_mixer_get_info(struct sst_hsw *hsw)
        trace_ipc_request("get global mixer info", 0);
-        ret = ipc_tx_message_wait(hsw, header, NULL, 0, reply, sizeof(*reply));
+        ret = sst_ipc_tx_message_wait(&hsw->ipc, header, NULL, 0,
+                reply, sizeof(*reply));
        if (ret < 0) {
                dev_err(hsw->dev, "error: get stream info failed\n");
                return ret;
@@ -1409,9 +1283,10 @@ static int sst_hsw_stream_operations(struct sst_hsw *hsw, int type,
        header |= (stream_id << IPC_STR_ID_SHIFT);
        if (wait)
-                return ipc_tx_message_wait(hsw, header, NULL, 0, NULL, 0);
+                return sst_ipc_tx_message_wait(&hsw->ipc, header,
+                        NULL, 0, NULL, 0);
        else
-                return ipc_tx_message_nowait(hsw, header, NULL, 0);
+                return sst_ipc_tx_message_nowait(&hsw->ipc, header, NULL, 0);
 }
 /* Stream ALSA trigger operations */
@@ -1538,8 +1413,8 @@ int sst_hsw_device_set_config(struct sst_hsw *hsw,
        header = IPC_GLB_TYPE(IPC_GLB_SET_DEVICE_FORMATS);
-        ret = ipc_tx_message_wait(hsw, header, &config, sizeof(config),
+        ret = sst_ipc_tx_message_wait(&hsw->ipc, header, &config,
-                NULL, 0);
+                sizeof(config), NULL, 0);
        if (ret < 0)
                dev_err(hsw->dev, "error: set device formats failed\n");
@@ -1559,8 +1434,8 @@ int sst_hsw_dx_set_state(struct sst_hsw *hsw,
        trace_ipc_request("PM enter Dx state", state);
-        ret = ipc_tx_message_wait(hsw, header, &state_, sizeof(state_),
+        ret = sst_ipc_tx_message_wait(&hsw->ipc, header, &state_,
-                dx, sizeof(*dx));
+                sizeof(state_), dx, sizeof(*dx));
        if (ret < 0) {
                dev_err(hsw->dev, "ipc: error set dx state %d failed\n", state);
                return ret;
@@ -1703,32 +1578,6 @@ static int sst_hsw_dx_state_restore(struct sst_hsw *hsw)
        return 0;
 }
-static void sst_hsw_drop_all(struct sst_hsw *hsw)
-{
-        struct ipc_message *msg, *tmp;
-        unsigned long flags;
-        int tx_drop_cnt = 0, rx_drop_cnt = 0;
-        /* drop all TX and Rx messages before we stall + reset DSP */
-        spin_lock_irqsave(&hsw->dsp->spinlock, flags);
-        list_for_each_entry_safe(msg, tmp, &hsw->tx_list, list) {
-                list_move(&msg->list, &hsw->empty_list);
-                tx_drop_cnt++;
-        }
-        list_for_each_entry_safe(msg, tmp, &hsw->rx_list, list) {
-                list_move(&msg->list, &hsw->empty_list);
-                rx_drop_cnt++;
-        }
-        spin_unlock_irqrestore(&hsw->dsp->spinlock, flags);
-        if (tx_drop_cnt || rx_drop_cnt)
-                dev_err(hsw->dev, "dropped IPC msg RX=%d, TX=%d\n",
-                        tx_drop_cnt, rx_drop_cnt);
-}
 int sst_hsw_dsp_load(struct sst_hsw *hsw)
 {
        struct sst_dsp *dsp = hsw->dsp;
@@ -1808,7 +1657,7 @@ int sst_hsw_dsp_runtime_suspend(struct sst_hsw *hsw)
        if (ret < 0)
                return ret;
-        sst_hsw_drop_all(hsw);
+        sst_ipc_drop_all(&hsw->ipc);
        return 0;
 }
@@ -1844,6 +1693,8 @@ int sst_hsw_dsp_runtime_resume(struct sst_hsw *hsw)
        if (ret < 0)
                dev_err(dev, "error: audio DSP boot failure\n");
+        sst_hsw_init_module_state(hsw);
        ret = wait_event_timeout(hsw->boot_wait, hsw->boot_complete,
                msecs_to_jiffies(IPC_BOOT_MSECS));
        if (ret == 0) {
@@ -1864,26 +1715,345 @@ int sst_hsw_dsp_runtime_resume(struct sst_hsw *hsw)
 }
 #endif
-static int msg_empty_list_init(struct sst_hsw *hsw)
+struct sst_dsp *sst_hsw_get_dsp(struct sst_hsw *hsw)
 {
-        int i;
+        return hsw->dsp;
+}
-        hsw->msg = kzalloc(sizeof(struct ipc_message) *
+void sst_hsw_init_module_state(struct sst_hsw *hsw)
-                IPC_EMPTY_LIST_SIZE, GFP_KERNEL);
+{
-        if (hsw->msg == NULL)
+        struct sst_module *module;
-                return -ENOMEM;
+        enum sst_hsw_module_id id;
+        /* the base fw contains several modules */
+        for (id = SST_HSW_MODULE_BASE_FW; id < SST_HSW_MAX_MODULE_ID; id++) {
+                module = sst_module_get_from_id(hsw->dsp, id);
+                if (module) {
+                        /* module waves is active only after being enabled */
+                        if (id == SST_HSW_MODULE_WAVES)
+                                module->state = SST_MODULE_STATE_INITIALIZED;
+                        else
+                                module->state = SST_MODULE_STATE_ACTIVE;
+                }
+        }
+}
+bool sst_hsw_is_module_loaded(struct sst_hsw *hsw, u32 module_id)
+{
+        struct sst_module *module;
+        module = sst_module_get_from_id(hsw->dsp, module_id);
+        if (module == NULL || module->state == SST_MODULE_STATE_UNLOADED)
+                return false;
+        else
+                return true;
+}
+bool sst_hsw_is_module_active(struct sst_hsw *hsw, u32 module_id)
+{
+        struct sst_module *module;
+        module = sst_module_get_from_id(hsw->dsp, module_id);
+        if (module != NULL && module->state == SST_MODULE_STATE_ACTIVE)
+                return true;
+        else
+                return false;
+}
-        for (i = 0; i < IPC_EMPTY_LIST_SIZE; i++) {
+void sst_hsw_set_module_enabled_rtd3(struct sst_hsw *hsw, u32 module_id)
-                init_waitqueue_head(&hsw->msg[i].waitq);
+{
-                list_add(&hsw->msg[i].list, &hsw->empty_list);
+        hsw->enabled_modules_rtd3 |= (1 << module_id);
+}
+void sst_hsw_set_module_disabled_rtd3(struct sst_hsw *hsw, u32 module_id)
+{
+        hsw->enabled_modules_rtd3 &= ~(1 << module_id);
+}
+bool sst_hsw_is_module_enabled_rtd3(struct sst_hsw *hsw, u32 module_id)
+{
+        return hsw->enabled_modules_rtd3 & (1 << module_id);
+}
+void sst_hsw_reset_param_buf(struct sst_hsw *hsw)
+{
+        hsw->param_idx_w = 0;
+        hsw->param_idx_r = 0;
+        memset((void *)hsw->param_buf, 0, sizeof(hsw->param_buf));
+}
+int sst_hsw_store_param_line(struct sst_hsw *hsw, u8 *buf)
+{
+        /* save line to the first available position of param buffer */
+        if (hsw->param_idx_w > WAVES_PARAM_LINES - 1) {
+                dev_warn(hsw->dev, "warning: param buffer overflow!\n");
+                return -EPERM;
+        }
+        memcpy(hsw->param_buf[hsw->param_idx_w], buf, WAVES_PARAM_COUNT);
+        hsw->param_idx_w++;
+        return 0;
+}
+int sst_hsw_load_param_line(struct sst_hsw *hsw, u8 *buf)
+{
+        u8 id = 0;
+        /* read the first matching line from param buffer */
+        while (hsw->param_idx_r < WAVES_PARAM_LINES) {
+                id = hsw->param_buf[hsw->param_idx_r][0];
+                hsw->param_idx_r++;
+                if (buf[0] == id) {
+                        memcpy(buf, hsw->param_buf[hsw->param_idx_r],
+                                WAVES_PARAM_COUNT);
+                        break;
+                }
        }
+        if (hsw->param_idx_r > WAVES_PARAM_LINES - 1) {
+                dev_dbg(hsw->dev, "end of buffer, roll to the beginning\n");
+                hsw->param_idx_r = 0;
+                return 0;
+        }
+        return 0;
+}
+int sst_hsw_launch_param_buf(struct sst_hsw *hsw)
+{
+        int ret, idx;
+        if (!sst_hsw_is_module_active(hsw, SST_HSW_MODULE_WAVES)) {
+                dev_dbg(hsw->dev, "module waves is not active\n");
+                return 0;
+        }
+        /* put all param lines to DSP through ipc */
+        for (idx = 0; idx < hsw->param_idx_w; idx++) {
+                ret = sst_hsw_module_set_param(hsw,
+                        SST_HSW_MODULE_WAVES, 0, hsw->param_buf[idx][0],
+                        WAVES_PARAM_COUNT, hsw->param_buf[idx]);
+                if (ret < 0)
+                        return ret;
+        }
        return 0;
 }
-struct sst_dsp *sst_hsw_get_dsp(struct sst_hsw *hsw)
+int sst_hsw_module_load(struct sst_hsw *hsw,
+        u32 module_id, u32 instance_id, char *name)
 {
-        return hsw->dsp;
+        int ret = 0;
+        const struct firmware *fw = NULL;
+        struct sst_fw *hsw_sst_fw;
+        struct sst_module *module;
+        struct device *dev = hsw->dev;
+        struct sst_dsp *dsp = hsw->dsp;
+        dev_dbg(dev, "sst_hsw_module_load id=%d, name='%s'", module_id, name);
+        module = sst_module_get_from_id(dsp, module_id);
+        if (module == NULL) {
+                /* loading for the first time */
+                if (module_id == SST_HSW_MODULE_BASE_FW) {
+                        /* for base module: use fw requested in acpi probe */
+                        fw = dsp->pdata->fw;
+                        if (!fw) {
+                                dev_err(dev, "request Base fw failed\n");
+                                return -ENODEV;
+                        }
+                } else {
+                        /* try and load any other optional modules if they are
+                         * available. Use dev_info instead of dev_err in case
+                         * request firmware failed */
+                        ret = request_firmware(&fw, name, dev);
+                        if (ret) {
+                                dev_info(dev, "fw image %s not available(%d)\n",
+                                                name, ret);
+                                return ret;
+                        }
+                }
+                hsw_sst_fw = sst_fw_new(dsp, fw, hsw);
+                if (hsw_sst_fw  == NULL) {
+                        dev_err(dev, "error: failed to load firmware\n");
+                        ret = -ENOMEM;
+                        goto out;
+                }
+                module = sst_module_get_from_id(dsp, module_id);
+                if (module == NULL) {
+                        dev_err(dev, "error: no module %d in firmware %s\n",
+                                        module_id, name);
+                }
+        } else
+                dev_info(dev, "module %d (%s) already loaded\n",
+                                module_id, name);
+out:
+        /* release fw, but base fw should be released by acpi driver */
+        if (fw && module_id != SST_HSW_MODULE_BASE_FW)
+                release_firmware(fw);
+        return ret;
+}
+int sst_hsw_module_enable(struct sst_hsw *hsw,
+        u32 module_id, u32 instance_id)
+{
+        int ret;
+        u32 header = 0;
+        struct sst_hsw_ipc_module_config config;
+        struct sst_module *module;
+        struct sst_module_runtime *runtime;
+        struct device *dev = hsw->dev;
+        struct sst_dsp *dsp = hsw->dsp;
+        if (!sst_hsw_is_module_loaded(hsw, module_id)) {
+                dev_dbg(dev, "module %d not loaded\n", module_id);
+                return 0;
+        }
+        if (sst_hsw_is_module_active(hsw, module_id)) {
+                dev_info(dev, "module %d already enabled\n", module_id);
+                return 0;
+        }
+        module = sst_module_get_from_id(dsp, module_id);
+        if (module == NULL) {
+                dev_err(dev, "module %d not valid\n", module_id);
+                return -ENXIO;
+        }
+        runtime = sst_module_runtime_get_from_id(module, module_id);
+        if (runtime == NULL) {
+                dev_err(dev, "runtime %d not valid", module_id);
+                return -ENXIO;
+        }
+        header = IPC_GLB_TYPE(IPC_GLB_MODULE_OPERATION) |
+                        IPC_MODULE_OPERATION(IPC_MODULE_ENABLE) |
+                        IPC_MODULE_ID(module_id);
+        dev_dbg(dev, "module enable header: %x\n", header);
+        config.map.module_entries_count = 1;
+        config.map.module_entries[0].module_id = module->id;
+        config.map.module_entries[0].entry_point = module->entry;
+        config.persistent_mem.offset =
+                sst_dsp_get_offset(dsp,
+                        runtime->persistent_offset, SST_MEM_DRAM);
+        config.persistent_mem.size = module->persistent_size;
+        config.scratch_mem.offset =
+                sst_dsp_get_offset(dsp,
+                        dsp->scratch_offset, SST_MEM_DRAM);
+        config.scratch_mem.size = module->scratch_size;
+        dev_dbg(dev, "mod %d enable p:%d @ %x, s:%d @ %x, ep: %x",
+                config.map.module_entries[0].module_id,
+                config.persistent_mem.size,
+                config.persistent_mem.offset,
+                config.scratch_mem.size, config.scratch_mem.offset,
+                config.map.module_entries[0].entry_point);
+        ret = sst_ipc_tx_message_wait(&hsw->ipc, header,
+                        &config, sizeof(config), NULL, 0);
+        if (ret < 0)
+                dev_err(dev, "ipc: module enable failed - %d\n", ret);
+        else
+                module->state = SST_MODULE_STATE_ACTIVE;
+        return ret;
+}
+int sst_hsw_module_disable(struct sst_hsw *hsw,
+        u32 module_id, u32 instance_id)
+{
+        int ret;
+        u32 header;
+        struct sst_module *module;
+        struct device *dev = hsw->dev;
+        struct sst_dsp *dsp = hsw->dsp;
+        if (!sst_hsw_is_module_loaded(hsw, module_id)) {
+                dev_dbg(dev, "module %d not loaded\n", module_id);
+                return 0;
+        }
+        if (!sst_hsw_is_module_active(hsw, module_id)) {
+                dev_info(dev, "module %d already disabled\n", module_id);
+                return 0;
+        }
+        module = sst_module_get_from_id(dsp, module_id);
+        if (module == NULL) {
+                dev_err(dev, "module %d not valid\n", module_id);
+                return -ENXIO;
+        }
+        header = IPC_GLB_TYPE(IPC_GLB_MODULE_OPERATION) |
+                        IPC_MODULE_OPERATION(IPC_MODULE_DISABLE) |
+                        IPC_MODULE_ID(module_id);
+        ret = sst_ipc_tx_message_wait(&hsw->ipc, header,  NULL, 0, NULL, 0);
+        if (ret < 0)
+                dev_err(dev, "module disable failed - %d\n", ret);
+        else
+                module->state = SST_MODULE_STATE_INITIALIZED;
+        return ret;
+}
+int sst_hsw_module_set_param(struct sst_hsw *hsw,
+        u32 module_id, u32 instance_id, u32 parameter_id,
+        u32 param_size, char *param)
+{
+        int ret;
+        unsigned char *data = NULL;
+        u32 header = 0;
+        u32 payload_size = 0, transfer_parameter_size = 0;
+        dma_addr_t dma_addr = 0;
+        struct sst_hsw_transfer_parameter *parameter;
+        struct device *dev = hsw->dev;
+        header = IPC_GLB_TYPE(IPC_GLB_MODULE_OPERATION) |
+                        IPC_MODULE_OPERATION(IPC_MODULE_SET_PARAMETER) |
+                        IPC_MODULE_ID(module_id);
+        dev_dbg(dev, "sst_hsw_module_set_param header=%x\n", header);
+        payload_size = param_size +
+                sizeof(struct sst_hsw_transfer_parameter) -
+                sizeof(struct sst_hsw_transfer_list);
+        dev_dbg(dev, "parameter size : %d\n", param_size);
+        dev_dbg(dev, "payload size   : %d\n", payload_size);
+        if (payload_size <= SST_HSW_IPC_MAX_SHORT_PARAMETER_SIZE) {
+                /* short parameter, mailbox can contain data */
+                dev_dbg(dev, "transfer parameter size : %d\n",
+                        transfer_parameter_size);
+                transfer_parameter_size = ALIGN(payload_size, 4);
+                dev_dbg(dev, "transfer parameter aligned size : %d\n",
+                        transfer_parameter_size);
+                parameter = kzalloc(transfer_parameter_size, GFP_KERNEL);
+                if (parameter == NULL)
+                        return -ENOMEM;
+                memcpy(parameter->data, param, param_size);
+        } else {
+                dev_warn(dev, "transfer parameter size too large!");
+                return 0;
+        }
+        parameter->parameter_id = parameter_id;
+        parameter->data_size = param_size;
+        ret = sst_ipc_tx_message_wait(&hsw->ipc, header,
+                parameter, transfer_parameter_size , NULL, 0);
+        if (ret < 0)
+                dev_err(dev, "ipc: module set parameter failed - %d\n", ret);
+        kfree(parameter);
+        if (data)
+                dma_free_coherent(hsw->dsp->dma_dev,
+                        param_size, (void *)data, dma_addr);
+        return ret;
 }
 static struct sst_dsp_device hsw_dev = {
@@ -1891,10 +2061,48 @@ static struct sst_dsp_device hsw_dev = {
        .ops = &haswell_ops,
 };
+static void hsw_tx_msg(struct sst_generic_ipc *ipc, struct ipc_message *msg)
+{
+        /* send the message */
+        sst_dsp_outbox_write(ipc->dsp, msg->tx_data, msg->tx_size);
+        sst_dsp_ipc_msg_tx(ipc->dsp, msg->header);
+}
+static void hsw_shim_dbg(struct sst_generic_ipc *ipc, const char *text)
+{
+        struct sst_dsp *sst = ipc->dsp;
+        u32 isr, ipcd, imrx, ipcx;
+        ipcx = sst_dsp_shim_read_unlocked(sst, SST_IPCX);
+        isr = sst_dsp_shim_read_unlocked(sst, SST_ISRX);
+        ipcd = sst_dsp_shim_read_unlocked(sst, SST_IPCD);
+        imrx = sst_dsp_shim_read_unlocked(sst, SST_IMRX);
+        dev_err(ipc->dev,
+                "ipc: --%s-- ipcx 0x%8.8x isr 0x%8.8x ipcd 0x%8.8x imrx 0x%8.8x\n",
+                text, ipcx, isr, ipcd, imrx);
+}
+static void hsw_tx_data_copy(struct ipc_message *msg, char *tx_data,
+        size_t tx_size)
+{
+        memcpy(msg->tx_data, tx_data, tx_size);
+}
+static u64 hsw_reply_msg_match(u64 header, u64 *mask)
+{
+        /* clear reply bits & status bits */
+        header &= ~(IPC_STATUS_MASK | IPC_GLB_REPLY_MASK);
+        *mask = (u64)-1;
+        return header;
+}
 int sst_hsw_dsp_init(struct device *dev, struct sst_pdata *pdata)
 {
        struct sst_hsw_ipc_fw_version version;
        struct sst_hsw *hsw;
+        struct sst_generic_ipc *ipc;
        int ret;
        dev_dbg(dev, "initialising Audio DSP IPC\n");
@@ -1903,39 +2111,30 @@ int sst_hsw_dsp_init(struct device *dev, struct sst_pdata *pdata)
        if (hsw == NULL)
                return -ENOMEM;
-        hsw->dev = dev;
+        ipc = &hsw->ipc;
-        INIT_LIST_HEAD(&hsw->stream_list);
+        ipc->dev = dev;
-        INIT_LIST_HEAD(&hsw->tx_list);
+        ipc->ops.tx_msg = hsw_tx_msg;
-        INIT_LIST_HEAD(&hsw->rx_list);
+        ipc->ops.shim_dbg = hsw_shim_dbg;
-        INIT_LIST_HEAD(&hsw->empty_list);
+        ipc->ops.tx_data_copy = hsw_tx_data_copy;
-        init_waitqueue_head(&hsw->boot_wait);
+        ipc->ops.reply_msg_match = hsw_reply_msg_match;
-        init_waitqueue_head(&hsw->wait_txq);
-        ret = msg_empty_list_init(hsw);
-        if (ret < 0)
-                return -ENOMEM;
-        /* start the IPC message thread */
+        ret = sst_ipc_init(ipc);
-        init_kthread_worker(&hsw->kworker);
+        if (ret != 0)
-        hsw->tx_thread = kthread_run(kthread_worker_fn,
+                goto ipc_init_err;
-                                           &hsw->kworker, "%s",
-                                           dev_name(hsw->dev));
-        if (IS_ERR(hsw->tx_thread)) {
-                ret = PTR_ERR(hsw->tx_thread);
-                dev_err(hsw->dev, "error: failed to create message TX task\n");
-                goto err_free_msg;
-        }
-        init_kthread_work(&hsw->kwork, ipc_tx_msgs);
+        INIT_LIST_HEAD(&hsw->stream_list);
+        init_waitqueue_head(&hsw->boot_wait);
        hsw_dev.thread_context = hsw;
        /* init SST shim */
        hsw->dsp = sst_dsp_new(dev, &hsw_dev, pdata);
        if (hsw->dsp == NULL) {
                ret = -ENODEV;
-                goto dsp_err;
+                goto dsp_new_err;
        }
+        ipc->dsp = hsw->dsp;
        /* allocate DMA buffer for context storage */
        hsw->dx_context = dma_alloc_coherent(hsw->dsp->dma_dev,
                SST_HSW_DX_CONTEXT_SIZE, &hsw->dx_context_paddr, GFP_KERNEL);
@@ -1947,18 +2146,22 @@ int sst_hsw_dsp_init(struct device *dev, struct sst_pdata *pdata)
        /* keep the DSP in reset state for base FW loading */
        sst_dsp_reset(hsw->dsp);
-        hsw->sst_fw = sst_fw_new(hsw->dsp, pdata->fw, hsw);
+        /* load base module and other modules in base firmware image */
-        if (hsw->sst_fw == NULL) {
+        ret = sst_hsw_module_load(hsw, SST_HSW_MODULE_BASE_FW, 0, "Base");
-                ret = -ENODEV;
+        if (ret < 0)
-                dev_err(dev, "error: failed to load firmware\n");
                goto fw_err;
-        }
+        /* try to load module waves */
+        sst_hsw_module_load(hsw, SST_HSW_MODULE_WAVES, 0, "intel/IntcPP01.bin");
        /* allocate scratch mem regions */
        ret = sst_block_alloc_scratch(hsw->dsp);
        if (ret < 0)
                goto boot_err;
+        /* init param buffer */
+        sst_hsw_reset_param_buf(hsw);
        /* wait for DSP boot completion */
        sst_dsp_boot(hsw->dsp);
        ret = wait_event_timeout(hsw->boot_wait, hsw->boot_complete,
@@ -1971,6 +2174,9 @@ int sst_hsw_dsp_init(struct device *dev, struct sst_pdata *pdata)
                goto boot_err;
        }
+        /* init module state after boot */
+        sst_hsw_init_module_state(hsw);
        /* get the FW version */
        sst_hsw_fw_get_version(hsw, &version);
@@ -1986,17 +2192,16 @@ int sst_hsw_dsp_init(struct device *dev, struct sst_pdata *pdata)
 boot_err:
        sst_dsp_reset(hsw->dsp);
-        sst_fw_free(hsw->sst_fw);
+        sst_fw_free_all(hsw->dsp);
 fw_err:
        dma_free_coherent(hsw->dsp->dma_dev, SST_HSW_DX_CONTEXT_SIZE,
                        hsw->dx_context, hsw->dx_context_paddr);
 dma_err:
        sst_dsp_free(hsw->dsp);
-dsp_err:
+dsp_new_err:
-        kthread_stop(hsw->tx_thread);
+        sst_ipc_fini(ipc);
-err_free_msg:
+ipc_init_err:
-        kfree(hsw->msg);
+        kfree(hsw);
        return ret;
 }
 EXPORT_SYMBOL_GPL(sst_hsw_dsp_init);
@@ -2010,7 +2215,6 @@ void sst_hsw_dsp_free(struct device *dev, struct sst_pdata *pdata)
        dma_free_coherent(hsw->dsp->dma_dev, SST_HSW_DX_CONTEXT_SIZE,
                        hsw->dx_context, hsw->dx_context_paddr);
        sst_dsp_free(hsw->dsp);
-        kthread_stop(hsw->tx_thread);
+        sst_ipc_fini(&hsw->ipc);
-        kfree(hsw->msg);
 }
 EXPORT_SYMBOL_GPL(sst_hsw_dsp_free);
diff --git a/sound/soc/intel/sst-haswell-ipc.h b/sound/soc/intel/haswell/sst-haswell-ipc.h
index 858096041cb1..06d71aefa1fe 100644
--- a/sound/soc/intel/sst-haswell-ipc.h
+++ b/sound/soc/intel/haswell/sst-haswell-ipc.h
@@ -37,6 +37,9 @@
 #define SST_HSW_IPC_MAX_PAYLOAD_SIZE    400
 #define SST_HSW_MAX_INFO_SIZE           64
 #define SST_HSW_BUILD_HASH_LENGTH       40
+#define SST_HSW_IPC_MAX_SHORT_PARAMETER_SIZE    500
+#define WAVES_PARAM_COUNT               128
+#define WAVES_PARAM_LINES               160
 struct sst_hsw;
 struct sst_hsw_stream;
@@ -187,6 +190,28 @@ enum sst_hsw_performance_action {
        SST_HSW_PERF_STOP = 1,
 };
+struct sst_hsw_transfer_info {
+        uint32_t destination;       /* destination address */
+        uint32_t reverse:1;         /* if 1 data flows from destination */
+        uint32_t size:31;           /* transfer size in bytes.*/
+        uint16_t first_page_offset; /* offset to data in the first page. */
+        uint8_t  packed_pages;   /* page addresses. Each occupies 20 bits */
+} __attribute__((packed));
+struct sst_hsw_transfer_list {
+        uint32_t transfers_count;
+        struct sst_hsw_transfer_info transfers;
+} __attribute__((packed));
+struct sst_hsw_transfer_parameter {
+        uint32_t parameter_id;
+        uint32_t data_size;
+        union {
+                uint8_t data[1];
+                struct sst_hsw_transfer_list transfer_list;
+        };
+} __attribute__((packed));
 /* SST firmware module info */
 struct sst_hsw_module_info {
        u8 name[SST_HSW_MAX_INFO_SIZE];
@@ -215,6 +240,12 @@ struct sst_hsw_fx_enable {
        struct sst_hsw_memory_info persistent_mem;
 } __attribute__((packed));
+struct sst_hsw_ipc_module_config {
+        struct sst_hsw_module_map map;
+        struct sst_hsw_memory_info persistent_mem;
+        struct sst_hsw_memory_info scratch_mem;
+} __attribute__((packed));
 struct sst_hsw_get_fx_param {
        u32 parameter_id;
        u32 param_size;
@@ -467,6 +498,28 @@ int sst_hsw_dsp_init(struct device *dev, struct sst_pdata *pdata);
 void sst_hsw_dsp_free(struct device *dev, struct sst_pdata *pdata);
 struct sst_dsp *sst_hsw_get_dsp(struct sst_hsw *hsw);
+/* fw module function */
+void sst_hsw_init_module_state(struct sst_hsw *hsw);
+bool sst_hsw_is_module_loaded(struct sst_hsw *hsw, u32 module_id);
+bool sst_hsw_is_module_active(struct sst_hsw *hsw, u32 module_id);
+void sst_hsw_set_module_enabled_rtd3(struct sst_hsw *hsw, u32 module_id);
+void sst_hsw_set_module_disabled_rtd3(struct sst_hsw *hsw, u32 module_id);
+bool sst_hsw_is_module_enabled_rtd3(struct sst_hsw *hsw, u32 module_id);
+void sst_hsw_reset_param_buf(struct sst_hsw *hsw);
+int sst_hsw_store_param_line(struct sst_hsw *hsw, u8 *buf);
+int sst_hsw_load_param_line(struct sst_hsw *hsw, u8 *buf);
+int sst_hsw_launch_param_buf(struct sst_hsw *hsw);
+int sst_hsw_module_load(struct sst_hsw *hsw,
+        u32 module_id, u32 instance_id, char *name);
+int sst_hsw_module_enable(struct sst_hsw *hsw,
+        u32 module_id, u32 instance_id);
+int sst_hsw_module_disable(struct sst_hsw *hsw,
+        u32 module_id, u32 instance_id);
+int sst_hsw_module_set_param(struct sst_hsw *hsw,
+        u32 module_id, u32 instance_id, u32 parameter_id,
+        u32 param_size, char *param);
 /* runtime module management */
 struct sst_module_runtime *sst_hsw_runtime_module_create(struct sst_hsw *hsw,
        int mod_id, int offset);
diff --git a/sound/soc/intel/sst-haswell-pcm.c b/sound/soc/intel/haswell/sst-haswell-pcm.c
index 7e21e8f85885..23ae0400d6db 100644
--- a/sound/soc/intel/sst-haswell-pcm.c
+++ b/sound/soc/intel/haswell/sst-haswell-pcm.c
@@ -29,9 +29,9 @@
 #include <sound/tlv.h>
 #include <sound/compress_driver.h>
-#include "sst-haswell-ipc.h"
+#include "../haswell/sst-haswell-ipc.h"
-#include "sst-dsp-priv.h"
+#include "../common/sst-dsp-priv.h"
-#include "sst-dsp.h"
+#include "../common/sst-dsp.h"
 #define HSW_PCM_COUNT           6
 #define HSW_VOLUME_MAX          0x7FFFFFFF      /* 0dB */
@@ -137,6 +137,7 @@ struct hsw_priv_data {
        struct device *dev;
        enum hsw_pm_state pm_state;
        struct snd_soc_card *soc_card;
+        struct sst_module_runtime *runtime_waves; /* sound effect module */
        /* page tables */
        struct snd_dma_buffer dmab[HSW_PCM_COUNT][2];
@@ -318,6 +319,93 @@ static int hsw_volume_get(struct snd_kcontrol *kcontrol,
        return 0;
 }
+static int hsw_waves_switch_get(struct snd_kcontrol *kcontrol,
+                                struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_platform *platform = snd_soc_kcontrol_platform(kcontrol);
+        struct hsw_priv_data *pdata = snd_soc_platform_get_drvdata(platform);
+        struct sst_hsw *hsw = pdata->hsw;
+        enum sst_hsw_module_id id = SST_HSW_MODULE_WAVES;
+        ucontrol->value.integer.value[0] =
+                (sst_hsw_is_module_active(hsw, id) ||
+                sst_hsw_is_module_enabled_rtd3(hsw, id));
+        return 0;
+}
+static int hsw_waves_switch_put(struct snd_kcontrol *kcontrol,
+                                struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_platform *platform = snd_soc_kcontrol_platform(kcontrol);
+        struct hsw_priv_data *pdata = snd_soc_platform_get_drvdata(platform);
+        struct sst_hsw *hsw = pdata->hsw;
+        int ret = 0;
+        enum sst_hsw_module_id id = SST_HSW_MODULE_WAVES;
+        bool switch_on = (bool)ucontrol->value.integer.value[0];
+        /* if module is in RAM on the DSP, apply user settings to module through
+         * ipc. If module is not in RAM on the DSP, store user setting for
+         * track */
+        if (sst_hsw_is_module_loaded(hsw, id)) {
+                if (switch_on == sst_hsw_is_module_active(hsw, id))
+                        return 0;
+                if (switch_on)
+                        ret = sst_hsw_module_enable(hsw, id, 0);
+                else
+                        ret = sst_hsw_module_disable(hsw, id, 0);
+        } else {
+                if (switch_on == sst_hsw_is_module_enabled_rtd3(hsw, id))
+                        return 0;
+                if (switch_on)
+                        sst_hsw_set_module_enabled_rtd3(hsw, id);
+                else
+                        sst_hsw_set_module_disabled_rtd3(hsw, id);
+        }
+        return ret;
+}
+static int hsw_waves_param_get(struct snd_kcontrol *kcontrol,
+                                struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_platform *platform = snd_soc_kcontrol_platform(kcontrol);
+        struct hsw_priv_data *pdata = snd_soc_platform_get_drvdata(platform);
+        struct sst_hsw *hsw = pdata->hsw;
+        /* return a matching line from param buffer */
+        return sst_hsw_load_param_line(hsw, ucontrol->value.bytes.data);
+}
+static int hsw_waves_param_put(struct snd_kcontrol *kcontrol,
+                                struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_platform *platform = snd_soc_kcontrol_platform(kcontrol);
+        struct hsw_priv_data *pdata = snd_soc_platform_get_drvdata(platform);
+        struct sst_hsw *hsw = pdata->hsw;
+        int ret;
+        enum sst_hsw_module_id id = SST_HSW_MODULE_WAVES;
+        int param_id = ucontrol->value.bytes.data[0];
+        int param_size = WAVES_PARAM_COUNT;
+        /* clear param buffer and reset buffer index */
+        if (param_id == 0xFF) {
+                sst_hsw_reset_param_buf(hsw);
+                return 0;
+        }
+        /* store params into buffer */
+        ret = sst_hsw_store_param_line(hsw, ucontrol->value.bytes.data);
+        if (ret < 0)
+                return ret;
+        if (sst_hsw_is_module_active(hsw, id))
+                ret = sst_hsw_module_set_param(hsw, id, 0, param_id,
+                                param_size, ucontrol->value.bytes.data);
+        return ret;
+}
 /* TLV used by both global and stream volumes */
 static const DECLARE_TLV_DB_SCALE(hsw_vol_tlv, -9000, 300, 1);
@@ -339,6 +427,12 @@ static const struct snd_kcontrol_new hsw_volume_controls[] = {
        SOC_DOUBLE_EXT_TLV("Mic Capture Volume", 4, 0, 8,
                ARRAY_SIZE(volume_map) - 1, 0,
                hsw_stream_volume_get, hsw_stream_volume_put, hsw_vol_tlv),
+        /* enable/disable module waves */
+        SOC_SINGLE_BOOL_EXT("Waves Switch", 0,
+                hsw_waves_switch_get, hsw_waves_switch_put),
+        /* set parameters to module waves */
+        SND_SOC_BYTES_EXT("Waves Set Param", WAVES_PARAM_COUNT,
+                hsw_waves_param_get, hsw_waves_param_put),
 };
 /* Create DMA buffer page table for DSP */
@@ -807,6 +901,14 @@ static int hsw_pcm_create_modules(struct hsw_priv_data *pdata)
                        pcm_data->runtime->persistent_offset;
        }
+        /* create runtime blocks for module waves */
+        if (sst_hsw_is_module_loaded(hsw, SST_HSW_MODULE_WAVES)) {
+                pdata->runtime_waves = sst_hsw_runtime_module_create(hsw,
+                        SST_HSW_MODULE_WAVES, 0);
+                if (pdata->runtime_waves == NULL)
+                        goto err;
+        }
        return 0;
 err:
@@ -820,14 +922,17 @@ err:
 static void hsw_pcm_free_modules(struct hsw_priv_data *pdata)
 {
+        struct sst_hsw *hsw = pdata->hsw;
        struct hsw_pcm_data *pcm_data;
        int i;
        for (i = 0; i < ARRAY_SIZE(mod_map); i++) {
                pcm_data = &pdata->pcm[mod_map[i].dai_id][mod_map[i].stream];
                sst_hsw_runtime_module_free(pcm_data->runtime);
        }
+        if (sst_hsw_is_module_loaded(hsw, SST_HSW_MODULE_WAVES)) {
+                sst_hsw_runtime_module_free(pdata->runtime_waves);
+        }
 }
 static int hsw_pcm_new(struct snd_soc_pcm_runtime *rtd)
@@ -984,7 +1089,9 @@ static int hsw_pcm_probe(struct snd_soc_platform *platform)
        }
        /* allocate runtime modules */
-        hsw_pcm_create_modules(priv_data);
+        ret = hsw_pcm_create_modules(priv_data);
+        if (ret < 0)
+                goto err;
        /* enable runtime PM with auto suspend */
        pm_runtime_set_autosuspend_delay(platform->dev,
@@ -996,7 +1103,7 @@ static int hsw_pcm_probe(struct snd_soc_platform *platform)
        return 0;
 err:
-        for (;i >= 0; i--) {
+        for (--i; i >= 0; i--) {
                if (hsw_dais[i].playback.channels_min)
                        snd_dma_free_pages(&priv_data->dmab[i][0]);
                if (hsw_dais[i].capture.channels_min)
@@ -1101,10 +1208,18 @@ static int hsw_pcm_runtime_suspend(struct device *dev)
 {
        struct hsw_priv_data *pdata = dev_get_drvdata(dev);
        struct sst_hsw *hsw = pdata->hsw;
+        int ret;
        if (pdata->pm_state >= HSW_PM_STATE_RTD3)
                return 0;
+        /* fw modules will be unloaded on RTD3, set flag to track */
+        if (sst_hsw_is_module_active(hsw, SST_HSW_MODULE_WAVES)) {
+                ret = sst_hsw_module_disable(hsw, SST_HSW_MODULE_WAVES, 0);
+                if (ret < 0)
+                        return ret;
+                sst_hsw_set_module_enabled_rtd3(hsw, SST_HSW_MODULE_WAVES);
+        }
        sst_hsw_dsp_runtime_suspend(hsw);
        sst_hsw_dsp_runtime_sleep(hsw);
        pdata->pm_state = HSW_PM_STATE_RTD3;
@@ -1139,6 +1254,19 @@ static int hsw_pcm_runtime_resume(struct device *dev)
        else if (ret == 1) /* no action required */
                return 0;
+        /* check flag when resume */
+        if (sst_hsw_is_module_enabled_rtd3(hsw, SST_HSW_MODULE_WAVES)) {
+                ret = sst_hsw_module_enable(hsw, SST_HSW_MODULE_WAVES, 0);
+                if (ret < 0)
+                        return ret;
+                /* put parameters from buffer to dsp */
+                ret = sst_hsw_launch_param_buf(hsw);
+                if (ret < 0)
+                        return ret;
+                /* unset flag */
+                sst_hsw_set_module_disabled_rtd3(hsw, SST_HSW_MODULE_WAVES);
+        }
        pdata->pm_state = HSW_PM_STATE_D0;
        return ret;
 }
diff --git a/sound/soc/jz4740/jz4740-i2s.c b/sound/soc/jz4740/jz4740-i2s.c
index 07f77815a586..b05fb1c1a848 100644
--- a/sound/soc/jz4740/jz4740-i2s.c
+++ b/sound/soc/jz4740/jz4740-i2s.c
@@ -58,6 +58,12 @@
 #define JZ_AIC_CONF_FIFO_RX_THRESHOLD_OFFSET 12
 #define JZ_AIC_CONF_FIFO_TX_THRESHOLD_OFFSET 8
+#define JZ4780_AIC_CONF_FIFO_RX_THRESHOLD_OFFSET 24
+#define JZ4780_AIC_CONF_FIFO_TX_THRESHOLD_OFFSET 16
+#define JZ4780_AIC_CONF_FIFO_RX_THRESHOLD_MASK \
+                        (0xf << JZ4780_AIC_CONF_FIFO_RX_THRESHOLD_OFFSET)
+#define JZ4780_AIC_CONF_FIFO_TX_THRESHOLD_MASK \
+                        (0x1f <<  JZ4780_AIC_CONF_FIFO_TX_THRESHOLD_OFFSET)
 #define JZ_AIC_CTRL_OUTPUT_SAMPLE_SIZE_MASK (0x7 << 19)
 #define JZ_AIC_CTRL_INPUT_SAMPLE_SIZE_MASK (0x7 << 16)
@@ -79,6 +85,7 @@
 #define JZ_AIC_CTRL_INPUT_SAMPLE_SIZE_OFFSET  16
 #define JZ_AIC_I2S_FMT_DISABLE_BIT_CLK BIT(12)
+#define JZ_AIC_I2S_FMT_DISABLE_BIT_ICLK BIT(13)
 #define JZ_AIC_I2S_FMT_ENABLE_SYS_CLK BIT(4)
 #define JZ_AIC_I2S_FMT_MSB BIT(0)
@@ -87,6 +94,13 @@
 #define JZ_AIC_CLK_DIV_MASK 0xf
 #define I2SDIV_DV_SHIFT 8
 #define I2SDIV_DV_MASK (0xf << I2SDIV_DV_SHIFT)
+#define I2SDIV_IDV_SHIFT 8
+#define I2SDIV_IDV_MASK (0xf << I2SDIV_IDV_SHIFT)
+enum jz47xx_i2s_version {
+        JZ_I2S_JZ4740,
+        JZ_I2S_JZ4780,
+};
 struct jz4740_i2s {
        struct resource *mem;
@@ -98,6 +112,8 @@ struct jz4740_i2s {
        struct snd_dmaengine_dai_dma_data playback_dma_data;
        struct snd_dmaengine_dai_dma_data capture_dma_data;
+        enum jz47xx_i2s_version version;
 };
 static inline uint32_t jz4740_i2s_read(const struct jz4740_i2s *i2s,
@@ -267,13 +283,22 @@ static int jz4740_i2s_hw_params(struct snd_pcm_substream *substream,
                        ctrl |= JZ_AIC_CTRL_MONO_TO_STEREO;
                else
                        ctrl &= ~JZ_AIC_CTRL_MONO_TO_STEREO;
+                div_reg &= ~I2SDIV_DV_MASK;
+                div_reg |= (div - 1) << I2SDIV_DV_SHIFT;
        } else {
                ctrl &= ~JZ_AIC_CTRL_INPUT_SAMPLE_SIZE_MASK;
                ctrl |= sample_size << JZ_AIC_CTRL_INPUT_SAMPLE_SIZE_OFFSET;
+                if (i2s->version >= JZ_I2S_JZ4780) {
+                        div_reg &= ~I2SDIV_IDV_MASK;
+                        div_reg |= (div - 1) << I2SDIV_IDV_SHIFT;
+                } else {
+                        div_reg &= ~I2SDIV_DV_MASK;
+                        div_reg |= (div - 1) << I2SDIV_DV_SHIFT;
+                }
        }
-        div_reg &= ~I2SDIV_DV_MASK;
-        div_reg |= (div - 1) << I2SDIV_DV_SHIFT;
        jz4740_i2s_write(i2s, JZ_REG_AIC_CTRL, ctrl);
        jz4740_i2s_write(i2s, JZ_REG_AIC_CLK_DIV, div_reg);
@@ -369,11 +394,19 @@ static int jz4740_i2s_dai_probe(struct snd_soc_dai *dai)
        snd_soc_dai_init_dma_data(dai, &i2s->playback_dma_data,
                &i2s->capture_dma_data);
-        conf = (7 << JZ_AIC_CONF_FIFO_RX_THRESHOLD_OFFSET) |
+        if (i2s->version >= JZ_I2S_JZ4780) {
-                (8 << JZ_AIC_CONF_FIFO_TX_THRESHOLD_OFFSET) |
+                conf = (7 << JZ4780_AIC_CONF_FIFO_RX_THRESHOLD_OFFSET) |
-                JZ_AIC_CONF_OVERFLOW_PLAY_LAST |
+                        (8 << JZ4780_AIC_CONF_FIFO_TX_THRESHOLD_OFFSET) |
-                JZ_AIC_CONF_I2S |
+                        JZ_AIC_CONF_OVERFLOW_PLAY_LAST |
-                JZ_AIC_CONF_INTERNAL_CODEC;
+                        JZ_AIC_CONF_I2S |
+                        JZ_AIC_CONF_INTERNAL_CODEC;
+        } else {
+                conf = (7 << JZ_AIC_CONF_FIFO_RX_THRESHOLD_OFFSET) |
+                        (8 << JZ_AIC_CONF_FIFO_TX_THRESHOLD_OFFSET) |
+                        JZ_AIC_CONF_OVERFLOW_PLAY_LAST |
+                        JZ_AIC_CONF_I2S |
+                        JZ_AIC_CONF_INTERNAL_CODEC;
+        }
        jz4740_i2s_write(i2s, JZ_REG_AIC_CONF, JZ_AIC_CONF_RESET);
        jz4740_i2s_write(i2s, JZ_REG_AIC_CONF, conf);
@@ -422,13 +455,34 @@ static struct snd_soc_dai_driver jz4740_i2s_dai = {
        .resume = jz4740_i2s_resume,
 };
+static struct snd_soc_dai_driver jz4780_i2s_dai = {
+        .probe = jz4740_i2s_dai_probe,
+        .remove = jz4740_i2s_dai_remove,
+        .playback = {
+                .channels_min = 1,
+                .channels_max = 2,
+                .rates = SNDRV_PCM_RATE_8000_48000,
+                .formats = JZ4740_I2S_FMTS,
+        },
+        .capture = {
+                .channels_min = 2,
+                .channels_max = 2,
+                .rates = SNDRV_PCM_RATE_8000_48000,
+                .formats = JZ4740_I2S_FMTS,
+        },
+        .ops = &jz4740_i2s_dai_ops,
+        .suspend = jz4740_i2s_suspend,
+        .resume = jz4740_i2s_resume,
+};
 static const struct snd_soc_component_driver jz4740_i2s_component = {
        .name           = "jz4740-i2s",
 };
 #ifdef CONFIG_OF
 static const struct of_device_id jz4740_of_matches[] = {
-        { .compatible = "ingenic,jz4740-i2s" },
+        { .compatible = "ingenic,jz4740-i2s", .data = (void *)JZ_I2S_JZ4740 },
+        { .compatible = "ingenic,jz4780-i2s", .data = (void *)JZ_I2S_JZ4780 },
        { /* sentinel */ }
 };
 #endif
@@ -438,11 +492,16 @@ static int jz4740_i2s_dev_probe(struct platform_device *pdev)
        struct jz4740_i2s *i2s;
        struct resource *mem;
        int ret;
+        const struct of_device_id *match;
        i2s = devm_kzalloc(&pdev->dev, sizeof(*i2s), GFP_KERNEL);
        if (!i2s)
                return -ENOMEM;
+        match = of_match_device(jz4740_of_matches, &pdev->dev);
+        if (match)
+                i2s->version = (enum jz47xx_i2s_version)match->data;
        mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        i2s->base = devm_ioremap_resource(&pdev->dev, mem);
        if (IS_ERR(i2s->base))
@@ -460,8 +519,13 @@ static int jz4740_i2s_dev_probe(struct platform_device *pdev)
        platform_set_drvdata(pdev, i2s);
-        ret = devm_snd_soc_register_component(&pdev->dev,
+        if (i2s->version == JZ_I2S_JZ4780)
-                &jz4740_i2s_component, &jz4740_i2s_dai, 1);
+                ret = devm_snd_soc_register_component(&pdev->dev,
+                        &jz4740_i2s_component, &jz4780_i2s_dai, 1);
+        else
+                ret = devm_snd_soc_register_component(&pdev->dev,
+                        &jz4740_i2s_component, &jz4740_i2s_dai, 1);
        if (ret)
                return ret;
diff --git a/sound/soc/kirkwood/kirkwood-i2s.c b/sound/soc/kirkwood/kirkwood-i2s.c
index d19483081f9b..3a36d60e1785 100644
--- a/sound/soc/kirkwood/kirkwood-i2s.c
+++ b/sound/soc/kirkwood/kirkwood-i2s.c
@@ -643,7 +643,7 @@ static int kirkwood_i2s_dev_remove(struct platform_device *pdev)
 }
 #ifdef CONFIG_OF
-static struct of_device_id mvebu_audio_of_match[] = {
+static const struct of_device_id mvebu_audio_of_match[] = {
        { .compatible = "marvell,kirkwood-audio" },
        { .compatible = "marvell,dove-audio" },
        { .compatible = "marvell,armada370-audio" },
diff --git a/sound/soc/nuc900/nuc900-audio.h b/sound/soc/nuc900/nuc900-audio.h
index 59f7e8ed1a68..d0b725705914 100644
--- a/sound/soc/nuc900/nuc900-audio.h
+++ b/sound/soc/nuc900/nuc900-audio.h
@@ -100,10 +100,7 @@
 struct nuc900_audio {
        void __iomem *mmio;
        spinlock_t lock;
-        dma_addr_t dma_addr[2];
-        unsigned long buffersize[2];
        unsigned long irq_num;
-        struct snd_pcm_substream *substream;
        struct resource *res;
        struct clk *clk;
        struct device *dev;
diff --git a/sound/soc/nuc900/nuc900-pcm.c b/sound/soc/nuc900/nuc900-pcm.c
index b809fa909e4d..5ae5ca15b6d6 100644
--- a/sound/soc/nuc900/nuc900-pcm.c
+++ b/sound/soc/nuc900/nuc900-pcm.c
@@ -42,29 +42,10 @@ static const struct snd_pcm_hardware nuc900_pcm_hardware = {
 static int nuc900_dma_hw_params(struct snd_pcm_substream *substream,
        struct snd_pcm_hw_params *params)
 {
-        struct snd_pcm_runtime *runtime = substream->runtime;
+        return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params));
-        struct nuc900_audio *nuc900_audio = runtime->private_data;
-        unsigned long flags;
-        int ret = 0;
-        ret = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params));
-        if (ret < 0)
-                return ret;
-        spin_lock_irqsave(&nuc900_audio->lock, flags);
-        nuc900_audio->substream = substream;
-        nuc900_audio->dma_addr[substream->stream] = runtime->dma_addr;
-        nuc900_audio->buffersize[substream->stream] =
-                                                params_buffer_bytes(params);
-        spin_unlock_irqrestore(&nuc900_audio->lock, flags);
-        return ret;
 }
-static void nuc900_update_dma_register(struct snd_pcm_substream *substream,
+static void nuc900_update_dma_register(struct snd_pcm_substream *substream)
-                                dma_addr_t dma_addr, size_t count)
 {
        struct snd_pcm_runtime *runtime = substream->runtime;
        struct nuc900_audio *nuc900_audio = runtime->private_data;
@@ -78,8 +59,8 @@ static void nuc900_update_dma_register(struct snd_pcm_substream *substream,
                mmio_len = nuc900_audio->mmio + ACTL_RDST_LENGTH;
        }
-        AUDIO_WRITE(mmio_addr, dma_addr);
+        AUDIO_WRITE(mmio_addr, runtime->dma_addr);
-        AUDIO_WRITE(mmio_len, count);
+        AUDIO_WRITE(mmio_len, runtime->dma_bytes);
 }
 static void nuc900_dma_start(struct snd_pcm_substream *substream)
@@ -170,9 +151,7 @@ static int nuc900_dma_prepare(struct snd_pcm_substream *substream)
        spin_lock_irqsave(&nuc900_audio->lock, flags);
-        nuc900_update_dma_register(substream,
+        nuc900_update_dma_register(substream);
-                                nuc900_audio->dma_addr[substream->stream],
-                                nuc900_audio->buffersize[substream->stream]);
        val = AUDIO_READ(nuc900_audio->mmio + ACTL_RESET);
diff --git a/sound/soc/omap/Kconfig b/sound/soc/omap/Kconfig
index e7c78b0406b5..6768e4f7d7d0 100644
--- a/sound/soc/omap/Kconfig
+++ b/sound/soc/omap/Kconfig
@@ -105,7 +105,7 @@ config SND_OMAP_SOC_OMAP_ABE_TWL6040
        select SND_OMAP_SOC_MCPDM
        select SND_SOC_TWL6040
        select SND_SOC_DMIC
-        select COMMON_CLK_PALMAS if SOC_OMAP5
+        select COMMON_CLK_PALMAS if MFD_PALMAS
        help
          Say Y if you want to add support for SoC audio on OMAP boards using
          ABE and twl6040 codec. This driver currently supports:
diff --git a/sound/soc/omap/n810.c b/sound/soc/omap/n810.c
index 5d7f9cebe041..dcb5336b5698 100644
--- a/sound/soc/omap/n810.c
+++ b/sound/soc/omap/n810.c
@@ -98,12 +98,11 @@ static int n810_startup(struct snd_pcm_substream *substream)
 {
        struct snd_pcm_runtime *runtime = substream->runtime;
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-        struct snd_soc_codec *codec = rtd->codec;
        snd_pcm_hw_constraint_minmax(runtime,
                                     SNDRV_PCM_HW_PARAM_CHANNELS, 2, 2);
-        n810_ext_control(&codec->dapm);
+        n810_ext_control(&rtd->card->dapm);
        return clk_prepare_enable(sys_clkout2);
 }
@@ -255,24 +254,6 @@ static const struct snd_kcontrol_new aic33_n810_controls[] = {
                     n810_get_input, n810_set_input),
 };
-static int n810_aic33_init(struct snd_soc_pcm_runtime *rtd)
-{
-        struct snd_soc_codec *codec = rtd->codec;
-        struct snd_soc_dapm_context *dapm = &codec->dapm;
-        /* Not connected */
-        snd_soc_dapm_nc_pin(dapm, "MONO_LOUT");
-        snd_soc_dapm_nc_pin(dapm, "HPLCOM");
-        snd_soc_dapm_nc_pin(dapm, "HPRCOM");
-        snd_soc_dapm_nc_pin(dapm, "MIC3L");
-        snd_soc_dapm_nc_pin(dapm, "MIC3R");
-        snd_soc_dapm_nc_pin(dapm, "LINE1R");
-        snd_soc_dapm_nc_pin(dapm, "LINE2L");
-        snd_soc_dapm_nc_pin(dapm, "LINE2R");
-        return 0;
-}
 /* Digital audio interface glue - connects codec <--> CPU */
 static struct snd_soc_dai_link n810_dai = {
        .name = "TLV320AIC33",
@@ -283,7 +264,6 @@ static struct snd_soc_dai_link n810_dai = {
        .codec_dai_name = "tlv320aic3x-hifi",
        .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
                   SND_SOC_DAIFMT_CBM_CFM,
-        .init = n810_aic33_init,
        .ops = &n810_ops,
 };
@@ -300,6 +280,7 @@ static struct snd_soc_card snd_soc_n810 = {
        .num_dapm_widgets = ARRAY_SIZE(aic33_dapm_widgets),
        .dapm_routes = audio_map,
        .num_dapm_routes = ARRAY_SIZE(audio_map),
+        .fully_routed = true,
 };
 static struct platform_device *n810_snd_device;
diff --git a/sound/soc/omap/omap-hdmi-audio.c b/sound/soc/omap/omap-hdmi-audio.c
index f7eb42aa3f38..4775da4c4db5 100644
--- a/sound/soc/omap/omap-hdmi-audio.c
+++ b/sound/soc/omap/omap-hdmi-audio.c
@@ -142,8 +142,6 @@ static int hdmi_dai_hw_params(struct snd_pcm_substream *substream,
        iec->status[0] |= IEC958_AES0_CON_EMPHASIS_NONE;
-        iec->status[0] |= IEC958_AES1_PRO_MODE_NOTID;
        iec->status[1] = IEC958_AES1_CON_GENERAL;
        iec->status[2] |= IEC958_AES2_CON_SOURCE_UNSPEC;
diff --git a/sound/soc/qcom/Kconfig b/sound/soc/qcom/Kconfig
new file mode 100644
index 000000000000..5f58e4f1bca9
--- /dev/null
+++ b/sound/soc/qcom/Kconfig
@@ -0,0 +1,25 @@
+config SND_SOC_QCOM
+        tristate "ASoC support for QCOM platforms"
+        help
+          Say Y or M if you want to add support to use audio devices
+          in Qualcomm Technologies SOC-based platforms.
+config SND_SOC_LPASS_CPU
+        tristate
+        depends on SND_SOC_QCOM
+        select REGMAP_MMIO
+config SND_SOC_LPASS_PLATFORM
+        tristate
+        depends on SND_SOC_QCOM
+        select REGMAP_MMIO
+config SND_SOC_STORM
+        tristate "ASoC I2S support for Storm boards"
+        depends on (ARCH_QCOM && SND_SOC_QCOM) || COMPILE_TEST
+        select SND_SOC_LPASS_CPU
+        select SND_SOC_LPASS_PLATFORM
+        select SND_SOC_MAX98357A
+        help
+          Say Y or M if you want add support for SoC audio on the
+          Qualcomm Technologies IPQ806X-based Storm board.
diff --git a/sound/soc/qcom/Makefile b/sound/soc/qcom/Makefile
new file mode 100644
index 000000000000..c5ce96c761c4
--- /dev/null
+++ b/sound/soc/qcom/Makefile
@@ -0,0 +1,11 @@
+# Platform
+snd-soc-lpass-cpu-objs := lpass-cpu.o
+snd-soc-lpass-platform-objs := lpass-platform.o
+obj-$(CONFIG_SND_SOC_LPASS_CPU) += snd-soc-lpass-cpu.o
+obj-$(CONFIG_SND_SOC_LPASS_PLATFORM) += snd-soc-lpass-platform.o
+# Machine
+snd-soc-storm-objs := storm.o
+obj-$(CONFIG_SND_SOC_STORM) += snd-soc-storm.o
diff --git a/sound/soc/qcom/lpass-cpu.c b/sound/soc/qcom/lpass-cpu.c
new file mode 100644
index 000000000000..6698d058de29
--- /dev/null
+++ b/sound/soc/qcom/lpass-cpu.c
@@ -0,0 +1,491 @@
+/*
+ * Copyright (c) 2010-2011,2013-2015 The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * lpass-cpu.c -- ALSA SoC CPU DAI driver for QTi LPASS
+ */
+#include <linux/clk.h>
+#include <linux/compiler.h>
+#include <linux/device.h>
+#include <linux/err.h>
+#include <linux/ioport.h>
+#include <linux/kernel.h>
+#include <linux/mod_devicetable.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/platform_device.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <linux/regmap.h>
+#include <sound/soc.h>
+#include <sound/soc-dai.h>
+#include "lpass-lpaif-ipq806x.h"
+#include "lpass.h"
+static int lpass_cpu_daiops_set_sysclk(struct snd_soc_dai *dai, int clk_id,
+                unsigned int freq, int dir)
+{
+        struct lpass_data *drvdata = snd_soc_dai_get_drvdata(dai);
+        int ret;
+        ret = clk_set_rate(drvdata->mi2s_osr_clk, freq);
+        if (ret)
+                dev_err(dai->dev, "%s() error setting mi2s osrclk to %u: %d\n",
+                                __func__, freq, ret);
+        return ret;
+}
+static int lpass_cpu_daiops_startup(struct snd_pcm_substream *substream,
+                struct snd_soc_dai *dai)
+{
+        struct lpass_data *drvdata = snd_soc_dai_get_drvdata(dai);
+        int ret;
+        ret = clk_prepare_enable(drvdata->mi2s_osr_clk);
+        if (ret) {
+                dev_err(dai->dev, "%s() error in enabling mi2s osr clk: %d\n",
+                                __func__, ret);
+                return ret;
+        }
+        ret = clk_prepare_enable(drvdata->mi2s_bit_clk);
+        if (ret) {
+                dev_err(dai->dev, "%s() error in enabling mi2s bit clk: %d\n",
+                                __func__, ret);
+                clk_disable_unprepare(drvdata->mi2s_osr_clk);
+                return ret;
+        }
+        return 0;
+}
+static void lpass_cpu_daiops_shutdown(struct snd_pcm_substream *substream,
+                struct snd_soc_dai *dai)
+{
+        struct lpass_data *drvdata = snd_soc_dai_get_drvdata(dai);
+        clk_disable_unprepare(drvdata->mi2s_bit_clk);
+        clk_disable_unprepare(drvdata->mi2s_osr_clk);
+}
+static int lpass_cpu_daiops_hw_params(struct snd_pcm_substream *substream,
+                struct snd_pcm_hw_params *params, struct snd_soc_dai *dai)
+{
+        struct lpass_data *drvdata = snd_soc_dai_get_drvdata(dai);
+        snd_pcm_format_t format = params_format(params);
+        unsigned int channels = params_channels(params);
+        unsigned int rate = params_rate(params);
+        unsigned int regval;
+        int bitwidth, ret;
+        bitwidth = snd_pcm_format_width(format);
+        if (bitwidth < 0) {
+                dev_err(dai->dev, "%s() invalid bit width given: %d\n",
+                                __func__, bitwidth);
+                return bitwidth;
+        }
+        regval = LPAIF_I2SCTL_LOOPBACK_DISABLE |
+                        LPAIF_I2SCTL_WSSRC_INTERNAL;
+        switch (bitwidth) {
+        case 16:
+                regval |= LPAIF_I2SCTL_BITWIDTH_16;
+                break;
+        case 24:
+                regval |= LPAIF_I2SCTL_BITWIDTH_24;
+                break;
+        case 32:
+                regval |= LPAIF_I2SCTL_BITWIDTH_32;
+                break;
+        default:
+                dev_err(dai->dev, "%s() invalid bitwidth given: %d\n",
+                                __func__, bitwidth);
+                return -EINVAL;
+        }
+        switch (channels) {
+        case 1:
+                regval |= LPAIF_I2SCTL_SPKMODE_SD0;
+                regval |= LPAIF_I2SCTL_SPKMONO_MONO;
+                break;
+        case 2:
+                regval |= LPAIF_I2SCTL_SPKMODE_SD0;
+                regval |= LPAIF_I2SCTL_SPKMONO_STEREO;
+                break;
+        case 4:
+                regval |= LPAIF_I2SCTL_SPKMODE_QUAD01;
+                regval |= LPAIF_I2SCTL_SPKMONO_STEREO;
+                break;
+        case 6:
+                regval |= LPAIF_I2SCTL_SPKMODE_6CH;
+                regval |= LPAIF_I2SCTL_SPKMONO_STEREO;
+                break;
+        case 8:
+                regval |= LPAIF_I2SCTL_SPKMODE_8CH;
+                regval |= LPAIF_I2SCTL_SPKMONO_STEREO;
+                break;
+        default:
+                dev_err(dai->dev, "%s() invalid channels given: %u\n",
+                                __func__, channels);
+                return -EINVAL;
+        }
+        ret = regmap_write(drvdata->lpaif_map,
+                        LPAIF_I2SCTL_REG(LPAIF_I2S_PORT_MI2S), regval);
+        if (ret) {
+                dev_err(dai->dev, "%s() error writing to i2sctl reg: %d\n",
+                                __func__, ret);
+                return ret;
+        }
+        ret = clk_set_rate(drvdata->mi2s_bit_clk, rate * bitwidth * 2);
+        if (ret) {
+                dev_err(dai->dev, "%s() error setting mi2s bitclk to %u: %d\n",
+                                __func__, rate * bitwidth * 2, ret);
+                return ret;
+        }
+        return 0;
+}
+static int lpass_cpu_daiops_hw_free(struct snd_pcm_substream *substream,
+                struct snd_soc_dai *dai)
+{
+        struct lpass_data *drvdata = snd_soc_dai_get_drvdata(dai);
+        int ret;
+        ret = regmap_write(drvdata->lpaif_map,
+                        LPAIF_I2SCTL_REG(LPAIF_I2S_PORT_MI2S), 0);
+        if (ret)
+                dev_err(dai->dev, "%s() error writing to i2sctl reg: %d\n",
+                                __func__, ret);
+        return ret;
+}
+static int lpass_cpu_daiops_prepare(struct snd_pcm_substream *substream,
+                struct snd_soc_dai *dai)
+{
+        struct lpass_data *drvdata = snd_soc_dai_get_drvdata(dai);
+        int ret;
+        ret = regmap_update_bits(drvdata->lpaif_map,
+                        LPAIF_I2SCTL_REG(LPAIF_I2S_PORT_MI2S),
+                        LPAIF_I2SCTL_SPKEN_MASK, LPAIF_I2SCTL_SPKEN_ENABLE);
+        if (ret)
+                dev_err(dai->dev, "%s() error writing to i2sctl reg: %d\n",
+                                __func__, ret);
+        return ret;
+}
+static int lpass_cpu_daiops_trigger(struct snd_pcm_substream *substream,
+                int cmd, struct snd_soc_dai *dai)
+{
+        struct lpass_data *drvdata = snd_soc_dai_get_drvdata(dai);
+        int ret;
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+        case SNDRV_PCM_TRIGGER_RESUME:
+        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
+                ret = regmap_update_bits(drvdata->lpaif_map,
+                                LPAIF_I2SCTL_REG(LPAIF_I2S_PORT_MI2S),
+                                LPAIF_I2SCTL_SPKEN_MASK,
+                                LPAIF_I2SCTL_SPKEN_ENABLE);
+                if (ret)
+                        dev_err(dai->dev, "%s() error writing to i2sctl reg: %d\n",
+                                        __func__, ret);
+                break;
+        case SNDRV_PCM_TRIGGER_STOP:
+        case SNDRV_PCM_TRIGGER_SUSPEND:
+        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
+                ret = regmap_update_bits(drvdata->lpaif_map,
+                                LPAIF_I2SCTL_REG(LPAIF_I2S_PORT_MI2S),
+                                LPAIF_I2SCTL_SPKEN_MASK,
+                                LPAIF_I2SCTL_SPKEN_DISABLE);
+                if (ret)
+                        dev_err(dai->dev, "%s() error writing to i2sctl reg: %d\n",
+                                        __func__, ret);
+                break;
+        }
+        return ret;
+}
+static struct snd_soc_dai_ops lpass_cpu_dai_ops = {
+        .set_sysclk     = lpass_cpu_daiops_set_sysclk,
+        .startup        = lpass_cpu_daiops_startup,
+        .shutdown       = lpass_cpu_daiops_shutdown,
+        .hw_params      = lpass_cpu_daiops_hw_params,
+        .hw_free        = lpass_cpu_daiops_hw_free,
+        .prepare        = lpass_cpu_daiops_prepare,
+        .trigger        = lpass_cpu_daiops_trigger,
+};
+static int lpass_cpu_dai_probe(struct snd_soc_dai *dai)
+{
+        struct lpass_data *drvdata = snd_soc_dai_get_drvdata(dai);
+        int ret;
+        /* ensure audio hardware is disabled */
+        ret = regmap_write(drvdata->lpaif_map,
+                        LPAIF_I2SCTL_REG(LPAIF_I2S_PORT_MI2S), 0);
+        if (ret)
+                dev_err(dai->dev, "%s() error writing to i2sctl reg: %d\n",
+                                __func__, ret);
+        return ret;
+}
+static struct snd_soc_dai_driver lpass_cpu_dai_driver = {
+        .playback = {
+                .stream_name    = "lpass-cpu-playback",
+                .formats        = SNDRV_PCM_FMTBIT_S16 |
+                                        SNDRV_PCM_FMTBIT_S24 |
+                                        SNDRV_PCM_FMTBIT_S32,
+                .rates          = SNDRV_PCM_RATE_8000 |
+                                        SNDRV_PCM_RATE_16000 |
+                                        SNDRV_PCM_RATE_32000 |
+                                        SNDRV_PCM_RATE_48000 |
+                                        SNDRV_PCM_RATE_96000,
+                .rate_min       = 8000,
+                .rate_max       = 96000,
+                .channels_min   = 1,
+                .channels_max   = 8,
+        },
+        .probe  = &lpass_cpu_dai_probe,
+        .ops    = &lpass_cpu_dai_ops,
+};
+static const struct snd_soc_component_driver lpass_cpu_comp_driver = {
+        .name = "lpass-cpu",
+};
+static bool lpass_cpu_regmap_writeable(struct device *dev, unsigned int reg)
+{
+        int i;
+        for (i = 0; i < LPAIF_I2S_PORT_NUM; ++i)
+                if (reg == LPAIF_I2SCTL_REG(i))
+                        return true;
+        for (i = 0; i < LPAIF_IRQ_PORT_NUM; ++i) {
+                if (reg == LPAIF_IRQEN_REG(i))
+                        return true;
+                if (reg == LPAIF_IRQCLEAR_REG(i))
+                        return true;
+        }
+        for (i = 0; i < LPAIF_RDMA_CHAN_NUM; ++i) {
+                if (reg == LPAIF_RDMACTL_REG(i))
+                        return true;
+                if (reg == LPAIF_RDMABASE_REG(i))
+                        return true;
+                if (reg == LPAIF_RDMABUFF_REG(i))
+                        return true;
+                if (reg == LPAIF_RDMAPER_REG(i))
+                        return true;
+        }
+        return false;
+}
+static bool lpass_cpu_regmap_readable(struct device *dev, unsigned int reg)
+{
+        int i;
+        for (i = 0; i < LPAIF_I2S_PORT_NUM; ++i)
+                if (reg == LPAIF_I2SCTL_REG(i))
+                        return true;
+        for (i = 0; i < LPAIF_IRQ_PORT_NUM; ++i) {
+                if (reg == LPAIF_IRQEN_REG(i))
+                        return true;
+                if (reg == LPAIF_IRQSTAT_REG(i))
+                        return true;
+        }
+        for (i = 0; i < LPAIF_RDMA_CHAN_NUM; ++i) {
+                if (reg == LPAIF_RDMACTL_REG(i))
+                        return true;
+                if (reg == LPAIF_RDMABASE_REG(i))
+                        return true;
+                if (reg == LPAIF_RDMABUFF_REG(i))
+                        return true;
+                if (reg == LPAIF_RDMACURR_REG(i))
+                        return true;
+                if (reg == LPAIF_RDMAPER_REG(i))
+                        return true;
+        }
+        return false;
+}
+static bool lpass_cpu_regmap_volatile(struct device *dev, unsigned int reg)
+{
+        int i;
+        for (i = 0; i < LPAIF_IRQ_PORT_NUM; ++i)
+                if (reg == LPAIF_IRQSTAT_REG(i))
+                        return true;
+        for (i = 0; i < LPAIF_RDMA_CHAN_NUM; ++i)
+                if (reg == LPAIF_RDMACURR_REG(i))
+                        return true;
+        return false;
+}
+static const struct regmap_config lpass_cpu_regmap_config = {
+        .reg_bits = 32,
+        .reg_stride = 4,
+        .val_bits = 32,
+        .max_register = LPAIF_RDMAPER_REG(LPAIF_RDMA_CHAN_MAX),
+        .writeable_reg = lpass_cpu_regmap_writeable,
+        .readable_reg = lpass_cpu_regmap_readable,
+        .volatile_reg = lpass_cpu_regmap_volatile,
+        .cache_type = REGCACHE_FLAT,
+};
+static int lpass_cpu_platform_probe(struct platform_device *pdev)
+{
+        struct lpass_data *drvdata;
+        struct device_node *dsp_of_node;
+        struct resource *res;
+        int ret;
+        dsp_of_node = of_parse_phandle(pdev->dev.of_node, "qcom,adsp", 0);
+        if (dsp_of_node) {
+                dev_err(&pdev->dev, "%s() DSP exists and holds audio resources\n",
+                                __func__);
+                return -EBUSY;
+        }
+        drvdata = devm_kzalloc(&pdev->dev, sizeof(struct lpass_data),
+                        GFP_KERNEL);
+        if (!drvdata)
+                return -ENOMEM;
+        platform_set_drvdata(pdev, drvdata);
+        res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "lpass-lpaif");
+        if (!res) {
+                dev_err(&pdev->dev, "%s() error getting resource\n", __func__);
+                return -ENODEV;
+        }
+        drvdata->lpaif = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR((void const __force *)drvdata->lpaif)) {
+                dev_err(&pdev->dev, "%s() error mapping reg resource: %ld\n",
+                                __func__,
+                                PTR_ERR((void const __force *)drvdata->lpaif));
+                return PTR_ERR((void const __force *)drvdata->lpaif);
+        }
+        drvdata->lpaif_map = devm_regmap_init_mmio(&pdev->dev, drvdata->lpaif,
+                        &lpass_cpu_regmap_config);
+        if (IS_ERR(drvdata->lpaif_map)) {
+                dev_err(&pdev->dev, "%s() error initializing regmap: %ld\n",
+                                __func__, PTR_ERR(drvdata->lpaif_map));
+                return PTR_ERR(drvdata->lpaif_map);
+        }
+        drvdata->mi2s_osr_clk = devm_clk_get(&pdev->dev, "mi2s-osr-clk");
+        if (IS_ERR(drvdata->mi2s_osr_clk)) {
+                dev_err(&pdev->dev, "%s() error getting mi2s-osr-clk: %ld\n",
+                                __func__, PTR_ERR(drvdata->mi2s_osr_clk));
+                return PTR_ERR(drvdata->mi2s_osr_clk);
+        }
+        drvdata->mi2s_bit_clk = devm_clk_get(&pdev->dev, "mi2s-bit-clk");
+        if (IS_ERR(drvdata->mi2s_bit_clk)) {
+                dev_err(&pdev->dev, "%s() error getting mi2s-bit-clk: %ld\n",
+                                __func__, PTR_ERR(drvdata->mi2s_bit_clk));
+                return PTR_ERR(drvdata->mi2s_bit_clk);
+        }
+        drvdata->ahbix_clk = devm_clk_get(&pdev->dev, "ahbix-clk");
+        if (IS_ERR(drvdata->ahbix_clk)) {
+                dev_err(&pdev->dev, "%s() error getting ahbix-clk: %ld\n",
+                                __func__, PTR_ERR(drvdata->ahbix_clk));
+                return PTR_ERR(drvdata->ahbix_clk);
+        }
+        ret = clk_set_rate(drvdata->ahbix_clk, LPASS_AHBIX_CLOCK_FREQUENCY);
+        if (ret) {
+                dev_err(&pdev->dev, "%s() error setting rate on ahbix_clk: %d\n",
+                                __func__, ret);
+                return ret;
+        }
+        dev_dbg(&pdev->dev, "%s() set ahbix_clk rate to %lu\n", __func__,
+                        clk_get_rate(drvdata->ahbix_clk));
+        ret = clk_prepare_enable(drvdata->ahbix_clk);
+        if (ret) {
+                dev_err(&pdev->dev, "%s() error enabling ahbix_clk: %d\n",
+                                __func__, ret);
+                return ret;
+        }
+        ret = devm_snd_soc_register_component(&pdev->dev,
+                        &lpass_cpu_comp_driver, &lpass_cpu_dai_driver, 1);
+        if (ret) {
+                dev_err(&pdev->dev, "%s() error registering cpu driver: %d\n",
+                                __func__, ret);
+                goto err_clk;
+        }
+        ret = asoc_qcom_lpass_platform_register(pdev);
+        if (ret) {
+                dev_err(&pdev->dev, "%s() error registering platform driver: %d\n",
+                                __func__, ret);
+                goto err_clk;
+        }
+        return 0;
+err_clk:
+        clk_disable_unprepare(drvdata->ahbix_clk);
+        return ret;
+}
+static int lpass_cpu_platform_remove(struct platform_device *pdev)
+{
+        struct lpass_data *drvdata = platform_get_drvdata(pdev);
+        clk_disable_unprepare(drvdata->ahbix_clk);
+        return 0;
+}
+#ifdef CONFIG_OF
+static const struct of_device_id lpass_cpu_device_id[] = {
+        { .compatible = "qcom,lpass-cpu" },
+        {}
+};
+MODULE_DEVICE_TABLE(of, lpass_cpu_device_id);
+#endif
+static struct platform_driver lpass_cpu_platform_driver = {
+        .driver = {
+                .name           = "lpass-cpu",
+                .of_match_table = of_match_ptr(lpass_cpu_device_id),
+        },
+        .probe  = lpass_cpu_platform_probe,
+        .remove = lpass_cpu_platform_remove,
+};
+module_platform_driver(lpass_cpu_platform_driver);
+MODULE_DESCRIPTION("QTi LPASS CPU Driver");
+MODULE_LICENSE("GPL v2");
diff --git a/sound/soc/qcom/lpass-lpaif-ipq806x.h b/sound/soc/qcom/lpass-lpaif-ipq806x.h
new file mode 100644
index 000000000000..dc423b888842
--- /dev/null
+++ b/sound/soc/qcom/lpass-lpaif-ipq806x.h
@@ -0,0 +1,172 @@
+/*
+ * Copyright (c) 2010-2011,2013-2015 The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * lpass-lpaif-ipq806x.h -- Definitions for the QTi LPAIF in the ipq806x LPASS
+ */
+#ifndef __LPASS_LPAIF_H__
+#define __LPASS_LPAIF_H__
+#define LPAIF_BANK_OFFSET               0x1000
+/* LPAIF I2S */
+#define LPAIF_I2SCTL_REG_BASE           0x0010
+#define LPAIF_I2SCTL_REG_STRIDE         0x4
+#define LPAIF_I2SCTL_REG_ADDR(addr, port) \
+        (LPAIF_I2SCTL_REG_BASE + (addr) + (LPAIF_I2SCTL_REG_STRIDE * (port)))
+enum lpaif_i2s_ports {
+        LPAIF_I2S_PORT_MIN              = 0,
+        LPAIF_I2S_PORT_CODEC_SPK        = 0,
+        LPAIF_I2S_PORT_CODEC_MIC        = 1,
+        LPAIF_I2S_PORT_SEC_SPK          = 2,
+        LPAIF_I2S_PORT_SEC_MIC          = 3,
+        LPAIF_I2S_PORT_MI2S             = 4,
+        LPAIF_I2S_PORT_MAX              = 4,
+        LPAIF_I2S_PORT_NUM              = 5,
+};
+#define LPAIF_I2SCTL_REG(port)          LPAIF_I2SCTL_REG_ADDR(0x0, (port))
+#define LPAIF_I2SCTL_LOOPBACK_MASK      0x8000
+#define LPAIF_I2SCTL_LOOPBACK_SHIFT     15
+#define LPAIF_I2SCTL_LOOPBACK_DISABLE   (0 << LPAIF_I2SCTL_LOOPBACK_SHIFT)
+#define LPAIF_I2SCTL_LOOPBACK_ENABLE    (1 << LPAIF_I2SCTL_LOOPBACK_SHIFT)
+#define LPAIF_I2SCTL_SPKEN_MASK         0x4000
+#define LPAIF_I2SCTL_SPKEN_SHIFT        14
+#define LPAIF_I2SCTL_SPKEN_DISABLE      (0 << LPAIF_I2SCTL_SPKEN_SHIFT)
+#define LPAIF_I2SCTL_SPKEN_ENABLE       (1 << LPAIF_I2SCTL_SPKEN_SHIFT)
+#define LPAIF_I2SCTL_SPKMODE_MASK       0x3C00
+#define LPAIF_I2SCTL_SPKMODE_SHIFT      10
+#define LPAIF_I2SCTL_SPKMODE_NONE       (0 << LPAIF_I2SCTL_SPKMODE_SHIFT)
+#define LPAIF_I2SCTL_SPKMODE_SD0        (1 << LPAIF_I2SCTL_SPKMODE_SHIFT)
+#define LPAIF_I2SCTL_SPKMODE_SD1        (2 << LPAIF_I2SCTL_SPKMODE_SHIFT)
+#define LPAIF_I2SCTL_SPKMODE_SD2        (3 << LPAIF_I2SCTL_SPKMODE_SHIFT)
+#define LPAIF_I2SCTL_SPKMODE_SD3        (4 << LPAIF_I2SCTL_SPKMODE_SHIFT)
+#define LPAIF_I2SCTL_SPKMODE_QUAD01     (5 << LPAIF_I2SCTL_SPKMODE_SHIFT)
+#define LPAIF_I2SCTL_SPKMODE_QUAD23     (6 << LPAIF_I2SCTL_SPKMODE_SHIFT)
+#define LPAIF_I2SCTL_SPKMODE_6CH        (7 << LPAIF_I2SCTL_SPKMODE_SHIFT)
+#define LPAIF_I2SCTL_SPKMODE_8CH        (8 << LPAIF_I2SCTL_SPKMODE_SHIFT)
+#define LPAIF_I2SCTL_SPKMONO_MASK       0x0200
+#define LPAIF_I2SCTL_SPKMONO_SHIFT      9
+#define LPAIF_I2SCTL_SPKMONO_STEREO     (0 << LPAIF_I2SCTL_SPKMONO_SHIFT)
+#define LPAIF_I2SCTL_SPKMONO_MONO       (1 << LPAIF_I2SCTL_SPKMONO_SHIFT)
+#define LPAIF_I2SCTL_WSSRC_MASK         0x0004
+#define LPAIF_I2SCTL_WSSRC_SHIFT        2
+#define LPAIF_I2SCTL_WSSRC_INTERNAL     (0 << LPAIF_I2SCTL_WSSRC_SHIFT)
+#define LPAIF_I2SCTL_WSSRC_EXTERNAL     (1 << LPAIF_I2SCTL_WSSRC_SHIFT)
+#define LPAIF_I2SCTL_BITWIDTH_MASK      0x0003
+#define LPAIF_I2SCTL_BITWIDTH_SHIFT     0
+#define LPAIF_I2SCTL_BITWIDTH_16        (0 << LPAIF_I2SCTL_BITWIDTH_SHIFT)
+#define LPAIF_I2SCTL_BITWIDTH_24        (1 << LPAIF_I2SCTL_BITWIDTH_SHIFT)
+#define LPAIF_I2SCTL_BITWIDTH_32        (2 << LPAIF_I2SCTL_BITWIDTH_SHIFT)
+/* LPAIF IRQ */
+#define LPAIF_IRQ_REG_BASE              0x3000
+#define LPAIF_IRQ_REG_STRIDE            0x1000
+#define LPAIF_IRQ_REG_ADDR(addr, port) \
+        (LPAIF_IRQ_REG_BASE + (addr) + (LPAIF_IRQ_REG_STRIDE * (port)))
+enum lpaif_irq_ports {
+        LPAIF_IRQ_PORT_MIN              = 0,
+        LPAIF_IRQ_PORT_HOST             = 0,
+        LPAIF_IRQ_PORT_ADSP             = 1,
+        LPAIF_IRQ_PORT_MAX              = 2,
+        LPAIF_IRQ_PORT_NUM              = 3,
+};
+#define LPAIF_IRQEN_REG(port)           LPAIF_IRQ_REG_ADDR(0x0, (port))
+#define LPAIF_IRQSTAT_REG(port)         LPAIF_IRQ_REG_ADDR(0x4, (port))
+#define LPAIF_IRQCLEAR_REG(port)        LPAIF_IRQ_REG_ADDR(0xC, (port))
+#define LPAIF_IRQ_BITSTRIDE             3
+#define LPAIF_IRQ_PER(chan)             (1 << (LPAIF_IRQ_BITSTRIDE * (chan)))
+#define LPAIF_IRQ_XRUN(chan)            (2 << (LPAIF_IRQ_BITSTRIDE * (chan)))
+#define LPAIF_IRQ_ERR(chan)             (4 << (LPAIF_IRQ_BITSTRIDE * (chan)))
+#define LPAIF_IRQ_ALL(chan)             (7 << (LPAIF_IRQ_BITSTRIDE * (chan)))
+/* LPAIF DMA */
+#define LPAIF_RDMA_REG_BASE             0x6000
+#define LPAIF_RDMA_REG_STRIDE           0x1000
+#define LPAIF_RDMA_REG_ADDR(addr, chan) \
+        (LPAIF_RDMA_REG_BASE + (addr) + (LPAIF_RDMA_REG_STRIDE * (chan)))
+enum lpaif_dma_channels {
+        LPAIF_RDMA_CHAN_MIN             = 0,
+        LPAIF_RDMA_CHAN_MI2S            = 0,
+        LPAIF_RDMA_CHAN_PCM0            = 1,
+        LPAIF_RDMA_CHAN_PCM1            = 2,
+        LPAIF_RDMA_CHAN_MAX             = 4,
+        LPAIF_RDMA_CHAN_NUM             = 5,
+};
+#define LPAIF_RDMACTL_REG(chan)         LPAIF_RDMA_REG_ADDR(0x00, (chan))
+#define LPAIF_RDMABASE_REG(chan)        LPAIF_RDMA_REG_ADDR(0x04, (chan))
+#define LPAIF_RDMABUFF_REG(chan)        LPAIF_RDMA_REG_ADDR(0x08, (chan))
+#define LPAIF_RDMACURR_REG(chan)        LPAIF_RDMA_REG_ADDR(0x0C, (chan))
+#define LPAIF_RDMAPER_REG(chan)         LPAIF_RDMA_REG_ADDR(0x10, (chan))
+#define LPAIF_RDMACTL_BURSTEN_MASK      0x800
+#define LPAIF_RDMACTL_BURSTEN_SHIFT     11
+#define LPAIF_RDMACTL_BURSTEN_SINGLE    (0 << LPAIF_RDMACTL_BURSTEN_SHIFT)
+#define LPAIF_RDMACTL_BURSTEN_INCR4     (1 << LPAIF_RDMACTL_BURSTEN_SHIFT)
+#define LPAIF_RDMACTL_WPSCNT_MASK       0x700
+#define LPAIF_RDMACTL_WPSCNT_SHIFT      8
+#define LPAIF_RDMACTL_WPSCNT_ONE        (0 << LPAIF_RDMACTL_WPSCNT_SHIFT)
+#define LPAIF_RDMACTL_WPSCNT_TWO        (1 << LPAIF_RDMACTL_WPSCNT_SHIFT)
+#define LPAIF_RDMACTL_WPSCNT_THREE      (2 << LPAIF_RDMACTL_WPSCNT_SHIFT)
+#define LPAIF_RDMACTL_WPSCNT_FOUR       (3 << LPAIF_RDMACTL_WPSCNT_SHIFT)
+#define LPAIF_RDMACTL_WPSCNT_SIX        (5 << LPAIF_RDMACTL_WPSCNT_SHIFT)
+#define LPAIF_RDMACTL_WPSCNT_EIGHT      (7 << LPAIF_RDMACTL_WPSCNT_SHIFT)
+#define LPAIF_RDMACTL_AUDINTF_MASK      0x0F0
+#define LPAIF_RDMACTL_AUDINTF_SHIFT     4
+#define LPAIF_RDMACTL_AUDINTF_NONE      (0 << LPAIF_RDMACTL_AUDINTF_SHIFT)
+#define LPAIF_RDMACTL_AUDINTF_CODEC     (1 << LPAIF_RDMACTL_AUDINTF_SHIFT)
+#define LPAIF_RDMACTL_AUDINTF_PCM       (2 << LPAIF_RDMACTL_AUDINTF_SHIFT)
+#define LPAIF_RDMACTL_AUDINTF_SEC_I2S   (3 << LPAIF_RDMACTL_AUDINTF_SHIFT)
+#define LPAIF_RDMACTL_AUDINTF_MI2S      (4 << LPAIF_RDMACTL_AUDINTF_SHIFT)
+#define LPAIF_RDMACTL_AUDINTF_HDMI      (5 << LPAIF_RDMACTL_AUDINTF_SHIFT)
+#define LPAIF_RDMACTL_AUDINTF_SEC_PCM   (7 << LPAIF_RDMACTL_AUDINTF_SHIFT)
+#define LPAIF_RDMACTL_FIFOWM_MASK       0x00E
+#define LPAIF_RDMACTL_FIFOWM_SHIFT      1
+#define LPAIF_RDMACTL_FIFOWM_1          (0 << LPAIF_RDMACTL_FIFOWM_SHIFT)
+#define LPAIF_RDMACTL_FIFOWM_2          (1 << LPAIF_RDMACTL_FIFOWM_SHIFT)
+#define LPAIF_RDMACTL_FIFOWM_3          (2 << LPAIF_RDMACTL_FIFOWM_SHIFT)
+#define LPAIF_RDMACTL_FIFOWM_4          (3 << LPAIF_RDMACTL_FIFOWM_SHIFT)
+#define LPAIF_RDMACTL_FIFOWM_5          (4 << LPAIF_RDMACTL_FIFOWM_SHIFT)
+#define LPAIF_RDMACTL_FIFOWM_6          (5 << LPAIF_RDMACTL_FIFOWM_SHIFT)
+#define LPAIF_RDMACTL_FIFOWM_7          (6 << LPAIF_RDMACTL_FIFOWM_SHIFT)
+#define LPAIF_RDMACTL_FIFOWM_8          (7 << LPAIF_RDMACTL_FIFOWM_SHIFT)
+#define LPAIF_RDMACTL_ENABLE_MASK       0x1
+#define LPAIF_RDMACTL_ENABLE_SHIFT      0
+#define LPAIF_RDMACTL_ENABLE_OFF        (0 << LPAIF_RDMACTL_ENABLE_SHIFT)
+#define LPAIF_RDMACTL_ENABLE_ON         (1 << LPAIF_RDMACTL_ENABLE_SHIFT)
+#endif /* __LPASS_LPAIF_H__ */
diff --git a/sound/soc/qcom/lpass-platform.c b/sound/soc/qcom/lpass-platform.c
new file mode 100644
index 000000000000..2fa6280dfb23
--- /dev/null
+++ b/sound/soc/qcom/lpass-platform.c
@@ -0,0 +1,526 @@
+/*
+ * Copyright (c) 2010-2011,2013-2015 The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * lpass-platform.c -- ALSA SoC platform driver for QTi LPASS
+ */
+#include <linux/compiler.h>
+#include <linux/device.h>
+#include <linux/dma-mapping.h>
+#include <linux/err.h>
+#include <linux/export.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/io.h>
+#include <linux/platform_device.h>
+#include <sound/memalloc.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <linux/regmap.h>
+#include <sound/soc.h>
+#include "lpass-lpaif-ipq806x.h"
+#include "lpass.h"
+#define LPASS_PLATFORM_BUFFER_SIZE      (16 * 1024)
+#define LPASS_PLATFORM_PERIODS          2
+static struct snd_pcm_hardware lpass_platform_pcm_hardware = {
+        .info                   =       SNDRV_PCM_INFO_MMAP |
+                                        SNDRV_PCM_INFO_MMAP_VALID |
+                                        SNDRV_PCM_INFO_INTERLEAVED |
+                                        SNDRV_PCM_INFO_PAUSE |
+                                        SNDRV_PCM_INFO_RESUME,
+        .formats                =       SNDRV_PCM_FMTBIT_S16 |
+                                        SNDRV_PCM_FMTBIT_S24 |
+                                        SNDRV_PCM_FMTBIT_S32,
+        .rates                  =       SNDRV_PCM_RATE_8000_192000,
+        .rate_min               =       8000,
+        .rate_max               =       192000,
+        .channels_min           =       1,
+        .channels_max           =       8,
+        .buffer_bytes_max       =       LPASS_PLATFORM_BUFFER_SIZE,
+        .period_bytes_max       =       LPASS_PLATFORM_BUFFER_SIZE /
+                                                LPASS_PLATFORM_PERIODS,
+        .period_bytes_min       =       LPASS_PLATFORM_BUFFER_SIZE /
+                                                LPASS_PLATFORM_PERIODS,
+        .periods_min            =       LPASS_PLATFORM_PERIODS,
+        .periods_max            =       LPASS_PLATFORM_PERIODS,
+        .fifo_size              =       0,
+};
+static int lpass_platform_pcmops_open(struct snd_pcm_substream *substream)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
+        int ret;
+        snd_soc_set_runtime_hwparams(substream, &lpass_platform_pcm_hardware);
+        runtime->dma_bytes = lpass_platform_pcm_hardware.buffer_bytes_max;
+        ret = snd_pcm_hw_constraint_integer(runtime,
+                        SNDRV_PCM_HW_PARAM_PERIODS);
+        if (ret < 0) {
+                dev_err(soc_runtime->dev, "%s() setting constraints failed: %d\n",
+                                __func__, ret);
+                return -EINVAL;
+        }
+        snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer);
+        return 0;
+}
+static int lpass_platform_pcmops_hw_params(struct snd_pcm_substream *substream,
+                struct snd_pcm_hw_params *params)
+{
+        struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
+        struct lpass_data *drvdata =
+                snd_soc_platform_get_drvdata(soc_runtime->platform);
+        snd_pcm_format_t format = params_format(params);
+        unsigned int channels = params_channels(params);
+        unsigned int regval;
+        int bitwidth;
+        int ret;
+        bitwidth = snd_pcm_format_width(format);
+        if (bitwidth < 0) {
+                dev_err(soc_runtime->dev, "%s() invalid bit width given: %d\n",
+                                __func__, bitwidth);
+                return bitwidth;
+        }
+        regval = LPAIF_RDMACTL_BURSTEN_INCR4 |
+                        LPAIF_RDMACTL_AUDINTF_MI2S |
+                        LPAIF_RDMACTL_FIFOWM_8;
+        switch (bitwidth) {
+        case 16:
+                switch (channels) {
+                case 1:
+                case 2:
+                        regval |= LPAIF_RDMACTL_WPSCNT_ONE;
+                        break;
+                case 4:
+                        regval |= LPAIF_RDMACTL_WPSCNT_TWO;
+                        break;
+                case 6:
+                        regval |= LPAIF_RDMACTL_WPSCNT_THREE;
+                        break;
+                case 8:
+                        regval |= LPAIF_RDMACTL_WPSCNT_FOUR;
+                        break;
+                default:
+                        dev_err(soc_runtime->dev, "%s() invalid PCM config given: bw=%d, ch=%u\n",
+                                        __func__, bitwidth, channels);
+                        return -EINVAL;
+                }
+                break;
+        case 24:
+        case 32:
+                switch (channels) {
+                case 1:
+                        regval |= LPAIF_RDMACTL_WPSCNT_ONE;
+                        break;
+                case 2:
+                        regval |= LPAIF_RDMACTL_WPSCNT_TWO;
+                        break;
+                case 4:
+                        regval |= LPAIF_RDMACTL_WPSCNT_FOUR;
+                        break;
+                case 6:
+                        regval |= LPAIF_RDMACTL_WPSCNT_SIX;
+                        break;
+                case 8:
+                        regval |= LPAIF_RDMACTL_WPSCNT_EIGHT;
+                        break;
+                default:
+                        dev_err(soc_runtime->dev, "%s() invalid PCM config given: bw=%d, ch=%u\n",
+                                        __func__, bitwidth, channels);
+                        return -EINVAL;
+                }
+                break;
+        default:
+                dev_err(soc_runtime->dev, "%s() invalid PCM config given: bw=%d, ch=%u\n",
+                                __func__, bitwidth, channels);
+                return -EINVAL;
+        }
+        ret = regmap_write(drvdata->lpaif_map,
+                        LPAIF_RDMACTL_REG(LPAIF_RDMA_CHAN_MI2S), regval);
+        if (ret) {
+                dev_err(soc_runtime->dev, "%s() error writing to rdmactl reg: %d\n",
+                                __func__, ret);
+                return ret;
+        }
+        return 0;
+}
+static int lpass_platform_pcmops_hw_free(struct snd_pcm_substream *substream)
+{
+        struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
+        struct lpass_data *drvdata =
+                snd_soc_platform_get_drvdata(soc_runtime->platform);
+        int ret;
+        ret = regmap_write(drvdata->lpaif_map,
+                        LPAIF_RDMACTL_REG(LPAIF_RDMA_CHAN_MI2S), 0);
+        if (ret)
+                dev_err(soc_runtime->dev, "%s() error writing to rdmactl reg: %d\n",
+                                __func__, ret);
+        return ret;
+}
+static int lpass_platform_pcmops_prepare(struct snd_pcm_substream *substream)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
+        struct lpass_data *drvdata =
+                snd_soc_platform_get_drvdata(soc_runtime->platform);
+        int ret;
+        ret = regmap_write(drvdata->lpaif_map,
+                        LPAIF_RDMABASE_REG(LPAIF_RDMA_CHAN_MI2S),
+                        runtime->dma_addr);
+        if (ret) {
+                dev_err(soc_runtime->dev, "%s() error writing to rdmabase reg: %d\n",
+                                __func__, ret);
+                return ret;
+        }
+        ret = regmap_write(drvdata->lpaif_map,
+                        LPAIF_RDMABUFF_REG(LPAIF_RDMA_CHAN_MI2S),
+                        (snd_pcm_lib_buffer_bytes(substream) >> 2) - 1);
+        if (ret) {
+                dev_err(soc_runtime->dev, "%s() error writing to rdmabuff reg: %d\n",
+                                __func__, ret);
+                return ret;
+        }
+        ret = regmap_write(drvdata->lpaif_map,
+                        LPAIF_RDMAPER_REG(LPAIF_RDMA_CHAN_MI2S),
+                        (snd_pcm_lib_period_bytes(substream) >> 2) - 1);
+        if (ret) {
+                dev_err(soc_runtime->dev, "%s() error writing to rdmaper reg: %d\n",
+                                __func__, ret);
+                return ret;
+        }
+        ret = regmap_update_bits(drvdata->lpaif_map,
+                        LPAIF_RDMACTL_REG(LPAIF_RDMA_CHAN_MI2S),
+                        LPAIF_RDMACTL_ENABLE_MASK, LPAIF_RDMACTL_ENABLE_ON);
+        if (ret) {
+                dev_err(soc_runtime->dev, "%s() error writing to rdmactl reg: %d\n",
+                                __func__, ret);
+                return ret;
+        }
+        return 0;
+}
+static int lpass_platform_pcmops_trigger(struct snd_pcm_substream *substream,
+                int cmd)
+{
+        struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
+        struct lpass_data *drvdata =
+                snd_soc_platform_get_drvdata(soc_runtime->platform);
+        int ret;
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+        case SNDRV_PCM_TRIGGER_RESUME:
+        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
+                /* clear status before enabling interrupts */
+                ret = regmap_write(drvdata->lpaif_map,
+                                LPAIF_IRQCLEAR_REG(LPAIF_IRQ_PORT_HOST),
+                                LPAIF_IRQ_ALL(LPAIF_RDMA_CHAN_MI2S));
+                if (ret) {
+                        dev_err(soc_runtime->dev, "%s() error writing to irqclear reg: %d\n",
+                                        __func__, ret);
+                        return ret;
+                }
+                ret = regmap_update_bits(drvdata->lpaif_map,
+                                LPAIF_IRQEN_REG(LPAIF_IRQ_PORT_HOST),
+                                LPAIF_IRQ_ALL(LPAIF_RDMA_CHAN_MI2S),
+                                LPAIF_IRQ_ALL(LPAIF_RDMA_CHAN_MI2S));
+                if (ret) {
+                        dev_err(soc_runtime->dev, "%s() error writing to irqen reg: %d\n",
+                                        __func__, ret);
+                        return ret;
+                }
+                ret = regmap_update_bits(drvdata->lpaif_map,
+                                LPAIF_RDMACTL_REG(LPAIF_RDMA_CHAN_MI2S),
+                                LPAIF_RDMACTL_ENABLE_MASK,
+                                LPAIF_RDMACTL_ENABLE_ON);
+                if (ret) {
+                        dev_err(soc_runtime->dev, "%s() error writing to rdmactl reg: %d\n",
+                                        __func__, ret);
+                        return ret;
+                }
+                break;
+        case SNDRV_PCM_TRIGGER_STOP:
+        case SNDRV_PCM_TRIGGER_SUSPEND:
+        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
+                ret = regmap_update_bits(drvdata->lpaif_map,
+                                LPAIF_RDMACTL_REG(LPAIF_RDMA_CHAN_MI2S),
+                                LPAIF_RDMACTL_ENABLE_MASK,
+                                LPAIF_RDMACTL_ENABLE_OFF);
+                if (ret) {
+                        dev_err(soc_runtime->dev, "%s() error writing to rdmactl reg: %d\n",
+                                        __func__, ret);
+                        return ret;
+                }
+                ret = regmap_update_bits(drvdata->lpaif_map,
+                                LPAIF_IRQEN_REG(LPAIF_IRQ_PORT_HOST),
+                                LPAIF_IRQ_ALL(LPAIF_RDMA_CHAN_MI2S), 0);
+                if (ret) {
+                        dev_err(soc_runtime->dev, "%s() error writing to irqen reg: %d\n",
+                                        __func__, ret);
+                        return ret;
+                }
+                break;
+        }
+        return 0;
+}
+static snd_pcm_uframes_t lpass_platform_pcmops_pointer(
+                struct snd_pcm_substream *substream)
+{
+        struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
+        struct lpass_data *drvdata =
+                        snd_soc_platform_get_drvdata(soc_runtime->platform);
+        unsigned int base_addr, curr_addr;
+        int ret;
+        ret = regmap_read(drvdata->lpaif_map,
+                        LPAIF_RDMABASE_REG(LPAIF_RDMA_CHAN_MI2S), &base_addr);
+        if (ret) {
+                dev_err(soc_runtime->dev, "%s() error reading from rdmabase reg: %d\n",
+                                __func__, ret);
+                return ret;
+        }
+        ret = regmap_read(drvdata->lpaif_map,
+                        LPAIF_RDMACURR_REG(LPAIF_RDMA_CHAN_MI2S), &curr_addr);
+        if (ret) {
+                dev_err(soc_runtime->dev, "%s() error reading from rdmacurr reg: %d\n",
+                                __func__, ret);
+                return ret;
+        }
+        return bytes_to_frames(substream->runtime, curr_addr - base_addr);
+}
+static int lpass_platform_pcmops_mmap(struct snd_pcm_substream *substream,
+                struct vm_area_struct *vma)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        return dma_mmap_coherent(substream->pcm->card->dev, vma,
+                        runtime->dma_area, runtime->dma_addr,
+                        runtime->dma_bytes);
+}
+static struct snd_pcm_ops lpass_platform_pcm_ops = {
+        .open           = lpass_platform_pcmops_open,
+        .ioctl          = snd_pcm_lib_ioctl,
+        .hw_params      = lpass_platform_pcmops_hw_params,
+        .hw_free        = lpass_platform_pcmops_hw_free,
+        .prepare        = lpass_platform_pcmops_prepare,
+        .trigger        = lpass_platform_pcmops_trigger,
+        .pointer        = lpass_platform_pcmops_pointer,
+        .mmap           = lpass_platform_pcmops_mmap,
+};
+static irqreturn_t lpass_platform_lpaif_irq(int irq, void *data)
+{
+        struct snd_pcm_substream *substream = data;
+        struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
+        struct lpass_data *drvdata =
+                snd_soc_platform_get_drvdata(soc_runtime->platform);
+        unsigned int interrupts;
+        irqreturn_t ret = IRQ_NONE;
+        int rv;
+        rv = regmap_read(drvdata->lpaif_map,
+                        LPAIF_IRQSTAT_REG(LPAIF_IRQ_PORT_HOST), &interrupts);
+        if (rv) {
+                dev_err(soc_runtime->dev, "%s() error reading from irqstat reg: %d\n",
+                                __func__, rv);
+                return IRQ_NONE;
+        }
+        interrupts &= LPAIF_IRQ_ALL(LPAIF_RDMA_CHAN_MI2S);
+        if (interrupts & LPAIF_IRQ_PER(LPAIF_RDMA_CHAN_MI2S)) {
+                rv = regmap_write(drvdata->lpaif_map,
+                                LPAIF_IRQCLEAR_REG(LPAIF_IRQ_PORT_HOST),
+                                LPAIF_IRQ_PER(LPAIF_RDMA_CHAN_MI2S));
+                if (rv) {
+                        dev_err(soc_runtime->dev, "%s() error writing to irqclear reg: %d\n",
+                                        __func__, rv);
+                        return IRQ_NONE;
+                }
+                snd_pcm_period_elapsed(substream);
+                ret = IRQ_HANDLED;
+        }
+        if (interrupts & LPAIF_IRQ_XRUN(LPAIF_RDMA_CHAN_MI2S)) {
+                rv = regmap_write(drvdata->lpaif_map,
+                                LPAIF_IRQCLEAR_REG(LPAIF_IRQ_PORT_HOST),
+                                LPAIF_IRQ_XRUN(LPAIF_RDMA_CHAN_MI2S));
+                if (rv) {
+                        dev_err(soc_runtime->dev, "%s() error writing to irqclear reg: %d\n",
+                                        __func__, rv);
+                        return IRQ_NONE;
+                }
+                dev_warn(soc_runtime->dev, "%s() xrun warning\n", __func__);
+                snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
+                ret = IRQ_HANDLED;
+        }
+        if (interrupts & LPAIF_IRQ_ERR(LPAIF_RDMA_CHAN_MI2S)) {
+                rv = regmap_write(drvdata->lpaif_map,
+                                LPAIF_IRQCLEAR_REG(LPAIF_IRQ_PORT_HOST),
+                                LPAIF_IRQ_ERR(LPAIF_RDMA_CHAN_MI2S));
+                if (rv) {
+                        dev_err(soc_runtime->dev, "%s() error writing to irqclear reg: %d\n",
+                                        __func__, rv);
+                        return IRQ_NONE;
+                }
+                dev_err(soc_runtime->dev, "%s() bus access error\n", __func__);
+                snd_pcm_stop(substream, SNDRV_PCM_STATE_DISCONNECTED);
+                ret = IRQ_HANDLED;
+        }
+        return ret;
+}
+static int lpass_platform_alloc_buffer(struct snd_pcm_substream *substream,
+                struct snd_soc_pcm_runtime *soc_runtime)
+{
+        struct snd_dma_buffer *buf = &substream->dma_buffer;
+        size_t size = lpass_platform_pcm_hardware.buffer_bytes_max;
+        buf->dev.type = SNDRV_DMA_TYPE_DEV;
+        buf->dev.dev = soc_runtime->dev;
+        buf->private_data = NULL;
+        buf->area = dma_alloc_coherent(soc_runtime->dev, size, &buf->addr,
+                        GFP_KERNEL);
+        if (!buf->area) {
+                dev_err(soc_runtime->dev, "%s: Could not allocate DMA buffer\n",
+                                __func__);
+                return -ENOMEM;
+        }
+        buf->bytes = size;
+        return 0;
+}
+static void lpass_platform_free_buffer(struct snd_pcm_substream *substream,
+                struct snd_soc_pcm_runtime *soc_runtime)
+{
+        struct snd_dma_buffer *buf = &substream->dma_buffer;
+        if (buf->area) {
+                dma_free_coherent(soc_runtime->dev, buf->bytes, buf->area,
+                                buf->addr);
+        }
+        buf->area = NULL;
+}
+static int lpass_platform_pcm_new(struct snd_soc_pcm_runtime *soc_runtime)
+{
+        struct snd_pcm *pcm = soc_runtime->pcm;
+        struct snd_pcm_substream *substream =
+                pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream;
+        struct lpass_data *drvdata =
+                snd_soc_platform_get_drvdata(soc_runtime->platform);
+        int ret;
+        soc_runtime->dev->coherent_dma_mask = DMA_BIT_MASK(32);
+        soc_runtime->dev->dma_mask = &soc_runtime->dev->coherent_dma_mask;
+        ret = lpass_platform_alloc_buffer(substream, soc_runtime);
+        if (ret)
+                return ret;
+        ret = devm_request_irq(soc_runtime->dev, drvdata->lpaif_irq,
+                        lpass_platform_lpaif_irq, IRQF_TRIGGER_RISING,
+                        "lpass-irq-lpaif", substream);
+        if (ret) {
+                dev_err(soc_runtime->dev, "%s() irq request failed: %d\n",
+                                __func__, ret);
+                goto err_buf;
+        }
+        /* ensure audio hardware is disabled */
+        ret = regmap_write(drvdata->lpaif_map,
+                        LPAIF_IRQEN_REG(LPAIF_IRQ_PORT_HOST), 0);
+        if (ret) {
+                dev_err(soc_runtime->dev, "%s() error writing to irqen reg: %d\n",
+                                __func__, ret);
+                return ret;
+        }
+        ret = regmap_write(drvdata->lpaif_map,
+                        LPAIF_RDMACTL_REG(LPAIF_RDMA_CHAN_MI2S), 0);
+        if (ret) {
+                dev_err(soc_runtime->dev, "%s() error writing to rdmactl reg: %d\n",
+                                __func__, ret);
+                return ret;
+        }
+        return 0;
+err_buf:
+        lpass_platform_free_buffer(substream, soc_runtime);
+        return ret;
+}
+static void lpass_platform_pcm_free(struct snd_pcm *pcm)
+{
+        struct snd_pcm_substream *substream =
+                pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream;
+        struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
+        lpass_platform_free_buffer(substream, soc_runtime);
+}
+static struct snd_soc_platform_driver lpass_platform_driver = {
+        .pcm_new        = lpass_platform_pcm_new,
+        .pcm_free       = lpass_platform_pcm_free,
+        .ops            = &lpass_platform_pcm_ops,
+};
+int asoc_qcom_lpass_platform_register(struct platform_device *pdev)
+{
+        struct lpass_data *drvdata = platform_get_drvdata(pdev);
+        drvdata->lpaif_irq = platform_get_irq_byname(pdev, "lpass-irq-lpaif");
+        if (drvdata->lpaif_irq < 0) {
+                dev_err(&pdev->dev, "%s() error getting irq handle: %d\n",
+                                __func__, drvdata->lpaif_irq);
+                return -ENODEV;
+        }
+        return devm_snd_soc_register_platform(&pdev->dev,
+                        &lpass_platform_driver);
+}
+EXPORT_SYMBOL_GPL(asoc_qcom_lpass_platform_register);
+MODULE_DESCRIPTION("QTi LPASS Platform Driver");
+MODULE_LICENSE("GPL v2");
diff --git a/sound/soc/qcom/lpass.h b/sound/soc/qcom/lpass.h
new file mode 100644
index 000000000000..5c99b3dace86
--- /dev/null
+++ b/sound/soc/qcom/lpass.h
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2010-2011,2013-2015 The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * lpass.h - Definitions for the QTi LPASS
+ */
+#ifndef __LPASS_H__
+#define __LPASS_H__
+#include <linux/clk.h>
+#include <linux/compiler.h>
+#include <linux/platform_device.h>
+#include <linux/regmap.h>
+#define LPASS_AHBIX_CLOCK_FREQUENCY             131072000
+/* Both the CPU DAI and platform drivers will access this data */
+struct lpass_data {
+        /* AHB-I/X bus clocks inside the low-power audio subsystem (LPASS) */
+        struct clk *ahbix_clk;
+        /* MI2S system clock */
+        struct clk *mi2s_osr_clk;
+        /* MI2S bit clock (derived from system clock by a divider */
+        struct clk *mi2s_bit_clk;
+        /* low-power audio interface (LPAIF) registers */
+        void __iomem *lpaif;
+        /* regmap backed by the low-power audio interface (LPAIF) registers */
+        struct regmap *lpaif_map;
+        /* interrupts from the low-power audio interface (LPAIF) */
+        int lpaif_irq;
+};
+/* register the platform driver from the CPU DAI driver */
+int asoc_qcom_lpass_platform_register(struct platform_device *);
+#endif /* __LPASS_H__ */
diff --git a/sound/soc/qcom/storm.c b/sound/soc/qcom/storm.c
new file mode 100644
index 000000000000..b8bd296190ad
--- /dev/null
+++ b/sound/soc/qcom/storm.c
@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) 2010-2011,2013-2015 The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * storm.c -- ALSA SoC machine driver for QTi ipq806x-based Storm board
+ */
+#include <linux/device.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/mod_devicetable.h>
+#include <linux/platform_device.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/soc.h>
+#define STORM_SYSCLK_MULT                       4
+static int storm_ops_hw_params(struct snd_pcm_substream *substream,
+                struct snd_pcm_hw_params *params)
+{
+        struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
+        struct snd_soc_card *card = soc_runtime->card;
+        snd_pcm_format_t format = params_format(params);
+        unsigned int rate = params_rate(params);
+        unsigned int sysclk_freq;
+        int bitwidth, ret;
+        bitwidth = snd_pcm_format_width(format);
+        if (bitwidth < 0) {
+                dev_err(card->dev, "%s() invalid bit width given: %d\n",
+                                __func__, bitwidth);
+                return bitwidth;
+        }
+        /*
+         * as the CPU DAI is the I2S bus master and no system clock is needed by
+         * the MAX98357a DAC, simply set the system clock to be a constant
+         * multiple of the bit clock for the clock divider
+         */
+        sysclk_freq = rate * bitwidth * 2 * STORM_SYSCLK_MULT;
+        ret = snd_soc_dai_set_sysclk(soc_runtime->cpu_dai, 0, sysclk_freq, 0);
+        if (ret) {
+                dev_err(card->dev, "%s() error setting sysclk to %u: %d\n",
+                                __func__, sysclk_freq, ret);
+                return ret;
+        }
+        return 0;
+}
+static struct snd_soc_ops storm_soc_ops = {
+        .hw_params      = storm_ops_hw_params,
+};
+static struct snd_soc_dai_link storm_dai_link = {
+        .name           = "Primary",
+        .stream_name    = "Primary",
+        .codec_dai_name = "HiFi",
+        .ops            = &storm_soc_ops,
+};
+static struct snd_soc_card storm_soc_card = {
+        .name   = "ipq806x-storm",
+        .dev    = NULL,
+};
+static int storm_parse_of(struct snd_soc_card *card)
+{
+        struct snd_soc_dai_link *dai_link = card->dai_link;
+        struct device_node *np = card->dev->of_node;
+        dai_link->cpu_of_node = of_parse_phandle(np, "cpu", 0);
+        if (!dai_link->cpu_of_node) {
+                dev_err(card->dev, "%s() error getting cpu phandle\n",
+                                __func__);
+                return -EINVAL;
+        }
+        dai_link->platform_of_node = dai_link->cpu_of_node;
+        dai_link->codec_of_node = of_parse_phandle(np, "codec", 0);
+        if (!dai_link->codec_of_node) {
+                dev_err(card->dev, "%s() error getting codec phandle\n",
+                                __func__);
+                return -EINVAL;
+        }
+        return 0;
+}
+static int storm_platform_probe(struct platform_device *pdev)
+{
+        struct snd_soc_card *card = &storm_soc_card;
+        int ret;
+        if (card->dev) {
+                dev_err(&pdev->dev, "%s() error, existing soundcard\n",
+                                __func__);
+                return -ENODEV;
+        }
+        card->dev = &pdev->dev;
+        platform_set_drvdata(pdev, card);
+        ret = snd_soc_of_parse_card_name(card, "qcom,model");
+        if (ret) {
+                dev_err(&pdev->dev, "%s() error parsing card name: %d\n",
+                                __func__, ret);
+                return ret;
+        }
+        card->dai_link  = &storm_dai_link;
+        card->num_links = 1;
+        ret = storm_parse_of(card);
+        if (ret) {
+                dev_err(&pdev->dev, "%s() error resolving dai links: %d\n",
+                                __func__, ret);
+                return ret;
+        }
+        ret = devm_snd_soc_register_card(&pdev->dev, card);
+        if (ret == -EPROBE_DEFER) {
+                card->dev = NULL;
+                return ret;
+        } else if (ret) {
+                dev_err(&pdev->dev, "%s() error registering soundcard: %d\n",
+                                __func__, ret);
+                return ret;
+        }
+        return 0;
+}
+#ifdef CONFIG_OF
+static const struct of_device_id storm_device_id[]  = {
+        { .compatible = "google,storm-audio" },
+        {},
+};
+MODULE_DEVICE_TABLE(of, storm_device_id);
+#endif
+static struct platform_driver storm_platform_driver = {
+        .driver = {
+                .name = "storm-audio",
+                .of_match_table =
+                        of_match_ptr(storm_device_id),
+        },
+        .probe = storm_platform_probe,
+};
+module_platform_driver(storm_platform_driver);
+MODULE_DESCRIPTION("QTi IPQ806x-based Storm Machine Driver");
+MODULE_LICENSE("GPL v2");
diff --git a/sound/soc/sh/Kconfig b/sound/soc/sh/Kconfig
index 80245b6eebd6..07114b0b0dc1 100644
--- a/sound/soc/sh/Kconfig
+++ b/sound/soc/sh/Kconfig
@@ -36,11 +36,17 @@ config SND_SOC_SH4_SIU
 config SND_SOC_RCAR
        tristate "R-Car series SRU/SCU/SSIU/SSI support"
+        depends on DMA_OF
        select SND_SIMPLE_CARD
        select REGMAP_MMIO
        help
          This option enables R-Car SUR/SCU/SSIU/SSI sound support
+config SND_SOC_RSRC_CARD
+        tristate "Renesas Sampling Rate Convert Sound Card"
+        help
+          This option enables simple sound if you need sampling rate convert
 ##
 ## Boards
 ##
diff --git a/sound/soc/sh/fsi.c b/sound/soc/sh/fsi.c
index b87b22e88e43..0c2af21b0b82 100644
--- a/sound/soc/sh/fsi.c
+++ b/sound/soc/sh/fsi.c
@@ -1876,7 +1876,40 @@ static void fsi_handler_init(struct fsi_priv *fsi,
        }
 }
-static struct of_device_id fsi_of_match[];
+static const struct fsi_core fsi1_core = {
+        .ver    = 1,
+        /* Interrupt */
+        .int_st = INT_ST,
+        .iemsk  = IEMSK,
+        .imsk   = IMSK,
+};
+static const struct fsi_core fsi2_core = {
+        .ver    = 2,
+        /* Interrupt */
+        .int_st = CPU_INT_ST,
+        .iemsk  = CPU_IEMSK,
+        .imsk   = CPU_IMSK,
+        .a_mclk = A_MST_CTLR,
+        .b_mclk = B_MST_CTLR,
+};
+static const struct of_device_id fsi_of_match[] = {
+        { .compatible = "renesas,sh_fsi",       .data = &fsi1_core},
+        { .compatible = "renesas,sh_fsi2",      .data = &fsi2_core},
+        {},
+};
+MODULE_DEVICE_TABLE(of, fsi_of_match);
+static const struct platform_device_id fsi_id_table[] = {
+        { "sh_fsi",     (kernel_ulong_t)&fsi1_core },
+        { "sh_fsi2",    (kernel_ulong_t)&fsi2_core },
+        {},
+};
+MODULE_DEVICE_TABLE(platform, fsi_id_table);
 static int fsi_probe(struct platform_device *pdev)
 {
        struct fsi_master *master;
@@ -2072,40 +2105,6 @@ static struct dev_pm_ops fsi_pm_ops = {
        .resume                 = fsi_resume,
 };
-static struct fsi_core fsi1_core = {
-        .ver    = 1,
-        /* Interrupt */
-        .int_st = INT_ST,
-        .iemsk  = IEMSK,
-        .imsk   = IMSK,
-};
-static struct fsi_core fsi2_core = {
-        .ver    = 2,
-        /* Interrupt */
-        .int_st = CPU_INT_ST,
-        .iemsk  = CPU_IEMSK,
-        .imsk   = CPU_IMSK,
-        .a_mclk = A_MST_CTLR,
-        .b_mclk = B_MST_CTLR,
-};
-static struct of_device_id fsi_of_match[] = {
-        { .compatible = "renesas,sh_fsi",       .data = &fsi1_core},
-        { .compatible = "renesas,sh_fsi2",      .data = &fsi2_core},
-        {},
-};
-MODULE_DEVICE_TABLE(of, fsi_of_match);
-static struct platform_device_id fsi_id_table[] = {
-        { "sh_fsi",     (kernel_ulong_t)&fsi1_core },
-        { "sh_fsi2",    (kernel_ulong_t)&fsi2_core },
-        {},
-};
-MODULE_DEVICE_TABLE(platform, fsi_id_table);
 static struct platform_driver fsi_driver = {
        .driver         = {
                .name   = "fsi-pcm-audio",
@@ -2119,7 +2118,7 @@ static struct platform_driver fsi_driver = {
 module_platform_driver(fsi_driver);
-MODULE_LICENSE("GPL");
+MODULE_LICENSE("GPL v2");
 MODULE_DESCRIPTION("SuperH onchip FSI audio driver");
 MODULE_AUTHOR("Kuninori Morimoto <morimoto.kuninori@renesas.com>");
 MODULE_ALIAS("platform:fsi-pcm-audio");
diff --git a/sound/soc/sh/rcar/Makefile b/sound/soc/sh/rcar/Makefile
index 9ac536429800..f1b445173fba 100644
--- a/sound/soc/sh/rcar/Makefile
+++ b/sound/soc/sh/rcar/Makefile
@@ -1,2 +1,5 @@
-snd-soc-rcar-objs       := core.o gen.o src.o adg.o ssi.o dvc.o
+snd-soc-rcar-objs       := core.o gen.o dma.o src.o adg.o ssi.o dvc.o
-obj-$(CONFIG_SND_SOC_RCAR)      += snd-soc-rcar.o
-\ No newline at end of file
+obj-$(CONFIG_SND_SOC_RCAR)      += snd-soc-rcar.o
+snd-soc-rsrc-card-objs  := rsrc-card.o
+obj-$(CONFIG_SND_SOC_RSRC_CARD) += snd-soc-rsrc-card.o
diff --git a/sound/soc/sh/rcar/adg.c b/sound/soc/sh/rcar/adg.c
index 7ac35c9d1cb8..fefc881dbac2 100644
--- a/sound/soc/sh/rcar/adg.c
+++ b/sound/soc/sh/rcar/adg.c
@@ -183,6 +183,8 @@ int rsnd_adg_set_convert_clk_gen2(struct rsnd_mod *mod,
        rsnd_mod_bset(mod, DIV_EN, en, en);
+        dev_dbg(dev, "convert rate %d <-> %d\n", src_rate, dst_rate);
        return 0;
 }
@@ -432,7 +434,5 @@ int rsnd_adg_probe(struct platform_device *pdev,
        priv->adg = adg;
-        dev_dbg(dev, "adg probed\n");
        return 0;
 }
diff --git a/sound/soc/sh/rcar/core.c b/sound/soc/sh/rcar/core.c
index 110577c52317..9f48d75fa992 100644
--- a/sound/soc/sh/rcar/core.c
+++ b/sound/soc/sh/rcar/core.c
@@ -94,21 +94,20 @@
 *
 */
 #include <linux/pm_runtime.h>
-#include <linux/shdma-base.h>
 #include "rsnd.h"
 #define RSND_RATES SNDRV_PCM_RATE_8000_96000
 #define RSND_FMTS (SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S16_LE)
-static struct rsnd_of_data rsnd_of_data_gen1 = {
+static const struct rsnd_of_data rsnd_of_data_gen1 = {
        .flags = RSND_GEN1,
 };
-static struct rsnd_of_data rsnd_of_data_gen2 = {
+static const struct rsnd_of_data rsnd_of_data_gen2 = {
        .flags = RSND_GEN2,
 };
-static struct of_device_id rsnd_of_match[] = {
+static const struct of_device_id rsnd_of_match[] = {
        { .compatible = "renesas,rcar_sound-gen1", .data = &rsnd_of_data_gen1 },
        { .compatible = "renesas,rcar_sound-gen2", .data = &rsnd_of_data_gen2 },
        {},
@@ -138,249 +137,37 @@ char *rsnd_mod_name(struct rsnd_mod *mod)
        return mod->ops->name;
 }
-char *rsnd_mod_dma_name(struct rsnd_mod *mod)
+struct dma_chan *rsnd_mod_dma_req(struct rsnd_mod *mod)
 {
-        if (!mod || !mod->ops)
+        if (!mod || !mod->ops || !mod->ops->dma_req)
-                return "unknown";
+                return NULL;
-        if (!mod->ops->dma_name)
-                return mod->ops->name;
-        return mod->ops->dma_name(mod);
+        return mod->ops->dma_req(mod);
 }
-void rsnd_mod_init(struct rsnd_mod *mod,
+int rsnd_mod_init(struct rsnd_mod *mod,
                   struct rsnd_mod_ops *ops,
                   struct clk *clk,
                   enum rsnd_mod_type type,
                   int id)
 {
+        int ret = clk_prepare(clk);
+        if (ret)
+                return ret;
        mod->id         = id;
        mod->ops        = ops;
        mod->type       = type;
        mod->clk        = clk;
-}
-/*
- *      rsnd_dma functions
- */
-void rsnd_dma_stop(struct rsnd_dma *dma)
-{
-        dmaengine_terminate_all(dma->chan);
-}
-static void rsnd_dma_complete(void *data)
-{
-        struct rsnd_dma *dma = (struct rsnd_dma *)data;
-        struct rsnd_mod *mod = rsnd_dma_to_mod(dma);
-        struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
-        /*
-         * Renesas sound Gen1 needs 1 DMAC,
-         * Gen2 needs 2 DMAC.
-         * In Gen2 case, it are Audio-DMAC, and Audio-DMAC-peri-peri.
-         * But, Audio-DMAC-peri-peri doesn't have interrupt,
-         * and this driver is assuming that here.
-         *
-         * If Audio-DMAC-peri-peri has interrpt,
-         * rsnd_dai_pointer_update() will be called twice,
-         * ant it will breaks io->byte_pos
-         */
-        rsnd_dai_pointer_update(io, io->byte_per_period);
-}
-void rsnd_dma_start(struct rsnd_dma *dma)
-{
-        struct rsnd_mod *mod = rsnd_dma_to_mod(dma);
-        struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
-        struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
-        struct snd_pcm_substream *substream = io->substream;
-        struct device *dev = rsnd_priv_to_dev(priv);
-        struct dma_async_tx_descriptor *desc;
-        desc = dmaengine_prep_dma_cyclic(dma->chan,
-                                         (dma->addr) ? dma->addr :
-                                         substream->runtime->dma_addr,
-                                         snd_pcm_lib_buffer_bytes(substream),
-                                         snd_pcm_lib_period_bytes(substream),
-                                         dma->dir,
-                                         DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
-        if (!desc) {
-                dev_err(dev, "dmaengine_prep_slave_sg() fail\n");
-                return;
-        }
-        desc->callback          = rsnd_dma_complete;
-        desc->callback_param    = dma;
-        if (dmaengine_submit(desc) < 0) {
-                dev_err(dev, "dmaengine_submit() fail\n");
-                return;
-        }
-        dma_async_issue_pending(dma->chan);
-}
-int rsnd_dma_available(struct rsnd_dma *dma)
-{
-        return !!dma->chan;
-}
-#define DMA_NAME_SIZE 16
-#define MOD_MAX 4 /* MEM/SSI/SRC/DVC */
-static int _rsnd_dma_of_name(char *dma_name, struct rsnd_mod *mod)
-{
-        if (mod)
-                return snprintf(dma_name, DMA_NAME_SIZE / 2, "%s%d",
-                         rsnd_mod_dma_name(mod), rsnd_mod_id(mod));
-        else
-                return snprintf(dma_name, DMA_NAME_SIZE / 2, "mem");
-}
-static void rsnd_dma_of_name(struct rsnd_mod *mod_from,
-                             struct rsnd_mod *mod_to,
-                             char *dma_name)
-{
-        int index = 0;
-        index = _rsnd_dma_of_name(dma_name + index, mod_from);
-        *(dma_name + index++) = '_';
-        index = _rsnd_dma_of_name(dma_name + index, mod_to);
-}
-static void rsnd_dma_of_path(struct rsnd_dma *dma,
-                             int is_play,
-                             struct rsnd_mod **mod_from,
-                             struct rsnd_mod **mod_to)
-{
-        struct rsnd_mod *this = rsnd_dma_to_mod(dma);
-        struct rsnd_dai_stream *io = rsnd_mod_to_io(this);
-        struct rsnd_mod *ssi = rsnd_io_to_mod_ssi(io);
-        struct rsnd_mod *src = rsnd_io_to_mod_src(io);
-        struct rsnd_mod *dvc = rsnd_io_to_mod_dvc(io);
-        struct rsnd_mod *mod[MOD_MAX];
-        int i, index;
+        return ret;
-        for (i = 0; i < MOD_MAX; i++)
-                mod[i] = NULL;
-        /*
-         * in play case...
-         *
-         * src -> dst
-         *
-         * mem -> SSI
-         * mem -> SRC -> SSI
-         * mem -> SRC -> DVC -> SSI
-         */
-        mod[0] = NULL; /* for "mem" */
-        index = 1;
-        for (i = 1; i < MOD_MAX; i++) {
-                if (!src) {
-                        mod[i] = ssi;
-                } else if (!dvc) {
-                        mod[i] = src;
-                        src = NULL;
-                } else {
-                        if ((!is_play) && (this == src))
-                                this = dvc;
-                        mod[i] = (is_play) ? src : dvc;
-                        i++;
-                        mod[i] = (is_play) ? dvc : src;
-                        src = NULL;
-                        dvc = NULL;
-                }
-                if (mod[i] == this)
-                        index = i;
-                if (mod[i] == ssi)
-                        break;
-        }
-        if (is_play) {
-                *mod_from = mod[index - 1];
-                *mod_to   = mod[index];
-        } else {
-                *mod_from = mod[index];
-                *mod_to   = mod[index - 1];
-        }
-}
-int rsnd_dma_init(struct rsnd_priv *priv, struct rsnd_dma *dma,
-                  int is_play, int id)
-{
-        struct device *dev = rsnd_priv_to_dev(priv);
-        struct dma_slave_config cfg;
-        struct rsnd_mod *mod_from;
-        struct rsnd_mod *mod_to;
-        char dma_name[DMA_NAME_SIZE];
-        dma_cap_mask_t mask;
-        int ret;
-        if (dma->chan) {
-                dev_err(dev, "it already has dma channel\n");
-                return -EIO;
-        }
-        dma_cap_zero(mask);
-        dma_cap_set(DMA_SLAVE, mask);
-        rsnd_dma_of_path(dma, is_play, &mod_from, &mod_to);
-        rsnd_dma_of_name(mod_from, mod_to, dma_name);
-        cfg.slave_id    = id;
-        cfg.direction   = is_play ? DMA_MEM_TO_DEV : DMA_DEV_TO_MEM;
-        cfg.src_addr    = rsnd_gen_dma_addr(priv, mod_from, is_play, 1);
-        cfg.dst_addr    = rsnd_gen_dma_addr(priv, mod_to,   is_play, 0);
-        cfg.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
-        cfg.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
-        dev_dbg(dev, "dma : %s %pad -> %pad\n",
-                dma_name, &cfg.src_addr, &cfg.dst_addr);
-        dma->chan = dma_request_slave_channel_compat(mask, shdma_chan_filter,
-                                                     (void *)id, dev,
-                                                     dma_name);
-        if (!dma->chan) {
-                dev_err(dev, "can't get dma channel\n");
-                goto rsnd_dma_channel_err;
-        }
-        ret = dmaengine_slave_config(dma->chan, &cfg);
-        if (ret < 0)
-                goto rsnd_dma_init_err;
-        dma->addr = is_play ? cfg.src_addr : cfg.dst_addr;
-        dma->dir = is_play ? DMA_MEM_TO_DEV : DMA_DEV_TO_MEM;
-        return 0;
-rsnd_dma_init_err:
-        rsnd_dma_quit(priv, dma);
-rsnd_dma_channel_err:
-        /*
-         * DMA failed. try to PIO mode
-         * see
-         *      rsnd_ssi_fallback()
-         *      rsnd_rdai_continuance_probe()
-         */
-        return -EAGAIN;
 }
-void  rsnd_dma_quit(struct rsnd_priv *priv,
+void rsnd_mod_quit(struct rsnd_mod *mod)
-                    struct rsnd_dma *dma)
 {
-        if (dma->chan)
+        if (mod->clk)
-                dma_release_channel(dma->chan);
+                clk_unprepare(mod->clk);
-        dma->chan = NULL;
 }
 /*
@@ -416,7 +203,7 @@ u32 rsnd_get_adinr(struct rsnd_mod *mod)
 ({                                                              \
        struct rsnd_priv *priv = rsnd_mod_to_priv(mod);         \
        struct device *dev = rsnd_priv_to_dev(priv);            \
-        u32 mask = 1 << __rsnd_mod_shift_##func;                        \
+        u32 mask = (1 << __rsnd_mod_shift_##func) & ~(1 << 31); \
        u32 call = __rsnd_mod_call_##func << __rsnd_mod_shift_##func;   \
        int ret = 0;                                                    \
        if ((mod->status & mask) == call) {                             \
@@ -458,7 +245,7 @@ static int rsnd_dai_connect(struct rsnd_mod *mod,
                struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
                struct device *dev = rsnd_priv_to_dev(priv);
-                dev_err(dev, "%s%d is not empty\n",
+                dev_err(dev, "%s[%d] is not empty\n",
                        rsnd_mod_name(mod),
                        rsnd_mod_id(mod));
                return -EIO;
@@ -874,20 +661,28 @@ static int rsnd_dai_probe(struct platform_device *pdev,
                drv[i].name     = rdai[i].name;
                drv[i].ops      = &rsnd_soc_dai_ops;
                if (pmod) {
+                        snprintf(rdai[i].playback.name, RSND_DAI_NAME_SIZE,
+                                 "DAI%d Playback", i);
                        drv[i].playback.rates           = RSND_RATES;
                        drv[i].playback.formats         = RSND_FMTS;
                        drv[i].playback.channels_min    = 2;
                        drv[i].playback.channels_max    = 2;
+                        drv[i].playback.stream_name     = rdai[i].playback.name;
                        rdai[i].playback.info = &info->dai_info[i].playback;
                        rdai[i].playback.rdai = rdai + i;
                        rsnd_path_init(priv, &rdai[i], &rdai[i].playback);
                }
                if (cmod) {
+                        snprintf(rdai[i].capture.name, RSND_DAI_NAME_SIZE,
+                                 "DAI%d Capture", i);
                        drv[i].capture.rates            = RSND_RATES;
                        drv[i].capture.formats          = RSND_FMTS;
                        drv[i].capture.channels_min     = 2;
                        drv[i].capture.channels_max     = 2;
+                        drv[i].capture.stream_name      = rdai[i].capture.name;
                        rdai[i].capture.info = &info->dai_info[i].capture;
                        rdai[i].capture.rdai = rdai + i;
@@ -933,6 +728,15 @@ static int rsnd_pcm_open(struct snd_pcm_substream *substream)
 static int rsnd_hw_params(struct snd_pcm_substream *substream,
                         struct snd_pcm_hw_params *hw_params)
 {
+        struct snd_soc_dai *dai = rsnd_substream_to_dai(substream);
+        struct rsnd_dai *rdai = rsnd_dai_to_rdai(dai);
+        struct rsnd_dai_stream *io = rsnd_rdai_to_io(rdai, substream);
+        int ret;
+        ret = rsnd_dai_call(hw_params, io, substream, hw_params);
+        if (ret)
+                return ret;
        return snd_pcm_lib_malloc_pages(substream,
                                        params_buffer_bytes(hw_params));
 }
@@ -1197,6 +1001,7 @@ static int rsnd_probe(struct platform_device *pdev)
                            const struct rsnd_of_data *of_data,
                            struct rsnd_priv *priv) = {
                rsnd_gen_probe,
+                rsnd_dma_probe,
                rsnd_ssi_probe,
                rsnd_src_probe,
                rsnd_dvc_probe,
@@ -1290,6 +1095,12 @@ static int rsnd_remove(struct platform_device *pdev)
 {
        struct rsnd_priv *priv = dev_get_drvdata(&pdev->dev);
        struct rsnd_dai *rdai;
+        void (*remove_func[])(struct platform_device *pdev,
+                              struct rsnd_priv *priv) = {
+                rsnd_ssi_remove,
+                rsnd_src_remove,
+                rsnd_dvc_remove,
+        };
        int ret = 0, i;
        pm_runtime_disable(&pdev->dev);
@@ -1299,6 +1110,9 @@ static int rsnd_remove(struct platform_device *pdev)
                ret |= rsnd_dai_call(remove, &rdai->capture, priv);
        }
+        for (i = 0; i < ARRAY_SIZE(remove_func); i++)
+                remove_func[i](pdev, priv);
        snd_soc_unregister_component(&pdev->dev);
        snd_soc_unregister_platform(&pdev->dev);
diff --git a/sound/soc/sh/rcar/dma.c b/sound/soc/sh/rcar/dma.c
new file mode 100644
index 000000000000..ac3756f6af60
--- /dev/null
+++ b/sound/soc/sh/rcar/dma.c
@@ -0,0 +1,616 @@
+/*
+ * Renesas R-Car Audio DMAC support
+ *
+ * Copyright (C) 2015 Renesas Electronics Corp.
+ * Copyright (c) 2015 Kuninori Morimoto <kuninori.morimoto.gx@renesas.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/delay.h>
+#include <linux/of_dma.h>
+#include "rsnd.h"
+/*
+ * Audio DMAC peri peri register
+ */
+#define PDMASAR         0x00
+#define PDMADAR         0x04
+#define PDMACHCR        0x0c
+/* PDMACHCR */
+#define PDMACHCR_DE             (1 << 0)
+struct rsnd_dma_ctrl {
+        void __iomem *base;
+        int dmapp_num;
+};
+#define rsnd_priv_to_dmac(p)    ((struct rsnd_dma_ctrl *)(p)->dma)
+/*
+ *              Audio DMAC
+ */
+static void rsnd_dmaen_complete(void *data)
+{
+        struct rsnd_dma *dma = (struct rsnd_dma *)data;
+        struct rsnd_mod *mod = rsnd_dma_to_mod(dma);
+        struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
+        /*
+         * Renesas sound Gen1 needs 1 DMAC,
+         * Gen2 needs 2 DMAC.
+         * In Gen2 case, it are Audio-DMAC, and Audio-DMAC-peri-peri.
+         * But, Audio-DMAC-peri-peri doesn't have interrupt,
+         * and this driver is assuming that here.
+         *
+         * If Audio-DMAC-peri-peri has interrpt,
+         * rsnd_dai_pointer_update() will be called twice,
+         * ant it will breaks io->byte_pos
+         */
+        rsnd_dai_pointer_update(io, io->byte_per_period);
+}
+static void rsnd_dmaen_stop(struct rsnd_dma *dma)
+{
+        struct rsnd_dmaen *dmaen = rsnd_dma_to_dmaen(dma);
+        dmaengine_terminate_all(dmaen->chan);
+}
+static void rsnd_dmaen_start(struct rsnd_dma *dma)
+{
+        struct rsnd_dmaen *dmaen = rsnd_dma_to_dmaen(dma);
+        struct rsnd_mod *mod = rsnd_dma_to_mod(dma);
+        struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
+        struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
+        struct snd_pcm_substream *substream = io->substream;
+        struct device *dev = rsnd_priv_to_dev(priv);
+        struct dma_async_tx_descriptor *desc;
+        int is_play = rsnd_io_is_play(io);
+        desc = dmaengine_prep_dma_cyclic(dmaen->chan,
+                                         substream->runtime->dma_addr,
+                                         snd_pcm_lib_buffer_bytes(substream),
+                                         snd_pcm_lib_period_bytes(substream),
+                                         is_play ? DMA_MEM_TO_DEV : DMA_DEV_TO_MEM,
+                                         DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
+        if (!desc) {
+                dev_err(dev, "dmaengine_prep_slave_sg() fail\n");
+                return;
+        }
+        desc->callback          = rsnd_dmaen_complete;
+        desc->callback_param    = dma;
+        if (dmaengine_submit(desc) < 0) {
+                dev_err(dev, "dmaengine_submit() fail\n");
+                return;
+        }
+        dma_async_issue_pending(dmaen->chan);
+}
+struct dma_chan *rsnd_dma_request_channel(struct device_node *of_node,
+                                          struct rsnd_mod *mod, char *name)
+{
+        struct dma_chan *chan;
+        struct device_node *np;
+        int i = 0;
+        for_each_child_of_node(of_node, np) {
+                if (i == rsnd_mod_id(mod))
+                        break;
+                i++;
+        }
+        chan = of_dma_request_slave_channel(np, name);
+        of_node_put(np);
+        of_node_put(of_node);
+        return chan;
+}
+static struct dma_chan *rsnd_dmaen_request_channel(struct rsnd_mod *mod_from,
+                                                   struct rsnd_mod *mod_to)
+{
+        if ((!mod_from && !mod_to) ||
+            (mod_from && mod_to))
+                return NULL;
+        if (mod_from)
+                return rsnd_mod_dma_req(mod_from);
+        else
+                return rsnd_mod_dma_req(mod_to);
+}
+static int rsnd_dmaen_init(struct rsnd_priv *priv, struct rsnd_dma *dma, int id,
+                           struct rsnd_mod *mod_from, struct rsnd_mod *mod_to)
+{
+        struct rsnd_dmaen *dmaen = rsnd_dma_to_dmaen(dma);
+        struct device *dev = rsnd_priv_to_dev(priv);
+        struct dma_slave_config cfg = {};
+        struct rsnd_mod *mod = rsnd_dma_to_mod(dma);
+        struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
+        int is_play = rsnd_io_is_play(io);
+        int ret;
+        if (dmaen->chan) {
+                dev_err(dev, "it already has dma channel\n");
+                return -EIO;
+        }
+        if (dev->of_node) {
+                dmaen->chan = rsnd_dmaen_request_channel(mod_from, mod_to);
+        } else {
+                dma_cap_mask_t mask;
+                dma_cap_zero(mask);
+                dma_cap_set(DMA_SLAVE, mask);
+                dmaen->chan = dma_request_channel(mask, shdma_chan_filter,
+                                                  (void *)id);
+        }
+        if (IS_ERR_OR_NULL(dmaen->chan)) {
+                dev_err(dev, "can't get dma channel\n");
+                goto rsnd_dma_channel_err;
+        }
+        cfg.direction   = is_play ? DMA_MEM_TO_DEV : DMA_DEV_TO_MEM;
+        cfg.src_addr    = dma->src_addr;
+        cfg.dst_addr    = dma->dst_addr;
+        cfg.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
+        cfg.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
+        dev_dbg(dev, "dma : %pad -> %pad\n",
+                &cfg.src_addr, &cfg.dst_addr);
+        ret = dmaengine_slave_config(dmaen->chan, &cfg);
+        if (ret < 0)
+                goto rsnd_dma_init_err;
+        return 0;
+rsnd_dma_init_err:
+        rsnd_dma_quit(dma);
+rsnd_dma_channel_err:
+        /*
+         * DMA failed. try to PIO mode
+         * see
+         *      rsnd_ssi_fallback()
+         *      rsnd_rdai_continuance_probe()
+         */
+        return -EAGAIN;
+}
+static void rsnd_dmaen_quit(struct rsnd_dma *dma)
+{
+        struct rsnd_dmaen *dmaen = rsnd_dma_to_dmaen(dma);
+        if (dmaen->chan)
+                dma_release_channel(dmaen->chan);
+        dmaen->chan = NULL;
+}
+static struct rsnd_dma_ops rsnd_dmaen_ops = {
+        .start  = rsnd_dmaen_start,
+        .stop   = rsnd_dmaen_stop,
+        .init   = rsnd_dmaen_init,
+        .quit   = rsnd_dmaen_quit,
+};
+/*
+ *              Audio DMAC peri peri
+ */
+static const u8 gen2_id_table_ssiu[] = {
+        0x00, /* SSI00 */
+        0x04, /* SSI10 */
+        0x08, /* SSI20 */
+        0x0c, /* SSI3  */
+        0x0d, /* SSI4  */
+        0x0e, /* SSI5  */
+        0x0f, /* SSI6  */
+        0x10, /* SSI7  */
+        0x11, /* SSI8  */
+        0x12, /* SSI90 */
+};
+static const u8 gen2_id_table_scu[] = {
+        0x2d, /* SCU_SRCI0 */
+        0x2e, /* SCU_SRCI1 */
+        0x2f, /* SCU_SRCI2 */
+        0x30, /* SCU_SRCI3 */
+        0x31, /* SCU_SRCI4 */
+        0x32, /* SCU_SRCI5 */
+        0x33, /* SCU_SRCI6 */
+        0x34, /* SCU_SRCI7 */
+        0x35, /* SCU_SRCI8 */
+        0x36, /* SCU_SRCI9 */
+};
+static const u8 gen2_id_table_cmd[] = {
+        0x37, /* SCU_CMD0 */
+        0x38, /* SCU_CMD1 */
+};
+static u32 rsnd_dmapp_get_id(struct rsnd_mod *mod)
+{
+        struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
+        struct rsnd_mod *ssi = rsnd_io_to_mod_ssi(io);
+        struct rsnd_mod *src = rsnd_io_to_mod_src(io);
+        struct rsnd_mod *dvc = rsnd_io_to_mod_dvc(io);
+        const u8 *entry = NULL;
+        int id = rsnd_mod_id(mod);
+        int size = 0;
+        if (mod == ssi) {
+                entry = gen2_id_table_ssiu;
+                size = ARRAY_SIZE(gen2_id_table_ssiu);
+        } else if (mod == src) {
+                entry = gen2_id_table_scu;
+                size = ARRAY_SIZE(gen2_id_table_scu);
+        } else if (mod == dvc) {
+                entry = gen2_id_table_cmd;
+                size = ARRAY_SIZE(gen2_id_table_cmd);
+        }
+        if (!entry)
+                return 0xFF;
+        if (size <= id)
+                return 0xFF;
+        return entry[id];
+}
+static u32 rsnd_dmapp_get_chcr(struct rsnd_mod *mod_from,
+                               struct rsnd_mod *mod_to)
+{
+        return  (rsnd_dmapp_get_id(mod_from) << 24) +
+                (rsnd_dmapp_get_id(mod_to) << 16);
+}
+#define rsnd_dmapp_addr(dmac, dma, reg) \
+        (dmac->base + 0x20 + reg + \
+         (0x10 * rsnd_dma_to_dmapp(dma)->dmapp_id))
+static void rsnd_dmapp_write(struct rsnd_dma *dma, u32 data, u32 reg)
+{
+        struct rsnd_mod *mod = rsnd_dma_to_mod(dma);
+        struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
+        struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
+        struct device *dev = rsnd_priv_to_dev(priv);
+        dev_dbg(dev, "w %p : %08x\n", rsnd_dmapp_addr(dmac, dma, reg), data);
+        iowrite32(data, rsnd_dmapp_addr(dmac, dma, reg));
+}
+static u32 rsnd_dmapp_read(struct rsnd_dma *dma, u32 reg)
+{
+        struct rsnd_mod *mod = rsnd_dma_to_mod(dma);
+        struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
+        struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
+        return ioread32(rsnd_dmapp_addr(dmac, dma, reg));
+}
+static void rsnd_dmapp_stop(struct rsnd_dma *dma)
+{
+        int i;
+        rsnd_dmapp_write(dma, 0, PDMACHCR);
+        for (i = 0; i < 1024; i++) {
+                if (0 == rsnd_dmapp_read(dma, PDMACHCR))
+                        return;
+                udelay(1);
+        }
+}
+static void rsnd_dmapp_start(struct rsnd_dma *dma)
+{
+        struct rsnd_dmapp *dmapp = rsnd_dma_to_dmapp(dma);
+        rsnd_dmapp_write(dma, dma->src_addr,    PDMASAR);
+        rsnd_dmapp_write(dma, dma->dst_addr,    PDMADAR);
+        rsnd_dmapp_write(dma, dmapp->chcr,      PDMACHCR);
+}
+static int rsnd_dmapp_init(struct rsnd_priv *priv, struct rsnd_dma *dma, int id,
+                           struct rsnd_mod *mod_from, struct rsnd_mod *mod_to)
+{
+        struct rsnd_dmapp *dmapp = rsnd_dma_to_dmapp(dma);
+        struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
+        struct device *dev = rsnd_priv_to_dev(priv);
+        dmapp->dmapp_id = dmac->dmapp_num;
+        dmapp->chcr = rsnd_dmapp_get_chcr(mod_from, mod_to) | PDMACHCR_DE;
+        dmac->dmapp_num++;
+        rsnd_dmapp_stop(dma);
+        dev_dbg(dev, "id/src/dst/chcr = %d/%pad/%pad/%08x\n",
+                dmapp->dmapp_id, &dma->src_addr, &dma->dst_addr, dmapp->chcr);
+        return 0;
+}
+static struct rsnd_dma_ops rsnd_dmapp_ops = {
+        .start  = rsnd_dmapp_start,
+        .stop   = rsnd_dmapp_stop,
+        .init   = rsnd_dmapp_init,
+        .quit   = rsnd_dmapp_stop,
+};
+/*
+ *              Common DMAC Interface
+ */
+/*
+ *      DMA read/write register offset
+ *
+ *      RSND_xxx_I_N    for Audio DMAC input
+ *      RSND_xxx_O_N    for Audio DMAC output
+ *      RSND_xxx_I_P    for Audio DMAC peri peri input
+ *      RSND_xxx_O_P    for Audio DMAC peri peri output
+ *
+ *      ex) R-Car H2 case
+ *            mod        / DMAC in    / DMAC out   / DMAC PP in / DMAC pp out
+ *      SSI : 0xec541000 / 0xec241008 / 0xec24100c
+ *      SSIU: 0xec541000 / 0xec100000 / 0xec100000 / 0xec400000 / 0xec400000
+ *      SCU : 0xec500000 / 0xec000000 / 0xec004000 / 0xec300000 / 0xec304000
+ *      CMD : 0xec500000 /            / 0xec008000                0xec308000
+ */
+#define RDMA_SSI_I_N(addr, i)   (addr ##_reg - 0x00300000 + (0x40 * i) + 0x8)
+#define RDMA_SSI_O_N(addr, i)   (addr ##_reg - 0x00300000 + (0x40 * i) + 0xc)
+#define RDMA_SSIU_I_N(addr, i)  (addr ##_reg - 0x00441000 + (0x1000 * i))
+#define RDMA_SSIU_O_N(addr, i)  (addr ##_reg - 0x00441000 + (0x1000 * i))
+#define RDMA_SSIU_I_P(addr, i)  (addr ##_reg - 0x00141000 + (0x1000 * i))
+#define RDMA_SSIU_O_P(addr, i)  (addr ##_reg - 0x00141000 + (0x1000 * i))
+#define RDMA_SRC_I_N(addr, i)   (addr ##_reg - 0x00500000 + (0x400 * i))
+#define RDMA_SRC_O_N(addr, i)   (addr ##_reg - 0x004fc000 + (0x400 * i))
+#define RDMA_SRC_I_P(addr, i)   (addr ##_reg - 0x00200000 + (0x400 * i))
+#define RDMA_SRC_O_P(addr, i)   (addr ##_reg - 0x001fc000 + (0x400 * i))
+#define RDMA_CMD_O_N(addr, i)   (addr ##_reg - 0x004f8000 + (0x400 * i))
+#define RDMA_CMD_O_P(addr, i)   (addr ##_reg - 0x001f8000 + (0x400 * i))
+static dma_addr_t
+rsnd_gen2_dma_addr(struct rsnd_priv *priv,
+                   struct rsnd_mod *mod,
+                   int is_play, int is_from)
+{
+        struct device *dev = rsnd_priv_to_dev(priv);
+        struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
+        phys_addr_t ssi_reg = rsnd_gen_get_phy_addr(priv, RSND_GEN2_SSI);
+        phys_addr_t src_reg = rsnd_gen_get_phy_addr(priv, RSND_GEN2_SCU);
+        int is_ssi = !!(rsnd_io_to_mod_ssi(io) == mod);
+        int use_src = !!rsnd_io_to_mod_src(io);
+        int use_dvc = !!rsnd_io_to_mod_dvc(io);
+        int id = rsnd_mod_id(mod);
+        struct dma_addr {
+                dma_addr_t out_addr;
+                dma_addr_t in_addr;
+        } dma_addrs[3][2][3] = {
+                /* SRC */
+                {{{ 0,                          0 },
+                  /* Capture */
+                  { RDMA_SRC_O_N(src, id),      RDMA_SRC_I_P(src, id) },
+                  { RDMA_CMD_O_N(src, id),      RDMA_SRC_I_P(src, id) } },
+                 /* Playback */
+                 {{ 0,                          0, },
+                  { RDMA_SRC_O_P(src, id),      RDMA_SRC_I_N(src, id) },
+                  { RDMA_CMD_O_P(src, id),      RDMA_SRC_I_N(src, id) } }
+                },
+                /* SSI */
+                /* Capture */
+                {{{ RDMA_SSI_O_N(ssi, id),      0 },
+                  { RDMA_SSIU_O_P(ssi, id),     0 },
+                  { RDMA_SSIU_O_P(ssi, id),     0 } },
+                 /* Playback */
+                 {{ 0,                          RDMA_SSI_I_N(ssi, id) },
+                  { 0,                          RDMA_SSIU_I_P(ssi, id) },
+                  { 0,                          RDMA_SSIU_I_P(ssi, id) } }
+                },
+                /* SSIU */
+                /* Capture */
+                {{{ RDMA_SSIU_O_N(ssi, id),     0 },
+                  { RDMA_SSIU_O_P(ssi, id),     0 },
+                  { RDMA_SSIU_O_P(ssi, id),     0 } },
+                 /* Playback */
+                 {{ 0,                          RDMA_SSIU_I_N(ssi, id) },
+                  { 0,                          RDMA_SSIU_I_P(ssi, id) },
+                  { 0,                          RDMA_SSIU_I_P(ssi, id) } } },
+        };
+        /* it shouldn't happen */
+        if (use_dvc && !use_src)
+                dev_err(dev, "DVC is selected without SRC\n");
+        /* use SSIU or SSI ? */
+        if (is_ssi && rsnd_ssi_use_busif(mod))
+                is_ssi++;
+        return (is_from) ?
+                dma_addrs[is_ssi][is_play][use_src + use_dvc].out_addr :
+                dma_addrs[is_ssi][is_play][use_src + use_dvc].in_addr;
+}
+static dma_addr_t rsnd_dma_addr(struct rsnd_priv *priv,
+                                struct rsnd_mod *mod,
+                                int is_play, int is_from)
+{
+        /*
+         * gen1 uses default DMA addr
+         */
+        if (rsnd_is_gen1(priv))
+                return 0;
+        if (!mod)
+                return 0;
+        return rsnd_gen2_dma_addr(priv, mod, is_play, is_from);
+}
+#define MOD_MAX 4 /* MEM/SSI/SRC/DVC */
+static void rsnd_dma_of_path(struct rsnd_dma *dma,
+                             int is_play,
+                             struct rsnd_mod **mod_from,
+                             struct rsnd_mod **mod_to)
+{
+        struct rsnd_mod *this = rsnd_dma_to_mod(dma);
+        struct rsnd_dai_stream *io = rsnd_mod_to_io(this);
+        struct rsnd_mod *ssi = rsnd_io_to_mod_ssi(io);
+        struct rsnd_mod *src = rsnd_io_to_mod_src(io);
+        struct rsnd_mod *dvc = rsnd_io_to_mod_dvc(io);
+        struct rsnd_mod *mod[MOD_MAX];
+        int i, index;
+        for (i = 0; i < MOD_MAX; i++)
+                mod[i] = NULL;
+        /*
+         * in play case...
+         *
+         * src -> dst
+         *
+         * mem -> SSI
+         * mem -> SRC -> SSI
+         * mem -> SRC -> DVC -> SSI
+         */
+        mod[0] = NULL; /* for "mem" */
+        index = 1;
+        for (i = 1; i < MOD_MAX; i++) {
+                if (!src) {
+                        mod[i] = ssi;
+                } else if (!dvc) {
+                        mod[i] = src;
+                        src = NULL;
+                } else {
+                        if ((!is_play) && (this == src))
+                                this = dvc;
+                        mod[i] = (is_play) ? src : dvc;
+                        i++;
+                        mod[i] = (is_play) ? dvc : src;
+                        src = NULL;
+                        dvc = NULL;
+                }
+                if (mod[i] == this)
+                        index = i;
+                if (mod[i] == ssi)
+                        break;
+        }
+        if (is_play) {
+                *mod_from = mod[index - 1];
+                *mod_to   = mod[index];
+        } else {
+                *mod_from = mod[index];
+                *mod_to   = mod[index - 1];
+        }
+}
+void rsnd_dma_stop(struct rsnd_dma *dma)
+{
+        dma->ops->stop(dma);
+}
+void rsnd_dma_start(struct rsnd_dma *dma)
+{
+        dma->ops->start(dma);
+}
+void rsnd_dma_quit(struct rsnd_dma *dma)
+{
+        struct rsnd_mod *mod = rsnd_dma_to_mod(dma);
+        struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
+        struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
+        if (!dmac)
+                return;
+        dma->ops->quit(dma);
+}
+int rsnd_dma_init(struct rsnd_priv *priv, struct rsnd_dma *dma, int id)
+{
+        struct rsnd_mod *mod = rsnd_dma_to_mod(dma);
+        struct rsnd_mod *mod_from;
+        struct rsnd_mod *mod_to;
+        struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
+        struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);
+        int is_play = rsnd_io_is_play(io);
+        /*
+         * DMA failed. try to PIO mode
+         * see
+         *      rsnd_ssi_fallback()
+         *      rsnd_rdai_continuance_probe()
+         */
+        if (!dmac)
+                return -EAGAIN;
+        rsnd_dma_of_path(dma, is_play, &mod_from, &mod_to);
+        dma->src_addr = rsnd_dma_addr(priv, mod_from, is_play, 1);
+        dma->dst_addr = rsnd_dma_addr(priv, mod_to,   is_play, 0);
+        /* for Gen2 */
+        if (mod_from && mod_to)
+                dma->ops = &rsnd_dmapp_ops;
+        else
+                dma->ops = &rsnd_dmaen_ops;
+        /* for Gen1, overwrite */
+        if (rsnd_is_gen1(priv))
+                dma->ops = &rsnd_dmaen_ops;
+        return dma->ops->init(priv, dma, id, mod_from, mod_to);
+}
+int rsnd_dma_probe(struct platform_device *pdev,
+                   const struct rsnd_of_data *of_data,
+                   struct rsnd_priv *priv)
+{
+        struct device *dev = rsnd_priv_to_dev(priv);
+        struct rsnd_dma_ctrl *dmac;
+        struct resource *res;
+        /*
+         * for Gen1
+         */
+        if (rsnd_is_gen1(priv))
+                return 0;
+        /*
+         * for Gen2
+         */
+        res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "audmapp");
+        dmac = devm_kzalloc(dev, sizeof(*dmac), GFP_KERNEL);
+        if (!dmac || !res) {
+                dev_err(dev, "dma allocate failed\n");
+                return 0; /* it will be PIO mode */
+        }
+        dmac->dmapp_num = 0;
+        dmac->base = devm_ioremap_resource(dev, res);
+        if (IS_ERR(dmac->base))
+                return PTR_ERR(dmac->base);
+        priv->dma = dmac;
+        return 0;
+}
diff --git a/sound/soc/sh/rcar/dvc.c b/sound/soc/sh/rcar/dvc.c
index d7f9ed959c4e..e5fcb062ad77 100644
--- a/sound/soc/sh/rcar/dvc.c
+++ b/sound/soc/sh/rcar/dvc.c
@@ -24,6 +24,9 @@ struct rsnd_dvc {
        struct rsnd_kctrl_cfg_s rdown;  /* Ramp Rate Down */
 };
+#define rsnd_dvc_of_node(priv) \
+        of_get_child_by_name(rsnd_priv_to_dev(priv)->of_node, "rcar_sound,dvc")
 #define rsnd_mod_to_dvc(_mod)   \
        container_of((_mod), struct rsnd_dvc, mod)
@@ -33,7 +36,7 @@ struct rsnd_dvc {
             ((pos) = (struct rsnd_dvc *)(priv)->dvc + i);      \
             i++)
-static const char const *dvc_ramp_rate[] = {
+static const char * const dvc_ramp_rate[] = {
        "128 dB/1 step",         /* 00000 */
        "64 dB/1 step",          /* 00001 */
        "32 dB/1 step",          /* 00010 */
@@ -116,17 +119,6 @@ static void rsnd_dvc_volume_update(struct rsnd_mod *mod)
        rsnd_mod_write(mod, DVC_DVUER, 1);
 }
-static int rsnd_dvc_probe_gen2(struct rsnd_mod *mod,
-                               struct rsnd_priv *priv)
-{
-        struct device *dev = rsnd_priv_to_dev(priv);
-        dev_dbg(dev, "%s[%d] (Gen2) is probed\n",
-                rsnd_mod_name(mod), rsnd_mod_id(mod));
-        return 0;
-}
 static int rsnd_dvc_remove_gen2(struct rsnd_mod *mod,
                                struct rsnd_priv *priv)
 {
@@ -269,9 +261,17 @@ static int rsnd_dvc_pcm_new(struct rsnd_mod *mod,
        return 0;
 }
+static struct dma_chan *rsnd_dvc_dma_req(struct rsnd_mod *mod)
+{
+        struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
+        return rsnd_dma_request_channel(rsnd_dvc_of_node(priv),
+                                        mod, "tx");
+}
 static struct rsnd_mod_ops rsnd_dvc_ops = {
        .name           = DVC_NAME,
-        .probe          = rsnd_dvc_probe_gen2,
+        .dma_req        = rsnd_dvc_dma_req,
        .remove         = rsnd_dvc_remove_gen2,
        .init           = rsnd_dvc_init,
        .quit           = rsnd_dvc_quit,
@@ -333,7 +333,7 @@ int rsnd_dvc_probe(struct platform_device *pdev,
        struct rsnd_dvc *dvc;
        struct clk *clk;
        char name[RSND_DVC_NAME_SIZE];
-        int i, nr;
+        int i, nr, ret;
        rsnd_of_parse_dvc(pdev, of_data, priv);
@@ -366,11 +366,22 @@ int rsnd_dvc_probe(struct platform_device *pdev,
                dvc->info = &info->dvc_info[i];
-                rsnd_mod_init(&dvc->mod, &rsnd_dvc_ops,
+                ret = rsnd_mod_init(&dvc->mod, &rsnd_dvc_ops,
                              clk, RSND_MOD_DVC, i);
+                if (ret)
-                dev_dbg(dev, "CMD%d probed\n", i);
+                        return ret;
        }
        return 0;
 }
+void rsnd_dvc_remove(struct platform_device *pdev,
+                     struct rsnd_priv *priv)
+{
+        struct rsnd_dvc *dvc;
+        int i;
+        for_each_rsnd_dvc(dvc, priv, i) {
+                rsnd_mod_quit(&dvc->mod);
+        }
+}
diff --git a/sound/soc/sh/rcar/gen.c b/sound/soc/sh/rcar/gen.c
index de0685f2abae..8c7dc51b1c4f 100644
--- a/sound/soc/sh/rcar/gen.c
+++ b/sound/soc/sh/rcar/gen.c
@@ -28,6 +28,7 @@ struct rsnd_gen {
        struct regmap *regmap[RSND_BASE_MAX];
        struct regmap_field *regs[RSND_REG_MAX];
+        phys_addr_t res[RSND_REG_MAX];
 };
 #define rsnd_priv_to_gen(p)     ((struct rsnd_gen *)(p)->gen)
@@ -118,11 +119,19 @@ void rsnd_bset(struct rsnd_priv *priv, struct rsnd_mod *mod,
                                  mask, data);
 }
-#define rsnd_gen_regmap_init(priv, id_size, reg_id, conf)               \
+phys_addr_t rsnd_gen_get_phy_addr(struct rsnd_priv *priv, int reg_id)
-        _rsnd_gen_regmap_init(priv, id_size, reg_id, conf, ARRAY_SIZE(conf))
+{
+        struct rsnd_gen *gen = rsnd_priv_to_gen(priv);
+        return  gen->res[reg_id];
+}
+#define rsnd_gen_regmap_init(priv, id_size, reg_id, name, conf)         \
+        _rsnd_gen_regmap_init(priv, id_size, reg_id, name, conf, ARRAY_SIZE(conf))
 static int _rsnd_gen_regmap_init(struct rsnd_priv *priv,
                                 int id_size,
                                 int reg_id,
+                                 const char *name,
                                 struct rsnd_regmap_field_conf *conf,
                                 int conf_size)
 {
@@ -141,8 +150,11 @@ static int _rsnd_gen_regmap_init(struct rsnd_priv *priv,
        regc.reg_bits = 32;
        regc.val_bits = 32;
        regc.reg_stride = 4;
+        regc.name = name;
-        res = platform_get_resource(pdev, IORESOURCE_MEM, reg_id);
+        res = platform_get_resource_byname(pdev, IORESOURCE_MEM, name);
+        if (!res)
+                res = platform_get_resource(pdev, IORESOURCE_MEM, reg_id);
        if (!res)
                return -ENODEV;
@@ -156,6 +168,7 @@ static int _rsnd_gen_regmap_init(struct rsnd_priv *priv,
        gen->base[reg_id] = base;
        gen->regmap[reg_id] = regmap;
+        gen->res[reg_id] = res->start;
        for (i = 0; i < conf_size; i++) {
@@ -176,125 +189,11 @@ static int _rsnd_gen_regmap_init(struct rsnd_priv *priv,
 }
 /*
- *      DMA read/write register offset
- *
- *      RSND_xxx_I_N    for Audio DMAC input
- *      RSND_xxx_O_N    for Audio DMAC output
- *      RSND_xxx_I_P    for Audio DMAC peri peri input
- *      RSND_xxx_O_P    for Audio DMAC peri peri output
- *
- *      ex) R-Car H2 case
- *            mod        / DMAC in    / DMAC out   / DMAC PP in / DMAC pp out
- *      SSI : 0xec541000 / 0xec241008 / 0xec24100c
- *      SSIU: 0xec541000 / 0xec100000 / 0xec100000 / 0xec400000 / 0xec400000
- *      SCU : 0xec500000 / 0xec000000 / 0xec004000 / 0xec300000 / 0xec304000
- *      CMD : 0xec500000 /            / 0xec008000                0xec308000
- */
-#define RDMA_SSI_I_N(addr, i)   (addr ##_reg - 0x00300000 + (0x40 * i) + 0x8)
-#define RDMA_SSI_O_N(addr, i)   (addr ##_reg - 0x00300000 + (0x40 * i) + 0xc)
-#define RDMA_SSIU_I_N(addr, i)  (addr ##_reg - 0x00441000 + (0x1000 * i))
-#define RDMA_SSIU_O_N(addr, i)  (addr ##_reg - 0x00441000 + (0x1000 * i))
-#define RDMA_SSIU_I_P(addr, i)  (addr ##_reg - 0x00141000 + (0x1000 * i))
-#define RDMA_SSIU_O_P(addr, i)  (addr ##_reg - 0x00141000 + (0x1000 * i))
-#define RDMA_SRC_I_N(addr, i)   (addr ##_reg - 0x00500000 + (0x400 * i))
-#define RDMA_SRC_O_N(addr, i)   (addr ##_reg - 0x004fc000 + (0x400 * i))
-#define RDMA_SRC_I_P(addr, i)   (addr ##_reg - 0x00200000 + (0x400 * i))
-#define RDMA_SRC_O_P(addr, i)   (addr ##_reg - 0x001fc000 + (0x400 * i))
-#define RDMA_CMD_O_N(addr, i)   (addr ##_reg - 0x004f8000 + (0x400 * i))
-#define RDMA_CMD_O_P(addr, i)   (addr ##_reg - 0x001f8000 + (0x400 * i))
-static dma_addr_t
-rsnd_gen2_dma_addr(struct rsnd_priv *priv,
-                   struct rsnd_mod *mod,
-                   int is_play, int is_from)
-{
-        struct platform_device *pdev = rsnd_priv_to_pdev(priv);
-        struct device *dev = rsnd_priv_to_dev(priv);
-        struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
-        dma_addr_t ssi_reg = platform_get_resource(pdev,
-                                IORESOURCE_MEM, RSND_GEN2_SSI)->start;
-        dma_addr_t src_reg = platform_get_resource(pdev,
-                                IORESOURCE_MEM, RSND_GEN2_SCU)->start;
-        int is_ssi = !!(rsnd_io_to_mod_ssi(io) == mod);
-        int use_src = !!rsnd_io_to_mod_src(io);
-        int use_dvc = !!rsnd_io_to_mod_dvc(io);
-        int id = rsnd_mod_id(mod);
-        struct dma_addr {
-                dma_addr_t out_addr;
-                dma_addr_t in_addr;
-        } dma_addrs[3][2][3] = {
-                /* SRC */
-                {{{ 0,                          0 },
-                /* Capture */
-                  { RDMA_SRC_O_N(src, id),      RDMA_SRC_I_P(src, id) },
-                  { RDMA_CMD_O_N(src, id),      RDMA_SRC_I_P(src, id) } },
-                 /* Playback */
-                 {{ 0,                          0, },
-                  { RDMA_SRC_O_P(src, id),      RDMA_SRC_I_N(src, id) },
-                  { RDMA_CMD_O_P(src, id),      RDMA_SRC_I_N(src, id) } }
-                },
-                /* SSI */
-                /* Capture */
-                {{{ RDMA_SSI_O_N(ssi, id),      0 },
-                  { RDMA_SSIU_O_P(ssi, id),     0 },
-                  { RDMA_SSIU_O_P(ssi, id),     0 } },
-                 /* Playback */
-                 {{ 0,                          RDMA_SSI_I_N(ssi, id) },
-                  { 0,                          RDMA_SSIU_I_P(ssi, id) },
-                  { 0,                          RDMA_SSIU_I_P(ssi, id) } }
-                },
-                /* SSIU */
-                /* Capture */
-                {{{ RDMA_SSIU_O_N(ssi, id),     0 },
-                  { RDMA_SSIU_O_P(ssi, id),     0 },
-                  { RDMA_SSIU_O_P(ssi, id),     0 } },
-                 /* Playback */
-                 {{ 0,                          RDMA_SSIU_I_N(ssi, id) },
-                  { 0,                          RDMA_SSIU_I_P(ssi, id) },
-                  { 0,                          RDMA_SSIU_I_P(ssi, id) } } },
-        };
-        /* it shouldn't happen */
-        if (use_dvc && !use_src)
-                dev_err(dev, "DVC is selected without SRC\n");
-        /* use SSIU or SSI ? */
-        if (is_ssi && (0 == strcmp(rsnd_mod_dma_name(mod), "ssiu")))
-                is_ssi++;
-        return (is_from) ?
-                dma_addrs[is_ssi][is_play][use_src + use_dvc].out_addr :
-                dma_addrs[is_ssi][is_play][use_src + use_dvc].in_addr;
-}
-dma_addr_t rsnd_gen_dma_addr(struct rsnd_priv *priv,
-                             struct rsnd_mod *mod,
-                             int is_play, int is_from)
-{
-        /*
-         * gen1 uses default DMA addr
-         */
-        if (rsnd_is_gen1(priv))
-                return 0;
-        if (!mod)
-                return 0;
-        return rsnd_gen2_dma_addr(priv, mod, is_play, is_from);
-}
-/*
 *              Gen2
 */
 static int rsnd_gen2_probe(struct platform_device *pdev,
                           struct rsnd_priv *priv)
 {
-        struct device *dev = rsnd_priv_to_dev(priv);
        struct rsnd_regmap_field_conf conf_ssiu[] = {
                RSND_GEN_S_REG(SSI_MODE0,       0x800),
                RSND_GEN_S_REG(SSI_MODE1,       0x804),
@@ -368,18 +267,16 @@ static int rsnd_gen2_probe(struct platform_device *pdev,
        int ret_adg;
        int ret_ssi;
-        ret_ssiu = rsnd_gen_regmap_init(priv, 10, RSND_GEN2_SSIU, conf_ssiu);
+        ret_ssiu = rsnd_gen_regmap_init(priv, 10, RSND_GEN2_SSIU, "ssiu", conf_ssiu);
-        ret_scu  = rsnd_gen_regmap_init(priv, 10, RSND_GEN2_SCU,  conf_scu);
+        ret_scu  = rsnd_gen_regmap_init(priv, 10, RSND_GEN2_SCU,  "scu",  conf_scu);
-        ret_adg  = rsnd_gen_regmap_init(priv, 10, RSND_GEN2_ADG,  conf_adg);
+        ret_adg  = rsnd_gen_regmap_init(priv, 10, RSND_GEN2_ADG,  "adg",  conf_adg);
-        ret_ssi  = rsnd_gen_regmap_init(priv, 10, RSND_GEN2_SSI,  conf_ssi);
+        ret_ssi  = rsnd_gen_regmap_init(priv, 10, RSND_GEN2_SSI,  "ssi",  conf_ssi);
        if (ret_ssiu < 0 ||
            ret_scu  < 0 ||
            ret_adg  < 0 ||
            ret_ssi  < 0)
                return ret_ssiu | ret_scu | ret_adg | ret_ssi;
-        dev_dbg(dev, "Gen2 is probed\n");
        return 0;
 }
@@ -390,7 +287,6 @@ static int rsnd_gen2_probe(struct platform_device *pdev,
 static int rsnd_gen1_probe(struct platform_device *pdev,
                           struct rsnd_priv *priv)
 {
-        struct device *dev = rsnd_priv_to_dev(priv);
        struct rsnd_regmap_field_conf conf_sru[] = {
                RSND_GEN_S_REG(SRC_ROUTE_SEL,   0x00),
                RSND_GEN_S_REG(SRC_TMG_SEL0,    0x08),
@@ -440,16 +336,14 @@ static int rsnd_gen1_probe(struct platform_device *pdev,
        int ret_adg;
        int ret_ssi;
-        ret_sru  = rsnd_gen_regmap_init(priv, 9, RSND_GEN1_SRU,  conf_sru);
+        ret_sru  = rsnd_gen_regmap_init(priv, 9, RSND_GEN1_SRU, "sru", conf_sru);
-        ret_adg  = rsnd_gen_regmap_init(priv, 9, RSND_GEN1_ADG,  conf_adg);
+        ret_adg  = rsnd_gen_regmap_init(priv, 9, RSND_GEN1_ADG, "adg", conf_adg);
-        ret_ssi  = rsnd_gen_regmap_init(priv, 9, RSND_GEN1_SSI,  conf_ssi);
+        ret_ssi  = rsnd_gen_regmap_init(priv, 9, RSND_GEN1_SSI, "ssi", conf_ssi);
        if (ret_sru  < 0 ||
            ret_adg  < 0 ||
            ret_ssi  < 0)
                return ret_sru | ret_adg | ret_ssi;
-        dev_dbg(dev, "Gen1 is probed\n");
        return 0;
 }
diff --git a/sound/soc/sh/rcar/rsnd.h b/sound/soc/sh/rcar/rsnd.h
index e7914bd610e2..4e6de6804cfb 100644
--- a/sound/soc/sh/rcar/rsnd.h
+++ b/sound/soc/sh/rcar/rsnd.h
@@ -170,21 +170,47 @@ u32 rsnd_get_adinr(struct rsnd_mod *mod);
 /*
 *      R-Car DMA
 */
-struct rsnd_dma {
+struct rsnd_dma;
-        struct sh_dmae_slave    slave;
+struct rsnd_dma_ops {
+        void (*start)(struct rsnd_dma *dma);
+        void (*stop)(struct rsnd_dma *dma);
+        int (*init)(struct rsnd_priv *priv, struct rsnd_dma *dma, int id,
+                    struct rsnd_mod *mod_from, struct rsnd_mod *mod_to);
+        void  (*quit)(struct rsnd_dma *dma);
+};
+struct rsnd_dmaen {
        struct dma_chan         *chan;
-        enum dma_transfer_direction dir;
-        dma_addr_t              addr;
 };
+struct rsnd_dmapp {
+        int                     dmapp_id;
+        u32                     chcr;
+};
+struct rsnd_dma {
+        struct rsnd_dma_ops     *ops;
+        dma_addr_t              src_addr;
+        dma_addr_t              dst_addr;
+        union {
+                struct rsnd_dmaen en;
+                struct rsnd_dmapp pp;
+        } dma;
+};
+#define rsnd_dma_to_dmaen(dma)  (&(dma)->dma.en)
+#define rsnd_dma_to_dmapp(dma)  (&(dma)->dma.pp)
 void rsnd_dma_start(struct rsnd_dma *dma);
 void rsnd_dma_stop(struct rsnd_dma *dma);
-int rsnd_dma_available(struct rsnd_dma *dma);
+int rsnd_dma_init(struct rsnd_priv *priv, struct rsnd_dma *dma, int id);
-int rsnd_dma_init(struct rsnd_priv *priv, struct rsnd_dma *dma,
+void  rsnd_dma_quit(struct rsnd_dma *dma);
-        int is_play, int id);
+int rsnd_dma_probe(struct platform_device *pdev,
-void  rsnd_dma_quit(struct rsnd_priv *priv,
+                   const struct rsnd_of_data *of_data,
-                    struct rsnd_dma *dma);
+                   struct rsnd_priv *priv);
+struct dma_chan *rsnd_dma_request_channel(struct device_node *of_node,
+                                          struct rsnd_mod *mod, char *name);
+#define rsnd_dma_to_mod(_dma) container_of((_dma), struct rsnd_mod, dma)
 /*
 *      R-Car sound mod
@@ -198,7 +224,7 @@ enum rsnd_mod_type {
 struct rsnd_mod_ops {
        char *name;
-        char* (*dma_name)(struct rsnd_mod *mod);
+        struct dma_chan* (*dma_req)(struct rsnd_mod *mod);
        int (*probe)(struct rsnd_mod *mod,
                     struct rsnd_priv *priv);
        int (*remove)(struct rsnd_mod *mod,
@@ -213,6 +239,9 @@ struct rsnd_mod_ops {
                    struct rsnd_priv *priv);
        int (*pcm_new)(struct rsnd_mod *mod,
                       struct snd_soc_pcm_runtime *rtd);
+        int (*hw_params)(struct rsnd_mod *mod,
+                         struct snd_pcm_substream *substream,
+                         struct snd_pcm_hw_params *hw_params);
        int (*fallback)(struct rsnd_mod *mod,
                        struct rsnd_priv *priv);
 };
@@ -236,6 +265,9 @@ struct rsnd_mod {
 * 2    0: start        1: stop
 * 3    0: pcm_new
 * 4    0: fallback
+ *
+ * 31 bit is always called (see __rsnd_mod_call)
+ * 31   0: hw_params
 */
 #define __rsnd_mod_shift_probe          0
 #define __rsnd_mod_shift_remove         0
@@ -245,6 +277,7 @@ struct rsnd_mod {
 #define __rsnd_mod_shift_stop           2
 #define __rsnd_mod_shift_pcm_new        3
 #define __rsnd_mod_shift_fallback       4
+#define __rsnd_mod_shift_hw_params      31 /* always called */
 #define __rsnd_mod_call_probe           0
 #define __rsnd_mod_call_remove          1
@@ -254,28 +287,30 @@ struct rsnd_mod {
 #define __rsnd_mod_call_stop            1
 #define __rsnd_mod_call_pcm_new         0
 #define __rsnd_mod_call_fallback        0
+#define __rsnd_mod_call_hw_params       0
 #define rsnd_mod_to_priv(mod) (rsnd_io_to_priv(rsnd_mod_to_io(mod)))
 #define rsnd_mod_to_dma(mod) (&(mod)->dma)
-#define rsnd_dma_to_mod(_dma) container_of((_dma), struct rsnd_mod, dma)
 #define rsnd_mod_to_io(mod) ((mod)->io)
 #define rsnd_mod_id(mod) ((mod)->id)
-#define rsnd_mod_hw_start(mod)  clk_prepare_enable((mod)->clk)
+#define rsnd_mod_hw_start(mod)  clk_enable((mod)->clk)
-#define rsnd_mod_hw_stop(mod)   clk_disable_unprepare((mod)->clk)
+#define rsnd_mod_hw_stop(mod)   clk_disable((mod)->clk)
-void rsnd_mod_init(struct rsnd_mod *mod,
+int rsnd_mod_init(struct rsnd_mod *mod,
                   struct rsnd_mod_ops *ops,
                   struct clk *clk,
                   enum rsnd_mod_type type,
                   int id);
+void rsnd_mod_quit(struct rsnd_mod *mod);
 char *rsnd_mod_name(struct rsnd_mod *mod);
-char *rsnd_mod_dma_name(struct rsnd_mod *mod);
+struct dma_chan *rsnd_mod_dma_req(struct rsnd_mod *mod);
 /*
 *      R-Car sound DAI
 */
 #define RSND_DAI_NAME_SIZE      16
 struct rsnd_dai_stream {
+        char name[RSND_DAI_NAME_SIZE];
        struct snd_pcm_substream *substream;
        struct rsnd_mod *mod[RSND_MOD_MAX];
        struct rsnd_dai_path_info *info; /* rcar_snd.h */
@@ -331,9 +366,7 @@ int rsnd_gen_probe(struct platform_device *pdev,
 void __iomem *rsnd_gen_reg_get(struct rsnd_priv *priv,
                               struct rsnd_mod *mod,
                               enum rsnd_reg reg);
-dma_addr_t rsnd_gen_dma_addr(struct rsnd_priv *priv,
+phys_addr_t rsnd_gen_get_phy_addr(struct rsnd_priv *priv, int reg_id);
-                       struct rsnd_mod *mod,
-                       int is_play,  int is_from);
 #define rsnd_is_gen1(s)         (((s)->info->flags & RSND_GEN_MASK) == RSND_GEN1)
 #define rsnd_is_gen2(s)         (((s)->info->flags & RSND_GEN_MASK) == RSND_GEN2)
@@ -389,6 +422,11 @@ struct rsnd_priv {
        void *adg;
        /*
+         * below value will be filled on rsnd_dma_probe()
+         */
+        void *dma;
+        /*
         * below value will be filled on rsnd_ssi_probe()
         */
        void *ssi;
@@ -414,19 +452,6 @@ struct rsnd_priv {
 #define rsnd_lock(priv, flags) spin_lock_irqsave(&priv->lock, flags)
 #define rsnd_unlock(priv, flags) spin_unlock_irqrestore(&priv->lock, flags)
-#define rsnd_info_is_playback(priv, type)                               \
-({                                                                      \
-        struct rcar_snd_info *info = rsnd_priv_to_info(priv);           \
-        int i, is_play = 0;                                             \
-        for (i = 0; i < info->dai_info_nr; i++) {                       \
-                if (info->dai_info[i].playback.type == (type)->info) {  \
-                        is_play = 1;                                    \
-                        break;                                          \
-                }                                                       \
-        }                                                               \
-        is_play;                                                        \
-})
 /*
 *      rsnd_kctrl
 */
@@ -480,6 +505,8 @@ int rsnd_kctrl_new_e(struct rsnd_mod *mod,
 int rsnd_src_probe(struct platform_device *pdev,
                   const struct rsnd_of_data *of_data,
                   struct rsnd_priv *priv);
+void rsnd_src_remove(struct platform_device *pdev,
+                     struct rsnd_priv *priv);
 struct rsnd_mod *rsnd_src_mod_get(struct rsnd_priv *priv, int id);
 unsigned int rsnd_src_get_ssi_rate(struct rsnd_priv *priv,
                                   struct rsnd_dai_stream *io,
@@ -498,9 +525,12 @@ int rsnd_src_ssi_irq_disable(struct rsnd_mod *ssi_mod);
 int rsnd_ssi_probe(struct platform_device *pdev,
                   const struct rsnd_of_data *of_data,
                   struct rsnd_priv *priv);
+void rsnd_ssi_remove(struct platform_device *pdev,
+                     struct rsnd_priv *priv);
 struct rsnd_mod *rsnd_ssi_mod_get(struct rsnd_priv *priv, int id);
 int rsnd_ssi_is_pin_sharing(struct rsnd_mod *mod);
 int rsnd_ssi_is_dma_mode(struct rsnd_mod *mod);
+int rsnd_ssi_use_busif(struct rsnd_mod *mod);
 /*
 *      R-Car DVC
diff --git a/sound/soc/sh/rcar/rsrc-card.c b/sound/soc/sh/rcar/rsrc-card.c
new file mode 100644
index 000000000000..a68517afe615
--- /dev/null
+++ b/sound/soc/sh/rcar/rsrc-card.c
@@ -0,0 +1,512 @@
+/*
+ * Renesas Sampling Rate Convert Sound Card for DPCM
+ *
+ * Copyright (C) 2015 Renesas Solutions Corp.
+ * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
+ *
+ * based on ${LINUX}/sound/soc/generic/simple-card.c
+ *
+ * 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/clk.h>
+#include <linux/device.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/platform_device.h>
+#include <linux/string.h>
+#include <sound/jack.h>
+#include <sound/soc.h>
+#include <sound/soc-dai.h>
+struct rsrc_card_of_data {
+        const char *prefix;
+        const struct snd_soc_dapm_route *routes;
+        int num_routes;
+};
+static const struct snd_soc_dapm_route routes_ssi0_ak4642[] = {
+        {"ak4642 Playback", NULL, "DAI0 Playback"},
+        {"DAI0 Capture", NULL, "ak4642 Capture"},
+};
+static const struct rsrc_card_of_data routes_of_ssi0_ak4642 = {
+        .prefix         = "ak4642",
+        .routes         = routes_ssi0_ak4642,
+        .num_routes     = ARRAY_SIZE(routes_ssi0_ak4642),
+};
+static const struct of_device_id rsrc_card_of_match[] = {
+        { .compatible = "renesas,rsrc-card,lager",      .data = &routes_of_ssi0_ak4642 },
+        { .compatible = "renesas,rsrc-card,koelsch",    .data = &routes_of_ssi0_ak4642 },
+        {},
+};
+MODULE_DEVICE_TABLE(of, rsrc_card_of_match);
+struct rsrc_card_dai {
+        const char *name;
+        unsigned int fmt;
+        unsigned int sysclk;
+        struct clk *clk;
+};
+#define RSRC_FB_NUM     2 /* FE/BE */
+#define IDX_CPU         0
+#define IDX_CODEC       1
+struct rsrc_card_priv {
+        struct snd_soc_card snd_card;
+        struct rsrc_card_dai_props {
+                struct rsrc_card_dai cpu_dai;
+                struct rsrc_card_dai codec_dai;
+        } dai_props[RSRC_FB_NUM];
+        struct snd_soc_codec_conf codec_conf;
+        struct snd_soc_dai_link dai_link[RSRC_FB_NUM];
+        u32 convert_rate;
+};
+#define rsrc_priv_to_dev(priv) ((priv)->snd_card.dev)
+#define rsrc_priv_to_link(priv, i) ((priv)->snd_card.dai_link + i)
+#define rsrc_priv_to_props(priv, i) ((priv)->dai_props + i)
+#define rsrc_dev_to_of_data(dev) (of_match_device(rsrc_card_of_match, (dev))->data)
+static int rsrc_card_startup(struct snd_pcm_substream *substream)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct rsrc_card_priv *priv =   snd_soc_card_get_drvdata(rtd->card);
+        struct rsrc_card_dai_props *dai_props =
+                &priv->dai_props[rtd - rtd->card->rtd];
+        int ret;
+        ret = clk_prepare_enable(dai_props->cpu_dai.clk);
+        if (ret)
+                return ret;
+        ret = clk_prepare_enable(dai_props->codec_dai.clk);
+        if (ret)
+                clk_disable_unprepare(dai_props->cpu_dai.clk);
+        return ret;
+}
+static void rsrc_card_shutdown(struct snd_pcm_substream *substream)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct rsrc_card_priv *priv =   snd_soc_card_get_drvdata(rtd->card);
+        struct rsrc_card_dai_props *dai_props =
+                &priv->dai_props[rtd - rtd->card->rtd];
+        clk_disable_unprepare(dai_props->cpu_dai.clk);
+        clk_disable_unprepare(dai_props->codec_dai.clk);
+}
+static struct snd_soc_ops rsrc_card_ops = {
+        .startup = rsrc_card_startup,
+        .shutdown = rsrc_card_shutdown,
+};
+static int __rsrc_card_dai_init(struct snd_soc_dai *dai,
+                                struct rsrc_card_dai *set)
+{
+        int ret;
+        if (set->fmt) {
+                ret = snd_soc_dai_set_fmt(dai, set->fmt);
+                if (ret && ret != -ENOTSUPP) {
+                        dev_err(dai->dev, "set_fmt error\n");
+                        goto err;
+                }
+        }
+        if (set->sysclk) {
+                ret = snd_soc_dai_set_sysclk(dai, 0, set->sysclk, 0);
+                if (ret && ret != -ENOTSUPP) {
+                        dev_err(dai->dev, "set_sysclk error\n");
+                        goto err;
+                }
+        }
+        ret = 0;
+err:
+        return ret;
+}
+static int rsrc_card_dai_init(struct snd_soc_pcm_runtime *rtd)
+{
+        struct rsrc_card_priv *priv =   snd_soc_card_get_drvdata(rtd->card);
+        struct snd_soc_dai *codec = rtd->codec_dai;
+        struct snd_soc_dai *cpu = rtd->cpu_dai;
+        struct rsrc_card_dai_props *dai_props;
+        int num, ret;
+        num = rtd - rtd->card->rtd;
+        dai_props = &priv->dai_props[num];
+        ret = __rsrc_card_dai_init(codec, &dai_props->codec_dai);
+        if (ret < 0)
+                return ret;
+        ret = __rsrc_card_dai_init(cpu, &dai_props->cpu_dai);
+        if (ret < 0)
+                return ret;
+        return 0;
+}
+static int rsrc_card_be_hw_params_fixup(struct snd_soc_pcm_runtime *rtd,
+                                        struct snd_pcm_hw_params *params)
+{
+        struct rsrc_card_priv *priv = snd_soc_card_get_drvdata(rtd->card);
+        struct snd_interval *rate = hw_param_interval(params,
+                                                      SNDRV_PCM_HW_PARAM_RATE);
+        if (!priv->convert_rate)
+                return 0;
+        rate->min = rate->max = priv->convert_rate;
+        return 0;
+}
+static int
+rsrc_card_sub_parse_of(struct rsrc_card_priv *priv,
+                       struct device_node *np,
+                       struct rsrc_card_dai *dai,
+                       struct snd_soc_dai_link *dai_link,
+                       int *args_count)
+{
+        struct device *dev = rsrc_priv_to_dev(priv);
+        const struct rsrc_card_of_data *of_data = rsrc_dev_to_of_data(dev);
+        struct of_phandle_args args;
+        struct device_node **p_node;
+        struct clk *clk;
+        const char **dai_name;
+        const char **name;
+        u32 val;
+        int ret;
+        if (args_count) {
+                p_node          = &dai_link->cpu_of_node;
+                dai_name        = &dai_link->cpu_dai_name;
+                name            = &dai_link->cpu_name;
+        } else {
+                p_node          = &dai_link->codec_of_node;
+                dai_name        = &dai_link->codec_dai_name;
+                name            = &dai_link->codec_name;
+        }
+        if (!np) {
+                /* use snd-soc-dummy */
+                *p_node         = NULL;
+                *dai_name       = "snd-soc-dummy-dai";
+                *name           = "snd-soc-dummy";
+                return 0;
+        }
+        /*
+         * Get node via "sound-dai = <&phandle port>"
+         * it will be used as xxx_of_node on soc_bind_dai_link()
+         */
+        ret = of_parse_phandle_with_args(np, "sound-dai",
+                                         "#sound-dai-cells", 0, &args);
+        if (ret)
+                return ret;
+        *p_node = args.np;
+        /* Get dai->name */
+        ret = snd_soc_of_get_dai_name(np, dai_name);
+        if (ret < 0)
+                return ret;
+        /*
+         * FIXME
+         *
+         * rsrc assumes DPCM playback/capture
+         */
+        dai_link->dpcm_playback = 1;
+        dai_link->dpcm_capture = 1;
+        if (args_count) {
+                *args_count = args.args_count;
+                dai_link->dynamic = 1;
+        } else {
+                dai_link->no_pcm = 1;
+                priv->codec_conf.of_node = (*p_node);
+                priv->codec_conf.name_prefix = of_data->prefix;
+        }
+        /*
+         * Parse dai->sysclk come from "clocks = <&xxx>"
+         * (if system has common clock)
+         *  or "system-clock-frequency = <xxx>"
+         *  or device's module clock.
+         */
+        if (of_property_read_bool(np, "clocks")) {
+                clk = of_clk_get(np, 0);
+                if (IS_ERR(clk)) {
+                        ret = PTR_ERR(clk);
+                        return ret;
+                }
+                dai->sysclk = clk_get_rate(clk);
+                dai->clk = clk;
+        } else if (!of_property_read_u32(np, "system-clock-frequency", &val)) {
+                dai->sysclk = val;
+        } else {
+                clk = of_clk_get(args.np, 0);
+                if (!IS_ERR(clk))
+                        dai->sysclk = clk_get_rate(clk);
+        }
+        return 0;
+}
+static int rsrc_card_parse_daifmt(struct device_node *node,
+                                  struct rsrc_card_priv *priv,
+                                  struct device_node *codec,
+                                  int idx)
+{
+        struct device_node *bitclkmaster = NULL;
+        struct device_node *framemaster = NULL;
+        struct rsrc_card_dai_props *dai_props = rsrc_priv_to_props(priv, idx);
+        struct rsrc_card_dai *cpu_dai = &dai_props->cpu_dai;
+        struct rsrc_card_dai *codec_dai = &dai_props->codec_dai;
+        unsigned int daifmt;
+        daifmt = snd_soc_of_parse_daifmt(node, NULL,
+                                         &bitclkmaster, &framemaster);
+        daifmt &= ~SND_SOC_DAIFMT_MASTER_MASK;
+        if (!bitclkmaster && !framemaster)
+                return -EINVAL;
+        if (codec == bitclkmaster)
+                daifmt |= (codec == framemaster) ?
+                        SND_SOC_DAIFMT_CBM_CFM : SND_SOC_DAIFMT_CBM_CFS;
+        else
+                daifmt |= (codec == framemaster) ?
+                        SND_SOC_DAIFMT_CBS_CFM : SND_SOC_DAIFMT_CBS_CFS;
+        cpu_dai->fmt    = daifmt;
+        codec_dai->fmt  = daifmt;
+        of_node_put(bitclkmaster);
+        of_node_put(framemaster);
+        return 0;
+}
+static int rsrc_card_dai_link_of(struct device_node *node,
+                                 struct rsrc_card_priv *priv,
+                                 int idx)
+{
+        struct device *dev = rsrc_priv_to_dev(priv);
+        struct snd_soc_dai_link *dai_link = rsrc_priv_to_link(priv, idx);
+        struct rsrc_card_dai_props *dai_props = rsrc_priv_to_props(priv, idx);
+        struct device_node *cpu = NULL;
+        struct device_node *codec = NULL;
+        char *name;
+        char prop[128];
+        int ret, cpu_args;
+        cpu = of_get_child_by_name(node, "cpu");
+        codec = of_get_child_by_name(node, "codec");
+        if (!cpu || !codec) {
+                ret = -EINVAL;
+                dev_err(dev, "%s: Can't find %s DT node\n", __func__, prop);
+                goto dai_link_of_err;
+        }
+        ret = rsrc_card_parse_daifmt(node, priv, codec, idx);
+        if (ret < 0)
+                goto dai_link_of_err;
+        ret = rsrc_card_sub_parse_of(priv, (idx == IDX_CPU) ? cpu : NULL,
+                                     &dai_props->cpu_dai,
+                                     dai_link,
+                                     &cpu_args);
+        if (ret < 0)
+                goto dai_link_of_err;
+        ret = rsrc_card_sub_parse_of(priv, (idx == IDX_CODEC) ? codec : NULL,
+                                     &dai_props->codec_dai,
+                                     dai_link,
+                                     NULL);
+        if (ret < 0)
+                goto dai_link_of_err;
+        if (!dai_link->cpu_dai_name || !dai_link->codec_dai_name) {
+                ret = -EINVAL;
+                goto dai_link_of_err;
+        }
+        /* Simple Card assumes platform == cpu */
+        dai_link->platform_of_node = dai_link->cpu_of_node;
+        /* DAI link name is created from CPU/CODEC dai name */
+        name = devm_kzalloc(dev,
+                            strlen(dai_link->cpu_dai_name)   +
+                            strlen(dai_link->codec_dai_name) + 2,
+                            GFP_KERNEL);
+        if (!name) {
+                ret = -ENOMEM;
+                goto dai_link_of_err;
+        }
+        sprintf(name, "%s-%s", dai_link->cpu_dai_name,
+                dai_link->codec_dai_name);
+        dai_link->name = dai_link->stream_name = name;
+        dai_link->ops = &rsrc_card_ops;
+        dai_link->init = rsrc_card_dai_init;
+        if (idx == IDX_CODEC)
+                dai_link->be_hw_params_fixup = rsrc_card_be_hw_params_fixup;
+        dev_dbg(dev, "\tname : %s\n", dai_link->stream_name);
+        dev_dbg(dev, "\tcpu : %s / %04x / %d\n",
+                dai_link->cpu_dai_name,
+                dai_props->cpu_dai.fmt,
+                dai_props->cpu_dai.sysclk);
+        dev_dbg(dev, "\tcodec : %s / %04x / %d\n",
+                dai_link->codec_dai_name,
+                dai_props->codec_dai.fmt,
+                dai_props->codec_dai.sysclk);
+        /*
+         * In soc_bind_dai_link() will check cpu name after
+         * of_node matching if dai_link has cpu_dai_name.
+         * but, it will never match if name was created by
+         * fmt_single_name() remove cpu_dai_name if cpu_args
+         * was 0. See:
+         *      fmt_single_name()
+         *      fmt_multiple_name()
+         */
+        if (!cpu_args)
+                dai_link->cpu_dai_name = NULL;
+dai_link_of_err:
+        of_node_put(cpu);
+        of_node_put(codec);
+        return ret;
+}
+static int rsrc_card_parse_of(struct device_node *node,
+                              struct rsrc_card_priv *priv)
+{
+        struct device *dev = rsrc_priv_to_dev(priv);
+        const struct rsrc_card_of_data *of_data = rsrc_dev_to_of_data(dev);
+        int ret;
+        int i;
+        if (!node)
+                return -EINVAL;
+        /* Parse the card name from DT */
+        snd_soc_of_parse_card_name(&priv->snd_card, "card-name");
+        /* DAPM routes */
+        priv->snd_card.of_dapm_routes           = of_data->routes;
+        priv->snd_card.num_of_dapm_routes       = of_data->num_routes;
+        /* sampling rate convert */
+        of_property_read_u32(node, "convert-rate", &priv->convert_rate);
+        dev_dbg(dev, "New rsrc-audio-card: %s (%d)\n",
+                priv->snd_card.name ? priv->snd_card.name : "",
+                priv->convert_rate);
+        /* FE/BE */
+        for (i = 0; i < RSRC_FB_NUM; i++) {
+                ret = rsrc_card_dai_link_of(node, priv, i);
+                if (ret < 0)
+                        return ret;
+        }
+        if (!priv->snd_card.name)
+                priv->snd_card.name = priv->snd_card.dai_link->name;
+        return 0;
+}
+/* Decrease the reference count of the device nodes */
+static int rsrc_card_unref(struct snd_soc_card *card)
+{
+        struct snd_soc_dai_link *dai_link;
+        int num_links;
+        for (num_links = 0, dai_link = card->dai_link;
+             num_links < card->num_links;
+             num_links++, dai_link++) {
+                of_node_put(dai_link->cpu_of_node);
+                of_node_put(dai_link->codec_of_node);
+        }
+        return 0;
+}
+static int rsrc_card_probe(struct platform_device *pdev)
+{
+        struct rsrc_card_priv *priv;
+        struct snd_soc_dai_link *dai_link;
+        struct device_node *np = pdev->dev.of_node;
+        struct device *dev = &pdev->dev;
+        int ret;
+        /* Allocate the private data */
+        priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
+        if (!priv)
+                return -ENOMEM;
+        /* Init snd_soc_card */
+        priv->snd_card.owner = THIS_MODULE;
+        priv->snd_card.dev = dev;
+        dai_link = priv->dai_link;
+        priv->snd_card.dai_link = dai_link;
+        priv->snd_card.num_links = RSRC_FB_NUM;
+        priv->snd_card.codec_conf = &priv->codec_conf;
+        priv->snd_card.num_configs = 1;
+        ret = rsrc_card_parse_of(np, priv);
+        if (ret < 0) {
+                if (ret != -EPROBE_DEFER)
+                        dev_err(dev, "parse error %d\n", ret);
+                goto err;
+        }
+        snd_soc_card_set_drvdata(&priv->snd_card, priv);
+        ret = devm_snd_soc_register_card(&pdev->dev, &priv->snd_card);
+        if (ret >= 0)
+                return ret;
+err:
+        rsrc_card_unref(&priv->snd_card);
+        return ret;
+}
+static int rsrc_card_remove(struct platform_device *pdev)
+{
+        struct snd_soc_card *card = platform_get_drvdata(pdev);
+        return rsrc_card_unref(card);
+}
+static struct platform_driver rsrc_card = {
+        .driver = {
+                .name = "renesas-src-audio-card",
+                .of_match_table = rsrc_card_of_match,
+        },
+        .probe = rsrc_card_probe,
+        .remove = rsrc_card_remove,
+};
+module_platform_driver(rsrc_card);
+MODULE_ALIAS("platform:renesas-src-audio-card");
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Renesas Sampling Rate Convert Sound Card");
+MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>");
diff --git a/sound/soc/sh/rcar/src.c b/sound/soc/sh/rcar/src.c
index 81c182b4bad5..3beb32eb412a 100644
--- a/sound/soc/sh/rcar/src.c
+++ b/sound/soc/sh/rcar/src.c
@@ -22,16 +22,20 @@
 struct rsnd_src {
        struct rsnd_src_platform_info *info; /* rcar_snd.h */
        struct rsnd_mod mod;
+        struct rsnd_kctrl_cfg_s sen;  /* sync convert enable */
+        struct rsnd_kctrl_cfg_s sync; /* sync convert */
+        u32 convert_rate; /* sampling rate convert */
        int err;
 };
 #define RSND_SRC_NAME_SIZE 16
-#define rsnd_src_convert_rate(p) ((p)->info->convert_rate)
+#define rsnd_enable_sync_convert(src) ((src)->sen.val)
+#define rsnd_src_of_node(priv) \
+        of_get_child_by_name(rsnd_priv_to_dev(priv)->of_node, "rcar_sound,src")
 #define rsnd_mod_to_src(_mod)                           \
        container_of((_mod), struct rsnd_src, mod)
-#define rsnd_src_dma_available(src) \
-        rsnd_dma_available(rsnd_mod_to_dma(&(src)->mod))
 #define for_each_rsnd_src(pos, priv, i)                         \
        for ((i) = 0;                                           \
@@ -113,6 +117,17 @@ struct rsnd_src {
 /*
 *              Gen1/Gen2 common functions
 */
+static struct dma_chan *rsnd_src_dma_req(struct rsnd_mod *mod)
+{
+        struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
+        struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
+        int is_play = rsnd_io_is_play(io);
+        return rsnd_dma_request_channel(rsnd_src_of_node(priv),
+                                        mod,
+                                        is_play ? "rx" : "tx");
+}
 int rsnd_src_ssiu_start(struct rsnd_mod *ssi_mod,
                        int use_busif)
 {
@@ -220,6 +235,30 @@ int rsnd_src_ssi_irq_disable(struct rsnd_mod *ssi_mod)
        return 0;
 }
+static u32 rsnd_src_convert_rate(struct rsnd_src *src)
+{
+        struct rsnd_mod *mod = &src->mod;
+        struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
+        struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
+        u32 convert_rate;
+        if (!runtime)
+                return 0;
+        if (!rsnd_enable_sync_convert(src))
+                return src->convert_rate;
+        convert_rate = src->sync.val;
+        if (!convert_rate)
+                convert_rate = src->convert_rate;
+        if (!convert_rate)
+                convert_rate = runtime->rate;
+        return convert_rate;
+}
 unsigned int rsnd_src_get_ssi_rate(struct rsnd_priv *priv,
                                   struct rsnd_dai_stream *io,
                                   struct snd_pcm_runtime *runtime)
@@ -276,7 +315,43 @@ static int rsnd_src_set_convert_rate(struct rsnd_mod *mod)
        return 0;
 }
-static int rsnd_src_init(struct rsnd_mod *mod)
+static int rsnd_src_hw_params(struct rsnd_mod *mod,
+                              struct snd_pcm_substream *substream,
+                              struct snd_pcm_hw_params *fe_params)
+{
+        struct rsnd_src *src = rsnd_mod_to_src(mod);
+        struct snd_soc_pcm_runtime *fe = substream->private_data;
+        /* default value (mainly for non-DT) */
+        src->convert_rate = src->info->convert_rate;
+        /*
+         * SRC assumes that it is used under DPCM if user want to use
+         * sampling rate convert. Then, SRC should be FE.
+         * And then, this function will be called *after* BE settings.
+         * this means, each BE already has fixuped hw_params.
+         * see
+         *      dpcm_fe_dai_hw_params()
+         *      dpcm_be_dai_hw_params()
+         */
+        if (fe->dai_link->dynamic) {
+                int stream = substream->stream;
+                struct snd_soc_dpcm *dpcm;
+                struct snd_pcm_hw_params *be_params;
+                list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be) {
+                        be_params = &dpcm->hw_params;
+                        if (params_rate(fe_params) != params_rate(be_params))
+                                src->convert_rate = params_rate(be_params);
+                }
+        }
+        return 0;
+}
+static int rsnd_src_init(struct rsnd_mod *mod,
+                         struct rsnd_priv *priv)
 {
        struct rsnd_src *src = rsnd_mod_to_src(mod);
@@ -284,6 +359,9 @@ static int rsnd_src_init(struct rsnd_mod *mod)
        src->err = 0;
+        /* reset sync convert_rate */
+        src->sync.val = 0;
        /*
         * Initialize the operation of the SRC internal circuits
         * see rsnd_src_start()
@@ -305,6 +383,11 @@ static int rsnd_src_quit(struct rsnd_mod *mod,
                dev_warn(dev, "%s[%d] under/over flow err = %d\n",
                         rsnd_mod_name(mod), rsnd_mod_id(mod), src->err);
+        src->convert_rate = 0;
+        /* reset sync convert_rate */
+        src->sync.val = 0;
        return 0;
 }
@@ -448,23 +531,12 @@ static int rsnd_src_set_convert_rate_gen1(struct rsnd_mod *mod)
        return 0;
 }
-static int rsnd_src_probe_gen1(struct rsnd_mod *mod,
-                               struct rsnd_priv *priv)
-{
-        struct device *dev = rsnd_priv_to_dev(priv);
-        dev_dbg(dev, "%s[%d] (Gen1) is probed\n",
-                rsnd_mod_name(mod), rsnd_mod_id(mod));
-        return 0;
-}
 static int rsnd_src_init_gen1(struct rsnd_mod *mod,
                              struct rsnd_priv *priv)
 {
        int ret;
-        ret = rsnd_src_init(mod);
+        ret = rsnd_src_init(mod, priv);
        if (ret < 0)
                return ret;
@@ -505,11 +577,12 @@ static int rsnd_src_stop_gen1(struct rsnd_mod *mod,
 static struct rsnd_mod_ops rsnd_src_gen1_ops = {
        .name   = SRC_NAME,
-        .probe  = rsnd_src_probe_gen1,
+        .dma_req = rsnd_src_dma_req,
        .init   = rsnd_src_init_gen1,
        .quit   = rsnd_src_quit,
        .start  = rsnd_src_start_gen1,
        .stop   = rsnd_src_stop_gen1,
+        .hw_params = rsnd_src_hw_params,
 };
 /*
@@ -607,13 +680,17 @@ static irqreturn_t rsnd_src_interrupt_gen2(int irq, void *data)
        if (rsnd_src_error_record_gen2(mod)) {
                struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
+                struct rsnd_src *src = rsnd_mod_to_src(mod);
                struct device *dev = rsnd_priv_to_dev(priv);
-                _rsnd_src_stop_gen2(mod);
-                _rsnd_src_start_gen2(mod);
                dev_dbg(dev, "%s[%d] restart\n",
                        rsnd_mod_name(mod), rsnd_mod_id(mod));
+                _rsnd_src_stop_gen2(mod);
+                if (src->err < 1024)
+                        _rsnd_src_start_gen2(mod);
+                else
+                        dev_warn(dev, "no more SRC restart\n");
        }
        return IRQ_HANDLED;
@@ -627,6 +704,7 @@ static int rsnd_src_set_convert_rate_gen2(struct rsnd_mod *mod)
        struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
        struct rsnd_src *src = rsnd_mod_to_src(mod);
        u32 convert_rate = rsnd_src_convert_rate(src);
+        u32 cr, route;
        uint ratio;
        int ret;
@@ -647,13 +725,21 @@ static int rsnd_src_set_convert_rate_gen2(struct rsnd_mod *mod)
        if (ret < 0)
                return ret;
-        rsnd_mod_write(mod, SRC_SRCCR, 0x00011110);
+        cr      = 0x00011110;
+        route   = 0x0;
        if (convert_rate) {
-                /* Gen1/Gen2 are not compatible */
+                route   = 0x1;
-                rsnd_mod_write(mod, SRC_ROUTE_MODE0, 1);
+                if (rsnd_enable_sync_convert(src)) {
+                        cr |= 0x1;
+                        route |= rsnd_io_is_play(io) ?
+                                (0x1 << 24) : (0x1 << 25);
+                }
        }
+        rsnd_mod_write(mod, SRC_SRCCR, cr);
+        rsnd_mod_write(mod, SRC_ROUTE_MODE0, route);
        switch (rsnd_mod_id(mod)) {
        case 5:
        case 6:
@@ -708,24 +794,12 @@ static int rsnd_src_probe_gen2(struct rsnd_mod *mod,
                                       IRQF_SHARED,
                                       dev_name(dev), mod);
                if (ret)
-                        goto rsnd_src_probe_gen2_fail;
+                        return ret;
        }
        ret = rsnd_dma_init(priv,
                            rsnd_mod_to_dma(mod),
-                            rsnd_info_is_playback(priv, src),
                            src->info->dma_id);
-        if (ret)
-                goto rsnd_src_probe_gen2_fail;
-        dev_dbg(dev, "%s[%d] (Gen2) is probed\n",
-                rsnd_mod_name(mod), rsnd_mod_id(mod));
-        return ret;
-rsnd_src_probe_gen2_fail:
-        dev_err(dev, "%s[%d] (Gen2) failed\n",
-                rsnd_mod_name(mod), rsnd_mod_id(mod));
        return ret;
 }
@@ -733,7 +807,7 @@ rsnd_src_probe_gen2_fail:
 static int rsnd_src_remove_gen2(struct rsnd_mod *mod,
                                struct rsnd_priv *priv)
 {
-        rsnd_dma_quit(priv, rsnd_mod_to_dma(mod));
+        rsnd_dma_quit(rsnd_mod_to_dma(mod));
        return 0;
 }
@@ -743,7 +817,7 @@ static int rsnd_src_init_gen2(struct rsnd_mod *mod,
 {
        int ret;
-        ret = rsnd_src_init(mod);
+        ret = rsnd_src_init(mod, priv);
        if (ret < 0)
                return ret;
@@ -778,14 +852,91 @@ static int rsnd_src_stop_gen2(struct rsnd_mod *mod,
        return ret;
 }
+static void rsnd_src_reconvert_update(struct rsnd_mod *mod)
+{
+        struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
+        struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
+        struct rsnd_src *src = rsnd_mod_to_src(mod);
+        u32 convert_rate = rsnd_src_convert_rate(src);
+        u32 fsrate;
+        if (!runtime)
+                return;
+        if (!convert_rate)
+                convert_rate = runtime->rate;
+        fsrate = 0x0400000 / convert_rate * runtime->rate;
+        /* update IFS */
+        rsnd_mod_write(mod, SRC_IFSVR, fsrate);
+}
+static int rsnd_src_pcm_new(struct rsnd_mod *mod,
+                            struct snd_soc_pcm_runtime *rtd)
+{
+        struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
+        struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
+        struct rsnd_dai *rdai = rsnd_io_to_rdai(io);
+        struct rsnd_src *src = rsnd_mod_to_src(mod);
+        int ret;
+        /*
+         * enable SRC sync convert if possible
+         */
+        /*
+         * Gen1 is not supported
+         */
+        if (rsnd_is_gen1(priv))
+                return 0;
+        /*
+         * SRC sync convert needs clock master
+         */
+        if (!rsnd_rdai_is_clk_master(rdai))
+                return 0;
+        /*
+         * We can't use SRC sync convert
+         * if it has DVC
+         */
+        if (rsnd_io_to_mod_dvc(io))
+                return 0;
+        /*
+         * enable sync convert
+         */
+        ret = rsnd_kctrl_new_s(mod, rtd,
+                               rsnd_io_is_play(io) ?
+                               "SRC Out Rate Switch" :
+                               "SRC In Rate Switch",
+                               rsnd_src_reconvert_update,
+                               &src->sen, 1);
+        if (ret < 0)
+                return ret;
+        ret = rsnd_kctrl_new_s(mod, rtd,
+                               rsnd_io_is_play(io) ?
+                               "SRC Out Rate" :
+                               "SRC In Rate",
+                               rsnd_src_reconvert_update,
+                               &src->sync, 192000);
+        return ret;
+}
 static struct rsnd_mod_ops rsnd_src_gen2_ops = {
        .name   = SRC_NAME,
+        .dma_req = rsnd_src_dma_req,
        .probe  = rsnd_src_probe_gen2,
        .remove = rsnd_src_remove_gen2,
        .init   = rsnd_src_init_gen2,
        .quit   = rsnd_src_quit,
        .start  = rsnd_src_start_gen2,
        .stop   = rsnd_src_stop_gen2,
+        .hw_params = rsnd_src_hw_params,
+        .pcm_new = rsnd_src_pcm_new,
 };
 struct rsnd_mod *rsnd_src_mod_get(struct rsnd_priv *priv, int id)
@@ -810,7 +961,7 @@ static void rsnd_of_parse_src(struct platform_device *pdev,
        if (!of_data)
                return;
-        src_node = of_get_child_by_name(dev->of_node, "rcar_sound,src");
+        src_node = rsnd_src_of_node(priv);
        if (!src_node)
                return;
@@ -850,7 +1001,7 @@ int rsnd_src_probe(struct platform_device *pdev,
        struct rsnd_mod_ops *ops;
        struct clk *clk;
        char name[RSND_SRC_NAME_SIZE];
-        int i, nr;
+        int i, nr, ret;
        ops = NULL;
        if (rsnd_is_gen1(priv))
@@ -890,10 +1041,21 @@ int rsnd_src_probe(struct platform_device *pdev,
                src->info = &info->src_info[i];
-                rsnd_mod_init(&src->mod, ops, clk, RSND_MOD_SRC, i);
+                ret = rsnd_mod_init(&src->mod, ops, clk, RSND_MOD_SRC, i);
+                if (ret)
-                dev_dbg(dev, "SRC%d probed\n", i);
+                        return ret;
        }
        return 0;
 }
+void rsnd_src_remove(struct platform_device *pdev,
+                     struct rsnd_priv *priv)
+{
+        struct rsnd_src *src;
+        int i;
+        for_each_rsnd_src(src, priv, i) {
+                rsnd_mod_quit(&src->mod);
+        }
+}
diff --git a/sound/soc/sh/rcar/ssi.c b/sound/soc/sh/rcar/ssi.c
index 9e7b627c08e2..7bb9c087f3dc 100644
--- a/sound/soc/sh/rcar/ssi.c
+++ b/sound/soc/sh/rcar/ssi.c
@@ -80,13 +80,13 @@ struct rsnd_ssi {
 #define rsnd_mod_to_ssi(_mod) container_of((_mod), struct rsnd_ssi, mod)
 #define rsnd_dma_to_ssi(dma)  rsnd_mod_to_ssi(rsnd_dma_to_mod(dma))
 #define rsnd_ssi_pio_available(ssi) ((ssi)->info->irq > 0)
-#define rsnd_ssi_dma_available(ssi) \
-        rsnd_dma_available(rsnd_mod_to_dma(&(ssi)->mod))
 #define rsnd_ssi_clk_from_parent(ssi) ((ssi)->parent)
 #define rsnd_ssi_mode_flags(p) ((p)->info->flags)
 #define rsnd_ssi_dai_id(ssi) ((ssi)->info->dai_id)
+#define rsnd_ssi_of_node(priv) \
+        of_get_child_by_name(rsnd_priv_to_dev(priv)->of_node, "rcar_sound,ssi")
-static int rsnd_ssi_use_busif(struct rsnd_mod *mod)
+int rsnd_ssi_use_busif(struct rsnd_mod *mod)
 {
        struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
        struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
@@ -416,11 +416,14 @@ static irqreturn_t rsnd_ssi_interrupt(int irq, void *data)
                /*
                 * restart SSI
                 */
-                rsnd_ssi_stop(mod, priv);
-                rsnd_ssi_start(mod, priv);
                dev_dbg(dev, "%s[%d] restart\n",
                        rsnd_mod_name(mod), rsnd_mod_id(mod));
+                rsnd_ssi_stop(mod, priv);
+                if (ssi->err < 1024)
+                        rsnd_ssi_start(mod, priv);
+                else
+                        dev_warn(dev, "no more SSI restart\n");
        }
        rsnd_ssi_record_error(ssi, status);
@@ -442,12 +445,6 @@ static int rsnd_ssi_pio_probe(struct rsnd_mod *mod,
                               rsnd_ssi_interrupt,
                               IRQF_SHARED,
                               dev_name(dev), ssi);
-        if (ret)
-                dev_err(dev, "%s[%d] (PIO) request interrupt failed\n",
-                        rsnd_mod_name(mod), rsnd_mod_id(mod));
-        else
-                dev_dbg(dev, "%s[%d] (PIO) is probed\n",
-                        rsnd_mod_name(mod), rsnd_mod_id(mod));
        return ret;
 }
@@ -474,23 +471,11 @@ static int rsnd_ssi_dma_probe(struct rsnd_mod *mod,
                               IRQF_SHARED,
                               dev_name(dev), ssi);
        if (ret)
-                goto rsnd_ssi_dma_probe_fail;
+                return ret;
        ret = rsnd_dma_init(
                priv, rsnd_mod_to_dma(mod),
-                rsnd_info_is_playback(priv, ssi),
                dma_id);
-        if (ret)
-                goto rsnd_ssi_dma_probe_fail;
-        dev_dbg(dev, "%s[%d] (DMA) is probed\n",
-                rsnd_mod_name(mod), rsnd_mod_id(mod));
-        return ret;
-rsnd_ssi_dma_probe_fail:
-        dev_err(dev, "%s[%d] (DMA) is failed\n",
-                rsnd_mod_name(mod), rsnd_mod_id(mod));
        return ret;
 }
@@ -502,7 +487,7 @@ static int rsnd_ssi_dma_remove(struct rsnd_mod *mod,
        struct device *dev = rsnd_priv_to_dev(priv);
        int irq = ssi->info->irq;
-        rsnd_dma_quit(priv, rsnd_mod_to_dma(mod));
+        rsnd_dma_quit(rsnd_mod_to_dma(mod));
        /* PIO will request IRQ again */
        devm_free_irq(dev, irq, ssi);
@@ -554,14 +539,25 @@ static int rsnd_ssi_dma_stop(struct rsnd_mod *mod,
        return 0;
 }
-static char *rsnd_ssi_dma_name(struct rsnd_mod *mod)
+static struct dma_chan *rsnd_ssi_dma_req(struct rsnd_mod *mod)
 {
-        return rsnd_ssi_use_busif(mod) ? "ssiu" : SSI_NAME;
+        struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
+        struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
+        int is_play = rsnd_io_is_play(io);
+        char *name;
+        if (rsnd_ssi_use_busif(mod))
+                name = is_play ? "rxu" : "txu";
+        else
+                name = is_play ? "rx" : "tx";
+        return rsnd_dma_request_channel(rsnd_ssi_of_node(priv),
+                                        mod, name);
 }
 static struct rsnd_mod_ops rsnd_ssi_dma_ops = {
        .name   = SSI_NAME,
-        .dma_name = rsnd_ssi_dma_name,
+        .dma_req = rsnd_ssi_dma_req,
        .probe  = rsnd_ssi_dma_probe,
        .remove = rsnd_ssi_dma_remove,
        .init   = rsnd_ssi_init,
@@ -636,7 +632,7 @@ static void rsnd_of_parse_ssi(struct platform_device *pdev,
        if (!of_data)
                return;
-        node = of_get_child_by_name(dev->of_node, "rcar_sound,ssi");
+        node = rsnd_ssi_of_node(priv);
        if (!node)
                return;
@@ -697,7 +693,7 @@ int rsnd_ssi_probe(struct platform_device *pdev,
        struct clk *clk;
        struct rsnd_ssi *ssi;
        char name[RSND_SSI_NAME_SIZE];
-        int i, nr;
+        int i, nr, ret;
        rsnd_of_parse_ssi(pdev, of_data, priv);
@@ -732,10 +728,23 @@ int rsnd_ssi_probe(struct platform_device *pdev,
                else if (rsnd_ssi_pio_available(ssi))
                        ops = &rsnd_ssi_pio_ops;
-                rsnd_mod_init(&ssi->mod, ops, clk, RSND_MOD_SSI, i);
+                ret = rsnd_mod_init(&ssi->mod, ops, clk, RSND_MOD_SSI, i);
+                if (ret)
+                        return ret;
                rsnd_ssi_parent_clk_setup(priv, ssi);
        }
        return 0;
 }
+void rsnd_ssi_remove(struct platform_device *pdev,
+                     struct rsnd_priv *priv)
+{
+        struct rsnd_ssi *ssi;
+        int i;
+        for_each_rsnd_ssi(ssi, priv, i) {
+                rsnd_mod_quit(&ssi->mod);
+        }
+}
diff --git a/sound/soc/soc-core.c b/sound/soc/soc-core.c
index 07aa54385ae0..12b7ff2426da 100644
--- a/sound/soc/soc-core.c
+++ b/sound/soc/soc-core.c
@@ -292,6 +292,9 @@ static const struct file_operations codec_reg_fops = {
 static void soc_init_component_debugfs(struct snd_soc_component *component)
 {
+        if (!component->card->debugfs_card_root)
+                return;
        if (component->debugfs_prefix) {
                char *name;
@@ -455,6 +458,9 @@ static const struct file_operations platform_list_fops = {
 static void soc_init_card_debugfs(struct snd_soc_card *card)
 {
+        if (!snd_soc_debugfs_root)
+                return;
        card->debugfs_card_root = debugfs_create_dir(card->name,
                                                     snd_soc_debugfs_root);
        if (!card->debugfs_card_root) {
@@ -476,6 +482,34 @@ static void soc_cleanup_card_debugfs(struct snd_soc_card *card)
        debugfs_remove_recursive(card->debugfs_card_root);
 }
+static void snd_soc_debugfs_init(void)
+{
+        snd_soc_debugfs_root = debugfs_create_dir("asoc", NULL);
+        if (IS_ERR(snd_soc_debugfs_root) || !snd_soc_debugfs_root) {
+                pr_warn("ASoC: Failed to create debugfs directory\n");
+                snd_soc_debugfs_root = NULL;
+                return;
+        }
+        if (!debugfs_create_file("codecs", 0444, snd_soc_debugfs_root, NULL,
+                                 &codec_list_fops))
+                pr_warn("ASoC: Failed to create CODEC list debugfs file\n");
+        if (!debugfs_create_file("dais", 0444, snd_soc_debugfs_root, NULL,
+                                 &dai_list_fops))
+                pr_warn("ASoC: Failed to create DAI list debugfs file\n");
+        if (!debugfs_create_file("platforms", 0444, snd_soc_debugfs_root, NULL,
+                                 &platform_list_fops))
+                pr_warn("ASoC: Failed to create platform list debugfs file\n");
+}
+static void snd_soc_debugfs_exit(void)
+{
+        debugfs_remove_recursive(snd_soc_debugfs_root);
+}
 #else
 #define soc_init_codec_debugfs NULL
@@ -497,6 +531,15 @@ static inline void soc_init_card_debugfs(struct snd_soc_card *card)
 static inline void soc_cleanup_card_debugfs(struct snd_soc_card *card)
 {
 }
+static inline void snd_soc_debugfs_init(void)
+{
+}
+static inline void snd_soc_debugfs_exit(void)
+{
+}
 #endif
 struct snd_pcm_substream *snd_soc_get_dai_substream(struct snd_soc_card *card,
@@ -595,15 +638,9 @@ int snd_soc_suspend(struct device *dev)
                        cpu_dai->driver->suspend(cpu_dai);
        }
-        /* close any waiting streams and save state */
+        /* close any waiting streams */
-        for (i = 0; i < card->num_rtd; i++) {
+        for (i = 0; i < card->num_rtd; i++)
-                struct snd_soc_dai **codec_dais = card->rtd[i].codec_dais;
                flush_delayed_work(&card->rtd[i].delayed_work);
-                for (j = 0; j < card->rtd[i].num_codecs; j++) {
-                        codec_dais[j]->codec->dapm.suspend_bias_level =
-                                        codec_dais[j]->codec->dapm.bias_level;
-                }
-        }
        for (i = 0; i < card->num_rtd; i++) {
@@ -1261,7 +1298,8 @@ static int soc_link_dai_widgets(struct snd_soc_card *card,
        capture_w = cpu_dai->capture_widget;
        if (play_w && capture_w) {
                ret = snd_soc_dapm_new_pcm(card, dai_link->params,
-                                           capture_w, play_w);
+                                           dai_link->num_params, capture_w,
+                                           play_w);
                if (ret != 0) {
                        dev_err(card->dev, "ASoC: Can't link %s to %s: %d\n",
                                play_w->name, capture_w->name, ret);
@@ -1273,7 +1311,8 @@ static int soc_link_dai_widgets(struct snd_soc_card *card,
        capture_w = codec_dai->capture_widget;
        if (play_w && capture_w) {
                ret = snd_soc_dapm_new_pcm(card, dai_link->params,
-                                           capture_w, play_w);
+                                           dai_link->num_params, capture_w,
+                                           play_w);
                if (ret != 0) {
                        dev_err(card->dev, "ASoC: Can't link %s to %s: %d\n",
                                play_w->name, capture_w->name, ret);
@@ -1322,21 +1361,17 @@ static int soc_probe_link_dais(struct snd_soc_card *card, int num, int order)
                }
        }
+        if (dai_link->dai_fmt)
+                snd_soc_runtime_set_dai_fmt(rtd, dai_link->dai_fmt);
        ret = soc_post_component_init(rtd, dai_link->name);
        if (ret)
                return ret;
 #ifdef CONFIG_DEBUG_FS
        /* add DPCM sysfs entries */
-        if (dai_link->dynamic) {
+        if (dai_link->dynamic)
-                ret = soc_dpcm_debugfs_add(rtd);
+                soc_dpcm_debugfs_add(rtd);
-                if (ret < 0) {
-                        dev_err(rtd->dev,
-                                "ASoC: failed to add dpcm sysfs entries: %d\n",
-                                ret);
-                        return ret;
-                }
-        }
 #endif
        if (cpu_dai->driver->compress_dai) {
@@ -1426,7 +1461,6 @@ static void soc_remove_aux_dev(struct snd_soc_card *card, int num)
        /* unregister the rtd device */
        if (rtd->dev_registered) {
-                device_remove_file(rtd->dev, &dev_attr_codec_reg);
                device_unregister(rtd->dev);
                rtd->dev_registered = 0;
        }
@@ -1560,6 +1594,8 @@ static int snd_soc_instantiate_card(struct snd_soc_card *card)
                goto base_error;
        }
+        soc_init_card_debugfs(card);
        card->dapm.bias_level = SND_SOC_BIAS_OFF;
        card->dapm.dev = card->dev;
        card->dapm.card = card;
@@ -1641,12 +1677,6 @@ static int snd_soc_instantiate_card(struct snd_soc_card *card)
                snd_soc_dapm_add_routes(&card->dapm, card->of_dapm_routes,
                                        card->num_of_dapm_routes);
-        for (i = 0; i < card->num_links; i++) {
-                if (card->dai_link[i].dai_fmt)
-                        snd_soc_runtime_set_dai_fmt(&card->rtd[i],
-                                card->dai_link[i].dai_fmt);
-        }
        snprintf(card->snd_card->shortname, sizeof(card->snd_card->shortname),
                 "%s", card->name);
        snprintf(card->snd_card->longname, sizeof(card->snd_card->longname),
@@ -1702,6 +1732,7 @@ card_probe_error:
        if (card->remove)
                card->remove(card);
+        soc_cleanup_card_debugfs(card);
        snd_card_free(card->snd_card);
 base_error:
@@ -2380,8 +2411,6 @@ int snd_soc_register_card(struct snd_soc_card *card)
        snd_soc_initialize_card_lists(card);
-        soc_init_card_debugfs(card);
        card->rtd = devm_kzalloc(card->dev,
                                 sizeof(struct snd_soc_pcm_runtime) *
                                 (card->num_links + card->num_aux_devs),
@@ -2412,7 +2441,7 @@ int snd_soc_register_card(struct snd_soc_card *card)
        ret = snd_soc_instantiate_card(card);
        if (ret != 0)
-                soc_cleanup_card_debugfs(card);
+                return ret;
        /* deactivate pins to sleep state */
        for (i = 0; i < card->num_rtd; i++) {
@@ -3595,26 +3624,7 @@ EXPORT_SYMBOL_GPL(snd_soc_of_get_dai_link_codecs);
 static int __init snd_soc_init(void)
 {
-#ifdef CONFIG_DEBUG_FS
+        snd_soc_debugfs_init();
-        snd_soc_debugfs_root = debugfs_create_dir("asoc", NULL);
-        if (IS_ERR(snd_soc_debugfs_root) || !snd_soc_debugfs_root) {
-                pr_warn("ASoC: Failed to create debugfs directory\n");
-                snd_soc_debugfs_root = NULL;
-        }
-        if (!debugfs_create_file("codecs", 0444, snd_soc_debugfs_root, NULL,
-                                 &codec_list_fops))
-                pr_warn("ASoC: Failed to create CODEC list debugfs file\n");
-        if (!debugfs_create_file("dais", 0444, snd_soc_debugfs_root, NULL,
-                                 &dai_list_fops))
-                pr_warn("ASoC: Failed to create DAI list debugfs file\n");
-        if (!debugfs_create_file("platforms", 0444, snd_soc_debugfs_root, NULL,
-                                 &platform_list_fops))
-                pr_warn("ASoC: Failed to create platform list debugfs file\n");
-#endif
        snd_soc_util_init();
        return platform_driver_register(&soc_driver);
@@ -3624,9 +3634,9 @@ module_init(snd_soc_init);
 static void __exit snd_soc_exit(void)
 {
        snd_soc_util_exit();
+        snd_soc_debugfs_exit();
 #ifdef CONFIG_DEBUG_FS
-        debugfs_remove_recursive(snd_soc_debugfs_root);
 #endif
        platform_driver_unregister(&soc_driver);
 }
diff --git a/sound/soc/soc-dapm.c b/sound/soc/soc-dapm.c
index b6f88202b8c9..defe0f0082b5 100644
--- a/sound/soc/soc-dapm.c
+++ b/sound/soc/soc-dapm.c
@@ -473,16 +473,6 @@ struct snd_soc_dapm_context *snd_soc_dapm_kcontrol_dapm(
 }
 EXPORT_SYMBOL_GPL(snd_soc_dapm_kcontrol_dapm);
-/**
- * snd_soc_dapm_kcontrol_codec() - Returns the codec associated to a kcontrol
- * @kcontrol: The kcontrol
- */
-struct snd_soc_codec *snd_soc_dapm_kcontrol_codec(struct snd_kcontrol *kcontrol)
-{
-        return snd_soc_dapm_to_codec(snd_soc_dapm_kcontrol_dapm(kcontrol));
-}
-EXPORT_SYMBOL_GPL(snd_soc_dapm_kcontrol_codec);
 static void dapm_reset(struct snd_soc_card *card)
 {
        struct snd_soc_dapm_widget *w;
@@ -853,6 +843,36 @@ static int dapm_new_pga(struct snd_soc_dapm_widget *w)
        return 0;
 }
+/* create new dapm dai link control */
+static int dapm_new_dai_link(struct snd_soc_dapm_widget *w)
+{
+        int i, ret;
+        struct snd_kcontrol *kcontrol;
+        struct snd_soc_dapm_context *dapm = w->dapm;
+        struct snd_card *card = dapm->card->snd_card;
+        /* create control for links with > 1 config */
+        if (w->num_params <= 1)
+                return 0;
+        /* add kcontrol */
+        for (i = 0; i < w->num_kcontrols; i++) {
+                kcontrol = snd_soc_cnew(&w->kcontrol_news[i], w,
+                                        w->name, NULL);
+                ret = snd_ctl_add(card, kcontrol);
+                if (ret < 0) {
+                        dev_err(dapm->dev,
+                                "ASoC: failed to add widget %s dapm kcontrol %s: %d\n",
+                                w->name, w->kcontrol_news[i].name, ret);
+                        return ret;
+                }
+                kcontrol->private_data = w;
+                w->kcontrols[i] = kcontrol;
+        }
+        return 0;
+}
 /* We implement power down on suspend by checking the power state of
 * the ALSA card - when we are suspending the ALSA state for the card
 * is set to D3.
@@ -1898,6 +1918,9 @@ void snd_soc_dapm_debugfs_init(struct snd_soc_dapm_context *dapm,
 {
        struct dentry *d;
+        if (!parent)
+                return;
        dapm->debugfs_dapm = debugfs_create_dir("dapm", parent);
        if (!dapm->debugfs_dapm) {
@@ -2719,6 +2742,9 @@ int snd_soc_dapm_new_widgets(struct snd_soc_card *card)
                case snd_soc_dapm_out_drv:
                        dapm_new_pga(w);
                        break;
+                case snd_soc_dapm_dai_link:
+                        dapm_new_dai_link(w);
+                        break;
                default:
                        break;
                }
@@ -3193,7 +3219,7 @@ static int snd_soc_dai_link_event(struct snd_soc_dapm_widget *w,
 {
        struct snd_soc_dapm_path *source_p, *sink_p;
        struct snd_soc_dai *source, *sink;
-        const struct snd_soc_pcm_stream *config = w->params;
+        const struct snd_soc_pcm_stream *config = w->params + w->params_select;
        struct snd_pcm_substream substream;
        struct snd_pcm_hw_params *params = NULL;
        u64 fmt;
@@ -3285,22 +3311,97 @@ out:
        return ret;
 }
+static int snd_soc_dapm_dai_link_get(struct snd_kcontrol *kcontrol,
+                          struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_dapm_widget *w = snd_kcontrol_chip(kcontrol);
+        ucontrol->value.integer.value[0] = w->params_select;
+        return 0;
+}
+static int snd_soc_dapm_dai_link_put(struct snd_kcontrol *kcontrol,
+                          struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_dapm_widget *w = snd_kcontrol_chip(kcontrol);
+        /* Can't change the config when widget is already powered */
+        if (w->power)
+                return -EBUSY;
+        if (ucontrol->value.integer.value[0] == w->params_select)
+                return 0;
+        if (ucontrol->value.integer.value[0] >= w->num_params)
+                return -EINVAL;
+        w->params_select = ucontrol->value.integer.value[0];
+        return 0;
+}
 int snd_soc_dapm_new_pcm(struct snd_soc_card *card,
                         const struct snd_soc_pcm_stream *params,
+                         unsigned int num_params,
                         struct snd_soc_dapm_widget *source,
                         struct snd_soc_dapm_widget *sink)
 {
        struct snd_soc_dapm_widget template;
        struct snd_soc_dapm_widget *w;
-        size_t len;
        char *link_name;
-        int ret;
+        int ret, count;
+        unsigned long private_value;
-        len = strlen(source->name) + strlen(sink->name) + 2;
+        const char **w_param_text;
-        link_name = devm_kzalloc(card->dev, len, GFP_KERNEL);
+        struct soc_enum w_param_enum[] = {
-        if (!link_name)
+                SOC_ENUM_SINGLE(0, 0, 0, NULL),
+        };
+        struct snd_kcontrol_new kcontrol_dai_link[] = {
+                SOC_ENUM_EXT(NULL, w_param_enum[0],
+                             snd_soc_dapm_dai_link_get,
+                             snd_soc_dapm_dai_link_put),
+        };
+        const struct snd_soc_pcm_stream *config = params;
+        w_param_text = devm_kcalloc(card->dev, num_params,
+                                        sizeof(char *), GFP_KERNEL);
+        if (!w_param_text)
                return -ENOMEM;
-        snprintf(link_name, len, "%s-%s", source->name, sink->name);
+        link_name = devm_kasprintf(card->dev, GFP_KERNEL, "%s-%s",
+                                   source->name, sink->name);
+        if (!link_name) {
+                ret = -ENOMEM;
+                goto outfree_w_param;
+        }
+        for (count = 0 ; count < num_params; count++) {
+                if (!config->stream_name) {
+                        dev_warn(card->dapm.dev,
+                                "ASoC: anonymous config %d for dai link %s\n",
+                                count, link_name);
+                        w_param_text[count] =
+                                devm_kasprintf(card->dev, GFP_KERNEL,
+                                               "Anonymous Configuration %d",
+                                               count);
+                        if (!w_param_text[count]) {
+                                ret = -ENOMEM;
+                                goto outfree_link_name;
+                        }
+                } else {
+                        w_param_text[count] = devm_kmemdup(card->dev,
+                                                config->stream_name,
+                                                strlen(config->stream_name) + 1,
+                                                GFP_KERNEL);
+                        if (!w_param_text[count]) {
+                                ret = -ENOMEM;
+                                goto outfree_link_name;
+                        }
+                }
+                config++;
+        }
+        w_param_enum[0].items = num_params;
+        w_param_enum[0].texts = w_param_text;
        memset(&template, 0, sizeof(template));
        template.reg = SND_SOC_NOPM;
@@ -3309,6 +3410,30 @@ int snd_soc_dapm_new_pcm(struct snd_soc_card *card,
        template.event = snd_soc_dai_link_event;
        template.event_flags = SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
                SND_SOC_DAPM_PRE_PMD;
+        template.num_kcontrols = 1;
+        /* duplicate w_param_enum on heap so that memory persists */
+        private_value =
+                (unsigned long) devm_kmemdup(card->dev,
+                        (void *)(kcontrol_dai_link[0].private_value),
+                        sizeof(struct soc_enum), GFP_KERNEL);
+        if (!private_value) {
+                dev_err(card->dev, "ASoC: Failed to create control for %s widget\n",
+                        link_name);
+                ret = -ENOMEM;
+                goto outfree_link_name;
+        }
+        kcontrol_dai_link[0].private_value = private_value;
+        /* duplicate kcontrol_dai_link on heap so that memory persists */
+        template.kcontrol_news =
+                                devm_kmemdup(card->dev, &kcontrol_dai_link[0],
+                                        sizeof(struct snd_kcontrol_new),
+                                        GFP_KERNEL);
+        if (!template.kcontrol_news) {
+                dev_err(card->dev, "ASoC: Failed to create control for %s widget\n",
+                        link_name);
+                ret = -ENOMEM;
+                goto outfree_private_value;
+        }
        dev_dbg(card->dev, "ASoC: adding %s widget\n", link_name);
@@ -3316,15 +3441,32 @@ int snd_soc_dapm_new_pcm(struct snd_soc_card *card,
        if (!w) {
                dev_err(card->dev, "ASoC: Failed to create %s widget\n",
                        link_name);
-                return -ENOMEM;
+                ret = -ENOMEM;
+                goto outfree_kcontrol_news;
        }
        w->params = params;
+        w->num_params = num_params;
        ret = snd_soc_dapm_add_path(&card->dapm, source, w, NULL, NULL);
        if (ret)
-                return ret;
+                goto outfree_w;
        return snd_soc_dapm_add_path(&card->dapm, w, sink, NULL, NULL);
+outfree_w:
+        devm_kfree(card->dev, w);
+outfree_kcontrol_news:
+        devm_kfree(card->dev, (void *)template.kcontrol_news);
+outfree_private_value:
+        devm_kfree(card->dev, (void *)private_value);
+outfree_link_name:
+        devm_kfree(card->dev, link_name);
+outfree_w_param:
+        for (count = 0 ; count < num_params; count++)
+                devm_kfree(card->dev, (void *)w_param_text[count]);
+        devm_kfree(card->dev, w_param_text);
+        return ret;
 }
 int snd_soc_dapm_new_dai_widgets(struct snd_soc_dapm_context *dapm,
diff --git a/sound/soc/soc-pcm.c b/sound/soc/soc-pcm.c
index 6e3781e88f9a..35fe58f4fa86 100644
--- a/sound/soc/soc-pcm.c
+++ b/sound/soc/soc-pcm.c
@@ -1097,8 +1097,9 @@ static int dpcm_be_connect(struct snd_soc_pcm_runtime *fe,
                        stream ? "<-" : "->", be->dai_link->name);
 #ifdef CONFIG_DEBUG_FS
-        dpcm->debugfs_state = debugfs_create_u32(be->dai_link->name, 0644,
+        if (fe->debugfs_dpcm_root)
-                        fe->debugfs_dpcm_root, &dpcm->state);
+                dpcm->debugfs_state = debugfs_create_u32(be->dai_link->name, 0644,
+                                fe->debugfs_dpcm_root, &dpcm->state);
 #endif
        return 1;
 }
@@ -2803,10 +2804,13 @@ static const struct file_operations dpcm_state_fops = {
        .llseek = default_llseek,
 };
-int soc_dpcm_debugfs_add(struct snd_soc_pcm_runtime *rtd)
+void soc_dpcm_debugfs_add(struct snd_soc_pcm_runtime *rtd)
 {
        if (!rtd->dai_link)
-                return 0;
+                return;
+        if (!rtd->card->debugfs_card_root)
+                return;
        rtd->debugfs_dpcm_root = debugfs_create_dir(rtd->dai_link->name,
                        rtd->card->debugfs_card_root);
@@ -2814,13 +2818,11 @@ int soc_dpcm_debugfs_add(struct snd_soc_pcm_runtime *rtd)
                dev_dbg(rtd->dev,
                         "ASoC: Failed to create dpcm debugfs directory %s\n",
                         rtd->dai_link->name);
-                return -EINVAL;
+                return;
        }
        rtd->debugfs_dpcm_state = debugfs_create_file("state", 0444,
                                                rtd->debugfs_dpcm_root,
                                                rtd, &dpcm_state_fops);
-        return 0;
 }
 #endif
diff --git a/sound/soc/tegra/tegra_alc5632.c b/sound/soc/tegra/tegra_alc5632.c
index 6dcd06a966c7..ba272e21a6fa 100644
--- a/sound/soc/tegra/tegra_alc5632.c
+++ b/sound/soc/tegra/tegra_alc5632.c
@@ -101,9 +101,6 @@ static const struct snd_kcontrol_new tegra_alc5632_controls[] = {
 static int tegra_alc5632_asoc_init(struct snd_soc_pcm_runtime *rtd)
 {
-        struct snd_soc_dai *codec_dai = rtd->codec_dai;
-        struct snd_soc_codec *codec = codec_dai->codec;
-        struct snd_soc_dapm_context *dapm = &codec->dapm;
        struct tegra_alc5632 *machine = snd_soc_card_get_drvdata(rtd->card);
        snd_soc_card_jack_new(rtd->card, "Headset Jack", SND_JACK_HEADSET,
@@ -118,7 +115,7 @@ static int tegra_alc5632_asoc_init(struct snd_soc_pcm_runtime *rtd)
                                                &tegra_alc5632_hp_jack_gpio);
        }
-        snd_soc_dapm_force_enable_pin(dapm, "MICBIAS1");
+        snd_soc_dapm_force_enable_pin(&rtd->card->dapm, "MICBIAS1");
        return 0;
 }
diff --git a/sound/soc/tegra/tegra_rt5677.c b/sound/soc/tegra/tegra_rt5677.c
index 68d8b67e79c1..1470873ecde6 100644
--- a/sound/soc/tegra/tegra_rt5677.c
+++ b/sound/soc/tegra/tegra_rt5677.c
@@ -141,9 +141,6 @@ static const struct snd_kcontrol_new tegra_rt5677_controls[] = {
 static int tegra_rt5677_asoc_init(struct snd_soc_pcm_runtime *rtd)
 {
-        struct snd_soc_dai *codec_dai = rtd->codec_dai;
-        struct snd_soc_codec *codec = codec_dai->codec;
-        struct snd_soc_dapm_context *dapm = &codec->dapm;
        struct tegra_rt5677 *machine = snd_soc_card_get_drvdata(rtd->card);
        snd_soc_card_jack_new(rtd->card, "Headphone Jack", SND_JACK_HEADPHONE,
@@ -167,7 +164,7 @@ static int tegra_rt5677_asoc_init(struct snd_soc_pcm_runtime *rtd)
                                &tegra_rt5677_mic_jack_gpio);
        }
-        snd_soc_dapm_force_enable_pin(dapm, "MICBIAS1");
+        snd_soc_dapm_force_enable_pin(&rtd->card->dapm, "MICBIAS1");
        return 0;
 }
@@ -329,7 +326,6 @@ static const struct of_device_id tegra_rt5677_of_match[] = {
 static struct platform_driver tegra_rt5677_driver = {
        .driver = {
                .name = DRV_NAME,
-                .owner = THIS_MODULE,
                .pm = &snd_soc_pm_ops,
                .of_match_table = tegra_rt5677_of_match,
        },
diff --git a/sound/soc/tegra/tegra_wm8903.c b/sound/soc/tegra/tegra_wm8903.c
index 4a95b70f0cf0..21604009bc1a 100644
--- a/sound/soc/tegra/tegra_wm8903.c
+++ b/sound/soc/tegra/tegra_wm8903.c
@@ -171,7 +171,6 @@ static int tegra_wm8903_init(struct snd_soc_pcm_runtime *rtd)
 {
        struct snd_soc_dai *codec_dai = rtd->codec_dai;
        struct snd_soc_codec *codec = codec_dai->codec;
-        struct snd_soc_dapm_context *dapm = &codec->dapm;
        struct snd_soc_card *card = rtd->card;
        struct tegra_wm8903 *machine = snd_soc_card_get_drvdata(card);
@@ -193,7 +192,7 @@ static int tegra_wm8903_init(struct snd_soc_pcm_runtime *rtd)
        wm8903_mic_detect(codec, &tegra_wm8903_mic_jack, SND_JACK_MICROPHONE,
                                0);
-        snd_soc_dapm_force_enable_pin(dapm, "MICBIAS");
+        snd_soc_dapm_force_enable_pin(&card->dapm, "MICBIAS");
        return 0;
 }
diff --git a/sound/soc/tegra/tegra_wm9712.c b/sound/soc/tegra/tegra_wm9712.c
index 2868b4839bc0..6492f8143ff1 100644
--- a/sound/soc/tegra/tegra_wm9712.c
+++ b/sound/soc/tegra/tegra_wm9712.c
@@ -46,11 +46,7 @@ static const struct snd_soc_dapm_widget tegra_wm9712_dapm_widgets[] = {
 static int tegra_wm9712_init(struct snd_soc_pcm_runtime *rtd)
 {
-        struct snd_soc_dai *codec_dai = rtd->codec_dai;
+        return snd_soc_dapm_force_enable_pin(&rtd->card->dapm, "Mic Bias");
-        struct snd_soc_codec *codec = codec_dai->codec;
-        struct snd_soc_dapm_context *dapm = &codec->dapm;
-        return snd_soc_dapm_force_enable_pin(dapm, "Mic Bias");
 }
 static struct snd_soc_dai_link tegra_wm9712_dai = {
diff --git a/sound/soc/ux500/mop500_ab8500.c b/sound/soc/ux500/mop500_ab8500.c
index aa65370db82a..b81a7a4c938b 100644
--- a/sound/soc/ux500/mop500_ab8500.c
+++ b/sound/soc/ux500/mop500_ab8500.c
@@ -362,7 +362,7 @@ struct snd_soc_ops mop500_ab8500_ops[] = {
 int mop500_ab8500_machine_init(struct snd_soc_pcm_runtime *rtd)
 {
-        struct snd_soc_codec *codec = rtd->codec;
+        struct snd_soc_dapm_context *dapm = &rtd->card->dapm;
        struct device *dev = rtd->card->dev;
        struct mop500_ab8500_drvdata *drvdata;
        int ret;
@@ -407,23 +407,23 @@ int mop500_ab8500_machine_init(struct snd_soc_pcm_runtime *rtd)
                return ret;
        }
-        ret = snd_soc_dapm_disable_pin(&codec->dapm, "Earpiece");
+        ret = snd_soc_dapm_disable_pin(dapm, "Earpiece");
-        ret |= snd_soc_dapm_disable_pin(&codec->dapm, "Speaker Left");
+        ret |= snd_soc_dapm_disable_pin(dapm, "Speaker Left");
-        ret |= snd_soc_dapm_disable_pin(&codec->dapm, "Speaker Right");
+        ret |= snd_soc_dapm_disable_pin(dapm, "Speaker Right");
-        ret |= snd_soc_dapm_disable_pin(&codec->dapm, "LineOut Left");
+        ret |= snd_soc_dapm_disable_pin(dapm, "LineOut Left");
-        ret |= snd_soc_dapm_disable_pin(&codec->dapm, "LineOut Right");
+        ret |= snd_soc_dapm_disable_pin(dapm, "LineOut Right");
-        ret |= snd_soc_dapm_disable_pin(&codec->dapm, "Vibra 1");
+        ret |= snd_soc_dapm_disable_pin(dapm, "Vibra 1");
-        ret |= snd_soc_dapm_disable_pin(&codec->dapm, "Vibra 2");
+        ret |= snd_soc_dapm_disable_pin(dapm, "Vibra 2");
-        ret |= snd_soc_dapm_disable_pin(&codec->dapm, "Mic 1");
+        ret |= snd_soc_dapm_disable_pin(dapm, "Mic 1");
-        ret |= snd_soc_dapm_disable_pin(&codec->dapm, "Mic 2");
+        ret |= snd_soc_dapm_disable_pin(dapm, "Mic 2");
-        ret |= snd_soc_dapm_disable_pin(&codec->dapm, "LineIn Left");
+        ret |= snd_soc_dapm_disable_pin(dapm, "LineIn Left");
-        ret |= snd_soc_dapm_disable_pin(&codec->dapm, "LineIn Right");
+        ret |= snd_soc_dapm_disable_pin(dapm, "LineIn Right");
-        ret |= snd_soc_dapm_disable_pin(&codec->dapm, "DMic 1");
+        ret |= snd_soc_dapm_disable_pin(dapm, "DMic 1");
-        ret |= snd_soc_dapm_disable_pin(&codec->dapm, "DMic 2");
+        ret |= snd_soc_dapm_disable_pin(dapm, "DMic 2");
-        ret |= snd_soc_dapm_disable_pin(&codec->dapm, "DMic 3");
+        ret |= snd_soc_dapm_disable_pin(dapm, "DMic 3");
-        ret |= snd_soc_dapm_disable_pin(&codec->dapm, "DMic 4");
+        ret |= snd_soc_dapm_disable_pin(dapm, "DMic 4");
-        ret |= snd_soc_dapm_disable_pin(&codec->dapm, "DMic 5");
+        ret |= snd_soc_dapm_disable_pin(dapm, "DMic 5");
-        ret |= snd_soc_dapm_disable_pin(&codec->dapm, "DMic 6");
+        ret |= snd_soc_dapm_disable_pin(dapm, "DMic 6");
        return ret;
 }
author	Takashi Iwai <tiwai@suse.de>	2015-04-13 08:14:29 -0400
committer	Takashi Iwai <tiwai@suse.de>	2015-04-13 08:14:29 -0400
commit	ce4524e5a78123fbf2db5b1549798c91a6d98294 (patch)
tree	fc6450c80af14542f8bdb6b4726674669d259969 /sound
parent	f2aa111041ce36b94e651d882458dea502e76721 (diff)
parent	7667428f80526d908124e0647ac5dbe3dad88900 (diff)