60 files changed, 2002 insertions, 3282 deletions

diff --git a/sound/core/pcm.c b/sound/core/pcm.c
index 42ded997b223..c6ff94ab1ad6 100644
--- a/sound/core/pcm.c
+++ b/sound/core/pcm.c
@@ -216,6 +216,8 @@ static char *snd_pcm_format_names[] = {
         FORMAT(DSD_U8),
         FORMAT(DSD_U16_LE),
         FORMAT(DSD_U32_LE),
+        FORMAT(DSD_U16_BE),
+        FORMAT(DSD_U32_BE),
 };
 
 const char *snd_pcm_format_name(snd_pcm_format_t format)
diff --git a/sound/core/pcm_compat.c b/sound/core/pcm_compat.c
index 102e8fd1d450..2d957ba63557 100644
--- a/sound/core/pcm_compat.c
+++ b/sound/core/pcm_compat.c
@@ -210,6 +210,8 @@ static int snd_pcm_status_user_compat(struct snd_pcm_substream *substream,
         if (err < 0)
                 return err;
 
+        if (clear_user(src, sizeof(*src)))
+                return -EFAULT;
         if (put_user(status.state, &src->state) ||
             compat_put_timespec(&status.trigger_tstamp, &src->trigger_tstamp) ||
             compat_put_timespec(&status.tstamp, &src->tstamp) ||
diff --git a/sound/core/pcm_misc.c b/sound/core/pcm_misc.c
index ae7a0feb3b76..ebe8444de6c6 100644
--- a/sound/core/pcm_misc.c
+++ b/sound/core/pcm_misc.c
@@ -152,6 +152,14 @@ static struct pcm_format_data pcm_formats[(INT)SNDRV_PCM_FORMAT_LAST+1] = {
                 .width = 32, .phys = 32, .le = 1, .signd = 0,
                 .silence = { 0x69, 0x69, 0x69, 0x69 },
         },
+        [SNDRV_PCM_FORMAT_DSD_U16_BE] = {
+                .width = 16, .phys = 16, .le = 0, .signd = 0,
+                .silence = { 0x69, 0x69 },
+        },
+        [SNDRV_PCM_FORMAT_DSD_U32_BE] = {
+                .width = 32, .phys = 32, .le = 0, .signd = 0,
+                .silence = { 0x69, 0x69, 0x69, 0x69 },
+        },
         /* FIXME: the following three formats are not defined properly yet */
         [SNDRV_PCM_FORMAT_MPEG] = {
                 .le = -1, .signd = -1,
diff --git a/sound/core/pcm_native.c b/sound/core/pcm_native.c
index bfe1cf6b492f..166d59cdc86b 100644
--- a/sound/core/pcm_native.c
+++ b/sound/core/pcm_native.c
@@ -781,16 +781,15 @@ static int snd_pcm_action_group(struct action_ops *ops,
 {
         struct snd_pcm_substream *s = NULL;
         struct snd_pcm_substream *s1;
-        int res = 0;
+        int res = 0, depth = 1;
 
         snd_pcm_group_for_each_entry(s, substream) {
                 if (do_lock && s != substream) {
                         if (s->pcm->nonatomic)
-                                mutex_lock_nested(&s->self_group.mutex,
-                                                  SINGLE_DEPTH_NESTING);
+                                mutex_lock_nested(&s->self_group.mutex, depth);
                         else
-                                spin_lock_nested(&s->self_group.lock,
-                                                 SINGLE_DEPTH_NESTING);
+                                spin_lock_nested(&s->self_group.lock, depth);
+                        depth++;
                 }
                 res = ops->pre_action(s, state);
                 if (res < 0)
@@ -906,8 +905,7 @@ static int snd_pcm_action_lock_mutex(struct action_ops *ops,
         down_read(&snd_pcm_link_rwsem);
         if (snd_pcm_stream_linked(substream)) {
                 mutex_lock(&substream->group->mutex);
-                mutex_lock_nested(&substream->self_group.mutex,
-                                  SINGLE_DEPTH_NESTING);
+                mutex_lock(&substream->self_group.mutex);
                 res = snd_pcm_action_group(ops, substream, state, 1);
                 mutex_unlock(&substream->self_group.mutex);
                 mutex_unlock(&substream->group->mutex);
@@ -3311,7 +3309,7 @@ static const struct vm_operations_struct snd_pcm_vm_ops_data_fault = {
 
 #ifndef ARCH_HAS_DMA_MMAP_COHERENT
 /* This should be defined / handled globally! */
-#ifdef CONFIG_ARM
+#if defined(CONFIG_ARM) || defined(CONFIG_ARM64)
 #define ARCH_HAS_DMA_MMAP_COHERENT
 #endif
 #endif
diff --git a/sound/firewire/bebob/bebob_focusrite.c b/sound/firewire/bebob/bebob_focusrite.c
index 45a0eed6d5b1..3b052ed0fbf5 100644
--- a/sound/firewire/bebob/bebob_focusrite.c
+++ b/sound/firewire/bebob/bebob_focusrite.c
@@ -27,12 +27,14 @@
 #define SAFFIRE_CLOCK_SOURCE_INTERNAL           0
 #define SAFFIRE_CLOCK_SOURCE_SPDIF              1
 
-/* '1' is absent, why... */
+/* clock sources as returned from register of Saffire Pro 10 and 26 */
 #define SAFFIREPRO_CLOCK_SOURCE_INTERNAL        0
+#define SAFFIREPRO_CLOCK_SOURCE_SKIP            1 /* never used on hardware */
 #define SAFFIREPRO_CLOCK_SOURCE_SPDIF           2
-#define SAFFIREPRO_CLOCK_SOURCE_ADAT1           3
-#define SAFFIREPRO_CLOCK_SOURCE_ADAT2           4
+#define SAFFIREPRO_CLOCK_SOURCE_ADAT1           3 /* not used on s.pro. 10 */
+#define SAFFIREPRO_CLOCK_SOURCE_ADAT2           4 /* not used on s.pro. 10 */
 #define SAFFIREPRO_CLOCK_SOURCE_WORDCLOCK       5
+#define SAFFIREPRO_CLOCK_SOURCE_COUNT           6
 
 /* S/PDIF, ADAT1, ADAT2 is enabled or not. three quadlets */
 #define SAFFIREPRO_ENABLE_DIG_IFACES            0x01a4
@@ -101,13 +103,34 @@ saffire_write_quad(struct snd_bebob *bebob, u64 offset, u32 value)
                                   &data, sizeof(__be32), 0);
 }
 
+static char *const saffirepro_10_clk_src_labels[] = {
+        SND_BEBOB_CLOCK_INTERNAL, "S/PDIF", "Word Clock"
+};
 static char *const saffirepro_26_clk_src_labels[] = {
         SND_BEBOB_CLOCK_INTERNAL, "S/PDIF", "ADAT1", "ADAT2", "Word Clock"
 };
-
-static char *const saffirepro_10_clk_src_labels[] = {
-        SND_BEBOB_CLOCK_INTERNAL, "S/PDIF", "Word Clock"
+/* Value maps between registers and labels for SaffirePro 10/26. */
+static const signed char saffirepro_clk_maps[][SAFFIREPRO_CLOCK_SOURCE_COUNT] = {
+        /* SaffirePro 10 */
+        [0] = {
+                [SAFFIREPRO_CLOCK_SOURCE_INTERNAL]  =  0,
+                [SAFFIREPRO_CLOCK_SOURCE_SKIP]      = -1, /* not supported */
+                [SAFFIREPRO_CLOCK_SOURCE_SPDIF]     =  1,
+                [SAFFIREPRO_CLOCK_SOURCE_ADAT1]     = -1, /* not supported */
+                [SAFFIREPRO_CLOCK_SOURCE_ADAT2]     = -1, /* not supported */
+                [SAFFIREPRO_CLOCK_SOURCE_WORDCLOCK] =  2,
+        },
+        /* SaffirePro 26 */
+        [1] = {
+                [SAFFIREPRO_CLOCK_SOURCE_INTERNAL]  =  0,
+                [SAFFIREPRO_CLOCK_SOURCE_SKIP]      = -1, /* not supported */
+                [SAFFIREPRO_CLOCK_SOURCE_SPDIF]     =  1,
+                [SAFFIREPRO_CLOCK_SOURCE_ADAT1]     =  2,
+                [SAFFIREPRO_CLOCK_SOURCE_ADAT2]     =  3,
+                [SAFFIREPRO_CLOCK_SOURCE_WORDCLOCK] =  4,
+        }
 };
+
 static int
 saffirepro_both_clk_freq_get(struct snd_bebob *bebob, unsigned int *rate)
 {
@@ -138,24 +161,35 @@ saffirepro_both_clk_freq_set(struct snd_bebob *bebob, unsigned int rate)
 
         return saffire_write_quad(bebob, SAFFIREPRO_RATE_NOREBOOT, id);
 }
+
+/*
+ * query hardware for current clock source, return our internally
+ * used clock index in *id, depending on hardware.
+ */
 static int
 saffirepro_both_clk_src_get(struct snd_bebob *bebob, unsigned int *id)
 {
         int err;
-        u32 value;
+        u32 value;       /* clock source read from hw register */
+        const signed char *map;
 
         err = saffire_read_quad(bebob, SAFFIREPRO_OFFSET_CLOCK_SOURCE, &value);
         if (err < 0)
                 goto end;
 
-        if (bebob->spec->clock->labels == saffirepro_10_clk_src_labels) {
-                if (value == SAFFIREPRO_CLOCK_SOURCE_WORDCLOCK)
-                        *id = 2;
-                else if (value == SAFFIREPRO_CLOCK_SOURCE_SPDIF)
-                        *id = 1;
-        } else if (value > 1) {
-                *id = value - 1;
+        /* depending on hardware, use a different mapping */
+        if (bebob->spec->clock->labels == saffirepro_10_clk_src_labels)
+                map = saffirepro_clk_maps[0];
+        else
+                map = saffirepro_clk_maps[1];
+
+        /* In a case that this driver cannot handle the value of register. */
+        if (value >= SAFFIREPRO_CLOCK_SOURCE_COUNT || map[value] < 0) {
+                err = -EIO;
+                goto end;
         }
+
+        *id = (unsigned int)map[value];
 end:
         return err;
 }
diff --git a/sound/firewire/bebob/bebob_stream.c b/sound/firewire/bebob/bebob_stream.c
index ef4d0c9f6578..1aab0a32870c 100644
--- a/sound/firewire/bebob/bebob_stream.c
+++ b/sound/firewire/bebob/bebob_stream.c
@@ -129,12 +129,24 @@ snd_bebob_stream_check_internal_clock(struct snd_bebob *bebob, bool *internal)
         /* 1.The device has its own operation to switch source of clock */
         if (clk_spec) {
                 err = clk_spec->get(bebob, &id);
-                if (err < 0)
+                if (err < 0) {
                         dev_err(&bebob->unit->device,
                                 "fail to get clock source: %d\n", err);
-                else if (strncmp(clk_spec->labels[id], SND_BEBOB_CLOCK_INTERNAL,
-                                 strlen(SND_BEBOB_CLOCK_INTERNAL)) == 0)
+                        goto end;
+                }
+
+                if (id >= clk_spec->num) {
+                        dev_err(&bebob->unit->device,
+                                "clock source %d out of range 0..%d\n",
+                                id, clk_spec->num - 1);
+                        err = -EIO;
+                        goto end;
+                }
+
+                if (strncmp(clk_spec->labels[id], SND_BEBOB_CLOCK_INTERNAL,
+                            strlen(SND_BEBOB_CLOCK_INTERNAL)) == 0)
                         *internal = true;
+
                 goto end;
         }
 
diff --git a/sound/firewire/bebob/bebob_terratec.c b/sound/firewire/bebob/bebob_terratec.c
index 0e4c0bfc463b..9940611f2e1b 100644
--- a/sound/firewire/bebob/bebob_terratec.c
+++ b/sound/firewire/bebob/bebob_terratec.c
@@ -24,7 +24,12 @@ phase88_rack_clk_src_get(struct snd_bebob *bebob, unsigned int *id)
         if (err < 0)
                 goto end;
 
-        *id = (enable_ext & 0x01) | ((enable_word & 0x01) << 1);
+        if (enable_ext == 0)
+                *id = 0;
+        else if (enable_word == 0)
+                *id = 1;
+        else
+                *id = 2;
 end:
         return err;
 }
diff --git a/sound/pci/ad1889.c b/sound/pci/ad1889.c
index 7bfdf9c51416..1610c38337af 100644
--- a/sound/pci/ad1889.c
+++ b/sound/pci/ad1889.c
@@ -681,7 +681,7 @@ snd_ad1889_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffe
         
         /* WARQ is at offset 12 */
         tmp = (reg & AD_DS_WSMC_WARQ) ?
-                        (((reg & AD_DS_WSMC_WARQ >> 12) & 0x01) ? 12 : 18) : 4;
+                ((((reg & AD_DS_WSMC_WARQ) >> 12) & 0x01) ? 12 : 18) : 4;
         tmp /= (reg & AD_DS_WSMC_WAST) ? 2 : 1;
         
         snd_iprintf(buffer, "Wave FIFO: %d %s words\n\n", tmp,
@@ -693,7 +693,7 @@ snd_ad1889_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffe
         
         /* SYRQ is at offset 4 */
         tmp = (reg & AD_DS_WSMC_SYRQ) ?
-                        (((reg & AD_DS_WSMC_SYRQ >> 4) & 0x01) ? 12 : 18) : 4;
+                ((((reg & AD_DS_WSMC_SYRQ) >> 4) & 0x01) ? 12 : 18) : 4;
         tmp /= (reg & AD_DS_WSMC_WAST) ? 2 : 1;
         
         snd_iprintf(buffer, "Synthesis FIFO: %d %s words\n\n", tmp,
@@ -709,7 +709,7 @@ snd_ad1889_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffe
         
         /* ACRQ is at offset 4 */
         tmp = (reg & AD_DS_RAMC_ACRQ) ?
-                        (((reg & AD_DS_RAMC_ACRQ >> 4) & 0x01) ? 12 : 18) : 4;
+                ((((reg & AD_DS_RAMC_ACRQ) >> 4) & 0x01) ? 12 : 18) : 4;
         tmp /= (reg & AD_DS_RAMC_ADST) ? 2 : 1;
         
         snd_iprintf(buffer, "ADC FIFO: %d %s words\n\n", tmp,
@@ -720,7 +720,7 @@ snd_ad1889_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffe
                         
         /* RERQ is at offset 12 */
         tmp = (reg & AD_DS_RAMC_RERQ) ?
-                        (((reg & AD_DS_RAMC_RERQ >> 12) & 0x01) ? 12 : 18) : 4;
+                ((((reg & AD_DS_RAMC_RERQ) >> 12) & 0x01) ? 12 : 18) : 4;
         tmp /= (reg & AD_DS_RAMC_ADST) ? 2 : 1;
         
         snd_iprintf(buffer, "Resampler FIFO: %d %s words\n\n", tmp,
diff --git a/sound/pci/hda/hda_intel.c b/sound/pci/hda/hda_intel.c
index cfcca4c30d4d..48b6c5a3884f 100644
--- a/sound/pci/hda/hda_intel.c
+++ b/sound/pci/hda/hda_intel.c
@@ -219,6 +219,7 @@ MODULE_SUPPORTED_DEVICE("{{Intel, ICH6},"
                          "{Intel, LPT_LP},"
                          "{Intel, WPT_LP},"
                          "{Intel, SPT},"
+                         "{Intel, SPT_LP},"
                          "{Intel, HPT},"
                          "{Intel, PBG},"
                          "{Intel, SCH},"
@@ -297,7 +298,8 @@ enum {
 
 /* quirks for ATI/AMD HDMI */
 #define AZX_DCAPS_PRESET_ATI_HDMI \
-        (AZX_DCAPS_NO_TCSEL | AZX_DCAPS_SYNC_WRITE | AZX_DCAPS_POSFIX_LPIB)
+        (AZX_DCAPS_NO_TCSEL | AZX_DCAPS_SYNC_WRITE | AZX_DCAPS_POSFIX_LPIB|\
+         AZX_DCAPS_NO_MSI64)
 
 /* quirks for Nvidia */
 #define AZX_DCAPS_PRESET_NVIDIA \
@@ -374,6 +376,8 @@ static void __mark_pages_wc(struct azx *chip, struct snd_dma_buffer *dmab, bool
 #ifdef CONFIG_SND_DMA_SGBUF
         if (dmab->dev.type == SNDRV_DMA_TYPE_DEV_SG) {
                 struct snd_sg_buf *sgbuf = dmab->private_data;
+                if (chip->driver_type == AZX_DRIVER_CMEDIA)
+                        return; /* deal with only CORB/RIRB buffers */
                 if (on)
                         set_pages_array_wc(sgbuf->page_table, sgbuf->pages);
                 else
@@ -1483,6 +1487,7 @@ static int azx_first_init(struct azx *chip)
         struct snd_card *card = chip->card;
         int err;
         unsigned short gcap;
+        unsigned int dma_bits = 64;
 
 #if BITS_PER_LONG != 64
         /* Fix up base address on ULI M5461 */
@@ -1506,9 +1511,14 @@ static int azx_first_init(struct azx *chip)
                 return -ENXIO;
         }
 
-        if (chip->msi)
+        if (chip->msi) {
+                if (chip->driver_caps & AZX_DCAPS_NO_MSI64) {
+                        dev_dbg(card->dev, "Disabling 64bit MSI\n");
+                        pci->no_64bit_msi = true;
+                }
                 if (pci_enable_msi(pci) < 0)
                         chip->msi = 0;
+        }
 
         if (azx_acquire_irq(chip, 0) < 0)
                 return -EBUSY;
@@ -1519,9 +1529,14 @@ static int azx_first_init(struct azx *chip)
         gcap = azx_readw(chip, GCAP);
         dev_dbg(card->dev, "chipset global capabilities = 0x%x\n", gcap);
 
+        /* AMD devices support 40 or 48bit DMA, take the safe one */
+        if (chip->pci->vendor == PCI_VENDOR_ID_AMD)
+                dma_bits = 40;
+
         /* disable SB600 64bit support for safety */
         if (chip->pci->vendor == PCI_VENDOR_ID_ATI) {
                 struct pci_dev *p_smbus;
+                dma_bits = 40;
                 p_smbus = pci_get_device(PCI_VENDOR_ID_ATI,
                                          PCI_DEVICE_ID_ATI_SBX00_SMBUS,
                                          NULL);
@@ -1551,9 +1566,11 @@ static int azx_first_init(struct azx *chip)
         }
 
         /* allow 64bit DMA address if supported by H/W */
-        if ((gcap & AZX_GCAP_64OK) && !pci_set_dma_mask(pci, DMA_BIT_MASK(64)))
-                pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(64));
-        else {
+        if (!(gcap & AZX_GCAP_64OK))
+                dma_bits = 32;
+        if (!pci_set_dma_mask(pci, DMA_BIT_MASK(dma_bits))) {
+                pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(dma_bits));
+        } else {
                 pci_set_dma_mask(pci, DMA_BIT_MASK(32));
                 pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(32));
         }
@@ -1769,7 +1786,7 @@ static void pcm_mmap_prepare(struct snd_pcm_substream *substream,
 #ifdef CONFIG_X86
         struct azx_pcm *apcm = snd_pcm_substream_chip(substream);
         struct azx *chip = apcm->chip;
-        if (!azx_snoop(chip))
+        if (!azx_snoop(chip) && chip->driver_type != AZX_DRIVER_CMEDIA)
                 area->vm_page_prot = pgprot_writecombine(area->vm_page_prot);
 #endif
 }
@@ -2002,6 +2019,9 @@ static const struct pci_device_id azx_ids[] = {
         /* Sunrise Point */
         { PCI_DEVICE(0x8086, 0xa170),
           .driver_data = AZX_DRIVER_PCH | AZX_DCAPS_INTEL_PCH },
+        /* Sunrise Point-LP */
+        { PCI_DEVICE(0x8086, 0x9d70),
+          .driver_data = AZX_DRIVER_PCH | AZX_DCAPS_INTEL_PCH },
         /* Haswell */
         { PCI_DEVICE(0x8086, 0x0a0c),
           .driver_data = AZX_DRIVER_HDMI | AZX_DCAPS_INTEL_HASWELL },
diff --git a/sound/pci/hda/hda_local.h b/sound/pci/hda/hda_local.h
index 7eb44e78e141..62658f2f8c9f 100644
--- a/sound/pci/hda/hda_local.h
+++ b/sound/pci/hda/hda_local.h
@@ -419,7 +419,7 @@ struct snd_hda_pin_quirk {
           .subvendor = _subvendor,\
           .name = _name,\
           .value = _value,\
-          .pins = (const struct hda_pintbl[]) { _pins } \
+          .pins = (const struct hda_pintbl[]) { _pins, {0, 0}} \
         }
 #else
 
@@ -427,7 +427,7 @@ struct snd_hda_pin_quirk {
         { .codec = _codec,\
           .subvendor = _subvendor,\
           .value = _value,\
-          .pins = (const struct hda_pintbl[]) { _pins } \
+          .pins = (const struct hda_pintbl[]) { _pins, {0, 0}} \
         }
 
 #endif
diff --git a/sound/pci/hda/hda_priv.h b/sound/pci/hda/hda_priv.h
index 949cd437eeb2..5016014e57f2 100644
--- a/sound/pci/hda/hda_priv.h
+++ b/sound/pci/hda/hda_priv.h
@@ -171,6 +171,7 @@ enum { SDI0, SDI1, SDI2, SDI3, SDO0, SDO1, SDO2, SDO3 };
 #define AZX_DCAPS_PM_RUNTIME    (1 << 26)       /* runtime PM support */
 #define AZX_DCAPS_I915_POWERWELL (1 << 27)      /* HSW i915 powerwell support */
 #define AZX_DCAPS_CORBRP_SELF_CLEAR (1 << 28)   /* CORBRP clears itself after reset */
+#define AZX_DCAPS_NO_MSI64      (1 << 29)       /* Stick to 32-bit MSIs */
 
 /* HD Audio class code */
 #define PCI_CLASS_MULTIMEDIA_HD_AUDIO   0x0403
diff --git a/sound/pci/hda/patch_conexant.c b/sound/pci/hda/patch_conexant.c
index 71e4bad06345..e9ebc7bd752c 100644
--- a/sound/pci/hda/patch_conexant.c
+++ b/sound/pci/hda/patch_conexant.c
@@ -43,6 +43,7 @@ struct conexant_spec {
         unsigned int num_eapds;
         hda_nid_t eapds[4];
         bool dynamic_eapd;
+        hda_nid_t mute_led_eapd;
 
         unsigned int parse_flags; /* flag for snd_hda_parse_pin_defcfg() */
 
@@ -163,6 +164,17 @@ static void cx_auto_vmaster_hook(void *private_data, int enabled)
         cx_auto_turn_eapd(codec, spec->num_eapds, spec->eapds, enabled);
 }
 
+/* turn on/off EAPD according to Master switch (inversely!) for mute LED */
+static void cx_auto_vmaster_hook_mute_led(void *private_data, int enabled)
+{
+        struct hda_codec *codec = private_data;
+        struct conexant_spec *spec = codec->spec;
+
+        snd_hda_codec_write(codec, spec->mute_led_eapd, 0,
+                            AC_VERB_SET_EAPD_BTLENABLE,
+                            enabled ? 0x00 : 0x02);
+}
+
 static int cx_auto_build_controls(struct hda_codec *codec)
 {
         int err;
@@ -223,6 +235,7 @@ enum {
         CXT_FIXUP_TOSHIBA_P105,
         CXT_FIXUP_HP_530,
         CXT_FIXUP_CAP_MIX_AMP_5047,
+        CXT_FIXUP_MUTE_LED_EAPD,
 };
 
 /* for hda_fixup_thinkpad_acpi() */
@@ -557,6 +570,18 @@ static void cxt_fixup_olpc_xo(struct hda_codec *codec,
         }
 }
 
+static void cxt_fixup_mute_led_eapd(struct hda_codec *codec,
+                                    const struct hda_fixup *fix, int action)
+{
+        struct conexant_spec *spec = codec->spec;
+
+        if (action == HDA_FIXUP_ACT_PRE_PROBE) {
+                spec->mute_led_eapd = 0x1b;
+                spec->dynamic_eapd = 1;
+                spec->gen.vmaster_mute.hook = cx_auto_vmaster_hook_mute_led;
+        }
+}
+
 /*
  * Fix max input level on mixer widget to 0dB
  * (originally it has 0x2b steps with 0dB offset 0x14)
@@ -705,6 +730,10 @@ static const struct hda_fixup cxt_fixups[] = {
                 .type = HDA_FIXUP_FUNC,
                 .v.func = cxt_fixup_cap_mix_amp_5047,
         },
+        [CXT_FIXUP_MUTE_LED_EAPD] = {
+                .type = HDA_FIXUP_FUNC,
+                .v.func = cxt_fixup_mute_led_eapd,
+        },
 };
 
 static const struct snd_pci_quirk cxt5045_fixups[] = {
@@ -762,6 +791,7 @@ static const struct snd_pci_quirk cxt5066_fixups[] = {
         SND_PCI_QUIRK(0x17aa, 0x21cf, "Lenovo T520", CXT_PINCFG_LENOVO_TP410),
         SND_PCI_QUIRK(0x17aa, 0x21da, "Lenovo X220", CXT_PINCFG_LENOVO_TP410),
         SND_PCI_QUIRK(0x17aa, 0x21db, "Lenovo X220-tablet", CXT_PINCFG_LENOVO_TP410),
+        SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo IdeaPad Z560", CXT_FIXUP_MUTE_LED_EAPD),
         SND_PCI_QUIRK(0x17aa, 0x3975, "Lenovo U300s", CXT_FIXUP_STEREO_DMIC),
         SND_PCI_QUIRK(0x17aa, 0x3977, "Lenovo IdeaPad U310", CXT_FIXUP_STEREO_DMIC),
         SND_PCI_QUIRK(0x17aa, 0x397b, "Lenovo S205", CXT_FIXUP_STEREO_DMIC),
@@ -780,6 +810,7 @@ static const struct hda_model_fixup cxt5066_fixup_models[] = {
         { .id = CXT_PINCFG_LEMOTE_A1004, .name = "lemote-a1004" },
         { .id = CXT_PINCFG_LEMOTE_A1205, .name = "lemote-a1205" },
         { .id = CXT_FIXUP_OLPC_XO, .name = "olpc-xo" },
+        { .id = CXT_FIXUP_MUTE_LED_EAPD, .name = "mute-led-eapd" },
         {}
 };
 
diff --git a/sound/pci/hda/patch_hdmi.c b/sound/pci/hda/patch_hdmi.c
index 39862e98551c..9dc9cf8c90e9 100644
--- a/sound/pci/hda/patch_hdmi.c
+++ b/sound/pci/hda/patch_hdmi.c
@@ -1583,19 +1583,22 @@ static bool hdmi_present_sense(struct hdmi_spec_per_pin *per_pin, int repoll)
                 }
         }
 
-        if (pin_eld->eld_valid && !eld->eld_valid) {
-                update_eld = true;
+        if (pin_eld->eld_valid != eld->eld_valid)
                 eld_changed = true;
-        }
+
+        if (pin_eld->eld_valid && !eld->eld_valid)
+                update_eld = true;
+
         if (update_eld) {
                 bool old_eld_valid = pin_eld->eld_valid;
                 pin_eld->eld_valid = eld->eld_valid;
-                eld_changed = pin_eld->eld_size != eld->eld_size ||
+                if (pin_eld->eld_size != eld->eld_size ||
                               memcmp(pin_eld->eld_buffer, eld->eld_buffer,
-                                     eld->eld_size) != 0;
-                if (eld_changed)
+                                     eld->eld_size) != 0) {
                         memcpy(pin_eld->eld_buffer, eld->eld_buffer,
                                eld->eld_size);
+                        eld_changed = true;
+                }
                 pin_eld->eld_size = eld->eld_size;
                 pin_eld->info = eld->info;
 
diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c
index bc86c36b4bfa..b118a5be18df 100644
--- a/sound/pci/hda/patch_realtek.c
+++ b/sound/pci/hda/patch_realtek.c
@@ -288,21 +288,91 @@ static void alc880_unsol_event(struct hda_codec *codec, unsigned int res)
         snd_hda_jack_unsol_event(codec, res >> 2);
 }
 
-/* additional initialization for ALC888 variants */
-static void alc888_coef_init(struct hda_codec *codec)
+/* Change EAPD to verb control */
+static void alc_fill_eapd_coef(struct hda_codec *codec)
 {
-        if (alc_get_coef0(codec) == 0x20)
-                /* alc888S-VC */
-                alc_write_coef_idx(codec, 7, 0x830);
-         else
-                 /* alc888-VB */
-                alc_write_coef_idx(codec, 7, 0x3030);
+        int coef;
+
+        coef = alc_get_coef0(codec);
+
+        switch (codec->vendor_id) {
+        case 0x10ec0262:
+                alc_update_coef_idx(codec, 0x7, 0, 1<<5);
+                break;
+        case 0x10ec0267:
+        case 0x10ec0268:
+                alc_update_coef_idx(codec, 0x7, 0, 1<<13);
+                break;
+        case 0x10ec0269:
+                if ((coef & 0x00f0) == 0x0010)
+                        alc_update_coef_idx(codec, 0xd, 0, 1<<14);
+                if ((coef & 0x00f0) == 0x0020)
+                        alc_update_coef_idx(codec, 0x4, 1<<15, 0);
+                if ((coef & 0x00f0) == 0x0030)
+                        alc_update_coef_idx(codec, 0x10, 1<<9, 0);
+                break;
+        case 0x10ec0280:
+        case 0x10ec0284:
+        case 0x10ec0290:
+        case 0x10ec0292:
+                alc_update_coef_idx(codec, 0x4, 1<<15, 0);
+                break;
+        case 0x10ec0233:
+        case 0x10ec0255:
+        case 0x10ec0282:
+        case 0x10ec0283:
+        case 0x10ec0286:
+        case 0x10ec0288:
+                alc_update_coef_idx(codec, 0x10, 1<<9, 0);
+                break;
+        case 0x10ec0285:
+        case 0x10ec0293:
+                alc_update_coef_idx(codec, 0xa, 1<<13, 0);
+                break;
+        case 0x10ec0662:
+                if ((coef & 0x00f0) == 0x0030)
+                        alc_update_coef_idx(codec, 0x4, 1<<10, 0); /* EAPD Ctrl */
+                break;
+        case 0x10ec0272:
+        case 0x10ec0273:
+        case 0x10ec0663:
+        case 0x10ec0665:
+        case 0x10ec0670:
+        case 0x10ec0671:
+        case 0x10ec0672:
+                alc_update_coef_idx(codec, 0xd, 0, 1<<14); /* EAPD Ctrl */
+                break;
+        case 0x10ec0668:
+                alc_update_coef_idx(codec, 0x7, 3<<13, 0);
+                break;
+        case 0x10ec0867:
+                alc_update_coef_idx(codec, 0x4, 1<<10, 0);
+                break;
+        case 0x10ec0888:
+                if ((coef & 0x00f0) == 0x0020 || (coef & 0x00f0) == 0x0030)
+                        alc_update_coef_idx(codec, 0x7, 1<<5, 0);
+                break;
+        case 0x10ec0892:
+                alc_update_coef_idx(codec, 0x7, 1<<5, 0);
+                break;
+        case 0x10ec0899:
+        case 0x10ec0900:
+                alc_update_coef_idx(codec, 0x7, 1<<1, 0);
+                break;
+        }
 }
 
-/* additional initialization for ALC889 variants */
-static void alc889_coef_init(struct hda_codec *codec)
+/* additional initialization for ALC888 variants */
+static void alc888_coef_init(struct hda_codec *codec)
 {
-        alc_update_coef_idx(codec, 7, 0, 0x2010);
+        switch (alc_get_coef0(codec) & 0x00f0) {
+        /* alc888-VA */
+        case 0x00:
+        /* alc888-VB */
+        case 0x10:
+                alc_update_coef_idx(codec, 7, 0, 0x2030); /* Turn EAPD to High */
+                break;
+        }
 }
 
 /* turn on/off EAPD control (only if available) */
@@ -343,6 +413,7 @@ static void alc_eapd_shutup(struct hda_codec *codec)
 /* generic EAPD initialization */
 static void alc_auto_init_amp(struct hda_codec *codec, int type)
 {
+        alc_fill_eapd_coef(codec);
         alc_auto_setup_eapd(codec, true);
         switch (type) {
         case ALC_INIT_GPIO1:
@@ -359,25 +430,15 @@ static void alc_auto_init_amp(struct hda_codec *codec, int type)
                 case 0x10ec0260:
                         alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x2010);
                         break;
-                case 0x10ec0262:
                 case 0x10ec0880:
                 case 0x10ec0882:
                 case 0x10ec0883:
                 case 0x10ec0885:
-                case 0x10ec0887:
-                /*case 0x10ec0889:*/ /* this causes an SPDIF problem */
-                case 0x10ec0900:
-                        alc889_coef_init(codec);
+                        alc_update_coef_idx(codec, 7, 0, 0x2030);
                         break;
                 case 0x10ec0888:
                         alc888_coef_init(codec);
                         break;
-#if 0 /* XXX: This may cause the silent output on speaker on some machines */
-                case 0x10ec0267:
-                case 0x10ec0268:
-                        alc_update_coef_idx(codec, 7, 0, 0x3000);
-                        break;
-#endif /* XXX */
                 }
                 break;
         }
@@ -1710,7 +1771,7 @@ static void alc889_fixup_coef(struct hda_codec *codec,
 {
         if (action != HDA_FIXUP_ACT_INIT)
                 return;
-        alc889_coef_init(codec);
+        alc_update_coef_idx(codec, 7, 0, 0x2030);
 }
 
 /* toggle speaker-output according to the hp-jack state */
@@ -2675,7 +2736,7 @@ static void alc269_shutup(struct hda_codec *codec)
 
 static struct coef_fw alc282_coefs[] = {
         WRITE_COEF(0x03, 0x0002), /* Power Down Control */
-        WRITE_COEF(0x05, 0x0700), /* FIFO and filter clock */
+        UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
         WRITE_COEF(0x07, 0x0200), /* DMIC control */
         UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
         UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
@@ -2786,7 +2847,7 @@ static void alc282_shutup(struct hda_codec *codec)
 
 static struct coef_fw alc283_coefs[] = {
         WRITE_COEF(0x03, 0x0002), /* Power Down Control */
-        WRITE_COEF(0x05, 0x0700), /* FIFO and filter clock */
+        UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
         WRITE_COEF(0x07, 0x0200), /* DMIC control */
         UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
         UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
@@ -2817,6 +2878,7 @@ static struct coef_fw alc283_coefs[] = {
         UPDATE_COEF(0x40, 0xf800, 0x9800), /* Class D DC enable */
         UPDATE_COEF(0x42, 0xf000, 0x2000), /* DC offset */
         WRITE_COEF(0x37, 0xfc06), /* Class D amp control */
+        UPDATE_COEF(0x1b, 0x8000, 0), /* HP JD control */
         {}
 };
 
@@ -2884,6 +2946,9 @@ static void alc283_shutup(struct hda_codec *codec)
 
         alc_write_coef_idx(codec, 0x43, 0x9004);
 
+        /*depop hp during suspend*/
+        alc_write_coef_idx(codec, 0x06, 0x2100);
+
         snd_hda_codec_write(codec, hp_pin, 0,
                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
 
@@ -3346,6 +3411,27 @@ static void alc269_fixup_hp_gpio_mic1_led(struct hda_codec *codec,
         }
 }
 
+static void alc280_fixup_hp_gpio4(struct hda_codec *codec,
+                                   const struct hda_fixup *fix, int action)
+{
+        /* Like hp_gpio_mic1_led, but also needs GPIO4 low to enable headphone amp */
+        struct alc_spec *spec = codec->spec;
+        static const struct hda_verb gpio_init[] = {
+                { 0x01, AC_VERB_SET_GPIO_MASK, 0x18 },
+                { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x18 },
+                {}
+        };
+
+        if (action == HDA_FIXUP_ACT_PRE_PROBE) {
+                spec->gen.vmaster_mute.hook = alc269_fixup_hp_gpio_mute_hook;
+                spec->gen.cap_sync_hook = alc269_fixup_hp_cap_mic_mute_hook;
+                spec->gpio_led = 0;
+                spec->cap_mute_led_nid = 0x18;
+                snd_hda_add_verbs(codec, gpio_init);
+                codec->power_filter = led_power_filter;
+        }
+}
+
 static void alc269_fixup_hp_line1_mic1_led(struct hda_codec *codec,
                                 const struct hda_fixup *fix, int action)
 {
@@ -4213,6 +4299,7 @@ enum {
         ALC283_FIXUP_BXBT2807_MIC,
         ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED,
         ALC282_FIXUP_ASPIRE_V5_PINS,
+        ALC280_FIXUP_HP_GPIO4,
 };
 
 static const struct hda_fixup alc269_fixups[] = {
@@ -4433,6 +4520,8 @@ static const struct hda_fixup alc269_fixups[] = {
         [ALC269_FIXUP_HEADSET_MODE] = {
                 .type = HDA_FIXUP_FUNC,
                 .v.func = alc_fixup_headset_mode,
+                .chained = true,
+                .chain_id = ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED
         },
         [ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
                 .type = HDA_FIXUP_FUNC,
@@ -4622,6 +4711,8 @@ static const struct hda_fixup alc269_fixups[] = {
         [ALC255_FIXUP_HEADSET_MODE] = {
                 .type = HDA_FIXUP_FUNC,
                 .v.func = alc_fixup_headset_mode_alc255,
+                .chained = true,
+                .chain_id = ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED
         },
         [ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
                 .type = HDA_FIXUP_FUNC,
@@ -4657,8 +4748,6 @@ static const struct hda_fixup alc269_fixups[] = {
         [ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED] = {
                 .type = HDA_FIXUP_FUNC,
                 .v.func = alc_fixup_dell_wmi,
-                .chained_before = true,
-                .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
         },
         [ALC282_FIXUP_ASPIRE_V5_PINS] = {
                 .type = HDA_FIXUP_PINS,
@@ -4676,7 +4765,10 @@ static const struct hda_fixup alc269_fixups[] = {
                         { },
                 },
         },
-
+        [ALC280_FIXUP_HP_GPIO4] = {
+                .type = HDA_FIXUP_FUNC,
+                .v.func = alc280_fixup_hp_gpio4,
+        },
 };
 
 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
@@ -4693,13 +4785,13 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = {
         SND_PCI_QUIRK(0x1028, 0x05f4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x1028, 0x05f5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x1028, 0x05f6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
-        SND_PCI_QUIRK(0x1028, 0x0610, "Dell", ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED),
         SND_PCI_QUIRK(0x1028, 0x0615, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
         SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
-        SND_PCI_QUIRK(0x1028, 0x061f, "Dell", ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED),
         SND_PCI_QUIRK(0x1028, 0x0638, "Dell Inspiron 5439", ALC290_FIXUP_MONO_SPEAKERS_HSJACK),
         SND_PCI_QUIRK(0x1028, 0x064a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x1028, 0x064b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
+        SND_PCI_QUIRK(0x1028, 0x06d9, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
+        SND_PCI_QUIRK(0x1028, 0x06da, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2),
@@ -4724,21 +4816,15 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = {
         SND_PCI_QUIRK(0x103c, 0x22cf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
         SND_PCI_QUIRK(0x103c, 0x22dc, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
         SND_PCI_QUIRK(0x103c, 0x22fb, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
-        SND_PCI_QUIRK(0x103c, 0x8004, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
         /* ALC290 */
         SND_PCI_QUIRK(0x103c, 0x221b, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
         SND_PCI_QUIRK(0x103c, 0x2221, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
         SND_PCI_QUIRK(0x103c, 0x2225, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
-        SND_PCI_QUIRK(0x103c, 0x2246, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
-        SND_PCI_QUIRK(0x103c, 0x2247, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
-        SND_PCI_QUIRK(0x103c, 0x2248, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
-        SND_PCI_QUIRK(0x103c, 0x2249, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
         SND_PCI_QUIRK(0x103c, 0x2253, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
         SND_PCI_QUIRK(0x103c, 0x2254, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
         SND_PCI_QUIRK(0x103c, 0x2255, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
         SND_PCI_QUIRK(0x103c, 0x2256, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
         SND_PCI_QUIRK(0x103c, 0x2257, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
-        SND_PCI_QUIRK(0x103c, 0x2258, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
         SND_PCI_QUIRK(0x103c, 0x2259, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
         SND_PCI_QUIRK(0x103c, 0x225a, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
         SND_PCI_QUIRK(0x103c, 0x2260, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
@@ -4747,7 +4833,6 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = {
         SND_PCI_QUIRK(0x103c, 0x2265, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
         SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
         SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
-        SND_PCI_QUIRK(0x103c, 0x2277, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
         SND_PCI_QUIRK(0x103c, 0x2278, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
         SND_PCI_QUIRK(0x103c, 0x227f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
         SND_PCI_QUIRK(0x103c, 0x2282, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
@@ -4800,7 +4885,7 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = {
         SND_PCI_QUIRK(0x17aa, 0x220e, "Thinkpad T440p", ALC292_FIXUP_TPT440_DOCK),
         SND_PCI_QUIRK(0x17aa, 0x2210, "Thinkpad T540p", ALC292_FIXUP_TPT440_DOCK),
         SND_PCI_QUIRK(0x17aa, 0x2212, "Thinkpad T440", ALC292_FIXUP_TPT440_DOCK),
-        SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
+        SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad X240", ALC292_FIXUP_TPT440_DOCK),
         SND_PCI_QUIRK(0x17aa, 0x2215, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
         SND_PCI_QUIRK(0x17aa, 0x3978, "IdeaPad Y410P", ALC269_FIXUP_NO_SHUTUP),
         SND_PCI_QUIRK(0x17aa, 0x5013, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
@@ -4980,6 +5065,19 @@ static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = {
                 {0x17, 0x40000000},
                 {0x1d, 0x40700001},
                 {0x21, 0x02211040}),
+        SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC280_FIXUP_HP_GPIO4,
+                {0x12, 0x90a60130},
+                {0x13, 0x40000000},
+                {0x14, 0x90170110},
+                {0x15, 0x0421101f},
+                {0x16, 0x411111f0},
+                {0x17, 0x411111f0},
+                {0x18, 0x411111f0},
+                {0x19, 0x411111f0},
+                {0x1a, 0x04a11020},
+                {0x1b, 0x411111f0},
+                {0x1d, 0x40748605},
+                {0x1e, 0x411111f0}),
         SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED,
                 {0x12, 0x90a60140},
                 {0x13, 0x40000000},
@@ -5190,9 +5288,6 @@ static void alc269_fill_coef(struct hda_codec *codec)
                 }
         }
 
-        /* Class D */
-        alc_update_coef_idx(codec, 0xd, 0, 1<<14);
-
         /* HP */
         alc_update_coef_idx(codec, 0x4, 0, 1<<11);
 }
@@ -5610,9 +5705,9 @@ static void alc662_led_gpio1_mute_hook(void *private_data, int enabled)
         unsigned int oldval = spec->gpio_led;
 
         if (enabled)
-                spec->gpio_led &= ~0x01;
-        else
                 spec->gpio_led |= 0x01;
+        else
+                spec->gpio_led &= ~0x01;
         if (spec->gpio_led != oldval)
                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
                                     spec->gpio_led);
@@ -5647,6 +5742,35 @@ static void alc662_fixup_led_gpio1(struct hda_codec *codec,
         }
 }
 
+static struct coef_fw alc668_coefs[] = {
+        WRITE_COEF(0x01, 0xbebe), WRITE_COEF(0x02, 0xaaaa), WRITE_COEF(0x03,    0x0),
+        WRITE_COEF(0x04, 0x0180), WRITE_COEF(0x06,    0x0), WRITE_COEF(0x07, 0x0f80),
+        WRITE_COEF(0x08, 0x0031), WRITE_COEF(0x0a, 0x0060), WRITE_COEF(0x0b,    0x0),
+        WRITE_COEF(0x0c, 0x7cf7), WRITE_COEF(0x0d, 0x1080), WRITE_COEF(0x0e, 0x7f7f),
+        WRITE_COEF(0x0f, 0xcccc), WRITE_COEF(0x10, 0xddcc), WRITE_COEF(0x11, 0x0001),
+        WRITE_COEF(0x13,    0x0), WRITE_COEF(0x14, 0x2aa0), WRITE_COEF(0x17, 0xa940),
+        WRITE_COEF(0x19,    0x0), WRITE_COEF(0x1a,    0x0), WRITE_COEF(0x1b,    0x0),
+        WRITE_COEF(0x1c,    0x0), WRITE_COEF(0x1d,    0x0), WRITE_COEF(0x1e, 0x7418),
+        WRITE_COEF(0x1f, 0x0804), WRITE_COEF(0x20, 0x4200), WRITE_COEF(0x21, 0x0468),
+        WRITE_COEF(0x22, 0x8ccc), WRITE_COEF(0x23, 0x0250), WRITE_COEF(0x24, 0x7418),
+        WRITE_COEF(0x27,    0x0), WRITE_COEF(0x28, 0x8ccc), WRITE_COEF(0x2a, 0xff00),
+        WRITE_COEF(0x2b, 0x8000), WRITE_COEF(0xa7, 0xff00), WRITE_COEF(0xa8, 0x8000),
+        WRITE_COEF(0xaa, 0x2e17), WRITE_COEF(0xab, 0xa0c0), WRITE_COEF(0xac,    0x0),
+        WRITE_COEF(0xad,    0x0), WRITE_COEF(0xae, 0x2ac6), WRITE_COEF(0xaf, 0xa480),
+        WRITE_COEF(0xb0,    0x0), WRITE_COEF(0xb1,    0x0), WRITE_COEF(0xb2,    0x0),
+        WRITE_COEF(0xb3,    0x0), WRITE_COEF(0xb4,    0x0), WRITE_COEF(0xb5, 0x1040),
+        WRITE_COEF(0xb6, 0xd697), WRITE_COEF(0xb7, 0x902b), WRITE_COEF(0xb8, 0xd697),
+        WRITE_COEF(0xb9, 0x902b), WRITE_COEF(0xba, 0xb8ba), WRITE_COEF(0xbb, 0xaaab),
+        WRITE_COEF(0xbc, 0xaaaf), WRITE_COEF(0xbd, 0x6aaa), WRITE_COEF(0xbe, 0x1c02),
+        WRITE_COEF(0xc0, 0x00ff), WRITE_COEF(0xc1, 0x0fa6),
+        {}
+};
+
+static void alc668_restore_default_value(struct hda_codec *codec)
+{
+        alc_process_coef_fw(codec, alc668_coefs);
+}
+
 enum {
         ALC662_FIXUP_ASPIRE,
         ALC662_FIXUP_LED_GPIO1,
@@ -5919,6 +6043,7 @@ static const struct snd_pci_quirk alc662_fixup_tbl[] = {
         SND_PCI_QUIRK(0x1028, 0x0626, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x1028, 0x0696, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x1028, 0x0698, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
+        SND_PCI_QUIRK(0x1028, 0x069f, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
         SND_PCI_QUIRK(0x1043, 0x11cd, "Asus N550", ALC662_FIXUP_BASS_1A),
         SND_PCI_QUIRK(0x1043, 0x1477, "ASUS N56VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
@@ -6072,29 +6197,6 @@ static const struct snd_hda_pin_quirk alc662_pin_fixup_tbl[] = {
         {}
 };
 
-static void alc662_fill_coef(struct hda_codec *codec)
-{
-        int coef;
-
-        coef = alc_get_coef0(codec);
-
-        switch (codec->vendor_id) {
-        case 0x10ec0662:
-                if ((coef & 0x00f0) == 0x0030)
-                        alc_update_coef_idx(codec, 0x4, 1<<10, 0); /* EAPD Ctrl */
-                break;
-        case 0x10ec0272:
-        case 0x10ec0273:
-        case 0x10ec0663:
-        case 0x10ec0665:
-        case 0x10ec0670:
-        case 0x10ec0671:
-        case 0x10ec0672:
-                alc_update_coef_idx(codec, 0xd, 0, 1<<14); /* EAPD Ctrl */
-                break;
-        }
-}
-
 /*
  */
 static int patch_alc662(struct hda_codec *codec)
@@ -6113,8 +6215,11 @@ static int patch_alc662(struct hda_codec *codec)
 
         alc_fix_pll_init(codec, 0x20, 0x04, 15);
 
-        spec->init_hook = alc662_fill_coef;
-        alc662_fill_coef(codec);
+        switch (codec->vendor_id) {
+        case 0x10ec0668:
+                spec->init_hook = alc668_restore_default_value;
+                break;
+        }
 
         snd_hda_pick_fixup(codec, alc662_fixup_models,
                        alc662_fixup_tbl, alc662_fixups);
diff --git a/sound/soc/Kconfig b/sound/soc/Kconfig
index 0e9623368ab0..7d5d6444a837 100644
--- a/sound/soc/Kconfig
+++ b/sound/soc/Kconfig
@@ -49,7 +49,6 @@ source "sound/soc/mxs/Kconfig"
 source "sound/soc/pxa/Kconfig"
 source "sound/soc/rockchip/Kconfig"
 source "sound/soc/samsung/Kconfig"
-source "sound/soc/s6000/Kconfig"
 source "sound/soc/sh/Kconfig"
 source "sound/soc/sirf/Kconfig"
 source "sound/soc/spear/Kconfig"
diff --git a/sound/soc/Makefile b/sound/soc/Makefile
index 0fded1bb613f..865e090c8061 100644
--- a/sound/soc/Makefile
+++ b/sound/soc/Makefile
@@ -1,5 +1,5 @@
 snd-soc-core-objs := soc-core.o soc-dapm.o soc-jack.o soc-cache.o soc-utils.o
-snd-soc-core-objs += soc-pcm.o soc-compress.o soc-io.o soc-devres.o
+snd-soc-core-objs += soc-pcm.o soc-compress.o soc-io.o soc-devres.o soc-ops.o
 
 ifneq ($(CONFIG_SND_SOC_GENERIC_DMAENGINE_PCM),)
 snd-soc-core-objs += soc-generic-dmaengine-pcm.o
@@ -30,7 +30,6 @@ obj-$(CONFIG_SND_SOC)	+= kirkwood/
 obj-$(CONFIG_SND_SOC)   += pxa/
 obj-$(CONFIG_SND_SOC)   += rockchip/
 obj-$(CONFIG_SND_SOC)   += samsung/
-obj-$(CONFIG_SND_SOC)   += s6000/
 obj-$(CONFIG_SND_SOC)   += sh/
 obj-$(CONFIG_SND_SOC)   += sirf/
 obj-$(CONFIG_SND_SOC)   += spear/
diff --git a/sound/soc/codecs/ad193x.c b/sound/soc/codecs/ad193x.c
index 6844d0b2af68..387530b0b0fd 100644
--- a/sound/soc/codecs/ad193x.c
+++ b/sound/soc/codecs/ad193x.c
@@ -72,11 +72,13 @@ static const struct snd_kcontrol_new ad193x_snd_controls[] = {
 };
 
 static const struct snd_soc_dapm_widget ad193x_dapm_widgets[] = {
-        SND_SOC_DAPM_DAC("DAC", "Playback", AD193X_DAC_CTRL0, 0, 1),
+        SND_SOC_DAPM_DAC("DAC", "Playback", SND_SOC_NOPM, 0, 0),
+        SND_SOC_DAPM_PGA("DAC Output", AD193X_DAC_CTRL0, 0, 1, NULL, 0),
         SND_SOC_DAPM_ADC("ADC", "Capture", SND_SOC_NOPM, 0, 0),
         SND_SOC_DAPM_SUPPLY("PLL_PWR", AD193X_PLL_CLK_CTRL0, 0, 1, NULL, 0),
         SND_SOC_DAPM_SUPPLY("ADC_PWR", AD193X_ADC_CTRL0, 0, 1, NULL, 0),
         SND_SOC_DAPM_SUPPLY("SYSCLK", AD193X_PLL_CLK_CTRL0, 7, 0, NULL, 0),
+        SND_SOC_DAPM_VMID("VMID"),
         SND_SOC_DAPM_OUTPUT("DAC1OUT"),
         SND_SOC_DAPM_OUTPUT("DAC2OUT"),
         SND_SOC_DAPM_OUTPUT("DAC3OUT"),
@@ -87,13 +89,15 @@ static const struct snd_soc_dapm_widget ad193x_dapm_widgets[] = {
 
 static const struct snd_soc_dapm_route audio_paths[] = {
         { "DAC", NULL, "SYSCLK" },
+        { "DAC Output", NULL, "DAC" },
+        { "DAC Output", NULL, "VMID" },
         { "ADC", NULL, "SYSCLK" },
         { "DAC", NULL, "ADC_PWR" },
         { "ADC", NULL, "ADC_PWR" },
-        { "DAC1OUT", NULL, "DAC" },
-        { "DAC2OUT", NULL, "DAC" },
-        { "DAC3OUT", NULL, "DAC" },
-        { "DAC4OUT", NULL, "DAC" },
+        { "DAC1OUT", NULL, "DAC Output" },
+        { "DAC2OUT", NULL, "DAC Output" },
+        { "DAC3OUT", NULL, "DAC Output" },
+        { "DAC4OUT", NULL, "DAC Output" },
         { "ADC", NULL, "ADC1IN" },
         { "ADC", NULL, "ADC2IN" },
         { "SYSCLK", NULL, "PLL_PWR" },
diff --git a/sound/soc/codecs/adau1373.c b/sound/soc/codecs/adau1373.c
index 7c784ad3e8b2..783dcb57043a 100644
--- a/sound/soc/codecs/adau1373.c
+++ b/sound/soc/codecs/adau1373.c
@@ -551,7 +551,7 @@ static const struct snd_kcontrol_new adau1373_drc_controls[] = {
 static int adau1373_pll_event(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct adau1373 *adau1373 = snd_soc_codec_get_drvdata(codec);
         unsigned int pll_id = w->name[3] - '1';
         unsigned int val;
@@ -823,7 +823,7 @@ static const struct snd_soc_dapm_widget adau1373_dapm_widgets[] = {
 static int adau1373_check_aif_clk(struct snd_soc_dapm_widget *source,
         struct snd_soc_dapm_widget *sink)
 {
-        struct snd_soc_codec *codec = source->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(source->dapm);
         struct adau1373 *adau1373 = snd_soc_codec_get_drvdata(codec);
         unsigned int dai;
         const char *clk;
@@ -844,7 +844,7 @@ static int adau1373_check_aif_clk(struct snd_soc_dapm_widget *source,
 static int adau1373_check_src(struct snd_soc_dapm_widget *source,
         struct snd_soc_dapm_widget *sink)
 {
-        struct snd_soc_codec *codec = source->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(source->dapm);
         struct adau1373 *adau1373 = snd_soc_codec_get_drvdata(codec);
         unsigned int dai;
 
diff --git a/sound/soc/codecs/adau1761.c b/sound/soc/codecs/adau1761.c
index 5518ebd6947c..16093dc89441 100644
--- a/sound/soc/codecs/adau1761.c
+++ b/sound/soc/codecs/adau1761.c
@@ -255,7 +255,8 @@ static const struct snd_kcontrol_new adau1761_input_mux_control =
 static int adau1761_dejitter_fixup(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
-        struct adau *adau = snd_soc_codec_get_drvdata(w->codec);
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
+        struct adau *adau = snd_soc_codec_get_drvdata(codec);
 
         /* After any power changes have been made the dejitter circuit
          * has to be reinitialized. */
@@ -405,6 +406,7 @@ static const struct snd_soc_dapm_widget adau1761_dapm_widgets[] = {
                 2, 0, NULL, 0),
 
         SND_SOC_DAPM_SUPPLY("Slew Clock", ADAU1761_CLK_ENABLE0, 6, 0, NULL, 0),
+        SND_SOC_DAPM_SUPPLY("ALC Clock", ADAU1761_CLK_ENABLE0, 5, 0, NULL, 0),
 
         SND_SOC_DAPM_SUPPLY_S("Digital Clock 0", 1, ADAU1761_CLK_ENABLE1,
                 0, 0, NULL, 0),
@@ -436,6 +438,9 @@ static const struct snd_soc_dapm_route adau1761_dapm_routes[] = {
         { "Right Playback Mixer", NULL, "Slew Clock" },
         { "Left Playback Mixer", NULL, "Slew Clock" },
 
+        { "Left Input Mixer", NULL, "ALC Clock" },
+        { "Right Input Mixer", NULL, "ALC Clock" },
+
         { "Digital Clock 0", NULL, "SYSCLK" },
         { "Digital Clock 1", NULL, "SYSCLK" },
 };
diff --git a/sound/soc/codecs/adau1781.c b/sound/soc/codecs/adau1781.c
index e9fc00fb13dd..aa6a37cc44b7 100644
--- a/sound/soc/codecs/adau1781.c
+++ b/sound/soc/codecs/adau1781.c
@@ -174,7 +174,7 @@ static const struct snd_kcontrol_new adau1781_mono_mixer_controls[] = {
 static int adau1781_dejitter_fixup(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct adau *adau = snd_soc_codec_get_drvdata(codec);
 
         /* After any power changes have been made the dejitter circuit
diff --git a/sound/soc/codecs/adau17x1.c b/sound/soc/codecs/adau17x1.c
index 3e16c1c64115..427ad77bfe56 100644
--- a/sound/soc/codecs/adau17x1.c
+++ b/sound/soc/codecs/adau17x1.c
@@ -61,7 +61,8 @@ static const struct snd_kcontrol_new adau17x1_controls[] = {
 static int adau17x1_pll_event(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
-        struct adau *adau = snd_soc_codec_get_drvdata(w->codec);
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
+        struct adau *adau = snd_soc_codec_get_drvdata(codec);
         int ret;
 
         if (SND_SOC_DAPM_EVENT_ON(event)) {
diff --git a/sound/soc/codecs/cs42l51-i2c.c b/sound/soc/codecs/cs42l51-i2c.c
index cee51ae177c1..c40428f25ba5 100644
--- a/sound/soc/codecs/cs42l51-i2c.c
+++ b/sound/soc/codecs/cs42l51-i2c.c
@@ -46,6 +46,7 @@ static struct i2c_driver cs42l51_i2c_driver = {
         .driver = {
                 .name = "cs42l51",
                 .owner = THIS_MODULE,
+                .of_match_table = cs42l51_of_match,
         },
         .probe = cs42l51_i2c_probe,
         .remove = cs42l51_i2c_remove,
diff --git a/sound/soc/codecs/cs42l51.c b/sound/soc/codecs/cs42l51.c
index 09488d97de60..669c38fc3034 100644
--- a/sound/soc/codecs/cs42l51.c
+++ b/sound/soc/codecs/cs42l51.c
@@ -558,11 +558,13 @@ error:
 }
 EXPORT_SYMBOL_GPL(cs42l51_probe);
 
-static const struct of_device_id cs42l51_of_match[] = {
+const struct of_device_id cs42l51_of_match[] = {
         { .compatible = "cirrus,cs42l51", },
         { }
 };
 MODULE_DEVICE_TABLE(of, cs42l51_of_match);
+EXPORT_SYMBOL_GPL(cs42l51_of_match);
+
 MODULE_AUTHOR("Arnaud Patard <arnaud.patard@rtp-net.org>");
 MODULE_DESCRIPTION("Cirrus Logic CS42L51 ALSA SoC Codec Driver");
 MODULE_LICENSE("GPL");
diff --git a/sound/soc/codecs/cs42l51.h b/sound/soc/codecs/cs42l51.h
index 8c55bf384bc6..0ca805492ac4 100644
--- a/sound/soc/codecs/cs42l51.h
+++ b/sound/soc/codecs/cs42l51.h
@@ -22,6 +22,7 @@ struct device;
 
 extern const struct regmap_config cs42l51_regmap;
 int cs42l51_probe(struct device *dev, struct regmap *regmap);
+extern const struct of_device_id cs42l51_of_match[];
 
 #define CS42L51_CHIP_ID                 0x1B
 #define CS42L51_CHIP_REV_A              0x00
diff --git a/sound/soc/codecs/es8328-i2c.c b/sound/soc/codecs/es8328-i2c.c
index aae410d122ee..2d05b5d3a6ce 100644
--- a/sound/soc/codecs/es8328-i2c.c
+++ b/sound/soc/codecs/es8328-i2c.c
@@ -19,7 +19,7 @@
 #include "es8328.h"
 
 static const struct i2c_device_id es8328_id[] = {
-        { "everest,es8328", 0 },
+        { "es8328", 0 },
         { }
 };
 MODULE_DEVICE_TABLE(i2c, es8328_id);
diff --git a/sound/soc/codecs/max98090.c b/sound/soc/codecs/max98090.c
index d519294f57c7..34ed9a91f392 100644
--- a/sound/soc/codecs/max98090.c
+++ b/sound/soc/codecs/max98090.c
@@ -1311,6 +1311,10 @@ static const struct snd_soc_dapm_route max98090_dapm_routes[] = {
         {"MIC1 Input", NULL, "MIC1"},
         {"MIC2 Input", NULL, "MIC2"},
 
+        {"DMICL", NULL, "DMICL_ENA"},
+        {"DMICL", NULL, "DMICR_ENA"},
+        {"DMICR", NULL, "DMICL_ENA"},
+        {"DMICR", NULL, "DMICR_ENA"},
         {"DMICL", NULL, "AHPF"},
         {"DMICR", NULL, "AHPF"},
 
@@ -1368,8 +1372,6 @@ static const struct snd_soc_dapm_route max98090_dapm_routes[] = {
         {"DMIC Mux", "ADC", "ADCR"},
         {"DMIC Mux", "DMIC", "DMICL"},
         {"DMIC Mux", "DMIC", "DMICR"},
-        {"DMIC Mux", "DMIC", "DMICL_ENA"},
-        {"DMIC Mux", "DMIC", "DMICR_ENA"},
 
         {"LBENL Mux", "Normal", "DMIC Mux"},
         {"LBENL Mux", "Loopback", "LTENL Mux"},
@@ -1395,8 +1397,8 @@ static const struct snd_soc_dapm_route max98090_dapm_routes[] = {
         {"STENL Mux", "Sidetone Left", "DMICL"},
         {"STENR Mux", "Sidetone Right", "ADCR"},
         {"STENR Mux", "Sidetone Right", "DMICR"},
-        {"DACL", "NULL", "STENL Mux"},
-        {"DACR", "NULL", "STENL Mux"},
+        {"DACL", NULL, "STENL Mux"},
+        {"DACR", NULL, "STENR Mux"},
 
         {"AIFINL", NULL, "SHDN"},
         {"AIFINR", NULL, "SHDN"},
@@ -1941,13 +1943,13 @@ static int max98090_dai_set_sysclk(struct snd_soc_dai *dai,
          *               0x02 (when master clk is 20MHz to 40MHz)..
          *               0x03 (when master clk is 40MHz to 60MHz)..
          */
-        if ((freq >= 10000000) && (freq < 20000000)) {
+        if ((freq >= 10000000) && (freq <= 20000000)) {
                 snd_soc_write(codec, M98090_REG_SYSTEM_CLOCK,
                         M98090_PSCLK_DIV1);
-        } else if ((freq >= 20000000) && (freq < 40000000)) {
+        } else if ((freq > 20000000) && (freq <= 40000000)) {
                 snd_soc_write(codec, M98090_REG_SYSTEM_CLOCK,
                         M98090_PSCLK_DIV2);
-        } else if ((freq >= 40000000) && (freq < 60000000)) {
+        } else if ((freq > 40000000) && (freq <= 60000000)) {
                 snd_soc_write(codec, M98090_REG_SYSTEM_CLOCK,
                         M98090_PSCLK_DIV4);
         } else {
diff --git a/sound/soc/codecs/rt5645.c b/sound/soc/codecs/rt5645.c
index 3fb83bf09768..d16331e0b64d 100644
--- a/sound/soc/codecs/rt5645.c
+++ b/sound/soc/codecs/rt5645.c
@@ -139,6 +139,7 @@ static const struct reg_default rt5645_reg[] = {
         { 0x76, 0x000a },
         { 0x77, 0x0c00 },
         { 0x78, 0x0000 },
+        { 0x79, 0x0123 },
         { 0x80, 0x0000 },
         { 0x81, 0x0000 },
         { 0x82, 0x0000 },
@@ -334,6 +335,7 @@ static bool rt5645_readable_register(struct device *dev, unsigned int reg)
         case RT5645_DMIC_CTRL2:
         case RT5645_TDM_CTRL_1:
         case RT5645_TDM_CTRL_2:
+        case RT5645_TDM_CTRL_3:
         case RT5645_GLB_CLK:
         case RT5645_PLL_CTRL1:
         case RT5645_PLL_CTRL2:
diff --git a/sound/soc/codecs/rt5670.c b/sound/soc/codecs/rt5670.c
index ba9d9b4d4857..9bd8b4f63303 100644
--- a/sound/soc/codecs/rt5670.c
+++ b/sound/soc/codecs/rt5670.c
@@ -100,18 +100,18 @@ static const struct reg_default rt5670_reg[] = {
         { 0x4c, 0x5380 },
         { 0x4f, 0x0073 },
         { 0x52, 0x00d3 },
-        { 0x53, 0xf0f0 },
+        { 0x53, 0xf000 },
         { 0x61, 0x0000 },
         { 0x62, 0x0001 },
         { 0x63, 0x00c3 },
         { 0x64, 0x0000 },
-        { 0x65, 0x0000 },
+        { 0x65, 0x0001 },
         { 0x66, 0x0000 },
         { 0x6f, 0x8000 },
         { 0x70, 0x8000 },
         { 0x71, 0x8000 },
         { 0x72, 0x8000 },
-        { 0x73, 0x1110 },
+        { 0x73, 0x7770 },
         { 0x74, 0x0e00 },
         { 0x75, 0x1505 },
         { 0x76, 0x0015 },
@@ -125,21 +125,21 @@ static const struct reg_default rt5670_reg[] = {
         { 0x83, 0x0000 },
         { 0x84, 0x0000 },
         { 0x85, 0x0000 },
-        { 0x86, 0x0008 },
+        { 0x86, 0x0004 },
         { 0x87, 0x0000 },
         { 0x88, 0x0000 },
         { 0x89, 0x0000 },
         { 0x8a, 0x0000 },
         { 0x8b, 0x0000 },
-        { 0x8c, 0x0007 },
+        { 0x8c, 0x0003 },
         { 0x8d, 0x0000 },
         { 0x8e, 0x0004 },
         { 0x8f, 0x1100 },
         { 0x90, 0x0646 },
         { 0x91, 0x0c06 },
         { 0x93, 0x0000 },
-        { 0x94, 0x0000 },
-        { 0x95, 0x0000 },
+        { 0x94, 0x1270 },
+        { 0x95, 0x1000 },
         { 0x97, 0x0000 },
         { 0x98, 0x0000 },
         { 0x99, 0x0000 },
@@ -150,11 +150,11 @@ static const struct reg_default rt5670_reg[] = {
         { 0x9e, 0x0400 },
         { 0xae, 0x7000 },
         { 0xaf, 0x0000 },
-        { 0xb0, 0x6000 },
+        { 0xb0, 0x7000 },
         { 0xb1, 0x0000 },
         { 0xb2, 0x0000 },
         { 0xb3, 0x001f },
-        { 0xb4, 0x2206 },
+        { 0xb4, 0x220c },
         { 0xb5, 0x1f00 },
         { 0xb6, 0x0000 },
         { 0xb7, 0x0000 },
@@ -171,25 +171,25 @@ static const struct reg_default rt5670_reg[] = {
         { 0xcf, 0x1813 },
         { 0xd0, 0x0690 },
         { 0xd1, 0x1c17 },
-        { 0xd3, 0xb320 },
+        { 0xd3, 0xa220 },
         { 0xd4, 0x0000 },
         { 0xd6, 0x0400 },
         { 0xd9, 0x0809 },
         { 0xda, 0x0000 },
         { 0xdb, 0x0001 },
         { 0xdc, 0x0049 },
-        { 0xdd, 0x0009 },
+        { 0xdd, 0x0024 },
         { 0xe6, 0x8000 },
         { 0xe7, 0x0000 },
-        { 0xec, 0xb300 },
+        { 0xec, 0xa200 },
         { 0xed, 0x0000 },
-        { 0xee, 0xb300 },
+        { 0xee, 0xa200 },
         { 0xef, 0x0000 },
         { 0xf8, 0x0000 },
         { 0xf9, 0x0000 },
         { 0xfa, 0x8010 },
         { 0xfb, 0x0033 },
-        { 0xfc, 0x0080 },
+        { 0xfc, 0x0100 },
 };
 
 static bool rt5670_volatile_register(struct device *dev, unsigned int reg)
@@ -1877,6 +1877,10 @@ static const struct snd_soc_dapm_route rt5670_dapm_routes[] = {
         { "DAC1 MIXR", "DAC1 Switch", "DAC1 R Mux" },
         { "DAC1 MIXR", NULL, "DAC Stereo1 Filter" },
 
+        { "DAC Stereo1 Filter", NULL, "PLL1", is_sys_clk_from_pll },
+        { "DAC Mono Left Filter", NULL, "PLL1", is_sys_clk_from_pll },
+        { "DAC Mono Right Filter", NULL, "PLL1", is_sys_clk_from_pll },
+
         { "DAC MIX", NULL, "DAC1 MIXL" },
         { "DAC MIX", NULL, "DAC1 MIXR" },
 
@@ -1926,14 +1930,10 @@ static const struct snd_soc_dapm_route rt5670_dapm_routes[] = {
 
         { "DAC L1", NULL, "DAC L1 Power" },
         { "DAC L1", NULL, "Stereo DAC MIXL" },
-        { "DAC L1", NULL, "PLL1", is_sys_clk_from_pll },
         { "DAC R1", NULL, "DAC R1 Power" },
         { "DAC R1", NULL, "Stereo DAC MIXR" },
-        { "DAC R1", NULL, "PLL1", is_sys_clk_from_pll },
         { "DAC L2", NULL, "Mono DAC MIXL" },
-        { "DAC L2", NULL, "PLL1", is_sys_clk_from_pll },
         { "DAC R2", NULL, "Mono DAC MIXR" },
-        { "DAC R2", NULL, "PLL1", is_sys_clk_from_pll },
 
         { "OUT MIXL", "BST1 Switch", "BST1" },
         { "OUT MIXL", "INL Switch", "INL VOL" },
diff --git a/sound/soc/codecs/sgtl5000.c b/sound/soc/codecs/sgtl5000.c
index 6bb77d76561b..dab9b15304af 100644
--- a/sound/soc/codecs/sgtl5000.c
+++ b/sound/soc/codecs/sgtl5000.c
@@ -1299,8 +1299,7 @@ static int sgtl5000_probe(struct snd_soc_codec *codec)
 
         /* enable small pop, introduce 400ms delay in turning off */
         snd_soc_update_bits(codec, SGTL5000_CHIP_REF_CTRL,
-                                SGTL5000_SMALL_POP,
-                                SGTL5000_SMALL_POP);
+                                SGTL5000_SMALL_POP, 1);
 
         /* disable short cut detector */
         snd_soc_write(codec, SGTL5000_CHIP_SHORT_CTRL, 0);
diff --git a/sound/soc/codecs/sgtl5000.h b/sound/soc/codecs/sgtl5000.h
index 2f8c88931f69..bd7a344bf8c5 100644
--- a/sound/soc/codecs/sgtl5000.h
+++ b/sound/soc/codecs/sgtl5000.h
@@ -275,7 +275,7 @@
 #define SGTL5000_BIAS_CTRL_MASK                 0x000e
 #define SGTL5000_BIAS_CTRL_SHIFT                1
 #define SGTL5000_BIAS_CTRL_WIDTH                3
-#define SGTL5000_SMALL_POP                      0x0001
+#define SGTL5000_SMALL_POP                      0
 
 /*
  * SGTL5000_CHIP_MIC_CTRL
diff --git a/sound/soc/codecs/sigmadsp.c b/sound/soc/codecs/sigmadsp.c
index f2de7e049bc6..81a38dd9af1f 100644
--- a/sound/soc/codecs/sigmadsp.c
+++ b/sound/soc/codecs/sigmadsp.c
@@ -159,6 +159,13 @@ int _process_sigma_firmware(struct device *dev,
                 goto done;
         }
 
+        if (ssfw_head->version != 1) {
+                dev_err(dev,
+                        "Failed to load firmware: Invalid version %d. Supported firmware versions: 1\n",
+                        ssfw_head->version);
+                goto done;
+        }
+
         crc = crc32(0, fw->data + sizeof(*ssfw_head),
                         fw->size - sizeof(*ssfw_head));
         pr_debug("%s: crc=%x\n", __func__, crc);
diff --git a/sound/soc/codecs/tlv320aic31xx.c b/sound/soc/codecs/tlv320aic31xx.c
index 145fe5b253d4..93de5dd0a7b9 100644
--- a/sound/soc/codecs/tlv320aic31xx.c
+++ b/sound/soc/codecs/tlv320aic31xx.c
@@ -911,12 +911,13 @@ static int aic31xx_set_dai_sysclk(struct snd_soc_dai *codec_dai,
         }
         aic31xx->p_div = i;
 
-        for (i = 0; aic31xx_divs[i].mclk_p != freq/aic31xx->p_div; i++) {
-                if (i == ARRAY_SIZE(aic31xx_divs)) {
-                        dev_err(aic31xx->dev, "%s: Unsupported frequency %d\n",
-                                __func__, freq);
-                        return -EINVAL;
-                }
+        for (i = 0; i < ARRAY_SIZE(aic31xx_divs) &&
+                     aic31xx_divs[i].mclk_p != freq/aic31xx->p_div; i++)
+                ;
+        if (i == ARRAY_SIZE(aic31xx_divs)) {
+                dev_err(aic31xx->dev, "%s: Unsupported frequency %d\n",
+                        __func__, freq);
+                return -EINVAL;
         }
 
         /* set clock on MCLK, BCLK, or GPIO1 as PLL input */
diff --git a/sound/soc/codecs/wm_adsp.c b/sound/soc/codecs/wm_adsp.c
index f412a9911a75..cce9020933c6 100644
--- a/sound/soc/codecs/wm_adsp.c
+++ b/sound/soc/codecs/wm_adsp.c
@@ -1355,6 +1355,7 @@ static int wm_adsp_load_coeff(struct wm_adsp *dsp)
                           file, blocks, pos - firmware->size);
 
 out_fw:
+        regmap_async_complete(regmap);
         release_firmware(firmware);
         wm_adsp_buf_free(&buf_list);
 out:
@@ -1594,13 +1595,6 @@ static void wm_adsp2_boot_work(struct work_struct *work)
         if (ret != 0)
                 goto err;
 
-        ret = regmap_update_bits_async(dsp->regmap,
-                                       dsp->base + ADSP2_CONTROL,
-                                       ADSP2_CORE_ENA,
-                                       ADSP2_CORE_ENA);
-        if (ret != 0)
-                goto err;
-
         dsp->running = true;
 
         return;
@@ -1650,8 +1644,8 @@ int wm_adsp2_event(struct snd_soc_dapm_widget *w,
 
                 ret = regmap_update_bits(dsp->regmap,
                                          dsp->base + ADSP2_CONTROL,
-                                         ADSP2_START,
-                                         ADSP2_START);
+                                         ADSP2_CORE_ENA | ADSP2_START,
+                                         ADSP2_CORE_ENA | ADSP2_START);
                 if (ret != 0)
                         goto err;
                 break;
diff --git a/sound/soc/davinci/davinci-mcasp.c b/sound/soc/davinci/davinci-mcasp.c
index 0eed9b1b24e1..ea3ad747d092 100644
--- a/sound/soc/davinci/davinci-mcasp.c
+++ b/sound/soc/davinci/davinci-mcasp.c
@@ -154,9 +154,9 @@ static bool mcasp_is_synchronous(struct davinci_mcasp *mcasp)
 
 static void mcasp_start_rx(struct davinci_mcasp *mcasp)
 {
+        /* Start clocks */
         mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLR_REG, RXHCLKRST);
         mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLR_REG, RXCLKRST);
-
         /*
          * When ASYNC == 0 the transmit and receive sections operate
          * synchronously from the transmit clock and frame sync. We need to make
@@ -167,47 +167,36 @@ static void mcasp_start_rx(struct davinci_mcasp *mcasp)
                 mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, TXCLKRST);
         }
 
+        /* Activate serializer(s) */
         mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLR_REG, RXSERCLR);
-        mcasp_set_reg(mcasp, DAVINCI_MCASP_RXBUF_REG, 0);
-
-        mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLR_REG, RXSMRST);
-        mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLR_REG, RXFSRST);
-        mcasp_set_reg(mcasp, DAVINCI_MCASP_RXBUF_REG, 0);
-
+        /* Release RX state machine */
         mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLR_REG, RXSMRST);
+        /* Release Frame Sync generator */
         mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLR_REG, RXFSRST);
-
         if (mcasp_is_synchronous(mcasp))
                 mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, TXFSRST);
 }
 
 static void mcasp_start_tx(struct davinci_mcasp *mcasp)
 {
-        u8 offset = 0, i;
         u32 cnt;
 
+        /* Start clocks */
         mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, TXHCLKRST);
         mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, TXCLKRST);
+        /* Activate serializer(s) */
         mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, TXSERCLR);
-        mcasp_set_reg(mcasp, DAVINCI_MCASP_TXBUF_REG, 0);
 
-        mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, TXSMRST);
-        mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, TXFSRST);
-        mcasp_set_reg(mcasp, DAVINCI_MCASP_TXBUF_REG, 0);
-        for (i = 0; i < mcasp->num_serializer; i++) {
-                if (mcasp->serial_dir[i] == TX_MODE) {
-                        offset = i;
-                        break;
-                }
-        }
-
-        /* wait for TX ready */
+        /* wait for XDATA to be cleared */
         cnt = 0;
-        while (!(mcasp_get_reg(mcasp, DAVINCI_MCASP_XRSRCTL_REG(offset)) &
-                 TXSTATE) && (cnt < 100000))
+        while (!(mcasp_get_reg(mcasp, DAVINCI_MCASP_TXSTAT_REG) &
+                 ~XRDATA) && (cnt < 100000))
                 cnt++;
 
-        mcasp_set_reg(mcasp, DAVINCI_MCASP_TXBUF_REG, 0);
+        /* Release TX state machine */
+        mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, TXSMRST);
+        /* Release Frame Sync generator */
+        mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, TXFSRST);
 }
 
 static void davinci_mcasp_start(struct davinci_mcasp *mcasp, int stream)
@@ -244,6 +233,12 @@ static void mcasp_stop_rx(struct davinci_mcasp *mcasp)
 
         mcasp_set_reg(mcasp, DAVINCI_MCASP_GBLCTLR_REG, 0);
         mcasp_set_reg(mcasp, DAVINCI_MCASP_RXSTAT_REG, 0xFFFFFFFF);
+
+        if (mcasp->rxnumevt) {  /* disable FIFO */
+                u32 reg = mcasp->fifo_base + MCASP_RFIFOCTL_OFFSET;
+
+                mcasp_clr_bits(mcasp, reg, FIFO_ENABLE);
+        }
 }
 
 static void mcasp_stop_tx(struct davinci_mcasp *mcasp)
@@ -259,27 +254,22 @@ static void mcasp_stop_tx(struct davinci_mcasp *mcasp)
 
         mcasp_set_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, val);
         mcasp_set_reg(mcasp, DAVINCI_MCASP_TXSTAT_REG, 0xFFFFFFFF);
+
+        if (mcasp->txnumevt) {  /* disable FIFO */
+                u32 reg = mcasp->fifo_base + MCASP_WFIFOCTL_OFFSET;
+
+                mcasp_clr_bits(mcasp, reg, FIFO_ENABLE);
+        }
 }
 
 static void davinci_mcasp_stop(struct davinci_mcasp *mcasp, int stream)
 {
-        u32 reg;
-
         mcasp->streams--;
 
-        if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
-                if (mcasp->txnumevt) {  /* disable FIFO */
-                        reg = mcasp->fifo_base + MCASP_WFIFOCTL_OFFSET;
-                        mcasp_clr_bits(mcasp, reg, FIFO_ENABLE);
-                }
+        if (stream == SNDRV_PCM_STREAM_PLAYBACK)
                 mcasp_stop_tx(mcasp);
-        } else {
-                if (mcasp->rxnumevt) {  /* disable FIFO */
-                        reg = mcasp->fifo_base + MCASP_RFIFOCTL_OFFSET;
-                        mcasp_clr_bits(mcasp, reg, FIFO_ENABLE);
-                }
+        else
                 mcasp_stop_rx(mcasp);
-        }
 }
 
 static int davinci_mcasp_set_dai_fmt(struct snd_soc_dai *cpu_dai,
@@ -500,8 +490,17 @@ static int davinci_config_channel_size(struct davinci_mcasp *mcasp,
          * both left and right channels), so it has to be divided by number of
          * tdm-slots (for I2S - divided by 2).
          */
-        if (mcasp->bclk_lrclk_ratio)
-                word_length = mcasp->bclk_lrclk_ratio / mcasp->tdm_slots;
+        if (mcasp->bclk_lrclk_ratio) {
+                u32 slot_length = mcasp->bclk_lrclk_ratio / mcasp->tdm_slots;
+
+                /*
+                 * When we have more bclk then it is needed for the data, we
+                 * need to use the rotation to move the received samples to have
+                 * correct alignment.
+                 */
+                rx_rotate = (slot_length - word_length) / 4;
+                word_length = slot_length;
+        }
 
         /* mapping of the XSSZ bit-field as described in the datasheet */
         fmt = (word_length >> 1) - 1;
@@ -971,6 +970,7 @@ static struct snd_soc_dai_driver davinci_mcasp_dai[] = {
                 },
                 .ops            = &davinci_mcasp_dai_ops,
 
+                .symmetric_samplebits   = 1,
         },
         {
                 .name           = "davinci-mcasp.1",
@@ -1235,6 +1235,7 @@ static int davinci_mcasp_probe(struct platform_device *pdev)
         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;
         }
 
diff --git a/sound/soc/davinci/davinci-mcasp.h b/sound/soc/davinci/davinci-mcasp.h
index 98fbc451892a..9737108f0305 100644
--- a/sound/soc/davinci/davinci-mcasp.h
+++ b/sound/soc/davinci/davinci-mcasp.h
@@ -253,6 +253,12 @@
 #define TXFSRST         BIT(12) /* Frame Sync Generator Reset */
 
 /*
+ * DAVINCI_MCASP_TXSTAT_REG - Transmitter Status Register Bits
+ * DAVINCI_MCASP_RXSTAT_REG - Receiver Status Register Bits
+ */
+#define XRDATA          BIT(5) /* Transmit/Receive data ready */
+
+/*
  * DAVINCI_MCASP_AMUTE_REG -  Mute Control Register Bits
  */
 #define MUTENA(val)     (val)
diff --git a/sound/soc/fsl/fsl_asrc.c b/sound/soc/fsl/fsl_asrc.c
index 3b145313f93e..9deabdd2b1a2 100644
--- a/sound/soc/fsl/fsl_asrc.c
+++ b/sound/soc/fsl/fsl_asrc.c
@@ -684,12 +684,38 @@ static bool fsl_asrc_writeable_reg(struct device *dev, unsigned int reg)
         }
 }
 
+static struct reg_default fsl_asrc_reg[] = {
+        { REG_ASRCTR, 0x0000 }, { REG_ASRIER, 0x0000 },
+        { REG_ASRCNCR, 0x0000 }, { REG_ASRCFG, 0x0000 },
+        { REG_ASRCSR, 0x0000 }, { REG_ASRCDR1, 0x0000 },
+        { REG_ASRCDR2, 0x0000 }, { REG_ASRSTR, 0x0000 },
+        { REG_ASRRA, 0x0000 }, { REG_ASRRB, 0x0000 },
+        { REG_ASRRC, 0x0000 }, { REG_ASRPM1, 0x0000 },
+        { REG_ASRPM2, 0x0000 }, { REG_ASRPM3, 0x0000 },
+        { REG_ASRPM4, 0x0000 }, { REG_ASRPM5, 0x0000 },
+        { REG_ASRTFR1, 0x0000 }, { REG_ASRCCR, 0x0000 },
+        { REG_ASRDIA, 0x0000 }, { REG_ASRDOA, 0x0000 },
+        { REG_ASRDIB, 0x0000 }, { REG_ASRDOB, 0x0000 },
+        { REG_ASRDIC, 0x0000 }, { REG_ASRDOC, 0x0000 },
+        { REG_ASRIDRHA, 0x0000 }, { REG_ASRIDRLA, 0x0000 },
+        { REG_ASRIDRHB, 0x0000 }, { REG_ASRIDRLB, 0x0000 },
+        { REG_ASRIDRHC, 0x0000 }, { REG_ASRIDRLC, 0x0000 },
+        { REG_ASR76K, 0x0A47 }, { REG_ASR56K, 0x0DF3 },
+        { REG_ASRMCRA, 0x0000 }, { REG_ASRFSTA, 0x0000 },
+        { REG_ASRMCRB, 0x0000 }, { REG_ASRFSTB, 0x0000 },
+        { REG_ASRMCRC, 0x0000 }, { REG_ASRFSTC, 0x0000 },
+        { REG_ASRMCR1A, 0x0000 }, { REG_ASRMCR1B, 0x0000 },
+        { REG_ASRMCR1C, 0x0000 },
+};
+
 static const struct regmap_config fsl_asrc_regmap_config = {
         .reg_bits = 32,
         .reg_stride = 4,
         .val_bits = 32,
 
         .max_register = REG_ASRMCR1C,
+        .reg_defaults = fsl_asrc_reg,
+        .num_reg_defaults = ARRAY_SIZE(fsl_asrc_reg),
         .readable_reg = fsl_asrc_readable_reg,
         .volatile_reg = fsl_asrc_volatile_reg,
         .writeable_reg = fsl_asrc_writeable_reg,
@@ -792,7 +818,7 @@ static int fsl_asrc_probe(struct platform_device *pdev)
                 return -ENOMEM;
 
         asrc_priv->pdev = pdev;
-        strcpy(asrc_priv->name, np->name);
+        strncpy(asrc_priv->name, np->name, sizeof(asrc_priv->name) - 1);
 
         /* Get the addresses and IRQ */
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
diff --git a/sound/soc/fsl/fsl_esai.c b/sound/soc/fsl/fsl_esai.c
index 8bcdfda09d7a..ca319d59f843 100644
--- a/sound/soc/fsl/fsl_esai.c
+++ b/sound/soc/fsl/fsl_esai.c
@@ -513,10 +513,15 @@ static int fsl_esai_hw_params(struct snd_pcm_substream *substream,
         u32 width = snd_pcm_format_width(params_format(params));
         u32 channels = params_channels(params);
         u32 pins = DIV_ROUND_UP(channels, esai_priv->slots);
+        u32 slot_width = width;
         u32 bclk, mask, val;
         int ret;
 
-        bclk = params_rate(params) * esai_priv->slot_width * esai_priv->slots;
+        /* Override slot_width if being specifially set */
+        if (esai_priv->slot_width)
+                slot_width = esai_priv->slot_width;
+
+        bclk = params_rate(params) * slot_width * esai_priv->slots;
 
         ret = fsl_esai_set_bclk(dai, tx, bclk);
         if (ret)
@@ -538,7 +543,7 @@ static int fsl_esai_hw_params(struct snd_pcm_substream *substream,
         regmap_update_bits(esai_priv->regmap, REG_ESAI_xFCR(tx), mask, val);
 
         mask = ESAI_xCR_xSWS_MASK | (tx ? ESAI_xCR_PADC : 0);
-        val = ESAI_xCR_xSWS(esai_priv->slot_width, width) | (tx ? ESAI_xCR_PADC : 0);
+        val = ESAI_xCR_xSWS(slot_width, width) | (tx ? ESAI_xCR_PADC : 0);
 
         regmap_update_bits(esai_priv->regmap, REG_ESAI_xCR(tx), mask, val);
 
@@ -734,7 +739,7 @@ static int fsl_esai_probe(struct platform_device *pdev)
                 return -ENOMEM;
 
         esai_priv->pdev = pdev;
-        strcpy(esai_priv->name, np->name);
+        strncpy(esai_priv->name, np->name, sizeof(esai_priv->name) - 1);
 
         /* Get the addresses and IRQ */
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
@@ -780,9 +785,6 @@ static int fsl_esai_probe(struct platform_device *pdev)
                 return ret;
         }
 
-        /* Set a default slot size */
-        esai_priv->slot_width = 32;
-
         /* Set a default slot number */
         esai_priv->slots = 2;
 
diff --git a/sound/soc/intel/sst-haswell-pcm.c b/sound/soc/intel/sst-haswell-pcm.c
index 33fc5c3abf55..4df867cbb92a 100644
--- a/sound/soc/intel/sst-haswell-pcm.c
+++ b/sound/soc/intel/sst-haswell-pcm.c
@@ -691,9 +691,7 @@ static int hsw_pcm_new(struct snd_soc_pcm_runtime *rtd)
 }
 
 #define HSW_FORMATS \
-        (SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S24_LE | \
-        SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S16_LE |\
-        SNDRV_PCM_FMTBIT_S8)
+        (SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S16_LE)
 
 static struct snd_soc_dai_driver hsw_dais[] = {
         {
diff --git a/sound/soc/rockchip/rockchip_i2s.c b/sound/soc/rockchip/rockchip_i2s.c
index f373e37f8305..c74ba37f862c 100644
--- a/sound/soc/rockchip/rockchip_i2s.c
+++ b/sound/soc/rockchip/rockchip_i2s.c
@@ -154,8 +154,10 @@ static void rockchip_snd_rxctrl(struct rk_i2s_dev *i2s, int on)
                         while (val) {
                                 regmap_read(i2s->regmap, I2S_CLR, &val);
                                 retry--;
-                                if (!retry)
+                                if (!retry) {
                                         dev_warn(i2s->dev, "fail to clear\n");
+                                        break;
+                                }
                         }
                 }
         }
diff --git a/sound/soc/s6000/Kconfig b/sound/soc/s6000/Kconfig
deleted file mode 100644
index f244a2566f20..000000000000
--- a/sound/soc/s6000/Kconfig
+++ /dev/null
@@ -1,26 +0,0 @@
-config SND_S6000_SOC
-        tristate "SoC Audio for the Stretch s6000 family"
-        depends on XTENSA_VARIANT_S6000 || COMPILE_TEST
-        depends on HAS_IOMEM
-        select SND_S6000_SOC_PCM if XTENSA_VARIANT_S6000
-        help
-          Say Y or M if you want to add support for codecs attached to
-          s6000 family chips. You will also need to select the platform
-          to support below.
-
-config SND_S6000_SOC_PCM
-        tristate
-
-config SND_S6000_SOC_I2S
-        tristate
-
-config SND_S6000_SOC_S6IPCAM
-        bool "SoC Audio support for Stretch 6105 IP Camera"
-        depends on SND_S6000_SOC=y
-        depends on I2C=y
-        depends on XTENSA_PLATFORM_S6105 || COMPILE_TEST
-        select SND_S6000_SOC_I2S
-        select SND_SOC_TLV320AIC3X
-        help
-          Say Y if you want to add support for SoC audio on the
-          Stretch s6105 IP Camera Reference Design.
diff --git a/sound/soc/s6000/Makefile b/sound/soc/s6000/Makefile
deleted file mode 100644
index 0f0ae2a012aa..000000000000
--- a/sound/soc/s6000/Makefile
+++ /dev/null
@@ -1,11 +0,0 @@
-# s6000 Platform Support
-snd-soc-s6000-objs := s6000-pcm.o
-snd-soc-s6000-i2s-objs := s6000-i2s.o
-
-obj-$(CONFIG_SND_S6000_SOC_PCM) += snd-soc-s6000.o
-obj-$(CONFIG_SND_S6000_SOC_I2S) += snd-soc-s6000-i2s.o
-
-# s6105 Machine Support
-snd-soc-s6ipcam-objs := s6105-ipcam.o
-
-obj-$(CONFIG_SND_S6000_SOC_S6IPCAM) += snd-soc-s6ipcam.o
diff --git a/sound/soc/s6000/s6000-i2s.c b/sound/soc/s6000/s6000-i2s.c
deleted file mode 100644
index 1c8d01166e5b..000000000000
--- a/sound/soc/s6000/s6000-i2s.c
+++ /dev/null
@@ -1,617 +0,0 @@
-/*
- * ALSA SoC I2S Audio Layer for the Stretch S6000 family
- *
- * Author:      Daniel Gloeckner, <dg@emlix.com>
- * Copyright:   (C) 2009 emlix GmbH <info@emlix.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/init.h>
-#include <linux/module.h>
-#include <linux/device.h>
-#include <linux/delay.h>
-#include <linux/clk.h>
-#include <linux/interrupt.h>
-#include <linux/io.h>
-#include <linux/slab.h>
-
-#include <sound/core.h>
-#include <sound/pcm.h>
-#include <sound/pcm_params.h>
-#include <sound/initval.h>
-#include <sound/soc.h>
-
-#include "s6000-i2s.h"
-#include "s6000-pcm.h"
-
-struct s6000_i2s_dev {
-        dma_addr_t sifbase;
-        u8 __iomem *scbbase;
-        unsigned int wide;
-        unsigned int channel_in;
-        unsigned int channel_out;
-        unsigned int lines_in;
-        unsigned int lines_out;
-        struct s6000_pcm_dma_params dma_params;
-};
-
-#define S6_I2S_INTERRUPT_STATUS 0x00
-#define   S6_I2S_INT_OVERRUN    1
-#define   S6_I2S_INT_UNDERRUN   2
-#define   S6_I2S_INT_ALIGNMENT  4
-#define S6_I2S_INTERRUPT_ENABLE 0x04
-#define S6_I2S_INTERRUPT_RAW    0x08
-#define S6_I2S_INTERRUPT_CLEAR  0x0C
-#define S6_I2S_INTERRUPT_SET    0x10
-#define S6_I2S_MODE             0x20
-#define   S6_I2S_DUAL           0
-#define   S6_I2S_WIDE           1
-#define S6_I2S_TX_DEFAULT       0x24
-#define S6_I2S_DATA_CFG(c)      (0x40 + 0x10 * (c))
-#define   S6_I2S_IN             0
-#define   S6_I2S_OUT            1
-#define   S6_I2S_UNUSED         2
-#define S6_I2S_INTERFACE_CFG(c) (0x44 + 0x10 * (c))
-#define   S6_I2S_DIV_MASK       0x001fff
-#define   S6_I2S_16BIT          0x000000
-#define   S6_I2S_20BIT          0x002000
-#define   S6_I2S_24BIT          0x004000
-#define   S6_I2S_32BIT          0x006000
-#define   S6_I2S_BITS_MASK      0x006000
-#define   S6_I2S_MEM_16BIT      0x000000
-#define   S6_I2S_MEM_32BIT      0x008000
-#define   S6_I2S_MEM_MASK       0x008000
-#define   S6_I2S_CHANNELS_SHIFT 16
-#define   S6_I2S_CHANNELS_MASK  0x030000
-#define   S6_I2S_SCK_IN         0x000000
-#define   S6_I2S_SCK_OUT        0x040000
-#define   S6_I2S_SCK_DIR        0x040000
-#define   S6_I2S_WS_IN          0x000000
-#define   S6_I2S_WS_OUT         0x080000
-#define   S6_I2S_WS_DIR         0x080000
-#define   S6_I2S_LEFT_FIRST     0x000000
-#define   S6_I2S_RIGHT_FIRST    0x100000
-#define   S6_I2S_FIRST          0x100000
-#define   S6_I2S_CUR_SCK        0x200000
-#define   S6_I2S_CUR_WS         0x400000
-#define S6_I2S_ENABLE(c)        (0x48 + 0x10 * (c))
-#define   S6_I2S_DISABLE_IF     0x02
-#define   S6_I2S_ENABLE_IF      0x03
-#define   S6_I2S_IS_BUSY        0x04
-#define   S6_I2S_DMA_ACTIVE     0x08
-#define   S6_I2S_IS_ENABLED     0x10
-
-#define S6_I2S_NUM_LINES        4
-
-#define S6_I2S_SIF_PORT0        0x0000000
-#define S6_I2S_SIF_PORT1        0x0000080 /* docs say 0x0000010 */
-
-static inline void s6_i2s_write_reg(struct s6000_i2s_dev *dev, int reg, u32 val)
-{
-        writel(val, dev->scbbase + reg);
-}
-
-static inline u32 s6_i2s_read_reg(struct s6000_i2s_dev *dev, int reg)
-{
-        return readl(dev->scbbase + reg);
-}
-
-static inline void s6_i2s_mod_reg(struct s6000_i2s_dev *dev, int reg,
-                                  u32 mask, u32 val)
-{
-        val ^= s6_i2s_read_reg(dev, reg) & ~mask;
-        s6_i2s_write_reg(dev, reg, val);
-}
-
-static void s6000_i2s_start_channel(struct s6000_i2s_dev *dev, int channel)
-{
-        int i, j, cur, prev;
-
-        /*
-         * Wait for WCLK to toggle 5 times before enabling the channel
-         * s6000 Family Datasheet 3.6.4:
-         *   "At least two cycles of WS must occur between commands
-         *    to disable or enable the interface"
-         */
-        j = 0;
-        prev = ~S6_I2S_CUR_WS;
-        for (i = 1000000; --i && j < 6; ) {
-                cur = s6_i2s_read_reg(dev, S6_I2S_INTERFACE_CFG(channel))
-                       & S6_I2S_CUR_WS;
-                if (prev != cur) {
-                        prev = cur;
-                        j++;
-                }
-        }
-        if (j < 6)
-                printk(KERN_WARNING "s6000-i2s: timeout waiting for WCLK\n");
-
-        s6_i2s_write_reg(dev, S6_I2S_ENABLE(channel), S6_I2S_ENABLE_IF);
-}
-
-static void s6000_i2s_stop_channel(struct s6000_i2s_dev *dev, int channel)
-{
-        s6_i2s_write_reg(dev, S6_I2S_ENABLE(channel), S6_I2S_DISABLE_IF);
-}
-
-static void s6000_i2s_start(struct snd_pcm_substream *substream)
-{
-        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-        struct s6000_i2s_dev *dev = snd_soc_dai_get_drvdata(rtd->cpu_dai);
-        int channel;
-
-        channel = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ?
-                        dev->channel_out : dev->channel_in;
-
-        s6000_i2s_start_channel(dev, channel);
-}
-
-static void s6000_i2s_stop(struct snd_pcm_substream *substream)
-{
-        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-        struct s6000_i2s_dev *dev = snd_soc_dai_get_drvdata(rtd->cpu_dai);
-        int channel;
-
-        channel = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ?
-                        dev->channel_out : dev->channel_in;
-
-        s6000_i2s_stop_channel(dev, channel);
-}
-
-static int s6000_i2s_trigger(struct snd_pcm_substream *substream, int cmd,
-                             int after)
-{
-        switch (cmd) {
-        case SNDRV_PCM_TRIGGER_START:
-        case SNDRV_PCM_TRIGGER_RESUME:
-        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
-                if ((substream->stream == SNDRV_PCM_STREAM_CAPTURE) ^ !after)
-                        s6000_i2s_start(substream);
-                break;
-        case SNDRV_PCM_TRIGGER_STOP:
-        case SNDRV_PCM_TRIGGER_SUSPEND:
-        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
-                if (!after)
-                        s6000_i2s_stop(substream);
-        }
-        return 0;
-}
-
-static unsigned int s6000_i2s_int_sources(struct s6000_i2s_dev *dev)
-{
-        unsigned int pending;
-        pending = s6_i2s_read_reg(dev, S6_I2S_INTERRUPT_RAW);
-        pending &= S6_I2S_INT_ALIGNMENT |
-                   S6_I2S_INT_UNDERRUN |
-                   S6_I2S_INT_OVERRUN;
-        s6_i2s_write_reg(dev, S6_I2S_INTERRUPT_CLEAR, pending);
-
-        return pending;
-}
-
-static unsigned int s6000_i2s_check_xrun(struct snd_soc_dai *cpu_dai)
-{
-        struct s6000_i2s_dev *dev = snd_soc_dai_get_drvdata(cpu_dai);
-        unsigned int errors;
-        unsigned int ret;
-
-        errors = s6000_i2s_int_sources(dev);
-        if (likely(!errors))
-                return 0;
-
-        ret = 0;
-        if (errors & S6_I2S_INT_ALIGNMENT)
-                printk(KERN_ERR "s6000-i2s: WCLK misaligned\n");
-        if (errors & S6_I2S_INT_UNDERRUN)
-                ret |= 1 << SNDRV_PCM_STREAM_PLAYBACK;
-        if (errors & S6_I2S_INT_OVERRUN)
-                ret |= 1 << SNDRV_PCM_STREAM_CAPTURE;
-        return ret;
-}
-
-static void s6000_i2s_wait_disabled(struct s6000_i2s_dev *dev)
-{
-        int channel;
-        int n = 50;
-        for (channel = 0; channel < 2; channel++) {
-                while (--n >= 0) {
-                        int v = s6_i2s_read_reg(dev, S6_I2S_ENABLE(channel));
-                        if ((v & S6_I2S_IS_ENABLED)
-                            || !(v & (S6_I2S_DMA_ACTIVE | S6_I2S_IS_BUSY)))
-                                break;
-                        udelay(20);
-                }
-        }
-        if (n < 0)
-                printk(KERN_WARNING "s6000-i2s: timeout disabling interfaces");
-}
-
-static int s6000_i2s_set_dai_fmt(struct snd_soc_dai *cpu_dai,
-                                   unsigned int fmt)
-{
-        struct s6000_i2s_dev *dev = snd_soc_dai_get_drvdata(cpu_dai);
-        u32 w;
-
-        switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
-        case SND_SOC_DAIFMT_CBM_CFM:
-                w = S6_I2S_SCK_IN | S6_I2S_WS_IN;
-                break;
-        case SND_SOC_DAIFMT_CBS_CFM:
-                w = S6_I2S_SCK_OUT | S6_I2S_WS_IN;
-                break;
-        case SND_SOC_DAIFMT_CBM_CFS:
-                w = S6_I2S_SCK_IN | S6_I2S_WS_OUT;
-                break;
-        case SND_SOC_DAIFMT_CBS_CFS:
-                w = S6_I2S_SCK_OUT | S6_I2S_WS_OUT;
-                break;
-        default:
-                return -EINVAL;
-        }
-
-        switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
-        case SND_SOC_DAIFMT_NB_NF:
-                w |= S6_I2S_LEFT_FIRST;
-                break;
-        case SND_SOC_DAIFMT_NB_IF:
-                w |= S6_I2S_RIGHT_FIRST;
-                break;
-        default:
-                return -EINVAL;
-        }
-
-        s6_i2s_mod_reg(dev, S6_I2S_INTERFACE_CFG(0),
-                       S6_I2S_FIRST | S6_I2S_WS_DIR | S6_I2S_SCK_DIR, w);
-        s6_i2s_mod_reg(dev, S6_I2S_INTERFACE_CFG(1),
-                       S6_I2S_FIRST | S6_I2S_WS_DIR | S6_I2S_SCK_DIR, w);
-
-        return 0;
-}
-
-static int s6000_i2s_set_clkdiv(struct snd_soc_dai *dai, int div_id, int div)
-{
-        struct s6000_i2s_dev *dev = snd_soc_dai_get_drvdata(dai);
-
-        if (!div || (div & 1) || div > (S6_I2S_DIV_MASK + 1) * 2)
-                return -EINVAL;
-
-        s6_i2s_mod_reg(dev, S6_I2S_INTERFACE_CFG(div_id),
-                       S6_I2S_DIV_MASK, div / 2 - 1);
-        return 0;
-}
-
-static int s6000_i2s_hw_params(struct snd_pcm_substream *substream,
-                               struct snd_pcm_hw_params *params,
-                               struct snd_soc_dai *dai)
-{
-        struct s6000_i2s_dev *dev = snd_soc_dai_get_drvdata(dai);
-        int interf;
-        u32 w = 0;
-
-        if (dev->wide)
-                interf = 0;
-        else {
-                w |= (((params_channels(params) - 2) / 2)
-                      << S6_I2S_CHANNELS_SHIFT) & S6_I2S_CHANNELS_MASK;
-                interf = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
-                                ? dev->channel_out : dev->channel_in;
-        }
-
-        switch (params_format(params)) {
-        case SNDRV_PCM_FORMAT_S16_LE:
-                w |= S6_I2S_16BIT | S6_I2S_MEM_16BIT;
-                break;
-        case SNDRV_PCM_FORMAT_S32_LE:
-                w |= S6_I2S_32BIT | S6_I2S_MEM_32BIT;
-                break;
-        default:
-                printk(KERN_WARNING "s6000-i2s: unsupported PCM format %x\n",
-                       params_format(params));
-                return -EINVAL;
-        }
-
-        if (s6_i2s_read_reg(dev, S6_I2S_INTERFACE_CFG(interf))
-             & S6_I2S_IS_ENABLED) {
-                printk(KERN_ERR "s6000-i2s: interface already enabled\n");
-                return -EBUSY;
-        }
-
-        s6_i2s_mod_reg(dev, S6_I2S_INTERFACE_CFG(interf),
-                       S6_I2S_CHANNELS_MASK|S6_I2S_MEM_MASK|S6_I2S_BITS_MASK,
-                       w);
-
-        return 0;
-}
-
-static int s6000_i2s_dai_probe(struct snd_soc_dai *dai)
-{
-        struct s6000_i2s_dev *dev = snd_soc_dai_get_drvdata(dai);
-        struct s6000_snd_platform_data *pdata = dai->dev->platform_data;
-
-        if (!pdata)
-                return -EINVAL;
-
-        dai->capture_dma_data = &dev->dma_params;
-        dai->playback_dma_data = &dev->dma_params;
-
-        dev->wide = pdata->wide;
-        dev->channel_in = pdata->channel_in;
-        dev->channel_out = pdata->channel_out;
-        dev->lines_in = pdata->lines_in;
-        dev->lines_out = pdata->lines_out;
-
-        s6_i2s_write_reg(dev, S6_I2S_MODE,
-                         dev->wide ? S6_I2S_WIDE : S6_I2S_DUAL);
-
-        if (dev->wide) {
-                int i;
-
-                if (dev->lines_in + dev->lines_out > S6_I2S_NUM_LINES)
-                        return -EINVAL;
-
-                dev->channel_in = 0;
-                dev->channel_out = 1;
-                dai->driver->capture.channels_min = 2 * dev->lines_in;
-                dai->driver->capture.channels_max = dai->driver->capture.channels_min;
-                dai->driver->playback.channels_min = 2 * dev->lines_out;
-                dai->driver->playback.channels_max = dai->driver->playback.channels_min;
-
-                for (i = 0; i < dev->lines_out; i++)
-                        s6_i2s_write_reg(dev, S6_I2S_DATA_CFG(i), S6_I2S_OUT);
-
-                for (; i < S6_I2S_NUM_LINES - dev->lines_in; i++)
-                        s6_i2s_write_reg(dev, S6_I2S_DATA_CFG(i),
-                                         S6_I2S_UNUSED);
-
-                for (; i < S6_I2S_NUM_LINES; i++)
-                        s6_i2s_write_reg(dev, S6_I2S_DATA_CFG(i), S6_I2S_IN);
-        } else {
-                unsigned int cfg[2] = {S6_I2S_UNUSED, S6_I2S_UNUSED};
-
-                if (dev->lines_in > 1 || dev->lines_out > 1)
-                        return -EINVAL;
-
-                dai->driver->capture.channels_min = 2 * dev->lines_in;
-                dai->driver->capture.channels_max = 8 * dev->lines_in;
-                dai->driver->playback.channels_min = 2 * dev->lines_out;
-                dai->driver->playback.channels_max = 8 * dev->lines_out;
-
-                if (dev->lines_in)
-                        cfg[dev->channel_in] = S6_I2S_IN;
-                if (dev->lines_out)
-                        cfg[dev->channel_out] = S6_I2S_OUT;
-
-                s6_i2s_write_reg(dev, S6_I2S_DATA_CFG(0), cfg[0]);
-                s6_i2s_write_reg(dev, S6_I2S_DATA_CFG(1), cfg[1]);
-        }
-
-        if (dev->lines_out) {
-                if (dev->lines_in) {
-                        if (!dev->dma_params.dma_out)
-                                return -ENODEV;
-                } else {
-                        dev->dma_params.dma_out = dev->dma_params.dma_in;
-                        dev->dma_params.dma_in = 0;
-                }
-        }
-        dev->dma_params.sif_in = dev->sifbase + (dev->channel_in ?
-                                        S6_I2S_SIF_PORT1 : S6_I2S_SIF_PORT0);
-        dev->dma_params.sif_out = dev->sifbase + (dev->channel_out ?
-                                        S6_I2S_SIF_PORT1 : S6_I2S_SIF_PORT0);
-        dev->dma_params.same_rate = pdata->same_rate | pdata->wide;
-        return 0;
-}
-
-#define S6000_I2S_RATES SNDRV_PCM_RATE_CONTINUOUS
-#define S6000_I2S_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S32_LE)
-
-static const struct snd_soc_dai_ops s6000_i2s_dai_ops = {
-        .set_fmt = s6000_i2s_set_dai_fmt,
-        .set_clkdiv = s6000_i2s_set_clkdiv,
-        .hw_params = s6000_i2s_hw_params,
-};
-
-static struct snd_soc_dai_driver s6000_i2s_dai = {
-        .probe = s6000_i2s_dai_probe,
-        .playback = {
-                .channels_min = 2,
-                .channels_max = 8,
-                .formats = S6000_I2S_FORMATS,
-                .rates = S6000_I2S_RATES,
-                .rate_min = 0,
-                .rate_max = 1562500,
-        },
-        .capture = {
-                .channels_min = 2,
-                .channels_max = 8,
-                .formats = S6000_I2S_FORMATS,
-                .rates = S6000_I2S_RATES,
-                .rate_min = 0,
-                .rate_max = 1562500,
-        },
-        .ops = &s6000_i2s_dai_ops,
-};
-
-static const struct snd_soc_component_driver s6000_i2s_component = {
-        .name           = "s6000-i2s",
-};
-
-static int s6000_i2s_probe(struct platform_device *pdev)
-{
-        struct s6000_i2s_dev *dev;
-        struct resource *scbmem, *sifmem, *region, *dma1, *dma2;
-        u8 __iomem *mmio;
-        int ret;
-
-        scbmem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!scbmem) {
-                dev_err(&pdev->dev, "no mem resource?\n");
-                ret = -ENODEV;
-                goto err_release_none;
-        }
-
-        region = request_mem_region(scbmem->start, resource_size(scbmem),
-                                                                pdev->name);
-        if (!region) {
-                dev_err(&pdev->dev, "I2S SCB region already claimed\n");
-                ret = -EBUSY;
-                goto err_release_none;
-        }
-
-        mmio = ioremap(scbmem->start, resource_size(scbmem));
-        if (!mmio) {
-                dev_err(&pdev->dev, "can't ioremap SCB region\n");
-                ret = -ENOMEM;
-                goto err_release_scb;
-        }
-
-        sifmem = platform_get_resource(pdev, IORESOURCE_MEM, 1);
-        if (!sifmem) {
-                dev_err(&pdev->dev, "no second mem resource?\n");
-                ret = -ENODEV;
-                goto err_release_map;
-        }
-
-        region = request_mem_region(sifmem->start, resource_size(sifmem),
-                                                                pdev->name);
-        if (!region) {
-                dev_err(&pdev->dev, "I2S SIF region already claimed\n");
-                ret = -EBUSY;
-                goto err_release_map;
-        }
-
-        dma1 = platform_get_resource(pdev, IORESOURCE_DMA, 0);
-        if (!dma1) {
-                dev_err(&pdev->dev, "no dma resource?\n");
-                ret = -ENODEV;
-                goto err_release_sif;
-        }
-
-        region = request_mem_region(dma1->start, resource_size(dma1),
-                                                                pdev->name);
-        if (!region) {
-                dev_err(&pdev->dev, "I2S DMA region already claimed\n");
-                ret = -EBUSY;
-                goto err_release_sif;
-        }
-
-        dma2 = platform_get_resource(pdev, IORESOURCE_DMA, 1);
-        if (dma2) {
-                region = request_mem_region(dma2->start, resource_size(dma2),
-                                                                pdev->name);
-                if (!region) {
-                        dev_err(&pdev->dev,
-                                "I2S DMA region already claimed\n");
-                        ret = -EBUSY;
-                        goto err_release_dma1;
-                }
-        }
-
-        dev = kzalloc(sizeof(struct s6000_i2s_dev), GFP_KERNEL);
-        if (!dev) {
-                ret = -ENOMEM;
-                goto err_release_dma2;
-        }
-        dev_set_drvdata(&pdev->dev, dev);
-
-        dev->sifbase = sifmem->start;
-        dev->scbbase = mmio;
-
-        s6_i2s_write_reg(dev, S6_I2S_INTERRUPT_ENABLE, 0);
-        s6_i2s_write_reg(dev, S6_I2S_INTERRUPT_CLEAR,
-                         S6_I2S_INT_ALIGNMENT |
-                         S6_I2S_INT_UNDERRUN |
-                         S6_I2S_INT_OVERRUN);
-
-        s6000_i2s_stop_channel(dev, 0);
-        s6000_i2s_stop_channel(dev, 1);
-        s6000_i2s_wait_disabled(dev);
-
-        dev->dma_params.check_xrun = s6000_i2s_check_xrun;
-        dev->dma_params.trigger = s6000_i2s_trigger;
-        dev->dma_params.dma_in = dma1->start;
-        dev->dma_params.dma_out = dma2 ? dma2->start : 0;
-        dev->dma_params.irq = platform_get_irq(pdev, 0);
-        if (dev->dma_params.irq < 0) {
-                dev_err(&pdev->dev, "no irq resource?\n");
-                ret = -ENODEV;
-                goto err_release_dev;
-        }
-
-        s6_i2s_write_reg(dev, S6_I2S_INTERRUPT_ENABLE,
-                         S6_I2S_INT_ALIGNMENT |
-                         S6_I2S_INT_UNDERRUN |
-                         S6_I2S_INT_OVERRUN);
-
-        ret = snd_soc_register_component(&pdev->dev, &s6000_i2s_component,
-                                         &s6000_i2s_dai, 1);
-        if (ret)
-                goto err_release_dev;
-
-        return 0;
-
-err_release_dev:
-        kfree(dev);
-err_release_dma2:
-        if (dma2)
-                release_mem_region(dma2->start, resource_size(dma2));
-err_release_dma1:
-        release_mem_region(dma1->start, resource_size(dma1));
-err_release_sif:
-        release_mem_region(sifmem->start, resource_size(sifmem));
-err_release_map:
-        iounmap(mmio);
-err_release_scb:
-        release_mem_region(scbmem->start, resource_size(scbmem));
-err_release_none:
-        return ret;
-}
-
-static int s6000_i2s_remove(struct platform_device *pdev)
-{
-        struct s6000_i2s_dev *dev = dev_get_drvdata(&pdev->dev);
-        struct resource *region;
-        void __iomem *mmio = dev->scbbase;
-
-        snd_soc_unregister_component(&pdev->dev);
-
-        s6000_i2s_stop_channel(dev, 0);
-        s6000_i2s_stop_channel(dev, 1);
-
-        s6_i2s_write_reg(dev, S6_I2S_INTERRUPT_ENABLE, 0);
-        kfree(dev);
-
-        region = platform_get_resource(pdev, IORESOURCE_DMA, 0);
-        release_mem_region(region->start, resource_size(region));
-
-        region = platform_get_resource(pdev, IORESOURCE_DMA, 1);
-        if (region)
-                release_mem_region(region->start, resource_size(region));
-
-        region = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        release_mem_region(region->start, resource_size(region));
-
-        iounmap(mmio);
-        region = platform_get_resource(pdev, IORESOURCE_IO, 0);
-        release_mem_region(region->start, resource_size(region));
-
-        return 0;
-}
-
-static struct platform_driver s6000_i2s_driver = {
-        .probe  = s6000_i2s_probe,
-        .remove = s6000_i2s_remove,
-        .driver = {
-                .name   = "s6000-i2s",
-                .owner  = THIS_MODULE,
-        },
-};
-
-module_platform_driver(s6000_i2s_driver);
-
-MODULE_AUTHOR("Daniel Gloeckner");
-MODULE_DESCRIPTION("Stretch s6000 family I2S SoC Interface");
-MODULE_LICENSE("GPL");
diff --git a/sound/soc/s6000/s6000-i2s.h b/sound/soc/s6000/s6000-i2s.h
deleted file mode 100644
index 86aa1921c89e..000000000000
--- a/sound/soc/s6000/s6000-i2s.h
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
- * ALSA SoC I2S Audio Layer for the Stretch s6000 family
- *
- * Author:      Daniel Gloeckner, <dg@emlix.com>
- * Copyright:   (C) 2009 emlix GmbH <info@emlix.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-#ifndef _S6000_I2S_H
-#define _S6000_I2S_H
-
-struct s6000_snd_platform_data {
-        int lines_in;
-        int lines_out;
-        int channel_in;
-        int channel_out;
-        int wide;
-        int same_rate;
-};
-#endif
diff --git a/sound/soc/s6000/s6000-pcm.c b/sound/soc/s6000/s6000-pcm.c
deleted file mode 100644
index fb8461e1b1f6..000000000000
--- a/sound/soc/s6000/s6000-pcm.c
+++ /dev/null
@@ -1,521 +0,0 @@
-/*
- * ALSA PCM interface for the Stetch s6000 family
- *
- * Author:      Daniel Gloeckner, <dg@emlix.com>
- * Copyright:   (C) 2009 emlix GmbH <info@emlix.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/platform_device.h>
-#include <linux/slab.h>
-#include <linux/dma-mapping.h>
-#include <linux/interrupt.h>
-
-#include <sound/core.h>
-#include <sound/pcm.h>
-#include <sound/pcm_params.h>
-#include <sound/soc.h>
-
-#include <asm/dma.h>
-#include <variant/dmac.h>
-
-#include "s6000-pcm.h"
-
-#define S6_PCM_PREALLOCATE_SIZE (96 * 1024)
-#define S6_PCM_PREALLOCATE_MAX  (2048 * 1024)
-
-static struct snd_pcm_hardware s6000_pcm_hardware = {
-        .info = (SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER |
-                 SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID |
-                 SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_JOINT_DUPLEX),
-        .buffer_bytes_max = 0x7ffffff0,
-        .period_bytes_min = 16,
-        .period_bytes_max = 0xfffff0,
-        .periods_min = 2,
-        .periods_max = 1024, /* no limit */
-        .fifo_size = 0,
-};
-
-struct s6000_runtime_data {
-        spinlock_t lock;
-        int period;             /* current DMA period */
-};
-
-static void s6000_pcm_enqueue_dma(struct snd_pcm_substream *substream)
-{
-        struct snd_pcm_runtime *runtime = substream->runtime;
-        struct s6000_runtime_data *prtd = runtime->private_data;
-        struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
-        struct s6000_pcm_dma_params *par;
-        int channel;
-        unsigned int period_size;
-        unsigned int dma_offset;
-        dma_addr_t dma_pos;
-        dma_addr_t src, dst;
-
-        par = snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);
-
-        period_size = snd_pcm_lib_period_bytes(substream);
-        dma_offset = prtd->period * period_size;
-        dma_pos = runtime->dma_addr + dma_offset;
-
-        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
-                src = dma_pos;
-                dst = par->sif_out;
-                channel = par->dma_out;
-        } else {
-                src = par->sif_in;
-                dst = dma_pos;
-                channel = par->dma_in;
-        }
-
-        if (!s6dmac_channel_enabled(DMA_MASK_DMAC(channel),
-                                    DMA_INDEX_CHNL(channel)))
-                return;
-
-        if (s6dmac_fifo_full(DMA_MASK_DMAC(channel), DMA_INDEX_CHNL(channel))) {
-                printk(KERN_ERR "s6000-pcm: fifo full\n");
-                return;
-        }
-
-        if (WARN_ON(period_size & 15))
-                return;
-        s6dmac_put_fifo(DMA_MASK_DMAC(channel), DMA_INDEX_CHNL(channel),
-                        src, dst, period_size);
-
-        prtd->period++;
-        if (unlikely(prtd->period >= runtime->periods))
-                prtd->period = 0;
-}
-
-static irqreturn_t s6000_pcm_irq(int irq, void *data)
-{
-        struct snd_pcm *pcm = data;
-        struct snd_soc_pcm_runtime *runtime = pcm->private_data;
-        struct s6000_runtime_data *prtd;
-        unsigned int has_xrun;
-        int i, ret = IRQ_NONE;
-
-        for (i = 0; i < 2; ++i) {
-                struct snd_pcm_substream *substream = pcm->streams[i].substream;
-                struct s6000_pcm_dma_params *params =
-                                        snd_soc_dai_get_dma_data(runtime->cpu_dai, substream);
-                u32 channel;
-                unsigned int pending;
-
-                if (substream == SNDRV_PCM_STREAM_PLAYBACK)
-                        channel = params->dma_out;
-                else
-                        channel = params->dma_in;
-
-                has_xrun = params->check_xrun(runtime->cpu_dai);
-
-                if (!channel)
-                        continue;
-
-                if (unlikely(has_xrun & (1 << i)) &&
-                    substream->runtime &&
-                    snd_pcm_running(substream)) {
-                        dev_dbg(pcm->dev, "xrun\n");
-                        snd_pcm_stream_lock(substream);
-                        snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
-                        snd_pcm_stream_unlock(substream);
-                        ret = IRQ_HANDLED;
-                }
-
-                pending = s6dmac_int_sources(DMA_MASK_DMAC(channel),
-                                             DMA_INDEX_CHNL(channel));
-
-                if (pending & 1) {
-                        ret = IRQ_HANDLED;
-                        if (likely(substream->runtime &&
-                                   snd_pcm_running(substream))) {
-                                snd_pcm_period_elapsed(substream);
-                                dev_dbg(pcm->dev, "period elapsed %x %x\n",
-                                       s6dmac_cur_src(DMA_MASK_DMAC(channel),
-                                                   DMA_INDEX_CHNL(channel)),
-                                       s6dmac_cur_dst(DMA_MASK_DMAC(channel),
-                                                   DMA_INDEX_CHNL(channel)));
-                                prtd = substream->runtime->private_data;
-                                spin_lock(&prtd->lock);
-                                s6000_pcm_enqueue_dma(substream);
-                                spin_unlock(&prtd->lock);
-                        }
-                }
-
-                if (unlikely(pending & ~7)) {
-                        if (pending & (1 << 3))
-                                printk(KERN_WARNING
-                                       "s6000-pcm: DMA %x Underflow\n",
-                                       channel);
-                        if (pending & (1 << 4))
-                                printk(KERN_WARNING
-                                       "s6000-pcm: DMA %x Overflow\n",
-                                       channel);
-                        if (pending & 0x1e0)
-                                printk(KERN_WARNING
-                                       "s6000-pcm: DMA %x Master Error "
-                                       "(mask %x)\n",
-                                       channel, pending >> 5);
-
-                }
-        }
-
-        return ret;
-}
-
-static int s6000_pcm_start(struct snd_pcm_substream *substream)
-{
-        struct s6000_runtime_data *prtd = substream->runtime->private_data;
-        struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
-        struct s6000_pcm_dma_params *par;
-        unsigned long flags;
-        int srcinc;
-        u32 dma;
-
-        par = snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);
-
-        spin_lock_irqsave(&prtd->lock, flags);
-
-        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
-                srcinc = 1;
-                dma = par->dma_out;
-        } else {
-                srcinc = 0;
-                dma = par->dma_in;
-        }
-        s6dmac_enable_chan(DMA_MASK_DMAC(dma), DMA_INDEX_CHNL(dma),
-                           1 /* priority 1 (0 is max) */,
-                           0 /* peripheral requests w/o xfer length mode */,
-                           srcinc /* source address increment */,
-                           srcinc^1 /* destination address increment */,
-                           0 /* chunksize 0 (skip impossible on this dma) */,
-                           0 /* source skip after chunk (impossible) */,
-                           0 /* destination skip after chunk (impossible) */,
-                           4 /* 16 byte burst size */,
-                           -1 /* don't conserve bandwidth */,
-                           0 /* low watermark irq descriptor threshold */,
-                           0 /* disable hardware timestamps */,
-                           1 /* enable channel */);
-
-        s6000_pcm_enqueue_dma(substream);
-        s6000_pcm_enqueue_dma(substream);
-
-        spin_unlock_irqrestore(&prtd->lock, flags);
-
-        return 0;
-}
-
-static int s6000_pcm_stop(struct snd_pcm_substream *substream)
-{
-        struct s6000_runtime_data *prtd = substream->runtime->private_data;
-        struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
-        struct s6000_pcm_dma_params *par;
-        unsigned long flags;
-        u32 channel;
-
-        par = snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);
-
-        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
-                channel = par->dma_out;
-        else
-                channel = par->dma_in;
-
-        s6dmac_set_terminal_count(DMA_MASK_DMAC(channel),
-                                  DMA_INDEX_CHNL(channel), 0);
-
-        spin_lock_irqsave(&prtd->lock, flags);
-
-        s6dmac_disable_chan(DMA_MASK_DMAC(channel), DMA_INDEX_CHNL(channel));
-
-        spin_unlock_irqrestore(&prtd->lock, flags);
-
-        return 0;
-}
-
-static int s6000_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
-{
-        struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
-        struct s6000_pcm_dma_params *par;
-        int ret;
-
-        par = snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);
-
-        ret = par->trigger(substream, cmd, 0);
-        if (ret < 0)
-                return ret;
-
-        switch (cmd) {
-        case SNDRV_PCM_TRIGGER_START:
-        case SNDRV_PCM_TRIGGER_RESUME:
-        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
-                ret = s6000_pcm_start(substream);
-                break;
-        case SNDRV_PCM_TRIGGER_STOP:
-        case SNDRV_PCM_TRIGGER_SUSPEND:
-        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
-                ret = s6000_pcm_stop(substream);
-                break;
-        default:
-                ret = -EINVAL;
-        }
-        if (ret < 0)
-                return ret;
-
-        return par->trigger(substream, cmd, 1);
-}
-
-static int s6000_pcm_prepare(struct snd_pcm_substream *substream)
-{
-        struct s6000_runtime_data *prtd = substream->runtime->private_data;
-
-        prtd->period = 0;
-
-        return 0;
-}
-
-static snd_pcm_uframes_t s6000_pcm_pointer(struct snd_pcm_substream *substream)
-{
-        struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
-        struct s6000_pcm_dma_params *par;
-        struct snd_pcm_runtime *runtime = substream->runtime;
-        struct s6000_runtime_data *prtd = runtime->private_data;
-        unsigned long flags;
-        unsigned int offset;
-        dma_addr_t count;
-
-        par = snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);
-
-        spin_lock_irqsave(&prtd->lock, flags);
-
-        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
-                count = s6dmac_cur_src(DMA_MASK_DMAC(par->dma_out),
-                                       DMA_INDEX_CHNL(par->dma_out));
-        else
-                count = s6dmac_cur_dst(DMA_MASK_DMAC(par->dma_in),
-                                       DMA_INDEX_CHNL(par->dma_in));
-
-        count -= runtime->dma_addr;
-
-        spin_unlock_irqrestore(&prtd->lock, flags);
-
-        offset = bytes_to_frames(runtime, count);
-        if (unlikely(offset >= runtime->buffer_size))
-                offset = 0;
-
-        return offset;
-}
-
-static int s6000_pcm_open(struct snd_pcm_substream *substream)
-{
-        struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
-        struct s6000_pcm_dma_params *par;
-        struct snd_pcm_runtime *runtime = substream->runtime;
-        struct s6000_runtime_data *prtd;
-        int ret;
-
-        par = snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);
-        snd_soc_set_runtime_hwparams(substream, &s6000_pcm_hardware);
-
-        ret = snd_pcm_hw_constraint_step(runtime, 0,
-                                         SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 16);
-        if (ret < 0)
-                return ret;
-        ret = snd_pcm_hw_constraint_step(runtime, 0,
-                                         SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 16);
-        if (ret < 0)
-                return ret;
-        ret = snd_pcm_hw_constraint_integer(runtime,
-                                            SNDRV_PCM_HW_PARAM_PERIODS);
-        if (ret < 0)
-                return ret;
-
-        if (par->same_rate) {
-                int rate;
-                spin_lock(&par->lock); /* needed? */
-                rate = par->rate;
-                spin_unlock(&par->lock);
-                if (rate != -1) {
-                        ret = snd_pcm_hw_constraint_minmax(runtime,
-                                                        SNDRV_PCM_HW_PARAM_RATE,
-                                                        rate, rate);
-                        if (ret < 0)
-                                return ret;
-                }
-        }
-
-        prtd = kzalloc(sizeof(struct s6000_runtime_data), GFP_KERNEL);
-        if (prtd == NULL)
-                return -ENOMEM;
-
-        spin_lock_init(&prtd->lock);
-
-        runtime->private_data = prtd;
-
-        return 0;
-}
-
-static int s6000_pcm_close(struct snd_pcm_substream *substream)
-{
-        struct snd_pcm_runtime *runtime = substream->runtime;
-        struct s6000_runtime_data *prtd = runtime->private_data;
-
-        kfree(prtd);
-
-        return 0;
-}
-
-static int s6000_pcm_hw_params(struct snd_pcm_substream *substream,
-                                 struct snd_pcm_hw_params *hw_params)
-{
-        struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
-        struct s6000_pcm_dma_params *par;
-        int ret;
-        ret = snd_pcm_lib_malloc_pages(substream,
-                                       params_buffer_bytes(hw_params));
-        if (ret < 0) {
-                printk(KERN_WARNING "s6000-pcm: allocation of memory failed\n");
-                return ret;
-        }
-
-        par = snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);
-
-        if (par->same_rate) {
-                spin_lock(&par->lock);
-                if (par->rate == -1 ||
-                    !(par->in_use & ~(1 << substream->stream))) {
-                        par->rate = params_rate(hw_params);
-                        par->in_use |= 1 << substream->stream;
-                } else if (params_rate(hw_params) != par->rate) {
-                        snd_pcm_lib_free_pages(substream);
-                        par->in_use &= ~(1 << substream->stream);
-                        ret = -EBUSY;
-                }
-                spin_unlock(&par->lock);
-        }
-        return ret;
-}
-
-static int s6000_pcm_hw_free(struct snd_pcm_substream *substream)
-{
-        struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
-        struct s6000_pcm_dma_params *par =
-                snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);
-
-        spin_lock(&par->lock);
-        par->in_use &= ~(1 << substream->stream);
-        if (!par->in_use)
-                par->rate = -1;
-        spin_unlock(&par->lock);
-
-        return snd_pcm_lib_free_pages(substream);
-}
-
-static struct snd_pcm_ops s6000_pcm_ops = {
-        .open =         s6000_pcm_open,
-        .close =        s6000_pcm_close,
-        .ioctl =        snd_pcm_lib_ioctl,
-        .hw_params =    s6000_pcm_hw_params,
-        .hw_free =      s6000_pcm_hw_free,
-        .trigger =      s6000_pcm_trigger,
-        .prepare =      s6000_pcm_prepare,
-        .pointer =      s6000_pcm_pointer,
-};
-
-static void s6000_pcm_free(struct snd_pcm *pcm)
-{
-        struct snd_soc_pcm_runtime *runtime = pcm->private_data;
-        struct s6000_pcm_dma_params *params =
-                snd_soc_dai_get_dma_data(runtime->cpu_dai,
-                        pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream);
-
-        free_irq(params->irq, pcm);
-        snd_pcm_lib_preallocate_free_for_all(pcm);
-}
-
-static int s6000_pcm_new(struct snd_soc_pcm_runtime *runtime)
-{
-        struct snd_card *card = runtime->card->snd_card;
-        struct snd_pcm *pcm = runtime->pcm;
-        struct s6000_pcm_dma_params *params;
-        int res;
-
-        params = snd_soc_dai_get_dma_data(runtime->cpu_dai,
-                        pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream);
-
-        res = dma_coerce_mask_and_coherent(card->dev, DMA_BIT_MASK(32));
-        if (res)
-                return res;
-
-        if (params->dma_in) {
-                s6dmac_disable_chan(DMA_MASK_DMAC(params->dma_in),
-                                    DMA_INDEX_CHNL(params->dma_in));
-                s6dmac_int_sources(DMA_MASK_DMAC(params->dma_in),
-                                   DMA_INDEX_CHNL(params->dma_in));
-        }
-
-        if (params->dma_out) {
-                s6dmac_disable_chan(DMA_MASK_DMAC(params->dma_out),
-                                    DMA_INDEX_CHNL(params->dma_out));
-                s6dmac_int_sources(DMA_MASK_DMAC(params->dma_out),
-                                   DMA_INDEX_CHNL(params->dma_out));
-        }
-
-        res = request_irq(params->irq, s6000_pcm_irq, IRQF_SHARED,
-                          "s6000-audio", pcm);
-        if (res) {
-                printk(KERN_ERR "s6000-pcm couldn't get IRQ\n");
-                return res;
-        }
-
-        res = snd_pcm_lib_preallocate_pages_for_all(pcm,
-                                                    SNDRV_DMA_TYPE_DEV,
-                                                    card->dev,
-                                                    S6_PCM_PREALLOCATE_SIZE,
-                                                    S6_PCM_PREALLOCATE_MAX);
-        if (res)
-                printk(KERN_WARNING "s6000-pcm: preallocation failed\n");
-
-        spin_lock_init(&params->lock);
-        params->in_use = 0;
-        params->rate = -1;
-        return 0;
-}
-
-static struct snd_soc_platform_driver s6000_soc_platform = {
-        .ops =          &s6000_pcm_ops,
-        .pcm_new =      s6000_pcm_new,
-        .pcm_free =     s6000_pcm_free,
-};
-
-static int s6000_soc_platform_probe(struct platform_device *pdev)
-{
-        return snd_soc_register_platform(&pdev->dev, &s6000_soc_platform);
-}
-
-static int s6000_soc_platform_remove(struct platform_device *pdev)
-{
-        snd_soc_unregister_platform(&pdev->dev);
-        return 0;
-}
-
-static struct platform_driver s6000_pcm_driver = {
-        .driver = {
-                        .name = "s6000-pcm-audio",
-                        .owner = THIS_MODULE,
-        },
-
-        .probe = s6000_soc_platform_probe,
-        .remove = s6000_soc_platform_remove,
-};
-
-module_platform_driver(s6000_pcm_driver);
-
-MODULE_AUTHOR("Daniel Gloeckner");
-MODULE_DESCRIPTION("Stretch s6000 family PCM DMA module");
-MODULE_LICENSE("GPL");
diff --git a/sound/soc/s6000/s6000-pcm.h b/sound/soc/s6000/s6000-pcm.h
deleted file mode 100644
index 09d9b883e58b..000000000000
--- a/sound/soc/s6000/s6000-pcm.h
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * ALSA PCM interface for the Stretch s6000 family
- *
- * Author:      Daniel Gloeckner, <dg@emlix.com>
- * Copyright:   (C) 2009 emlix GmbH <info@emlix.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-#ifndef _S6000_PCM_H
-#define _S6000_PCM_H
-
-struct snd_soc_dai;
-struct snd_pcm_substream;
-
-struct s6000_pcm_dma_params {
-        unsigned int (*check_xrun)(struct snd_soc_dai *cpu_dai);
-        int (*trigger)(struct snd_pcm_substream *substream, int cmd, int after);
-        dma_addr_t sif_in;
-        dma_addr_t sif_out;
-        u32 dma_in;
-        u32 dma_out;
-        int irq;
-        int same_rate;
-
-        spinlock_t lock;
-        int in_use;
-        int rate;
-};
-
-#endif
diff --git a/sound/soc/s6000/s6105-ipcam.c b/sound/soc/s6000/s6105-ipcam.c
deleted file mode 100644
index 3510c01f8a6a..000000000000
--- a/sound/soc/s6000/s6105-ipcam.c
+++ /dev/null
@@ -1,221 +0,0 @@
-/*
- * ASoC driver for Stretch s6105 IP camera platform
- *
- * Author:      Daniel Gloeckner, <dg@emlix.com>
- * Copyright:   (C) 2009 emlix GmbH <info@emlix.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-#include <linux/module.h>
-#include <linux/moduleparam.h>
-#include <linux/timer.h>
-#include <linux/interrupt.h>
-#include <linux/platform_device.h>
-#include <linux/i2c.h>
-#include <sound/core.h>
-#include <sound/pcm.h>
-#include <sound/soc.h>
-
-#include "s6000-pcm.h"
-#include "s6000-i2s.h"
-
-#define S6105_CAM_CODEC_CLOCK 12288000
-
-static int s6105_hw_params(struct snd_pcm_substream *substream,
-                           struct snd_pcm_hw_params *params)
-{
-        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-        struct snd_soc_dai *codec_dai = rtd->codec_dai;
-        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
-        int ret = 0;
-
-        /* set codec DAI configuration */
-        ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_I2S |
-                                             SND_SOC_DAIFMT_CBM_CFM);
-        if (ret < 0)
-                return ret;
-
-        /* set cpu DAI configuration */
-        ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_CBM_CFM |
-                                           SND_SOC_DAIFMT_NB_NF);
-        if (ret < 0)
-                return ret;
-
-        /* set the codec system clock */
-        ret = snd_soc_dai_set_sysclk(codec_dai, 0, S6105_CAM_CODEC_CLOCK,
-                                            SND_SOC_CLOCK_OUT);
-        if (ret < 0)
-                return ret;
-
-        return 0;
-}
-
-static struct snd_soc_ops s6105_ops = {
-        .hw_params = s6105_hw_params,
-};
-
-/* s6105 machine dapm widgets */
-static const struct snd_soc_dapm_widget aic3x_dapm_widgets[] = {
-        SND_SOC_DAPM_LINE("Audio Out Differential", NULL),
-        SND_SOC_DAPM_LINE("Audio Out Stereo", NULL),
-        SND_SOC_DAPM_LINE("Audio In", NULL),
-};
-
-/* s6105 machine audio_mapnections to the codec pins */
-static const struct snd_soc_dapm_route audio_map[] = {
-        /* Audio Out connected to HPLOUT, HPLCOM, HPROUT */
-        {"Audio Out Differential", NULL, "HPLOUT"},
-        {"Audio Out Differential", NULL, "HPLCOM"},
-        {"Audio Out Stereo", NULL, "HPLOUT"},
-        {"Audio Out Stereo", NULL, "HPROUT"},
-
-        /* Audio In connected to LINE1L, LINE1R */
-        {"LINE1L", NULL, "Audio In"},
-        {"LINE1R", NULL, "Audio In"},
-};
-
-static int output_type_info(struct snd_kcontrol *kcontrol,
-                            struct snd_ctl_elem_info *uinfo)
-{
-        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
-        uinfo->count = 1;
-        uinfo->value.enumerated.items = 2;
-        if (uinfo->value.enumerated.item) {
-                uinfo->value.enumerated.item = 1;
-                strcpy(uinfo->value.enumerated.name, "HPLOUT/HPROUT");
-        } else {
-                strcpy(uinfo->value.enumerated.name, "HPLOUT/HPLCOM");
-        }
-        return 0;
-}
-
-static int output_type_get(struct snd_kcontrol *kcontrol,
-                           struct snd_ctl_elem_value *ucontrol)
-{
-        ucontrol->value.enumerated.item[0] = kcontrol->private_value;
-        return 0;
-}
-
-static int output_type_put(struct snd_kcontrol *kcontrol,
-                           struct snd_ctl_elem_value *ucontrol)
-{
-        struct snd_soc_card *card = kcontrol->private_data;
-        struct snd_soc_dapm_context *dapm = &card->dapm;
-        unsigned int val = (ucontrol->value.enumerated.item[0] != 0);
-        char *differential = "Audio Out Differential";
-        char *stereo = "Audio Out Stereo";
-
-        if (kcontrol->private_value == val)
-                return 0;
-        kcontrol->private_value = val;
-        snd_soc_dapm_disable_pin(dapm, val ? differential : stereo);
-        snd_soc_dapm_sync(dapm);
-        snd_soc_dapm_enable_pin(dapm, val ? stereo : differential);
-        snd_soc_dapm_sync(dapm);
-
-        return 1;
-}
-
-static const struct snd_kcontrol_new audio_out_mux = {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "Master Output Mux",
-        .index = 0,
-        .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
-        .info = output_type_info,
-        .get = output_type_get,
-        .put = output_type_put,
-        .private_value = 1 /* default to stereo */
-};
-
-/* Logic for a aic3x as connected on the s6105 ip camera ref design */
-static int s6105_aic3x_init(struct snd_soc_pcm_runtime *rtd)
-{
-        struct snd_soc_card *card = rtd->card;
-
-        /* must correspond to audio_out_mux.private_value initializer */
-        snd_soc_dapm_disable_pin(&card->dapm, "Audio Out Differential");
-
-        snd_ctl_add(card->snd_card, snd_ctl_new1(&audio_out_mux, card));
-
-        return 0;
-}
-
-/* s6105 digital audio interface glue - connects codec <--> CPU */
-static struct snd_soc_dai_link s6105_dai = {
-        .name = "TLV320AIC31",
-        .stream_name = "AIC31",
-        .cpu_dai_name = "s6000-i2s",
-        .codec_dai_name = "tlv320aic3x-hifi",
-        .platform_name = "s6000-pcm-audio",
-        .codec_name = "tlv320aic3x-codec.0-001a",
-        .init = s6105_aic3x_init,
-        .ops = &s6105_ops,
-};
-
-/* s6105 audio machine driver */
-static struct snd_soc_card snd_soc_card_s6105 = {
-        .name = "Stretch IP Camera",
-        .owner = THIS_MODULE,
-        .dai_link = &s6105_dai,
-        .num_links = 1,
-
-        .dapm_widgets = aic3x_dapm_widgets,
-        .num_dapm_widgets = ARRAY_SIZE(aic3x_dapm_widgets),
-        .dapm_routes = audio_map,
-        .num_dapm_routes = ARRAY_SIZE(audio_map),
-        .fully_routed = true,
-};
-
-static struct s6000_snd_platform_data s6105_snd_data __initdata = {
-        .wide           = 0,
-        .channel_in     = 0,
-        .channel_out    = 1,
-        .lines_in       = 1,
-        .lines_out      = 1,
-        .same_rate      = 1,
-};
-
-static struct platform_device *s6105_snd_device;
-
-/* temporary i2c device creation until this can be moved into the machine
- * support file.
-*/
-static struct i2c_board_info i2c_device[] = {
-        { I2C_BOARD_INFO("tlv320aic33", 0x18), }
-};
-
-static int __init s6105_init(void)
-{
-        int ret;
-
-        i2c_register_board_info(0, i2c_device, ARRAY_SIZE(i2c_device));
-
-        s6105_snd_device = platform_device_alloc("soc-audio", -1);
-        if (!s6105_snd_device)
-                return -ENOMEM;
-
-        platform_set_drvdata(s6105_snd_device, &snd_soc_card_s6105);
-        platform_device_add_data(s6105_snd_device, &s6105_snd_data,
-                                 sizeof(s6105_snd_data));
-
-        ret = platform_device_add(s6105_snd_device);
-        if (ret)
-                platform_device_put(s6105_snd_device);
-
-        return ret;
-}
-
-static void __exit s6105_exit(void)
-{
-        platform_device_unregister(s6105_snd_device);
-}
-
-module_init(s6105_init);
-module_exit(s6105_exit);
-
-MODULE_AUTHOR("Daniel Gloeckner");
-MODULE_DESCRIPTION("Stretch s6105 IP camera ASoC driver");
-MODULE_LICENSE("GPL");
diff --git a/sound/soc/samsung/snow.c b/sound/soc/samsung/snow.c
index 0acf5d0eed53..72118a77dd5b 100644
--- a/sound/soc/samsung/snow.c
+++ b/sound/soc/samsung/snow.c
@@ -110,6 +110,7 @@ static const struct of_device_id snow_of_match[] = {
         { .compatible = "google,snow-audio-max98095", },
         {},
 };
+MODULE_DEVICE_TABLE(of, snow_of_match);
 
 static struct platform_driver snow_driver = {
         .driver = {
diff --git a/sound/soc/sh/fsi.c b/sound/soc/sh/fsi.c
index 66fddec9543d..88e5df474ccf 100644
--- a/sound/soc/sh/fsi.c
+++ b/sound/soc/sh/fsi.c
@@ -1711,8 +1711,7 @@ static const struct snd_soc_dai_ops fsi_dai_ops = {
 static struct snd_pcm_hardware fsi_pcm_hardware = {
         .info =         SNDRV_PCM_INFO_INTERLEAVED      |
                         SNDRV_PCM_INFO_MMAP             |
-                        SNDRV_PCM_INFO_MMAP_VALID       |
-                        SNDRV_PCM_INFO_PAUSE,
+                        SNDRV_PCM_INFO_MMAP_VALID,
         .buffer_bytes_max       = 64 * 1024,
         .period_bytes_min       = 32,
         .period_bytes_max       = 8192,
diff --git a/sound/soc/sh/rcar/core.c b/sound/soc/sh/rcar/core.c
index 1922ec57d10a..70042197f9e2 100644
--- a/sound/soc/sh/rcar/core.c
+++ b/sound/soc/sh/rcar/core.c
@@ -886,8 +886,7 @@ static int rsnd_dai_probe(struct platform_device *pdev,
 static struct snd_pcm_hardware rsnd_pcm_hardware = {
         .info =         SNDRV_PCM_INFO_INTERLEAVED      |
                         SNDRV_PCM_INFO_MMAP             |
-                        SNDRV_PCM_INFO_MMAP_VALID       |
-                        SNDRV_PCM_INFO_PAUSE,
+                        SNDRV_PCM_INFO_MMAP_VALID,
         .buffer_bytes_max       = 64 * 1024,
         .period_bytes_min       = 32,
         .period_bytes_max       = 8192,
diff --git a/sound/soc/soc-cache.c b/sound/soc/soc-cache.c
index a9f82b5aba9d..07f43356f963 100644
--- a/sound/soc/soc-cache.c
+++ b/sound/soc/soc-cache.c
@@ -15,56 +15,6 @@
 #include <linux/export.h>
 #include <linux/slab.h>
 
-#include <trace/events/asoc.h>
-
-static bool snd_soc_set_cache_val(void *base, unsigned int idx,
-                                  unsigned int val, unsigned int word_size)
-{
-        switch (word_size) {
-        case 1: {
-                u8 *cache = base;
-                if (cache[idx] == val)
-                        return true;
-                cache[idx] = val;
-                break;
-        }
-        case 2: {
-                u16 *cache = base;
-                if (cache[idx] == val)
-                        return true;
-                cache[idx] = val;
-                break;
-        }
-        default:
-                WARN(1, "Invalid word_size %d\n", word_size);
-                break;
-        }
-        return false;
-}
-
-static unsigned int snd_soc_get_cache_val(const void *base, unsigned int idx,
-                unsigned int word_size)
-{
-        if (!base)
-                return -1;
-
-        switch (word_size) {
-        case 1: {
-                const u8 *cache = base;
-                return cache[idx];
-        }
-        case 2: {
-                const u16 *cache = base;
-                return cache[idx];
-        }
-        default:
-                WARN(1, "Invalid word_size %d\n", word_size);
-                break;
-        }
-        /* unreachable */
-        return -1;
-}
-
 int snd_soc_cache_init(struct snd_soc_codec *codec)
 {
         const struct snd_soc_codec_driver *codec_drv = codec->driver;
@@ -75,8 +25,6 @@ int snd_soc_cache_init(struct snd_soc_codec *codec)
         if (!reg_size)
                 return 0;
 
-        mutex_init(&codec->cache_rw_mutex);
-
         dev_dbg(codec->dev, "ASoC: Initializing cache for %s codec\n",
                                 codec->component.name);
 
@@ -103,100 +51,3 @@ int snd_soc_cache_exit(struct snd_soc_codec *codec)
         codec->reg_cache = NULL;
         return 0;
 }
-
-/**
- * snd_soc_cache_read: Fetch the value of a given register from the cache.
- *
- * @codec: CODEC to configure.
- * @reg: The register index.
- * @value: The value to be returned.
- */
-int snd_soc_cache_read(struct snd_soc_codec *codec,
-                       unsigned int reg, unsigned int *value)
-{
-        if (!value)
-                return -EINVAL;
-
-        mutex_lock(&codec->cache_rw_mutex);
-        if (!ZERO_OR_NULL_PTR(codec->reg_cache))
-                *value = snd_soc_get_cache_val(codec->reg_cache, reg,
-                                               codec->driver->reg_word_size);
-        mutex_unlock(&codec->cache_rw_mutex);
-
-        return 0;
-}
-EXPORT_SYMBOL_GPL(snd_soc_cache_read);
-
-/**
- * snd_soc_cache_write: Set the value of a given register in the cache.
- *
- * @codec: CODEC to configure.
- * @reg: The register index.
- * @value: The new register value.
- */
-int snd_soc_cache_write(struct snd_soc_codec *codec,
-                        unsigned int reg, unsigned int value)
-{
-        mutex_lock(&codec->cache_rw_mutex);
-        if (!ZERO_OR_NULL_PTR(codec->reg_cache))
-                snd_soc_set_cache_val(codec->reg_cache, reg, value,
-                                      codec->driver->reg_word_size);
-        mutex_unlock(&codec->cache_rw_mutex);
-
-        return 0;
-}
-EXPORT_SYMBOL_GPL(snd_soc_cache_write);
-
-static int snd_soc_flat_cache_sync(struct snd_soc_codec *codec)
-{
-        int i;
-        int ret;
-        const struct snd_soc_codec_driver *codec_drv;
-        unsigned int val;
-
-        codec_drv = codec->driver;
-        for (i = 0; i < codec_drv->reg_cache_size; ++i) {
-                ret = snd_soc_cache_read(codec, i, &val);
-                if (ret)
-                        return ret;
-                if (codec_drv->reg_cache_default)
-                        if (snd_soc_get_cache_val(codec_drv->reg_cache_default,
-                                                  i, codec_drv->reg_word_size) == val)
-                                continue;
-
-                ret = snd_soc_write(codec, i, val);
-                if (ret)
-                        return ret;
-                dev_dbg(codec->dev, "ASoC: Synced register %#x, value = %#x\n",
-                        i, val);
-        }
-        return 0;
-}
-
-/**
- * snd_soc_cache_sync: Sync the register cache with the hardware.
- *
- * @codec: CODEC to configure.
- *
- * Any registers that should not be synced should be marked as
- * volatile.  In general drivers can choose not to use the provided
- * syncing functionality if they so require.
- */
-int snd_soc_cache_sync(struct snd_soc_codec *codec)
-{
-        const char *name = "flat";
-        int ret;
-
-        if (!codec->cache_sync)
-                return 0;
-
-        dev_dbg(codec->dev, "ASoC: Syncing cache for %s codec\n",
-                codec->component.name);
-        trace_snd_soc_cache_sync(codec, name, "start");
-        ret = snd_soc_flat_cache_sync(codec);
-        if (!ret)
-                codec->cache_sync = 0;
-        trace_snd_soc_cache_sync(codec, name, "end");
-        return ret;
-}
-EXPORT_SYMBOL_GPL(snd_soc_cache_sync);
diff --git a/sound/soc/soc-core.c b/sound/soc/soc-core.c
index 1edc519d6286..e0d3b6f109c4 100644
--- a/sound/soc/soc-core.c
+++ b/sound/soc/soc-core.c
@@ -296,9 +296,6 @@ static void soc_init_codec_debugfs(struct snd_soc_component *component)
 {
         struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
 
-        debugfs_create_bool("cache_sync", 0444, codec->component.debugfs_root,
-                            &codec->cache_sync);
-
         codec->debugfs_reg = debugfs_create_file("codec_reg", 0644,
                                                  codec->component.debugfs_root,
                                                  codec, &codec_reg_fops);
@@ -545,17 +542,12 @@ int snd_soc_suspend(struct device *dev)
 
         for (i = 0; i < card->num_rtd; i++) {
                 struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
-                struct snd_soc_platform *platform = card->rtd[i].platform;
 
                 if (card->rtd[i].dai_link->ignore_suspend)
                         continue;
 
                 if (cpu_dai->driver->suspend && !cpu_dai->driver->bus_control)
                         cpu_dai->driver->suspend(cpu_dai);
-                if (platform->driver->suspend && !platform->suspended) {
-                        platform->driver->suspend(cpu_dai);
-                        platform->suspended = 1;
-                }
         }
 
         /* close any waiting streams and save state */
@@ -582,8 +574,8 @@ int snd_soc_suspend(struct device *dev)
                                           SND_SOC_DAPM_STREAM_SUSPEND);
         }
 
-        /* Recheck all analogue paths too */
-        dapm_mark_io_dirty(&card->dapm);
+        /* Recheck all endpoints too, their state is affected by suspend */
+        dapm_mark_endpoints_dirty(card);
         snd_soc_dapm_sync(&card->dapm);
 
         /* suspend all CODECs */
@@ -609,7 +601,6 @@ int snd_soc_suspend(struct device *dev)
                                 if (codec->driver->suspend)
                                         codec->driver->suspend(codec);
                                 codec->suspended = 1;
-                                codec->cache_sync = 1;
                                 if (codec->component.regmap)
                                         regcache_mark_dirty(codec->component.regmap);
                                 /* deactivate pins to sleep state */
@@ -728,17 +719,12 @@ static void soc_resume_deferred(struct work_struct *work)
 
         for (i = 0; i < card->num_rtd; i++) {
                 struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
-                struct snd_soc_platform *platform = card->rtd[i].platform;
 
                 if (card->rtd[i].dai_link->ignore_suspend)
                         continue;
 
                 if (cpu_dai->driver->resume && !cpu_dai->driver->bus_control)
                         cpu_dai->driver->resume(cpu_dai);
-                if (platform->driver->resume && platform->suspended) {
-                        platform->driver->resume(cpu_dai);
-                        platform->suspended = 0;
-                }
         }
 
         if (card->resume_post)
@@ -749,8 +735,8 @@ static void soc_resume_deferred(struct work_struct *work)
         /* userspace can access us now we are back as we were before */
         snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D0);
 
-        /* Recheck all analogue paths too */
-        dapm_mark_io_dirty(&card->dapm);
+        /* Recheck all endpoints too, their state is affected by suspend */
+        dapm_mark_endpoints_dirty(card);
         snd_soc_dapm_sync(&card->dapm);
 }
 
@@ -839,7 +825,7 @@ static struct snd_soc_dai *snd_soc_find_dai(
         list_for_each_entry(component, &component_list, list) {
                 if (dlc->of_node && component->dev->of_node != dlc->of_node)
                         continue;
-                if (dlc->name && strcmp(dev_name(component->dev), dlc->name))
+                if (dlc->name && strcmp(component->name, dlc->name))
                         continue;
                 list_for_each_entry(dai, &component->dai_list, list) {
                         if (dlc->dai_name && strcmp(dai->name, dlc->dai_name))
@@ -1206,25 +1192,22 @@ static int soc_probe_link_components(struct snd_soc_card *card, int num,
         return 0;
 }
 
-static int soc_probe_codec_dai(struct snd_soc_card *card,
-                               struct snd_soc_dai *codec_dai,
-                               int order)
+static int soc_probe_dai(struct snd_soc_dai *dai, int order)
 {
         int ret;
 
-        if (!codec_dai->probed && codec_dai->driver->probe_order == order) {
-                if (codec_dai->driver->probe) {
-                        ret = codec_dai->driver->probe(codec_dai);
+        if (!dai->probed && dai->driver->probe_order == order) {
+                if (dai->driver->probe) {
+                        ret = dai->driver->probe(dai);
                         if (ret < 0) {
-                                dev_err(codec_dai->dev,
-                                        "ASoC: failed to probe CODEC DAI %s: %d\n",
-                                        codec_dai->name, ret);
+                                dev_err(dai->dev,
+                                        "ASoC: failed to probe DAI %s: %d\n",
+                                        dai->name, ret);
                                 return ret;
                         }
                 }
 
-                /* mark codec_dai as probed and add to card dai list */
-                codec_dai->probed = 1;
+                dai->probed = 1;
         }
 
         return 0;
@@ -1274,40 +1257,22 @@ static int soc_probe_link_dais(struct snd_soc_card *card, int num, int order)
 {
         struct snd_soc_dai_link *dai_link = &card->dai_link[num];
         struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
-        struct snd_soc_platform *platform = rtd->platform;
         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
         int i, ret;
 
         dev_dbg(card->dev, "ASoC: probe %s dai link %d late %d\n",
                         card->name, num, order);
 
-        /* config components */
-        cpu_dai->platform = platform;
-        cpu_dai->card = card;
-        for (i = 0; i < rtd->num_codecs; i++)
-                rtd->codec_dais[i]->card = card;
-
         /* set default power off timeout */
         rtd->pmdown_time = pmdown_time;
 
-        /* probe the cpu_dai */
-        if (!cpu_dai->probed &&
-                        cpu_dai->driver->probe_order == order) {
-                if (cpu_dai->driver->probe) {
-                        ret = cpu_dai->driver->probe(cpu_dai);
-                        if (ret < 0) {
-                                dev_err(cpu_dai->dev,
-                                        "ASoC: failed to probe CPU DAI %s: %d\n",
-                                        cpu_dai->name, ret);
-                                return ret;
-                        }
-                }
-                cpu_dai->probed = 1;
-        }
+        ret = soc_probe_dai(cpu_dai, order);
+        if (ret)
+                return ret;
 
         /* probe the CODEC DAI */
         for (i = 0; i < rtd->num_codecs; i++) {
-                ret = soc_probe_codec_dai(card, rtd->codec_dais[i], order);
+                ret = soc_probe_dai(rtd->codec_dais[i], order);
                 if (ret)
                         return ret;
         }
@@ -1982,7 +1947,7 @@ EXPORT_SYMBOL_GPL(snd_soc_add_card_controls);
 int snd_soc_add_dai_controls(struct snd_soc_dai *dai,
         const struct snd_kcontrol_new *controls, int num_controls)
 {
-        struct snd_card *card = dai->card->snd_card;
+        struct snd_card *card = dai->component->card->snd_card;
 
         return snd_soc_add_controls(card, dai->dev, controls, num_controls,
                         NULL, dai);
@@ -1990,1020 +1955,6 @@ int snd_soc_add_dai_controls(struct snd_soc_dai *dai,
 EXPORT_SYMBOL_GPL(snd_soc_add_dai_controls);
 
 /**
- * snd_soc_info_enum_double - enumerated double mixer info callback
- * @kcontrol: mixer control
- * @uinfo: control element information
- *
- * Callback to provide information about a double enumerated
- * mixer control.
- *
- * Returns 0 for success.
- */
-int snd_soc_info_enum_double(struct snd_kcontrol *kcontrol,
-        struct snd_ctl_elem_info *uinfo)
-{
-        struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
-
-        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
-        uinfo->count = e->shift_l == e->shift_r ? 1 : 2;
-        uinfo->value.enumerated.items = e->items;
-
-        if (uinfo->value.enumerated.item >= e->items)
-                uinfo->value.enumerated.item = e->items - 1;
-        strlcpy(uinfo->value.enumerated.name,
-                e->texts[uinfo->value.enumerated.item],
-                sizeof(uinfo->value.enumerated.name));
-        return 0;
-}
-EXPORT_SYMBOL_GPL(snd_soc_info_enum_double);
-
-/**
- * snd_soc_get_enum_double - enumerated double mixer get callback
- * @kcontrol: mixer control
- * @ucontrol: control element information
- *
- * Callback to get the value of a double enumerated mixer.
- *
- * Returns 0 for success.
- */
-int snd_soc_get_enum_double(struct snd_kcontrol *kcontrol,
-        struct snd_ctl_elem_value *ucontrol)
-{
-        struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
-        struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
-        unsigned int val, item;
-        unsigned int reg_val;
-        int ret;
-
-        ret = snd_soc_component_read(component, e->reg, &reg_val);
-        if (ret)
-                return ret;
-        val = (reg_val >> e->shift_l) & e->mask;
-        item = snd_soc_enum_val_to_item(e, val);
-        ucontrol->value.enumerated.item[0] = item;
-        if (e->shift_l != e->shift_r) {
-                val = (reg_val >> e->shift_l) & e->mask;
-                item = snd_soc_enum_val_to_item(e, val);
-                ucontrol->value.enumerated.item[1] = item;
-        }
-
-        return 0;
-}
-EXPORT_SYMBOL_GPL(snd_soc_get_enum_double);
-
-/**
- * snd_soc_put_enum_double - enumerated double mixer put callback
- * @kcontrol: mixer control
- * @ucontrol: control element information
- *
- * Callback to set the value of a double enumerated mixer.
- *
- * Returns 0 for success.
- */
-int snd_soc_put_enum_double(struct snd_kcontrol *kcontrol,
-        struct snd_ctl_elem_value *ucontrol)
-{
-        struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
-        struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
-        unsigned int *item = ucontrol->value.enumerated.item;
-        unsigned int val;
-        unsigned int mask;
-
-        if (item[0] >= e->items)
-                return -EINVAL;
-        val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l;
-        mask = e->mask << e->shift_l;
-        if (e->shift_l != e->shift_r) {
-                if (item[1] >= e->items)
-                        return -EINVAL;
-                val |= snd_soc_enum_item_to_val(e, item[1]) << e->shift_r;
-                mask |= e->mask << e->shift_r;
-        }
-
-        return snd_soc_component_update_bits(component, e->reg, mask, val);
-}
-EXPORT_SYMBOL_GPL(snd_soc_put_enum_double);
-
-/**
- * snd_soc_read_signed - Read a codec register and interprete as signed value
- * @component: component
- * @reg: Register to read
- * @mask: Mask to use after shifting the register value
- * @shift: Right shift of register value
- * @sign_bit: Bit that describes if a number is negative or not.
- * @signed_val: Pointer to where the read value should be stored
- *
- * This functions reads a codec register. The register value is shifted right
- * by 'shift' bits and masked with the given 'mask'. Afterwards it translates
- * the given registervalue into a signed integer if sign_bit is non-zero.
- *
- * Returns 0 on sucess, otherwise an error value
- */
-static int snd_soc_read_signed(struct snd_soc_component *component,
-        unsigned int reg, unsigned int mask, unsigned int shift,
-        unsigned int sign_bit, int *signed_val)
-{
-        int ret;
-        unsigned int val;
-
-        ret = snd_soc_component_read(component, reg, &val);
-        if (ret < 0)
-                return ret;
-
-        val = (val >> shift) & mask;
-
-        if (!sign_bit) {
-                *signed_val = val;
-                return 0;
-        }
-
-        /* non-negative number */
-        if (!(val & BIT(sign_bit))) {
-                *signed_val = val;
-                return 0;
-        }
-
-        ret = val;
-
-        /*
-         * The register most probably does not contain a full-sized int.
-         * Instead we have an arbitrary number of bits in a signed
-         * representation which has to be translated into a full-sized int.
-         * This is done by filling up all bits above the sign-bit.
-         */
-        ret |= ~((int)(BIT(sign_bit) - 1));
-
-        *signed_val = ret;
-
-        return 0;
-}
-
-/**
- * snd_soc_info_volsw - single mixer info callback
- * @kcontrol: mixer control
- * @uinfo: control element information
- *
- * Callback to provide information about a single mixer control, or a double
- * mixer control that spans 2 registers.
- *
- * Returns 0 for success.
- */
-int snd_soc_info_volsw(struct snd_kcontrol *kcontrol,
-        struct snd_ctl_elem_info *uinfo)
-{
-        struct soc_mixer_control *mc =
-                (struct soc_mixer_control *)kcontrol->private_value;
-        int platform_max;
-
-        if (!mc->platform_max)
-                mc->platform_max = mc->max;
-        platform_max = mc->platform_max;
-
-        if (platform_max == 1 && !strstr(kcontrol->id.name, " Volume"))
-                uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
-        else
-                uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
-
-        uinfo->count = snd_soc_volsw_is_stereo(mc) ? 2 : 1;
-        uinfo->value.integer.min = 0;
-        uinfo->value.integer.max = platform_max - mc->min;
-        return 0;
-}
-EXPORT_SYMBOL_GPL(snd_soc_info_volsw);
-
-/**
- * snd_soc_get_volsw - single mixer get callback
- * @kcontrol: mixer control
- * @ucontrol: control element information
- *
- * Callback to get the value of a single mixer control, or a double mixer
- * control that spans 2 registers.
- *
- * Returns 0 for success.
- */
-int snd_soc_get_volsw(struct snd_kcontrol *kcontrol,
-        struct snd_ctl_elem_value *ucontrol)
-{
-        struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
-        struct soc_mixer_control *mc =
-                (struct soc_mixer_control *)kcontrol->private_value;
-        unsigned int reg = mc->reg;
-        unsigned int reg2 = mc->rreg;
-        unsigned int shift = mc->shift;
-        unsigned int rshift = mc->rshift;
-        int max = mc->max;
-        int min = mc->min;
-        int sign_bit = mc->sign_bit;
-        unsigned int mask = (1 << fls(max)) - 1;
-        unsigned int invert = mc->invert;
-        int val;
-        int ret;
-
-        if (sign_bit)
-                mask = BIT(sign_bit + 1) - 1;
-
-        ret = snd_soc_read_signed(component, reg, mask, shift, sign_bit, &val);
-        if (ret)
-                return ret;
-
-        ucontrol->value.integer.value[0] = val - min;
-        if (invert)
-                ucontrol->value.integer.value[0] =
-                        max - ucontrol->value.integer.value[0];
-
-        if (snd_soc_volsw_is_stereo(mc)) {
-                if (reg == reg2)
-                        ret = snd_soc_read_signed(component, reg, mask, rshift,
-                                sign_bit, &val);
-                else
-                        ret = snd_soc_read_signed(component, reg2, mask, shift,
-                                sign_bit, &val);
-                if (ret)
-                        return ret;
-
-                ucontrol->value.integer.value[1] = val - min;
-                if (invert)
-                        ucontrol->value.integer.value[1] =
-                                max - ucontrol->value.integer.value[1];
-        }
-
-        return 0;
-}
-EXPORT_SYMBOL_GPL(snd_soc_get_volsw);
-
-/**
- * snd_soc_put_volsw - single mixer put callback
- * @kcontrol: mixer control
- * @ucontrol: control element information
- *
- * Callback to set the value of a single mixer control, or a double mixer
- * control that spans 2 registers.
- *
- * Returns 0 for success.
- */
-int snd_soc_put_volsw(struct snd_kcontrol *kcontrol,
-        struct snd_ctl_elem_value *ucontrol)
-{
-        struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
-        struct soc_mixer_control *mc =
-                (struct soc_mixer_control *)kcontrol->private_value;
-        unsigned int reg = mc->reg;
-        unsigned int reg2 = mc->rreg;
-        unsigned int shift = mc->shift;
-        unsigned int rshift = mc->rshift;
-        int max = mc->max;
-        int min = mc->min;
-        unsigned int sign_bit = mc->sign_bit;
-        unsigned int mask = (1 << fls(max)) - 1;
-        unsigned int invert = mc->invert;
-        int err;
-        bool type_2r = false;
-        unsigned int val2 = 0;
-        unsigned int val, val_mask;
-
-        if (sign_bit)
-                mask = BIT(sign_bit + 1) - 1;
-
-        val = ((ucontrol->value.integer.value[0] + min) & mask);
-        if (invert)
-                val = max - val;
-        val_mask = mask << shift;
-        val = val << shift;
-        if (snd_soc_volsw_is_stereo(mc)) {
-                val2 = ((ucontrol->value.integer.value[1] + min) & mask);
-                if (invert)
-                        val2 = max - val2;
-                if (reg == reg2) {
-                        val_mask |= mask << rshift;
-                        val |= val2 << rshift;
-                } else {
-                        val2 = val2 << shift;
-                        type_2r = true;
-                }
-        }
-        err = snd_soc_component_update_bits(component, reg, val_mask, val);
-        if (err < 0)
-                return err;
-
-        if (type_2r)
-                err = snd_soc_component_update_bits(component, reg2, val_mask,
-                        val2);
-
-        return err;
-}
-EXPORT_SYMBOL_GPL(snd_soc_put_volsw);
-
-/**
- * snd_soc_get_volsw_sx - single mixer get callback
- * @kcontrol: mixer control
- * @ucontrol: control element information
- *
- * Callback to get the value of a single mixer control, or a double mixer
- * control that spans 2 registers.
- *
- * Returns 0 for success.
- */
-int snd_soc_get_volsw_sx(struct snd_kcontrol *kcontrol,
-                      struct snd_ctl_elem_value *ucontrol)
-{
-        struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
-        struct soc_mixer_control *mc =
-            (struct soc_mixer_control *)kcontrol->private_value;
-        unsigned int reg = mc->reg;
-        unsigned int reg2 = mc->rreg;
-        unsigned int shift = mc->shift;
-        unsigned int rshift = mc->rshift;
-        int max = mc->max;
-        int min = mc->min;
-        int mask = (1 << (fls(min + max) - 1)) - 1;
-        unsigned int val;
-        int ret;
-
-        ret = snd_soc_component_read(component, reg, &val);
-        if (ret < 0)
-                return ret;
-
-        ucontrol->value.integer.value[0] = ((val >> shift) - min) & mask;
-
-        if (snd_soc_volsw_is_stereo(mc)) {
-                ret = snd_soc_component_read(component, reg2, &val);
-                if (ret < 0)
-                        return ret;
-
-                val = ((val >> rshift) - min) & mask;
-                ucontrol->value.integer.value[1] = val;
-        }
-
-        return 0;
-}
-EXPORT_SYMBOL_GPL(snd_soc_get_volsw_sx);
-
-/**
- * snd_soc_put_volsw_sx - double mixer set callback
- * @kcontrol: mixer control
- * @uinfo: control element information
- *
- * Callback to set the value of a double mixer control that spans 2 registers.
- *
- * Returns 0 for success.
- */
-int snd_soc_put_volsw_sx(struct snd_kcontrol *kcontrol,
-                         struct snd_ctl_elem_value *ucontrol)
-{
-        struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
-        struct soc_mixer_control *mc =
-            (struct soc_mixer_control *)kcontrol->private_value;
-
-        unsigned int reg = mc->reg;
-        unsigned int reg2 = mc->rreg;
-        unsigned int shift = mc->shift;
-        unsigned int rshift = mc->rshift;
-        int max = mc->max;
-        int min = mc->min;
-        int mask = (1 << (fls(min + max) - 1)) - 1;
-        int err = 0;
-        unsigned int val, val_mask, val2 = 0;
-
-        val_mask = mask << shift;
-        val = (ucontrol->value.integer.value[0] + min) & mask;
-        val = val << shift;
-
-        err = snd_soc_component_update_bits(component, reg, val_mask, val);
-        if (err < 0)
-                return err;
-
-        if (snd_soc_volsw_is_stereo(mc)) {
-                val_mask = mask << rshift;
-                val2 = (ucontrol->value.integer.value[1] + min) & mask;
-                val2 = val2 << rshift;
-
-                err = snd_soc_component_update_bits(component, reg2, val_mask,
-                        val2);
-        }
-        return err;
-}
-EXPORT_SYMBOL_GPL(snd_soc_put_volsw_sx);
-
-/**
- * snd_soc_info_volsw_s8 - signed mixer info callback
- * @kcontrol: mixer control
- * @uinfo: control element information
- *
- * Callback to provide information about a signed mixer control.
- *
- * Returns 0 for success.
- */
-int snd_soc_info_volsw_s8(struct snd_kcontrol *kcontrol,
-        struct snd_ctl_elem_info *uinfo)
-{
-        struct soc_mixer_control *mc =
-                (struct soc_mixer_control *)kcontrol->private_value;
-        int platform_max;
-        int min = mc->min;
-
-        if (!mc->platform_max)
-                mc->platform_max = mc->max;
-        platform_max = mc->platform_max;
-
-        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
-        uinfo->count = 2;
-        uinfo->value.integer.min = 0;
-        uinfo->value.integer.max = platform_max - min;
-        return 0;
-}
-EXPORT_SYMBOL_GPL(snd_soc_info_volsw_s8);
-
-/**
- * snd_soc_get_volsw_s8 - signed mixer get callback
- * @kcontrol: mixer control
- * @ucontrol: control element information
- *
- * Callback to get the value of a signed mixer control.
- *
- * Returns 0 for success.
- */
-int snd_soc_get_volsw_s8(struct snd_kcontrol *kcontrol,
-        struct snd_ctl_elem_value *ucontrol)
-{
-        struct soc_mixer_control *mc =
-                (struct soc_mixer_control *)kcontrol->private_value;
-        struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
-        unsigned int reg = mc->reg;
-        unsigned int val;
-        int min = mc->min;
-        int ret;
-
-        ret = snd_soc_component_read(component, reg, &val);
-        if (ret)
-                return ret;
-
-        ucontrol->value.integer.value[0] =
-                ((signed char)(val & 0xff))-min;
-        ucontrol->value.integer.value[1] =
-                ((signed char)((val >> 8) & 0xff))-min;
-        return 0;
-}
-EXPORT_SYMBOL_GPL(snd_soc_get_volsw_s8);
-
-/**
- * snd_soc_put_volsw_sgn - signed mixer put callback
- * @kcontrol: mixer control
- * @ucontrol: control element information
- *
- * Callback to set the value of a signed mixer control.
- *
- * Returns 0 for success.
- */
-int snd_soc_put_volsw_s8(struct snd_kcontrol *kcontrol,
-        struct snd_ctl_elem_value *ucontrol)
-{
-        struct soc_mixer_control *mc =
-                (struct soc_mixer_control *)kcontrol->private_value;
-        struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
-        unsigned int reg = mc->reg;
-        int min = mc->min;
-        unsigned int val;
-
-        val = (ucontrol->value.integer.value[0]+min) & 0xff;
-        val |= ((ucontrol->value.integer.value[1]+min) & 0xff) << 8;
-
-        return snd_soc_component_update_bits(component, reg, 0xffff, val);
-}
-EXPORT_SYMBOL_GPL(snd_soc_put_volsw_s8);
-
-/**
- * snd_soc_info_volsw_range - single mixer info callback with range.
- * @kcontrol: mixer control
- * @uinfo: control element information
- *
- * Callback to provide information, within a range, about a single
- * mixer control.
- *
- * returns 0 for success.
- */
-int snd_soc_info_volsw_range(struct snd_kcontrol *kcontrol,
-        struct snd_ctl_elem_info *uinfo)
-{
-        struct soc_mixer_control *mc =
-                (struct soc_mixer_control *)kcontrol->private_value;
-        int platform_max;
-        int min = mc->min;
-
-        if (!mc->platform_max)
-                mc->platform_max = mc->max;
-        platform_max = mc->platform_max;
-
-        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
-        uinfo->count = snd_soc_volsw_is_stereo(mc) ? 2 : 1;
-        uinfo->value.integer.min = 0;
-        uinfo->value.integer.max = platform_max - min;
-
-        return 0;
-}
-EXPORT_SYMBOL_GPL(snd_soc_info_volsw_range);
-
-/**
- * snd_soc_put_volsw_range - single mixer put value callback with range.
- * @kcontrol: mixer control
- * @ucontrol: control element information
- *
- * Callback to set the value, within a range, for a single mixer control.
- *
- * Returns 0 for success.
- */
-int snd_soc_put_volsw_range(struct snd_kcontrol *kcontrol,
-        struct snd_ctl_elem_value *ucontrol)
-{
-        struct soc_mixer_control *mc =
-                (struct soc_mixer_control *)kcontrol->private_value;
-        struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
-        unsigned int reg = mc->reg;
-        unsigned int rreg = mc->rreg;
-        unsigned int shift = mc->shift;
-        int min = mc->min;
-        int max = mc->max;
-        unsigned int mask = (1 << fls(max)) - 1;
-        unsigned int invert = mc->invert;
-        unsigned int val, val_mask;
-        int ret;
-
-        if (invert)
-                val = (max - ucontrol->value.integer.value[0]) & mask;
-        else
-                val = ((ucontrol->value.integer.value[0] + min) & mask);
-        val_mask = mask << shift;
-        val = val << shift;
-
-        ret = snd_soc_component_update_bits(component, reg, val_mask, val);
-        if (ret < 0)
-                return ret;
-
-        if (snd_soc_volsw_is_stereo(mc)) {
-                if (invert)
-                        val = (max - ucontrol->value.integer.value[1]) & mask;
-                else
-                        val = ((ucontrol->value.integer.value[1] + min) & mask);
-                val_mask = mask << shift;
-                val = val << shift;
-
-                ret = snd_soc_component_update_bits(component, rreg, val_mask,
-                        val);
-        }
-
-        return ret;
-}
-EXPORT_SYMBOL_GPL(snd_soc_put_volsw_range);
-
-/**
- * snd_soc_get_volsw_range - single mixer get callback with range
- * @kcontrol: mixer control
- * @ucontrol: control element information
- *
- * Callback to get the value, within a range, of a single mixer control.
- *
- * Returns 0 for success.
- */
-int snd_soc_get_volsw_range(struct snd_kcontrol *kcontrol,
-        struct snd_ctl_elem_value *ucontrol)
-{
-        struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
-        struct soc_mixer_control *mc =
-                (struct soc_mixer_control *)kcontrol->private_value;
-        unsigned int reg = mc->reg;
-        unsigned int rreg = mc->rreg;
-        unsigned int shift = mc->shift;
-        int min = mc->min;
-        int max = mc->max;
-        unsigned int mask = (1 << fls(max)) - 1;
-        unsigned int invert = mc->invert;
-        unsigned int val;
-        int ret;
-
-        ret = snd_soc_component_read(component, reg, &val);
-        if (ret)
-                return ret;
-
-        ucontrol->value.integer.value[0] = (val >> shift) & mask;
-        if (invert)
-                ucontrol->value.integer.value[0] =
-                        max - ucontrol->value.integer.value[0];
-        else
-                ucontrol->value.integer.value[0] =
-                        ucontrol->value.integer.value[0] - min;
-
-        if (snd_soc_volsw_is_stereo(mc)) {
-                ret = snd_soc_component_read(component, rreg, &val);
-                if (ret)
-                        return ret;
-
-                ucontrol->value.integer.value[1] = (val >> shift) & mask;
-                if (invert)
-                        ucontrol->value.integer.value[1] =
-                                max - ucontrol->value.integer.value[1];
-                else
-                        ucontrol->value.integer.value[1] =
-                                ucontrol->value.integer.value[1] - min;
-        }
-
-        return 0;
-}
-EXPORT_SYMBOL_GPL(snd_soc_get_volsw_range);
-
-/**
- * snd_soc_limit_volume - Set new limit to an existing volume control.
- *
- * @codec: where to look for the control
- * @name: Name of the control
- * @max: new maximum limit
- *
- * Return 0 for success, else error.
- */
-int snd_soc_limit_volume(struct snd_soc_codec *codec,
-        const char *name, int max)
-{
-        struct snd_card *card = codec->component.card->snd_card;
-        struct snd_kcontrol *kctl;
-        struct soc_mixer_control *mc;
-        int found = 0;
-        int ret = -EINVAL;
-
-        /* Sanity check for name and max */
-        if (unlikely(!name || max <= 0))
-                return -EINVAL;
-
-        list_for_each_entry(kctl, &card->controls, list) {
-                if (!strncmp(kctl->id.name, name, sizeof(kctl->id.name))) {
-                        found = 1;
-                        break;
-                }
-        }
-        if (found) {
-                mc = (struct soc_mixer_control *)kctl->private_value;
-                if (max <= mc->max) {
-                        mc->platform_max = max;
-                        ret = 0;
-                }
-        }
-        return ret;
-}
-EXPORT_SYMBOL_GPL(snd_soc_limit_volume);
-
-int snd_soc_bytes_info(struct snd_kcontrol *kcontrol,
-                       struct snd_ctl_elem_info *uinfo)
-{
-        struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
-        struct soc_bytes *params = (void *)kcontrol->private_value;
-
-        uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES;
-        uinfo->count = params->num_regs * component->val_bytes;
-
-        return 0;
-}
-EXPORT_SYMBOL_GPL(snd_soc_bytes_info);
-
-int snd_soc_bytes_get(struct snd_kcontrol *kcontrol,
-                      struct snd_ctl_elem_value *ucontrol)
-{
-        struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
-        struct soc_bytes *params = (void *)kcontrol->private_value;
-        int ret;
-
-        if (component->regmap)
-                ret = regmap_raw_read(component->regmap, params->base,
-                                      ucontrol->value.bytes.data,
-                                      params->num_regs * component->val_bytes);
-        else
-                ret = -EINVAL;
-
-        /* Hide any masked bytes to ensure consistent data reporting */
-        if (ret == 0 && params->mask) {
-                switch (component->val_bytes) {
-                case 1:
-                        ucontrol->value.bytes.data[0] &= ~params->mask;
-                        break;
-                case 2:
-                        ((u16 *)(&ucontrol->value.bytes.data))[0]
-                                &= cpu_to_be16(~params->mask);
-                        break;
-                case 4:
-                        ((u32 *)(&ucontrol->value.bytes.data))[0]
-                                &= cpu_to_be32(~params->mask);
-                        break;
-                default:
-                        return -EINVAL;
-                }
-        }
-
-        return ret;
-}
-EXPORT_SYMBOL_GPL(snd_soc_bytes_get);
-
-int snd_soc_bytes_put(struct snd_kcontrol *kcontrol,
-                      struct snd_ctl_elem_value *ucontrol)
-{
-        struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
-        struct soc_bytes *params = (void *)kcontrol->private_value;
-        int ret, len;
-        unsigned int val, mask;
-        void *data;
-
-        if (!component->regmap || !params->num_regs)
-                return -EINVAL;
-
-        len = params->num_regs * component->val_bytes;
-
-        data = kmemdup(ucontrol->value.bytes.data, len, GFP_KERNEL | GFP_DMA);
-        if (!data)
-                return -ENOMEM;
-
-        /*
-         * If we've got a mask then we need to preserve the register
-         * bits.  We shouldn't modify the incoming data so take a
-         * copy.
-         */
-        if (params->mask) {
-                ret = regmap_read(component->regmap, params->base, &val);
-                if (ret != 0)
-                        goto out;
-
-                val &= params->mask;
-
-                switch (component->val_bytes) {
-                case 1:
-                        ((u8 *)data)[0] &= ~params->mask;
-                        ((u8 *)data)[0] |= val;
-                        break;
-                case 2:
-                        mask = ~params->mask;
-                        ret = regmap_parse_val(component->regmap,
-                                                        &mask, &mask);
-                        if (ret != 0)
-                                goto out;
-
-                        ((u16 *)data)[0] &= mask;
-
-                        ret = regmap_parse_val(component->regmap,
-                                                        &val, &val);
-                        if (ret != 0)
-                                goto out;
-
-                        ((u16 *)data)[0] |= val;
-                        break;
-                case 4:
-                        mask = ~params->mask;
-                        ret = regmap_parse_val(component->regmap,
-                                                        &mask, &mask);
-                        if (ret != 0)
-                                goto out;
-
-                        ((u32 *)data)[0] &= mask;
-
-                        ret = regmap_parse_val(component->regmap,
-                                                        &val, &val);
-                        if (ret != 0)
-                                goto out;
-
-                        ((u32 *)data)[0] |= val;
-                        break;
-                default:
-                        ret = -EINVAL;
-                        goto out;
-                }
-        }
-
-        ret = regmap_raw_write(component->regmap, params->base,
-                               data, len);
-
-out:
-        kfree(data);
-
-        return ret;
-}
-EXPORT_SYMBOL_GPL(snd_soc_bytes_put);
-
-int snd_soc_bytes_info_ext(struct snd_kcontrol *kcontrol,
-                        struct snd_ctl_elem_info *ucontrol)
-{
-        struct soc_bytes_ext *params = (void *)kcontrol->private_value;
-
-        ucontrol->type = SNDRV_CTL_ELEM_TYPE_BYTES;
-        ucontrol->count = params->max;
-
-        return 0;
-}
-EXPORT_SYMBOL_GPL(snd_soc_bytes_info_ext);
-
-int snd_soc_bytes_tlv_callback(struct snd_kcontrol *kcontrol, int op_flag,
-                                unsigned int size, unsigned int __user *tlv)
-{
-        struct soc_bytes_ext *params = (void *)kcontrol->private_value;
-        unsigned int count = size < params->max ? size : params->max;
-        int ret = -ENXIO;
-
-        switch (op_flag) {
-        case SNDRV_CTL_TLV_OP_READ:
-                if (params->get)
-                        ret = params->get(tlv, count);
-                break;
-        case SNDRV_CTL_TLV_OP_WRITE:
-                if (params->put)
-                        ret = params->put(tlv, count);
-                break;
-        }
-        return ret;
-}
-EXPORT_SYMBOL_GPL(snd_soc_bytes_tlv_callback);
-
-/**
- * snd_soc_info_xr_sx - signed multi register info callback
- * @kcontrol: mreg control
- * @uinfo: control element information
- *
- * Callback to provide information of a control that can
- * span multiple codec registers which together
- * forms a single signed value in a MSB/LSB manner.
- *
- * Returns 0 for success.
- */
-int snd_soc_info_xr_sx(struct snd_kcontrol *kcontrol,
-        struct snd_ctl_elem_info *uinfo)
-{
-        struct soc_mreg_control *mc =
-                (struct soc_mreg_control *)kcontrol->private_value;
-        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
-        uinfo->count = 1;
-        uinfo->value.integer.min = mc->min;
-        uinfo->value.integer.max = mc->max;
-
-        return 0;
-}
-EXPORT_SYMBOL_GPL(snd_soc_info_xr_sx);
-
-/**
- * snd_soc_get_xr_sx - signed multi register get callback
- * @kcontrol: mreg control
- * @ucontrol: control element information
- *
- * Callback to get the value of a control that can span
- * multiple codec registers which together forms a single
- * signed value in a MSB/LSB manner. The control supports
- * specifying total no of bits used to allow for bitfields
- * across the multiple codec registers.
- *
- * Returns 0 for success.
- */
-int snd_soc_get_xr_sx(struct snd_kcontrol *kcontrol,
-        struct snd_ctl_elem_value *ucontrol)
-{
-        struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
-        struct soc_mreg_control *mc =
-                (struct soc_mreg_control *)kcontrol->private_value;
-        unsigned int regbase = mc->regbase;
-        unsigned int regcount = mc->regcount;
-        unsigned int regwshift = component->val_bytes * BITS_PER_BYTE;
-        unsigned int regwmask = (1<<regwshift)-1;
-        unsigned int invert = mc->invert;
-        unsigned long mask = (1UL<<mc->nbits)-1;
-        long min = mc->min;
-        long max = mc->max;
-        long val = 0;
-        unsigned int regval;
-        unsigned int i;
-        int ret;
-
-        for (i = 0; i < regcount; i++) {
-                ret = snd_soc_component_read(component, regbase+i, &regval);
-                if (ret)
-                        return ret;
-                val |= (regval & regwmask) << (regwshift*(regcount-i-1));
-        }
-        val &= mask;
-        if (min < 0 && val > max)
-                val |= ~mask;
-        if (invert)
-                val = max - val;
-        ucontrol->value.integer.value[0] = val;
-
-        return 0;
-}
-EXPORT_SYMBOL_GPL(snd_soc_get_xr_sx);
-
-/**
- * snd_soc_put_xr_sx - signed multi register get callback
- * @kcontrol: mreg control
- * @ucontrol: control element information
- *
- * Callback to set the value of a control that can span
- * multiple codec registers which together forms a single
- * signed value in a MSB/LSB manner. The control supports
- * specifying total no of bits used to allow for bitfields
- * across the multiple codec registers.
- *
- * Returns 0 for success.
- */
-int snd_soc_put_xr_sx(struct snd_kcontrol *kcontrol,
-        struct snd_ctl_elem_value *ucontrol)
-{
-        struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
-        struct soc_mreg_control *mc =
-                (struct soc_mreg_control *)kcontrol->private_value;
-        unsigned int regbase = mc->regbase;
-        unsigned int regcount = mc->regcount;
-        unsigned int regwshift = component->val_bytes * BITS_PER_BYTE;
-        unsigned int regwmask = (1<<regwshift)-1;
-        unsigned int invert = mc->invert;
-        unsigned long mask = (1UL<<mc->nbits)-1;
-        long max = mc->max;
-        long val = ucontrol->value.integer.value[0];
-        unsigned int i, regval, regmask;
-        int err;
-
-        if (invert)
-                val = max - val;
-        val &= mask;
-        for (i = 0; i < regcount; i++) {
-                regval = (val >> (regwshift*(regcount-i-1))) & regwmask;
-                regmask = (mask >> (regwshift*(regcount-i-1))) & regwmask;
-                err = snd_soc_component_update_bits(component, regbase+i,
-                                regmask, regval);
-                if (err < 0)
-                        return err;
-        }
-
-        return 0;
-}
-EXPORT_SYMBOL_GPL(snd_soc_put_xr_sx);
-
-/**
- * snd_soc_get_strobe - strobe get callback
- * @kcontrol: mixer control
- * @ucontrol: control element information
- *
- * Callback get the value of a strobe mixer control.
- *
- * Returns 0 for success.
- */
-int snd_soc_get_strobe(struct snd_kcontrol *kcontrol,
-        struct snd_ctl_elem_value *ucontrol)
-{
-        struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
-        struct soc_mixer_control *mc =
-                (struct soc_mixer_control *)kcontrol->private_value;
-        unsigned int reg = mc->reg;
-        unsigned int shift = mc->shift;
-        unsigned int mask = 1 << shift;
-        unsigned int invert = mc->invert != 0;
-        unsigned int val;
-        int ret;
-
-        ret = snd_soc_component_read(component, reg, &val);
-        if (ret)
-                return ret;
-
-        val &= mask;
-
-        if (shift != 0 && val != 0)
-                val = val >> shift;
-        ucontrol->value.enumerated.item[0] = val ^ invert;
-
-        return 0;
-}
-EXPORT_SYMBOL_GPL(snd_soc_get_strobe);
-
-/**
- * snd_soc_put_strobe - strobe put callback
- * @kcontrol: mixer control
- * @ucontrol: control element information
- *
- * Callback strobe a register bit to high then low (or the inverse)
- * in one pass of a single mixer enum control.
- *
- * Returns 1 for success.
- */
-int snd_soc_put_strobe(struct snd_kcontrol *kcontrol,
-        struct snd_ctl_elem_value *ucontrol)
-{
-        struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
-        struct soc_mixer_control *mc =
-                (struct soc_mixer_control *)kcontrol->private_value;
-        unsigned int reg = mc->reg;
-        unsigned int shift = mc->shift;
-        unsigned int mask = 1 << shift;
-        unsigned int invert = mc->invert != 0;
-        unsigned int strobe = ucontrol->value.enumerated.item[0] != 0;
-        unsigned int val1 = (strobe ^ invert) ? mask : 0;
-        unsigned int val2 = (strobe ^ invert) ? 0 : mask;
-        int err;
-
-        err = snd_soc_component_update_bits(component, reg, mask, val1);
-        if (err < 0)
-                return err;
-
-        return snd_soc_component_update_bits(component, reg, mask, val2);
-}
-EXPORT_SYMBOL_GPL(snd_soc_put_strobe);
-
-/**
  * snd_soc_dai_set_sysclk - configure DAI system or master clock.
  * @dai: DAI
  * @clk_id: DAI specific clock ID
@@ -4281,7 +3232,7 @@ int snd_soc_of_parse_audio_routing(struct snd_soc_card *card,
                                    const char *propname)
 {
         struct device_node *np = card->dev->of_node;
-        int num_routes;
+        int num_routes, old_routes;
         struct snd_soc_dapm_route *routes;
         int i, ret;
 
@@ -4299,7 +3250,9 @@ int snd_soc_of_parse_audio_routing(struct snd_soc_card *card,
                 return -EINVAL;
         }
 
-        routes = devm_kzalloc(card->dev, num_routes * sizeof(*routes),
+        old_routes = card->num_dapm_routes;
+        routes = devm_kzalloc(card->dev,
+                              (old_routes + num_routes) * sizeof(*routes),
                               GFP_KERNEL);
         if (!routes) {
                 dev_err(card->dev,
@@ -4307,9 +3260,11 @@ int snd_soc_of_parse_audio_routing(struct snd_soc_card *card,
                 return -EINVAL;
         }
 
+        memcpy(routes, card->dapm_routes, old_routes * sizeof(*routes));
+
         for (i = 0; i < num_routes; i++) {
                 ret = of_property_read_string_index(np, propname,
-                        2 * i, &routes[i].sink);
+                        2 * i, &routes[old_routes + i].sink);
                 if (ret) {
                         dev_err(card->dev,
                                 "ASoC: Property '%s' index %d could not be read: %d\n",
@@ -4317,7 +3272,7 @@ int snd_soc_of_parse_audio_routing(struct snd_soc_card *card,
                         return -EINVAL;
                 }
                 ret = of_property_read_string_index(np, propname,
-                        (2 * i) + 1, &routes[i].source);
+                        (2 * i) + 1, &routes[old_routes + i].source);
                 if (ret) {
                         dev_err(card->dev,
                                 "ASoC: Property '%s' index %d could not be read: %d\n",
@@ -4326,7 +3281,7 @@ int snd_soc_of_parse_audio_routing(struct snd_soc_card *card,
                 }
         }
 
-        card->num_dapm_routes = num_routes;
+        card->num_dapm_routes += num_routes;
         card->dapm_routes = routes;
 
         return 0;
diff --git a/sound/soc/soc-dapm.c b/sound/soc/soc-dapm.c
index c61cb9cedbcd..c5136bb1f982 100644
--- a/sound/soc/soc-dapm.c
+++ b/sound/soc/soc-dapm.c
@@ -159,27 +159,135 @@ static void dapm_mark_dirty(struct snd_soc_dapm_widget *w, const char *reason)
         }
 }
 
-void dapm_mark_io_dirty(struct snd_soc_dapm_context *dapm)
+/*
+ * dapm_widget_invalidate_input_paths() - Invalidate the cached number of input
+ *  paths
+ * @w: The widget for which to invalidate the cached number of input paths
+ *
+ * The function resets the cached number of inputs for the specified widget and
+ * all widgets that can be reached via outgoing paths from the widget.
+ *
+ * This function must be called if the number of input paths for a widget might
+ * have changed. E.g. if the source state of a widget changes or a path is added
+ * or activated with the widget as the sink.
+ */
+static void dapm_widget_invalidate_input_paths(struct snd_soc_dapm_widget *w)
+{
+        struct snd_soc_dapm_widget *sink;
+        struct snd_soc_dapm_path *p;
+        LIST_HEAD(list);
+
+        dapm_assert_locked(w->dapm);
+
+        if (w->inputs == -1)
+                return;
+
+        w->inputs = -1;
+        list_add_tail(&w->work_list, &list);
+
+        list_for_each_entry(w, &list, work_list) {
+                list_for_each_entry(p, &w->sinks, list_source) {
+                        if (p->is_supply || p->weak || !p->connect)
+                                continue;
+                        sink = p->sink;
+                        if (sink->inputs != -1) {
+                                sink->inputs = -1;
+                                list_add_tail(&sink->work_list, &list);
+                        }
+                }
+        }
+}
+
+/*
+ * dapm_widget_invalidate_output_paths() - Invalidate the cached number of
+ *  output paths
+ * @w: The widget for which to invalidate the cached number of output paths
+ *
+ * Resets the cached number of outputs for the specified widget and all widgets
+ * that can be reached via incoming paths from the widget.
+ *
+ * This function must be called if the number of output paths for a widget might
+ * have changed. E.g. if the sink state of a widget changes or a path is added
+ * or activated with the widget as the source.
+ */
+static void dapm_widget_invalidate_output_paths(struct snd_soc_dapm_widget *w)
+{
+        struct snd_soc_dapm_widget *source;
+        struct snd_soc_dapm_path *p;
+        LIST_HEAD(list);
+
+        dapm_assert_locked(w->dapm);
+
+        if (w->outputs == -1)
+                return;
+
+        w->outputs = -1;
+        list_add_tail(&w->work_list, &list);
+
+        list_for_each_entry(w, &list, work_list) {
+                list_for_each_entry(p, &w->sources, list_sink) {
+                        if (p->is_supply || p->weak || !p->connect)
+                                continue;
+                        source = p->source;
+                        if (source->outputs != -1) {
+                                source->outputs = -1;
+                                list_add_tail(&source->work_list, &list);
+                        }
+                }
+        }
+}
+
+/*
+ * dapm_path_invalidate() - Invalidates the cached number of inputs and outputs
+ *  for the widgets connected to a path
+ * @p: The path to invalidate
+ *
+ * Resets the cached number of inputs for the sink of the path and the cached
+ * number of outputs for the source of the path.
+ *
+ * This function must be called when a path is added, removed or the connected
+ * state changes.
+ */
+static void dapm_path_invalidate(struct snd_soc_dapm_path *p)
+{
+        /*
+         * Weak paths or supply paths do not influence the number of input or
+         * output paths of their neighbors.
+         */
+        if (p->weak || p->is_supply)
+                return;
+
+        /*
+         * The number of connected endpoints is the sum of the number of
+         * connected endpoints of all neighbors. If a node with 0 connected
+         * endpoints is either connected or disconnected that sum won't change,
+         * so there is no need to re-check the path.
+         */
+        if (p->source->inputs != 0)
+                dapm_widget_invalidate_input_paths(p->sink);
+        if (p->sink->outputs != 0)
+                dapm_widget_invalidate_output_paths(p->source);
+}
+
+void dapm_mark_endpoints_dirty(struct snd_soc_card *card)
 {
-        struct snd_soc_card *card = dapm->card;
         struct snd_soc_dapm_widget *w;
 
         mutex_lock(&card->dapm_mutex);
 
         list_for_each_entry(w, &card->widgets, list) {
-                switch (w->id) {
-                case snd_soc_dapm_input:
-                case snd_soc_dapm_output:
-                        dapm_mark_dirty(w, "Rechecking inputs and outputs");
-                        break;
-                default:
-                        break;
+                if (w->is_sink || w->is_source) {
+                        dapm_mark_dirty(w, "Rechecking endpoints");
+                        if (w->is_sink)
+                                dapm_widget_invalidate_output_paths(w);
+                        if (w->is_source)
+                                dapm_widget_invalidate_input_paths(w);
                 }
         }
 
         mutex_unlock(&card->dapm_mutex);
 }
-EXPORT_SYMBOL_GPL(dapm_mark_io_dirty);
+EXPORT_SYMBOL_GPL(dapm_mark_endpoints_dirty);
 
 /* create a new dapm widget */
 static inline struct snd_soc_dapm_widget *dapm_cnew_widget(
@@ -386,8 +494,6 @@ static void dapm_reset(struct snd_soc_card *card)
         list_for_each_entry(w, &card->widgets, list) {
                 w->new_power = w->power;
                 w->power_checked = false;
-                w->inputs = -1;
-                w->outputs = -1;
         }
 }
 
@@ -469,10 +575,9 @@ out:
 
 /* connect mux widget to its interconnecting audio paths */
 static int dapm_connect_mux(struct snd_soc_dapm_context *dapm,
-        struct snd_soc_dapm_widget *src, struct snd_soc_dapm_widget *dest,
-        struct snd_soc_dapm_path *path, const char *control_name,
-        const struct snd_kcontrol_new *kcontrol)
+        struct snd_soc_dapm_path *path, const char *control_name)
 {
+        const struct snd_kcontrol_new *kcontrol = &path->sink->kcontrol_news[0];
         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
         unsigned int val, item;
         int i;
@@ -493,10 +598,7 @@ static int dapm_connect_mux(struct snd_soc_dapm_context *dapm,
 
         for (i = 0; i < e->items; i++) {
                 if (!(strcmp(control_name, e->texts[i]))) {
-                        list_add(&path->list, &dapm->card->paths);
-                        list_add(&path->list_sink, &dest->sources);
-                        list_add(&path->list_source, &src->sinks);
-                        path->name = (char*)e->texts[i];
+                        path->name = e->texts[i];
                         if (i == item)
                                 path->connect = 1;
                         else
@@ -509,11 +611,10 @@ static int dapm_connect_mux(struct snd_soc_dapm_context *dapm,
 }
 
 /* set up initial codec paths */
-static void dapm_set_mixer_path_status(struct snd_soc_dapm_widget *w,
-        struct snd_soc_dapm_path *p, int i)
+static void dapm_set_mixer_path_status(struct snd_soc_dapm_path *p, int i)
 {
         struct soc_mixer_control *mc = (struct soc_mixer_control *)
-                w->kcontrol_news[i].private_value;
+                p->sink->kcontrol_news[i].private_value;
         unsigned int reg = mc->reg;
         unsigned int shift = mc->shift;
         unsigned int max = mc->max;
@@ -522,7 +623,7 @@ static void dapm_set_mixer_path_status(struct snd_soc_dapm_widget *w,
         unsigned int val;
 
         if (reg != SND_SOC_NOPM) {
-                soc_dapm_read(w->dapm, reg, &val);
+                soc_dapm_read(p->sink->dapm, reg, &val);
                 val = (val >> shift) & mask;
                 if (invert)
                         val = max - val;
@@ -534,19 +635,15 @@ static void dapm_set_mixer_path_status(struct snd_soc_dapm_widget *w,
 
 /* connect mixer widget to its interconnecting audio paths */
 static int dapm_connect_mixer(struct snd_soc_dapm_context *dapm,
-        struct snd_soc_dapm_widget *src, struct snd_soc_dapm_widget *dest,
         struct snd_soc_dapm_path *path, const char *control_name)
 {
         int i;
 
         /* search for mixer kcontrol */
-        for (i = 0; i < dest->num_kcontrols; i++) {
-                if (!strcmp(control_name, dest->kcontrol_news[i].name)) {
-                        list_add(&path->list, &dapm->card->paths);
-                        list_add(&path->list_sink, &dest->sources);
-                        list_add(&path->list_source, &src->sinks);
-                        path->name = dest->kcontrol_news[i].name;
-                        dapm_set_mixer_path_status(dest, path, i);
+        for (i = 0; i < path->sink->num_kcontrols; i++) {
+                if (!strcmp(control_name, path->sink->kcontrol_news[i].name)) {
+                        path->name = path->sink->kcontrol_news[i].name;
+                        dapm_set_mixer_path_status(path, i);
                         return 0;
                 }
         }
@@ -738,8 +835,10 @@ static int dapm_new_mux(struct snd_soc_dapm_widget *w)
         if (ret < 0)
                 return ret;
 
-        list_for_each_entry(path, &w->sources, list_sink)
-                dapm_kcontrol_add_path(w->kcontrols[0], path);
+        list_for_each_entry(path, &w->sources, list_sink) {
+                if (path->name)
+                        dapm_kcontrol_add_path(w->kcontrols[0], path);
+        }
 
         return 0;
 }
@@ -754,34 +853,6 @@ static int dapm_new_pga(struct snd_soc_dapm_widget *w)
         return 0;
 }
 
-/* reset 'walked' bit for each dapm path */
-static void dapm_clear_walk_output(struct snd_soc_dapm_context *dapm,
-                                   struct list_head *sink)
-{
-        struct snd_soc_dapm_path *p;
-
-        list_for_each_entry(p, sink, list_source) {
-                if (p->walked) {
-                        p->walked = 0;
-                        dapm_clear_walk_output(dapm, &p->sink->sinks);
-                }
-        }
-}
-
-static void dapm_clear_walk_input(struct snd_soc_dapm_context *dapm,
-                                  struct list_head *source)
-{
-        struct snd_soc_dapm_path *p;
-
-        list_for_each_entry(p, source, list_sink) {
-                if (p->walked) {
-                        p->walked = 0;
-                        dapm_clear_walk_input(dapm, &p->source->sources);
-                }
-        }
-}
-
-
 /* 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.
@@ -856,61 +927,23 @@ static int is_connected_output_ep(struct snd_soc_dapm_widget *widget,
 
         DAPM_UPDATE_STAT(widget, path_checks);
 
-        switch (widget->id) {
-        case snd_soc_dapm_supply:
-        case snd_soc_dapm_regulator_supply:
-        case snd_soc_dapm_clock_supply:
-        case snd_soc_dapm_kcontrol:
-                return 0;
-        default:
-                break;
-        }
-
-        switch (widget->id) {
-        case snd_soc_dapm_adc:
-        case snd_soc_dapm_aif_out:
-        case snd_soc_dapm_dai_out:
-                if (widget->active) {
-                        widget->outputs = snd_soc_dapm_suspend_check(widget);
-                        return widget->outputs;
-                }
-        default:
-                break;
-        }
-
-        if (widget->connected) {
-                /* connected pin ? */
-                if (widget->id == snd_soc_dapm_output && !widget->ext) {
-                        widget->outputs = snd_soc_dapm_suspend_check(widget);
-                        return widget->outputs;
-                }
-
-                /* connected jack or spk ? */
-                if (widget->id == snd_soc_dapm_hp ||
-                    widget->id == snd_soc_dapm_spk ||
-                    (widget->id == snd_soc_dapm_line &&
-                     !list_empty(&widget->sources))) {
-                        widget->outputs = snd_soc_dapm_suspend_check(widget);
-                        return widget->outputs;
-                }
+        if (widget->is_sink && widget->connected) {
+                widget->outputs = snd_soc_dapm_suspend_check(widget);
+                return widget->outputs;
         }
 
         list_for_each_entry(path, &widget->sinks, list_source) {
                 DAPM_UPDATE_STAT(widget, neighbour_checks);
 
-                if (path->weak)
+                if (path->weak || path->is_supply)
                         continue;
 
                 if (path->walking)
                         return 1;
 
-                if (path->walked)
-                        continue;
-
                 trace_snd_soc_dapm_output_path(widget, path);
 
-                if (path->sink && path->connect) {
-                        path->walked = 1;
+                if (path->connect) {
                         path->walking = 1;
 
                         /* do we need to add this widget to the list ? */
@@ -952,73 +985,23 @@ static int is_connected_input_ep(struct snd_soc_dapm_widget *widget,
 
         DAPM_UPDATE_STAT(widget, path_checks);
 
-        switch (widget->id) {
-        case snd_soc_dapm_supply:
-        case snd_soc_dapm_regulator_supply:
-        case snd_soc_dapm_clock_supply:
-        case snd_soc_dapm_kcontrol:
-                return 0;
-        default:
-                break;
-        }
-
-        /* active stream ? */
-        switch (widget->id) {
-        case snd_soc_dapm_dac:
-        case snd_soc_dapm_aif_in:
-        case snd_soc_dapm_dai_in:
-                if (widget->active) {
-                        widget->inputs = snd_soc_dapm_suspend_check(widget);
-                        return widget->inputs;
-                }
-        default:
-                break;
-        }
-
-        if (widget->connected) {
-                /* connected pin ? */
-                if (widget->id == snd_soc_dapm_input && !widget->ext) {
-                        widget->inputs = snd_soc_dapm_suspend_check(widget);
-                        return widget->inputs;
-                }
-
-                /* connected VMID/Bias for lower pops */
-                if (widget->id == snd_soc_dapm_vmid) {
-                        widget->inputs = snd_soc_dapm_suspend_check(widget);
-                        return widget->inputs;
-                }
-
-                /* connected jack ? */
-                if (widget->id == snd_soc_dapm_mic ||
-                    (widget->id == snd_soc_dapm_line &&
-                     !list_empty(&widget->sinks))) {
-                        widget->inputs = snd_soc_dapm_suspend_check(widget);
-                        return widget->inputs;
-                }
-
-                /* signal generator */
-                if (widget->id == snd_soc_dapm_siggen) {
-                        widget->inputs = snd_soc_dapm_suspend_check(widget);
-                        return widget->inputs;
-                }
+        if (widget->is_source && widget->connected) {
+                widget->inputs = snd_soc_dapm_suspend_check(widget);
+                return widget->inputs;
         }
 
         list_for_each_entry(path, &widget->sources, list_sink) {
                 DAPM_UPDATE_STAT(widget, neighbour_checks);
 
-                if (path->weak)
+                if (path->weak || path->is_supply)
                         continue;
 
                 if (path->walking)
                         return 1;
 
-                if (path->walked)
-                        continue;
-
                 trace_snd_soc_dapm_input_path(widget, path);
 
-                if (path->source && path->connect) {
-                        path->walked = 1;
+                if (path->connect) {
                         path->walking = 1;
 
                         /* do we need to add this widget to the list ? */
@@ -1060,21 +1043,25 @@ static int is_connected_input_ep(struct snd_soc_dapm_widget *widget,
 int snd_soc_dapm_dai_get_connected_widgets(struct snd_soc_dai *dai, int stream,
         struct snd_soc_dapm_widget_list **list)
 {
-        struct snd_soc_card *card = dai->card;
+        struct snd_soc_card *card = dai->component->card;
+        struct snd_soc_dapm_widget *w;
         int paths;
 
         mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
-        dapm_reset(card);
 
-        if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
+        /*
+         * For is_connected_{output,input}_ep fully discover the graph we need
+         * to reset the cached number of inputs and outputs.
+         */
+        list_for_each_entry(w, &card->widgets, list) {
+                w->inputs = -1;
+                w->outputs = -1;
+        }
+
+        if (stream == SNDRV_PCM_STREAM_PLAYBACK)
                 paths = is_connected_output_ep(dai->playback_widget, list);
-                dapm_clear_walk_output(&card->dapm,
-                                       &dai->playback_widget->sinks);
-        } else {
+        else
                 paths = is_connected_input_ep(dai->capture_widget, list);
-                dapm_clear_walk_input(&card->dapm,
-                                      &dai->capture_widget->sources);
-        }
 
         trace_snd_soc_dapm_connected(paths, stream);
         mutex_unlock(&card->dapm_mutex);
@@ -1163,44 +1150,10 @@ static int dapm_generic_check_power(struct snd_soc_dapm_widget *w)
         DAPM_UPDATE_STAT(w, power_checks);
 
         in = is_connected_input_ep(w, NULL);
-        dapm_clear_walk_input(w->dapm, &w->sources);
         out = is_connected_output_ep(w, NULL);
-        dapm_clear_walk_output(w->dapm, &w->sinks);
         return out != 0 && in != 0;
 }
 
-/* Check to see if an ADC has power */
-static int dapm_adc_check_power(struct snd_soc_dapm_widget *w)
-{
-        int in;
-
-        DAPM_UPDATE_STAT(w, power_checks);
-
-        if (w->active) {
-                in = is_connected_input_ep(w, NULL);
-                dapm_clear_walk_input(w->dapm, &w->sources);
-                return in != 0;
-        } else {
-                return dapm_generic_check_power(w);
-        }
-}
-
-/* Check to see if a DAC has power */
-static int dapm_dac_check_power(struct snd_soc_dapm_widget *w)
-{
-        int out;
-
-        DAPM_UPDATE_STAT(w, power_checks);
-
-        if (w->active) {
-                out = is_connected_output_ep(w, NULL);
-                dapm_clear_walk_output(w->dapm, &w->sinks);
-                return out != 0;
-        } else {
-                return dapm_generic_check_power(w);
-        }
-}
-
 /* Check to see if a power supply is needed */
 static int dapm_supply_check_power(struct snd_soc_dapm_widget *w)
 {
@@ -1219,9 +1172,6 @@ static int dapm_supply_check_power(struct snd_soc_dapm_widget *w)
                     !path->connected(path->source, path->sink))
                         continue;
 
-                if (!path->sink)
-                        continue;
-
                 if (dapm_widget_power_check(path->sink))
                         return 1;
         }
@@ -1636,27 +1586,14 @@ static void dapm_widget_set_power(struct snd_soc_dapm_widget *w, bool power,
         /* If we changed our power state perhaps our neigbours changed
          * also.
          */
-        list_for_each_entry(path, &w->sources, list_sink) {
-                if (path->source) {
-                        dapm_widget_set_peer_power(path->source, power,
+        list_for_each_entry(path, &w->sources, list_sink)
+                dapm_widget_set_peer_power(path->source, power, path->connect);
+
+        /* Supplies can't affect their outputs, only their inputs */
+        if (!w->is_supply) {
+                list_for_each_entry(path, &w->sinks, list_source)
+                        dapm_widget_set_peer_power(path->sink, power,
                                                    path->connect);
-                }
-        }
-        switch (w->id) {
-        case snd_soc_dapm_supply:
-        case snd_soc_dapm_regulator_supply:
-        case snd_soc_dapm_clock_supply:
-        case snd_soc_dapm_kcontrol:
-                /* Supplies can't affect their outputs, only their inputs */
-                break;
-        default:
-                list_for_each_entry(path, &w->sinks, list_source) {
-                        if (path->sink) {
-                                dapm_widget_set_peer_power(path->sink, power,
-                                                           path->connect);
-                        }
-                }
-                break;
         }
 
         if (power)
@@ -1863,10 +1800,14 @@ static ssize_t dapm_widget_power_read_file(struct file *file,
         if (!buf)
                 return -ENOMEM;
 
-        in = is_connected_input_ep(w, NULL);
-        dapm_clear_walk_input(w->dapm, &w->sources);
-        out = is_connected_output_ep(w, NULL);
-        dapm_clear_walk_output(w->dapm, &w->sinks);
+        /* Supply widgets are not handled by is_connected_{input,output}_ep() */
+        if (w->is_supply) {
+                in = 0;
+                out = 0;
+        } else {
+                in = is_connected_input_ep(w, NULL);
+                out = is_connected_output_ep(w, NULL);
+        }
 
         ret = snprintf(buf, PAGE_SIZE, "%s: %s%s  in %d out %d",
                        w->name, w->power ? "On" : "Off",
@@ -2011,32 +1952,45 @@ static inline void dapm_debugfs_cleanup(struct snd_soc_dapm_context *dapm)
 
 #endif
 
+/*
+ * soc_dapm_connect_path() - Connects or disconnects a path
+ * @path: The path to update
+ * @connect: The new connect state of the path. True if the path is connected,
+ *  false if it is disconneted.
+ * @reason: The reason why the path changed (for debugging only)
+ */
+static void soc_dapm_connect_path(struct snd_soc_dapm_path *path,
+        bool connect, const char *reason)
+{
+        if (path->connect == connect)
+                return;
+
+        path->connect = connect;
+        dapm_mark_dirty(path->source, reason);
+        dapm_mark_dirty(path->sink, reason);
+        dapm_path_invalidate(path);
+}
+
 /* test and update the power status of a mux widget */
 static int soc_dapm_mux_update_power(struct snd_soc_card *card,
                                  struct snd_kcontrol *kcontrol, int mux, struct soc_enum *e)
 {
         struct snd_soc_dapm_path *path;
         int found = 0;
+        bool connect;
 
         lockdep_assert_held(&card->dapm_mutex);
 
         /* find dapm widget path assoc with kcontrol */
         dapm_kcontrol_for_each_path(path, kcontrol) {
-                if (!path->name || !e->texts[mux])
-                        continue;
-
                 found = 1;
                 /* we now need to match the string in the enum to the path */
-                if (!(strcmp(path->name, e->texts[mux]))) {
-                        path->connect = 1; /* new connection */
-                        dapm_mark_dirty(path->source, "mux connection");
-                } else {
-                        if (path->connect)
-                                dapm_mark_dirty(path->source,
-                                                "mux disconnection");
-                        path->connect = 0; /* old connection must be powered down */
-                }
-                dapm_mark_dirty(path->sink, "mux change");
+                if (!(strcmp(path->name, e->texts[mux])))
+                        connect = true;
+                else
+                        connect = false;
+
+                soc_dapm_connect_path(path, connect, "mux update");
         }
 
         if (found)
@@ -2075,9 +2029,7 @@ static int soc_dapm_mixer_update_power(struct snd_soc_card *card,
         /* find dapm widget path assoc with kcontrol */
         dapm_kcontrol_for_each_path(path, kcontrol) {
                 found = 1;
-                path->connect = connect;
-                dapm_mark_dirty(path->source, "mixer connection");
-                dapm_mark_dirty(path->sink, "mixer update");
+                soc_dapm_connect_path(path, connect, "mixer update");
         }
 
         if (found)
@@ -2255,8 +2207,11 @@ static int snd_soc_dapm_set_pin(struct snd_soc_dapm_context *dapm,
                 return -EINVAL;
         }
 
-        if (w->connected != status)
+        if (w->connected != status) {
                 dapm_mark_dirty(w, "pin configuration");
+                dapm_widget_invalidate_input_paths(w);
+                dapm_widget_invalidate_output_paths(w);
+        }
 
         w->connected = status;
         if (status == 0)
@@ -2309,6 +2264,53 @@ int snd_soc_dapm_sync(struct snd_soc_dapm_context *dapm)
 }
 EXPORT_SYMBOL_GPL(snd_soc_dapm_sync);
 
+/*
+ * dapm_update_widget_flags() - Re-compute widget sink and source flags
+ * @w: The widget for which to update the flags
+ *
+ * Some widgets have a dynamic category which depends on which neighbors they
+ * are connected to. This function update the category for these widgets.
+ *
+ * This function must be called whenever a path is added or removed to a widget.
+ */
+static void dapm_update_widget_flags(struct snd_soc_dapm_widget *w)
+{
+        struct snd_soc_dapm_path *p;
+
+        switch (w->id) {
+        case snd_soc_dapm_input:
+                w->is_source = 1;
+                list_for_each_entry(p, &w->sources, list_sink) {
+                        if (p->source->id == snd_soc_dapm_micbias ||
+                                p->source->id == snd_soc_dapm_mic ||
+                                p->source->id == snd_soc_dapm_line ||
+                                p->source->id == snd_soc_dapm_output) {
+                                        w->is_source = 0;
+                                        break;
+                        }
+                }
+                break;
+        case snd_soc_dapm_output:
+                w->is_sink = 1;
+                list_for_each_entry(p, &w->sinks, list_source) {
+                        if (p->sink->id == snd_soc_dapm_spk ||
+                                p->sink->id == snd_soc_dapm_hp ||
+                                p->sink->id == snd_soc_dapm_line ||
+                                p->sink->id == snd_soc_dapm_input) {
+                                        w->is_sink = 0;
+                                        break;
+                        }
+                }
+                break;
+        case snd_soc_dapm_line:
+                w->is_sink = !list_empty(&w->sources);
+                w->is_source = !list_empty(&w->sinks);
+                break;
+        default:
+                break;
+        }
+}
+
 static int snd_soc_dapm_add_path(struct snd_soc_dapm_context *dapm,
         struct snd_soc_dapm_widget *wsource, struct snd_soc_dapm_widget *wsink,
         const char *control,
@@ -2318,6 +2320,27 @@ static int snd_soc_dapm_add_path(struct snd_soc_dapm_context *dapm,
         struct snd_soc_dapm_path *path;
         int ret;
 
+        if (wsink->is_supply && !wsource->is_supply) {
+                dev_err(dapm->dev,
+                        "Connecting non-supply widget to supply widget is not supported (%s -> %s)\n",
+                        wsource->name, wsink->name);
+                return -EINVAL;
+        }
+
+        if (connected && !wsource->is_supply) {
+                dev_err(dapm->dev,
+                        "connected() callback only supported for supply widgets (%s -> %s)\n",
+                        wsource->name, wsink->name);
+                return -EINVAL;
+        }
+
+        if (wsource->is_supply && control) {
+                dev_err(dapm->dev,
+                        "Conditional paths are not supported for supply widgets (%s -> [%s] -> %s)\n",
+                        wsource->name, control, wsink->name);
+                return -EINVAL;
+        }
+
         path = kzalloc(sizeof(struct snd_soc_dapm_path), GFP_KERNEL);
         if (!path)
                 return -ENOMEM;
@@ -2330,85 +2353,49 @@ static int snd_soc_dapm_add_path(struct snd_soc_dapm_context *dapm,
         INIT_LIST_HEAD(&path->list_source);
         INIT_LIST_HEAD(&path->list_sink);
 
-        /* check for external widgets */
-        if (wsink->id == snd_soc_dapm_input) {
-                if (wsource->id == snd_soc_dapm_micbias ||
-                        wsource->id == snd_soc_dapm_mic ||
-                        wsource->id == snd_soc_dapm_line ||
-                        wsource->id == snd_soc_dapm_output)
-                        wsink->ext = 1;
-        }
-        if (wsource->id == snd_soc_dapm_output) {
-                if (wsink->id == snd_soc_dapm_spk ||
-                        wsink->id == snd_soc_dapm_hp ||
-                        wsink->id == snd_soc_dapm_line ||
-                        wsink->id == snd_soc_dapm_input)
-                        wsource->ext = 1;
-        }
-
-        dapm_mark_dirty(wsource, "Route added");
-        dapm_mark_dirty(wsink, "Route added");
+        if (wsource->is_supply || wsink->is_supply)
+                path->is_supply = 1;
 
         /* connect static paths */
         if (control == NULL) {
-                list_add(&path->list, &dapm->card->paths);
-                list_add(&path->list_sink, &wsink->sources);
-                list_add(&path->list_source, &wsource->sinks);
                 path->connect = 1;
-                return 0;
-        }
-
-        /* connect dynamic paths */
-        switch (wsink->id) {
-        case snd_soc_dapm_adc:
-        case snd_soc_dapm_dac:
-        case snd_soc_dapm_pga:
-        case snd_soc_dapm_out_drv:
-        case snd_soc_dapm_input:
-        case snd_soc_dapm_output:
-        case snd_soc_dapm_siggen:
-        case snd_soc_dapm_micbias:
-        case snd_soc_dapm_vmid:
-        case snd_soc_dapm_pre:
-        case snd_soc_dapm_post:
-        case snd_soc_dapm_supply:
-        case snd_soc_dapm_regulator_supply:
-        case snd_soc_dapm_clock_supply:
-        case snd_soc_dapm_aif_in:
-        case snd_soc_dapm_aif_out:
-        case snd_soc_dapm_dai_in:
-        case snd_soc_dapm_dai_out:
-        case snd_soc_dapm_dai_link:
-        case snd_soc_dapm_kcontrol:
-                list_add(&path->list, &dapm->card->paths);
-                list_add(&path->list_sink, &wsink->sources);
-                list_add(&path->list_source, &wsource->sinks);
-                path->connect = 1;
-                return 0;
-        case snd_soc_dapm_mux:
-                ret = dapm_connect_mux(dapm, wsource, wsink, path, control,
-                        &wsink->kcontrol_news[0]);
-                if (ret != 0)
-                        goto err;
-                break;
-        case snd_soc_dapm_switch:
-        case snd_soc_dapm_mixer:
-        case snd_soc_dapm_mixer_named_ctl:
-                ret = dapm_connect_mixer(dapm, wsource, wsink, path, control);
-                if (ret != 0)
+        } else {
+                /* connect dynamic paths */
+                switch (wsink->id) {
+                case snd_soc_dapm_mux:
+                        ret = dapm_connect_mux(dapm, path, control);
+                        if (ret != 0)
+                                goto err;
+                        break;
+                case snd_soc_dapm_switch:
+                case snd_soc_dapm_mixer:
+                case snd_soc_dapm_mixer_named_ctl:
+                        ret = dapm_connect_mixer(dapm, path, control);
+                        if (ret != 0)
+                                goto err;
+                        break;
+                default:
+                        dev_err(dapm->dev,
+                                "Control not supported for path %s -> [%s] -> %s\n",
+                                wsource->name, control, wsink->name);
+                        ret = -EINVAL;
                         goto err;
-                break;
-        case snd_soc_dapm_hp:
-        case snd_soc_dapm_mic:
-        case snd_soc_dapm_line:
-        case snd_soc_dapm_spk:
-                list_add(&path->list, &dapm->card->paths);
-                list_add(&path->list_sink, &wsink->sources);
-                list_add(&path->list_source, &wsource->sinks);
-                path->connect = 0;
-                return 0;
+                }
         }
 
+        list_add(&path->list, &dapm->card->paths);
+        list_add(&path->list_sink, &wsink->sources);
+        list_add(&path->list_source, &wsource->sinks);
+
+        dapm_update_widget_flags(wsource);
+        dapm_update_widget_flags(wsink);
+
+        dapm_mark_dirty(wsource, "Route added");
+        dapm_mark_dirty(wsink, "Route added");
+
+        if (dapm->card->instantiated && path->connect)
+                dapm_path_invalidate(path);
+
         return 0;
 err:
         kfree(path);
@@ -2489,6 +2476,7 @@ err:
 static int snd_soc_dapm_del_route(struct snd_soc_dapm_context *dapm,
                                   const struct snd_soc_dapm_route *route)
 {
+        struct snd_soc_dapm_widget *wsource, *wsink;
         struct snd_soc_dapm_path *path, *p;
         const char *sink;
         const char *source;
@@ -2526,10 +2514,19 @@ static int snd_soc_dapm_del_route(struct snd_soc_dapm_context *dapm,
         }
 
         if (path) {
-                dapm_mark_dirty(path->source, "Route removed");
-                dapm_mark_dirty(path->sink, "Route removed");
+                wsource = path->source;
+                wsink = path->sink;
+
+                dapm_mark_dirty(wsource, "Route removed");
+                dapm_mark_dirty(wsink, "Route removed");
+                if (path->connect)
+                        dapm_path_invalidate(path);
 
                 dapm_free_path(path);
+
+                /* Update any path related flags */
+                dapm_update_widget_flags(wsource);
+                dapm_update_widget_flags(wsink);
         } else {
                 dev_warn(dapm->dev, "ASoC: Route %s->%s does not exist\n",
                          source, sink);
@@ -3087,40 +3084,44 @@ snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm,
         }
 
         switch (w->id) {
-        case snd_soc_dapm_switch:
-        case snd_soc_dapm_mixer:
-        case snd_soc_dapm_mixer_named_ctl:
+        case snd_soc_dapm_mic:
+        case snd_soc_dapm_input:
+                w->is_source = 1;
                 w->power_check = dapm_generic_check_power;
                 break;
-        case snd_soc_dapm_mux:
+        case snd_soc_dapm_spk:
+        case snd_soc_dapm_hp:
+        case snd_soc_dapm_output:
+                w->is_sink = 1;
                 w->power_check = dapm_generic_check_power;
                 break;
-        case snd_soc_dapm_dai_out:
-                w->power_check = dapm_adc_check_power;
-                break;
-        case snd_soc_dapm_dai_in:
-                w->power_check = dapm_dac_check_power;
+        case snd_soc_dapm_vmid:
+        case snd_soc_dapm_siggen:
+                w->is_source = 1;
+                w->power_check = dapm_always_on_check_power;
                 break;
+        case snd_soc_dapm_mux:
+        case snd_soc_dapm_switch:
+        case snd_soc_dapm_mixer:
+        case snd_soc_dapm_mixer_named_ctl:
         case snd_soc_dapm_adc:
         case snd_soc_dapm_aif_out:
         case snd_soc_dapm_dac:
         case snd_soc_dapm_aif_in:
         case snd_soc_dapm_pga:
         case snd_soc_dapm_out_drv:
-        case snd_soc_dapm_input:
-        case snd_soc_dapm_output:
         case snd_soc_dapm_micbias:
-        case snd_soc_dapm_spk:
-        case snd_soc_dapm_hp:
-        case snd_soc_dapm_mic:
         case snd_soc_dapm_line:
         case snd_soc_dapm_dai_link:
+        case snd_soc_dapm_dai_out:
+        case snd_soc_dapm_dai_in:
                 w->power_check = dapm_generic_check_power;
                 break;
         case snd_soc_dapm_supply:
         case snd_soc_dapm_regulator_supply:
         case snd_soc_dapm_clock_supply:
         case snd_soc_dapm_kcontrol:
+                w->is_supply = 1;
                 w->power_check = dapm_supply_check_power;
                 break;
         default:
@@ -3137,6 +3138,9 @@ snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm,
         INIT_LIST_HEAD(&w->dirty);
         list_add(&w->list, &dapm->card->widgets);
 
+        w->inputs = -1;
+        w->outputs = -1;
+
         /* machine layer set ups unconnected pins and insertions */
         w->connected = 1;
         return w;
@@ -3484,6 +3488,14 @@ static void soc_dapm_dai_stream_event(struct snd_soc_dai *dai, int stream,
                 case SND_SOC_DAPM_STREAM_PAUSE_RELEASE:
                         break;
                 }
+
+                if (w->id == snd_soc_dapm_dai_in) {
+                        w->is_source = w->active;
+                        dapm_widget_invalidate_input_paths(w);
+                } else {
+                        w->is_sink = w->active;
+                        dapm_widget_invalidate_output_paths(w);
+                }
         }
 }
 
@@ -3610,7 +3622,15 @@ int snd_soc_dapm_force_enable_pin_unlocked(struct snd_soc_dapm_context *dapm,
         }
 
         dev_dbg(w->dapm->dev, "ASoC: force enable pin %s\n", pin);
-        w->connected = 1;
+        if (!w->connected) {
+                /*
+                 * w->force does not affect the number of input or output paths,
+                 * so we only have to recheck if w->connected is changed
+                 */
+                dapm_widget_invalidate_input_paths(w);
+                dapm_widget_invalidate_output_paths(w);
+                w->connected = 1;
+        }
         w->force = 1;
         dapm_mark_dirty(w, "force enable");
 
@@ -3788,35 +3808,54 @@ int snd_soc_dapm_ignore_suspend(struct snd_soc_dapm_context *dapm,
 }
 EXPORT_SYMBOL_GPL(snd_soc_dapm_ignore_suspend);
 
+/**
+ * dapm_is_external_path() - Checks if a path is a external path
+ * @card: The card the path belongs to
+ * @path: The path to check
+ *
+ * Returns true if the path is either between two different DAPM contexts or
+ * between two external pins of the same DAPM context. Otherwise returns
+ * false.
+ */
+static bool dapm_is_external_path(struct snd_soc_card *card,
+        struct snd_soc_dapm_path *path)
+{
+        dev_dbg(card->dev,
+                "... Path %s(id:%d dapm:%p) - %s(id:%d dapm:%p)\n",
+                path->source->name, path->source->id, path->source->dapm,
+                path->sink->name, path->sink->id, path->sink->dapm);
+
+        /* Connection between two different DAPM contexts */
+        if (path->source->dapm != path->sink->dapm)
+                return true;
+
+        /* Loopback connection from external pin to external pin */
+        if (path->sink->id == snd_soc_dapm_input) {
+                switch (path->source->id) {
+                case snd_soc_dapm_output:
+                case snd_soc_dapm_micbias:
+                        return true;
+                default:
+                        break;
+                }
+        }
+
+        return false;
+}
+
 static bool snd_soc_dapm_widget_in_card_paths(struct snd_soc_card *card,
                                               struct snd_soc_dapm_widget *w)
 {
         struct snd_soc_dapm_path *p;
 
-        list_for_each_entry(p, &card->paths, list) {
-                if ((p->source == w) || (p->sink == w)) {
-                        dev_dbg(card->dev,
-                            "... Path %s(id:%d dapm:%p) - %s(id:%d dapm:%p)\n",
-                            p->source->name, p->source->id, p->source->dapm,
-                            p->sink->name, p->sink->id, p->sink->dapm);
+        list_for_each_entry(p, &w->sources, list_sink) {
+                if (dapm_is_external_path(card, p))
+                        return true;
+        }
 
-                        /* Connected to something other than the codec */
-                        if (p->source->dapm != p->sink->dapm)
-                                return true;
-                        /*
-                         * Loopback connection from codec external pin to
-                         * codec external pin
-                         */
-                        if (p->sink->id == snd_soc_dapm_input) {
-                                switch (p->source->id) {
-                                case snd_soc_dapm_output:
-                                case snd_soc_dapm_micbias:
-                                        return true;
-                                default:
-                                        break;
-                                }
-                        }
-                }
+        list_for_each_entry(p, &w->sinks, list_source) {
+                if (dapm_is_external_path(card, p))
+                        return true;
         }
 
         return false;
diff --git a/sound/soc/soc-ops.c b/sound/soc/soc-ops.c
new file mode 100644
index 000000000000..100d92b5b77e
--- /dev/null
+++ b/sound/soc/soc-ops.c
@@ -0,0 +1,952 @@
+/*
+ * soc-ops.c  --  Generic ASoC operations
+ *
+ * Copyright 2005 Wolfson Microelectronics PLC.
+ * Copyright 2005 Openedhand Ltd.
+ * Copyright (C) 2010 Slimlogic Ltd.
+ * Copyright (C) 2010 Texas Instruments Inc.
+ *
+ * Author: Liam Girdwood <lrg@slimlogic.co.uk>
+ *         with code, comments and ideas from :-
+ *         Richard Purdie <richard@openedhand.com>
+ *
+ *  This program is free software; you can redistribute  it and/or modify it
+ *  under  the terms of  the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/pm.h>
+#include <linux/bitops.h>
+#include <linux/ctype.h>
+#include <linux/slab.h>
+#include <sound/core.h>
+#include <sound/jack.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/soc.h>
+#include <sound/soc-dpcm.h>
+#include <sound/initval.h>
+
+/**
+ * snd_soc_info_enum_double - enumerated double mixer info callback
+ * @kcontrol: mixer control
+ * @uinfo: control element information
+ *
+ * Callback to provide information about a double enumerated
+ * mixer control.
+ *
+ * Returns 0 for success.
+ */
+int snd_soc_info_enum_double(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_info *uinfo)
+{
+        struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
+
+        return snd_ctl_enum_info(uinfo, e->shift_l == e->shift_r ? 1 : 2,
+                                 e->items, e->texts);
+}
+EXPORT_SYMBOL_GPL(snd_soc_info_enum_double);
+
+/**
+ * snd_soc_get_enum_double - enumerated double mixer get callback
+ * @kcontrol: mixer control
+ * @ucontrol: control element information
+ *
+ * Callback to get the value of a double enumerated mixer.
+ *
+ * Returns 0 for success.
+ */
+int snd_soc_get_enum_double(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
+        struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
+        unsigned int val, item;
+        unsigned int reg_val;
+        int ret;
+
+        ret = snd_soc_component_read(component, e->reg, &reg_val);
+        if (ret)
+                return ret;
+        val = (reg_val >> e->shift_l) & e->mask;
+        item = snd_soc_enum_val_to_item(e, val);
+        ucontrol->value.enumerated.item[0] = item;
+        if (e->shift_l != e->shift_r) {
+                val = (reg_val >> e->shift_l) & e->mask;
+                item = snd_soc_enum_val_to_item(e, val);
+                ucontrol->value.enumerated.item[1] = item;
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(snd_soc_get_enum_double);
+
+/**
+ * snd_soc_put_enum_double - enumerated double mixer put callback
+ * @kcontrol: mixer control
+ * @ucontrol: control element information
+ *
+ * Callback to set the value of a double enumerated mixer.
+ *
+ * Returns 0 for success.
+ */
+int snd_soc_put_enum_double(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
+        struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
+        unsigned int *item = ucontrol->value.enumerated.item;
+        unsigned int val;
+        unsigned int mask;
+
+        if (item[0] >= e->items)
+                return -EINVAL;
+        val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l;
+        mask = e->mask << e->shift_l;
+        if (e->shift_l != e->shift_r) {
+                if (item[1] >= e->items)
+                        return -EINVAL;
+                val |= snd_soc_enum_item_to_val(e, item[1]) << e->shift_r;
+                mask |= e->mask << e->shift_r;
+        }
+
+        return snd_soc_component_update_bits(component, e->reg, mask, val);
+}
+EXPORT_SYMBOL_GPL(snd_soc_put_enum_double);
+
+/**
+ * snd_soc_read_signed - Read a codec register and interprete as signed value
+ * @component: component
+ * @reg: Register to read
+ * @mask: Mask to use after shifting the register value
+ * @shift: Right shift of register value
+ * @sign_bit: Bit that describes if a number is negative or not.
+ * @signed_val: Pointer to where the read value should be stored
+ *
+ * This functions reads a codec register. The register value is shifted right
+ * by 'shift' bits and masked with the given 'mask'. Afterwards it translates
+ * the given registervalue into a signed integer if sign_bit is non-zero.
+ *
+ * Returns 0 on sucess, otherwise an error value
+ */
+static int snd_soc_read_signed(struct snd_soc_component *component,
+        unsigned int reg, unsigned int mask, unsigned int shift,
+        unsigned int sign_bit, int *signed_val)
+{
+        int ret;
+        unsigned int val;
+
+        ret = snd_soc_component_read(component, reg, &val);
+        if (ret < 0)
+                return ret;
+
+        val = (val >> shift) & mask;
+
+        if (!sign_bit) {
+                *signed_val = val;
+                return 0;
+        }
+
+        /* non-negative number */
+        if (!(val & BIT(sign_bit))) {
+                *signed_val = val;
+                return 0;
+        }
+
+        ret = val;
+
+        /*
+         * The register most probably does not contain a full-sized int.
+         * Instead we have an arbitrary number of bits in a signed
+         * representation which has to be translated into a full-sized int.
+         * This is done by filling up all bits above the sign-bit.
+         */
+        ret |= ~((int)(BIT(sign_bit) - 1));
+
+        *signed_val = ret;
+
+        return 0;
+}
+
+/**
+ * snd_soc_info_volsw - single mixer info callback
+ * @kcontrol: mixer control
+ * @uinfo: control element information
+ *
+ * Callback to provide information about a single mixer control, or a double
+ * mixer control that spans 2 registers.
+ *
+ * Returns 0 for success.
+ */
+int snd_soc_info_volsw(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_info *uinfo)
+{
+        struct soc_mixer_control *mc =
+                (struct soc_mixer_control *)kcontrol->private_value;
+        int platform_max;
+
+        if (!mc->platform_max)
+                mc->platform_max = mc->max;
+        platform_max = mc->platform_max;
+
+        if (platform_max == 1 && !strstr(kcontrol->id.name, " Volume"))
+                uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
+        else
+                uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+
+        uinfo->count = snd_soc_volsw_is_stereo(mc) ? 2 : 1;
+        uinfo->value.integer.min = 0;
+        uinfo->value.integer.max = platform_max - mc->min;
+        return 0;
+}
+EXPORT_SYMBOL_GPL(snd_soc_info_volsw);
+
+/**
+ * snd_soc_get_volsw - single mixer get callback
+ * @kcontrol: mixer control
+ * @ucontrol: control element information
+ *
+ * Callback to get the value of a single mixer control, or a double mixer
+ * control that spans 2 registers.
+ *
+ * Returns 0 for success.
+ */
+int snd_soc_get_volsw(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
+        struct soc_mixer_control *mc =
+                (struct soc_mixer_control *)kcontrol->private_value;
+        unsigned int reg = mc->reg;
+        unsigned int reg2 = mc->rreg;
+        unsigned int shift = mc->shift;
+        unsigned int rshift = mc->rshift;
+        int max = mc->max;
+        int min = mc->min;
+        int sign_bit = mc->sign_bit;
+        unsigned int mask = (1 << fls(max)) - 1;
+        unsigned int invert = mc->invert;
+        int val;
+        int ret;
+
+        if (sign_bit)
+                mask = BIT(sign_bit + 1) - 1;
+
+        ret = snd_soc_read_signed(component, reg, mask, shift, sign_bit, &val);
+        if (ret)
+                return ret;
+
+        ucontrol->value.integer.value[0] = val - min;
+        if (invert)
+                ucontrol->value.integer.value[0] =
+                        max - ucontrol->value.integer.value[0];
+
+        if (snd_soc_volsw_is_stereo(mc)) {
+                if (reg == reg2)
+                        ret = snd_soc_read_signed(component, reg, mask, rshift,
+                                sign_bit, &val);
+                else
+                        ret = snd_soc_read_signed(component, reg2, mask, shift,
+                                sign_bit, &val);
+                if (ret)
+                        return ret;
+
+                ucontrol->value.integer.value[1] = val - min;
+                if (invert)
+                        ucontrol->value.integer.value[1] =
+                                max - ucontrol->value.integer.value[1];
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(snd_soc_get_volsw);
+
+/**
+ * snd_soc_put_volsw - single mixer put callback
+ * @kcontrol: mixer control
+ * @ucontrol: control element information
+ *
+ * Callback to set the value of a single mixer control, or a double mixer
+ * control that spans 2 registers.
+ *
+ * Returns 0 for success.
+ */
+int snd_soc_put_volsw(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
+        struct soc_mixer_control *mc =
+                (struct soc_mixer_control *)kcontrol->private_value;
+        unsigned int reg = mc->reg;
+        unsigned int reg2 = mc->rreg;
+        unsigned int shift = mc->shift;
+        unsigned int rshift = mc->rshift;
+        int max = mc->max;
+        int min = mc->min;
+        unsigned int sign_bit = mc->sign_bit;
+        unsigned int mask = (1 << fls(max)) - 1;
+        unsigned int invert = mc->invert;
+        int err;
+        bool type_2r = false;
+        unsigned int val2 = 0;
+        unsigned int val, val_mask;
+
+        if (sign_bit)
+                mask = BIT(sign_bit + 1) - 1;
+
+        val = ((ucontrol->value.integer.value[0] + min) & mask);
+        if (invert)
+                val = max - val;
+        val_mask = mask << shift;
+        val = val << shift;
+        if (snd_soc_volsw_is_stereo(mc)) {
+                val2 = ((ucontrol->value.integer.value[1] + min) & mask);
+                if (invert)
+                        val2 = max - val2;
+                if (reg == reg2) {
+                        val_mask |= mask << rshift;
+                        val |= val2 << rshift;
+                } else {
+                        val2 = val2 << shift;
+                        type_2r = true;
+                }
+        }
+        err = snd_soc_component_update_bits(component, reg, val_mask, val);
+        if (err < 0)
+                return err;
+
+        if (type_2r)
+                err = snd_soc_component_update_bits(component, reg2, val_mask,
+                        val2);
+
+        return err;
+}
+EXPORT_SYMBOL_GPL(snd_soc_put_volsw);
+
+/**
+ * snd_soc_get_volsw_sx - single mixer get callback
+ * @kcontrol: mixer control
+ * @ucontrol: control element information
+ *
+ * Callback to get the value of a single mixer control, or a double mixer
+ * control that spans 2 registers.
+ *
+ * Returns 0 for success.
+ */
+int snd_soc_get_volsw_sx(struct snd_kcontrol *kcontrol,
+                      struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
+        struct soc_mixer_control *mc =
+            (struct soc_mixer_control *)kcontrol->private_value;
+        unsigned int reg = mc->reg;
+        unsigned int reg2 = mc->rreg;
+        unsigned int shift = mc->shift;
+        unsigned int rshift = mc->rshift;
+        int max = mc->max;
+        int min = mc->min;
+        int mask = (1 << (fls(min + max) - 1)) - 1;
+        unsigned int val;
+        int ret;
+
+        ret = snd_soc_component_read(component, reg, &val);
+        if (ret < 0)
+                return ret;
+
+        ucontrol->value.integer.value[0] = ((val >> shift) - min) & mask;
+
+        if (snd_soc_volsw_is_stereo(mc)) {
+                ret = snd_soc_component_read(component, reg2, &val);
+                if (ret < 0)
+                        return ret;
+
+                val = ((val >> rshift) - min) & mask;
+                ucontrol->value.integer.value[1] = val;
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(snd_soc_get_volsw_sx);
+
+/**
+ * snd_soc_put_volsw_sx - double mixer set callback
+ * @kcontrol: mixer control
+ * @uinfo: control element information
+ *
+ * Callback to set the value of a double mixer control that spans 2 registers.
+ *
+ * Returns 0 for success.
+ */
+int snd_soc_put_volsw_sx(struct snd_kcontrol *kcontrol,
+                         struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
+        struct soc_mixer_control *mc =
+            (struct soc_mixer_control *)kcontrol->private_value;
+
+        unsigned int reg = mc->reg;
+        unsigned int reg2 = mc->rreg;
+        unsigned int shift = mc->shift;
+        unsigned int rshift = mc->rshift;
+        int max = mc->max;
+        int min = mc->min;
+        int mask = (1 << (fls(min + max) - 1)) - 1;
+        int err = 0;
+        unsigned int val, val_mask, val2 = 0;
+
+        val_mask = mask << shift;
+        val = (ucontrol->value.integer.value[0] + min) & mask;
+        val = val << shift;
+
+        err = snd_soc_component_update_bits(component, reg, val_mask, val);
+        if (err < 0)
+                return err;
+
+        if (snd_soc_volsw_is_stereo(mc)) {
+                val_mask = mask << rshift;
+                val2 = (ucontrol->value.integer.value[1] + min) & mask;
+                val2 = val2 << rshift;
+
+                err = snd_soc_component_update_bits(component, reg2, val_mask,
+                        val2);
+        }
+        return err;
+}
+EXPORT_SYMBOL_GPL(snd_soc_put_volsw_sx);
+
+/**
+ * snd_soc_info_volsw_range - single mixer info callback with range.
+ * @kcontrol: mixer control
+ * @uinfo: control element information
+ *
+ * Callback to provide information, within a range, about a single
+ * mixer control.
+ *
+ * returns 0 for success.
+ */
+int snd_soc_info_volsw_range(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_info *uinfo)
+{
+        struct soc_mixer_control *mc =
+                (struct soc_mixer_control *)kcontrol->private_value;
+        int platform_max;
+        int min = mc->min;
+
+        if (!mc->platform_max)
+                mc->platform_max = mc->max;
+        platform_max = mc->platform_max;
+
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+        uinfo->count = snd_soc_volsw_is_stereo(mc) ? 2 : 1;
+        uinfo->value.integer.min = 0;
+        uinfo->value.integer.max = platform_max - min;
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(snd_soc_info_volsw_range);
+
+/**
+ * snd_soc_put_volsw_range - single mixer put value callback with range.
+ * @kcontrol: mixer control
+ * @ucontrol: control element information
+ *
+ * Callback to set the value, within a range, for a single mixer control.
+ *
+ * Returns 0 for success.
+ */
+int snd_soc_put_volsw_range(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_value *ucontrol)
+{
+        struct soc_mixer_control *mc =
+                (struct soc_mixer_control *)kcontrol->private_value;
+        struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
+        unsigned int reg = mc->reg;
+        unsigned int rreg = mc->rreg;
+        unsigned int shift = mc->shift;
+        int min = mc->min;
+        int max = mc->max;
+        unsigned int mask = (1 << fls(max)) - 1;
+        unsigned int invert = mc->invert;
+        unsigned int val, val_mask;
+        int ret;
+
+        if (invert)
+                val = (max - ucontrol->value.integer.value[0]) & mask;
+        else
+                val = ((ucontrol->value.integer.value[0] + min) & mask);
+        val_mask = mask << shift;
+        val = val << shift;
+
+        ret = snd_soc_component_update_bits(component, reg, val_mask, val);
+        if (ret < 0)
+                return ret;
+
+        if (snd_soc_volsw_is_stereo(mc)) {
+                if (invert)
+                        val = (max - ucontrol->value.integer.value[1]) & mask;
+                else
+                        val = ((ucontrol->value.integer.value[1] + min) & mask);
+                val_mask = mask << shift;
+                val = val << shift;
+
+                ret = snd_soc_component_update_bits(component, rreg, val_mask,
+                        val);
+        }
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(snd_soc_put_volsw_range);
+
+/**
+ * snd_soc_get_volsw_range - single mixer get callback with range
+ * @kcontrol: mixer control
+ * @ucontrol: control element information
+ *
+ * Callback to get the value, within a range, of a single mixer control.
+ *
+ * Returns 0 for success.
+ */
+int snd_soc_get_volsw_range(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
+        struct soc_mixer_control *mc =
+                (struct soc_mixer_control *)kcontrol->private_value;
+        unsigned int reg = mc->reg;
+        unsigned int rreg = mc->rreg;
+        unsigned int shift = mc->shift;
+        int min = mc->min;
+        int max = mc->max;
+        unsigned int mask = (1 << fls(max)) - 1;
+        unsigned int invert = mc->invert;
+        unsigned int val;
+        int ret;
+
+        ret = snd_soc_component_read(component, reg, &val);
+        if (ret)
+                return ret;
+
+        ucontrol->value.integer.value[0] = (val >> shift) & mask;
+        if (invert)
+                ucontrol->value.integer.value[0] =
+                        max - ucontrol->value.integer.value[0];
+        else
+                ucontrol->value.integer.value[0] =
+                        ucontrol->value.integer.value[0] - min;
+
+        if (snd_soc_volsw_is_stereo(mc)) {
+                ret = snd_soc_component_read(component, rreg, &val);
+                if (ret)
+                        return ret;
+
+                ucontrol->value.integer.value[1] = (val >> shift) & mask;
+                if (invert)
+                        ucontrol->value.integer.value[1] =
+                                max - ucontrol->value.integer.value[1];
+                else
+                        ucontrol->value.integer.value[1] =
+                                ucontrol->value.integer.value[1] - min;
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(snd_soc_get_volsw_range);
+
+/**
+ * snd_soc_limit_volume - Set new limit to an existing volume control.
+ *
+ * @codec: where to look for the control
+ * @name: Name of the control
+ * @max: new maximum limit
+ *
+ * Return 0 for success, else error.
+ */
+int snd_soc_limit_volume(struct snd_soc_codec *codec,
+        const char *name, int max)
+{
+        struct snd_card *card = codec->component.card->snd_card;
+        struct snd_kcontrol *kctl;
+        struct soc_mixer_control *mc;
+        int found = 0;
+        int ret = -EINVAL;
+
+        /* Sanity check for name and max */
+        if (unlikely(!name || max <= 0))
+                return -EINVAL;
+
+        list_for_each_entry(kctl, &card->controls, list) {
+                if (!strncmp(kctl->id.name, name, sizeof(kctl->id.name))) {
+                        found = 1;
+                        break;
+                }
+        }
+        if (found) {
+                mc = (struct soc_mixer_control *)kctl->private_value;
+                if (max <= mc->max) {
+                        mc->platform_max = max;
+                        ret = 0;
+                }
+        }
+        return ret;
+}
+EXPORT_SYMBOL_GPL(snd_soc_limit_volume);
+
+int snd_soc_bytes_info(struct snd_kcontrol *kcontrol,
+                       struct snd_ctl_elem_info *uinfo)
+{
+        struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
+        struct soc_bytes *params = (void *)kcontrol->private_value;
+
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES;
+        uinfo->count = params->num_regs * component->val_bytes;
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(snd_soc_bytes_info);
+
+int snd_soc_bytes_get(struct snd_kcontrol *kcontrol,
+                      struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
+        struct soc_bytes *params = (void *)kcontrol->private_value;
+        int ret;
+
+        if (component->regmap)
+                ret = regmap_raw_read(component->regmap, params->base,
+                                      ucontrol->value.bytes.data,
+                                      params->num_regs * component->val_bytes);
+        else
+                ret = -EINVAL;
+
+        /* Hide any masked bytes to ensure consistent data reporting */
+        if (ret == 0 && params->mask) {
+                switch (component->val_bytes) {
+                case 1:
+                        ucontrol->value.bytes.data[0] &= ~params->mask;
+                        break;
+                case 2:
+                        ((u16 *)(&ucontrol->value.bytes.data))[0]
+                                &= cpu_to_be16(~params->mask);
+                        break;
+                case 4:
+                        ((u32 *)(&ucontrol->value.bytes.data))[0]
+                                &= cpu_to_be32(~params->mask);
+                        break;
+                default:
+                        return -EINVAL;
+                }
+        }
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(snd_soc_bytes_get);
+
+int snd_soc_bytes_put(struct snd_kcontrol *kcontrol,
+                      struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
+        struct soc_bytes *params = (void *)kcontrol->private_value;
+        int ret, len;
+        unsigned int val, mask;
+        void *data;
+
+        if (!component->regmap || !params->num_regs)
+                return -EINVAL;
+
+        len = params->num_regs * component->val_bytes;
+
+        data = kmemdup(ucontrol->value.bytes.data, len, GFP_KERNEL | GFP_DMA);
+        if (!data)
+                return -ENOMEM;
+
+        /*
+         * If we've got a mask then we need to preserve the register
+         * bits.  We shouldn't modify the incoming data so take a
+         * copy.
+         */
+        if (params->mask) {
+                ret = regmap_read(component->regmap, params->base, &val);
+                if (ret != 0)
+                        goto out;
+
+                val &= params->mask;
+
+                switch (component->val_bytes) {
+                case 1:
+                        ((u8 *)data)[0] &= ~params->mask;
+                        ((u8 *)data)[0] |= val;
+                        break;
+                case 2:
+                        mask = ~params->mask;
+                        ret = regmap_parse_val(component->regmap,
+                                                        &mask, &mask);
+                        if (ret != 0)
+                                goto out;
+
+                        ((u16 *)data)[0] &= mask;
+
+                        ret = regmap_parse_val(component->regmap,
+                                                        &val, &val);
+                        if (ret != 0)
+                                goto out;
+
+                        ((u16 *)data)[0] |= val;
+                        break;
+                case 4:
+                        mask = ~params->mask;
+                        ret = regmap_parse_val(component->regmap,
+                                                        &mask, &mask);
+                        if (ret != 0)
+                                goto out;
+
+                        ((u32 *)data)[0] &= mask;
+
+                        ret = regmap_parse_val(component->regmap,
+                                                        &val, &val);
+                        if (ret != 0)
+                                goto out;
+
+                        ((u32 *)data)[0] |= val;
+                        break;
+                default:
+                        ret = -EINVAL;
+                        goto out;
+                }
+        }
+
+        ret = regmap_raw_write(component->regmap, params->base,
+                               data, len);
+
+out:
+        kfree(data);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(snd_soc_bytes_put);
+
+int snd_soc_bytes_info_ext(struct snd_kcontrol *kcontrol,
+                        struct snd_ctl_elem_info *ucontrol)
+{
+        struct soc_bytes_ext *params = (void *)kcontrol->private_value;
+
+        ucontrol->type = SNDRV_CTL_ELEM_TYPE_BYTES;
+        ucontrol->count = params->max;
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(snd_soc_bytes_info_ext);
+
+int snd_soc_bytes_tlv_callback(struct snd_kcontrol *kcontrol, int op_flag,
+                                unsigned int size, unsigned int __user *tlv)
+{
+        struct soc_bytes_ext *params = (void *)kcontrol->private_value;
+        unsigned int count = size < params->max ? size : params->max;
+        int ret = -ENXIO;
+
+        switch (op_flag) {
+        case SNDRV_CTL_TLV_OP_READ:
+                if (params->get)
+                        ret = params->get(tlv, count);
+                break;
+        case SNDRV_CTL_TLV_OP_WRITE:
+                if (params->put)
+                        ret = params->put(tlv, count);
+                break;
+        }
+        return ret;
+}
+EXPORT_SYMBOL_GPL(snd_soc_bytes_tlv_callback);
+
+/**
+ * snd_soc_info_xr_sx - signed multi register info callback
+ * @kcontrol: mreg control
+ * @uinfo: control element information
+ *
+ * Callback to provide information of a control that can
+ * span multiple codec registers which together
+ * forms a single signed value in a MSB/LSB manner.
+ *
+ * Returns 0 for success.
+ */
+int snd_soc_info_xr_sx(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_info *uinfo)
+{
+        struct soc_mreg_control *mc =
+                (struct soc_mreg_control *)kcontrol->private_value;
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+        uinfo->count = 1;
+        uinfo->value.integer.min = mc->min;
+        uinfo->value.integer.max = mc->max;
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(snd_soc_info_xr_sx);
+
+/**
+ * snd_soc_get_xr_sx - signed multi register get callback
+ * @kcontrol: mreg control
+ * @ucontrol: control element information
+ *
+ * Callback to get the value of a control that can span
+ * multiple codec registers which together forms a single
+ * signed value in a MSB/LSB manner. The control supports
+ * specifying total no of bits used to allow for bitfields
+ * across the multiple codec registers.
+ *
+ * Returns 0 for success.
+ */
+int snd_soc_get_xr_sx(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
+        struct soc_mreg_control *mc =
+                (struct soc_mreg_control *)kcontrol->private_value;
+        unsigned int regbase = mc->regbase;
+        unsigned int regcount = mc->regcount;
+        unsigned int regwshift = component->val_bytes * BITS_PER_BYTE;
+        unsigned int regwmask = (1<<regwshift)-1;
+        unsigned int invert = mc->invert;
+        unsigned long mask = (1UL<<mc->nbits)-1;
+        long min = mc->min;
+        long max = mc->max;
+        long val = 0;
+        unsigned int regval;
+        unsigned int i;
+        int ret;
+
+        for (i = 0; i < regcount; i++) {
+                ret = snd_soc_component_read(component, regbase+i, &regval);
+                if (ret)
+                        return ret;
+                val |= (regval & regwmask) << (regwshift*(regcount-i-1));
+        }
+        val &= mask;
+        if (min < 0 && val > max)
+                val |= ~mask;
+        if (invert)
+                val = max - val;
+        ucontrol->value.integer.value[0] = val;
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(snd_soc_get_xr_sx);
+
+/**
+ * snd_soc_put_xr_sx - signed multi register get callback
+ * @kcontrol: mreg control
+ * @ucontrol: control element information
+ *
+ * Callback to set the value of a control that can span
+ * multiple codec registers which together forms a single
+ * signed value in a MSB/LSB manner. The control supports
+ * specifying total no of bits used to allow for bitfields
+ * across the multiple codec registers.
+ *
+ * Returns 0 for success.
+ */
+int snd_soc_put_xr_sx(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
+        struct soc_mreg_control *mc =
+                (struct soc_mreg_control *)kcontrol->private_value;
+        unsigned int regbase = mc->regbase;
+        unsigned int regcount = mc->regcount;
+        unsigned int regwshift = component->val_bytes * BITS_PER_BYTE;
+        unsigned int regwmask = (1<<regwshift)-1;
+        unsigned int invert = mc->invert;
+        unsigned long mask = (1UL<<mc->nbits)-1;
+        long max = mc->max;
+        long val = ucontrol->value.integer.value[0];
+        unsigned int i, regval, regmask;
+        int err;
+
+        if (invert)
+                val = max - val;
+        val &= mask;
+        for (i = 0; i < regcount; i++) {
+                regval = (val >> (regwshift*(regcount-i-1))) & regwmask;
+                regmask = (mask >> (regwshift*(regcount-i-1))) & regwmask;
+                err = snd_soc_component_update_bits(component, regbase+i,
+                                regmask, regval);
+                if (err < 0)
+                        return err;
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(snd_soc_put_xr_sx);
+
+/**
+ * snd_soc_get_strobe - strobe get callback
+ * @kcontrol: mixer control
+ * @ucontrol: control element information
+ *
+ * Callback get the value of a strobe mixer control.
+ *
+ * Returns 0 for success.
+ */
+int snd_soc_get_strobe(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
+        struct soc_mixer_control *mc =
+                (struct soc_mixer_control *)kcontrol->private_value;
+        unsigned int reg = mc->reg;
+        unsigned int shift = mc->shift;
+        unsigned int mask = 1 << shift;
+        unsigned int invert = mc->invert != 0;
+        unsigned int val;
+        int ret;
+
+        ret = snd_soc_component_read(component, reg, &val);
+        if (ret)
+                return ret;
+
+        val &= mask;
+
+        if (shift != 0 && val != 0)
+                val = val >> shift;
+        ucontrol->value.enumerated.item[0] = val ^ invert;
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(snd_soc_get_strobe);
+
+/**
+ * snd_soc_put_strobe - strobe put callback
+ * @kcontrol: mixer control
+ * @ucontrol: control element information
+ *
+ * Callback strobe a register bit to high then low (or the inverse)
+ * in one pass of a single mixer enum control.
+ *
+ * Returns 1 for success.
+ */
+int snd_soc_put_strobe(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
+        struct soc_mixer_control *mc =
+                (struct soc_mixer_control *)kcontrol->private_value;
+        unsigned int reg = mc->reg;
+        unsigned int shift = mc->shift;
+        unsigned int mask = 1 << shift;
+        unsigned int invert = mc->invert != 0;
+        unsigned int strobe = ucontrol->value.enumerated.item[0] != 0;
+        unsigned int val1 = (strobe ^ invert) ? mask : 0;
+        unsigned int val2 = (strobe ^ invert) ? 0 : mask;
+        int err;
+
+        err = snd_soc_component_update_bits(component, reg, mask, val1);
+        if (err < 0)
+                return err;
+
+        return snd_soc_component_update_bits(component, reg, mask, val2);
+}
+EXPORT_SYMBOL_GPL(snd_soc_put_strobe);
diff --git a/sound/soc/soc-pcm.c b/sound/soc/soc-pcm.c
index 002311afdeaa..5de2440ff25c 100644
--- a/sound/soc/soc-pcm.c
+++ b/sound/soc/soc-pcm.c
@@ -654,6 +654,8 @@ static int soc_pcm_close(struct snd_pcm_substream *substream)
                         codec_dai->rate = 0;
         }
 
+        snd_soc_dai_digital_mute(cpu_dai, 1, substream->stream);
+
         if (cpu_dai->driver->ops->shutdown)
                 cpu_dai->driver->ops->shutdown(substream, cpu_dai);
 
@@ -772,6 +774,7 @@ static int soc_pcm_prepare(struct snd_pcm_substream *substream)
         for (i = 0; i < rtd->num_codecs; i++)
                 snd_soc_dai_digital_mute(rtd->codec_dais[i], 0,
                                          substream->stream);
+        snd_soc_dai_digital_mute(cpu_dai, 0, substream->stream);
 
 out:
         mutex_unlock(&rtd->pcm_mutex);
@@ -1522,13 +1525,36 @@ static void dpcm_set_fe_runtime(struct snd_pcm_substream *substream)
                 dpcm_init_runtime_hw(runtime, &cpu_dai_drv->capture);
 }
 
+static int dpcm_fe_dai_do_trigger(struct snd_pcm_substream *substream, int cmd);
+
+/* Set FE's runtime_update state; the state is protected via PCM stream lock
+ * for avoiding the race with trigger callback.
+ * If the state is unset and a trigger is pending while the previous operation,
+ * process the pending trigger action here.
+ */
+static void dpcm_set_fe_update_state(struct snd_soc_pcm_runtime *fe,
+                                     int stream, enum snd_soc_dpcm_update state)
+{
+        struct snd_pcm_substream *substream =
+                snd_soc_dpcm_get_substream(fe, stream);
+
+        snd_pcm_stream_lock_irq(substream);
+        if (state == SND_SOC_DPCM_UPDATE_NO && fe->dpcm[stream].trigger_pending) {
+                dpcm_fe_dai_do_trigger(substream,
+                                       fe->dpcm[stream].trigger_pending - 1);
+                fe->dpcm[stream].trigger_pending = 0;
+        }
+        fe->dpcm[stream].runtime_update = state;
+        snd_pcm_stream_unlock_irq(substream);
+}
+
 static int dpcm_fe_dai_startup(struct snd_pcm_substream *fe_substream)
 {
         struct snd_soc_pcm_runtime *fe = fe_substream->private_data;
         struct snd_pcm_runtime *runtime = fe_substream->runtime;
         int stream = fe_substream->stream, ret = 0;
 
-        fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
+        dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_FE);
 
         ret = dpcm_be_dai_startup(fe, fe_substream->stream);
         if (ret < 0) {
@@ -1550,13 +1576,13 @@ static int dpcm_fe_dai_startup(struct snd_pcm_substream *fe_substream)
         dpcm_set_fe_runtime(fe_substream);
         snd_pcm_limit_hw_rates(runtime);
 
-        fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
+        dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_NO);
         return 0;
 
 unwind:
         dpcm_be_dai_startup_unwind(fe, fe_substream->stream);
 be_err:
-        fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
+        dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_NO);
         return ret;
 }
 
@@ -1603,7 +1629,7 @@ static int dpcm_fe_dai_shutdown(struct snd_pcm_substream *substream)
         struct snd_soc_pcm_runtime *fe = substream->private_data;
         int stream = substream->stream;
 
-        fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
+        dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_FE);
 
         /* shutdown the BEs */
         dpcm_be_dai_shutdown(fe, substream->stream);
@@ -1617,7 +1643,7 @@ static int dpcm_fe_dai_shutdown(struct snd_pcm_substream *substream)
         dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_STOP);
 
         fe->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE;
-        fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
+        dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_NO);
         return 0;
 }
 
@@ -1641,6 +1667,10 @@ int dpcm_be_dai_hw_free(struct snd_soc_pcm_runtime *fe, int stream)
                 if (!snd_soc_dpcm_can_be_free_stop(fe, be, stream))
                                 continue;
 
+                /* do not free hw if this BE is used by other FE */
+                if (be->dpcm[stream].users > 1)
+                        continue;
+
                 if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_PARAMS) &&
                     (be->dpcm[stream].state != SND_SOC_DPCM_STATE_PREPARE) &&
                     (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_FREE) &&
@@ -1665,7 +1695,7 @@ static int dpcm_fe_dai_hw_free(struct snd_pcm_substream *substream)
         int err, stream = substream->stream;
 
         mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
-        fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
+        dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_FE);
 
         dev_dbg(fe->dev, "ASoC: hw_free FE %s\n", fe->dai_link->name);
 
@@ -1680,7 +1710,7 @@ static int dpcm_fe_dai_hw_free(struct snd_pcm_substream *substream)
         err = dpcm_be_dai_hw_free(fe, stream);
 
         fe->dpcm[stream].state = SND_SOC_DPCM_STATE_HW_FREE;
-        fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
+        dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_NO);
 
         mutex_unlock(&fe->card->mutex);
         return 0;
@@ -1773,7 +1803,7 @@ static int dpcm_fe_dai_hw_params(struct snd_pcm_substream *substream,
         int ret, stream = substream->stream;
 
         mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
-        fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
+        dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_FE);
 
         memcpy(&fe->dpcm[substream->stream].hw_params, params,
                         sizeof(struct snd_pcm_hw_params));
@@ -1796,7 +1826,7 @@ static int dpcm_fe_dai_hw_params(struct snd_pcm_substream *substream,
                 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_HW_PARAMS;
 
 out:
-        fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
+        dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_NO);
         mutex_unlock(&fe->card->mutex);
         return ret;
 }
@@ -1910,7 +1940,7 @@ int dpcm_be_dai_trigger(struct snd_soc_pcm_runtime *fe, int stream,
 }
 EXPORT_SYMBOL_GPL(dpcm_be_dai_trigger);
 
-static int dpcm_fe_dai_trigger(struct snd_pcm_substream *substream, int cmd)
+static int dpcm_fe_dai_do_trigger(struct snd_pcm_substream *substream, int cmd)
 {
         struct snd_soc_pcm_runtime *fe = substream->private_data;
         int stream = substream->stream, ret;
@@ -1984,6 +2014,23 @@ out:
         return ret;
 }
 
+static int dpcm_fe_dai_trigger(struct snd_pcm_substream *substream, int cmd)
+{
+        struct snd_soc_pcm_runtime *fe = substream->private_data;
+        int stream = substream->stream;
+
+        /* if FE's runtime_update is already set, we're in race;
+         * process this trigger later at exit
+         */
+        if (fe->dpcm[stream].runtime_update != SND_SOC_DPCM_UPDATE_NO) {
+                fe->dpcm[stream].trigger_pending = cmd + 1;
+                return 0; /* delayed, assuming it's successful */
+        }
+
+        /* we're alone, let's trigger */
+        return dpcm_fe_dai_do_trigger(substream, cmd);
+}
+
 int dpcm_be_dai_prepare(struct snd_soc_pcm_runtime *fe, int stream)
 {
         struct snd_soc_dpcm *dpcm;
@@ -2027,7 +2074,7 @@ static int dpcm_fe_dai_prepare(struct snd_pcm_substream *substream)
 
         dev_dbg(fe->dev, "ASoC: prepare FE %s\n", fe->dai_link->name);
 
-        fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
+        dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_FE);
 
         /* there is no point preparing this FE if there are no BEs */
         if (list_empty(&fe->dpcm[stream].be_clients)) {
@@ -2054,7 +2101,7 @@ static int dpcm_fe_dai_prepare(struct snd_pcm_substream *substream)
         fe->dpcm[stream].state = SND_SOC_DPCM_STATE_PREPARE;
 
 out:
-        fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
+        dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_NO);
         mutex_unlock(&fe->card->mutex);
 
         return ret;
@@ -2201,11 +2248,11 @@ static int dpcm_run_new_update(struct snd_soc_pcm_runtime *fe, int stream)
 {
         int ret;
 
-        fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_BE;
+        dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_BE);
         ret = dpcm_run_update_startup(fe, stream);
         if (ret < 0)
                 dev_err(fe->dev, "ASoC: failed to startup some BEs\n");
-        fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
+        dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_NO);
 
         return ret;
 }
@@ -2214,11 +2261,11 @@ static int dpcm_run_old_update(struct snd_soc_pcm_runtime *fe, int stream)
 {
         int ret;
 
-        fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_BE;
+        dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_BE);
         ret = dpcm_run_update_shutdown(fe, stream);
         if (ret < 0)
                 dev_err(fe->dev, "ASoC: failed to shutdown some BEs\n");
-        fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
+        dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_NO);
 
         return ret;
 }
diff --git a/sound/soc/txx9/txx9aclc.c b/sound/soc/txx9/txx9aclc.c
index cd71fd889d8b..00b7e2d02690 100644
--- a/sound/soc/txx9/txx9aclc.c
+++ b/sound/soc/txx9/txx9aclc.c
@@ -292,7 +292,7 @@ static int txx9aclc_pcm_new(struct snd_soc_pcm_runtime *rtd)
         struct snd_card *card = rtd->card->snd_card;
         struct snd_soc_dai *dai = rtd->cpu_dai;
         struct snd_pcm *pcm = rtd->pcm;
-        struct platform_device *pdev = to_platform_device(dai->platform->dev);
+        struct platform_device *pdev = to_platform_device(rtd->platform->dev);
         struct txx9aclc_soc_device *dev;
         struct resource *r;
         int i;
diff --git a/sound/usb/card.c b/sound/usb/card.c
index 7ecd0e8a5c51..f61ebb17cc64 100644
--- a/sound/usb/card.c
+++ b/sound/usb/card.c
@@ -591,18 +591,19 @@ static void snd_usb_audio_disconnect(struct usb_device *dev,
 {
         struct snd_card *card;
         struct list_head *p;
+        bool was_shutdown;
 
         if (chip == (void *)-1L)
                 return;
 
         card = chip->card;
         down_write(&chip->shutdown_rwsem);
+        was_shutdown = chip->shutdown;
         chip->shutdown = 1;
         up_write(&chip->shutdown_rwsem);
 
         mutex_lock(&register_mutex);
-        chip->num_interfaces--;
-        if (chip->num_interfaces <= 0) {
+        if (!was_shutdown) {
                 struct snd_usb_endpoint *ep;
 
                 snd_card_disconnect(card);
@@ -622,6 +623,10 @@ static void snd_usb_audio_disconnect(struct usb_device *dev,
                 list_for_each(p, &chip->mixer_list) {
                         snd_usb_mixer_disconnect(p);
                 }
+        }
+
+        chip->num_interfaces--;
+        if (chip->num_interfaces <= 0) {
                 usb_chip[chip->index] = NULL;
                 mutex_unlock(&register_mutex);
                 snd_card_free_when_closed(card);
diff --git a/sound/usb/mixer.c b/sound/usb/mixer.c
index 2e4a9dbc51fa..6e354d326858 100644
--- a/sound/usb/mixer.c
+++ b/sound/usb/mixer.c
@@ -2033,10 +2033,11 @@ static int parse_audio_selector_unit(struct mixer_build *state, int unitid,
         cval->res = 1;
         cval->initialized = 1;
 
-        if (desc->bDescriptorSubtype == UAC2_CLOCK_SELECTOR)
-                cval->control = UAC2_CX_CLOCK_SELECTOR;
-        else
+        if (state->mixer->protocol == UAC_VERSION_1)
                 cval->control = 0;
+        else /* UAC_VERSION_2 */
+                cval->control = (desc->bDescriptorSubtype == UAC2_CLOCK_SELECTOR) ?
+                        UAC2_CX_CLOCK_SELECTOR : UAC2_SU_SELECTOR;
 
         namelist = kmalloc(sizeof(char *) * desc->bNrInPins, GFP_KERNEL);
         if (!namelist) {
diff --git a/sound/usb/mixer_quirks.c b/sound/usb/mixer_quirks.c
index f119a41ed9a9..8c9bf4b7aaf0 100644
--- a/sound/usb/mixer_quirks.c
+++ b/sound/usb/mixer_quirks.c
@@ -593,10 +593,10 @@ static int snd_nativeinstruments_control_get(struct snd_kcontrol *kcontrol,
         if (mixer->chip->shutdown)
                 ret = -ENODEV;
         else
-                ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), bRequest,
+                ret = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), bRequest,
                                   USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
                                   0, wIndex,
-                                  &tmp, sizeof(tmp), 1000);
+                                  &tmp, sizeof(tmp));
         up_read(&mixer->chip->shutdown_rwsem);
 
         if (ret < 0) {
@@ -885,6 +885,11 @@ static int snd_ftu_eff_switch_put(struct snd_kcontrol *kctl,
         return changed;
 }
 
+static void kctl_private_value_free(struct snd_kcontrol *kctl)
+{
+        kfree((void *)kctl->private_value);
+}
+
 static int snd_ftu_create_effect_switch(struct usb_mixer_interface *mixer,
         int validx, int bUnitID)
 {
@@ -919,6 +924,7 @@ static int snd_ftu_create_effect_switch(struct usb_mixer_interface *mixer,
                 return -ENOMEM;
         }
 
+        kctl->private_free = kctl_private_value_free;
         err = snd_ctl_add(mixer->chip->card, kctl);
         if (err < 0)
                 return err;
diff --git a/sound/usb/quirks-table.h b/sound/usb/quirks-table.h
index 223c47b33ba3..c657752a420c 100644
--- a/sound/usb/quirks-table.h
+++ b/sound/usb/quirks-table.h
@@ -385,6 +385,36 @@ YAMAHA_DEVICE(0x105d, NULL),
         }
 },
 {
+        USB_DEVICE(0x0499, 0x1509),
+        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
+                /* .vendor_name = "Yamaha", */
+                /* .product_name = "Steinberg UR22", */
+                .ifnum = QUIRK_ANY_INTERFACE,
+                .type = QUIRK_COMPOSITE,
+                .data = (const struct snd_usb_audio_quirk[]) {
+                        {
+                                .ifnum = 1,
+                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
+                        },
+                        {
+                                .ifnum = 2,
+                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
+                        },
+                        {
+                                .ifnum = 3,
+                                .type = QUIRK_MIDI_YAMAHA
+                        },
+                        {
+                                .ifnum = 4,
+                                .type = QUIRK_IGNORE_INTERFACE
+                        },
+                        {
+                                .ifnum = -1
+                        }
+                }
+        }
+},
+{
         USB_DEVICE(0x0499, 0x150a),
         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
                 /* .vendor_name = "Yamaha", */
diff --git a/sound/usb/quirks.c b/sound/usb/quirks.c
index d2aa45a8d895..60dfe0d28771 100644
--- a/sound/usb/quirks.c
+++ b/sound/usb/quirks.c
@@ -1146,6 +1146,20 @@ void snd_usb_ctl_msg_quirk(struct usb_device *dev, unsigned int pipe,
         if ((le16_to_cpu(dev->descriptor.idVendor) == 0x23ba) &&
             (requesttype & USB_TYPE_MASK) == USB_TYPE_CLASS)
                 mdelay(20);
+
+        /* Marantz/Denon devices with USB DAC functionality need a delay
+         * after each class compliant request
+         */
+        if ((le16_to_cpu(dev->descriptor.idVendor) == 0x154e) &&
+            (requesttype & USB_TYPE_MASK) == USB_TYPE_CLASS) {
+
+                switch (le16_to_cpu(dev->descriptor.idProduct)) {
+                case 0x3005: /* Marantz HD-DAC1 */
+                case 0x3006: /* Marantz SA-14S1 */
+                        mdelay(20);
+                        break;
+                }
+        }
 }
 
 /*
@@ -1179,12 +1193,12 @@ u64 snd_usb_interface_dsd_format_quirks(struct snd_usb_audio *chip,
         /* iFi Audio micro/nano iDSD */
         case USB_ID(0x20b1, 0x3008):
                 if (fp->altsetting == 2)
-                        return SNDRV_PCM_FMTBIT_DSD_U32_LE;
+                        return SNDRV_PCM_FMTBIT_DSD_U32_BE;
                 break;
         /* DIYINHK DSD DXD 384kHz USB to I2S/DSD */
         case USB_ID(0x20b1, 0x2009):
                 if (fp->altsetting == 3)
-                        return SNDRV_PCM_FMTBIT_DSD_U32_LE;
+                        return SNDRV_PCM_FMTBIT_DSD_U32_BE;
                 break;
         default:
                 break;