105 files changed, 4183 insertions, 1087 deletions

diff --git a/MAINTAINERS b/MAINTAINERS
index 783569e3c4b4..24e29b2e53c9 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -8044,6 +8044,7 @@ S:	Maintained
 F:      drivers/video/fbdev/i810/
 
 INTEL ASoC DRIVERS
+M:      Cezary Rojewski <cezary.rojewski@intel.com>
 M:      Pierre-Louis Bossart <pierre-louis.bossart@linux.intel.com>
 M:      Liam Girdwood <liam.r.girdwood@linux.intel.com>
 M:      Jie Yang <yang.jie@linux.intel.com>
@@ -16078,7 +16079,7 @@ S:	Maintained
 F:      drivers/net/ethernet/ti/netcp*
 
 TI PCM3060 ASoC CODEC DRIVER
-M:      Kirill Marinushkin <kmarinushkin@birdec.tech>
+M:      Kirill Marinushkin <kmarinushkin@birdec.com>
 L:      alsa-devel@alsa-project.org (moderated for non-subscribers)
 S:      Maintained
 F:      Documentation/devicetree/bindings/sound/pcm3060.txt
diff --git a/include/sound/compress_driver.h b/include/sound/compress_driver.h
index c5188ff724d1..bc88d6f964da 100644
--- a/include/sound/compress_driver.h
+++ b/include/sound/compress_driver.h
@@ -173,10 +173,7 @@ static inline void snd_compr_drain_notify(struct snd_compr_stream *stream)
         if (snd_BUG_ON(!stream))
                 return;
 
-        if (stream->direction == SND_COMPRESS_PLAYBACK)
-                stream->runtime->state = SNDRV_PCM_STATE_SETUP;
-        else
-                stream->runtime->state = SNDRV_PCM_STATE_PREPARED;
+        stream->runtime->state = SNDRV_PCM_STATE_SETUP;
 
         wake_up(&stream->runtime->sleep);
 }
diff --git a/sound/soc/intel/skylake/skl-nhlt.h b/include/sound/intel-nhlt.h
index f85fbf9c7ce4..f657fd8fc0ad 100644
--- a/sound/soc/intel/skylake/skl-nhlt.h
+++ b/include/sound/intel-nhlt.h
@@ -1,18 +1,17 @@
 /* SPDX-License-Identifier: GPL-2.0-only */
 /*
- *  skl-nhlt.h - Intel HDA Platform NHLT header
+ *  intel-nhlt.h - Intel HDA Platform NHLT header
  *
- *  Copyright (C) 2015 Intel Corp
- *  Author: Sanjiv Kumar <sanjiv.kumar@intel.com>
- *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- *
- * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *  Copyright (c) 2015-2019 Intel Corporation
  */
-#ifndef __SKL_NHLT_H__
-#define __SKL_NHLT_H__
+
+#ifndef __INTEL_NHLT_H__
+#define __INTEL_NHLT_H__
 
 #include <linux/acpi.h>
 
+#if IS_ENABLED(CONFIG_ACPI) && IS_ENABLED(CONFIG_SND_INTEL_NHLT)
+
 struct wav_fmt {
         u16 fmt_tag;
         u16 channels;
@@ -97,16 +96,22 @@ struct nhlt_resource_desc  {
 #define MIC_ARRAY_2CH 2
 #define MIC_ARRAY_4CH 4
 
-struct nhlt_tdm_config {
+struct nhlt_device_specific_config {
         u8 virtual_slot;
         u8 config_type;
 } __packed;
 
 struct nhlt_dmic_array_config {
-        struct nhlt_tdm_config tdm_config;
+        struct nhlt_device_specific_config device_config;
         u8 array_type;
 } __packed;
 
+struct nhlt_vendor_dmic_array_config {
+        struct nhlt_dmic_array_config dmic_config;
+        u8 nb_mics;
+        /* TODO add vendor mic config */
+} __packed;
+
 enum {
         NHLT_MIC_ARRAY_2CH_SMALL = 0xa,
         NHLT_MIC_ARRAY_2CH_BIG = 0xb,
@@ -116,4 +121,30 @@ enum {
         NHLT_MIC_ARRAY_VENDOR_DEFINED = 0xf,
 };
 
+struct nhlt_acpi_table *intel_nhlt_init(struct device *dev);
+
+void intel_nhlt_free(struct nhlt_acpi_table *addr);
+
+int intel_nhlt_get_dmic_geo(struct device *dev, struct nhlt_acpi_table *nhlt);
+
+#else
+
+struct nhlt_acpi_table;
+
+static inline struct nhlt_acpi_table *intel_nhlt_init(struct device *dev)
+{
+        return NULL;
+}
+
+static inline void intel_nhlt_free(struct nhlt_acpi_table *addr)
+{
+}
+
+static inline int intel_nhlt_get_dmic_geo(struct device *dev,
+                                          struct nhlt_acpi_table *nhlt)
+{
+        return 0;
+}
+#endif
+
 #endif
diff --git a/include/sound/simple_card_utils.h b/include/sound/simple_card_utils.h
index 954563ee2277..985a5f583de4 100644
--- a/include/sound/simple_card_utils.h
+++ b/include/sound/simple_card_utils.h
@@ -141,6 +141,10 @@ inline void asoc_simple_debug_dai(struct asoc_simple_priv *priv,
 {
         struct device *dev = simple_priv_to_dev(priv);
 
+        /* dai might be NULL */
+        if (!dai)
+                return;
+
         if (dai->name)
                 dev_dbg(dev, "%s dai name = %s\n",
                         name, dai->name);
diff --git a/include/uapi/sound/sof/fw.h b/include/uapi/sound/sof/fw.h
index 1afca973eb09..e9f697467a86 100644
--- a/include/uapi/sound/sof/fw.h
+++ b/include/uapi/sound/sof/fw.h
@@ -13,6 +13,8 @@
 #ifndef __INCLUDE_UAPI_SOF_FW_H__
 #define __INCLUDE_UAPI_SOF_FW_H__
 
+#include <linux/types.h>
+
 #define SND_SOF_FW_SIG_SIZE     4
 #define SND_SOF_FW_ABI          1
 #define SND_SOF_FW_SIG          "Reef"
@@ -46,8 +48,8 @@ enum snd_sof_fw_blk_type {
 
 struct snd_sof_blk_hdr {
         enum snd_sof_fw_blk_type type;
-        uint32_t size;          /* bytes minus this header */
-        uint32_t offset;        /* offset from base */
+        __u32 size;             /* bytes minus this header */
+        __u32 offset;           /* offset from base */
 } __packed;
 
 /*
@@ -61,8 +63,8 @@ enum snd_sof_fw_mod_type {
 
 struct snd_sof_mod_hdr {
         enum snd_sof_fw_mod_type type;
-        uint32_t size;          /* bytes minus this header */
-        uint32_t num_blocks;    /* number of blocks */
+        __u32 size;             /* bytes minus this header */
+        __u32 num_blocks;       /* number of blocks */
 } __packed;
 
 /*
@@ -70,9 +72,9 @@ struct snd_sof_mod_hdr {
  */
 struct snd_sof_fw_header {
         unsigned char sig[SND_SOF_FW_SIG_SIZE]; /* "Reef" */
-        uint32_t file_size;     /* size of file minus this header */
-        uint32_t num_modules;   /* number of modules */
-        uint32_t abi;           /* version of header format */
+        __u32 file_size;        /* size of file minus this header */
+        __u32 num_modules;      /* number of modules */
+        __u32 abi;              /* version of header format */
 } __packed;
 
 #endif
diff --git a/include/uapi/sound/sof/header.h b/include/uapi/sound/sof/header.h
index 7868990b0d6f..5f4518e7a972 100644
--- a/include/uapi/sound/sof/header.h
+++ b/include/uapi/sound/sof/header.h
@@ -9,6 +9,8 @@
 #ifndef __INCLUDE_UAPI_SOUND_SOF_USER_HEADER_H__
 #define __INCLUDE_UAPI_SOUND_SOF_USER_HEADER_H__
 
+#include <linux/types.h>
+
 /*
  * Header for all non IPC ABI data.
  *
@@ -16,12 +18,12 @@
  * Used by any bespoke component data structures or binary blobs.
  */
 struct sof_abi_hdr {
-        uint32_t magic;         /**< 'S', 'O', 'F', '\0' */
-        uint32_t type;          /**< component specific type */
-        uint32_t size;          /**< size in bytes of data excl. this struct */
-        uint32_t abi;           /**< SOF ABI version */
-        uint32_t reserved[4];   /**< reserved for future use */
-        uint32_t data[0];       /**< Component data - opaque to core */
+        __u32 magic;            /**< 'S', 'O', 'F', '\0' */
+        __u32 type;             /**< component specific type */
+        __u32 size;             /**< size in bytes of data excl. this struct */
+        __u32 abi;              /**< SOF ABI version */
+        __u32 reserved[4];      /**< reserved for future use */
+        __u32 data[0];          /**< Component data - opaque to core */
 }  __packed;
 
 #endif
diff --git a/sound/ac97/bus.c b/sound/ac97/bus.c
index 7b977b753a03..7985dd8198b6 100644
--- a/sound/ac97/bus.c
+++ b/sound/ac97/bus.c
@@ -122,17 +122,12 @@ static int ac97_codec_add(struct ac97_controller *ac97_ctrl, int idx,
                                                       vendor_id);
 
         ret = device_add(&codec->dev);
-        if (ret)
-                goto err_free_codec;
+        if (ret) {
+                put_device(&codec->dev);
+                return ret;
+        }
 
         return 0;
-err_free_codec:
-        of_node_put(codec->dev.of_node);
-        put_device(&codec->dev);
-        kfree(codec);
-        ac97_ctrl->codecs[idx] = NULL;
-
-        return ret;
 }
 
 unsigned int snd_ac97_bus_scan_one(struct ac97_controller *adrv,
diff --git a/sound/aoa/codecs/onyx.c b/sound/aoa/codecs/onyx.c
index db917546965d..9827bee109c1 100644
--- a/sound/aoa/codecs/onyx.c
+++ b/sound/aoa/codecs/onyx.c
@@ -71,8 +71,10 @@ static int onyx_read_register(struct onyx *onyx, u8 reg, u8 *value)
                 return 0;
         }
         v = i2c_smbus_read_byte_data(onyx->i2c, reg);
-        if (v < 0)
+        if (v < 0) {
+                *value = 0;
                 return -1;
+        }
         *value = (u8)v;
         onyx->cache[ONYX_REG_CONTROL-FIRSTREGISTER] = *value;
         return 0;
diff --git a/sound/core/compress_offload.c b/sound/core/compress_offload.c
index 99b882158705..41905afada63 100644
--- a/sound/core/compress_offload.c
+++ b/sound/core/compress_offload.c
@@ -574,10 +574,7 @@ snd_compr_set_params(struct snd_compr_stream *stream, unsigned long arg)
                 stream->metadata_set = false;
                 stream->next_track = false;
 
-                if (stream->direction == SND_COMPRESS_PLAYBACK)
-                        stream->runtime->state = SNDRV_PCM_STATE_SETUP;
-                else
-                        stream->runtime->state = SNDRV_PCM_STATE_PREPARED;
+                stream->runtime->state = SNDRV_PCM_STATE_SETUP;
         } else {
                 return -EPERM;
         }
@@ -693,8 +690,17 @@ static int snd_compr_start(struct snd_compr_stream *stream)
 {
         int retval;
 
-        if (stream->runtime->state != SNDRV_PCM_STATE_PREPARED)
+        switch (stream->runtime->state) {
+        case SNDRV_PCM_STATE_SETUP:
+                if (stream->direction != SND_COMPRESS_CAPTURE)
+                        return -EPERM;
+                break;
+        case SNDRV_PCM_STATE_PREPARED:
+                break;
+        default:
                 return -EPERM;
+        }
+
         retval = stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_START);
         if (!retval)
                 stream->runtime->state = SNDRV_PCM_STATE_RUNNING;
@@ -705,9 +711,15 @@ static int snd_compr_stop(struct snd_compr_stream *stream)
 {
         int retval;
 
-        if (stream->runtime->state == SNDRV_PCM_STATE_PREPARED ||
-                        stream->runtime->state == SNDRV_PCM_STATE_SETUP)
+        switch (stream->runtime->state) {
+        case SNDRV_PCM_STATE_OPEN:
+        case SNDRV_PCM_STATE_SETUP:
+        case SNDRV_PCM_STATE_PREPARED:
                 return -EPERM;
+        default:
+                break;
+        }
+
         retval = stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_STOP);
         if (!retval) {
                 snd_compr_drain_notify(stream);
@@ -795,9 +807,17 @@ static int snd_compr_drain(struct snd_compr_stream *stream)
 {
         int retval;
 
-        if (stream->runtime->state == SNDRV_PCM_STATE_PREPARED ||
-                        stream->runtime->state == SNDRV_PCM_STATE_SETUP)
+        switch (stream->runtime->state) {
+        case SNDRV_PCM_STATE_OPEN:
+        case SNDRV_PCM_STATE_SETUP:
+        case SNDRV_PCM_STATE_PREPARED:
+        case SNDRV_PCM_STATE_PAUSED:
                 return -EPERM;
+        case SNDRV_PCM_STATE_XRUN:
+                return -EPIPE;
+        default:
+                break;
+        }
 
         retval = stream->ops->trigger(stream, SND_COMPR_TRIGGER_DRAIN);
         if (retval) {
@@ -817,6 +837,10 @@ static int snd_compr_next_track(struct snd_compr_stream *stream)
         if (stream->runtime->state != SNDRV_PCM_STATE_RUNNING)
                 return -EPERM;
 
+        /* next track doesn't have any meaning for capture streams */
+        if (stream->direction == SND_COMPRESS_CAPTURE)
+                return -EPERM;
+
         /* you can signal next track if this is intended to be a gapless stream
          * and current track metadata is set
          */
@@ -834,9 +858,23 @@ static int snd_compr_next_track(struct snd_compr_stream *stream)
 static int snd_compr_partial_drain(struct snd_compr_stream *stream)
 {
         int retval;
-        if (stream->runtime->state == SNDRV_PCM_STATE_PREPARED ||
-                        stream->runtime->state == SNDRV_PCM_STATE_SETUP)
+
+        switch (stream->runtime->state) {
+        case SNDRV_PCM_STATE_OPEN:
+        case SNDRV_PCM_STATE_SETUP:
+        case SNDRV_PCM_STATE_PREPARED:
+        case SNDRV_PCM_STATE_PAUSED:
+                return -EPERM;
+        case SNDRV_PCM_STATE_XRUN:
+                return -EPIPE;
+        default:
+                break;
+        }
+
+        /* partial drain doesn't have any meaning for capture streams */
+        if (stream->direction == SND_COMPRESS_CAPTURE)
                 return -EPERM;
+
         /* stream can be drained only when next track has been signalled */
         if (stream->next_track == false)
                 return -EPERM;
diff --git a/sound/core/pcm_native.c b/sound/core/pcm_native.c
index 860543a4c840..703857aab00f 100644
--- a/sound/core/pcm_native.c
+++ b/sound/core/pcm_native.c
@@ -77,7 +77,7 @@ void snd_pcm_group_init(struct snd_pcm_group *group)
         spin_lock_init(&group->lock);
         mutex_init(&group->mutex);
         INIT_LIST_HEAD(&group->substreams);
-        refcount_set(&group->refs, 0);
+        refcount_set(&group->refs, 1);
 }
 
 /* define group lock helpers */
@@ -1096,8 +1096,7 @@ static void snd_pcm_group_unref(struct snd_pcm_group *group,
 
         if (!group)
                 return;
-        do_free = refcount_dec_and_test(&group->refs) &&
-                list_empty(&group->substreams);
+        do_free = refcount_dec_and_test(&group->refs);
         snd_pcm_group_unlock(group, substream->pcm->nonatomic);
         if (do_free)
                 kfree(group);
@@ -1874,6 +1873,7 @@ static int snd_pcm_drain(struct snd_pcm_substream *substream,
                 if (!to_check)
                         break; /* all drained */
                 init_waitqueue_entry(&wait, current);
+                set_current_state(TASK_INTERRUPTIBLE);
                 add_wait_queue(&to_check->sleep, &wait);
                 snd_pcm_stream_unlock_irq(substream);
                 if (runtime->no_period_wakeup)
@@ -1886,7 +1886,7 @@ static int snd_pcm_drain(struct snd_pcm_substream *substream,
                         }
                         tout = msecs_to_jiffies(tout * 1000);
                 }
-                tout = schedule_timeout_interruptible(tout);
+                tout = schedule_timeout(tout);
 
                 snd_pcm_stream_lock_irq(substream);
                 group = snd_pcm_stream_group_ref(substream);
@@ -2020,6 +2020,7 @@ static int snd_pcm_link(struct snd_pcm_substream *substream, int fd)
         snd_pcm_group_lock_irq(target_group, nonatomic);
         snd_pcm_stream_lock(substream1);
         snd_pcm_group_assign(substream1, target_group);
+        refcount_inc(&target_group->refs);
         snd_pcm_stream_unlock(substream1);
         snd_pcm_group_unlock_irq(target_group, nonatomic);
  _end:
@@ -2056,13 +2057,14 @@ static int snd_pcm_unlink(struct snd_pcm_substream *substream)
         snd_pcm_group_lock_irq(group, nonatomic);
 
         relink_to_local(substream);
+        refcount_dec(&group->refs);
 
         /* detach the last stream, too */
         if (list_is_singular(&group->substreams)) {
                 relink_to_local(list_first_entry(&group->substreams,
                                                  struct snd_pcm_substream,
                                                  link_list));
-                do_free = !refcount_read(&group->refs);
+                do_free = refcount_dec_and_test(&group->refs);
         }
 
         snd_pcm_group_unlock_irq(group, nonatomic);
diff --git a/sound/firewire/amdtp-am824.c b/sound/firewire/amdtp-am824.c
index fd5d6b8ac557..67d735e9a6a4 100644
--- a/sound/firewire/amdtp-am824.c
+++ b/sound/firewire/amdtp-am824.c
@@ -146,19 +146,24 @@ void amdtp_am824_set_midi_position(struct amdtp_stream *s,
 }
 EXPORT_SYMBOL_GPL(amdtp_am824_set_midi_position);
 
-static void write_pcm_s32(struct amdtp_stream *s,
-                          struct snd_pcm_substream *pcm,
-                          __be32 *buffer, unsigned int frames)
+static void write_pcm_s32(struct amdtp_stream *s, struct snd_pcm_substream *pcm,
+                          __be32 *buffer, unsigned int frames,
+                          unsigned int pcm_frames)
 {
         struct amdtp_am824 *p = s->protocol;
+        unsigned int channels = p->pcm_channels;
         struct snd_pcm_runtime *runtime = pcm->runtime;
-        unsigned int channels, remaining_frames, i, c;
+        unsigned int pcm_buffer_pointer;
+        int remaining_frames;
         const u32 *src;
+        int i, c;
+
+        pcm_buffer_pointer = s->pcm_buffer_pointer + pcm_frames;
+        pcm_buffer_pointer %= runtime->buffer_size;
 
-        channels = p->pcm_channels;
         src = (void *)runtime->dma_area +
-                        frames_to_bytes(runtime, s->pcm_buffer_pointer);
-        remaining_frames = runtime->buffer_size - s->pcm_buffer_pointer;
+                                frames_to_bytes(runtime, pcm_buffer_pointer);
+        remaining_frames = runtime->buffer_size - pcm_buffer_pointer;
 
         for (i = 0; i < frames; ++i) {
                 for (c = 0; c < channels; ++c) {
@@ -172,19 +177,24 @@ static void write_pcm_s32(struct amdtp_stream *s,
         }
 }
 
-static void read_pcm_s32(struct amdtp_stream *s,
-                         struct snd_pcm_substream *pcm,
-                         __be32 *buffer, unsigned int frames)
+static void read_pcm_s32(struct amdtp_stream *s, struct snd_pcm_substream *pcm,
+                         __be32 *buffer, unsigned int frames,
+                         unsigned int pcm_frames)
 {
         struct amdtp_am824 *p = s->protocol;
+        unsigned int channels = p->pcm_channels;
         struct snd_pcm_runtime *runtime = pcm->runtime;
-        unsigned int channels, remaining_frames, i, c;
+        unsigned int pcm_buffer_pointer;
+        int remaining_frames;
         u32 *dst;
+        int i, c;
+
+        pcm_buffer_pointer = s->pcm_buffer_pointer + pcm_frames;
+        pcm_buffer_pointer %= runtime->buffer_size;
 
-        channels = p->pcm_channels;
         dst  = (void *)runtime->dma_area +
-                        frames_to_bytes(runtime, s->pcm_buffer_pointer);
-        remaining_frames = runtime->buffer_size - s->pcm_buffer_pointer;
+                                frames_to_bytes(runtime, pcm_buffer_pointer);
+        remaining_frames = runtime->buffer_size - pcm_buffer_pointer;
 
         for (i = 0; i < frames; ++i) {
                 for (c = 0; c < channels; ++c) {
@@ -284,7 +294,7 @@ static void midi_rate_use_one_byte(struct amdtp_stream *s, unsigned int port)
 }
 
 static void write_midi_messages(struct amdtp_stream *s, __be32 *buffer,
-                                unsigned int frames)
+                        unsigned int frames, unsigned int data_block_counter)
 {
         struct amdtp_am824 *p = s->protocol;
         unsigned int f, port;
@@ -293,7 +303,7 @@ static void write_midi_messages(struct amdtp_stream *s, __be32 *buffer,
         for (f = 0; f < frames; f++) {
                 b = (u8 *)&buffer[p->midi_position];
 
-                port = (s->data_block_counter + f) % 8;
+                port = (data_block_counter + f) % 8;
                 if (f < MAX_MIDI_RX_BLOCKS &&
                     midi_ratelimit_per_packet(s, port) &&
                     p->midi[port] != NULL &&
@@ -311,16 +321,20 @@ static void write_midi_messages(struct amdtp_stream *s, __be32 *buffer,
         }
 }
 
-static void read_midi_messages(struct amdtp_stream *s,
-                               __be32 *buffer, unsigned int frames)
+static void read_midi_messages(struct amdtp_stream *s, __be32 *buffer,
+                        unsigned int frames, unsigned int data_block_counter)
 {
         struct amdtp_am824 *p = s->protocol;
-        unsigned int f, port;
         int len;
         u8 *b;
+        int f;
 
         for (f = 0; f < frames; f++) {
-                port = (8 - s->ctx_data.tx.first_dbc + s->data_block_counter + f) % 8;
+                unsigned int port = f;
+
+                if (!(s->flags & CIP_UNALIGHED_DBC))
+                        port += data_block_counter;
+                port %= 8;
                 b = (u8 *)&buffer[p->midi_position];
 
                 len = b[0] - 0x80;
@@ -331,43 +345,60 @@ static void read_midi_messages(struct amdtp_stream *s,
         }
 }
 
-static unsigned int process_rx_data_blocks(struct amdtp_stream *s, __be32 *buffer,
-                                           unsigned int data_blocks, unsigned int *syt)
+static unsigned int process_it_ctx_payloads(struct amdtp_stream *s,
+                                            const struct pkt_desc *descs,
+                                            unsigned int packets,
+                                            struct snd_pcm_substream *pcm)
 {
         struct amdtp_am824 *p = s->protocol;
-        struct snd_pcm_substream *pcm = READ_ONCE(s->pcm);
-        unsigned int pcm_frames;
-
-        if (pcm) {
-                write_pcm_s32(s, pcm, buffer, data_blocks);
-                pcm_frames = data_blocks * p->frame_multiplier;
-        } else {
-                write_pcm_silence(s, buffer, data_blocks);
-                pcm_frames = 0;
-        }
+        unsigned int pcm_frames = 0;
+        int i;
 
-        if (p->midi_ports)
-                write_midi_messages(s, buffer, data_blocks);
+        for (i = 0; i < packets; ++i) {
+                const struct pkt_desc *desc = descs + i;
+                __be32 *buf = desc->ctx_payload;
+                unsigned int data_blocks = desc->data_blocks;
+
+                if (pcm) {
+                        write_pcm_s32(s, pcm, buf, data_blocks, pcm_frames);
+                        pcm_frames += data_blocks * p->frame_multiplier;
+                } else {
+                        write_pcm_silence(s, buf, data_blocks);
+                }
+
+                if (p->midi_ports) {
+                        write_midi_messages(s, buf, data_blocks,
+                                            desc->data_block_counter);
+                }
+        }
 
         return pcm_frames;
 }
 
-static unsigned int process_tx_data_blocks(struct amdtp_stream *s, __be32 *buffer,
-                                           unsigned int data_blocks, unsigned int *syt)
+static unsigned int process_ir_ctx_payloads(struct amdtp_stream *s,
+                                            const struct pkt_desc *descs,
+                                            unsigned int packets,
+                                            struct snd_pcm_substream *pcm)
 {
         struct amdtp_am824 *p = s->protocol;
-        struct snd_pcm_substream *pcm = READ_ONCE(s->pcm);
-        unsigned int pcm_frames;
-
-        if (pcm) {
-                read_pcm_s32(s, pcm, buffer, data_blocks);
-                pcm_frames = data_blocks * p->frame_multiplier;
-        } else {
-                pcm_frames = 0;
-        }
+        unsigned int pcm_frames = 0;
+        int i;
+
+        for (i = 0; i < packets; ++i) {
+                const struct pkt_desc *desc = descs + i;
+                __be32 *buf = desc->ctx_payload;
+                unsigned int data_blocks = desc->data_blocks;
 
-        if (p->midi_ports)
-                read_midi_messages(s, buffer, data_blocks);
+                if (pcm) {
+                        read_pcm_s32(s, pcm, buf, data_blocks, pcm_frames);
+                        pcm_frames += data_blocks * p->frame_multiplier;
+                }
+
+                if (p->midi_ports) {
+                        read_midi_messages(s, buf, data_blocks,
+                                           desc->data_block_counter);
+                }
+        }
 
         return pcm_frames;
 }
@@ -383,15 +414,14 @@ static unsigned int process_tx_data_blocks(struct amdtp_stream *s, __be32 *buffe
 int amdtp_am824_init(struct amdtp_stream *s, struct fw_unit *unit,
                      enum amdtp_stream_direction dir, enum cip_flags flags)
 {
-        amdtp_stream_process_data_blocks_t process_data_blocks;
+        amdtp_stream_process_ctx_payloads_t process_ctx_payloads;
 
         if (dir == AMDTP_IN_STREAM)
-                process_data_blocks = process_tx_data_blocks;
+                process_ctx_payloads = process_ir_ctx_payloads;
         else
-                process_data_blocks = process_rx_data_blocks;
+                process_ctx_payloads = process_it_ctx_payloads;
 
         return amdtp_stream_init(s, unit, dir, flags, CIP_FMT_AM,
-                                 process_data_blocks,
-                                 sizeof(struct amdtp_am824));
+                        process_ctx_payloads, sizeof(struct amdtp_am824));
 }
 EXPORT_SYMBOL_GPL(amdtp_am824_init);
diff --git a/sound/firewire/amdtp-stream-trace.h b/sound/firewire/amdtp-stream-trace.h
index 4adbbf789cbe..16c7f6605511 100644
--- a/sound/firewire/amdtp-stream-trace.h
+++ b/sound/firewire/amdtp-stream-trace.h
@@ -14,8 +14,8 @@
 #include <linux/tracepoint.h>
 
 TRACE_EVENT(amdtp_packet,
-        TP_PROTO(const struct amdtp_stream *s, u32 cycles, const __be32 *cip_header, unsigned int payload_length, unsigned int data_blocks, unsigned int index),
-        TP_ARGS(s, cycles, cip_header, payload_length, data_blocks, index),
+        TP_PROTO(const struct amdtp_stream *s, u32 cycles, const __be32 *cip_header, unsigned int payload_length, unsigned int data_blocks, unsigned int data_block_counter, unsigned int index),
+        TP_ARGS(s, cycles, cip_header, payload_length, data_blocks, data_block_counter, index),
         TP_STRUCT__entry(
                 __field(unsigned int, second)
                 __field(unsigned int, cycle)
@@ -47,7 +47,7 @@ TRACE_EVENT(amdtp_packet,
                 }
                 __entry->payload_quadlets = payload_length / sizeof(__be32);
                 __entry->data_blocks = data_blocks;
-                __entry->data_block_counter = s->data_block_counter,
+                __entry->data_block_counter = data_block_counter,
                 __entry->packet_index = s->packet_index;
                 __entry->irq = !!in_interrupt();
                 __entry->index = index;
diff --git a/sound/firewire/amdtp-stream.c b/sound/firewire/amdtp-stream.c
index 4d71d74707cf..1a92855c7647 100644
--- a/sound/firewire/amdtp-stream.c
+++ b/sound/firewire/amdtp-stream.c
@@ -74,16 +74,16 @@ static void pcm_period_tasklet(unsigned long data);
  * @dir: the direction of stream
  * @flags: the packet transmission method to use
  * @fmt: the value of fmt field in CIP header
- * @process_data_blocks: callback handler to process data blocks
+ * @process_ctx_payloads: callback handler to process payloads of isoc context
  * @protocol_size: the size to allocate newly for protocol
  */
 int amdtp_stream_init(struct amdtp_stream *s, struct fw_unit *unit,
                       enum amdtp_stream_direction dir, enum cip_flags flags,
                       unsigned int fmt,
-                      amdtp_stream_process_data_blocks_t process_data_blocks,
+                      amdtp_stream_process_ctx_payloads_t process_ctx_payloads,
                       unsigned int protocol_size)
 {
-        if (process_data_blocks == NULL)
+        if (process_ctx_payloads == NULL)
                 return -EINVAL;
 
         s->protocol = kzalloc(protocol_size, GFP_KERNEL);
@@ -102,7 +102,10 @@ int amdtp_stream_init(struct amdtp_stream *s, struct fw_unit *unit,
         s->callbacked = false;
 
         s->fmt = fmt;
-        s->process_data_blocks = process_data_blocks;
+        s->process_ctx_payloads = process_ctx_payloads;
+
+        if (dir == AMDTP_OUT_STREAM)
+                s->ctx_data.rx.syt_override = -1;
 
         return 0;
 }
@@ -473,12 +476,12 @@ static inline int queue_in_packet(struct amdtp_stream *s,
 }
 
 static void generate_cip_header(struct amdtp_stream *s, __be32 cip_header[2],
-                                unsigned int syt)
+                        unsigned int data_block_counter, unsigned int syt)
 {
         cip_header[0] = cpu_to_be32(READ_ONCE(s->source_node_id_field) |
                                 (s->data_block_quadlets << CIP_DBS_SHIFT) |
                                 ((s->sph << CIP_SPH_SHIFT) & CIP_SPH_MASK) |
-                                s->data_block_counter);
+                                data_block_counter);
         cip_header[1] = cpu_to_be32(CIP_EOH |
                         ((s->fmt << CIP_FMT_SHIFT) & CIP_FMT_MASK) |
                         ((s->ctx_data.rx.fdf << CIP_FDF_SHIFT) & CIP_FDF_MASK) |
@@ -487,8 +490,9 @@ static void generate_cip_header(struct amdtp_stream *s, __be32 cip_header[2],
 
 static void build_it_pkt_header(struct amdtp_stream *s, unsigned int cycle,
                                 struct fw_iso_packet *params,
-                                unsigned int data_blocks, unsigned int syt,
-                                unsigned int index)
+                                unsigned int data_blocks,
+                                unsigned int data_block_counter,
+                                unsigned int syt, unsigned int index)
 {
         unsigned int payload_length;
         __be32 *cip_header;
@@ -496,14 +500,9 @@ static void build_it_pkt_header(struct amdtp_stream *s, unsigned int cycle,
         payload_length = data_blocks * sizeof(__be32) * s->data_block_quadlets;
         params->payload_length = payload_length;
 
-        if (s->flags & CIP_DBC_IS_END_EVENT) {
-                s->data_block_counter =
-                                (s->data_block_counter + data_blocks) & 0xff;
-        }
-
         if (!(s->flags & CIP_NO_HEADER)) {
                 cip_header = (__be32 *)params->header;
-                generate_cip_header(s, cip_header, syt);
+                generate_cip_header(s, cip_header, data_block_counter, syt);
                 params->header_length = 2 * sizeof(__be32);
                 payload_length += params->header_length;
         } else {
@@ -511,23 +510,19 @@ static void build_it_pkt_header(struct amdtp_stream *s, unsigned int cycle,
         }
 
         trace_amdtp_packet(s, cycle, cip_header, payload_length, data_blocks,
-                           index);
-
-        if (!(s->flags & CIP_DBC_IS_END_EVENT)) {
-                s->data_block_counter =
-                                (s->data_block_counter + data_blocks) & 0xff;
-        }
+                           data_block_counter, index);
 }
 
 static int check_cip_header(struct amdtp_stream *s, const __be32 *buf,
                             unsigned int payload_length,
-                            unsigned int *data_blocks, unsigned int *dbc,
-                            unsigned int *syt)
+                            unsigned int *data_blocks,
+                            unsigned int *data_block_counter, unsigned int *syt)
 {
         u32 cip_header[2];
         unsigned int sph;
         unsigned int fmt;
         unsigned int fdf;
+        unsigned int dbc;
         bool lost;
 
         cip_header[0] = be32_to_cpu(buf[0]);
@@ -579,17 +574,16 @@ static int check_cip_header(struct amdtp_stream *s, const __be32 *buf,
         }
 
         /* Check data block counter continuity */
-        *dbc = cip_header[0] & CIP_DBC_MASK;
+        dbc = cip_header[0] & CIP_DBC_MASK;
         if (*data_blocks == 0 && (s->flags & CIP_EMPTY_HAS_WRONG_DBC) &&
-            s->data_block_counter != UINT_MAX)
-                *dbc = s->data_block_counter;
+            *data_block_counter != UINT_MAX)
+                dbc = *data_block_counter;
 
-        if (((s->flags & CIP_SKIP_DBC_ZERO_CHECK) &&
-             *dbc == s->ctx_data.tx.first_dbc) ||
-            s->data_block_counter == UINT_MAX) {
+        if ((dbc == 0x00 && (s->flags & CIP_SKIP_DBC_ZERO_CHECK)) ||
+            *data_block_counter == UINT_MAX) {
                 lost = false;
         } else if (!(s->flags & CIP_DBC_IS_END_EVENT)) {
-                lost = *dbc != s->data_block_counter;
+                lost = dbc != *data_block_counter;
         } else {
                 unsigned int dbc_interval;
 
@@ -598,16 +592,18 @@ static int check_cip_header(struct amdtp_stream *s, const __be32 *buf,
                 else
                         dbc_interval = *data_blocks;
 
-                lost = *dbc != ((s->data_block_counter + dbc_interval) & 0xff);
+                lost = dbc != ((*data_block_counter + dbc_interval) & 0xff);
         }
 
         if (lost) {
                 dev_err(&s->unit->device,
                         "Detect discontinuity of CIP: %02X %02X\n",
-                        s->data_block_counter, *dbc);
+                        *data_block_counter, dbc);
                 return -EIO;
         }
 
+        *data_block_counter = dbc;
+
         *syt = cip_header[1] & CIP_SYT_MASK;
 
         return 0;
@@ -616,10 +612,10 @@ static int check_cip_header(struct amdtp_stream *s, const __be32 *buf,
 static int parse_ir_ctx_header(struct amdtp_stream *s, unsigned int cycle,
                                const __be32 *ctx_header,
                                unsigned int *payload_length,
-                               unsigned int *data_blocks, unsigned int *syt,
-                               unsigned int index)
+                               unsigned int *data_blocks,
+                               unsigned int *data_block_counter,
+                               unsigned int *syt, unsigned int index)
 {
-        unsigned int dbc;
         const __be32 *cip_header;
         int err;
 
@@ -635,7 +631,7 @@ static int parse_ir_ctx_header(struct amdtp_stream *s, unsigned int cycle,
         if (!(s->flags & CIP_NO_HEADER)) {
                 cip_header = ctx_header + 2;
                 err = check_cip_header(s, cip_header, *payload_length,
-                                       data_blocks, &dbc, syt);
+                                       data_blocks, data_block_counter, syt);
                 if (err < 0)
                         return err;
         } else {
@@ -645,16 +641,12 @@ static int parse_ir_ctx_header(struct amdtp_stream *s, unsigned int cycle,
                                s->data_block_quadlets;
                 *syt = 0;
 
-                if (s->data_block_counter != UINT_MAX)
-                        dbc = s->data_block_counter;
-                else
-                        dbc = 0;
+                if (*data_block_counter == UINT_MAX)
+                        *data_block_counter = 0;
         }
 
-        s->data_block_counter = dbc;
-
         trace_amdtp_packet(s, cycle, cip_header, *payload_length, *data_blocks,
-                           index);
+                           *data_block_counter, index);
 
         return err;
 }
@@ -686,6 +678,80 @@ static inline u32 compute_it_cycle(const __be32 ctx_header_tstamp)
         return increment_cycle_count(cycle, QUEUE_LENGTH);
 }
 
+static int generate_device_pkt_descs(struct amdtp_stream *s,
+                                     struct pkt_desc *descs,
+                                     const __be32 *ctx_header,
+                                     unsigned int packets)
+{
+        unsigned int dbc = s->data_block_counter;
+        int i;
+        int err;
+
+        for (i = 0; i < packets; ++i) {
+                struct pkt_desc *desc = descs + i;
+                unsigned int index = (s->packet_index + i) % QUEUE_LENGTH;
+                unsigned int cycle;
+                unsigned int payload_length;
+                unsigned int data_blocks;
+                unsigned int syt;
+
+                cycle = compute_cycle_count(ctx_header[1]);
+
+                err = parse_ir_ctx_header(s, cycle, ctx_header, &payload_length,
+                                          &data_blocks, &dbc, &syt, i);
+                if (err < 0)
+                        return err;
+
+                desc->cycle = cycle;
+                desc->syt = syt;
+                desc->data_blocks = data_blocks;
+                desc->data_block_counter = dbc;
+                desc->ctx_payload = s->buffer.packets[index].buffer;
+
+                if (!(s->flags & CIP_DBC_IS_END_EVENT))
+                        dbc = (dbc + desc->data_blocks) & 0xff;
+
+                ctx_header +=
+                        s->ctx_data.tx.ctx_header_size / sizeof(*ctx_header);
+        }
+
+        s->data_block_counter = dbc;
+
+        return 0;
+}
+
+static void generate_ideal_pkt_descs(struct amdtp_stream *s,
+                                     struct pkt_desc *descs,
+                                     const __be32 *ctx_header,
+                                     unsigned int packets)
+{
+        unsigned int dbc = s->data_block_counter;
+        int i;
+
+        for (i = 0; i < packets; ++i) {
+                struct pkt_desc *desc = descs + i;
+                unsigned int index = (s->packet_index + i) % QUEUE_LENGTH;
+
+                desc->cycle = compute_cycle_count(*ctx_header);
+                desc->syt = calculate_syt(s, desc->cycle);
+                desc->data_blocks = calculate_data_blocks(s, desc->syt);
+
+                if (s->flags & CIP_DBC_IS_END_EVENT)
+                        dbc = (dbc + desc->data_blocks) & 0xff;
+
+                desc->data_block_counter = dbc;
+
+                if (!(s->flags & CIP_DBC_IS_END_EVENT))
+                        dbc = (dbc + desc->data_blocks) & 0xff;
+
+                desc->ctx_payload = s->buffer.packets[index].buffer;
+
+                ++ctx_header;
+        }
+
+        s->data_block_counter = dbc;
+}
+
 static inline void cancel_stream(struct amdtp_stream *s)
 {
         s->packet_index = -1;
@@ -694,6 +760,19 @@ static inline void cancel_stream(struct amdtp_stream *s)
         WRITE_ONCE(s->pcm_buffer_pointer, SNDRV_PCM_POS_XRUN);
 }
 
+static void process_ctx_payloads(struct amdtp_stream *s,
+                                 const struct pkt_desc *descs,
+                                 unsigned int packets)
+{
+        struct snd_pcm_substream *pcm;
+        unsigned int pcm_frames;
+
+        pcm = READ_ONCE(s->pcm);
+        pcm_frames = s->process_ctx_payloads(s, descs, packets, pcm);
+        if (pcm)
+                update_pcm_pointers(s, pcm, pcm_frames);
+}
+
 static void out_stream_callback(struct fw_iso_context *context, u32 tstamp,
                                 size_t header_length, void *header,
                                 void *private_data)
@@ -706,38 +785,31 @@ static void out_stream_callback(struct fw_iso_context *context, u32 tstamp,
         if (s->packet_index < 0)
                 return;
 
+        generate_ideal_pkt_descs(s, s->pkt_descs, ctx_header, packets);
+
+        process_ctx_payloads(s, s->pkt_descs, packets);
+
         for (i = 0; i < packets; ++i) {
-                u32 cycle;
+                const struct pkt_desc *desc = s->pkt_descs + i;
                 unsigned int syt;
-                unsigned int data_blocks;
-                __be32 *buffer;
-                unsigned int pcm_frames;
                 struct {
                         struct fw_iso_packet params;
                         __be32 header[IT_PKT_HEADER_SIZE_CIP / sizeof(__be32)];
                 } template = { {0}, {0} };
-                struct snd_pcm_substream *pcm;
 
-                cycle = compute_it_cycle(*ctx_header);
-                syt = calculate_syt(s, cycle);
-                data_blocks = calculate_data_blocks(s, syt);
-                buffer = s->buffer.packets[s->packet_index].buffer;
-                pcm_frames = s->process_data_blocks(s, buffer, data_blocks,
-                                                    &syt);
+                if (s->ctx_data.rx.syt_override < 0)
+                        syt = desc->syt;
+                else
+                        syt = s->ctx_data.rx.syt_override;
 
-                build_it_pkt_header(s, cycle, &template.params, data_blocks,
+                build_it_pkt_header(s, desc->cycle, &template.params,
+                                    desc->data_blocks, desc->data_block_counter,
                                     syt, i);
 
                 if (queue_out_packet(s, &template.params) < 0) {
                         cancel_stream(s);
                         return;
                 }
-
-                pcm = READ_ONCE(s->pcm);
-                if (pcm && pcm_frames > 0)
-                        update_pcm_pointers(s, pcm, pcm_frames);
-
-                ++ctx_header;
         }
 
         fw_iso_context_queue_flush(s->context);
@@ -748,8 +820,10 @@ static void in_stream_callback(struct fw_iso_context *context, u32 tstamp,
                                void *private_data)
 {
         struct amdtp_stream *s = private_data;
-        unsigned int i, packets;
+        unsigned int packets;
         __be32 *ctx_header = header;
+        int i;
+        int err;
 
         if (s->packet_index < 0)
                 return;
@@ -757,48 +831,23 @@ static void in_stream_callback(struct fw_iso_context *context, u32 tstamp,
         // The number of packets in buffer.
         packets = header_length / s->ctx_data.tx.ctx_header_size;
 
-        for (i = 0; i < packets; i++) {
-                u32 cycle;
-                unsigned int payload_length;
-                unsigned int data_blocks;
-                unsigned int syt;
-                __be32 *buffer;
-                unsigned int pcm_frames = 0;
-                struct fw_iso_packet params = {0};
-                struct snd_pcm_substream *pcm;
-                int err;
-
-                cycle = compute_cycle_count(ctx_header[1]);
-                err = parse_ir_ctx_header(s, cycle, ctx_header, &payload_length,
-                                          &data_blocks, &syt, i);
-                if (err < 0 && err != -EAGAIN)
-                        break;
-
-                if (err >= 0) {
-                        buffer = s->buffer.packets[s->packet_index].buffer;
-                        pcm_frames = s->process_data_blocks(s, buffer,
-                                                            data_blocks, &syt);
-
-                        if (!(s->flags & CIP_DBC_IS_END_EVENT)) {
-                                s->data_block_counter += data_blocks;
-                                s->data_block_counter &= 0xff;
-                        }
+        err = generate_device_pkt_descs(s, s->pkt_descs, ctx_header, packets);
+        if (err < 0) {
+                if (err != -EAGAIN) {
+                        cancel_stream(s);
+                        return;
                 }
-
-                if (queue_in_packet(s, &params) < 0)
-                        break;
-
-                pcm = READ_ONCE(s->pcm);
-                if (pcm && pcm_frames > 0)
-                        update_pcm_pointers(s, pcm, pcm_frames);
-
-                ctx_header += s->ctx_data.tx.ctx_header_size / sizeof(*ctx_header);
+        } else {
+                process_ctx_payloads(s, s->pkt_descs, packets);
         }
 
-        /* Queueing error or detecting invalid payload. */
-        if (i < packets) {
-                cancel_stream(s);
-                return;
+        for (i = 0; i < packets; ++i) {
+                struct fw_iso_packet params = {0};
+
+                if (queue_in_packet(s, &params) < 0) {
+                        cancel_stream(s);
+                        return;
+                }
         }
 
         fw_iso_context_queue_flush(s->context);
@@ -845,7 +894,7 @@ static void amdtp_stream_first_callback(struct fw_iso_context *context,
  * amdtp_stream_set_parameters() and it must be started before any PCM or MIDI
  * device can be started.
  */
-int amdtp_stream_start(struct amdtp_stream *s, int channel, int speed)
+static int amdtp_stream_start(struct amdtp_stream *s, int channel, int speed)
 {
         static const struct {
                 unsigned int data_block;
@@ -932,6 +981,13 @@ int amdtp_stream_start(struct amdtp_stream *s, int channel, int speed)
         else
                 s->tag = TAG_CIP;
 
+        s->pkt_descs = kcalloc(INTERRUPT_INTERVAL, sizeof(*s->pkt_descs),
+                               GFP_KERNEL);
+        if (!s->pkt_descs) {
+                err = -ENOMEM;
+                goto err_context;
+        }
+
         s->packet_index = 0;
         do {
                 struct fw_iso_packet params;
@@ -943,7 +999,7 @@ int amdtp_stream_start(struct amdtp_stream *s, int channel, int speed)
                         err = queue_out_packet(s, &params);
                 }
                 if (err < 0)
-                        goto err_context;
+                        goto err_pkt_descs;
         } while (s->packet_index > 0);
 
         /* NOTE: TAG1 matches CIP. This just affects in stream. */
@@ -954,12 +1010,13 @@ int amdtp_stream_start(struct amdtp_stream *s, int channel, int speed)
         s->callbacked = false;
         err = fw_iso_context_start(s->context, -1, 0, tag);
         if (err < 0)
-                goto err_context;
+                goto err_pkt_descs;
 
         mutex_unlock(&s->mutex);
 
         return 0;
-
+err_pkt_descs:
+        kfree(s->pkt_descs);
 err_context:
         fw_iso_context_destroy(s->context);
         s->context = ERR_PTR(-1);
@@ -970,7 +1027,6 @@ err_unlock:
 
         return err;
 }
-EXPORT_SYMBOL(amdtp_stream_start);
 
 /**
  * amdtp_stream_pcm_pointer - get the PCM buffer position
@@ -1041,7 +1097,7 @@ EXPORT_SYMBOL(amdtp_stream_update);
  * All PCM and MIDI devices of the stream must be stopped before the stream
  * itself can be stopped.
  */
-void amdtp_stream_stop(struct amdtp_stream *s)
+static void amdtp_stream_stop(struct amdtp_stream *s)
 {
         mutex_lock(&s->mutex);
 
@@ -1055,12 +1111,12 @@ void amdtp_stream_stop(struct amdtp_stream *s)
         fw_iso_context_destroy(s->context);
         s->context = ERR_PTR(-1);
         iso_packets_buffer_destroy(&s->buffer, s->unit);
+        kfree(s->pkt_descs);
 
         s->callbacked = false;
 
         mutex_unlock(&s->mutex);
 }
-EXPORT_SYMBOL(amdtp_stream_stop);
 
 /**
  * amdtp_stream_pcm_abort - abort the running PCM device
@@ -1078,3 +1134,91 @@ void amdtp_stream_pcm_abort(struct amdtp_stream *s)
                 snd_pcm_stop_xrun(pcm);
 }
 EXPORT_SYMBOL(amdtp_stream_pcm_abort);
+
+/**
+ * amdtp_domain_init - initialize an AMDTP domain structure
+ * @d: the AMDTP domain to initialize.
+ */
+int amdtp_domain_init(struct amdtp_domain *d)
+{
+        INIT_LIST_HEAD(&d->streams);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(amdtp_domain_init);
+
+/**
+ * amdtp_domain_destroy - destroy an AMDTP domain structure
+ * @d: the AMDTP domain to destroy.
+ */
+void amdtp_domain_destroy(struct amdtp_domain *d)
+{
+        WARN_ON(!list_empty(&d->streams));
+}
+EXPORT_SYMBOL_GPL(amdtp_domain_destroy);
+
+/**
+ * amdtp_domain_add_stream - register isoc context into the domain.
+ * @d: the AMDTP domain.
+ * @s: the AMDTP stream.
+ * @channel: the isochronous channel on the bus.
+ * @speed: firewire speed code.
+ */
+int amdtp_domain_add_stream(struct amdtp_domain *d, struct amdtp_stream *s,
+                            int channel, int speed)
+{
+        struct amdtp_stream *tmp;
+
+        list_for_each_entry(tmp, &d->streams, list) {
+                if (s == tmp)
+                        return -EBUSY;
+        }
+
+        list_add(&s->list, &d->streams);
+
+        s->channel = channel;
+        s->speed = speed;
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(amdtp_domain_add_stream);
+
+/**
+ * amdtp_domain_start - start sending packets for isoc context in the domain.
+ * @d: the AMDTP domain.
+ */
+int amdtp_domain_start(struct amdtp_domain *d)
+{
+        struct amdtp_stream *s;
+        int err = 0;
+
+        list_for_each_entry(s, &d->streams, list) {
+                err = amdtp_stream_start(s, s->channel, s->speed);
+                if (err < 0)
+                        break;
+        }
+
+        if (err < 0) {
+                list_for_each_entry(s, &d->streams, list)
+                        amdtp_stream_stop(s);
+        }
+
+        return err;
+}
+EXPORT_SYMBOL_GPL(amdtp_domain_start);
+
+/**
+ * amdtp_domain_stop - stop sending packets for isoc context in the same domain.
+ * @d: the AMDTP domain to which the isoc contexts belong.
+ */
+void amdtp_domain_stop(struct amdtp_domain *d)
+{
+        struct amdtp_stream *s, *next;
+
+        list_for_each_entry_safe(s, next, &d->streams, list) {
+                list_del(&s->list);
+
+                amdtp_stream_stop(s);
+        }
+}
+EXPORT_SYMBOL_GPL(amdtp_domain_stop);
diff --git a/sound/firewire/amdtp-stream.h b/sound/firewire/amdtp-stream.h
index 3942894c11ac..bbbca964b9b4 100644
--- a/sound/firewire/amdtp-stream.h
+++ b/sound/firewire/amdtp-stream.h
@@ -33,6 +33,8 @@
  * @CIP_HEADER_WITHOUT_EOH: Only for in-stream. CIP Header doesn't include
  *      valid EOH.
  * @CIP_NO_HEADERS: a lack of headers in packets
+ * @CIP_UNALIGHED_DBC: Only for in-stream. The value of dbc is not alighed to
+ *      the value of current SYT_INTERVAL; e.g. initial value is not zero.
  */
 enum cip_flags {
         CIP_NONBLOCKING         = 0x00,
@@ -45,6 +47,7 @@ enum cip_flags {
         CIP_JUMBO_PAYLOAD       = 0x40,
         CIP_HEADER_WITHOUT_EOH  = 0x80,
         CIP_NO_HEADER           = 0x100,
+        CIP_UNALIGHED_DBC       = 0x200,
 };
 
 /**
@@ -91,12 +94,20 @@ enum amdtp_stream_direction {
         AMDTP_IN_STREAM
 };
 
+struct pkt_desc {
+        u32 cycle;
+        u32 syt;
+        unsigned int data_blocks;
+        unsigned int data_block_counter;
+        __be32 *ctx_payload;
+};
+
 struct amdtp_stream;
-typedef unsigned int (*amdtp_stream_process_data_blocks_t)(
+typedef unsigned int (*amdtp_stream_process_ctx_payloads_t)(
                                                 struct amdtp_stream *s,
-                                                __be32 *buffer,
-                                                unsigned int data_blocks,
-                                                unsigned int *syt);
+                                                const struct pkt_desc *desc,
+                                                unsigned int packets,
+                                                struct snd_pcm_substream *pcm);
 struct amdtp_stream {
         struct fw_unit *unit;
         enum cip_flags flags;
@@ -107,6 +118,7 @@ struct amdtp_stream {
         struct fw_iso_context *context;
         struct iso_packets_buffer buffer;
         int packet_index;
+        struct pkt_desc *pkt_descs;
         int tag;
         union {
                 struct {
@@ -119,8 +131,6 @@ struct amdtp_stream {
                         // Fixed interval of dbc between previos/current
                         // packets.
                         unsigned int dbc_interval;
-                        // Indicate the value of dbc field in a first packet.
-                        unsigned int first_dbc;
                 } tx;
                 struct {
                         // To calculate CIP data blocks and tstamp.
@@ -131,6 +141,7 @@ struct amdtp_stream {
 
                         // To generate CIP header.
                         unsigned int fdf;
+                        int syt_override;
                 } rx;
         } ctx_data;
 
@@ -158,13 +169,18 @@ struct amdtp_stream {
 
         /* For backends to process data blocks. */
         void *protocol;
-        amdtp_stream_process_data_blocks_t process_data_blocks;
+        amdtp_stream_process_ctx_payloads_t process_ctx_payloads;
+
+        // For domain.
+        int channel;
+        int speed;
+        struct list_head list;
 };
 
 int amdtp_stream_init(struct amdtp_stream *s, struct fw_unit *unit,
                       enum amdtp_stream_direction dir, enum cip_flags flags,
                       unsigned int fmt,
-                      amdtp_stream_process_data_blocks_t process_data_blocks,
+                      amdtp_stream_process_ctx_payloads_t process_ctx_payloads,
                       unsigned int protocol_size);
 void amdtp_stream_destroy(struct amdtp_stream *s);
 
@@ -172,9 +188,7 @@ int amdtp_stream_set_parameters(struct amdtp_stream *s, unsigned int rate,
                                 unsigned int data_block_quadlets);
 unsigned int amdtp_stream_get_max_payload(struct amdtp_stream *s);
 
-int amdtp_stream_start(struct amdtp_stream *s, int channel, int speed);
 void amdtp_stream_update(struct amdtp_stream *s);
-void amdtp_stream_stop(struct amdtp_stream *s);
 
 int amdtp_stream_add_pcm_hw_constraints(struct amdtp_stream *s,
                                         struct snd_pcm_runtime *runtime);
@@ -256,4 +270,17 @@ static inline bool amdtp_stream_wait_callback(struct amdtp_stream *s,
                                   msecs_to_jiffies(timeout)) > 0;
 }
 
+struct amdtp_domain {
+        struct list_head streams;
+};
+
+int amdtp_domain_init(struct amdtp_domain *d);
+void amdtp_domain_destroy(struct amdtp_domain *d);
+
+int amdtp_domain_add_stream(struct amdtp_domain *d, struct amdtp_stream *s,
+                            int channel, int speed);
+
+int amdtp_domain_start(struct amdtp_domain *d);
+void amdtp_domain_stop(struct amdtp_domain *d);
+
 #endif
diff --git a/sound/firewire/bebob/bebob.h b/sound/firewire/bebob/bebob.h
index 9e0b689fe34a..356d6ba60959 100644
--- a/sound/firewire/bebob/bebob.h
+++ b/sound/firewire/bebob/bebob.h
@@ -115,6 +115,8 @@ struct snd_bebob {
 
         /* For BeBoB version quirk. */
         unsigned int version;
+
+        struct amdtp_domain domain;
 };
 
 static inline int
diff --git a/sound/firewire/bebob/bebob_stream.c b/sound/firewire/bebob/bebob_stream.c
index 334dc7c96e1d..73fee991bd75 100644
--- a/sound/firewire/bebob/bebob_stream.c
+++ b/sound/firewire/bebob/bebob_stream.c
@@ -445,10 +445,9 @@ start_stream(struct snd_bebob *bebob, struct amdtp_stream *stream)
                         goto end;
         }
 
-        /* start amdtp stream */
-        err = amdtp_stream_start(stream,
-                                 conn->resources.channel,
-                                 conn->speed);
+        // start amdtp stream.
+        err = amdtp_domain_add_stream(&bebob->domain, stream,
+                                      conn->resources.channel, conn->speed);
 end:
         return err;
 }
@@ -523,7 +522,13 @@ int snd_bebob_stream_init_duplex(struct snd_bebob *bebob)
                 return err;
         }
 
-        return 0;
+        err = amdtp_domain_init(&bebob->domain);
+        if (err < 0) {
+                destroy_stream(bebob, &bebob->tx_stream);
+                destroy_stream(bebob, &bebob->rx_stream);
+        }
+
+        return err;
 }
 
 static int keep_resources(struct snd_bebob *bebob, struct amdtp_stream *stream,
@@ -566,9 +571,7 @@ int snd_bebob_stream_reserve_duplex(struct snd_bebob *bebob, unsigned int rate)
         if (rate == 0)
                 rate = curr_rate;
         if (curr_rate != rate) {
-                amdtp_stream_stop(&bebob->tx_stream);
-                amdtp_stream_stop(&bebob->rx_stream);
-
+                amdtp_domain_stop(&bebob->domain);
                 break_both_connections(bebob);
 
                 cmp_connection_release(&bebob->out_conn);
@@ -620,9 +623,7 @@ int snd_bebob_stream_start_duplex(struct snd_bebob *bebob)
         // packet queueing error or detecting discontinuity
         if (amdtp_streaming_error(&bebob->rx_stream) ||
             amdtp_streaming_error(&bebob->tx_stream)) {
-                amdtp_stream_stop(&bebob->rx_stream);
-                amdtp_stream_stop(&bebob->tx_stream);
-
+                amdtp_domain_stop(&bebob->domain);
                 break_both_connections(bebob);
         }
 
@@ -640,11 +641,16 @@ int snd_bebob_stream_start_duplex(struct snd_bebob *bebob)
                         return err;
 
                 err = start_stream(bebob, &bebob->rx_stream);
-                if (err < 0) {
-                        dev_err(&bebob->unit->device,
-                                "fail to run AMDTP master stream:%d\n", err);
+                if (err < 0)
+                        goto error;
+
+                err = start_stream(bebob, &bebob->tx_stream);
+                if (err < 0)
+                        goto error;
+
+                err = amdtp_domain_start(&bebob->domain);
+                if (err < 0)
                         goto error;
-                }
 
                 // NOTE:
                 // The firmware customized by M-Audio uses these commands to
@@ -660,21 +666,8 @@ int snd_bebob_stream_start_duplex(struct snd_bebob *bebob)
                 }
 
                 if (!amdtp_stream_wait_callback(&bebob->rx_stream,
-                                                CALLBACK_TIMEOUT)) {
-                        err = -ETIMEDOUT;
-                        goto error;
-                }
-        }
-
-        if (!amdtp_stream_running(&bebob->tx_stream)) {
-                err = start_stream(bebob, &bebob->tx_stream);
-                if (err < 0) {
-                        dev_err(&bebob->unit->device,
-                                "fail to run AMDTP slave stream:%d\n", err);
-                        goto error;
-                }
-
-                if (!amdtp_stream_wait_callback(&bebob->tx_stream,
+                                                CALLBACK_TIMEOUT) ||
+                    !amdtp_stream_wait_callback(&bebob->tx_stream,
                                                 CALLBACK_TIMEOUT)) {
                         err = -ETIMEDOUT;
                         goto error;
@@ -683,8 +676,7 @@ int snd_bebob_stream_start_duplex(struct snd_bebob *bebob)
 
         return 0;
 error:
-        amdtp_stream_stop(&bebob->tx_stream);
-        amdtp_stream_stop(&bebob->rx_stream);
+        amdtp_domain_stop(&bebob->domain);
         break_both_connections(bebob);
         return err;
 }
@@ -692,9 +684,7 @@ error:
 void snd_bebob_stream_stop_duplex(struct snd_bebob *bebob)
 {
         if (bebob->substreams_counter == 0) {
-                amdtp_stream_stop(&bebob->rx_stream);
-                amdtp_stream_stop(&bebob->tx_stream);
-
+                amdtp_domain_stop(&bebob->domain);
                 break_both_connections(bebob);
 
                 cmp_connection_release(&bebob->out_conn);
@@ -708,6 +698,8 @@ void snd_bebob_stream_stop_duplex(struct snd_bebob *bebob)
  */
 void snd_bebob_stream_destroy_duplex(struct snd_bebob *bebob)
 {
+        amdtp_domain_destroy(&bebob->domain);
+
         destroy_stream(bebob, &bebob->tx_stream);
         destroy_stream(bebob, &bebob->rx_stream);
 }
diff --git a/sound/firewire/dice/dice-stream.c b/sound/firewire/dice/dice-stream.c
index a9f0c77734c3..af8c5a2c28f3 100644
--- a/sound/firewire/dice/dice-stream.c
+++ b/sound/firewire/dice/dice-stream.c
@@ -154,14 +154,10 @@ static void stop_streams(struct snd_dice *dice, enum amdtp_stream_direction dir,
         for (i = 0; i < params->count; i++) {
                 reg = cpu_to_be32((u32)-1);
                 if (dir == AMDTP_IN_STREAM) {
-                        amdtp_stream_stop(&dice->tx_stream[i]);
-
                         snd_dice_transaction_write_tx(dice,
                                         params->size * i + TX_ISOCHRONOUS,
                                         &reg, sizeof(reg));
                 } else {
-                        amdtp_stream_stop(&dice->rx_stream[i]);
-
                         snd_dice_transaction_write_rx(dice,
                                         params->size * i + RX_ISOCHRONOUS,
                                         &reg, sizeof(reg));
@@ -297,10 +293,11 @@ int snd_dice_stream_reserve_duplex(struct snd_dice *dice, unsigned int rate)
         if (dice->substreams_counter == 0 || curr_rate != rate) {
                 struct reg_params tx_params, rx_params;
 
+                amdtp_domain_stop(&dice->domain);
+
                 err = get_register_params(dice, &tx_params, &rx_params);
                 if (err < 0)
                         return err;
-
                 finish_session(dice, &tx_params, &rx_params);
 
                 release_resources(dice);
@@ -377,7 +374,8 @@ static int start_streams(struct snd_dice *dice, enum amdtp_stream_direction dir,
                                 return err;
                 }
 
-                err = amdtp_stream_start(stream, resources->channel, max_speed);
+                err = amdtp_domain_add_stream(&dice->domain, stream,
+                                              resources->channel, max_speed);
                 if (err < 0)
                         return err;
         }
@@ -410,6 +408,7 @@ int snd_dice_stream_start_duplex(struct snd_dice *dice)
         for (i = 0; i < MAX_STREAMS; ++i) {
                 if (amdtp_streaming_error(&dice->tx_stream[i]) ||
                     amdtp_streaming_error(&dice->rx_stream[i])) {
+                        amdtp_domain_stop(&dice->domain);
                         finish_session(dice, &tx_params, &rx_params);
                         break;
                 }
@@ -456,6 +455,10 @@ int snd_dice_stream_start_duplex(struct snd_dice *dice)
                         goto error;
                 }
 
+                err = amdtp_domain_start(&dice->domain);
+                if (err < 0)
+                        goto error;
+
                 for (i = 0; i < MAX_STREAMS; i++) {
                         if ((i < tx_params.count &&
                             !amdtp_stream_wait_callback(&dice->tx_stream[i],
@@ -471,6 +474,7 @@ int snd_dice_stream_start_duplex(struct snd_dice *dice)
 
         return 0;
 error:
+        amdtp_domain_stop(&dice->domain);
         finish_session(dice, &tx_params, &rx_params);
         return err;
 }
@@ -485,8 +489,10 @@ void snd_dice_stream_stop_duplex(struct snd_dice *dice)
         struct reg_params tx_params, rx_params;
 
         if (dice->substreams_counter == 0) {
-                if (get_register_params(dice, &tx_params, &rx_params) >= 0)
+                if (get_register_params(dice, &tx_params, &rx_params) >= 0) {
+                        amdtp_domain_stop(&dice->domain);
                         finish_session(dice, &tx_params, &rx_params);
+                }
 
                 release_resources(dice);
         }
@@ -567,6 +573,14 @@ int snd_dice_stream_init_duplex(struct snd_dice *dice)
                         break;
                 }
         }
+
+        err = amdtp_domain_init(&dice->domain);
+        if (err < 0) {
+                for (i = 0; i < MAX_STREAMS; ++i) {
+                        destroy_stream(dice, AMDTP_OUT_STREAM, i);
+                        destroy_stream(dice, AMDTP_IN_STREAM, i);
+                }
+        }
 end:
         return err;
 }
@@ -579,6 +593,8 @@ void snd_dice_stream_destroy_duplex(struct snd_dice *dice)
                 destroy_stream(dice, AMDTP_IN_STREAM, i);
                 destroy_stream(dice, AMDTP_OUT_STREAM, i);
         }
+
+        amdtp_domain_destroy(&dice->domain);
 }
 
 void snd_dice_stream_update_duplex(struct snd_dice *dice)
@@ -596,6 +612,8 @@ void snd_dice_stream_update_duplex(struct snd_dice *dice)
         dice->global_enabled = false;
 
         if (get_register_params(dice, &tx_params, &rx_params) == 0) {
+                amdtp_domain_stop(&dice->domain);
+
                 stop_streams(dice, AMDTP_IN_STREAM, &tx_params);
                 stop_streams(dice, AMDTP_OUT_STREAM, &rx_params);
         }
diff --git a/sound/firewire/dice/dice.h b/sound/firewire/dice/dice.h
index c6304e5e9fc4..fa6d74303f54 100644
--- a/sound/firewire/dice/dice.h
+++ b/sound/firewire/dice/dice.h
@@ -112,6 +112,8 @@ struct snd_dice {
         bool global_enabled;
         struct completion clock_accepted;
         unsigned int substreams_counter;
+
+        struct amdtp_domain domain;
 };
 
 enum snd_dice_addr_type {
diff --git a/sound/firewire/digi00x/amdtp-dot.c b/sound/firewire/digi00x/amdtp-dot.c
index 45ff73d16074..d613642a2ce3 100644
--- a/sound/firewire/digi00x/amdtp-dot.c
+++ b/sound/firewire/digi00x/amdtp-dot.c
@@ -143,17 +143,23 @@ int amdtp_dot_set_parameters(struct amdtp_stream *s, unsigned int rate,
 }
 
 static void write_pcm_s32(struct amdtp_stream *s, struct snd_pcm_substream *pcm,
-                          __be32 *buffer, unsigned int frames)
+                          __be32 *buffer, unsigned int frames,
+                          unsigned int pcm_frames)
 {
         struct amdtp_dot *p = s->protocol;
+        unsigned int channels = p->pcm_channels;
         struct snd_pcm_runtime *runtime = pcm->runtime;
-        unsigned int channels, remaining_frames, i, c;
+        unsigned int pcm_buffer_pointer;
+        int remaining_frames;
         const u32 *src;
+        int i, c;
+
+        pcm_buffer_pointer = s->pcm_buffer_pointer + pcm_frames;
+        pcm_buffer_pointer %= runtime->buffer_size;
 
-        channels = p->pcm_channels;
         src = (void *)runtime->dma_area +
-                        frames_to_bytes(runtime, s->pcm_buffer_pointer);
-        remaining_frames = runtime->buffer_size - s->pcm_buffer_pointer;
+                                frames_to_bytes(runtime, pcm_buffer_pointer);
+        remaining_frames = runtime->buffer_size - pcm_buffer_pointer;
 
         buffer++;
         for (i = 0; i < frames; ++i) {
@@ -169,17 +175,23 @@ static void write_pcm_s32(struct amdtp_stream *s, struct snd_pcm_substream *pcm,
 }
 
 static void read_pcm_s32(struct amdtp_stream *s, struct snd_pcm_substream *pcm,
-                         __be32 *buffer, unsigned int frames)
+                         __be32 *buffer, unsigned int frames,
+                         unsigned int pcm_frames)
 {
         struct amdtp_dot *p = s->protocol;
+        unsigned int channels = p->pcm_channels;
         struct snd_pcm_runtime *runtime = pcm->runtime;
-        unsigned int channels, remaining_frames, i, c;
+        unsigned int pcm_buffer_pointer;
+        int remaining_frames;
         u32 *dst;
+        int i, c;
+
+        pcm_buffer_pointer = s->pcm_buffer_pointer + pcm_frames;
+        pcm_buffer_pointer %= runtime->buffer_size;
 
-        channels = p->pcm_channels;
         dst  = (void *)runtime->dma_area +
-                        frames_to_bytes(runtime, s->pcm_buffer_pointer);
-        remaining_frames = runtime->buffer_size - s->pcm_buffer_pointer;
+                                frames_to_bytes(runtime, pcm_buffer_pointer);
+        remaining_frames = runtime->buffer_size - pcm_buffer_pointer;
 
         buffer++;
         for (i = 0; i < frames; ++i) {
@@ -234,7 +246,7 @@ static inline void midi_use_bytes(struct amdtp_stream *s,
 }
 
 static void write_midi_messages(struct amdtp_stream *s, __be32 *buffer,
-                                unsigned int data_blocks)
+                unsigned int data_blocks, unsigned int data_block_counter)
 {
         struct amdtp_dot *p = s->protocol;
         unsigned int f, port;
@@ -242,7 +254,7 @@ static void write_midi_messages(struct amdtp_stream *s, __be32 *buffer,
         u8 *b;
 
         for (f = 0; f < data_blocks; f++) {
-                port = (s->data_block_counter + f) % 8;
+                port = (data_block_counter + f) % 8;
                 b = (u8 *)&buffer[0];
 
                 len = 0;
@@ -329,45 +341,53 @@ void amdtp_dot_midi_trigger(struct amdtp_stream *s, unsigned int port,
                 WRITE_ONCE(p->midi[port], midi);
 }
 
-static unsigned int process_tx_data_blocks(struct amdtp_stream *s,
-                                           __be32 *buffer,
-                                           unsigned int data_blocks,
-                                           unsigned int *syt)
+static unsigned int process_ir_ctx_payloads(struct amdtp_stream *s,
+                                            const struct pkt_desc *descs,
+                                            unsigned int packets,
+                                            struct snd_pcm_substream *pcm)
 {
-        struct snd_pcm_substream *pcm;
-        unsigned int pcm_frames;
+        unsigned int pcm_frames = 0;
+        int i;
 
-        pcm = READ_ONCE(s->pcm);
-        if (pcm) {
-                read_pcm_s32(s, pcm, buffer, data_blocks);
-                pcm_frames = data_blocks;
-        } else {
-                pcm_frames = 0;
-        }
+        for (i = 0; i < packets; ++i) {
+                const struct pkt_desc *desc = descs + i;
+                __be32 *buf = desc->ctx_payload;
+                unsigned int data_blocks = desc->data_blocks;
 
-        read_midi_messages(s, buffer, data_blocks);
+                if (pcm) {
+                        read_pcm_s32(s, pcm, buf, data_blocks, pcm_frames);
+                        pcm_frames += data_blocks;
+                }
+
+                read_midi_messages(s, buf, data_blocks);
+        }
 
         return pcm_frames;
 }
 
-static unsigned int process_rx_data_blocks(struct amdtp_stream *s,
-                                           __be32 *buffer,
-                                           unsigned int data_blocks,
-                                           unsigned int *syt)
+static unsigned int process_it_ctx_payloads(struct amdtp_stream *s,
+                                            const struct pkt_desc *descs,
+                                            unsigned int packets,
+                                            struct snd_pcm_substream *pcm)
 {
-        struct snd_pcm_substream *pcm;
-        unsigned int pcm_frames;
+        unsigned int pcm_frames = 0;
+        int i;
 
-        pcm = READ_ONCE(s->pcm);
-        if (pcm) {
-                write_pcm_s32(s, pcm, buffer, data_blocks);
-                pcm_frames = data_blocks;
-        } else {
-                write_pcm_silence(s, buffer, data_blocks);
-                pcm_frames = 0;
-        }
+        for (i = 0; i < packets; ++i) {
+                const struct pkt_desc *desc = descs + i;
+                __be32 *buf = desc->ctx_payload;
+                unsigned int data_blocks = desc->data_blocks;
 
-        write_midi_messages(s, buffer, data_blocks);
+                if (pcm) {
+                        write_pcm_s32(s, pcm, buf, data_blocks, pcm_frames);
+                        pcm_frames += data_blocks;
+                } else {
+                        write_pcm_silence(s, buf, data_blocks);
+                }
+
+                write_midi_messages(s, buf, data_blocks,
+                                    desc->data_block_counter);
+        }
 
         return pcm_frames;
 }
@@ -375,20 +395,20 @@ static unsigned int process_rx_data_blocks(struct amdtp_stream *s,
 int amdtp_dot_init(struct amdtp_stream *s, struct fw_unit *unit,
                  enum amdtp_stream_direction dir)
 {
-        amdtp_stream_process_data_blocks_t process_data_blocks;
+        amdtp_stream_process_ctx_payloads_t process_ctx_payloads;
         enum cip_flags flags;
 
-        /* Use different mode between incoming/outgoing. */
+        // Use different mode between incoming/outgoing.
         if (dir == AMDTP_IN_STREAM) {
                 flags = CIP_NONBLOCKING;
-                process_data_blocks = process_tx_data_blocks;
+                process_ctx_payloads = process_ir_ctx_payloads;
         } else {
                 flags = CIP_BLOCKING;
-                process_data_blocks = process_rx_data_blocks;
+                process_ctx_payloads = process_it_ctx_payloads;
         }
 
         return amdtp_stream_init(s, unit, dir, flags, CIP_FMT_AM,
-                                 process_data_blocks, sizeof(struct amdtp_dot));
+                                process_ctx_payloads, sizeof(struct amdtp_dot));
 }
 
 void amdtp_dot_reset(struct amdtp_stream *s)
diff --git a/sound/firewire/digi00x/digi00x-stream.c b/sound/firewire/digi00x/digi00x-stream.c
index 3e77dbd3ee22..d6a92460060f 100644
--- a/sound/firewire/digi00x/digi00x-stream.c
+++ b/sound/firewire/digi00x/digi00x-stream.c
@@ -126,9 +126,6 @@ static void finish_session(struct snd_dg00x *dg00x)
 {
         __be32 data;
 
-        amdtp_stream_stop(&dg00x->tx_stream);
-        amdtp_stream_stop(&dg00x->rx_stream);
-
         data = cpu_to_be32(0x00000003);
         snd_fw_transaction(dg00x->unit, TCODE_WRITE_QUADLET_REQUEST,
                            DG00X_ADDR_BASE + DG00X_OFFSET_STREAMING_SET,
@@ -218,29 +215,59 @@ static int keep_resources(struct snd_dg00x *dg00x, struct amdtp_stream *stream,
                                 fw_parent_device(dg00x->unit)->max_speed);
 }
 
-int snd_dg00x_stream_init_duplex(struct snd_dg00x *dg00x)
+static int init_stream(struct snd_dg00x *dg00x, struct amdtp_stream *s)
 {
+        struct fw_iso_resources *resources;
+        enum amdtp_stream_direction dir;
         int err;
 
-        /* For out-stream. */
-        err = fw_iso_resources_init(&dg00x->rx_resources, dg00x->unit);
+        if (s == &dg00x->tx_stream) {
+                resources = &dg00x->tx_resources;
+                dir = AMDTP_IN_STREAM;
+        } else {
+                resources = &dg00x->rx_resources;
+                dir = AMDTP_OUT_STREAM;
+        }
+
+        err = fw_iso_resources_init(resources, dg00x->unit);
         if (err < 0)
-                goto error;
-        err = amdtp_dot_init(&dg00x->rx_stream, dg00x->unit, AMDTP_OUT_STREAM);
+                return err;
+
+        err = amdtp_dot_init(s, dg00x->unit, dir);
         if (err < 0)
-                goto error;
+                fw_iso_resources_destroy(resources);
+
+        return err;
+}
+
+static void destroy_stream(struct snd_dg00x *dg00x, struct amdtp_stream *s)
+{
+        amdtp_stream_destroy(s);
+
+        if (s == &dg00x->tx_stream)
+                fw_iso_resources_destroy(&dg00x->tx_resources);
+        else
+                fw_iso_resources_destroy(&dg00x->rx_resources);
+}
+
+int snd_dg00x_stream_init_duplex(struct snd_dg00x *dg00x)
+{
+        int err;
 
-        /* For in-stream. */
-        err = fw_iso_resources_init(&dg00x->tx_resources, dg00x->unit);
+        err = init_stream(dg00x, &dg00x->rx_stream);
         if (err < 0)
-                goto error;
-        err = amdtp_dot_init(&dg00x->tx_stream, dg00x->unit, AMDTP_IN_STREAM);
+                return err;
+
+        err = init_stream(dg00x, &dg00x->tx_stream);
         if (err < 0)
-                goto error;
+                destroy_stream(dg00x, &dg00x->rx_stream);
+
+        err = amdtp_domain_init(&dg00x->domain);
+        if (err < 0) {
+                destroy_stream(dg00x, &dg00x->rx_stream);
+                destroy_stream(dg00x, &dg00x->tx_stream);
+        }
 
-        return 0;
-error:
-        snd_dg00x_stream_destroy_duplex(dg00x);
         return err;
 }
 
@@ -250,11 +277,10 @@ error:
  */
 void snd_dg00x_stream_destroy_duplex(struct snd_dg00x *dg00x)
 {
-        amdtp_stream_destroy(&dg00x->rx_stream);
-        fw_iso_resources_destroy(&dg00x->rx_resources);
+        amdtp_domain_destroy(&dg00x->domain);
 
-        amdtp_stream_destroy(&dg00x->tx_stream);
-        fw_iso_resources_destroy(&dg00x->tx_resources);
+        destroy_stream(dg00x, &dg00x->rx_stream);
+        destroy_stream(dg00x, &dg00x->tx_stream);
 }
 
 int snd_dg00x_stream_reserve_duplex(struct snd_dg00x *dg00x, unsigned int rate)
@@ -269,6 +295,8 @@ int snd_dg00x_stream_reserve_duplex(struct snd_dg00x *dg00x, unsigned int rate)
                 rate = curr_rate;
 
         if (dg00x->substreams_counter == 0 || curr_rate != rate) {
+                amdtp_domain_stop(&dg00x->domain);
+
                 finish_session(dg00x);
 
                 fw_iso_resources_free(&dg00x->tx_resources);
@@ -301,8 +329,10 @@ int snd_dg00x_stream_start_duplex(struct snd_dg00x *dg00x)
                 return 0;
 
         if (amdtp_streaming_error(&dg00x->tx_stream) ||
-            amdtp_streaming_error(&dg00x->rx_stream))
+            amdtp_streaming_error(&dg00x->rx_stream)) {
+                amdtp_domain_stop(&dg00x->domain);
                 finish_session(dg00x);
+        }
 
         if (generation != fw_parent_device(dg00x->unit)->card->generation) {
                 err = fw_iso_resources_update(&dg00x->tx_resources);
@@ -319,36 +349,30 @@ int snd_dg00x_stream_start_duplex(struct snd_dg00x *dg00x)
          * which source of clock is used.
          */
         if (!amdtp_stream_running(&dg00x->rx_stream)) {
+                int spd = fw_parent_device(dg00x->unit)->max_speed;
+
                 err = begin_session(dg00x);
                 if (err < 0)
                         goto error;
 
-                err = amdtp_stream_start(&dg00x->rx_stream,
-                                dg00x->rx_resources.channel,
-                                fw_parent_device(dg00x->unit)->max_speed);
+                err = amdtp_domain_add_stream(&dg00x->domain, &dg00x->rx_stream,
+                                              dg00x->rx_resources.channel, spd);
                 if (err < 0)
                         goto error;
 
-                if (!amdtp_stream_wait_callback(&dg00x->rx_stream,
-                                              CALLBACK_TIMEOUT)) {
-                        err = -ETIMEDOUT;
+                err = amdtp_domain_add_stream(&dg00x->domain, &dg00x->tx_stream,
+                                              dg00x->tx_resources.channel, spd);
+                if (err < 0)
                         goto error;
-                }
-        }
 
-        /*
-         * The value of SYT field in transmitted packets is always 0x0000. Thus,
-         * duplex streams with timestamp synchronization cannot be built.
-         */
-        if (!amdtp_stream_running(&dg00x->tx_stream)) {
-                err = amdtp_stream_start(&dg00x->tx_stream,
-                                dg00x->tx_resources.channel,
-                                fw_parent_device(dg00x->unit)->max_speed);
+                err = amdtp_domain_start(&dg00x->domain);
                 if (err < 0)
                         goto error;
 
-                if (!amdtp_stream_wait_callback(&dg00x->tx_stream,
-                                              CALLBACK_TIMEOUT)) {
+                if (!amdtp_stream_wait_callback(&dg00x->rx_stream,
+                                                CALLBACK_TIMEOUT) ||
+                    !amdtp_stream_wait_callback(&dg00x->tx_stream,
+                                                CALLBACK_TIMEOUT)) {
                         err = -ETIMEDOUT;
                         goto error;
                 }
@@ -356,6 +380,7 @@ int snd_dg00x_stream_start_duplex(struct snd_dg00x *dg00x)
 
         return 0;
 error:
+        amdtp_domain_stop(&dg00x->domain);
         finish_session(dg00x);
 
         return err;
@@ -364,6 +389,7 @@ error:
 void snd_dg00x_stream_stop_duplex(struct snd_dg00x *dg00x)
 {
         if (dg00x->substreams_counter == 0) {
+                amdtp_domain_stop(&dg00x->domain);
                 finish_session(dg00x);
 
                 fw_iso_resources_free(&dg00x->tx_resources);
diff --git a/sound/firewire/digi00x/digi00x.h b/sound/firewire/digi00x/digi00x.h
index 0994d191ccda..8041c65f2736 100644
--- a/sound/firewire/digi00x/digi00x.h
+++ b/sound/firewire/digi00x/digi00x.h
@@ -59,6 +59,8 @@ struct snd_dg00x {
 
         /* Console models have additional MIDI ports for control surface. */
         bool is_console;
+
+        struct amdtp_domain domain;
 };
 
 #define DG00X_ADDR_BASE         0xffffe0000000ull
diff --git a/sound/firewire/fireface/amdtp-ff.c b/sound/firewire/fireface/amdtp-ff.c
index 2938489740b4..119c0076b17a 100644
--- a/sound/firewire/fireface/amdtp-ff.c
+++ b/sound/firewire/fireface/amdtp-ff.c
@@ -27,19 +27,24 @@ int amdtp_ff_set_parameters(struct amdtp_stream *s, unsigned int rate,
         return amdtp_stream_set_parameters(s, rate, data_channels);
 }
 
-static void write_pcm_s32(struct amdtp_stream *s,
-                          struct snd_pcm_substream *pcm,
-                          __le32 *buffer, unsigned int frames)
+static void write_pcm_s32(struct amdtp_stream *s, struct snd_pcm_substream *pcm,
+                          __le32 *buffer, unsigned int frames,
+                          unsigned int pcm_frames)
 {
         struct amdtp_ff *p = s->protocol;
+        unsigned int channels = p->pcm_channels;
         struct snd_pcm_runtime *runtime = pcm->runtime;
-        unsigned int channels, remaining_frames, i, c;
+        unsigned int pcm_buffer_pointer;
+        int remaining_frames;
         const u32 *src;
+        int i, c;
+
+        pcm_buffer_pointer = s->pcm_buffer_pointer + pcm_frames;
+        pcm_buffer_pointer %= runtime->buffer_size;
 
-        channels = p->pcm_channels;
         src = (void *)runtime->dma_area +
-                        frames_to_bytes(runtime, s->pcm_buffer_pointer);
-        remaining_frames = runtime->buffer_size - s->pcm_buffer_pointer;
+                                frames_to_bytes(runtime, pcm_buffer_pointer);
+        remaining_frames = runtime->buffer_size - pcm_buffer_pointer;
 
         for (i = 0; i < frames; ++i) {
                 for (c = 0; c < channels; ++c) {
@@ -52,19 +57,24 @@ static void write_pcm_s32(struct amdtp_stream *s,
         }
 }
 
-static void read_pcm_s32(struct amdtp_stream *s,
-                         struct snd_pcm_substream *pcm,
-                         __le32 *buffer, unsigned int frames)
+static void read_pcm_s32(struct amdtp_stream *s, struct snd_pcm_substream *pcm,
+                         __le32 *buffer, unsigned int frames,
+                         unsigned int pcm_frames)
 {
         struct amdtp_ff *p = s->protocol;
+        unsigned int channels = p->pcm_channels;
         struct snd_pcm_runtime *runtime = pcm->runtime;
-        unsigned int channels, remaining_frames, i, c;
+        unsigned int pcm_buffer_pointer;
+        int remaining_frames;
         u32 *dst;
+        int i, c;
+
+        pcm_buffer_pointer = s->pcm_buffer_pointer + pcm_frames;
+        pcm_buffer_pointer %= runtime->buffer_size;
 
-        channels = p->pcm_channels;
         dst  = (void *)runtime->dma_area +
-                        frames_to_bytes(runtime, s->pcm_buffer_pointer);
-        remaining_frames = runtime->buffer_size - s->pcm_buffer_pointer;
+                                frames_to_bytes(runtime, pcm_buffer_pointer);
+        remaining_frames = runtime->buffer_size - pcm_buffer_pointer;
 
         for (i = 0; i < frames; ++i) {
                 for (c = 0; c < channels; ++c) {
@@ -102,38 +112,47 @@ int amdtp_ff_add_pcm_hw_constraints(struct amdtp_stream *s,
         return amdtp_stream_add_pcm_hw_constraints(s, runtime);
 }
 
-static unsigned int process_rx_data_blocks(struct amdtp_stream *s,
-                                           __be32 *buffer,
-                                           unsigned int data_blocks,
-                                           unsigned int *syt)
+static unsigned int process_it_ctx_payloads(struct amdtp_stream *s,
+                                           const struct pkt_desc *descs,
+                                           unsigned int packets,
+                                           struct snd_pcm_substream *pcm)
 {
-        struct snd_pcm_substream *pcm = READ_ONCE(s->pcm);
-        unsigned int pcm_frames;
-
-        if (pcm) {
-                write_pcm_s32(s, pcm, (__le32 *)buffer, data_blocks);
-                pcm_frames = data_blocks;
-        } else {
-                write_pcm_silence(s, (__le32 *)buffer, data_blocks);
-                pcm_frames = 0;
+        unsigned int pcm_frames = 0;
+        int i;
+
+        for (i = 0; i < packets; ++i) {
+                const struct pkt_desc *desc = descs + i;
+                __le32 *buf = (__le32 *)desc->ctx_payload;
+                unsigned int data_blocks = desc->data_blocks;
+
+                if (pcm) {
+                        write_pcm_s32(s, pcm, buf, data_blocks, pcm_frames);
+                        pcm_frames += data_blocks;
+                } else {
+                        write_pcm_silence(s, buf, data_blocks);
+                }
         }
 
         return pcm_frames;
 }
 
-static unsigned int process_tx_data_blocks(struct amdtp_stream *s,
-                                           __be32 *buffer,
-                                           unsigned int data_blocks,
-                                           unsigned int *syt)
+static unsigned int process_ir_ctx_payloads(struct amdtp_stream *s,
+                                            const struct pkt_desc *descs,
+                                            unsigned int packets,
+                                            struct snd_pcm_substream *pcm)
 {
-        struct snd_pcm_substream *pcm = READ_ONCE(s->pcm);
-        unsigned int pcm_frames;
-
-        if (pcm) {
-                read_pcm_s32(s, pcm, (__le32 *)buffer, data_blocks);
-                pcm_frames = data_blocks;
-        } else {
-                pcm_frames = 0;
+        unsigned int pcm_frames = 0;
+        int i;
+
+        for (i = 0; i < packets; ++i) {
+                const struct pkt_desc *desc = descs + i;
+                __le32 *buf = (__le32 *)desc->ctx_payload;
+                unsigned int data_blocks = desc->data_blocks;
+
+                if (pcm) {
+                        read_pcm_s32(s, pcm, buf, data_blocks, pcm_frames);
+                        pcm_frames += data_blocks;
+                }
         }
 
         return pcm_frames;
@@ -142,13 +161,13 @@ static unsigned int process_tx_data_blocks(struct amdtp_stream *s,
 int amdtp_ff_init(struct amdtp_stream *s, struct fw_unit *unit,
                   enum amdtp_stream_direction dir)
 {
-        amdtp_stream_process_data_blocks_t process_data_blocks;
+        amdtp_stream_process_ctx_payloads_t process_ctx_payloads;
 
         if (dir == AMDTP_IN_STREAM)
-                process_data_blocks = process_tx_data_blocks;
+                process_ctx_payloads = process_ir_ctx_payloads;
         else
-                process_data_blocks = process_rx_data_blocks;
+                process_ctx_payloads = process_it_ctx_payloads;
 
         return amdtp_stream_init(s, unit, dir, CIP_NO_HEADER, 0,
-                                 process_data_blocks, sizeof(struct amdtp_ff));
+                                 process_ctx_payloads, sizeof(struct amdtp_ff));
 }
diff --git a/sound/firewire/fireface/ff-stream.c b/sound/firewire/fireface/ff-stream.c
index 4208b8004d1a..e8e6f9fd6433 100644
--- a/sound/firewire/fireface/ff-stream.c
+++ b/sound/firewire/fireface/ff-stream.c
@@ -32,61 +32,65 @@ int snd_ff_stream_get_multiplier_mode(enum cip_sfc sfc,
 
 static inline void finish_session(struct snd_ff *ff)
 {
-        amdtp_stream_stop(&ff->tx_stream);
-        amdtp_stream_stop(&ff->rx_stream);
-
         ff->spec->protocol->finish_session(ff);
         ff->spec->protocol->switch_fetching_mode(ff, false);
 }
 
-static int init_stream(struct snd_ff *ff, enum amdtp_stream_direction dir)
+static int init_stream(struct snd_ff *ff, struct amdtp_stream *s)
 {
-        int err;
         struct fw_iso_resources *resources;
-        struct amdtp_stream *stream;
+        enum amdtp_stream_direction dir;
+        int err;
 
-        if (dir == AMDTP_IN_STREAM) {
+        if (s == &ff->tx_stream) {
                 resources = &ff->tx_resources;
-                stream = &ff->tx_stream;
+                dir = AMDTP_IN_STREAM;
         } else {
                 resources = &ff->rx_resources;
-                stream = &ff->rx_stream;
+                dir = AMDTP_OUT_STREAM;
         }
 
         err = fw_iso_resources_init(resources, ff->unit);
         if (err < 0)
                 return err;
 
-        err = amdtp_ff_init(stream, ff->unit, dir);
+        err = amdtp_ff_init(s, ff->unit, dir);
         if (err < 0)
                 fw_iso_resources_destroy(resources);
 
         return err;
 }
 
-static void destroy_stream(struct snd_ff *ff, enum amdtp_stream_direction dir)
+static void destroy_stream(struct snd_ff *ff, struct amdtp_stream *s)
 {
-        if (dir == AMDTP_IN_STREAM) {
-                amdtp_stream_destroy(&ff->tx_stream);
+        amdtp_stream_destroy(s);
+
+        if (s == &ff->tx_stream)
                 fw_iso_resources_destroy(&ff->tx_resources);
-        } else {
-                amdtp_stream_destroy(&ff->rx_stream);
+        else
                 fw_iso_resources_destroy(&ff->rx_resources);
-        }
 }
 
 int snd_ff_stream_init_duplex(struct snd_ff *ff)
 {
         int err;
 
-        err = init_stream(ff, AMDTP_OUT_STREAM);
+        err = init_stream(ff, &ff->rx_stream);
         if (err < 0)
-                goto end;
+                return err;
+
+        err = init_stream(ff, &ff->tx_stream);
+        if (err < 0) {
+                destroy_stream(ff, &ff->rx_stream);
+                return err;
+        }
+
+        err = amdtp_domain_init(&ff->domain);
+        if (err < 0) {
+                destroy_stream(ff, &ff->rx_stream);
+                destroy_stream(ff, &ff->tx_stream);
+        }
 
-        err = init_stream(ff, AMDTP_IN_STREAM);
-        if (err < 0)
-                destroy_stream(ff, AMDTP_OUT_STREAM);
-end:
         return err;
 }
 
@@ -96,8 +100,10 @@ end:
  */
 void snd_ff_stream_destroy_duplex(struct snd_ff *ff)
 {
-        destroy_stream(ff, AMDTP_IN_STREAM);
-        destroy_stream(ff, AMDTP_OUT_STREAM);
+        amdtp_domain_destroy(&ff->domain);
+
+        destroy_stream(ff, &ff->rx_stream);
+        destroy_stream(ff, &ff->tx_stream);
 }
 
 int snd_ff_stream_reserve_duplex(struct snd_ff *ff, unsigned int rate)
@@ -114,6 +120,7 @@ int snd_ff_stream_reserve_duplex(struct snd_ff *ff, unsigned int rate)
                 enum snd_ff_stream_mode mode;
                 int i;
 
+                amdtp_domain_stop(&ff->domain);
                 finish_session(ff);
 
                 fw_iso_resources_free(&ff->tx_resources);
@@ -156,51 +163,52 @@ int snd_ff_stream_start_duplex(struct snd_ff *ff, unsigned int rate)
                 return 0;
 
         if (amdtp_streaming_error(&ff->tx_stream) ||
-            amdtp_streaming_error(&ff->rx_stream))
+            amdtp_streaming_error(&ff->rx_stream)) {
+                amdtp_domain_stop(&ff->domain);
                 finish_session(ff);
+        }
 
         /*
          * Regardless of current source of clock signal, drivers transfer some
          * packets. Then, the device transfers packets.
          */
         if (!amdtp_stream_running(&ff->rx_stream)) {
+                int spd = fw_parent_device(ff->unit)->max_speed;
+
                 err = ff->spec->protocol->begin_session(ff, rate);
                 if (err < 0)
                         goto error;
 
-                err = amdtp_stream_start(&ff->rx_stream,
-                                         ff->rx_resources.channel,
-                                         fw_parent_device(ff->unit)->max_speed);
+                err = amdtp_domain_add_stream(&ff->domain, &ff->rx_stream,
+                                              ff->rx_resources.channel, spd);
                 if (err < 0)
                         goto error;
 
-                if (!amdtp_stream_wait_callback(&ff->rx_stream,
-                                                CALLBACK_TIMEOUT_MS)) {
-                        err = -ETIMEDOUT;
-                        goto error;
-                }
-
-                err = ff->spec->protocol->switch_fetching_mode(ff, true);
+                err = amdtp_domain_add_stream(&ff->domain, &ff->tx_stream,
+                                              ff->tx_resources.channel, spd);
                 if (err < 0)
                         goto error;
-        }
 
-        if (!amdtp_stream_running(&ff->tx_stream)) {
-                err = amdtp_stream_start(&ff->tx_stream,
-                                         ff->tx_resources.channel,
-                                         fw_parent_device(ff->unit)->max_speed);
+                err = amdtp_domain_start(&ff->domain);
                 if (err < 0)
                         goto error;
 
-                if (!amdtp_stream_wait_callback(&ff->tx_stream,
+                if (!amdtp_stream_wait_callback(&ff->rx_stream,
+                                                CALLBACK_TIMEOUT_MS) ||
+                    !amdtp_stream_wait_callback(&ff->tx_stream,
                                                 CALLBACK_TIMEOUT_MS)) {
                         err = -ETIMEDOUT;
                         goto error;
                 }
+
+                err = ff->spec->protocol->switch_fetching_mode(ff, true);
+                if (err < 0)
+                        goto error;
         }
 
         return 0;
 error:
+        amdtp_domain_stop(&ff->domain);
         finish_session(ff);
 
         return err;
@@ -209,6 +217,7 @@ error:
 void snd_ff_stream_stop_duplex(struct snd_ff *ff)
 {
         if (ff->substreams_counter == 0) {
+                amdtp_domain_stop(&ff->domain);
                 finish_session(ff);
 
                 fw_iso_resources_free(&ff->tx_resources);
@@ -218,12 +227,11 @@ void snd_ff_stream_stop_duplex(struct snd_ff *ff)
 
 void snd_ff_stream_update_duplex(struct snd_ff *ff)
 {
+        amdtp_domain_stop(&ff->domain);
+
         // The device discontinue to transfer packets.
         amdtp_stream_pcm_abort(&ff->tx_stream);
-        amdtp_stream_stop(&ff->tx_stream);
-
         amdtp_stream_pcm_abort(&ff->rx_stream);
-        amdtp_stream_stop(&ff->rx_stream);
 }
 
 void snd_ff_stream_lock_changed(struct snd_ff *ff)
diff --git a/sound/firewire/fireface/ff.h b/sound/firewire/fireface/ff.h
index 36dd0c75b9f7..b4c22ca6079e 100644
--- a/sound/firewire/fireface/ff.h
+++ b/sound/firewire/fireface/ff.h
@@ -91,6 +91,8 @@ struct snd_ff {
         int dev_lock_count;
         bool dev_lock_changed;
         wait_queue_head_t hwdep_wait;
+
+        struct amdtp_domain domain;
 };
 
 enum snd_ff_clock_src {
diff --git a/sound/firewire/fireworks/fireworks.h b/sound/firewire/fireworks/fireworks.h
index 31efd4b53b4f..4cda297f8438 100644
--- a/sound/firewire/fireworks/fireworks.h
+++ b/sound/firewire/fireworks/fireworks.h
@@ -107,6 +107,8 @@ struct snd_efw {
         u8 *resp_buf;
         u8 *pull_ptr;
         u8 *push_ptr;
+
+        struct amdtp_domain domain;
 };
 
 int snd_efw_transaction_cmd(struct fw_unit *unit,
diff --git a/sound/firewire/fireworks/fireworks_stream.c b/sound/firewire/fireworks/fireworks_stream.c
index e659a0b89ba5..f2de304d2f26 100644
--- a/sound/firewire/fireworks/fireworks_stream.c
+++ b/sound/firewire/fireworks/fireworks_stream.c
@@ -8,8 +8,7 @@
 
 #define CALLBACK_TIMEOUT        100
 
-static int
-init_stream(struct snd_efw *efw, struct amdtp_stream *stream)
+static int init_stream(struct snd_efw *efw, struct amdtp_stream *stream)
 {
         struct cmp_connection *conn;
         enum cmp_direction c_dir;
@@ -28,26 +27,38 @@ init_stream(struct snd_efw *efw, struct amdtp_stream *stream)
 
         err = cmp_connection_init(conn, efw->unit, c_dir, 0);
         if (err < 0)
-                goto end;
+                return err;
 
         err = amdtp_am824_init(stream, efw->unit, s_dir, CIP_BLOCKING);
         if (err < 0) {
                 amdtp_stream_destroy(stream);
                 cmp_connection_destroy(conn);
+                return err;
         }
-end:
-        return err;
-}
 
-static void
-stop_stream(struct snd_efw *efw, struct amdtp_stream *stream)
-{
-        amdtp_stream_stop(stream);
+        if (stream == &efw->tx_stream) {
+                // Fireworks transmits NODATA packets with TAG0.
+                efw->tx_stream.flags |= CIP_EMPTY_WITH_TAG0;
+                // Fireworks has its own meaning for dbc.
+                efw->tx_stream.flags |= CIP_DBC_IS_END_EVENT;
+                // Fireworks reset dbc at bus reset.
+                efw->tx_stream.flags |= CIP_SKIP_DBC_ZERO_CHECK;
+                // But Recent firmwares starts packets with non-zero dbc.
+                // Driver version 5.7.6 installs firmware version 5.7.3.
+                if (efw->is_fireworks3 &&
+                    (efw->firmware_version == 0x5070000 ||
+                     efw->firmware_version == 0x5070300 ||
+                     efw->firmware_version == 0x5080000))
+                        efw->tx_stream.flags |= CIP_UNALIGHED_DBC;
+                // AudioFire9 always reports wrong dbs.
+                if (efw->is_af9)
+                        efw->tx_stream.flags |= CIP_WRONG_DBS;
+                // Firmware version 5.5 reports fixed interval for dbc.
+                if (efw->firmware_version == 0x5050000)
+                        efw->tx_stream.ctx_data.tx.dbc_interval = 8;
+        }
 
-        if (stream == &efw->tx_stream)
-                cmp_connection_break(&efw->out_conn);
-        else
-                cmp_connection_break(&efw->in_conn);
+        return err;
 }
 
 static int start_stream(struct snd_efw *efw, struct amdtp_stream *stream,
@@ -67,38 +78,26 @@ static int start_stream(struct snd_efw *efw, struct amdtp_stream *stream,
                 return err;
 
         // Start amdtp stream.
-        err = amdtp_stream_start(stream, conn->resources.channel, conn->speed);
+        err = amdtp_domain_add_stream(&efw->domain, stream,
+                                      conn->resources.channel, conn->speed);
         if (err < 0) {
                 cmp_connection_break(conn);
                 return err;
         }
 
-        // Wait first callback.
-        if (!amdtp_stream_wait_callback(stream, CALLBACK_TIMEOUT)) {
-                amdtp_stream_stop(stream);
-                cmp_connection_break(conn);
-                return -ETIMEDOUT;
-        }
-
         return 0;
 }
 
-/*
- * This function should be called before starting the stream or after stopping
- * the streams.
- */
-static void
-destroy_stream(struct snd_efw *efw, struct amdtp_stream *stream)
+// This function should be called before starting the stream or after stopping
+// the streams.
+static void destroy_stream(struct snd_efw *efw, struct amdtp_stream *stream)
 {
-        struct cmp_connection *conn;
+        amdtp_stream_destroy(stream);
 
         if (stream == &efw->tx_stream)
-                conn = &efw->out_conn;
+                cmp_connection_destroy(&efw->out_conn);
         else
-                conn = &efw->in_conn;
-
-        amdtp_stream_destroy(stream);
-        cmp_connection_destroy(conn);
+                cmp_connection_destroy(&efw->in_conn);
 }
 
 static int
@@ -131,42 +130,28 @@ int snd_efw_stream_init_duplex(struct snd_efw *efw)
 
         err = init_stream(efw, &efw->tx_stream);
         if (err < 0)
-                goto end;
-        /* Fireworks transmits NODATA packets with TAG0. */
-        efw->tx_stream.flags |= CIP_EMPTY_WITH_TAG0;
-        /* Fireworks has its own meaning for dbc. */
-        efw->tx_stream.flags |= CIP_DBC_IS_END_EVENT;
-        /* Fireworks reset dbc at bus reset. */
-        efw->tx_stream.flags |= CIP_SKIP_DBC_ZERO_CHECK;
-        /*
-         * But Recent firmwares starts packets with non-zero dbc.
-         * Driver version 5.7.6 installs firmware version 5.7.3.
-         */
-        if (efw->is_fireworks3 &&
-            (efw->firmware_version == 0x5070000 ||
-             efw->firmware_version == 0x5070300 ||
-             efw->firmware_version == 0x5080000))
-                efw->tx_stream.ctx_data.tx.first_dbc = 0x02;
-        /* AudioFire9 always reports wrong dbs. */
-        if (efw->is_af9)
-                efw->tx_stream.flags |= CIP_WRONG_DBS;
-        /* Firmware version 5.5 reports fixed interval for dbc. */
-        if (efw->firmware_version == 0x5050000)
-                efw->tx_stream.ctx_data.tx.dbc_interval = 8;
+                return err;
 
         err = init_stream(efw, &efw->rx_stream);
         if (err < 0) {
                 destroy_stream(efw, &efw->tx_stream);
-                goto end;
+                return err;
+        }
+
+        err = amdtp_domain_init(&efw->domain);
+        if (err < 0) {
+                destroy_stream(efw, &efw->tx_stream);
+                destroy_stream(efw, &efw->rx_stream);
+                return err;
         }
 
-        /* set IEC61883 compliant mode (actually not fully compliant...) */
+        // set IEC61883 compliant mode (actually not fully compliant...).
         err = snd_efw_command_set_tx_mode(efw, SND_EFW_TRANSPORT_MODE_IEC61883);
         if (err < 0) {
                 destroy_stream(efw, &efw->tx_stream);
                 destroy_stream(efw, &efw->rx_stream);
         }
-end:
+
         return err;
 }
 
@@ -214,8 +199,10 @@ int snd_efw_stream_reserve_duplex(struct snd_efw *efw, unsigned int rate)
         if (rate == 0)
                 rate = curr_rate;
         if (rate != curr_rate) {
-                stop_stream(efw, &efw->tx_stream);
-                stop_stream(efw, &efw->rx_stream);
+                amdtp_domain_stop(&efw->domain);
+
+                cmp_connection_break(&efw->out_conn);
+                cmp_connection_break(&efw->in_conn);
 
                 cmp_connection_release(&efw->out_conn);
                 cmp_connection_release(&efw->in_conn);
@@ -255,47 +242,57 @@ int snd_efw_stream_start_duplex(struct snd_efw *efw)
         if (efw->substreams_counter == 0)
                 return -EIO;
 
-        err = snd_efw_command_get_sampling_rate(efw, &rate);
-        if (err < 0)
-                return err;
-
         if (amdtp_streaming_error(&efw->rx_stream) ||
             amdtp_streaming_error(&efw->tx_stream)) {
-                stop_stream(efw, &efw->rx_stream);
-                stop_stream(efw, &efw->tx_stream);
+                amdtp_domain_stop(&efw->domain);
+                cmp_connection_break(&efw->out_conn);
+                cmp_connection_break(&efw->in_conn);
         }
 
-        /* master should be always running */
+        err = snd_efw_command_get_sampling_rate(efw, &rate);
+        if (err < 0)
+                return err;
+
         if (!amdtp_stream_running(&efw->rx_stream)) {
                 err = start_stream(efw, &efw->rx_stream, rate);
-                if (err < 0) {
-                        dev_err(&efw->unit->device,
-                                "fail to start AMDTP master stream:%d\n", err);
+                if (err < 0)
                         goto error;
-                }
-        }
 
-        if (!amdtp_stream_running(&efw->tx_stream)) {
                 err = start_stream(efw, &efw->tx_stream, rate);
-                if (err < 0) {
-                        dev_err(&efw->unit->device,
-                                "fail to start AMDTP slave stream:%d\n", err);
+                if (err < 0)
+                        goto error;
+
+                err = amdtp_domain_start(&efw->domain);
+                if (err < 0)
+                        goto error;
+
+                // Wait first callback.
+                if (!amdtp_stream_wait_callback(&efw->rx_stream,
+                                                CALLBACK_TIMEOUT) ||
+                    !amdtp_stream_wait_callback(&efw->tx_stream,
+                                                CALLBACK_TIMEOUT)) {
+                        err = -ETIMEDOUT;
                         goto error;
                 }
         }
 
         return 0;
 error:
-        stop_stream(efw, &efw->rx_stream);
-        stop_stream(efw, &efw->tx_stream);
+        amdtp_domain_stop(&efw->domain);
+
+        cmp_connection_break(&efw->out_conn);
+        cmp_connection_break(&efw->in_conn);
+
         return err;
 }
 
 void snd_efw_stream_stop_duplex(struct snd_efw *efw)
 {
         if (efw->substreams_counter == 0) {
-                stop_stream(efw, &efw->tx_stream);
-                stop_stream(efw, &efw->rx_stream);
+                amdtp_domain_stop(&efw->domain);
+
+                cmp_connection_break(&efw->out_conn);
+                cmp_connection_break(&efw->in_conn);
 
                 cmp_connection_release(&efw->out_conn);
                 cmp_connection_release(&efw->in_conn);
@@ -304,18 +301,19 @@ void snd_efw_stream_stop_duplex(struct snd_efw *efw)
 
 void snd_efw_stream_update_duplex(struct snd_efw *efw)
 {
-        if (cmp_connection_update(&efw->out_conn) < 0 ||
-            cmp_connection_update(&efw->in_conn) < 0) {
-                stop_stream(efw, &efw->rx_stream);
-                stop_stream(efw, &efw->tx_stream);
-        } else {
-                amdtp_stream_update(&efw->rx_stream);
-                amdtp_stream_update(&efw->tx_stream);
-        }
+        amdtp_domain_stop(&efw->domain);
+
+        cmp_connection_break(&efw->out_conn);
+        cmp_connection_break(&efw->in_conn);
+
+        amdtp_stream_pcm_abort(&efw->rx_stream);
+        amdtp_stream_pcm_abort(&efw->tx_stream);
 }
 
 void snd_efw_stream_destroy_duplex(struct snd_efw *efw)
 {
+        amdtp_domain_destroy(&efw->domain);
+
         destroy_stream(efw, &efw->rx_stream);
         destroy_stream(efw, &efw->tx_stream);
 }
diff --git a/sound/firewire/motu/amdtp-motu.c b/sound/firewire/motu/amdtp-motu.c
index 7973dedd31ef..0fd36e469ad0 100644
--- a/sound/firewire/motu/amdtp-motu.c
+++ b/sound/firewire/motu/amdtp-motu.c
@@ -117,19 +117,25 @@ int amdtp_motu_set_parameters(struct amdtp_stream *s, unsigned int rate,
         return 0;
 }
 
-static void read_pcm_s32(struct amdtp_stream *s,
-                         struct snd_pcm_runtime *runtime,
-                         __be32 *buffer, unsigned int data_blocks)
+static void read_pcm_s32(struct amdtp_stream *s, struct snd_pcm_substream *pcm,
+                         __be32 *buffer, unsigned int data_blocks,
+                         unsigned int pcm_frames)
 {
         struct amdtp_motu *p = s->protocol;
-        unsigned int channels, remaining_frames, i, c;
+        unsigned int channels = p->pcm_chunks;
+        struct snd_pcm_runtime *runtime = pcm->runtime;
+        unsigned int pcm_buffer_pointer;
+        int remaining_frames;
         u8 *byte;
         u32 *dst;
+        int i, c;
+
+        pcm_buffer_pointer = s->pcm_buffer_pointer + pcm_frames;
+        pcm_buffer_pointer %= runtime->buffer_size;
 
-        channels = p->pcm_chunks;
         dst = (void *)runtime->dma_area +
-                        frames_to_bytes(runtime, s->pcm_buffer_pointer);
-        remaining_frames = runtime->buffer_size - s->pcm_buffer_pointer;
+                                frames_to_bytes(runtime, pcm_buffer_pointer);
+        remaining_frames = runtime->buffer_size - pcm_buffer_pointer;
 
         for (i = 0; i < data_blocks; ++i) {
                 byte = (u8 *)buffer + p->pcm_byte_offset;
@@ -147,19 +153,25 @@ static void read_pcm_s32(struct amdtp_stream *s,
         }
 }
 
-static void write_pcm_s32(struct amdtp_stream *s,
-                          struct snd_pcm_runtime *runtime,
-                          __be32 *buffer, unsigned int data_blocks)
+static void write_pcm_s32(struct amdtp_stream *s, struct snd_pcm_substream *pcm,
+                          __be32 *buffer, unsigned int data_blocks,
+                          unsigned int pcm_frames)
 {
         struct amdtp_motu *p = s->protocol;
-        unsigned int channels, remaining_frames, i, c;
+        unsigned int channels = p->pcm_chunks;
+        struct snd_pcm_runtime *runtime = pcm->runtime;
+        unsigned int pcm_buffer_pointer;
+        int remaining_frames;
         u8 *byte;
         const u32 *src;
+        int i, c;
+
+        pcm_buffer_pointer = s->pcm_buffer_pointer + pcm_frames;
+        pcm_buffer_pointer %= runtime->buffer_size;
 
-        channels = p->pcm_chunks;
         src = (void *)runtime->dma_area +
-                        frames_to_bytes(runtime, s->pcm_buffer_pointer);
-        remaining_frames = runtime->buffer_size - s->pcm_buffer_pointer;
+                                frames_to_bytes(runtime, pcm_buffer_pointer);
+        remaining_frames = runtime->buffer_size - pcm_buffer_pointer;
 
         for (i = 0; i < data_blocks; ++i) {
                 byte = (u8 *)buffer + p->pcm_byte_offset;
@@ -298,24 +310,52 @@ static void __maybe_unused copy_message(u64 *frames, __be32 *buffer,
         }
 }
 
-static unsigned int process_tx_data_blocks(struct amdtp_stream *s,
-                                __be32 *buffer, unsigned int data_blocks,
-                                unsigned int *syt)
+static void probe_tracepoints_events(struct amdtp_stream *s,
+                                     const struct pkt_desc *descs,
+                                     unsigned int packets)
+{
+        int i;
+
+        for (i = 0; i < packets; ++i) {
+                const struct pkt_desc *desc = descs + i;
+                __be32 *buf = desc->ctx_payload;
+                unsigned int data_blocks = desc->data_blocks;
+
+                trace_data_block_sph(s, data_blocks, buf);
+                trace_data_block_message(s, data_blocks, buf);
+        }
+}
+
+static unsigned int process_ir_ctx_payloads(struct amdtp_stream *s,
+                                            const struct pkt_desc *descs,
+                                            unsigned int packets,
+                                            struct snd_pcm_substream *pcm)
 {
         struct amdtp_motu *p = s->protocol;
-        struct snd_pcm_substream *pcm;
+        unsigned int pcm_frames = 0;
+        int i;
+
+        // For data block processing.
+        for (i = 0; i < packets; ++i) {
+                const struct pkt_desc *desc = descs + i;
+                __be32 *buf = desc->ctx_payload;
+                unsigned int data_blocks = desc->data_blocks;
 
-        trace_data_block_sph(s, data_blocks, buffer);
-        trace_data_block_message(s, data_blocks, buffer);
+                if (pcm) {
+                        read_pcm_s32(s, pcm, buf, data_blocks, pcm_frames);
+                        pcm_frames += data_blocks;
+                }
 
-        if (p->midi_ports)
-                read_midi_messages(s, buffer, data_blocks);
+                if (p->midi_ports)
+                        read_midi_messages(s, buf, data_blocks);
+        }
 
-        pcm = READ_ONCE(s->pcm);
-        if (data_blocks > 0 && pcm)
-                read_pcm_s32(s, pcm->runtime, buffer, data_blocks);
+        // For tracepoints.
+        if (trace_data_block_sph_enabled() ||
+            trace_data_block_message_enabled())
+                probe_tracepoints_events(s, descs, packets);
 
-        return data_blocks;
+        return pcm_frames;
 }
 
 static inline void compute_next_elapse_from_start(struct amdtp_motu *p)
@@ -360,46 +400,55 @@ static void write_sph(struct amdtp_stream *s, __be32 *buffer,
         }
 }
 
-static unsigned int process_rx_data_blocks(struct amdtp_stream *s,
-                                __be32 *buffer, unsigned int data_blocks,
-                                unsigned int *syt)
+static unsigned int process_it_ctx_payloads(struct amdtp_stream *s,
+                                            const struct pkt_desc *descs,
+                                            unsigned int packets,
+                                            struct snd_pcm_substream *pcm)
 {
-        struct amdtp_motu *p = (struct amdtp_motu *)s->protocol;
-        struct snd_pcm_substream *pcm;
+        struct amdtp_motu *p = s->protocol;
+        unsigned int pcm_frames = 0;
+        int i;
 
-        /* Not used. */
-        *syt = 0xffff;
+        // For data block processing.
+        for (i = 0; i < packets; ++i) {
+                const struct pkt_desc *desc = descs + i;
+                __be32 *buf = desc->ctx_payload;
+                unsigned int data_blocks = desc->data_blocks;
 
-        /* TODO: how to interact control messages between userspace? */
+                if (pcm) {
+                        write_pcm_s32(s, pcm, buf, data_blocks, pcm_frames);
+                        pcm_frames += data_blocks;
+                } else {
+                        write_pcm_silence(s, buf, data_blocks);
+                }
 
-        if (p->midi_ports)
-                write_midi_messages(s, buffer, data_blocks);
+                if (p->midi_ports)
+                        write_midi_messages(s, buf, data_blocks);
 
-        pcm = READ_ONCE(s->pcm);
-        if (pcm)
-                write_pcm_s32(s, pcm->runtime, buffer, data_blocks);
-        else
-                write_pcm_silence(s, buffer, data_blocks);
+                // TODO: how to interact control messages between userspace?
 
-        write_sph(s, buffer, data_blocks);
+                write_sph(s, buf, data_blocks);
+        }
 
-        trace_data_block_sph(s, data_blocks, buffer);
-        trace_data_block_message(s, data_blocks, buffer);
+        // For tracepoints.
+        if (trace_data_block_sph_enabled() ||
+            trace_data_block_message_enabled())
+                probe_tracepoints_events(s, descs, packets);
 
-        return data_blocks;
+        return pcm_frames;
 }
 
 int amdtp_motu_init(struct amdtp_stream *s, struct fw_unit *unit,
                     enum amdtp_stream_direction dir,
                     const struct snd_motu_protocol *const protocol)
 {
-        amdtp_stream_process_data_blocks_t process_data_blocks;
+        amdtp_stream_process_ctx_payloads_t process_ctx_payloads;
         int fmt = CIP_FMT_MOTU;
         int flags = CIP_BLOCKING;
         int err;
 
         if (dir == AMDTP_IN_STREAM) {
-                process_data_blocks = process_tx_data_blocks;
+                process_ctx_payloads = process_ir_ctx_payloads;
 
                 /*
                  * Units of version 3 transmits packets with invalid CIP header
@@ -418,17 +467,23 @@ int amdtp_motu_init(struct amdtp_stream *s, struct fw_unit *unit,
                                  CIP_SKIP_DBC_ZERO_CHECK;
                 }
         } else {
-                process_data_blocks = process_rx_data_blocks;
+                process_ctx_payloads = process_it_ctx_payloads;
                 flags |= CIP_DBC_IS_END_EVENT;
         }
 
-        err = amdtp_stream_init(s, unit, dir, flags, fmt, process_data_blocks,
+        err = amdtp_stream_init(s, unit, dir, flags, fmt, process_ctx_payloads,
                                 sizeof(struct amdtp_motu));
         if (err < 0)
                 return err;
 
         s->sph = 1;
-        s->ctx_data.rx.fdf = MOTU_FDF_AM824;
+
+        if (dir == AMDTP_OUT_STREAM) {
+                // Use fixed value for FDF field.
+                s->ctx_data.rx.fdf = MOTU_FDF_AM824;
+                // Not used.
+                s->ctx_data.rx.syt_override = 0xffff;
+        }
 
         return 0;
 }
diff --git a/sound/firewire/motu/motu-stream.c b/sound/firewire/motu/motu-stream.c
index 2bbb335e8de1..813e38e6a86e 100644
--- a/sound/firewire/motu/motu-stream.c
+++ b/sound/firewire/motu/motu-stream.c
@@ -92,9 +92,6 @@ static void finish_session(struct snd_motu *motu)
         if (err < 0)
                 return;
 
-        amdtp_stream_stop(&motu->tx_stream);
-        amdtp_stream_stop(&motu->rx_stream);
-
         err = snd_motu_transaction_read(motu, ISOC_COMM_CONTROL_OFFSET, &reg,
                                         sizeof(reg));
         if (err < 0)
@@ -109,27 +106,6 @@ static void finish_session(struct snd_motu *motu)
                                    sizeof(reg));
 }
 
-static int start_isoc_ctx(struct snd_motu *motu, struct amdtp_stream *stream)
-{
-        struct fw_iso_resources *resources;
-        int err;
-
-        if (stream == &motu->rx_stream)
-                resources = &motu->rx_resources;
-        else
-                resources = &motu->tx_resources;
-
-        err = amdtp_stream_start(stream, resources->channel,
-                                 fw_parent_device(motu->unit)->max_speed);
-        if (err < 0)
-                return err;
-
-        if (!amdtp_stream_wait_callback(stream, CALLBACK_TIMEOUT))
-                return -ETIMEDOUT;
-
-        return 0;
-}
-
 int snd_motu_stream_cache_packet_formats(struct snd_motu *motu)
 {
         int err;
@@ -169,6 +145,7 @@ int snd_motu_stream_reserve_duplex(struct snd_motu *motu, unsigned int rate)
                 rate = curr_rate;
 
         if (motu->substreams_counter == 0 || curr_rate != rate) {
+                amdtp_domain_stop(&motu->domain);
                 finish_session(motu);
 
                 fw_iso_resources_free(&motu->tx_resources);
@@ -234,8 +211,10 @@ int snd_motu_stream_start_duplex(struct snd_motu *motu)
                 return 0;
 
         if (amdtp_streaming_error(&motu->rx_stream) ||
-            amdtp_streaming_error(&motu->tx_stream))
+            amdtp_streaming_error(&motu->tx_stream)) {
+                amdtp_domain_stop(&motu->domain);
                 finish_session(motu);
+        }
 
         if (generation != fw_parent_device(motu->unit)->card->generation) {
                 err = fw_iso_resources_update(&motu->rx_resources);
@@ -248,6 +227,8 @@ int snd_motu_stream_start_duplex(struct snd_motu *motu)
         }
 
         if (!amdtp_stream_running(&motu->rx_stream)) {
+                int spd = fw_parent_device(motu->unit)->max_speed;
+
                 err = ensure_packet_formats(motu);
                 if (err < 0)
                         return err;
@@ -259,26 +240,32 @@ int snd_motu_stream_start_duplex(struct snd_motu *motu)
                         goto stop_streams;
                 }
 
-                err = start_isoc_ctx(motu, &motu->rx_stream);
-                if (err < 0) {
-                        dev_err(&motu->unit->device,
-                                "fail to start IT context: %d\n", err);
+                err = amdtp_domain_add_stream(&motu->domain, &motu->tx_stream,
+                                              motu->tx_resources.channel, spd);
+                if (err < 0)
                         goto stop_streams;
-                }
 
-                err = motu->spec->protocol->switch_fetching_mode(motu, true);
-                if (err < 0) {
-                        dev_err(&motu->unit->device,
-                                "fail to enable frame fetching: %d\n", err);
+                err = amdtp_domain_add_stream(&motu->domain, &motu->rx_stream,
+                                              motu->rx_resources.channel, spd);
+                if (err < 0)
+                        goto stop_streams;
+
+                err = amdtp_domain_start(&motu->domain);
+                if (err < 0)
+                        goto stop_streams;
+
+                if (!amdtp_stream_wait_callback(&motu->tx_stream,
+                                                CALLBACK_TIMEOUT) ||
+                    !amdtp_stream_wait_callback(&motu->rx_stream,
+                                                CALLBACK_TIMEOUT)) {
+                        err = -ETIMEDOUT;
                         goto stop_streams;
                 }
-        }
 
-        if (!amdtp_stream_running(&motu->tx_stream)) {
-                err = start_isoc_ctx(motu, &motu->tx_stream);
+                err = motu->spec->protocol->switch_fetching_mode(motu, true);
                 if (err < 0) {
                         dev_err(&motu->unit->device,
-                                "fail to start IR context: %d", err);
+                                "fail to enable frame fetching: %d\n", err);
                         goto stop_streams;
                 }
         }
@@ -286,6 +273,7 @@ int snd_motu_stream_start_duplex(struct snd_motu *motu)
         return 0;
 
 stop_streams:
+        amdtp_domain_stop(&motu->domain);
         finish_session(motu);
         return err;
 }
@@ -293,6 +281,7 @@ stop_streams:
 void snd_motu_stream_stop_duplex(struct snd_motu *motu)
 {
         if (motu->substreams_counter == 0) {
+                amdtp_domain_stop(&motu->domain);
                 finish_session(motu);
 
                 fw_iso_resources_free(&motu->tx_resources);
@@ -300,74 +289,72 @@ void snd_motu_stream_stop_duplex(struct snd_motu *motu)
         }
 }
 
-static int init_stream(struct snd_motu *motu, enum amdtp_stream_direction dir)
+static int init_stream(struct snd_motu *motu, struct amdtp_stream *s)
 {
-        int err;
-        struct amdtp_stream *stream;
         struct fw_iso_resources *resources;
+        enum amdtp_stream_direction dir;
+        int err;
 
-        if (dir == AMDTP_IN_STREAM) {
-                stream = &motu->tx_stream;
+        if (s == &motu->tx_stream) {
                 resources = &motu->tx_resources;
+                dir = AMDTP_IN_STREAM;
         } else {
-                stream = &motu->rx_stream;
                 resources = &motu->rx_resources;
+                dir = AMDTP_OUT_STREAM;
         }
 
         err = fw_iso_resources_init(resources, motu->unit);
         if (err < 0)
                 return err;
 
-        err = amdtp_motu_init(stream, motu->unit, dir, motu->spec->protocol);
-        if (err < 0) {
-                amdtp_stream_destroy(stream);
+        err = amdtp_motu_init(s, motu->unit, dir, motu->spec->protocol);
+        if (err < 0)
                 fw_iso_resources_destroy(resources);
-        }
 
         return err;
 }
 
-static void destroy_stream(struct snd_motu *motu,
-                           enum amdtp_stream_direction dir)
+static void destroy_stream(struct snd_motu *motu, struct amdtp_stream *s)
 {
-        struct amdtp_stream *stream;
-        struct fw_iso_resources *resources;
-
-        if (dir == AMDTP_IN_STREAM) {
-                stream = &motu->tx_stream;
-                resources = &motu->tx_resources;
-        } else {
-                stream = &motu->rx_stream;
-                resources = &motu->rx_resources;
-        }
+        amdtp_stream_destroy(s);
 
-        amdtp_stream_destroy(stream);
-        fw_iso_resources_destroy(resources);
+        if (s == &motu->tx_stream)
+                fw_iso_resources_destroy(&motu->tx_resources);
+        else
+                fw_iso_resources_destroy(&motu->rx_resources);
 }
 
 int snd_motu_stream_init_duplex(struct snd_motu *motu)
 {
         int err;
 
-        err = init_stream(motu, AMDTP_IN_STREAM);
+        err = init_stream(motu, &motu->tx_stream);
         if (err < 0)
                 return err;
 
-        err = init_stream(motu, AMDTP_OUT_STREAM);
-        if (err < 0)
-                destroy_stream(motu, AMDTP_IN_STREAM);
+        err = init_stream(motu, &motu->rx_stream);
+        if (err < 0) {
+                destroy_stream(motu, &motu->tx_stream);
+                return err;
+        }
+
+        err = amdtp_domain_init(&motu->domain);
+        if (err < 0) {
+                destroy_stream(motu, &motu->tx_stream);
+                destroy_stream(motu, &motu->rx_stream);
+        }
 
         return err;
 }
 
-/*
- * This function should be called before starting streams or after stopping
- * streams.
- */
+// This function should be called before starting streams or after stopping
+// streams.
 void snd_motu_stream_destroy_duplex(struct snd_motu *motu)
 {
-        destroy_stream(motu, AMDTP_IN_STREAM);
-        destroy_stream(motu, AMDTP_OUT_STREAM);
+        amdtp_domain_destroy(&motu->domain);
+
+        destroy_stream(motu, &motu->rx_stream);
+        destroy_stream(motu, &motu->tx_stream);
 
         motu->substreams_counter = 0;
 }
diff --git a/sound/firewire/motu/motu.h b/sound/firewire/motu/motu.h
index 09d1451d7de4..350ee2c16f4a 100644
--- a/sound/firewire/motu/motu.h
+++ b/sound/firewire/motu/motu.h
@@ -69,6 +69,8 @@ struct snd_motu {
         int dev_lock_count;
         bool dev_lock_changed;
         wait_queue_head_t hwdep_wait;
+
+        struct amdtp_domain domain;
 };
 
 enum snd_motu_spec_flags {
diff --git a/sound/firewire/oxfw/oxfw-stream.c b/sound/firewire/oxfw/oxfw-stream.c
index 74c972d25c66..0318dc4dcc55 100644
--- a/sound/firewire/oxfw/oxfw-stream.c
+++ b/sound/firewire/oxfw/oxfw-stream.c
@@ -114,19 +114,13 @@ static int start_stream(struct snd_oxfw *oxfw, struct amdtp_stream *stream)
         if (err < 0)
                 return err;
 
-        err = amdtp_stream_start(stream, conn->resources.channel, conn->speed);
+        err = amdtp_domain_add_stream(&oxfw->domain, stream,
+                                      conn->resources.channel, conn->speed);
         if (err < 0) {
                 cmp_connection_break(conn);
                 return err;
         }
 
-        // Wait first packet.
-        if (!amdtp_stream_wait_callback(stream, CALLBACK_TIMEOUT)) {
-                amdtp_stream_stop(stream);
-                cmp_connection_break(conn);
-                return -ETIMEDOUT;
-        }
-
         return 0;
 }
 
@@ -280,12 +274,12 @@ int snd_oxfw_stream_reserve_duplex(struct snd_oxfw *oxfw,
                 pcm_channels = formation.pcm;
         }
         if (formation.rate != rate || formation.pcm != pcm_channels) {
-                amdtp_stream_stop(&oxfw->rx_stream);
+                amdtp_domain_stop(&oxfw->domain);
+
                 cmp_connection_break(&oxfw->in_conn);
                 cmp_connection_release(&oxfw->in_conn);
 
                 if (oxfw->has_output) {
-                        amdtp_stream_stop(&oxfw->tx_stream);
                         cmp_connection_break(&oxfw->out_conn);
                         cmp_connection_release(&oxfw->out_conn);
                 }
@@ -325,55 +319,66 @@ int snd_oxfw_stream_start_duplex(struct snd_oxfw *oxfw)
 
         if (amdtp_streaming_error(&oxfw->rx_stream) ||
             amdtp_streaming_error(&oxfw->tx_stream)) {
-                amdtp_stream_stop(&oxfw->rx_stream);
-                cmp_connection_break(&oxfw->in_conn);
+                amdtp_domain_stop(&oxfw->domain);
 
-                if (oxfw->has_output) {
-                        amdtp_stream_stop(&oxfw->tx_stream);
+                cmp_connection_break(&oxfw->in_conn);
+                if (oxfw->has_output)
                         cmp_connection_break(&oxfw->out_conn);
-                }
         }
 
         if (!amdtp_stream_running(&oxfw->rx_stream)) {
                 err = start_stream(oxfw, &oxfw->rx_stream);
                 if (err < 0) {
                         dev_err(&oxfw->unit->device,
-                                "fail to start rx stream: %d\n", err);
+                                "fail to prepare rx stream: %d\n", err);
                         goto error;
                 }
-        }
 
-        if (oxfw->has_output) {
-                if (!amdtp_stream_running(&oxfw->tx_stream)) {
+                if (oxfw->has_output &&
+                    !amdtp_stream_running(&oxfw->tx_stream)) {
                         err = start_stream(oxfw, &oxfw->tx_stream);
                         if (err < 0) {
                                 dev_err(&oxfw->unit->device,
-                                        "fail to start tx stream: %d\n", err);
+                                        "fail to prepare tx stream: %d\n", err);
                                 goto error;
                         }
                 }
+
+                err = amdtp_domain_start(&oxfw->domain);
+                if (err < 0)
+                        goto error;
+
+                // Wait first packet.
+                if (!amdtp_stream_wait_callback(&oxfw->rx_stream,
+                                                CALLBACK_TIMEOUT) ||
+                    !amdtp_stream_wait_callback(&oxfw->tx_stream,
+                                                CALLBACK_TIMEOUT)) {
+                        err = -ETIMEDOUT;
+                        goto error;
+                }
+
         }
 
         return 0;
 error:
-        amdtp_stream_stop(&oxfw->rx_stream);
+        amdtp_domain_stop(&oxfw->domain);
+
         cmp_connection_break(&oxfw->in_conn);
-        if (oxfw->has_output) {
-                amdtp_stream_stop(&oxfw->tx_stream);
+        if (oxfw->has_output)
                 cmp_connection_break(&oxfw->out_conn);
-        }
+
         return err;
 }
 
 void snd_oxfw_stream_stop_duplex(struct snd_oxfw *oxfw)
 {
         if (oxfw->substreams_count == 0) {
-                amdtp_stream_stop(&oxfw->rx_stream);
+                amdtp_domain_stop(&oxfw->domain);
+
                 cmp_connection_break(&oxfw->in_conn);
                 cmp_connection_release(&oxfw->in_conn);
 
                 if (oxfw->has_output) {
-                        amdtp_stream_stop(&oxfw->tx_stream);
                         cmp_connection_break(&oxfw->out_conn);
                         cmp_connection_release(&oxfw->out_conn);
                 }
@@ -409,13 +414,22 @@ int snd_oxfw_stream_init_duplex(struct snd_oxfw *oxfw)
                 }
         }
 
-        return 0;
+        err = amdtp_domain_init(&oxfw->domain);
+        if (err < 0) {
+                destroy_stream(oxfw, &oxfw->rx_stream);
+                if (oxfw->has_output)
+                        destroy_stream(oxfw, &oxfw->tx_stream);
+        }
+
+        return err;
 }
 
 // This function should be called before starting the stream or after stopping
 // the streams.
 void snd_oxfw_stream_destroy_duplex(struct snd_oxfw *oxfw)
 {
+        amdtp_domain_destroy(&oxfw->domain);
+
         destroy_stream(oxfw, &oxfw->rx_stream);
 
         if (oxfw->has_output)
@@ -424,13 +438,13 @@ void snd_oxfw_stream_destroy_duplex(struct snd_oxfw *oxfw)
 
 void snd_oxfw_stream_update_duplex(struct snd_oxfw *oxfw)
 {
-        amdtp_stream_stop(&oxfw->rx_stream);
+        amdtp_domain_stop(&oxfw->domain);
+
         cmp_connection_break(&oxfw->in_conn);
 
         amdtp_stream_pcm_abort(&oxfw->rx_stream);
 
         if (oxfw->has_output) {
-                amdtp_stream_stop(&oxfw->tx_stream);
                 cmp_connection_break(&oxfw->out_conn);
 
                 amdtp_stream_pcm_abort(&oxfw->tx_stream);
diff --git a/sound/firewire/oxfw/oxfw.h b/sound/firewire/oxfw/oxfw.h
index cb69ab87bb14..c9627b8c5d6e 100644
--- a/sound/firewire/oxfw/oxfw.h
+++ b/sound/firewire/oxfw/oxfw.h
@@ -63,6 +63,8 @@ struct snd_oxfw {
 
         const struct ieee1394_device_id *entry;
         void *spec;
+
+        struct amdtp_domain domain;
 };
 
 /*
diff --git a/sound/firewire/tascam/amdtp-tascam.c b/sound/firewire/tascam/amdtp-tascam.c
index 95fb10b7a737..e80bb84c43f6 100644
--- a/sound/firewire/tascam/amdtp-tascam.c
+++ b/sound/firewire/tascam/amdtp-tascam.c
@@ -32,19 +32,24 @@ int amdtp_tscm_set_parameters(struct amdtp_stream *s, unsigned int rate)
         return amdtp_stream_set_parameters(s, rate, data_channels);
 }
 
-static void write_pcm_s32(struct amdtp_stream *s,
-                          struct snd_pcm_substream *pcm,
-                          __be32 *buffer, unsigned int frames)
+static void write_pcm_s32(struct amdtp_stream *s, struct snd_pcm_substream *pcm,
+                          __be32 *buffer, unsigned int frames,
+                          unsigned int pcm_frames)
 {
         struct amdtp_tscm *p = s->protocol;
+        unsigned int channels = p->pcm_channels;
         struct snd_pcm_runtime *runtime = pcm->runtime;
-        unsigned int channels, remaining_frames, i, c;
+        unsigned int pcm_buffer_pointer;
+        int remaining_frames;
         const u32 *src;
+        int i, c;
+
+        pcm_buffer_pointer = s->pcm_buffer_pointer + pcm_frames;
+        pcm_buffer_pointer %= runtime->buffer_size;
 
-        channels = p->pcm_channels;
         src = (void *)runtime->dma_area +
-                        frames_to_bytes(runtime, s->pcm_buffer_pointer);
-        remaining_frames = runtime->buffer_size - s->pcm_buffer_pointer;
+                                frames_to_bytes(runtime, pcm_buffer_pointer);
+        remaining_frames = runtime->buffer_size - pcm_buffer_pointer;
 
         for (i = 0; i < frames; ++i) {
                 for (c = 0; c < channels; ++c) {
@@ -57,19 +62,24 @@ static void write_pcm_s32(struct amdtp_stream *s,
         }
 }
 
-static void read_pcm_s32(struct amdtp_stream *s,
-                         struct snd_pcm_substream *pcm,
-                         __be32 *buffer, unsigned int frames)
+static void read_pcm_s32(struct amdtp_stream *s, struct snd_pcm_substream *pcm,
+                         __be32 *buffer, unsigned int frames,
+                         unsigned int pcm_frames)
 {
         struct amdtp_tscm *p = s->protocol;
+        unsigned int channels = p->pcm_channels;
         struct snd_pcm_runtime *runtime = pcm->runtime;
-        unsigned int channels, remaining_frames, i, c;
+        unsigned int pcm_buffer_pointer;
+        int remaining_frames;
         u32 *dst;
+        int i, c;
+
+        pcm_buffer_pointer = s->pcm_buffer_pointer + pcm_frames;
+        pcm_buffer_pointer %= runtime->buffer_size;
 
-        channels = p->pcm_channels;
         dst  = (void *)runtime->dma_area +
-                        frames_to_bytes(runtime, s->pcm_buffer_pointer);
-        remaining_frames = runtime->buffer_size - s->pcm_buffer_pointer;
+                                frames_to_bytes(runtime, pcm_buffer_pointer);
+        remaining_frames = runtime->buffer_size - pcm_buffer_pointer;
 
         /* The first data channel is for event counter. */
         buffer += 1;
@@ -165,65 +175,82 @@ static void read_status_messages(struct amdtp_stream *s,
         }
 }
 
-static unsigned int process_tx_data_blocks(struct amdtp_stream *s,
-                                           __be32 *buffer,
-                                           unsigned int data_blocks,
-                                           unsigned int *syt)
+static unsigned int process_ir_ctx_payloads(struct amdtp_stream *s,
+                                            const struct pkt_desc *descs,
+                                            unsigned int packets,
+                                            struct snd_pcm_substream *pcm)
 {
-        struct snd_pcm_substream *pcm;
+        unsigned int pcm_frames = 0;
+        int i;
+
+        for (i = 0; i < packets; ++i) {
+                const struct pkt_desc *desc = descs + i;
+                __be32 *buf = desc->ctx_payload;
+                unsigned int data_blocks = desc->data_blocks;
 
-        pcm = READ_ONCE(s->pcm);
-        if (data_blocks > 0 && pcm)
-                read_pcm_s32(s, pcm, buffer, data_blocks);
+                if (pcm) {
+                        read_pcm_s32(s, pcm, buf, data_blocks, pcm_frames);
+                        pcm_frames += data_blocks;
+                }
 
-        read_status_messages(s, buffer, data_blocks);
+                read_status_messages(s, buf, data_blocks);
+        }
 
-        return data_blocks;
+        return pcm_frames;
 }
 
-static unsigned int process_rx_data_blocks(struct amdtp_stream *s,
-                                           __be32 *buffer,
-                                           unsigned int data_blocks,
-                                           unsigned int *syt)
+static unsigned int process_it_ctx_payloads(struct amdtp_stream *s,
+                                            const struct pkt_desc *descs,
+                                            unsigned int packets,
+                                            struct snd_pcm_substream *pcm)
 {
-        struct snd_pcm_substream *pcm;
+        unsigned int pcm_frames = 0;
+        int i;
 
-        /* This field is not used. */
-        *syt = 0x0000;
+        for (i = 0; i < packets; ++i) {
+                const struct pkt_desc *desc = descs + i;
+                __be32 *buf = desc->ctx_payload;
+                unsigned int data_blocks = desc->data_blocks;
 
-        pcm = READ_ONCE(s->pcm);
-        if (pcm)
-                write_pcm_s32(s, pcm, buffer, data_blocks);
-        else
-                write_pcm_silence(s, buffer, data_blocks);
+                if (pcm) {
+                        write_pcm_s32(s, pcm, buf, data_blocks, pcm_frames);
+                        pcm_frames += data_blocks;
+                } else {
+                        write_pcm_silence(s, buf, data_blocks);
+                }
+        }
 
-        return data_blocks;
+        return pcm_frames;
 }
 
 int amdtp_tscm_init(struct amdtp_stream *s, struct fw_unit *unit,
                     enum amdtp_stream_direction dir, unsigned int pcm_channels)
 {
-        amdtp_stream_process_data_blocks_t process_data_blocks;
+        amdtp_stream_process_ctx_payloads_t process_ctx_payloads;
         struct amdtp_tscm *p;
         unsigned int fmt;
         int err;
 
         if (dir == AMDTP_IN_STREAM) {
                 fmt = AMDTP_FMT_TSCM_TX;
-                process_data_blocks = process_tx_data_blocks;
+                process_ctx_payloads = process_ir_ctx_payloads;
         } else {
                 fmt = AMDTP_FMT_TSCM_RX;
-                process_data_blocks = process_rx_data_blocks;
+                process_ctx_payloads = process_it_ctx_payloads;
         }
 
         err = amdtp_stream_init(s, unit, dir,
-                                CIP_NONBLOCKING | CIP_SKIP_DBC_ZERO_CHECK, fmt,
-                                process_data_blocks, sizeof(struct amdtp_tscm));
+                        CIP_NONBLOCKING | CIP_SKIP_DBC_ZERO_CHECK, fmt,
+                        process_ctx_payloads, sizeof(struct amdtp_tscm));
         if (err < 0)
                 return 0;
 
-        /* Use fixed value for FDF field. */
-        s->ctx_data.rx.fdf = 0x00;
+        if (dir == AMDTP_OUT_STREAM) {
+                // Use fixed value for FDF field.
+                s->ctx_data.rx.fdf = 0x00;
+                // Not used.
+                s->ctx_data.rx.syt_override = 0x0000;
+        }
 
         /* This protocol uses fixed number of data channels for PCM samples. */
         p = s->protocol;
diff --git a/sound/firewire/tascam/tascam-stream.c b/sound/firewire/tascam/tascam-stream.c
index e852e46ebe6f..9e2dc2fe3271 100644
--- a/sound/firewire/tascam/tascam-stream.c
+++ b/sound/firewire/tascam/tascam-stream.c
@@ -180,9 +180,6 @@ static void finish_session(struct snd_tscm *tscm)
 {
         __be32 reg;
 
-        amdtp_stream_stop(&tscm->rx_stream);
-        amdtp_stream_stop(&tscm->tx_stream);
-
         reg = 0;
         snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
                            TSCM_ADDR_BASE + TSCM_OFFSET_START_STREAMING,
@@ -287,38 +284,68 @@ static int keep_resources(struct snd_tscm *tscm, unsigned int rate,
                                 fw_parent_device(tscm->unit)->max_speed);
 }
 
-int snd_tscm_stream_init_duplex(struct snd_tscm *tscm)
+static int init_stream(struct snd_tscm *tscm, struct amdtp_stream *s)
 {
+        struct fw_iso_resources *resources;
+        enum amdtp_stream_direction dir;
         unsigned int pcm_channels;
         int err;
 
-        /* For out-stream. */
-        err = fw_iso_resources_init(&tscm->rx_resources, tscm->unit);
-        if (err < 0)
-                return err;
-        pcm_channels = tscm->spec->pcm_playback_analog_channels;
+        if (s == &tscm->tx_stream) {
+                resources = &tscm->tx_resources;
+                dir = AMDTP_IN_STREAM;
+                pcm_channels = tscm->spec->pcm_capture_analog_channels;
+        } else {
+                resources = &tscm->rx_resources;
+                dir = AMDTP_OUT_STREAM;
+                pcm_channels = tscm->spec->pcm_playback_analog_channels;
+        }
+
         if (tscm->spec->has_adat)
                 pcm_channels += 8;
         if (tscm->spec->has_spdif)
                 pcm_channels += 2;
-        err = amdtp_tscm_init(&tscm->rx_stream, tscm->unit, AMDTP_OUT_STREAM,
-                              pcm_channels);
+
+        err = fw_iso_resources_init(resources, tscm->unit);
         if (err < 0)
                 return err;
 
-        /* For in-stream. */
-        err = fw_iso_resources_init(&tscm->tx_resources, tscm->unit);
+        err = amdtp_tscm_init(s, tscm->unit, dir, pcm_channels);
         if (err < 0)
-                return err;
-        pcm_channels = tscm->spec->pcm_capture_analog_channels;
-        if (tscm->spec->has_adat)
-                pcm_channels += 8;
-        if (tscm->spec->has_spdif)
-                pcm_channels += 2;
-        err = amdtp_tscm_init(&tscm->tx_stream, tscm->unit, AMDTP_IN_STREAM,
-                              pcm_channels);
+                fw_iso_resources_free(resources);
+
+        return err;
+}
+
+static void destroy_stream(struct snd_tscm *tscm, struct amdtp_stream *s)
+{
+        amdtp_stream_destroy(s);
+
+        if (s == &tscm->tx_stream)
+                fw_iso_resources_destroy(&tscm->tx_resources);
+        else
+                fw_iso_resources_destroy(&tscm->rx_resources);
+}
+
+int snd_tscm_stream_init_duplex(struct snd_tscm *tscm)
+{
+        int err;
+
+        err = init_stream(tscm, &tscm->tx_stream);
         if (err < 0)
-                amdtp_stream_destroy(&tscm->rx_stream);
+                return err;
+
+        err = init_stream(tscm, &tscm->rx_stream);
+        if (err < 0) {
+                destroy_stream(tscm, &tscm->tx_stream);
+                return err;
+        }
+
+        err = amdtp_domain_init(&tscm->domain);
+        if (err < 0) {
+                destroy_stream(tscm, &tscm->tx_stream);
+                destroy_stream(tscm, &tscm->rx_stream);
+        }
 
         return err;
 }
@@ -326,24 +353,20 @@ int snd_tscm_stream_init_duplex(struct snd_tscm *tscm)
 // At bus reset, streaming is stopped and some registers are clear.
 void snd_tscm_stream_update_duplex(struct snd_tscm *tscm)
 {
-        amdtp_stream_pcm_abort(&tscm->tx_stream);
-        amdtp_stream_stop(&tscm->tx_stream);
+        amdtp_domain_stop(&tscm->domain);
 
+        amdtp_stream_pcm_abort(&tscm->tx_stream);
         amdtp_stream_pcm_abort(&tscm->rx_stream);
-        amdtp_stream_stop(&tscm->rx_stream);
 }
 
-/*
- * This function should be called before starting streams or after stopping
- * streams.
- */
+// This function should be called before starting streams or after stopping
+// streams.
 void snd_tscm_stream_destroy_duplex(struct snd_tscm *tscm)
 {
-        amdtp_stream_destroy(&tscm->rx_stream);
-        amdtp_stream_destroy(&tscm->tx_stream);
+        amdtp_domain_destroy(&tscm->domain);
 
-        fw_iso_resources_destroy(&tscm->rx_resources);
-        fw_iso_resources_destroy(&tscm->tx_resources);
+        destroy_stream(tscm, &tscm->rx_stream);
+        destroy_stream(tscm, &tscm->tx_stream);
 }
 
 int snd_tscm_stream_reserve_duplex(struct snd_tscm *tscm, unsigned int rate)
@@ -356,6 +379,8 @@ int snd_tscm_stream_reserve_duplex(struct snd_tscm *tscm, unsigned int rate)
                 return err;
 
         if (tscm->substreams_counter == 0 || rate != curr_rate) {
+                amdtp_domain_stop(&tscm->domain);
+
                 finish_session(tscm);
 
                 fw_iso_resources_free(&tscm->tx_resources);
@@ -388,8 +413,10 @@ int snd_tscm_stream_start_duplex(struct snd_tscm *tscm, unsigned int rate)
                 return 0;
 
         if (amdtp_streaming_error(&tscm->rx_stream) ||
-            amdtp_streaming_error(&tscm->tx_stream))
+            amdtp_streaming_error(&tscm->tx_stream)) {
+                amdtp_domain_stop(&tscm->domain);
                 finish_session(tscm);
+        }
 
         if (generation != fw_parent_device(tscm->unit)->card->generation) {
                 err = fw_iso_resources_update(&tscm->tx_resources);
@@ -402,6 +429,8 @@ int snd_tscm_stream_start_duplex(struct snd_tscm *tscm, unsigned int rate)
         }
 
         if (!amdtp_stream_running(&tscm->rx_stream)) {
+                int spd = fw_parent_device(tscm->unit)->max_speed;
+
                 err = set_stream_formats(tscm, rate);
                 if (err < 0)
                         goto error;
@@ -410,27 +439,23 @@ int snd_tscm_stream_start_duplex(struct snd_tscm *tscm, unsigned int rate)
                 if (err < 0)
                         goto error;
 
-                err = amdtp_stream_start(&tscm->rx_stream,
-                                tscm->rx_resources.channel,
-                                fw_parent_device(tscm->unit)->max_speed);
+                err = amdtp_domain_add_stream(&tscm->domain, &tscm->rx_stream,
+                                              tscm->rx_resources.channel, spd);
                 if (err < 0)
                         goto error;
 
-                if (!amdtp_stream_wait_callback(&tscm->rx_stream,
-                                                CALLBACK_TIMEOUT)) {
-                        err = -ETIMEDOUT;
+                err = amdtp_domain_add_stream(&tscm->domain, &tscm->tx_stream,
+                                              tscm->tx_resources.channel, spd);
+                if (err < 0)
                         goto error;
-                }
-        }
 
-        if (!amdtp_stream_running(&tscm->tx_stream)) {
-                err = amdtp_stream_start(&tscm->tx_stream,
-                                tscm->tx_resources.channel,
-                                fw_parent_device(tscm->unit)->max_speed);
+                err = amdtp_domain_start(&tscm->domain);
                 if (err < 0)
-                        goto error;
+                        return err;
 
-                if (!amdtp_stream_wait_callback(&tscm->tx_stream,
+                if (!amdtp_stream_wait_callback(&tscm->rx_stream,
+                                                CALLBACK_TIMEOUT) ||
+                    !amdtp_stream_wait_callback(&tscm->tx_stream,
                                                 CALLBACK_TIMEOUT)) {
                         err = -ETIMEDOUT;
                         goto error;
@@ -439,6 +464,7 @@ int snd_tscm_stream_start_duplex(struct snd_tscm *tscm, unsigned int rate)
 
         return 0;
 error:
+        amdtp_domain_stop(&tscm->domain);
         finish_session(tscm);
 
         return err;
@@ -447,6 +473,7 @@ error:
 void snd_tscm_stream_stop_duplex(struct snd_tscm *tscm)
 {
         if (tscm->substreams_counter == 0) {
+                amdtp_domain_stop(&tscm->domain);
                 finish_session(tscm);
 
                 fw_iso_resources_free(&tscm->tx_resources);
diff --git a/sound/firewire/tascam/tascam.h b/sound/firewire/tascam/tascam.h
index 734e5bb9c3da..64a2e4d2bbfe 100644
--- a/sound/firewire/tascam/tascam.h
+++ b/sound/firewire/tascam/tascam.h
@@ -97,6 +97,8 @@ struct snd_tscm {
         struct snd_firewire_tascam_change queue[SND_TSCM_QUEUE_COUNT];
         unsigned int pull_pos;
         unsigned int push_pos;
+
+        struct amdtp_domain domain;
 };
 
 #define TSCM_ADDR_BASE                  0xffff00000000ull
diff --git a/sound/hda/Kconfig b/sound/hda/Kconfig
index 1d475cf3f754..3d33fc1757ba 100644
--- a/sound/hda/Kconfig
+++ b/sound/hda/Kconfig
@@ -32,3 +32,8 @@ config SND_HDA_PREALLOC_SIZE
 
           Note that the pre-allocation size can be changed dynamically
           via a proc file (/proc/asound/card*/pcm*/sub*/prealloc), too.
+
+config SND_INTEL_NHLT
+        tristate
+        # this config should be selected only for Intel ACPI platforms.
+        # A fallback is provided so that the code compiles in all cases.
\ No newline at end of file
diff --git a/sound/hda/Makefile b/sound/hda/Makefile
index 2160202e2dc1..8560f6ef1b19 100644
--- a/sound/hda/Makefile
+++ b/sound/hda/Makefile
@@ -13,3 +13,6 @@ obj-$(CONFIG_SND_HDA_CORE) += snd-hda-core.o
 
 #extended hda
 obj-$(CONFIG_SND_HDA_EXT_CORE) += ext/
+
+snd-intel-nhlt-objs := intel-nhlt.o
+obj-$(CONFIG_SND_INTEL_NHLT) += snd-intel-nhlt.o
diff --git a/sound/hda/hdac_controller.c b/sound/hda/hdac_controller.c
index 7e7be8e4dcf9..d3999e7b0705 100644
--- a/sound/hda/hdac_controller.c
+++ b/sound/hda/hdac_controller.c
@@ -447,6 +447,8 @@ static void azx_int_disable(struct hdac_bus *bus)
         list_for_each_entry(azx_dev, &bus->stream_list, list)
                 snd_hdac_stream_updateb(azx_dev, SD_CTL, SD_INT_MASK, 0);
 
+        synchronize_irq(bus->irq);
+
         /* disable SIE for all streams */
         snd_hdac_chip_writeb(bus, INTCTL, 0);
 
diff --git a/sound/hda/hdac_i915.c b/sound/hda/hdac_i915.c
index 1192c7561d62..3c2db3816029 100644
--- a/sound/hda/hdac_i915.c
+++ b/sound/hda/hdac_i915.c
@@ -136,10 +136,12 @@ int snd_hdac_i915_init(struct hdac_bus *bus)
         if (!acomp)
                 return -ENODEV;
         if (!acomp->ops) {
-                request_module("i915");
-                /* 60s timeout */
-                wait_for_completion_timeout(&bind_complete,
-                                            msecs_to_jiffies(60 * 1000));
+                if (!IS_ENABLED(CONFIG_MODULES) ||
+                    !request_module("i915")) {
+                        /* 60s timeout */
+                        wait_for_completion_timeout(&bind_complete,
+                                                   msecs_to_jiffies(60 * 1000));
+                }
         }
         if (!acomp->ops) {
                 dev_info(bus->dev, "couldn't bind with audio component\n");
diff --git a/sound/hda/intel-nhlt.c b/sound/hda/intel-nhlt.c
new file mode 100644
index 000000000000..daede96f28ee
--- /dev/null
+++ b/sound/hda/intel-nhlt.c
@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: GPL-2.0
+// Copyright (c) 2015-2019 Intel Corporation
+
+#include <linux/acpi.h>
+#include <sound/intel-nhlt.h>
+
+#define NHLT_ACPI_HEADER_SIG    "NHLT"
+
+/* Unique identification for getting NHLT blobs */
+static guid_t osc_guid =
+        GUID_INIT(0xA69F886E, 0x6CEB, 0x4594,
+                  0xA4, 0x1F, 0x7B, 0x5D, 0xCE, 0x24, 0xC5, 0x53);
+
+struct nhlt_acpi_table *intel_nhlt_init(struct device *dev)
+{
+        acpi_handle handle;
+        union acpi_object *obj;
+        struct nhlt_resource_desc *nhlt_ptr;
+        struct nhlt_acpi_table *nhlt_table = NULL;
+
+        handle = ACPI_HANDLE(dev);
+        if (!handle) {
+                dev_err(dev, "Didn't find ACPI_HANDLE\n");
+                return NULL;
+        }
+
+        obj = acpi_evaluate_dsm(handle, &osc_guid, 1, 1, NULL);
+
+        if (!obj)
+                return NULL;
+
+        if (obj->type != ACPI_TYPE_BUFFER) {
+                dev_dbg(dev, "No NHLT table found\n");
+                ACPI_FREE(obj);
+                return NULL;
+        }
+
+        nhlt_ptr = (struct nhlt_resource_desc  *)obj->buffer.pointer;
+        if (nhlt_ptr->length)
+                nhlt_table = (struct nhlt_acpi_table *)
+                        memremap(nhlt_ptr->min_addr, nhlt_ptr->length,
+                                 MEMREMAP_WB);
+        ACPI_FREE(obj);
+        if (nhlt_table &&
+            (strncmp(nhlt_table->header.signature,
+                     NHLT_ACPI_HEADER_SIG,
+                     strlen(NHLT_ACPI_HEADER_SIG)) != 0)) {
+                memunmap(nhlt_table);
+                dev_err(dev, "NHLT ACPI header signature incorrect\n");
+                return NULL;
+        }
+        return nhlt_table;
+}
+EXPORT_SYMBOL_GPL(intel_nhlt_init);
+
+void intel_nhlt_free(struct nhlt_acpi_table *nhlt)
+{
+        memunmap((void *)nhlt);
+}
+EXPORT_SYMBOL_GPL(intel_nhlt_free);
+
+int intel_nhlt_get_dmic_geo(struct device *dev, struct nhlt_acpi_table *nhlt)
+{
+        struct nhlt_endpoint *epnt;
+        struct nhlt_dmic_array_config *cfg;
+        struct nhlt_vendor_dmic_array_config *cfg_vendor;
+        unsigned int dmic_geo = 0;
+        u8 j;
+
+        if (!nhlt)
+                return 0;
+
+        epnt = (struct nhlt_endpoint *)nhlt->desc;
+
+        for (j = 0; j < nhlt->endpoint_count; j++) {
+                if (epnt->linktype == NHLT_LINK_DMIC) {
+                        cfg = (struct nhlt_dmic_array_config  *)
+                                        (epnt->config.caps);
+                        switch (cfg->array_type) {
+                        case NHLT_MIC_ARRAY_2CH_SMALL:
+                        case NHLT_MIC_ARRAY_2CH_BIG:
+                                dmic_geo = MIC_ARRAY_2CH;
+                                break;
+
+                        case NHLT_MIC_ARRAY_4CH_1ST_GEOM:
+                        case NHLT_MIC_ARRAY_4CH_L_SHAPED:
+                        case NHLT_MIC_ARRAY_4CH_2ND_GEOM:
+                                dmic_geo = MIC_ARRAY_4CH;
+                                break;
+                        case NHLT_MIC_ARRAY_VENDOR_DEFINED:
+                                cfg_vendor = (struct nhlt_vendor_dmic_array_config *)cfg;
+                                dmic_geo = cfg_vendor->nb_mics;
+                                break;
+                        default:
+                                dev_warn(dev, "undefined DMIC array_type 0x%0x\n",
+                                         cfg->array_type);
+                        }
+                }
+                epnt = (struct nhlt_endpoint *)((u8 *)epnt + epnt->length);
+        }
+
+        return dmic_geo;
+}
+EXPORT_SYMBOL_GPL(intel_nhlt_get_dmic_geo);
+
+MODULE_LICENSE("GPL v2");
+MODULE_DESCRIPTION("Intel NHLT driver");
diff --git a/sound/i2c/other/ak4xxx-adda.c b/sound/i2c/other/ak4xxx-adda.c
index 5f59316f982a..7d15093844b9 100644
--- a/sound/i2c/other/ak4xxx-adda.c
+++ b/sound/i2c/other/ak4xxx-adda.c
@@ -775,11 +775,12 @@ static int build_adc_controls(struct snd_akm4xxx *ak)
                                 return err;
 
                         memset(&knew, 0, sizeof(knew));
-                        knew.name = ak->adc_info[mixer_ch].selector_name;
-                        if (!knew.name) {
+                        if (!ak->adc_info ||
+                                !ak->adc_info[mixer_ch].selector_name) {
                                 knew.name = "Capture Channel";
                                 knew.index = mixer_ch + ak->idx_offset * 2;
-                        }
+                        } else
+                                knew.name = ak->adc_info[mixer_ch].selector_name;
 
                         knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
                         knew.info = ak4xxx_capture_source_info;
diff --git a/sound/isa/wavefront/wavefront_synth.c b/sound/isa/wavefront/wavefront_synth.c
index aec1c46e6697..c5b1d5900eed 100644
--- a/sound/isa/wavefront/wavefront_synth.c
+++ b/sound/isa/wavefront/wavefront_synth.c
@@ -788,7 +788,6 @@ wavefront_send_patch (snd_wavefront_t *dev, wavefront_patch_info *header)
 
         dev->patch_status[header->number] |= WF_SLOT_FILLED;
 
-        bptr = buf;
         bptr = munge_int32 (header->number, buf, 2);
         munge_buf ((unsigned char *)&header->hdr.p, bptr, WF_PATCH_BYTES);
     
diff --git a/sound/oss/dmasound/dmasound_atari.c b/sound/oss/dmasound/dmasound_atari.c
index 83653683fd68..823ccfa089b2 100644
--- a/sound/oss/dmasound/dmasound_atari.c
+++ b/sound/oss/dmasound/dmasound_atari.c
@@ -1432,25 +1432,25 @@ static int FalconMixerIoctl(u_int cmd, u_long arg)
 {
         int data;
         switch (cmd) {
-            case SOUND_MIXER_READ_RECMASK:
+        case SOUND_MIXER_READ_RECMASK:
                 return IOCTL_OUT(arg, SOUND_MASK_MIC);
-            case SOUND_MIXER_READ_DEVMASK:
+        case SOUND_MIXER_READ_DEVMASK:
                 return IOCTL_OUT(arg, SOUND_MASK_VOLUME | SOUND_MASK_MIC | SOUND_MASK_SPEAKER);
-            case SOUND_MIXER_READ_STEREODEVS:
+        case SOUND_MIXER_READ_STEREODEVS:
                 return IOCTL_OUT(arg, SOUND_MASK_VOLUME | SOUND_MASK_MIC);
-            case SOUND_MIXER_READ_VOLUME:
+        case SOUND_MIXER_READ_VOLUME:
                 return IOCTL_OUT(arg,
                         VOLUME_ATT_TO_VOXWARE(dmasound.volume_left) |
                         VOLUME_ATT_TO_VOXWARE(dmasound.volume_right) << 8);
-            case SOUND_MIXER_READ_CAPS:
+        case SOUND_MIXER_READ_CAPS:
                 return IOCTL_OUT(arg, SOUND_CAP_EXCL_INPUT);
-            case SOUND_MIXER_WRITE_MIC:
+        case SOUND_MIXER_WRITE_MIC:
                 IOCTL_IN(arg, data);
                 tt_dmasnd.input_gain =
                         RECLEVEL_VOXWARE_TO_GAIN(data & 0xff) << 4 |
                         RECLEVEL_VOXWARE_TO_GAIN(data >> 8 & 0xff);
-                /* fall thru, return set value */
-            case SOUND_MIXER_READ_MIC:
+                /* fall through - return set value */
+        case SOUND_MIXER_READ_MIC:
                 return IOCTL_OUT(arg,
                         RECLEVEL_GAIN_TO_VOXWARE(tt_dmasnd.input_gain >> 4 & 0xf) |
                         RECLEVEL_GAIN_TO_VOXWARE(tt_dmasnd.input_gain & 0xf) << 8);
diff --git a/sound/pci/echoaudio/echoaudio.c b/sound/pci/echoaudio/echoaudio.c
index b612a536a5a1..ca9125726be2 100644
--- a/sound/pci/echoaudio/echoaudio.c
+++ b/sound/pci/echoaudio/echoaudio.c
@@ -2189,11 +2189,10 @@ static int snd_echo_resume(struct device *dev)
         u32 pipe_alloc_mask;
         int err;
 
-        commpage_bak = kmalloc(sizeof(*commpage), GFP_KERNEL);
+        commpage = chip->comm_page;
+        commpage_bak = kmemdup(commpage, sizeof(*commpage), GFP_KERNEL);
         if (commpage_bak == NULL)
                 return -ENOMEM;
-        commpage = chip->comm_page;
-        memcpy(commpage_bak, commpage, sizeof(*commpage));
 
         err = init_hw(chip, chip->pci->device, chip->pci->subsystem_device);
         if (err < 0) {
diff --git a/sound/pci/hda/Kconfig b/sound/pci/hda/Kconfig
index 82198ea8f7f8..dae47a45b2b8 100644
--- a/sound/pci/hda/Kconfig
+++ b/sound/pci/hda/Kconfig
@@ -12,6 +12,7 @@ config SND_HDA_INTEL
         tristate "HD Audio PCI"
         depends on SND_PCI
         select SND_HDA
+        select SND_INTEL_NHLT if ACPI
         help
           Say Y here to include support for Intel "High Definition
           Audio" (Azalia) and its compatible devices.
@@ -22,6 +23,15 @@ config SND_HDA_INTEL
           To compile this driver as a module, choose M here: the module
           will be called snd-hda-intel.
 
+config SND_HDA_INTEL_DETECT_DMIC
+        bool "DMIC detection and probe abort"
+        depends on SND_HDA_INTEL
+        help
+          Say Y to detect digital microphones on SKL+ devices. DMICs
+          cannot be handled by the HDaudio legacy driver and are
+          currently only supported by the SOF driver.
+          If unsure say N.
+
 config SND_HDA_TEGRA
         tristate "NVIDIA Tegra HD Audio"
         depends on ARCH_TEGRA
diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c
index e30e86ca6b72..51f10ed9bc43 100644
--- a/sound/pci/hda/hda_codec.c
+++ b/sound/pci/hda/hda_codec.c
@@ -2942,7 +2942,7 @@ static int hda_codec_runtime_resume(struct device *dev)
 static int hda_codec_force_resume(struct device *dev)
 {
         struct hda_codec *codec = dev_to_hda_codec(dev);
-        bool forced_resume = !codec->relaxed_resume;
+        bool forced_resume = !codec->relaxed_resume && codec->jacktbl.used;
         int ret;
 
         /* The get/put pair below enforces the runtime resume even if the
diff --git a/sound/pci/hda/hda_controller.c b/sound/pci/hda/hda_controller.c
index ee5504e2441f..156930d0c9d3 100644
--- a/sound/pci/hda/hda_controller.c
+++ b/sound/pci/hda/hda_controller.c
@@ -864,10 +864,13 @@ static int azx_rirb_get_response(struct hdac_bus *bus, unsigned int addr,
          */
         if (hbus->allow_bus_reset && !hbus->response_reset && !hbus->in_reset) {
                 hbus->response_reset = 1;
+                dev_err(chip->card->dev,
+                        "No response from codec, resetting bus: last cmd=0x%08x\n",
+                        bus->last_cmd[addr]);
                 return -EAGAIN; /* give a chance to retry */
         }
 
-        dev_err(chip->card->dev,
+        dev_WARN(chip->card->dev,
                 "azx_get_response timeout, switching to single_cmd mode: last cmd=0x%08x\n",
                 bus->last_cmd[addr]);
         chip->single_cmd = 1;
diff --git a/sound/pci/hda/hda_intel.c b/sound/pci/hda/hda_intel.c
index 963a92943a6d..3a209e07d5d8 100644
--- a/sound/pci/hda/hda_intel.c
+++ b/sound/pci/hda/hda_intel.c
@@ -46,6 +46,7 @@
 #include <sound/initval.h>
 #include <sound/hdaudio.h>
 #include <sound/hda_i915.h>
+#include <sound/intel-nhlt.h>
 #include <linux/vgaarb.h>
 #include <linux/vga_switcheroo.h>
 #include <linux/firmware.h>
@@ -124,6 +125,7 @@ static char *patch[SNDRV_CARDS];
 static bool beep_mode[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] =
                                         CONFIG_SND_HDA_INPUT_BEEP_MODE};
 #endif
+static bool dmic_detect = IS_ENABLED(CONFIG_SND_HDA_INTEL_DETECT_DMIC);
 
 module_param_array(index, int, NULL, 0444);
 MODULE_PARM_DESC(index, "Index value for Intel HD audio interface.");
@@ -158,6 +160,8 @@ module_param_array(beep_mode, bool, NULL, 0444);
 MODULE_PARM_DESC(beep_mode, "Select HDA Beep registration mode "
                             "(0=off, 1=on) (default=1).");
 #endif
+module_param(dmic_detect, bool, 0444);
+MODULE_PARM_DESC(dmic_detect, "DMIC detect on SKL+ platforms");
 
 #ifdef CONFIG_PM
 static int param_set_xint(const char *val, const struct kernel_param *kp);
@@ -266,6 +270,7 @@ enum {
         AZX_DRIVER_CTX,
         AZX_DRIVER_CTHDA,
         AZX_DRIVER_CMEDIA,
+        AZX_DRIVER_ZHAOXIN,
         AZX_DRIVER_GENERIC,
         AZX_NUM_DRIVERS, /* keep this as last entry */
 };
@@ -313,11 +318,10 @@ enum {
 
 #define AZX_DCAPS_INTEL_SKYLAKE \
         (AZX_DCAPS_INTEL_PCH_BASE | AZX_DCAPS_PM_RUNTIME |\
+         AZX_DCAPS_SYNC_WRITE |\
          AZX_DCAPS_SEPARATE_STREAM_TAG | AZX_DCAPS_I915_COMPONENT)
 
-#define AZX_DCAPS_INTEL_BROXTON \
-        (AZX_DCAPS_INTEL_PCH_BASE | AZX_DCAPS_PM_RUNTIME |\
-         AZX_DCAPS_SEPARATE_STREAM_TAG | AZX_DCAPS_I915_COMPONENT)
+#define AZX_DCAPS_INTEL_BROXTON         AZX_DCAPS_INTEL_SKYLAKE
 
 /* quirks for ATI SB / AMD Hudson */
 #define AZX_DCAPS_PRESET_ATI_SB \
@@ -380,6 +384,7 @@ static char *driver_short_names[] = {
         [AZX_DRIVER_CTX] = "HDA Creative", 
         [AZX_DRIVER_CTHDA] = "HDA Creative",
         [AZX_DRIVER_CMEDIA] = "HDA C-Media",
+        [AZX_DRIVER_ZHAOXIN] = "HDA Zhaoxin",
         [AZX_DRIVER_GENERIC] = "HD-Audio Generic",
 };
 
@@ -1301,9 +1306,9 @@ static int azx_free(struct azx *chip)
         }
 
         if (bus->chip_init) {
+                azx_stop_chip(chip);
                 azx_clear_irq_pending(chip);
                 azx_stop_all_streams(chip);
-                azx_stop_chip(chip);
         }
 
         if (bus->irq >= 0)
@@ -1964,6 +1969,25 @@ static const struct hda_controller_ops pci_hda_ops = {
         .position_check = azx_position_check,
 };
 
+static int azx_check_dmic(struct pci_dev *pci, struct azx *chip)
+{
+        struct nhlt_acpi_table *nhlt;
+        int ret = 0;
+
+        if (chip->driver_type == AZX_DRIVER_SKL &&
+            pci->class != 0x040300) {
+                nhlt = intel_nhlt_init(&pci->dev);
+                if (nhlt) {
+                        if (intel_nhlt_get_dmic_geo(&pci->dev, nhlt)) {
+                                ret = -ENODEV;
+                                dev_info(&pci->dev, "Digital mics found on Skylake+ platform, aborting probe\n");
+                        }
+                        intel_nhlt_free(nhlt);
+                }
+        }
+        return ret;
+}
+
 static int azx_probe(struct pci_dev *pci,
                      const struct pci_device_id *pci_id)
 {
@@ -1994,6 +2018,17 @@ static int azx_probe(struct pci_dev *pci,
         card->private_data = chip;
         hda = container_of(chip, struct hda_intel, chip);
 
+        /*
+         * stop probe if digital microphones detected on Skylake+ platform
+         * with the DSP enabled. This is an opt-in behavior defined at build
+         * time or at run-time with a module parameter
+         */
+        if (dmic_detect) {
+                err = azx_check_dmic(pci, chip);
+                if (err < 0)
+                        goto out_free;
+        }
+
         pci_set_drvdata(pci, card);
 
         err = register_vga_switcheroo(chip);
@@ -2529,6 +2564,8 @@ static const struct pci_device_id azx_ids[] = {
           .class = PCI_CLASS_MULTIMEDIA_HD_AUDIO << 8,
           .class_mask = 0xffffff,
           .driver_data = AZX_DRIVER_GENERIC | AZX_DCAPS_PRESET_ATI_HDMI },
+        /* Zhaoxin */
+        { PCI_DEVICE(0x1d17, 0x3288), .driver_data = AZX_DRIVER_ZHAOXIN },
         { 0, }
 };
 MODULE_DEVICE_TABLE(pci, azx_ids);
diff --git a/sound/pci/hda/patch_conexant.c b/sound/pci/hda/patch_conexant.c
index 4f8d0845ee1e..f299f137eaea 100644
--- a/sound/pci/hda/patch_conexant.c
+++ b/sound/pci/hda/patch_conexant.c
@@ -1083,6 +1083,7 @@ static int patch_conexant_auto(struct hda_codec *codec)
  */
 
 static const struct hda_device_id snd_hda_id_conexant[] = {
+        HDA_CODEC_ENTRY(0x14f11f86, "CX8070", patch_conexant_auto),
         HDA_CODEC_ENTRY(0x14f12008, "CX8200", patch_conexant_auto),
         HDA_CODEC_ENTRY(0x14f15045, "CX20549 (Venice)", patch_conexant_auto),
         HDA_CODEC_ENTRY(0x14f15047, "CX20551 (Waikiki)", patch_conexant_auto),
diff --git a/sound/pci/hda/patch_hdmi.c b/sound/pci/hda/patch_hdmi.c
index bea7b0961080..2096993eaf28 100644
--- a/sound/pci/hda/patch_hdmi.c
+++ b/sound/pci/hda/patch_hdmi.c
@@ -18,6 +18,7 @@
 
 #include <linux/init.h>
 #include <linux/delay.h>
+#include <linux/pci.h>
 #include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/pm_runtime.h>
@@ -119,6 +120,7 @@ struct hdmi_pcm {
 };
 
 struct hdmi_spec {
+        struct hda_codec *codec;
         int num_cvts;
         struct snd_array cvts; /* struct hdmi_spec_per_cvt */
         hda_nid_t cvt_nids[4]; /* only for haswell fix */
@@ -163,9 +165,11 @@ struct hdmi_spec {
         struct hda_multi_out multiout;
         struct hda_pcm_stream pcm_playback;
 
-        /* i915/powerwell (Haswell+/Valleyview+) specific */
-        bool use_acomp_notifier; /* use i915 eld_notify callback for hotplug */
+        bool use_jack_detect; /* jack detection enabled */
+        bool use_acomp_notifier; /* use eld_notify callback for hotplug */
+        bool acomp_registered; /* audio component registered in this driver */
         struct drm_audio_component_audio_ops drm_audio_ops;
+        int (*port2pin)(struct hda_codec *, int); /* reverse port/pin mapping */
 
         struct hdac_chmap chmap;
         hda_nid_t vendor_nid;
@@ -765,6 +769,10 @@ static void check_presence_and_report(struct hda_codec *codec, hda_nid_t nid,
 static void jack_callback(struct hda_codec *codec,
                           struct hda_jack_callback *jack)
 {
+        /* stop polling when notification is enabled */
+        if (codec_has_acomp(codec))
+                return;
+
         /* hda_jack don't support DP MST */
         check_presence_and_report(codec, jack->nid, 0);
 }
@@ -823,6 +831,9 @@ static void hdmi_unsol_event(struct hda_codec *codec, unsigned int res)
         int tag = res >> AC_UNSOL_RES_TAG_SHIFT;
         int subtag = (res & AC_UNSOL_RES_SUBTAG) >> AC_UNSOL_RES_SUBTAG_SHIFT;
 
+        if (codec_has_acomp(codec))
+                return;
+
         if (!snd_hda_jack_tbl_get_from_tag(codec, tag)) {
                 codec_dbg(codec, "Unexpected HDMI event tag 0x%x\n", tag);
                 return;
@@ -1421,7 +1432,7 @@ static void hdmi_pcm_reset_pin(struct hdmi_spec *spec,
 /* update per_pin ELD from the given new ELD;
  * setup info frame and notification accordingly
  */
-static void update_eld(struct hda_codec *codec,
+static bool update_eld(struct hda_codec *codec,
                        struct hdmi_spec_per_pin *per_pin,
                        struct hdmi_eld *eld)
 {
@@ -1452,18 +1463,22 @@ static void update_eld(struct hda_codec *codec,
                 snd_hdmi_show_eld(codec, &eld->info);
 
         eld_changed = (pin_eld->eld_valid != eld->eld_valid);
-        if (eld->eld_valid && pin_eld->eld_valid)
+        eld_changed |= (pin_eld->monitor_present != eld->monitor_present);
+        if (!eld_changed && eld->eld_valid && pin_eld->eld_valid)
                 if (pin_eld->eld_size != eld->eld_size ||
                     memcmp(pin_eld->eld_buffer, eld->eld_buffer,
                            eld->eld_size) != 0)
                         eld_changed = true;
 
-        pin_eld->monitor_present = eld->monitor_present;
-        pin_eld->eld_valid = eld->eld_valid;
-        pin_eld->eld_size = eld->eld_size;
-        if (eld->eld_valid)
-                memcpy(pin_eld->eld_buffer, eld->eld_buffer, eld->eld_size);
-        pin_eld->info = eld->info;
+        if (eld_changed) {
+                pin_eld->monitor_present = eld->monitor_present;
+                pin_eld->eld_valid = eld->eld_valid;
+                pin_eld->eld_size = eld->eld_size;
+                if (eld->eld_valid)
+                        memcpy(pin_eld->eld_buffer, eld->eld_buffer,
+                               eld->eld_size);
+                pin_eld->info = eld->info;
+        }
 
         /*
          * Re-setup pin and infoframe. This is needed e.g. when
@@ -1481,6 +1496,7 @@ static void update_eld(struct hda_codec *codec,
                                SNDRV_CTL_EVENT_MASK_VALUE |
                                SNDRV_CTL_EVENT_MASK_INFO,
                                &get_hdmi_pcm(spec, pcm_idx)->eld_ctl->id);
+        return eld_changed;
 }
 
 /* update ELD and jack state via HD-audio verbs */
@@ -1582,6 +1598,7 @@ static void sync_eld_via_acomp(struct hda_codec *codec,
         struct hdmi_spec *spec = codec->spec;
         struct hdmi_eld *eld = &spec->temp_eld;
         struct snd_jack *jack = NULL;
+        bool changed;
         int size;
 
         mutex_lock(&per_pin->lock);
@@ -1608,15 +1625,13 @@ static void sync_eld_via_acomp(struct hda_codec *codec,
          * disconnected event. Jack must be fetched before update_eld()
          */
         jack = pin_idx_to_jack(codec, per_pin);
-        update_eld(codec, per_pin, eld);
+        changed = update_eld(codec, per_pin, eld);
         if (jack == NULL)
                 jack = pin_idx_to_jack(codec, per_pin);
-        if (jack == NULL)
-                goto unlock;
-        snd_jack_report(jack,
-                        (eld->monitor_present && eld->eld_valid) ?
+        if (changed && jack)
+                snd_jack_report(jack,
+                                (eld->monitor_present && eld->eld_valid) ?
                                 SND_JACK_AVOUT : 0);
- unlock:
         mutex_unlock(&per_pin->lock);
 }
 
@@ -1632,18 +1647,13 @@ static bool hdmi_present_sense(struct hdmi_spec_per_pin *per_pin, int repoll)
                         snd_hda_power_down_pm(codec);
                         return false;
                 }
-        }
-
-        if (codec_has_acomp(codec)) {
+                ret = hdmi_present_sense_via_verbs(per_pin, repoll);
+                snd_hda_power_down_pm(codec);
+        } else {
                 sync_eld_via_acomp(codec, per_pin);
                 ret = false; /* don't call snd_hda_jack_report_sync() */
-        } else {
-                ret = hdmi_present_sense_via_verbs(per_pin, repoll);
         }
 
-        if (!codec_has_acomp(codec))
-                snd_hda_power_down_pm(codec);
-
         return ret;
 }
 
@@ -2248,6 +2258,8 @@ static int generic_hdmi_init(struct hda_codec *codec)
         struct hdmi_spec *spec = codec->spec;
         int pin_idx;
 
+        mutex_lock(&spec->pcm_lock);
+        spec->use_jack_detect = !codec->jackpoll_interval;
         for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++) {
                 struct hdmi_spec_per_pin *per_pin = get_pin(spec, pin_idx);
                 hda_nid_t pin_nid = per_pin->pin_nid;
@@ -2255,11 +2267,15 @@ static int generic_hdmi_init(struct hda_codec *codec)
 
                 snd_hda_set_dev_select(codec, pin_nid, dev_id);
                 hdmi_init_pin(codec, pin_nid);
-                if (!codec_has_acomp(codec))
+                if (codec_has_acomp(codec))
+                        continue;
+                if (spec->use_jack_detect)
+                        snd_hda_jack_detect_enable(codec, pin_nid);
+                else
                         snd_hda_jack_detect_enable_callback(codec, pin_nid,
-                                codec->jackpoll_interval > 0 ?
-                                jack_callback : NULL);
+                                                            jack_callback);
         }
+        mutex_unlock(&spec->pcm_lock);
         return 0;
 }
 
@@ -2292,7 +2308,9 @@ static void generic_hdmi_free(struct hda_codec *codec)
         struct hdmi_spec *spec = codec->spec;
         int pin_idx, pcm_idx;
 
-        if (codec_has_acomp(codec)) {
+        if (spec->acomp_registered) {
+                snd_hdac_acomp_exit(&codec->bus->core);
+        } else if (codec_has_acomp(codec)) {
                 snd_hdac_acomp_register_notifier(&codec->bus->core, NULL);
                 codec->relaxed_resume = 0;
         }
@@ -2360,6 +2378,7 @@ static int alloc_generic_hdmi(struct hda_codec *codec)
         if (!spec)
                 return -ENOMEM;
 
+        spec->codec = codec;
         spec->ops = generic_standard_hdmi_ops;
         spec->dev_num = 1;      /* initialize to 1 */
         mutex_init(&spec->pcm_lock);
@@ -2398,6 +2417,136 @@ static int patch_generic_hdmi(struct hda_codec *codec)
 }
 
 /*
+ * generic audio component binding
+ */
+
+/* turn on / off the unsol event jack detection dynamically */
+static void reprogram_jack_detect(struct hda_codec *codec, hda_nid_t nid,
+                                  bool use_acomp)
+{
+        struct hda_jack_tbl *tbl;
+
+        tbl = snd_hda_jack_tbl_get(codec, nid);
+        if (tbl) {
+                /* clear unsol even if component notifier is used, or re-enable
+                 * if notifier is cleared
+                 */
+                unsigned int val = use_acomp ? 0 : (AC_USRSP_EN | tbl->tag);
+                snd_hda_codec_write_cache(codec, nid, 0,
+                                          AC_VERB_SET_UNSOLICITED_ENABLE, val);
+        } else {
+                /* if no jack entry was defined beforehand, create a new one
+                 * at need (i.e. only when notifier is cleared)
+                 */
+                if (!use_acomp)
+                        snd_hda_jack_detect_enable(codec, nid);
+        }
+}
+
+/* set up / clear component notifier dynamically */
+static void generic_acomp_notifier_set(struct drm_audio_component *acomp,
+                                       bool use_acomp)
+{
+        struct hdmi_spec *spec;
+        int i;
+
+        spec = container_of(acomp->audio_ops, struct hdmi_spec, drm_audio_ops);
+        mutex_lock(&spec->pcm_lock);
+        spec->use_acomp_notifier = use_acomp;
+        spec->codec->relaxed_resume = use_acomp;
+        /* reprogram each jack detection logic depending on the notifier */
+        if (spec->use_jack_detect) {
+                for (i = 0; i < spec->num_pins; i++)
+                        reprogram_jack_detect(spec->codec,
+                                              get_pin(spec, i)->pin_nid,
+                                              use_acomp);
+        }
+        mutex_unlock(&spec->pcm_lock);
+}
+
+/* enable / disable the notifier via master bind / unbind */
+static int generic_acomp_master_bind(struct device *dev,
+                                     struct drm_audio_component *acomp)
+{
+        generic_acomp_notifier_set(acomp, true);
+        return 0;
+}
+
+static void generic_acomp_master_unbind(struct device *dev,
+                                        struct drm_audio_component *acomp)
+{
+        generic_acomp_notifier_set(acomp, false);
+}
+
+/* check whether both HD-audio and DRM PCI devices belong to the same bus */
+static int match_bound_vga(struct device *dev, int subtype, void *data)
+{
+        struct hdac_bus *bus = data;
+        struct pci_dev *pci, *master;
+
+        if (!dev_is_pci(dev) || !dev_is_pci(bus->dev))
+                return 0;
+        master = to_pci_dev(bus->dev);
+        pci = to_pci_dev(dev);
+        return master->bus == pci->bus;
+}
+
+/* audio component notifier for AMD/Nvidia HDMI codecs */
+static void generic_acomp_pin_eld_notify(void *audio_ptr, int port, int dev_id)
+{
+        struct hda_codec *codec = audio_ptr;
+        struct hdmi_spec *spec = codec->spec;
+        hda_nid_t pin_nid = spec->port2pin(codec, port);
+
+        if (!pin_nid)
+                return;
+        if (get_wcaps_type(get_wcaps(codec, pin_nid)) != AC_WID_PIN)
+                return;
+        /* skip notification during system suspend (but not in runtime PM);
+         * the state will be updated at resume
+         */
+        if (snd_power_get_state(codec->card) != SNDRV_CTL_POWER_D0)
+                return;
+        /* ditto during suspend/resume process itself */
+        if (snd_hdac_is_in_pm(&codec->core))
+                return;
+
+        check_presence_and_report(codec, pin_nid, dev_id);
+}
+
+/* set up the private drm_audio_ops from the template */
+static void setup_drm_audio_ops(struct hda_codec *codec,
+                                const struct drm_audio_component_audio_ops *ops)
+{
+        struct hdmi_spec *spec = codec->spec;
+
+        spec->drm_audio_ops.audio_ptr = codec;
+        /* intel_audio_codec_enable() or intel_audio_codec_disable()
+         * will call pin_eld_notify with using audio_ptr pointer
+         * We need make sure audio_ptr is really setup
+         */
+        wmb();
+        spec->drm_audio_ops.pin2port = ops->pin2port;
+        spec->drm_audio_ops.pin_eld_notify = ops->pin_eld_notify;
+        spec->drm_audio_ops.master_bind = ops->master_bind;
+        spec->drm_audio_ops.master_unbind = ops->master_unbind;
+}
+
+/* initialize the generic HDMI audio component */
+static void generic_acomp_init(struct hda_codec *codec,
+                               const struct drm_audio_component_audio_ops *ops,
+                               int (*port2pin)(struct hda_codec *, int))
+{
+        struct hdmi_spec *spec = codec->spec;
+
+        spec->port2pin = port2pin;
+        setup_drm_audio_ops(codec, ops);
+        if (!snd_hdac_acomp_init(&codec->bus->core, &spec->drm_audio_ops,
+                                 match_bound_vga, 0))
+                spec->acomp_registered = true;
+}
+
+/*
  * Intel codec parsers and helpers
  */
 
@@ -2565,20 +2714,19 @@ static void intel_pin_eld_notify(void *audio_ptr, int port, int pipe)
         check_presence_and_report(codec, pin_nid, dev_id);
 }
 
+static const struct drm_audio_component_audio_ops intel_audio_ops = {
+        .pin2port = intel_pin2port,
+        .pin_eld_notify = intel_pin_eld_notify,
+};
+
 /* register i915 component pin_eld_notify callback */
 static void register_i915_notifier(struct hda_codec *codec)
 {
         struct hdmi_spec *spec = codec->spec;
 
         spec->use_acomp_notifier = true;
-        spec->drm_audio_ops.audio_ptr = codec;
-        /* intel_audio_codec_enable() or intel_audio_codec_disable()
-         * will call pin_eld_notify with using audio_ptr pointer
-         * We need make sure audio_ptr is really setup
-         */
-        wmb();
-        spec->drm_audio_ops.pin2port = intel_pin2port;
-        spec->drm_audio_ops.pin_eld_notify = intel_pin_eld_notify;
+        spec->port2pin = intel_port2pin;
+        setup_drm_audio_ops(codec, &intel_audio_ops);
         snd_hdac_acomp_register_notifier(&codec->bus->core,
                                         &spec->drm_audio_ops);
         /* no need for forcible resume for jack check thanks to notifier */
@@ -2976,6 +3124,7 @@ static int patch_simple_hdmi(struct hda_codec *codec,
         if (!spec)
                 return -ENOMEM;
 
+        spec->codec = codec;
         codec->spec = spec;
         hdmi_array_init(spec, 1);
 
@@ -3280,6 +3429,26 @@ static int nvhdmi_chmap_validate(struct hdac_chmap *chmap,
         return 0;
 }
 
+/* map from pin NID to port; port is 0-based */
+/* for Nvidia: assume widget NID starting from 4, with step 1 (4, 5, 6, ...) */
+static int nvhdmi_pin2port(void *audio_ptr, int pin_nid)
+{
+        return pin_nid - 4;
+}
+
+/* reverse-map from port to pin NID: see above */
+static int nvhdmi_port2pin(struct hda_codec *codec, int port)
+{
+        return port + 4;
+}
+
+static const struct drm_audio_component_audio_ops nvhdmi_audio_ops = {
+        .pin2port = nvhdmi_pin2port,
+        .pin_eld_notify = generic_acomp_pin_eld_notify,
+        .master_bind = generic_acomp_master_bind,
+        .master_unbind = generic_acomp_master_unbind,
+};
+
 static int patch_nvhdmi(struct hda_codec *codec)
 {
         struct hdmi_spec *spec;
@@ -3296,6 +3465,8 @@ static int patch_nvhdmi(struct hda_codec *codec)
                 nvhdmi_chmap_cea_alloc_validate_get_type;
         spec->chmap.ops.chmap_validate = nvhdmi_chmap_validate;
 
+        generic_acomp_init(codec, &nvhdmi_audio_ops, nvhdmi_port2pin);
+
         return 0;
 }
 
@@ -3783,6 +3954,26 @@ static int atihdmi_init(struct hda_codec *codec)
         return 0;
 }
 
+/* map from pin NID to port; port is 0-based */
+/* for AMD: assume widget NID starting from 3, with step 2 (3, 5, 7, ...) */
+static int atihdmi_pin2port(void *audio_ptr, int pin_nid)
+{
+        return pin_nid / 2 - 1;
+}
+
+/* reverse-map from port to pin NID: see above */
+static int atihdmi_port2pin(struct hda_codec *codec, int port)
+{
+        return port * 2 + 3;
+}
+
+static const struct drm_audio_component_audio_ops atihdmi_audio_ops = {
+        .pin2port = atihdmi_pin2port,
+        .pin_eld_notify = generic_acomp_pin_eld_notify,
+        .master_bind = generic_acomp_master_bind,
+        .master_unbind = generic_acomp_master_unbind,
+};
+
 static int patch_atihdmi(struct hda_codec *codec)
 {
         struct hdmi_spec *spec;
@@ -3831,6 +4022,8 @@ static int patch_atihdmi(struct hda_codec *codec)
          */
         codec->link_down_at_suspend = 1;
 
+        generic_acomp_init(codec, &atihdmi_audio_ops, atihdmi_port2pin);
+
         return 0;
 }
 
diff --git a/sound/soc/amd/raven/acp3x-pcm-dma.c b/sound/soc/amd/raven/acp3x-pcm-dma.c
index a4ade6bb5beb..bc4dfafdfcd1 100644
--- a/sound/soc/amd/raven/acp3x-pcm-dma.c
+++ b/sound/soc/amd/raven/acp3x-pcm-dma.c
@@ -31,8 +31,8 @@ struct i2s_stream_instance {
         u16 num_pages;
         u16 channels;
         u32 xfer_resolution;
-        struct page *pg;
         u64 bytescount;
+        dma_addr_t dma_addr;
         void __iomem *acp3x_base;
 };
 
@@ -211,9 +211,8 @@ static irqreturn_t i2s_irq_handler(int irq, void *dev_id)
 static void config_acp3x_dma(struct i2s_stream_instance *rtd, int direction)
 {
         u16 page_idx;
-        u64 addr;
         u32 low, high, val, acp_fifo_addr;
-        struct page *pg = rtd->pg;
+        dma_addr_t addr = rtd->dma_addr;
 
         /* 8 scratch registers used to map one 64 bit address */
         if (direction == SNDRV_PCM_STREAM_PLAYBACK)
@@ -229,7 +228,6 @@ static void config_acp3x_dma(struct i2s_stream_instance *rtd, int direction)
 
         for (page_idx = 0; page_idx < rtd->num_pages; page_idx++) {
                 /* Load the low address of page int ACP SRAM through SRBM */
-                addr = page_to_phys(pg);
                 low = lower_32_bits(addr);
                 high = upper_32_bits(addr);
 
@@ -239,7 +237,7 @@ static void config_acp3x_dma(struct i2s_stream_instance *rtd, int direction)
                                 + 4);
                 /* Move to next physically contiguos page */
                 val += 8;
-                pg++;
+                addr += PAGE_SIZE;
         }
 
         if (direction == SNDRV_PCM_STREAM_PLAYBACK) {
@@ -341,7 +339,6 @@ static int acp3x_dma_hw_params(struct snd_pcm_substream *substream,
 {
         int status;
         u64 size;
-        struct page *pg;
         struct snd_pcm_runtime *runtime = substream->runtime;
         struct i2s_stream_instance *rtd = runtime->private_data;
 
@@ -354,9 +351,8 @@ static int acp3x_dma_hw_params(struct snd_pcm_substream *substream,
                 return status;
 
         memset(substream->runtime->dma_area, 0, params_buffer_bytes(params));
-        pg = virt_to_page(substream->dma_buffer.area);
-        if (pg) {
-                rtd->pg = pg;
+        if (substream->dma_buffer.area) {
+                rtd->dma_addr = substream->dma_buffer.addr;
                 rtd->num_pages = (PAGE_ALIGN(size) >> PAGE_SHIFT);
                 config_acp3x_dma(rtd, substream->stream);
                 status = 0;
@@ -385,9 +381,11 @@ static snd_pcm_uframes_t acp3x_dma_pointer(struct snd_pcm_substream *substream)
 
 static int acp3x_dma_new(struct snd_soc_pcm_runtime *rtd)
 {
+        struct snd_soc_component *component = snd_soc_rtdcom_lookup(rtd,
+                                                                    DRV_NAME);
+        struct device *parent = component->dev->parent;
         snd_pcm_lib_preallocate_pages_for_all(rtd->pcm, SNDRV_DMA_TYPE_DEV,
-                                              rtd->pcm->card->dev,
-                                              MIN_BUFFER, MAX_BUFFER);
+                                              parent, MIN_BUFFER, MAX_BUFFER);
         return 0;
 }
 
diff --git a/sound/soc/codecs/cs42xx8.c b/sound/soc/codecs/cs42xx8.c
index 6203f54d9f25..5b049fcdba20 100644
--- a/sound/soc/codecs/cs42xx8.c
+++ b/sound/soc/codecs/cs42xx8.c
@@ -47,6 +47,7 @@ struct cs42xx8_priv {
         unsigned long sysclk;
         u32 tx_channels;
         struct gpio_desc *gpiod_reset;
+        u32 rate[2];
 };
 
 /* -127.5dB to 0dB with step of 0.5dB */
@@ -176,21 +177,27 @@ static const struct snd_soc_dapm_route cs42xx8_adc3_dapm_routes[] = {
 };
 
 struct cs42xx8_ratios {
-        unsigned int ratio;
-        unsigned char speed;
-        unsigned char mclk;
+        unsigned int mfreq;
+        unsigned int min_mclk;
+        unsigned int max_mclk;
+        unsigned int ratio[3];
 };
 
+/*
+ * According to reference mannual, define the cs42xx8_ratio struct
+ * MFreq2 | MFreq1 | MFreq0 |     Description     | SSM | DSM | QSM |
+ * 0      | 0      | 0      |1.029MHz to 12.8MHz  | 256 | 128 |  64 |
+ * 0      | 0      | 1      |1.536MHz to 19.2MHz  | 384 | 192 |  96 |
+ * 0      | 1      | 0      |2.048MHz to 25.6MHz  | 512 | 256 | 128 |
+ * 0      | 1      | 1      |3.072MHz to 38.4MHz  | 768 | 384 | 192 |
+ * 1      | x      | x      |4.096MHz to 51.2MHz  |1024 | 512 | 256 |
+ */
 static const struct cs42xx8_ratios cs42xx8_ratios[] = {
-        { 64, CS42XX8_FM_QUAD, CS42XX8_FUNCMOD_MFREQ_256(4) },
-        { 96, CS42XX8_FM_QUAD, CS42XX8_FUNCMOD_MFREQ_384(4) },
-        { 128, CS42XX8_FM_QUAD, CS42XX8_FUNCMOD_MFREQ_512(4) },
-        { 192, CS42XX8_FM_QUAD, CS42XX8_FUNCMOD_MFREQ_768(4) },
-        { 256, CS42XX8_FM_SINGLE, CS42XX8_FUNCMOD_MFREQ_256(1) },
-        { 384, CS42XX8_FM_SINGLE, CS42XX8_FUNCMOD_MFREQ_384(1) },
-        { 512, CS42XX8_FM_SINGLE, CS42XX8_FUNCMOD_MFREQ_512(1) },
-        { 768, CS42XX8_FM_SINGLE, CS42XX8_FUNCMOD_MFREQ_768(1) },
-        { 1024, CS42XX8_FM_SINGLE, CS42XX8_FUNCMOD_MFREQ_1024(1) }
+        { 0, 1029000, 12800000, {256, 128, 64} },
+        { 2, 1536000, 19200000, {384, 192, 96} },
+        { 4, 2048000, 25600000, {512, 256, 128} },
+        { 6, 3072000, 38400000, {768, 384, 192} },
+        { 8, 4096000, 51200000, {1024, 512, 256} },
 };
 
 static int cs42xx8_set_dai_sysclk(struct snd_soc_dai *codec_dai,
@@ -257,14 +264,68 @@ static int cs42xx8_hw_params(struct snd_pcm_substream *substream,
         struct snd_soc_component *component = dai->component;
         struct cs42xx8_priv *cs42xx8 = snd_soc_component_get_drvdata(component);
         bool tx = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;
-        u32 ratio = cs42xx8->sysclk / params_rate(params);
-        u32 i, fm, val, mask;
+        u32 ratio[2];
+        u32 rate[2];
+        u32 fm[2];
+        u32 i, val, mask;
+        bool condition1, condition2;
 
         if (tx)
                 cs42xx8->tx_channels = params_channels(params);
 
+        rate[tx]  = params_rate(params);
+        rate[!tx] = cs42xx8->rate[!tx];
+
+        ratio[tx] = rate[tx] > 0 ? cs42xx8->sysclk / rate[tx] : 0;
+        ratio[!tx] = rate[!tx] > 0 ? cs42xx8->sysclk / rate[!tx] : 0;
+
+        /* Get functional mode for tx and rx according to rate */
+        for (i = 0; i < 2; i++) {
+                if (cs42xx8->slave_mode) {
+                        fm[i] = CS42XX8_FM_AUTO;
+                } else {
+                        if (rate[i] < 50000) {
+                                fm[i] = CS42XX8_FM_SINGLE;
+                        } else if (rate[i] > 50000 && rate[i] < 100000) {
+                                fm[i] = CS42XX8_FM_DOUBLE;
+                        } else if (rate[i] > 100000 && rate[i] < 200000) {
+                                fm[i] = CS42XX8_FM_QUAD;
+                        } else {
+                                dev_err(component->dev,
+                                        "unsupported sample rate\n");
+                                return -EINVAL;
+                        }
+                }
+        }
+
         for (i = 0; i < ARRAY_SIZE(cs42xx8_ratios); i++) {
-                if (cs42xx8_ratios[i].ratio == ratio)
+                /* Is the ratio[tx] valid ? */
+                condition1 = ((fm[tx] == CS42XX8_FM_AUTO) ?
+                        (cs42xx8_ratios[i].ratio[0] == ratio[tx] ||
+                        cs42xx8_ratios[i].ratio[1] == ratio[tx] ||
+                        cs42xx8_ratios[i].ratio[2] == ratio[tx]) :
+                        (cs42xx8_ratios[i].ratio[fm[tx]] == ratio[tx])) &&
+                        cs42xx8->sysclk >= cs42xx8_ratios[i].min_mclk &&
+                        cs42xx8->sysclk <= cs42xx8_ratios[i].max_mclk;
+
+                if (!ratio[tx])
+                        condition1 = true;
+
+                /* Is the ratio[!tx] valid ? */
+                condition2 = ((fm[!tx] == CS42XX8_FM_AUTO) ?
+                        (cs42xx8_ratios[i].ratio[0] == ratio[!tx] ||
+                        cs42xx8_ratios[i].ratio[1] == ratio[!tx] ||
+                        cs42xx8_ratios[i].ratio[2] == ratio[!tx]) :
+                        (cs42xx8_ratios[i].ratio[fm[!tx]] == ratio[!tx]));
+
+                if (!ratio[!tx])
+                        condition2 = true;
+
+                /*
+                 * Both ratio[tx] and ratio[!tx] is valid, then we get
+                 * a proper MFreq.
+                 */
+                if (condition1 && condition2)
                         break;
         }
 
@@ -273,15 +334,31 @@ static int cs42xx8_hw_params(struct snd_pcm_substream *substream,
                 return -EINVAL;
         }
 
-        mask = CS42XX8_FUNCMOD_MFREQ_MASK;
-        val = cs42xx8_ratios[i].mclk;
+        cs42xx8->rate[tx] = params_rate(params);
 
-        fm = cs42xx8->slave_mode ? CS42XX8_FM_AUTO : cs42xx8_ratios[i].speed;
+        mask = CS42XX8_FUNCMOD_MFREQ_MASK;
+        val = cs42xx8_ratios[i].mfreq;
 
         regmap_update_bits(cs42xx8->regmap, CS42XX8_FUNCMOD,
                            CS42XX8_FUNCMOD_xC_FM_MASK(tx) | mask,
-                           CS42XX8_FUNCMOD_xC_FM(tx, fm) | val);
+                           CS42XX8_FUNCMOD_xC_FM(tx, fm[tx]) | val);
+
+        return 0;
+}
+
+static int cs42xx8_hw_free(struct snd_pcm_substream *substream,
+                           struct snd_soc_dai *dai)
+{
+        struct snd_soc_component *component = dai->component;
+        struct cs42xx8_priv *cs42xx8 = snd_soc_component_get_drvdata(component);
+        bool tx = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;
 
+        /* Clear stored rate */
+        cs42xx8->rate[tx] = 0;
+
+        regmap_update_bits(cs42xx8->regmap, CS42XX8_FUNCMOD,
+                           CS42XX8_FUNCMOD_xC_FM_MASK(tx),
+                           CS42XX8_FUNCMOD_xC_FM(tx, CS42XX8_FM_AUTO));
         return 0;
 }
 
@@ -302,6 +379,7 @@ static const struct snd_soc_dai_ops cs42xx8_dai_ops = {
         .set_fmt        = cs42xx8_set_dai_fmt,
         .set_sysclk     = cs42xx8_set_dai_sysclk,
         .hw_params      = cs42xx8_hw_params,
+        .hw_free        = cs42xx8_hw_free,
         .digital_mute   = cs42xx8_digital_mute,
 };
 
diff --git a/sound/soc/codecs/max98357a.c b/sound/soc/codecs/max98357a.c
index 6f0e28f903bf..16313b973eaa 100644
--- a/sound/soc/codecs/max98357a.c
+++ b/sound/soc/codecs/max98357a.c
@@ -20,20 +20,10 @@
 #include <sound/soc-dapm.h>
 
 struct max98357a_priv {
-        struct delayed_work enable_sdmode_work;
         struct gpio_desc *sdmode;
         unsigned int sdmode_delay;
 };
 
-static void max98357a_enable_sdmode_work(struct work_struct *work)
-{
-        struct max98357a_priv *max98357a =
-        container_of(work, struct max98357a_priv,
-                        enable_sdmode_work.work);
-
-        gpiod_set_value(max98357a->sdmode, 1);
-}
-
 static int max98357a_daiops_trigger(struct snd_pcm_substream *substream,
                 int cmd, struct snd_soc_dai *dai)
 {
@@ -46,14 +36,12 @@ static int max98357a_daiops_trigger(struct snd_pcm_substream *substream,
         case SNDRV_PCM_TRIGGER_START:
         case SNDRV_PCM_TRIGGER_RESUME:
         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
-                queue_delayed_work(system_power_efficient_wq,
-                                &max98357a->enable_sdmode_work,
-                                msecs_to_jiffies(max98357a->sdmode_delay));
+                mdelay(max98357a->sdmode_delay);
+                gpiod_set_value(max98357a->sdmode, 1);
                 break;
         case SNDRV_PCM_TRIGGER_STOP:
         case SNDRV_PCM_TRIGGER_SUSPEND:
         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
-                cancel_delayed_work_sync(&max98357a->enable_sdmode_work);
                 gpiod_set_value(max98357a->sdmode, 0);
                 break;
         }
@@ -112,30 +100,25 @@ static int max98357a_platform_probe(struct platform_device *pdev)
         int ret;
 
         max98357a = devm_kzalloc(&pdev->dev, sizeof(*max98357a), GFP_KERNEL);
-
         if (!max98357a)
                 return -ENOMEM;
 
         max98357a->sdmode = devm_gpiod_get_optional(&pdev->dev,
                                 "sdmode", GPIOD_OUT_LOW);
-
         if (IS_ERR(max98357a->sdmode))
                 return PTR_ERR(max98357a->sdmode);
 
         ret = device_property_read_u32(&pdev->dev, "sdmode-delay",
                                         &max98357a->sdmode_delay);
-
         if (ret) {
                 max98357a->sdmode_delay = 0;
                 dev_dbg(&pdev->dev,
-                        "no optional property 'sdmode-delay' found, default: no delay\n");
+                        "no optional property 'sdmode-delay' found, "
+                        "default: no delay\n");
         }
 
         dev_set_drvdata(&pdev->dev, max98357a);
 
-        INIT_DELAYED_WORK(&max98357a->enable_sdmode_work,
-                                max98357a_enable_sdmode_work);
-
         return devm_snd_soc_register_component(&pdev->dev,
                         &max98357a_component_driver,
                         &max98357a_dai_driver, 1);
diff --git a/sound/soc/codecs/max98373.c b/sound/soc/codecs/max98373.c
index 528695cd6a1c..8c601a3ebc27 100644
--- a/sound/soc/codecs/max98373.c
+++ b/sound/soc/codecs/max98373.c
@@ -267,6 +267,12 @@ static int max98373_dai_hw_params(struct snd_pcm_substream *substream,
         case 48000:
                 sampling_rate = MAX98373_PCM_SR_SET1_SR_48000;
                 break;
+        case 88200:
+                sampling_rate = MAX98373_PCM_SR_SET1_SR_88200;
+                break;
+        case 96000:
+                sampling_rate = MAX98373_PCM_SR_SET1_SR_96000;
+                break;
         default:
                 dev_err(component->dev, "rate %d not supported\n",
                         params_rate(params));
diff --git a/sound/soc/codecs/max98373.h b/sound/soc/codecs/max98373.h
index f6a37aa02f26..a59e51355a84 100644
--- a/sound/soc/codecs/max98373.h
+++ b/sound/soc/codecs/max98373.h
@@ -130,6 +130,8 @@
 #define MAX98373_PCM_SR_SET1_SR_32000 (0x6 << 0)
 #define MAX98373_PCM_SR_SET1_SR_44100 (0x7 << 0)
 #define MAX98373_PCM_SR_SET1_SR_48000 (0x8 << 0)
+#define MAX98373_PCM_SR_SET1_SR_88200 (0x9 << 0)
+#define MAX98373_PCM_SR_SET1_SR_96000 (0xA << 0)
 
 /* MAX98373_R2028_PCM_SR_SETUP_2 */
 #define MAX98373_PCM_SR_SET2_SR_MASK (0xF << 4)
diff --git a/sound/soc/codecs/pcm3060-i2c.c b/sound/soc/codecs/pcm3060-i2c.c
index cdc8314882bc..abcdeb922201 100644
--- a/sound/soc/codecs/pcm3060-i2c.c
+++ b/sound/soc/codecs/pcm3060-i2c.c
@@ -2,7 +2,7 @@
 //
 // PCM3060 I2C driver
 //
-// Copyright (C) 2018 Kirill Marinushkin <kmarinushkin@birdec.tech>
+// Copyright (C) 2018 Kirill Marinushkin <kmarinushkin@birdec.com>
 
 #include <linux/i2c.h>
 #include <linux/module.h>
@@ -56,5 +56,5 @@ static struct i2c_driver pcm3060_i2c_driver = {
 module_i2c_driver(pcm3060_i2c_driver);
 
 MODULE_DESCRIPTION("PCM3060 I2C driver");
-MODULE_AUTHOR("Kirill Marinushkin <kmarinushkin@birdec.tech>");
+MODULE_AUTHOR("Kirill Marinushkin <kmarinushkin@birdec.com>");
 MODULE_LICENSE("GPL v2");
diff --git a/sound/soc/codecs/pcm3060-spi.c b/sound/soc/codecs/pcm3060-spi.c
index f6f19fa80932..3b79734b832b 100644
--- a/sound/soc/codecs/pcm3060-spi.c
+++ b/sound/soc/codecs/pcm3060-spi.c
@@ -2,7 +2,7 @@
 //
 // PCM3060 SPI driver
 //
-// Copyright (C) 2018 Kirill Marinushkin <kmarinushkin@birdec.tech>
+// Copyright (C) 2018 Kirill Marinushkin <kmarinushkin@birdec.com>
 
 #include <linux/module.h>
 #include <linux/spi/spi.h>
@@ -55,5 +55,5 @@ static struct spi_driver pcm3060_spi_driver = {
 module_spi_driver(pcm3060_spi_driver);
 
 MODULE_DESCRIPTION("PCM3060 SPI driver");
-MODULE_AUTHOR("Kirill Marinushkin <kmarinushkin@birdec.tech>");
+MODULE_AUTHOR("Kirill Marinushkin <kmarinushkin@birdec.com>");
 MODULE_LICENSE("GPL v2");
diff --git a/sound/soc/codecs/pcm3060.c b/sound/soc/codecs/pcm3060.c
index 32b26f1c2282..b2358069cf9b 100644
--- a/sound/soc/codecs/pcm3060.c
+++ b/sound/soc/codecs/pcm3060.c
@@ -2,7 +2,7 @@
 //
 // PCM3060 codec driver
 //
-// Copyright (C) 2018 Kirill Marinushkin <kmarinushkin@birdec.tech>
+// Copyright (C) 2018 Kirill Marinushkin <kmarinushkin@birdec.com>
 
 #include <linux/module.h>
 #include <sound/pcm_params.h>
@@ -342,5 +342,5 @@ int pcm3060_probe(struct device *dev)
 EXPORT_SYMBOL(pcm3060_probe);
 
 MODULE_DESCRIPTION("PCM3060 codec driver");
-MODULE_AUTHOR("Kirill Marinushkin <kmarinushkin@birdec.tech>");
+MODULE_AUTHOR("Kirill Marinushkin <kmarinushkin@birdec.com>");
 MODULE_LICENSE("GPL v2");
diff --git a/sound/soc/codecs/pcm3060.h b/sound/soc/codecs/pcm3060.h
index 75931c9a9d85..18d51e5dac2c 100644
--- a/sound/soc/codecs/pcm3060.h
+++ b/sound/soc/codecs/pcm3060.h
@@ -2,7 +2,7 @@
 /*
  * PCM3060 codec driver
  *
- * Copyright (C) 2018 Kirill Marinushkin <kmarinushkin@birdec.tech>
+ * Copyright (C) 2018 Kirill Marinushkin <kmarinushkin@birdec.com>
  */
 
 #ifndef _SND_SOC_PCM3060_H
diff --git a/sound/soc/codecs/rt1011.c b/sound/soc/codecs/rt1011.c
index 5605b660f4bf..0a6ff13d76e1 100644
--- a/sound/soc/codecs/rt1011.c
+++ b/sound/soc/codecs/rt1011.c
@@ -39,7 +39,7 @@ static const struct reg_sequence init_list[] = {
         { RT1011_POWER_9, 0xa840 },
 
         { RT1011_ADC_SET_5, 0x0a20 },
-        { RT1011_DAC_SET_2, 0xa232 },
+        { RT1011_DAC_SET_2, 0xa032 },
         { RT1011_ADC_SET_1, 0x2925 },
 
         { RT1011_SPK_PRO_DC_DET_1, 0xb00c },
@@ -1917,7 +1917,7 @@ static int rt1011_set_bias_level(struct snd_soc_component *component,
                 snd_soc_component_write(component,
                         RT1011_SYSTEM_RESET_2, 0x0000);
                 snd_soc_component_write(component,
-                        RT1011_SYSTEM_RESET_3, 0x0000);
+                        RT1011_SYSTEM_RESET_3, 0x0001);
                 snd_soc_component_write(component,
                         RT1011_SYSTEM_RESET_1, 0x003f);
                 snd_soc_component_write(component,
diff --git a/sound/soc/codecs/rt1308.c b/sound/soc/codecs/rt1308.c
index d673506c7c39..d673506c7c39 100755..100644
--- a/sound/soc/codecs/rt1308.c
+++ b/sound/soc/codecs/rt1308.c
diff --git a/sound/soc/codecs/rt1308.h b/sound/soc/codecs/rt1308.h
index c330aae1d527..c330aae1d527 100755..100644
--- a/sound/soc/codecs/rt1308.h
+++ b/sound/soc/codecs/rt1308.h
diff --git a/sound/soc/generic/audio-graph-card.c b/sound/soc/generic/audio-graph-card.c
index 30a4e8399ec3..288df245b2f0 100644
--- a/sound/soc/generic/audio-graph-card.c
+++ b/sound/soc/generic/audio-graph-card.c
@@ -63,6 +63,7 @@ static int graph_get_dai_id(struct device_node *ep)
         struct device_node *endpoint;
         struct of_endpoint info;
         int i, id;
+        const u32 *reg;
         int ret;
 
         /* use driver specified DAI ID if exist */
@@ -83,8 +84,9 @@ static int graph_get_dai_id(struct device_node *ep)
                         return info.id;
 
                 node = of_get_parent(ep);
+                reg = of_get_property(node, "reg", NULL);
                 of_node_put(node);
-                if (of_get_property(node, "reg", NULL))
+                if (reg)
                         return info.port;
         }
         node = of_graph_get_port_parent(ep);
@@ -208,10 +210,6 @@ static int graph_dai_link_of_dpcm(struct asoc_simple_priv *priv,
 
         dev_dbg(dev, "link_of DPCM (%pOF)\n", ep);
 
-        of_node_put(ports);
-        of_node_put(port);
-        of_node_put(node);
-
         if (li->cpu) {
                 int is_single_links = 0;
 
@@ -229,17 +227,17 @@ static int graph_dai_link_of_dpcm(struct asoc_simple_priv *priv,
 
                 ret = asoc_simple_parse_cpu(ep, dai_link, &is_single_links);
                 if (ret)
-                        return ret;
+                        goto out_put_node;
 
                 ret = asoc_simple_parse_clk_cpu(dev, ep, dai_link, dai);
                 if (ret < 0)
-                        return ret;
+                        goto out_put_node;
 
                 ret = asoc_simple_set_dailink_name(dev, dai_link,
                                                    "fe.%s",
                                                    cpus->dai_name);
                 if (ret < 0)
-                        return ret;
+                        goto out_put_node;
 
                 /* card->num_links includes Codec */
                 asoc_simple_canonicalize_cpu(dai_link, is_single_links);
@@ -263,17 +261,17 @@ static int graph_dai_link_of_dpcm(struct asoc_simple_priv *priv,
 
                 ret = asoc_simple_parse_codec(ep, dai_link);
                 if (ret < 0)
-                        return ret;
+                        goto out_put_node;
 
                 ret = asoc_simple_parse_clk_codec(dev, ep, dai_link, dai);
                 if (ret < 0)
-                        return ret;
+                        goto out_put_node;
 
                 ret = asoc_simple_set_dailink_name(dev, dai_link,
                                                    "be.%s",
                                                    codecs->dai_name);
                 if (ret < 0)
-                        return ret;
+                        goto out_put_node;
 
                 /* check "prefix" from top node */
                 snd_soc_of_parse_node_prefix(top, cconf, codecs->of_node,
@@ -293,19 +291,23 @@ static int graph_dai_link_of_dpcm(struct asoc_simple_priv *priv,
 
         ret = asoc_simple_parse_tdm(ep, dai);
         if (ret)
-                return ret;
+                goto out_put_node;
 
         ret = asoc_simple_parse_daifmt(dev, cpu_ep, codec_ep,
                                        NULL, &dai_link->dai_fmt);
         if (ret < 0)
-                return ret;
+                goto out_put_node;
 
         dai_link->dpcm_playback         = 1;
         dai_link->dpcm_capture          = 1;
         dai_link->ops                   = &graph_ops;
         dai_link->init                  = asoc_simple_dai_init;
 
-        return 0;
+out_put_node:
+        of_node_put(ports);
+        of_node_put(port);
+        of_node_put(node);
+        return ret;
 }
 
 static int graph_dai_link_of(struct asoc_simple_priv *priv,
diff --git a/sound/soc/generic/simple-card-utils.c b/sound/soc/generic/simple-card-utils.c
index ac8678fe55ff..556b1a789629 100644
--- a/sound/soc/generic/simple-card-utils.c
+++ b/sound/soc/generic/simple-card-utils.c
@@ -349,6 +349,13 @@ void asoc_simple_canonicalize_platform(struct snd_soc_dai_link *dai_link)
         /* Assumes platform == cpu */
         if (!dai_link->platforms->of_node)
                 dai_link->platforms->of_node = dai_link->cpus->of_node;
+
+        /*
+         * DPCM BE can be no platform.
+         * Alloced memory will be waste, but not leak.
+         */
+        if (!dai_link->platforms->of_node)
+                dai_link->num_platforms = 0;
 }
 EXPORT_SYMBOL_GPL(asoc_simple_canonicalize_platform);
 
diff --git a/sound/soc/generic/simple-card.c b/sound/soc/generic/simple-card.c
index e5cde0d5e63c..ef849151ba56 100644
--- a/sound/soc/generic/simple-card.c
+++ b/sound/soc/generic/simple-card.c
@@ -124,8 +124,6 @@ static int simple_dai_link_of_dpcm(struct asoc_simple_priv *priv,
 
         li->link++;
 
-        of_node_put(node);
-
         /* For single DAI link & old style of DT node */
         if (is_top)
                 prefix = PREFIX;
@@ -147,17 +145,17 @@ static int simple_dai_link_of_dpcm(struct asoc_simple_priv *priv,
 
                 ret = asoc_simple_parse_cpu(np, dai_link, &is_single_links);
                 if (ret)
-                        return ret;
+                        goto out_put_node;
 
                 ret = asoc_simple_parse_clk_cpu(dev, np, dai_link, dai);
                 if (ret < 0)
-                        return ret;
+                        goto out_put_node;
 
                 ret = asoc_simple_set_dailink_name(dev, dai_link,
                                                    "fe.%s",
                                                    cpus->dai_name);
                 if (ret < 0)
-                        return ret;
+                        goto out_put_node;
 
                 asoc_simple_canonicalize_cpu(dai_link, is_single_links);
         } else {
@@ -180,17 +178,17 @@ static int simple_dai_link_of_dpcm(struct asoc_simple_priv *priv,
 
                 ret = asoc_simple_parse_codec(np, dai_link);
                 if (ret < 0)
-                        return ret;
+                        goto out_put_node;
 
                 ret = asoc_simple_parse_clk_codec(dev, np, dai_link, dai);
                 if (ret < 0)
-                        return ret;
+                        goto out_put_node;
 
                 ret = asoc_simple_set_dailink_name(dev, dai_link,
                                                    "be.%s",
                                                    codecs->dai_name);
                 if (ret < 0)
-                        return ret;
+                        goto out_put_node;
 
                 /* check "prefix" from top node */
                 snd_soc_of_parse_node_prefix(top, cconf, codecs->of_node,
@@ -208,19 +206,21 @@ static int simple_dai_link_of_dpcm(struct asoc_simple_priv *priv,
 
         ret = asoc_simple_parse_tdm(np, dai);
         if (ret)
-                return ret;
+                goto out_put_node;
 
         ret = asoc_simple_parse_daifmt(dev, node, codec,
                                        prefix, &dai_link->dai_fmt);
         if (ret < 0)
-                return ret;
+                goto out_put_node;
 
         dai_link->dpcm_playback         = 1;
         dai_link->dpcm_capture          = 1;
         dai_link->ops                   = &simple_ops;
         dai_link->init                  = asoc_simple_dai_init;
 
-        return 0;
+out_put_node:
+        of_node_put(node);
+        return ret;
 }
 
 static int simple_dai_link_of(struct asoc_simple_priv *priv,
@@ -364,8 +364,6 @@ static int simple_for_each_link(struct asoc_simple_priv *priv,
                         goto error;
                 }
 
-                of_node_put(codec);
-
                 /* get convert-xxx property */
                 memset(&adata, 0, sizeof(adata));
                 for_each_child_of_node(node, np)
@@ -387,11 +385,13 @@ static int simple_for_each_link(struct asoc_simple_priv *priv,
                                 ret = func_noml(priv, np, codec, li, is_top);
 
                         if (ret < 0) {
+                                of_node_put(codec);
                                 of_node_put(np);
                                 goto error;
                         }
                 }
 
+                of_node_put(codec);
                 node = of_get_next_child(top, node);
         } while (!is_top && node);
 
diff --git a/sound/soc/intel/Kconfig b/sound/soc/intel/Kconfig
index 96a00a9d4cf8..a3ec17fd63cd 100644
--- a/sound/soc/intel/Kconfig
+++ b/sound/soc/intel/Kconfig
@@ -215,6 +215,7 @@ config SND_SOC_INTEL_SKYLAKE_COMMON
         select SND_SOC_INTEL_SST
         select SND_SOC_HDAC_HDA if SND_SOC_INTEL_SKYLAKE_HDAUDIO_CODEC
         select SND_SOC_ACPI_INTEL_MATCH
+        select SND_INTEL_NHLT
         help
           If you have a Intel Skylake/Broxton/ApolloLake/KabyLake/
           GeminiLake or CannonLake platform with the DSP enabled in the BIOS
diff --git a/sound/soc/intel/boards/bytcht_es8316.c b/sound/soc/intel/boards/bytcht_es8316.c
index fac09be3cade..46612331f5ea 100644
--- a/sound/soc/intel/boards/bytcht_es8316.c
+++ b/sound/soc/intel/boards/bytcht_es8316.c
@@ -437,6 +437,14 @@ static const struct acpi_gpio_mapping byt_cht_es8316_gpios[] = {
 
 /* Please keep this list alphabetically sorted */
 static const struct dmi_system_id byt_cht_es8316_quirk_table[] = {
+        {       /* Irbis NB41 */
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "IRBIS"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "NB41"),
+                },
+                .driver_data = (void *)(BYT_CHT_ES8316_INTMIC_IN2_MAP
+                                        | BYT_CHT_ES8316_JD_INVERTED),
+        },
         {       /* Teclast X98 Plus II */
                 .matches = {
                         DMI_MATCH(DMI_SYS_VENDOR, "TECLAST"),
diff --git a/sound/soc/intel/common/soc-acpi-intel-bxt-match.c b/sound/soc/intel/common/soc-acpi-intel-bxt-match.c
index 229e39586868..4a5adae1d785 100644
--- a/sound/soc/intel/common/soc-acpi-intel-bxt-match.c
+++ b/sound/soc/intel/common/soc-acpi-intel-bxt-match.c
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0
 /*
- * soc-apci-intel-bxt-match.c - tables and support for BXT ACPI enumeration.
+ * soc-acpi-intel-bxt-match.c - tables and support for BXT ACPI enumeration.
  *
  * Copyright (c) 2018, Intel Corporation.
  *
diff --git a/sound/soc/intel/common/soc-acpi-intel-byt-match.c b/sound/soc/intel/common/soc-acpi-intel-byt-match.c
index b94b482ac34f..1cc801ba92eb 100644
--- a/sound/soc/intel/common/soc-acpi-intel-byt-match.c
+++ b/sound/soc/intel/common/soc-acpi-intel-byt-match.c
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0-only
 /*
- * soc-apci-intel-byt-match.c - tables and support for BYT ACPI enumeration.
+ * soc-acpi-intel-byt-match.c - tables and support for BYT ACPI enumeration.
  *
  * Copyright (c) 2017, Intel Corporation.
  */
diff --git a/sound/soc/intel/common/soc-acpi-intel-cht-match.c b/sound/soc/intel/common/soc-acpi-intel-cht-match.c
index b7f11f6be1cf..d0fb43c2b9f6 100644
--- a/sound/soc/intel/common/soc-acpi-intel-cht-match.c
+++ b/sound/soc/intel/common/soc-acpi-intel-cht-match.c
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0-only
 /*
- * soc-apci-intel-cht-match.c - tables and support for CHT ACPI enumeration.
+ * soc-acpi-intel-cht-match.c - tables and support for CHT ACPI enumeration.
  *
  * Copyright (c) 2017, Intel Corporation.
  */
diff --git a/sound/soc/intel/common/soc-acpi-intel-cnl-match.c b/sound/soc/intel/common/soc-acpi-intel-cnl-match.c
index c36c0aa4f683..771b0ef21051 100644
--- a/sound/soc/intel/common/soc-acpi-intel-cnl-match.c
+++ b/sound/soc/intel/common/soc-acpi-intel-cnl-match.c
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0
 /*
- * soc-apci-intel-cnl-match.c - tables and support for CNL ACPI enumeration.
+ * soc-acpi-intel-cnl-match.c - tables and support for CNL ACPI enumeration.
  *
  * Copyright (c) 2018, Intel Corporation.
  *
diff --git a/sound/soc/intel/common/soc-acpi-intel-glk-match.c b/sound/soc/intel/common/soc-acpi-intel-glk-match.c
index 616eb09e78a0..60dea358fa04 100644
--- a/sound/soc/intel/common/soc-acpi-intel-glk-match.c
+++ b/sound/soc/intel/common/soc-acpi-intel-glk-match.c
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0
 /*
- * soc-apci-intel-glk-match.c - tables and support for GLK ACPI enumeration.
+ * soc-acpi-intel-glk-match.c - tables and support for GLK ACPI enumeration.
  *
  * Copyright (c) 2018, Intel Corporation.
  *
diff --git a/sound/soc/intel/common/soc-acpi-intel-hda-match.c b/sound/soc/intel/common/soc-acpi-intel-hda-match.c
index 68ae43f7b4b2..cc972d2ac691 100644
--- a/sound/soc/intel/common/soc-acpi-intel-hda-match.c
+++ b/sound/soc/intel/common/soc-acpi-intel-hda-match.c
@@ -2,7 +2,7 @@
 // Copyright (c) 2018, Intel Corporation.
 
 /*
- * soc-apci-intel-hda-match.c - tables and support for HDA+ACPI enumeration.
+ * soc-acpi-intel-hda-match.c - tables and support for HDA+ACPI enumeration.
  *
  */
 
diff --git a/sound/soc/intel/common/soc-acpi-intel-hsw-bdw-match.c b/sound/soc/intel/common/soc-acpi-intel-hsw-bdw-match.c
index d27853e7a369..34eb0baaa951 100644
--- a/sound/soc/intel/common/soc-acpi-intel-hsw-bdw-match.c
+++ b/sound/soc/intel/common/soc-acpi-intel-hsw-bdw-match.c
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0-only
 /*
- * soc-apci-intel-hsw-bdw-match.c - tables and support for ACPI enumeration.
+ * soc-acpi-intel-hsw-bdw-match.c - tables and support for ACPI enumeration.
  *
  * Copyright (c) 2017, Intel Corporation.
  */
diff --git a/sound/soc/intel/common/soc-acpi-intel-icl-match.c b/sound/soc/intel/common/soc-acpi-intel-icl-match.c
index 0b430b9b3673..38977669b576 100644
--- a/sound/soc/intel/common/soc-acpi-intel-icl-match.c
+++ b/sound/soc/intel/common/soc-acpi-intel-icl-match.c
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0
 /*
- * soc-apci-intel-icl-match.c - tables and support for ICL ACPI enumeration.
+ * soc-acpi-intel-icl-match.c - tables and support for ICL ACPI enumeration.
  *
  * Copyright (c) 2018, Intel Corporation.
  *
diff --git a/sound/soc/intel/common/soc-acpi-intel-kbl-match.c b/sound/soc/intel/common/soc-acpi-intel-kbl-match.c
index 4b331058e807..e200baa11011 100644
--- a/sound/soc/intel/common/soc-acpi-intel-kbl-match.c
+++ b/sound/soc/intel/common/soc-acpi-intel-kbl-match.c
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0
 /*
- * soc-apci-intel-kbl-match.c - tables and support for KBL ACPI enumeration.
+ * soc-acpi-intel-kbl-match.c - tables and support for KBL ACPI enumeration.
  *
  * Copyright (c) 2018, Intel Corporation.
  *
diff --git a/sound/soc/intel/common/soc-acpi-intel-skl-match.c b/sound/soc/intel/common/soc-acpi-intel-skl-match.c
index 0c9c0edd35b3..42fa40a8d932 100644
--- a/sound/soc/intel/common/soc-acpi-intel-skl-match.c
+++ b/sound/soc/intel/common/soc-acpi-intel-skl-match.c
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0
 /*
- * soc-apci-intel-skl-match.c - tables and support for SKL ACPI enumeration.
+ * soc-acpi-intel-skl-match.c - tables and support for SKL ACPI enumeration.
  *
  * Copyright (c) 2018, Intel Corporation.
  *
diff --git a/sound/soc/intel/skylake/skl-nhlt.c b/sound/soc/intel/skylake/skl-nhlt.c
index 1132109cb992..6f57ceb9efb7 100644
--- a/sound/soc/intel/skylake/skl-nhlt.c
+++ b/sound/soc/intel/skylake/skl-nhlt.c
@@ -9,57 +9,10 @@
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  */
 #include <linux/pci.h>
+#include <sound/intel-nhlt.h>
 #include "skl.h"
 #include "skl-i2s.h"
 
-#define NHLT_ACPI_HEADER_SIG    "NHLT"
-
-/* Unique identification for getting NHLT blobs */
-static guid_t osc_guid =
-        GUID_INIT(0xA69F886E, 0x6CEB, 0x4594,
-                  0xA4, 0x1F, 0x7B, 0x5D, 0xCE, 0x24, 0xC5, 0x53);
-
-
-struct nhlt_acpi_table *skl_nhlt_init(struct device *dev)
-{
-        acpi_handle handle;
-        union acpi_object *obj;
-        struct nhlt_resource_desc  *nhlt_ptr = NULL;
-        struct nhlt_acpi_table *nhlt_table = NULL;
-
-        handle = ACPI_HANDLE(dev);
-        if (!handle) {
-                dev_err(dev, "Didn't find ACPI_HANDLE\n");
-                return NULL;
-        }
-
-        obj = acpi_evaluate_dsm(handle, &osc_guid, 1, 1, NULL);
-        if (obj && obj->type == ACPI_TYPE_BUFFER) {
-                nhlt_ptr = (struct nhlt_resource_desc  *)obj->buffer.pointer;
-                if (nhlt_ptr->length)
-                        nhlt_table = (struct nhlt_acpi_table *)
-                                memremap(nhlt_ptr->min_addr, nhlt_ptr->length,
-                                MEMREMAP_WB);
-                ACPI_FREE(obj);
-                if (nhlt_table && (strncmp(nhlt_table->header.signature,
-                                        NHLT_ACPI_HEADER_SIG,
-                                        strlen(NHLT_ACPI_HEADER_SIG)) != 0)) {
-                        memunmap(nhlt_table);
-                        dev_err(dev, "NHLT ACPI header signature incorrect\n");
-                        return NULL;
-                }
-                return nhlt_table;
-        }
-
-        dev_err(dev, "device specific method to extract NHLT blob failed\n");
-        return NULL;
-}
-
-void skl_nhlt_free(struct nhlt_acpi_table *nhlt)
-{
-        memunmap((void *) nhlt);
-}
-
 static struct nhlt_specific_cfg *skl_get_specific_cfg(
                 struct device *dev, struct nhlt_fmt *fmt,
                 u8 no_ch, u32 rate, u16 bps, u8 linktype)
@@ -162,48 +115,6 @@ struct nhlt_specific_cfg
         return NULL;
 }
 
-int skl_get_dmic_geo(struct skl *skl)
-{
-        struct nhlt_acpi_table *nhlt = (struct nhlt_acpi_table *)skl->nhlt;
-        struct nhlt_endpoint *epnt;
-        struct nhlt_dmic_array_config *cfg;
-        struct device *dev = &skl->pci->dev;
-        unsigned int dmic_geo = 0;
-        u8 j;
-
-        if (!nhlt)
-                return 0;
-
-        epnt = (struct nhlt_endpoint *)nhlt->desc;
-
-        for (j = 0; j < nhlt->endpoint_count; j++) {
-                if (epnt->linktype == NHLT_LINK_DMIC) {
-                        cfg = (struct nhlt_dmic_array_config  *)
-                                        (epnt->config.caps);
-                        switch (cfg->array_type) {
-                        case NHLT_MIC_ARRAY_2CH_SMALL:
-                        case NHLT_MIC_ARRAY_2CH_BIG:
-                                dmic_geo |= MIC_ARRAY_2CH;
-                                break;
-
-                        case NHLT_MIC_ARRAY_4CH_1ST_GEOM:
-                        case NHLT_MIC_ARRAY_4CH_L_SHAPED:
-                        case NHLT_MIC_ARRAY_4CH_2ND_GEOM:
-                                dmic_geo |= MIC_ARRAY_4CH;
-                                break;
-
-                        default:
-                                dev_warn(dev, "undefined DMIC array_type 0x%0x\n",
-                                                cfg->array_type);
-
-                        }
-                }
-                epnt = (struct nhlt_endpoint *)((u8 *)epnt + epnt->length);
-        }
-
-        return dmic_geo;
-}
-
 static void skl_nhlt_trim_space(char *trim)
 {
         char *s = trim;
diff --git a/sound/soc/intel/skylake/skl-ssp-clk.c b/sound/soc/intel/skylake/skl-ssp-clk.c
index 5bb6e40d4d3e..5bfcd46452f9 100644
--- a/sound/soc/intel/skylake/skl-ssp-clk.c
+++ b/sound/soc/intel/skylake/skl-ssp-clk.c
@@ -11,6 +11,7 @@
 #include <linux/platform_device.h>
 #include <linux/clk-provider.h>
 #include <linux/clkdev.h>
+#include <sound/intel-nhlt.h>
 #include "skl.h"
 #include "skl-ssp-clk.h"
 #include "skl-topology.h"
diff --git a/sound/soc/intel/skylake/skl-topology.c b/sound/soc/intel/skylake/skl-topology.c
index 6241e35213af..f8a501cf5fbd 100644
--- a/sound/soc/intel/skylake/skl-topology.c
+++ b/sound/soc/intel/skylake/skl-topology.c
@@ -12,6 +12,7 @@
 #include <linux/types.h>
 #include <linux/firmware.h>
 #include <linux/uuid.h>
+#include <sound/intel-nhlt.h>
 #include <sound/soc.h>
 #include <sound/soc-topology.h>
 #include <uapi/sound/snd_sst_tokens.h>
diff --git a/sound/soc/intel/skylake/skl.c b/sound/soc/intel/skylake/skl.c
index c6d8076dc2fd..239348b0596b 100644
--- a/sound/soc/intel/skylake/skl.c
+++ b/sound/soc/intel/skylake/skl.c
@@ -26,9 +26,11 @@
 #include <sound/hdaudio.h>
 #include <sound/hda_i915.h>
 #include <sound/hda_codec.h>
+#include <sound/intel-nhlt.h>
 #include "skl.h"
 #include "skl-sst-dsp.h"
 #include "skl-sst-ipc.h"
+
 #if IS_ENABLED(CONFIG_SND_SOC_INTEL_SKYLAKE_HDAUDIO_CODEC)
 #include "../../../soc/codecs/hdac_hda.h"
 #endif
@@ -516,7 +518,9 @@ static int skl_find_machine(struct skl *skl, void *driver_data)
 
         if (pdata) {
                 skl->use_tplg_pcm = pdata->use_tplg_pcm;
-                mach->mach_params.dmic_num = skl_get_dmic_geo(skl);
+                mach->mach_params.dmic_num =
+                        intel_nhlt_get_dmic_geo(&skl->pci->dev,
+                                                skl->nhlt);
         }
 
         return 0;
@@ -1028,7 +1032,7 @@ static int skl_probe(struct pci_dev *pci,
 
         device_disable_async_suspend(bus->dev);
 
-        skl->nhlt = skl_nhlt_init(bus->dev);
+        skl->nhlt = intel_nhlt_init(bus->dev);
 
         if (skl->nhlt == NULL) {
 #if !IS_ENABLED(CONFIG_SND_SOC_INTEL_SKYLAKE_HDAUDIO_CODEC)
@@ -1094,7 +1098,7 @@ out_dsp_free:
 out_clk_free:
         skl_clock_device_unregister(skl);
 out_nhlt_free:
-        skl_nhlt_free(skl->nhlt);
+        intel_nhlt_free(skl->nhlt);
 out_free:
         skl_free(bus);
 
@@ -1143,7 +1147,7 @@ static void skl_remove(struct pci_dev *pci)
         skl_dmic_device_unregister(skl);
         skl_clock_device_unregister(skl);
         skl_nhlt_remove_sysfs(skl);
-        skl_nhlt_free(skl->nhlt);
+        intel_nhlt_free(skl->nhlt);
         skl_free(bus);
         dev_set_drvdata(&pci->dev, NULL);
 }
diff --git a/sound/soc/intel/skylake/skl.h b/sound/soc/intel/skylake/skl.h
index 6070666a6392..f4dd6c767993 100644
--- a/sound/soc/intel/skylake/skl.h
+++ b/sound/soc/intel/skylake/skl.h
@@ -16,7 +16,6 @@
 #include <sound/hdaudio_ext.h>
 #include <sound/hda_codec.h>
 #include <sound/soc.h>
-#include "skl-nhlt.h"
 #include "skl-ssp-clk.h"
 
 #define SKL_SUSPEND_DELAY 2000
@@ -129,13 +128,10 @@ struct skl_dsp_ops {
 int skl_platform_unregister(struct device *dev);
 int skl_platform_register(struct device *dev);
 
-struct nhlt_acpi_table *skl_nhlt_init(struct device *dev);
-void skl_nhlt_free(struct nhlt_acpi_table *addr);
 struct nhlt_specific_cfg *skl_get_ep_blob(struct skl *skl, u32 instance,
                                         u8 link_type, u8 s_fmt, u8 no_ch,
                                         u32 s_rate, u8 dirn, u8 dev_type);
 
-int skl_get_dmic_geo(struct skl *skl);
 int skl_nhlt_update_topology_bin(struct skl *skl);
 int skl_init_dsp(struct skl *skl);
 int skl_free_dsp(struct skl *skl);
diff --git a/sound/soc/qcom/apq8016_sbc.c b/sound/soc/qcom/apq8016_sbc.c
index f60a71990f66..ac75838bbfab 100644
--- a/sound/soc/qcom/apq8016_sbc.c
+++ b/sound/soc/qcom/apq8016_sbc.c
@@ -150,17 +150,17 @@ static struct apq8016_sbc_data *apq8016_sbc_parse_of(struct snd_soc_card *card)
 
         link = data->dai_link;
 
-        dlc = devm_kzalloc(dev, 2 * sizeof(*dlc), GFP_KERNEL);
-        if (!dlc)
-                return ERR_PTR(-ENOMEM);
+        for_each_child_of_node(node, np) {
+                dlc = devm_kzalloc(dev, 2 * sizeof(*dlc), GFP_KERNEL);
+                if (!dlc)
+                        return ERR_PTR(-ENOMEM);
 
-        link->cpus      = &dlc[0];
-        link->platforms = &dlc[1];
+                link->cpus      = &dlc[0];
+                link->platforms = &dlc[1];
 
-        link->num_cpus          = 1;
-        link->num_platforms     = 1;
+                link->num_cpus          = 1;
+                link->num_platforms     = 1;
 
-        for_each_child_of_node(node, np) {
                 cpu = of_get_child_by_name(np, "cpu");
                 codec = of_get_child_by_name(np, "codec");
 
diff --git a/sound/soc/rockchip/rockchip_i2s.c b/sound/soc/rockchip/rockchip_i2s.c
index 0a34d0eb8dba..88ebaf6e1880 100644
--- a/sound/soc/rockchip/rockchip_i2s.c
+++ b/sound/soc/rockchip/rockchip_i2s.c
@@ -326,7 +326,6 @@ static int rockchip_i2s_hw_params(struct snd_pcm_substream *substream,
                 val |= I2S_CHN_4;
                 break;
         case 2:
-        case 1:
                 val |= I2S_CHN_2;
                 break;
         default:
@@ -459,7 +458,7 @@ static struct snd_soc_dai_driver rockchip_i2s_dai = {
         },
         .capture = {
                 .stream_name = "Capture",
-                .channels_min = 1,
+                .channels_min = 2,
                 .channels_max = 2,
                 .rates = SNDRV_PCM_RATE_8000_192000,
                 .formats = (SNDRV_PCM_FMTBIT_S8 |
@@ -659,7 +658,7 @@ static int rockchip_i2s_probe(struct platform_device *pdev)
         }
 
         if (!of_property_read_u32(node, "rockchip,capture-channels", &val)) {
-                if (val >= 1 && val <= 8)
+                if (val >= 2 && val <= 8)
                         soc_dai->capture.channels_max = val;
         }
 
diff --git a/sound/soc/rockchip/rockchip_max98090.c b/sound/soc/rockchip/rockchip_max98090.c
index c5fc24675a33..782e534d4c0d 100644
--- a/sound/soc/rockchip/rockchip_max98090.c
+++ b/sound/soc/rockchip/rockchip_max98090.c
@@ -61,6 +61,37 @@ static const struct snd_kcontrol_new rk_mc_controls[] = {
         SOC_DAPM_PIN_SWITCH("Speaker"),
 };
 
+static int rk_jack_event(struct notifier_block *nb, unsigned long event,
+                         void *data)
+{
+        struct snd_soc_jack *jack = (struct snd_soc_jack *)data;
+        struct snd_soc_dapm_context *dapm = &jack->card->dapm;
+
+        if (event & SND_JACK_MICROPHONE)
+                snd_soc_dapm_force_enable_pin(dapm, "MICBIAS");
+        else
+                snd_soc_dapm_disable_pin(dapm, "MICBIAS");
+
+        snd_soc_dapm_sync(dapm);
+
+        return 0;
+}
+
+static struct notifier_block rk_jack_nb = {
+        .notifier_call = rk_jack_event,
+};
+
+static int rk_init(struct snd_soc_pcm_runtime *runtime)
+{
+        /*
+         * The jack has already been created in the rk_98090_headset_init()
+         * function.
+         */
+        snd_soc_jack_notifier_register(&headset_jack, &rk_jack_nb);
+
+        return 0;
+}
+
 static int rk_aif1_hw_params(struct snd_pcm_substream *substream,
                              struct snd_pcm_hw_params *params)
 {
@@ -119,6 +150,7 @@ SND_SOC_DAILINK_DEFS(hifi,
 static struct snd_soc_dai_link rk_dailink = {
         .name = "max98090",
         .stream_name = "Audio",
+        .init = rk_init,
         .ops = &rk_aif1_ops,
         /* set max98090 as slave */
         .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
diff --git a/sound/soc/samsung/odroid.c b/sound/soc/samsung/odroid.c
index dfb6e460e7eb..f0f5fa9c27d3 100644
--- a/sound/soc/samsung/odroid.c
+++ b/sound/soc/samsung/odroid.c
@@ -284,9 +284,8 @@ static int odroid_audio_probe(struct platform_device *pdev)
         }
 
         of_node_put(cpu);
-        of_node_put(codec);
         if (ret < 0)
-                return ret;
+                goto err_put_node;
 
         ret = snd_soc_of_get_dai_link_codecs(dev, codec, codec_link);
         if (ret < 0)
@@ -309,7 +308,6 @@ static int odroid_audio_probe(struct platform_device *pdev)
                 ret = PTR_ERR(priv->clk_i2s_bus);
                 goto err_put_sclk;
         }
-        of_node_put(cpu_dai);
 
         ret = devm_snd_soc_register_card(dev, card);
         if (ret < 0) {
@@ -317,6 +315,8 @@ static int odroid_audio_probe(struct platform_device *pdev)
                 goto err_put_clk_i2s;
         }
 
+        of_node_put(cpu_dai);
+        of_node_put(codec);
         return 0;
 
 err_put_clk_i2s:
@@ -326,6 +326,8 @@ err_put_sclk:
 err_put_cpu_dai:
         of_node_put(cpu_dai);
         snd_soc_of_put_dai_link_codecs(codec_link);
+err_put_node:
+        of_node_put(codec);
         return ret;
 }
 
diff --git a/sound/soc/soc-core.c b/sound/soc/soc-core.c
index fd6eaae6c0ed..44f899b970c2 100644
--- a/sound/soc/soc-core.c
+++ b/sound/soc/soc-core.c
@@ -1515,8 +1515,11 @@ static int soc_probe_link_dais(struct snd_soc_card *card,
                 }
         }
 
-        if (dai_link->dai_fmt)
-                snd_soc_runtime_set_dai_fmt(rtd, dai_link->dai_fmt);
+        if (dai_link->dai_fmt) {
+                ret = snd_soc_runtime_set_dai_fmt(rtd, dai_link->dai_fmt);
+                if (ret)
+                        return ret;
+        }
 
         ret = soc_post_component_init(rtd, dai_link->name);
         if (ret)
diff --git a/sound/soc/soc-dapm.c b/sound/soc/soc-dapm.c
index f013b24c050a..2790c00735f3 100644
--- a/sound/soc/soc-dapm.c
+++ b/sound/soc/soc-dapm.c
@@ -1157,8 +1157,8 @@ static __always_inline int is_connected_ep(struct snd_soc_dapm_widget *widget,
                 list_add_tail(&widget->work_list, list);
 
         if (custom_stop_condition && custom_stop_condition(widget, dir)) {
-                widget->endpoints[dir] = 1;
-                return widget->endpoints[dir];
+                list = NULL;
+                custom_stop_condition = NULL;
         }
 
         if ((widget->is_ep & SND_SOC_DAPM_DIR_TO_EP(dir)) && widget->connected) {
@@ -1195,8 +1195,8 @@ static __always_inline int is_connected_ep(struct snd_soc_dapm_widget *widget,
  *
  * Optionally, can be supplied with a function acting as a stopping condition.
  * This function takes the dapm widget currently being examined and the walk
- * direction as an arguments, it should return true if the walk should be
- * stopped and false otherwise.
+ * direction as an arguments, it should return true if widgets from that point
+ * in the graph onwards should not be added to the widget list.
  */
 static int is_connected_output_ep(struct snd_soc_dapm_widget *widget,
         struct list_head *list,
@@ -3706,6 +3706,8 @@ request_failed:
                 dev_err(dapm->dev, "ASoC: Failed to request %s: %d\n",
                         w->name, ret);
 
+        kfree_const(w->sname);
+        kfree(w);
         return ERR_PTR(ret);
 }
 
diff --git a/sound/soc/sof/intel/cnl.c b/sound/soc/sof/intel/cnl.c
index f2b392998f20..ffd8d4394537 100644
--- a/sound/soc/sof/intel/cnl.c
+++ b/sound/soc/sof/intel/cnl.c
@@ -101,8 +101,8 @@ static irqreturn_t cnl_ipc_irq_thread(int irq, void *context)
                 /*
                  * This interrupt is not shared so no need to return IRQ_NONE.
                  */
-                dev_err_ratelimited(sdev->dev,
-                                    "error: nothing to do in IRQ thread\n");
+                dev_dbg_ratelimited(sdev->dev,
+                                    "nothing to do in IPC IRQ thread\n");
         }
 
         /* re-enable IPC interrupt */
diff --git a/sound/soc/sof/intel/hda-ipc.c b/sound/soc/sof/intel/hda-ipc.c
index 50244b82600c..2ecba91f5219 100644
--- a/sound/soc/sof/intel/hda-ipc.c
+++ b/sound/soc/sof/intel/hda-ipc.c
@@ -224,8 +224,8 @@ irqreturn_t hda_dsp_ipc_irq_thread(int irq, void *context)
                 /*
                  * This interrupt is not shared so no need to return IRQ_NONE.
                  */
-                dev_err_ratelimited(sdev->dev,
-                                    "error: nothing to do in IRQ thread\n");
+                dev_dbg_ratelimited(sdev->dev,
+                                    "nothing to do in IPC IRQ thread\n");
         }
 
         /* re-enable IPC interrupt */
diff --git a/sound/soc/sunxi/sun4i-i2s.c b/sound/soc/sunxi/sun4i-i2s.c
index 9b2232908b65..7fa5c61169db 100644
--- a/sound/soc/sunxi/sun4i-i2s.c
+++ b/sound/soc/sunxi/sun4i-i2s.c
@@ -1002,8 +1002,8 @@ static const struct sun4i_i2s_quirks sun50i_a64_codec_i2s_quirks = {
         .field_rxchanmap        = REG_FIELD(SUN4I_I2S_RX_CHAN_MAP_REG, 0, 31),
         .field_txchansel        = REG_FIELD(SUN4I_I2S_TX_CHAN_SEL_REG, 0, 2),
         .field_rxchansel        = REG_FIELD(SUN4I_I2S_RX_CHAN_SEL_REG, 0, 2),
-        .get_sr                 = sun8i_i2s_get_sr_wss,
-        .get_wss                = sun8i_i2s_get_sr_wss,
+        .get_sr                 = sun4i_i2s_get_sr,
+        .get_wss                = sun4i_i2s_get_wss,
 };
 
 static int sun4i_i2s_init_regmap_fields(struct device *dev,
diff --git a/sound/soc/ti/davinci-mcasp.c b/sound/soc/ti/davinci-mcasp.c
index ac59b509ead5..bc7bf15ed7a4 100644
--- a/sound/soc/ti/davinci-mcasp.c
+++ b/sound/soc/ti/davinci-mcasp.c
@@ -195,7 +195,7 @@ static inline void mcasp_set_axr_pdir(struct davinci_mcasp *mcasp, bool enable)
 {
         u32 bit;
 
-        for_each_set_bit(bit, &mcasp->pdir, PIN_BIT_AFSR) {
+        for_each_set_bit(bit, &mcasp->pdir, PIN_BIT_AMUTE) {
                 if (enable)
                         mcasp_set_bits(mcasp, DAVINCI_MCASP_PDIR_REG, BIT(bit));
                 else
@@ -223,6 +223,7 @@ static void mcasp_start_rx(struct davinci_mcasp *mcasp)
         if (mcasp_is_synchronous(mcasp)) {
                 mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, TXHCLKRST);
                 mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, TXCLKRST);
+                mcasp_set_clk_pdir(mcasp, true);
         }
 
         /* Activate serializer(s) */
@@ -1256,6 +1257,28 @@ static int davinci_mcasp_trigger(struct snd_pcm_substream *substream,
         return ret;
 }
 
+static int davinci_mcasp_hw_rule_slot_width(struct snd_pcm_hw_params *params,
+                                            struct snd_pcm_hw_rule *rule)
+{
+        struct davinci_mcasp_ruledata *rd = rule->private;
+        struct snd_mask *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
+        struct snd_mask nfmt;
+        int i, slot_width;
+
+        snd_mask_none(&nfmt);
+        slot_width = rd->mcasp->slot_width;
+
+        for (i = 0; i <= SNDRV_PCM_FORMAT_LAST; i++) {
+                if (snd_mask_test(fmt, i)) {
+                        if (snd_pcm_format_width(i) <= slot_width) {
+                                snd_mask_set(&nfmt, i);
+                        }
+                }
+        }
+
+        return snd_mask_refine(fmt, &nfmt);
+}
+
 static const unsigned int davinci_mcasp_dai_rates[] = {
         8000, 11025, 16000, 22050, 32000, 44100, 48000, 64000,
         88200, 96000, 176400, 192000,
@@ -1377,7 +1400,7 @@ static int davinci_mcasp_startup(struct snd_pcm_substream *substream,
         struct davinci_mcasp_ruledata *ruledata =
                                         &mcasp->ruledata[substream->stream];
         u32 max_channels = 0;
-        int i, dir;
+        int i, dir, ret;
         int tdm_slots = mcasp->tdm_slots;
 
         /* Do not allow more then one stream per direction */
@@ -1406,6 +1429,7 @@ static int davinci_mcasp_startup(struct snd_pcm_substream *substream,
                         max_channels++;
         }
         ruledata->serializers = max_channels;
+        ruledata->mcasp = mcasp;
         max_channels *= tdm_slots;
         /*
          * If the already active stream has less channels than the calculated
@@ -1431,20 +1455,22 @@ static int davinci_mcasp_startup(struct snd_pcm_substream *substream,
                                    0, SNDRV_PCM_HW_PARAM_CHANNELS,
                                    &mcasp->chconstr[substream->stream]);
 
-        if (mcasp->slot_width)
-                snd_pcm_hw_constraint_minmax(substream->runtime,
-                                             SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
-                                             8, mcasp->slot_width);
+        if (mcasp->slot_width) {
+                /* Only allow formats require <= slot_width bits on the bus */
+                ret = snd_pcm_hw_rule_add(substream->runtime, 0,
+                                          SNDRV_PCM_HW_PARAM_FORMAT,
+                                          davinci_mcasp_hw_rule_slot_width,
+                                          ruledata,
+                                          SNDRV_PCM_HW_PARAM_FORMAT, -1);
+                if (ret)
+                        return ret;
+        }
 
         /*
          * If we rely on implicit BCLK divider setting we should
          * set constraints based on what we can provide.
          */
         if (mcasp->bclk_master && mcasp->bclk_div == 0 && mcasp->sysclk_freq) {
-                int ret;
-
-                ruledata->mcasp = mcasp;
-
                 ret = snd_pcm_hw_rule_add(substream->runtime, 0,
                                           SNDRV_PCM_HW_PARAM_RATE,
                                           davinci_mcasp_hw_rule_rate,
diff --git a/sound/sparc/dbri.c b/sound/sparc/dbri.c
index 010113156239..6e065d44060e 100644
--- a/sound/sparc/dbri.c
+++ b/sound/sparc/dbri.c
@@ -580,12 +580,16 @@ static __u32 reverse_bytes(__u32 b, int len)
         switch (len) {
         case 32:
                 b = ((b & 0xffff0000) >> 16) | ((b & 0x0000ffff) << 16);
+                /* fall through */
         case 16:
                 b = ((b & 0xff00ff00) >> 8) | ((b & 0x00ff00ff) << 8);
+                /* fall through */
         case 8:
                 b = ((b & 0xf0f0f0f0) >> 4) | ((b & 0x0f0f0f0f) << 4);
+                /* fall through */
         case 4:
                 b = ((b & 0xcccccccc) >> 2) | ((b & 0x33333333) << 2);
+                /* fall through */
         case 2:
                 b = ((b & 0xaaaaaaaa) >> 1) | ((b & 0x55555555) << 1);
         case 1:
diff --git a/sound/usb/Makefile b/sound/usb/Makefile
index e1ce257ab705..f4b7384caa9d 100644
--- a/sound/usb/Makefile
+++ b/sound/usb/Makefile
@@ -11,6 +11,7 @@ snd-usb-audio-objs := 	card.o \
                         mixer.o \
                         mixer_quirks.o \
                         mixer_scarlett.o \
+                        mixer_scarlett_gen2.o \
                         mixer_us16x08.o \
                         pcm.o \
                         power.o \
diff --git a/sound/usb/helper.c b/sound/usb/helper.c
index 71d5f540334a..4c12cc5b53fd 100644
--- a/sound/usb/helper.c
+++ b/sound/usb/helper.c
@@ -72,7 +72,7 @@ int snd_usb_pipe_sanity_check(struct usb_device *dev, unsigned int pipe)
         struct usb_host_endpoint *ep;
 
         ep = usb_pipe_endpoint(dev, pipe);
-        if (usb_pipetype(pipe) != pipetypes[usb_endpoint_type(&ep->desc)])
+        if (!ep || usb_pipetype(pipe) != pipetypes[usb_endpoint_type(&ep->desc)])
                 return -EINVAL;
         return 0;
 }
diff --git a/sound/usb/line6/driver.c b/sound/usb/line6/driver.c
index ab2ec896f49c..b5a3f754a4f1 100644
--- a/sound/usb/line6/driver.c
+++ b/sound/usb/line6/driver.c
@@ -342,7 +342,7 @@ int line6_read_data(struct usb_line6 *line6, unsigned address, void *data,
         if (address > 0xffff || datalen > 0xff)
                 return -EINVAL;
 
-        len = kmalloc(sizeof(*len), GFP_KERNEL);
+        len = kmalloc(1, GFP_KERNEL);
         if (!len)
                 return -ENOMEM;
 
@@ -418,7 +418,7 @@ int line6_write_data(struct usb_line6 *line6, unsigned address, void *data,
         if (address > 0xffff || datalen > 0xffff)
                 return -EINVAL;
 
-        status = kmalloc(sizeof(*status), GFP_KERNEL);
+        status = kmalloc(1, GFP_KERNEL);
         if (!status)
                 return -ENOMEM;
 
diff --git a/sound/usb/line6/podhd.c b/sound/usb/line6/podhd.c
index f0662bd4e50f..27bf61c177c0 100644
--- a/sound/usb/line6/podhd.c
+++ b/sound/usb/line6/podhd.c
@@ -368,7 +368,7 @@ static const struct line6_properties podhd_properties_table[] = {
                 .name = "POD HD500",
                 .capabilities   = LINE6_CAP_PCM
                                 | LINE6_CAP_HWMON,
-                .altsetting = 1,
+                .altsetting = 0,
                 .ep_ctrl_r = 0x81,
                 .ep_ctrl_w = 0x01,
                 .ep_audio_r = 0x86,
diff --git a/sound/usb/line6/variax.c b/sound/usb/line6/variax.c
index 0d24c72c155f..ed158f04de80 100644
--- a/sound/usb/line6/variax.c
+++ b/sound/usb/line6/variax.c
@@ -244,5 +244,5 @@ static struct usb_driver variax_driver = {
 
 module_usb_driver(variax_driver);
 
-MODULE_DESCRIPTION("Vairax Workbench USB driver");
+MODULE_DESCRIPTION("Variax Workbench USB driver");
 MODULE_LICENSE("GPL");
diff --git a/sound/usb/mixer.c b/sound/usb/mixer.c
index 7498b5191b68..7b51ab4c35b0 100644
--- a/sound/usb/mixer.c
+++ b/sound/usb/mixer.c
@@ -3509,6 +3509,8 @@ void snd_usb_mixer_disconnect(struct usb_mixer_interface *mixer)
                 usb_kill_urb(mixer->urb);
         if (mixer->rc_urb)
                 usb_kill_urb(mixer->rc_urb);
+        if (mixer->private_free)
+                mixer->private_free(mixer);
         mixer->disconnected = true;
 }
 
@@ -3536,6 +3538,8 @@ static int snd_usb_mixer_activate(struct usb_mixer_interface *mixer)
 int snd_usb_mixer_suspend(struct usb_mixer_interface *mixer)
 {
         snd_usb_mixer_inactivate(mixer);
+        if (mixer->private_suspend)
+                mixer->private_suspend(mixer);
         return 0;
 }
 
diff --git a/sound/usb/mixer.h b/sound/usb/mixer.h
index 394cd9107507..37e1b234c802 100644
--- a/sound/usb/mixer.h
+++ b/sound/usb/mixer.h
@@ -28,6 +28,10 @@ struct usb_mixer_interface {
         struct media_mixer_ctl *media_mixer_ctl;
 
         bool disconnected;
+
+        void *private_data;
+        void (*private_free)(struct usb_mixer_interface *mixer);
+        void (*private_suspend)(struct usb_mixer_interface *mixer);
 };
 
 #define MAX_CHANNELS    16      /* max logical channels */
diff --git a/sound/usb/mixer_quirks.c b/sound/usb/mixer_quirks.c
index 199fa157a411..70805c15b0b5 100644
--- a/sound/usb/mixer_quirks.c
+++ b/sound/usb/mixer_quirks.c
@@ -32,6 +32,7 @@
 #include "mixer.h"
 #include "mixer_quirks.h"
 #include "mixer_scarlett.h"
+#include "mixer_scarlett_gen2.h"
 #include "mixer_us16x08.h"
 #include "helper.h"
 
@@ -2258,6 +2259,12 @@ int snd_usb_mixer_apply_create_quirk(struct usb_mixer_interface *mixer)
                 err = snd_scarlett_controls_create(mixer);
                 break;
 
+        case USB_ID(0x1235, 0x8203): /* Focusrite Scarlett 6i6 2nd Gen */
+        case USB_ID(0x1235, 0x8204): /* Focusrite Scarlett 18i8 2nd Gen */
+        case USB_ID(0x1235, 0x8201): /* Focusrite Scarlett 18i20 2nd Gen */
+                err = snd_scarlett_gen2_controls_create(mixer);
+                break;
+
         case USB_ID(0x041e, 0x323b): /* Creative Sound Blaster E1 */
                 err = snd_soundblaster_e1_switch_create(mixer);
                 break;
diff --git a/sound/usb/mixer_scarlett_gen2.c b/sound/usb/mixer_scarlett_gen2.c
new file mode 100644
index 000000000000..7d460b1f1735
--- /dev/null
+++ b/sound/usb/mixer_scarlett_gen2.c
@@ -0,0 +1,2075 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ *   Focusrite Scarlett 6i6/18i8/18i20 Gen 2 Driver for ALSA
+ *
+ *   Copyright (c) 2018-2019 by Geoffrey D. Bennett <g at b4.vu>
+ *
+ *   Based on the Scarlett (Gen 1) Driver for ALSA:
+ *
+ *   Copyright (c) 2013 by Tobias Hoffmann
+ *   Copyright (c) 2013 by Robin Gareus <robin at gareus.org>
+ *   Copyright (c) 2002 by Takashi Iwai <tiwai at suse.de>
+ *   Copyright (c) 2014 by Chris J Arges <chris.j.arges at canonical.com>
+ *
+ *   Many codes borrowed from audio.c by
+ *     Alan Cox (alan at lxorguk.ukuu.org.uk)
+ *     Thomas Sailer (sailer at ife.ee.ethz.ch)
+ *
+ *   Code cleanup:
+ *   David Henningsson <david.henningsson at canonical.com>
+ */
+
+/* Mixer Interface for the Focusrite Scarlett 6i6/18i8/18i20 Gen 2 audio
+ * interface. Based on the Gen 1 driver and rewritten.
+ */
+
+/* The protocol was reverse engineered by looking at the communication
+ * between Focusrite Control 2.3.4 and the Focusrite(R) Scarlett 18i20
+ * (firmware 1083) using usbmon in July-August 2018.
+ *
+ * Scarlett 18i8 support added in April 2019.
+ *
+ * Scarlett 6i6 support added in June 2019 (thanks to Martin Wittmann
+ * for providing usbmon output and testing).
+ *
+ * This ALSA mixer gives access to:
+ *  - input, output, mixer-matrix muxes
+ *  - 18x10 mixer-matrix gain stages
+ *  - gain/volume controls
+ *  - level meters
+ *  - line/inst level and pad controls
+ *
+ * <ditaa>
+ *    /--------------\    18chn            20chn     /--------------\
+ *    | Hardware  in +--+------\    /-------------+--+ ALSA PCM out |
+ *    \--------------/  |      |    |             |  \--------------/
+ *                      |      |    |    /-----\  |
+ *                      |      |    |    |     |  |
+ *                      |      v    v    v     |  |
+ *                      |   +---------------+  |  |
+ *                      |    \ Matrix  Mux /   |  |
+ *                      |     +-----+-----+    |  |
+ *                      |           |          |  |
+ *                      |           |18chn     |  |
+ *                      |           |          |  |
+ *                      |           |     10chn|  |
+ *                      |           v          |  |
+ *                      |     +------------+   |  |
+ *                      |     | Mixer      |   |  |
+ *                      |     |     Matrix |   |  |
+ *                      |     |            |   |  |
+ *                      |     | 18x10 Gain |   |  |
+ *                      |     |   stages   |   |  |
+ *                      |     +-----+------+   |  |
+ *                      |           |          |  |
+ *                      |18chn      |10chn     |  |20chn
+ *                      |           |          |  |
+ *                      |           +----------/  |
+ *                      |           |             |
+ *                      v           v             v
+ *                      ===========================
+ *               +---------------+       +--—------------+
+ *                \ Output  Mux /         \ Capture Mux /
+ *                 +---+---+---+           +-----+-----+
+ *                     |   |                     |
+ *                10chn|   |                     |18chn
+ *                     |   |                     |
+ *  /--------------\   |   |                     |   /--------------\
+ *  | S/PDIF, ADAT |<--/   |10chn                \-->| ALSA PCM in  |
+ *  | Hardware out |       |                         \--------------/
+ *  \--------------/       |
+ *                         v
+ *                  +-------------+    Software gain per channel.
+ *                  | Master Gain |<-- 18i20 only: Switch per channel
+ *                  +------+------+    to select HW or SW gain control.
+ *                         |
+ *                         |10chn
+ *  /--------------\       |
+ *  | Analogue     |<------/
+ *  | Hardware out |
+ *  \--------------/
+ * </ditaa>
+ *
+ */
+
+#include <linux/slab.h>
+#include <linux/usb.h>
+#include <linux/moduleparam.h>
+
+#include <sound/control.h>
+#include <sound/tlv.h>
+
+#include "usbaudio.h"
+#include "mixer.h"
+#include "helper.h"
+
+#include "mixer_scarlett_gen2.h"
+
+/* device_setup value to enable */
+#define SCARLETT2_ENABLE 0x01
+
+/* some gui mixers can't handle negative ctl values */
+#define SCARLETT2_VOLUME_BIAS 127
+
+/* mixer range from -80dB to +6dB in 0.5dB steps */
+#define SCARLETT2_MIXER_MIN_DB -80
+#define SCARLETT2_MIXER_BIAS (-SCARLETT2_MIXER_MIN_DB * 2)
+#define SCARLETT2_MIXER_MAX_DB 6
+#define SCARLETT2_MIXER_MAX_VALUE \
+        ((SCARLETT2_MIXER_MAX_DB - SCARLETT2_MIXER_MIN_DB) * 2)
+
+/* map from (dB + 80) * 2 to mixer value
+ * for dB in 0 .. 172: int(8192 * pow(10, ((dB - 160) / 2 / 20)))
+ */
+static const u16 scarlett2_mixer_values[173] = {
+        0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,
+        2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 8, 8,
+        9, 9, 10, 10, 11, 12, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
+        23, 24, 25, 27, 29, 30, 32, 34, 36, 38, 41, 43, 46, 48, 51,
+        54, 57, 61, 65, 68, 73, 77, 81, 86, 91, 97, 103, 109, 115,
+        122, 129, 137, 145, 154, 163, 173, 183, 194, 205, 217, 230,
+        244, 259, 274, 290, 307, 326, 345, 365, 387, 410, 434, 460,
+        487, 516, 547, 579, 614, 650, 689, 730, 773, 819, 867, 919,
+        973, 1031, 1092, 1157, 1225, 1298, 1375, 1456, 1543, 1634,
+        1731, 1833, 1942, 2057, 2179, 2308, 2445, 2590, 2744, 2906,
+        3078, 3261, 3454, 3659, 3876, 4105, 4349, 4606, 4879, 5168,
+        5475, 5799, 6143, 6507, 6892, 7301, 7733, 8192, 8677, 9191,
+        9736, 10313, 10924, 11571, 12257, 12983, 13752, 14567, 15430,
+        16345
+};
+
+/* Maximum number of analogue outputs */
+#define SCARLETT2_ANALOGUE_MAX 10
+
+/* Maximum number of level and pad switches */
+#define SCARLETT2_LEVEL_SWITCH_MAX 2
+#define SCARLETT2_PAD_SWITCH_MAX 4
+
+/* Maximum number of inputs to the mixer */
+#define SCARLETT2_INPUT_MIX_MAX 18
+
+/* Maximum number of outputs from the mixer */
+#define SCARLETT2_OUTPUT_MIX_MAX 10
+
+/* Maximum size of the data in the USB mux assignment message:
+ * 18 inputs, 20 outputs, 18 matrix inputs, 8 spare
+ */
+#define SCARLETT2_MUX_MAX 64
+
+/* Number of meters:
+ * 18 inputs, 20 outputs, 18 matrix inputs
+ */
+#define SCARLETT2_NUM_METERS 56
+
+/* Hardware port types:
+ * - None (no input to mux)
+ * - Analogue I/O
+ * - S/PDIF I/O
+ * - ADAT I/O
+ * - Mixer I/O
+ * - PCM I/O
+ */
+enum {
+        SCARLETT2_PORT_TYPE_NONE = 0,
+        SCARLETT2_PORT_TYPE_ANALOGUE = 1,
+        SCARLETT2_PORT_TYPE_SPDIF = 2,
+        SCARLETT2_PORT_TYPE_ADAT = 3,
+        SCARLETT2_PORT_TYPE_MIX = 4,
+        SCARLETT2_PORT_TYPE_PCM = 5,
+        SCARLETT2_PORT_TYPE_COUNT = 6,
+};
+
+/* Count of total I/O and number available at each sample rate */
+enum {
+        SCARLETT2_PORT_IN = 0,
+        SCARLETT2_PORT_OUT = 1,
+        SCARLETT2_PORT_OUT_44 = 2,
+        SCARLETT2_PORT_OUT_88 = 3,
+        SCARLETT2_PORT_OUT_176 = 4,
+        SCARLETT2_PORT_DIRECTIONS = 5,
+};
+
+/* Hardware buttons on the 18i20 */
+#define SCARLETT2_BUTTON_MAX 2
+
+static const char *const scarlett2_button_names[SCARLETT2_BUTTON_MAX] = {
+        "Mute", "Dim"
+};
+
+/* Description of each hardware port type:
+ * - id: hardware ID for this port type
+ * - num: number of sources/destinations of this port type
+ * - src_descr: printf format string for mux input selections
+ * - src_num_offset: added to channel number for the fprintf
+ * - dst_descr: printf format string for mixer controls
+ */
+struct scarlett2_ports {
+        u16 id;
+        int num[SCARLETT2_PORT_DIRECTIONS];
+        const char * const src_descr;
+        int src_num_offset;
+        const char * const dst_descr;
+};
+
+struct scarlett2_device_info {
+        u8 line_out_hw_vol; /* line out hw volume is sw controlled */
+        u8 button_count; /* number of buttons */
+        u8 level_input_count; /* inputs with level selectable */
+        u8 pad_input_count; /* inputs with pad selectable */
+        const char * const line_out_descrs[SCARLETT2_ANALOGUE_MAX];
+        struct scarlett2_ports ports[SCARLETT2_PORT_TYPE_COUNT];
+};
+
+struct scarlett2_mixer_data {
+        struct usb_mixer_interface *mixer;
+        struct mutex usb_mutex; /* prevent sending concurrent USB requests */
+        struct mutex data_mutex; /* lock access to this data */
+        struct delayed_work work;
+        const struct scarlett2_device_info *info;
+        int num_mux_srcs;
+        u16 scarlett2_seq;
+        u8 vol_updated;
+        u8 master_vol;
+        u8 vol[SCARLETT2_ANALOGUE_MAX];
+        u8 vol_sw_hw_switch[SCARLETT2_ANALOGUE_MAX];
+        u8 level_switch[SCARLETT2_LEVEL_SWITCH_MAX];
+        u8 pad_switch[SCARLETT2_PAD_SWITCH_MAX];
+        u8 buttons[SCARLETT2_BUTTON_MAX];
+        struct snd_kcontrol *master_vol_ctl;
+        struct snd_kcontrol *vol_ctls[SCARLETT2_ANALOGUE_MAX];
+        struct snd_kcontrol *button_ctls[SCARLETT2_BUTTON_MAX];
+        u8 mux[SCARLETT2_MUX_MAX];
+        u8 mix[SCARLETT2_INPUT_MIX_MAX * SCARLETT2_OUTPUT_MIX_MAX];
+};
+
+/*** Model-specific data ***/
+
+static const struct scarlett2_device_info s6i6_gen2_info = {
+        /* The first two analogue inputs can be switched between line
+         * and instrument levels.
+         */
+        .level_input_count = 2,
+
+        /* The first two analogue inputs have an optional pad. */
+        .pad_input_count = 2,
+
+        .line_out_descrs = {
+                "Monitor L",
+                "Monitor R",
+                "Headphones L",
+                "Headphones R",
+        },
+
+        .ports = {
+                {
+                        .id = 0x000,
+                        .num = { 1, 0, 8, 8, 8 },
+                        .src_descr = "Off",
+                        .src_num_offset = 0,
+                },
+                {
+                        .id = 0x080,
+                        .num = { 4, 4, 4, 4, 4 },
+                        .src_descr = "Analogue %d",
+                        .src_num_offset = 1,
+                        .dst_descr = "Analogue Output %02d Playback"
+                },
+                {
+                        .id = 0x180,
+                        .num = { 2, 2, 2, 2, 2 },
+                        .src_descr = "S/PDIF %d",
+                        .src_num_offset = 1,
+                        .dst_descr = "S/PDIF Output %d Playback"
+                },
+                {
+                        .id = 0x300,
+                        .num = { 10, 18, 18, 18, 18 },
+                        .src_descr = "Mix %c",
+                        .src_num_offset = 65,
+                        .dst_descr = "Mixer Input %02d Capture"
+                },
+                {
+                        .id = 0x600,
+                        .num = { 6, 6, 6, 6, 6 },
+                        .src_descr = "PCM %d",
+                        .src_num_offset = 1,
+                        .dst_descr = "PCM %02d Capture"
+                },
+        },
+};
+
+static const struct scarlett2_device_info s18i8_gen2_info = {
+        /* The first two analogue inputs can be switched between line
+         * and instrument levels.
+         */
+        .level_input_count = 2,
+
+        /* The first four analogue inputs have an optional pad. */
+        .pad_input_count = 4,
+
+        .line_out_descrs = {
+                "Monitor L",
+                "Monitor R",
+                "Headphones 1 L",
+                "Headphones 1 R",
+                "Headphones 2 L",
+                "Headphones 2 R",
+        },
+
+        .ports = {
+                {
+                        .id = 0x000,
+                        .num = { 1, 0, 8, 8, 4 },
+                        .src_descr = "Off",
+                        .src_num_offset = 0,
+                },
+                {
+                        .id = 0x080,
+                        .num = { 8, 6, 6, 6, 6 },
+                        .src_descr = "Analogue %d",
+                        .src_num_offset = 1,
+                        .dst_descr = "Analogue Output %02d Playback"
+                },
+                {
+                        /* S/PDIF outputs aren't available at 192KHz
+                         * but are included in the USB mux I/O
+                         * assignment message anyway
+                         */
+                        .id = 0x180,
+                        .num = { 2, 2, 2, 2, 2 },
+                        .src_descr = "S/PDIF %d",
+                        .src_num_offset = 1,
+                        .dst_descr = "S/PDIF Output %d Playback"
+                },
+                {
+                        .id = 0x200,
+                        .num = { 8, 0, 0, 0, 0 },
+                        .src_descr = "ADAT %d",
+                        .src_num_offset = 1,
+                },
+                {
+                        .id = 0x300,
+                        .num = { 10, 18, 18, 18, 18 },
+                        .src_descr = "Mix %c",
+                        .src_num_offset = 65,
+                        .dst_descr = "Mixer Input %02d Capture"
+                },
+                {
+                        .id = 0x600,
+                        .num = { 20, 18, 18, 14, 10 },
+                        .src_descr = "PCM %d",
+                        .src_num_offset = 1,
+                        .dst_descr = "PCM %02d Capture"
+                },
+        },
+};
+
+static const struct scarlett2_device_info s18i20_gen2_info = {
+        /* The analogue line outputs on the 18i20 can be switched
+         * between software and hardware volume control
+         */
+        .line_out_hw_vol = 1,
+
+        /* Mute and dim buttons */
+        .button_count = 2,
+
+        .line_out_descrs = {
+                "Monitor L",
+                "Monitor R",
+                NULL,
+                NULL,
+                NULL,
+                NULL,
+                "Headphones 1 L",
+                "Headphones 1 R",
+                "Headphones 2 L",
+                "Headphones 2 R",
+        },
+
+        .ports = {
+                {
+                        .id = 0x000,
+                        .num = { 1, 0, 8, 8, 6 },
+                        .src_descr = "Off",
+                        .src_num_offset = 0,
+                },
+                {
+                        .id = 0x080,
+                        .num = { 8, 10, 10, 10, 10 },
+                        .src_descr = "Analogue %d",
+                        .src_num_offset = 1,
+                        .dst_descr = "Analogue Output %02d Playback"
+                },
+                {
+                        /* S/PDIF outputs aren't available at 192KHz
+                         * but are included in the USB mux I/O
+                         * assignment message anyway
+                         */
+                        .id = 0x180,
+                        .num = { 2, 2, 2, 2, 2 },
+                        .src_descr = "S/PDIF %d",
+                        .src_num_offset = 1,
+                        .dst_descr = "S/PDIF Output %d Playback"
+                },
+                {
+                        .id = 0x200,
+                        .num = { 8, 8, 8, 4, 0 },
+                        .src_descr = "ADAT %d",
+                        .src_num_offset = 1,
+                        .dst_descr = "ADAT Output %d Playback"
+                },
+                {
+                        .id = 0x300,
+                        .num = { 10, 18, 18, 18, 18 },
+                        .src_descr = "Mix %c",
+                        .src_num_offset = 65,
+                        .dst_descr = "Mixer Input %02d Capture"
+                },
+                {
+                        .id = 0x600,
+                        .num = { 20, 18, 18, 14, 10 },
+                        .src_descr = "PCM %d",
+                        .src_num_offset = 1,
+                        .dst_descr = "PCM %02d Capture"
+                },
+        },
+};
+
+/* get the starting port index number for a given port type/direction */
+static int scarlett2_get_port_start_num(const struct scarlett2_ports *ports,
+                                        int direction, int port_type)
+{
+        int i, num = 0;
+
+        for (i = 0; i < port_type; i++)
+                num += ports[i].num[direction];
+
+        return num;
+}
+
+/*** USB Interactions ***/
+
+/* Vendor-Specific Interface, Endpoint, MaxPacketSize, Interval */
+#define SCARLETT2_USB_VENDOR_SPECIFIC_INTERFACE 5
+#define SCARLETT2_USB_INTERRUPT_ENDPOINT 4
+#define SCARLETT2_USB_INTERRUPT_MAX_DATA 64
+#define SCARLETT2_USB_INTERRUPT_INTERVAL 3
+
+/* Interrupt flags for volume and mute/dim button changes */
+#define SCARLETT2_USB_INTERRUPT_VOL_CHANGE 0x400000
+#define SCARLETT2_USB_INTERRUPT_BUTTON_CHANGE 0x200000
+
+/* Commands for sending/receiving requests/responses */
+#define SCARLETT2_USB_VENDOR_SPECIFIC_CMD_REQ 2
+#define SCARLETT2_USB_VENDOR_SPECIFIC_CMD_RESP 3
+
+#define SCARLETT2_USB_INIT_SEQ 0x00000000
+#define SCARLETT2_USB_GET_METER_LEVELS 0x00001001
+#define SCARLETT2_USB_SET_MIX 0x00002002
+#define SCARLETT2_USB_SET_MUX 0x00003002
+#define SCARLETT2_USB_GET_DATA 0x00800000
+#define SCARLETT2_USB_SET_DATA 0x00800001
+#define SCARLETT2_USB_DATA_CMD 0x00800002
+#define SCARLETT2_USB_CONFIG_SAVE 6
+
+#define SCARLETT2_USB_VOLUME_STATUS_OFFSET 0x31
+#define SCARLETT2_USB_METER_LEVELS_GET_MAGIC 1
+
+/* volume status is read together (matches scarlett2_config_items[]) */
+struct scarlett2_usb_volume_status {
+        /* mute & dim buttons */
+        u8 buttons[SCARLETT2_BUTTON_MAX];
+
+        u8 pad1;
+
+        /* software volume setting */
+        s16 sw_vol[SCARLETT2_ANALOGUE_MAX];
+
+        /* actual volume of output inc. dim (-18dB) */
+        s16 hw_vol[SCARLETT2_ANALOGUE_MAX];
+
+        u8 pad2[SCARLETT2_ANALOGUE_MAX];
+
+        /* sw (0) or hw (1) controlled */
+        u8 sw_hw_switch[SCARLETT2_ANALOGUE_MAX];
+
+        u8 pad3[6];
+
+        /* front panel volume knob */
+        s16 master_vol;
+} __packed;
+
+/* Configuration parameters that can be read and written */
+enum {
+        SCARLETT2_CONFIG_BUTTONS = 0,
+        SCARLETT2_CONFIG_LINE_OUT_VOLUME = 1,
+        SCARLETT2_CONFIG_SW_HW_SWITCH = 2,
+        SCARLETT2_CONFIG_LEVEL_SWITCH = 3,
+        SCARLETT2_CONFIG_PAD_SWITCH = 4,
+        SCARLETT2_CONFIG_COUNT = 5
+};
+
+/* Location, size, and activation command number for the configuration
+ * parameters
+ */
+struct scarlett2_config {
+        u8 offset;
+        u8 size;
+        u8 activate;
+};
+
+static const struct scarlett2_config
+                scarlett2_config_items[SCARLETT2_CONFIG_COUNT] = {
+        /* Mute/Dim Buttons */
+        {
+                .offset = 0x31,
+                .size = 1,
+                .activate = 2
+        },
+
+        /* Line Out Volume */
+        {
+                .offset = 0x34,
+                .size = 2,
+                .activate = 1
+        },
+
+        /* SW/HW Volume Switch */
+        {
+                .offset = 0x66,
+                .size = 1,
+                .activate = 3
+        },
+
+        /* Level Switch */
+        {
+                .offset = 0x7c,
+                .size = 1,
+                .activate = 7
+        },
+
+        /* Pad Switch */
+        {
+                .offset = 0x84,
+                .size = 1,
+                .activate = 8
+        }
+};
+
+/* proprietary request/response format */
+struct scarlett2_usb_packet {
+        u32 cmd;
+        u16 size;
+        u16 seq;
+        u32 error;
+        u32 pad;
+        u8 data[];
+};
+
+#define SCARLETT2_USB_PACKET_LEN (sizeof(struct scarlett2_usb_packet))
+
+static void scarlett2_fill_request_header(struct scarlett2_mixer_data *private,
+                                          struct scarlett2_usb_packet *req,
+                                          u32 cmd, u16 req_size)
+{
+        /* sequence must go up by 1 for each request */
+        u16 seq = private->scarlett2_seq++;
+
+        req->cmd = cpu_to_le32(cmd);
+        req->size = cpu_to_le16(req_size);
+        req->seq = cpu_to_le16(seq);
+        req->error = 0;
+        req->pad = 0;
+}
+
+/* Send a proprietary format request to the Scarlett interface */
+static int scarlett2_usb(
+        struct usb_mixer_interface *mixer, u32 cmd,
+        void *req_data, u16 req_size, void *resp_data, u16 resp_size)
+{
+        struct scarlett2_mixer_data *private = mixer->private_data;
+        u16 req_buf_size = sizeof(struct scarlett2_usb_packet) + req_size;
+        u16 resp_buf_size = sizeof(struct scarlett2_usb_packet) + resp_size;
+        struct scarlett2_usb_packet *req = NULL, *resp = NULL;
+        int err = 0;
+
+        req = kmalloc(req_buf_size, GFP_KERNEL);
+        if (!req) {
+                err = -ENOMEM;
+                goto error;
+        }
+
+        resp = kmalloc(resp_buf_size, GFP_KERNEL);
+        if (!resp) {
+                err = -ENOMEM;
+                goto error;
+        }
+
+        mutex_lock(&private->usb_mutex);
+
+        /* build request message and send it */
+
+        scarlett2_fill_request_header(private, req, cmd, req_size);
+
+        if (req_size)
+                memcpy(req->data, req_data, req_size);
+
+        err = snd_usb_ctl_msg(mixer->chip->dev,
+                        usb_sndctrlpipe(mixer->chip->dev, 0),
+                        SCARLETT2_USB_VENDOR_SPECIFIC_CMD_REQ,
+                        USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
+                        0,
+                        SCARLETT2_USB_VENDOR_SPECIFIC_INTERFACE,
+                        req,
+                        req_buf_size);
+
+        if (err != req_buf_size) {
+                usb_audio_err(
+                        mixer->chip,
+                        "Scarlett Gen 2 USB request result cmd %x was %d\n",
+                        cmd, err);
+                err = -EINVAL;
+                goto unlock;
+        }
+
+        /* send a second message to get the response */
+
+        err = snd_usb_ctl_msg(mixer->chip->dev,
+                        usb_sndctrlpipe(mixer->chip->dev, 0),
+                        SCARLETT2_USB_VENDOR_SPECIFIC_CMD_RESP,
+                        USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
+                        0,
+                        SCARLETT2_USB_VENDOR_SPECIFIC_INTERFACE,
+                        resp,
+                        resp_buf_size);
+
+        /* validate the response */
+
+        if (err != resp_buf_size) {
+                usb_audio_err(
+                        mixer->chip,
+                        "Scarlett Gen 2 USB response result cmd %x was %d\n",
+                        cmd, err);
+                err = -EINVAL;
+                goto unlock;
+        }
+
+        if (resp->cmd != req->cmd ||
+            resp->seq != req->seq ||
+            resp_size != le16_to_cpu(resp->size) ||
+            resp->error ||
+            resp->pad) {
+                usb_audio_err(
+                        mixer->chip,
+                        "Scarlett Gen 2 USB invalid response; "
+                           "cmd tx/rx %d/%d seq %d/%d size %d/%d "
+                           "error %d pad %d\n",
+                        le16_to_cpu(req->cmd), le16_to_cpu(resp->cmd),
+                        le16_to_cpu(req->seq), le16_to_cpu(resp->seq),
+                        resp_size, le16_to_cpu(resp->size),
+                        le16_to_cpu(resp->error),
+                        le16_to_cpu(resp->pad));
+                err = -EINVAL;
+                goto unlock;
+        }
+
+        if (resp_size > 0)
+                memcpy(resp_data, resp->data, resp_size);
+
+unlock:
+        mutex_unlock(&private->usb_mutex);
+error:
+        kfree(req);
+        kfree(resp);
+        return err;
+}
+
+/* Send SCARLETT2_USB_DATA_CMD SCARLETT2_USB_CONFIG_SAVE */
+static void scarlett2_config_save(struct usb_mixer_interface *mixer)
+{
+        u32 req = cpu_to_le32(SCARLETT2_USB_CONFIG_SAVE);
+
+        scarlett2_usb(mixer, SCARLETT2_USB_DATA_CMD,
+                      &req, sizeof(u32),
+                      NULL, 0);
+}
+
+/* Delayed work to save config */
+static void scarlett2_config_save_work(struct work_struct *work)
+{
+        struct scarlett2_mixer_data *private =
+                container_of(work, struct scarlett2_mixer_data, work.work);
+
+        scarlett2_config_save(private->mixer);
+}
+
+/* Send a USB message to set a configuration parameter (volume level,
+ * sw/hw volume switch, line/inst level switch, or pad switch)
+ */
+static int scarlett2_usb_set_config(
+        struct usb_mixer_interface *mixer,
+        int config_item_num, int index, int value)
+{
+        const struct scarlett2_config config_item =
+               scarlett2_config_items[config_item_num];
+        struct {
+                u32 offset;
+                u32 bytes;
+                s32 value;
+        } __packed req;
+        u32 req2;
+        int err;
+        struct scarlett2_mixer_data *private = mixer->private_data;
+
+        /* Cancel any pending NVRAM save */
+        cancel_delayed_work_sync(&private->work);
+
+        /* Send the configuration parameter data */
+        req.offset = cpu_to_le32(config_item.offset + index * config_item.size);
+        req.bytes = cpu_to_le32(config_item.size);
+        req.value = cpu_to_le32(value);
+        err = scarlett2_usb(mixer, SCARLETT2_USB_SET_DATA,
+                            &req, sizeof(u32) * 2 + config_item.size,
+                            NULL, 0);
+        if (err < 0)
+                return err;
+
+        /* Activate the change */
+        req2 = cpu_to_le32(config_item.activate);
+        err = scarlett2_usb(mixer, SCARLETT2_USB_DATA_CMD,
+                            &req2, sizeof(req2), NULL, 0);
+        if (err < 0)
+                return err;
+
+        /* Schedule the change to be written to NVRAM */
+        schedule_delayed_work(&private->work, msecs_to_jiffies(2000));
+
+        return 0;
+}
+
+/* Send a USB message to get data; result placed in *buf */
+static int scarlett2_usb_get(
+        struct usb_mixer_interface *mixer,
+        int offset, void *buf, int size)
+{
+        struct {
+                u32 offset;
+                u32 size;
+        } __packed req;
+
+        req.offset = cpu_to_le32(offset);
+        req.size = cpu_to_le32(size);
+        return scarlett2_usb(mixer, SCARLETT2_USB_GET_DATA,
+                             &req, sizeof(req), buf, size);
+}
+
+/* Send a USB message to get configuration parameters; result placed in *buf */
+static int scarlett2_usb_get_config(
+        struct usb_mixer_interface *mixer,
+        int config_item_num, int count, void *buf)
+{
+        const struct scarlett2_config config_item =
+               scarlett2_config_items[config_item_num];
+        int size = config_item.size * count;
+
+        return scarlett2_usb_get(mixer, config_item.offset, buf, size);
+}
+
+/* Send a USB message to get volume status; result placed in *buf */
+static int scarlett2_usb_get_volume_status(
+        struct usb_mixer_interface *mixer,
+        struct scarlett2_usb_volume_status *buf)
+{
+        return scarlett2_usb_get(mixer, SCARLETT2_USB_VOLUME_STATUS_OFFSET,
+                                 buf, sizeof(*buf));
+}
+
+/* Send a USB message to set the volumes for all inputs of one mix
+ * (values obtained from private->mix[])
+ */
+static int scarlett2_usb_set_mix(struct usb_mixer_interface *mixer,
+                                     int mix_num)
+{
+        struct scarlett2_mixer_data *private = mixer->private_data;
+        const struct scarlett2_device_info *info = private->info;
+
+        struct {
+                u16 mix_num;
+                u16 data[SCARLETT2_INPUT_MIX_MAX];
+        } __packed req;
+
+        int i, j;
+        int num_mixer_in =
+                info->ports[SCARLETT2_PORT_TYPE_MIX].num[SCARLETT2_PORT_OUT];
+
+        req.mix_num = cpu_to_le16(mix_num);
+
+        for (i = 0, j = mix_num * num_mixer_in; i < num_mixer_in; i++, j++)
+                req.data[i] = cpu_to_le16(
+                        scarlett2_mixer_values[private->mix[j]]
+                );
+
+        return scarlett2_usb(mixer, SCARLETT2_USB_SET_MIX,
+                             &req, (num_mixer_in + 1) * sizeof(u16),
+                             NULL, 0);
+}
+
+/* Convert a port number index (per info->ports) to a hardware ID */
+static u32 scarlett2_mux_src_num_to_id(const struct scarlett2_ports *ports,
+                                       int num)
+{
+        int port_type;
+
+        for (port_type = 0;
+             port_type < SCARLETT2_PORT_TYPE_COUNT;
+             port_type++) {
+                if (num < ports[port_type].num[SCARLETT2_PORT_IN])
+                        return ports[port_type].id | num;
+                num -= ports[port_type].num[SCARLETT2_PORT_IN];
+        }
+
+        /* Oops */
+        return 0;
+}
+
+/* Send USB messages to set mux inputs */
+static int scarlett2_usb_set_mux(struct usb_mixer_interface *mixer)
+{
+        struct scarlett2_mixer_data *private = mixer->private_data;
+        const struct scarlett2_device_info *info = private->info;
+        const struct scarlett2_ports *ports = info->ports;
+        int rate, port_dir_rate;
+
+        static const int assignment_order[SCARLETT2_PORT_TYPE_COUNT] = {
+                SCARLETT2_PORT_TYPE_PCM,
+                SCARLETT2_PORT_TYPE_ANALOGUE,
+                SCARLETT2_PORT_TYPE_SPDIF,
+                SCARLETT2_PORT_TYPE_ADAT,
+                SCARLETT2_PORT_TYPE_MIX,
+                SCARLETT2_PORT_TYPE_NONE,
+        };
+
+        struct {
+                u16 pad;
+                u16 num;
+                u32 data[SCARLETT2_MUX_MAX];
+        } __packed req;
+
+        req.pad = 0;
+
+        /* mux settings for each rate */
+        for (rate = 0, port_dir_rate = SCARLETT2_PORT_OUT_44;
+             port_dir_rate <= SCARLETT2_PORT_OUT_176;
+             rate++, port_dir_rate++) {
+                int order_num, i, err;
+
+                req.num = cpu_to_le16(rate);
+
+                for (order_num = 0, i = 0;
+                     order_num < SCARLETT2_PORT_TYPE_COUNT;
+                     order_num++) {
+                        int port_type = assignment_order[order_num];
+                        int j = scarlett2_get_port_start_num(ports,
+                                                             SCARLETT2_PORT_OUT,
+                                                             port_type);
+                        int port_id = ports[port_type].id;
+                        int channel;
+
+                        for (channel = 0;
+                             channel < ports[port_type].num[port_dir_rate];
+                             channel++, i++, j++)
+                                /* lower 12 bits for the destination and
+                                 * next 12 bits for the source
+                                 */
+                                req.data[i] = !port_id
+                                        ? 0
+                                        : cpu_to_le32(
+                                                port_id |
+                                                channel |
+                                                scarlett2_mux_src_num_to_id(
+                                                        ports, private->mux[j]
+                                                ) << 12
+                                          );
+
+                        /* skip private->mux[j] entries not output */
+                        j += ports[port_type].num[SCARLETT2_PORT_OUT] -
+                             ports[port_type].num[port_dir_rate];
+                }
+
+                err = scarlett2_usb(mixer, SCARLETT2_USB_SET_MUX,
+                                    &req, (i + 1) * sizeof(u32),
+                                    NULL, 0);
+                if (err < 0)
+                        return err;
+        }
+
+        return 0;
+}
+
+/* Send USB message to get meter levels */
+static int scarlett2_usb_get_meter_levels(struct usb_mixer_interface *mixer,
+                                          u16 *levels)
+{
+        struct {
+                u16 pad;
+                u16 num_meters;
+                u32 magic;
+        } __packed req;
+        u32 resp[SCARLETT2_NUM_METERS];
+        int i, err;
+
+        req.pad = 0;
+        req.num_meters = cpu_to_le16(SCARLETT2_NUM_METERS);
+        req.magic = cpu_to_le32(SCARLETT2_USB_METER_LEVELS_GET_MAGIC);
+        err = scarlett2_usb(mixer, SCARLETT2_USB_GET_METER_LEVELS,
+                            &req, sizeof(req), resp, sizeof(resp));
+        if (err < 0)
+                return err;
+
+        /* copy, convert to u16 */
+        for (i = 0; i < SCARLETT2_NUM_METERS; i++)
+                levels[i] = resp[i];
+
+        return 0;
+}
+
+/*** Control Functions ***/
+
+/* helper function to create a new control */
+static int scarlett2_add_new_ctl(struct usb_mixer_interface *mixer,
+                                 const struct snd_kcontrol_new *ncontrol,
+                                 int index, int channels, const char *name,
+                                 struct snd_kcontrol **kctl_return)
+{
+        struct snd_kcontrol *kctl;
+        struct usb_mixer_elem_info *elem;
+        int err;
+
+        elem = kzalloc(sizeof(*elem), GFP_KERNEL);
+        if (!elem)
+                return -ENOMEM;
+
+        elem->head.mixer = mixer;
+        elem->control = index;
+        elem->head.id = index;
+        elem->channels = channels;
+
+        kctl = snd_ctl_new1(ncontrol, elem);
+        if (!kctl) {
+                kfree(elem);
+                return -ENOMEM;
+        }
+        kctl->private_free = snd_usb_mixer_elem_free;
+
+        strlcpy(kctl->id.name, name, sizeof(kctl->id.name));
+
+        err = snd_usb_mixer_add_control(&elem->head, kctl);
+        if (err < 0)
+                return err;
+
+        if (kctl_return)
+                *kctl_return = kctl;
+
+        return 0;
+}
+
+/*** Analogue Line Out Volume Controls ***/
+
+/* Update hardware volume controls after receiving notification that
+ * they have changed
+ */
+static int scarlett2_update_volumes(struct usb_mixer_interface *mixer)
+{
+        struct scarlett2_mixer_data *private = mixer->private_data;
+        const struct scarlett2_ports *ports = private->info->ports;
+        struct scarlett2_usb_volume_status volume_status;
+        int num_line_out =
+                ports[SCARLETT2_PORT_TYPE_ANALOGUE].num[SCARLETT2_PORT_OUT];
+        int err, i;
+
+        private->vol_updated = 0;
+
+        err = scarlett2_usb_get_volume_status(mixer, &volume_status);
+        if (err < 0)
+                return err;
+
+        private->master_vol = clamp(
+                volume_status.master_vol + SCARLETT2_VOLUME_BIAS,
+                0, SCARLETT2_VOLUME_BIAS);
+
+        for (i = 0; i < num_line_out; i++) {
+                if (private->vol_sw_hw_switch[i])
+                        private->vol[i] = private->master_vol;
+        }
+
+        for (i = 0; i < private->info->button_count; i++)
+                private->buttons[i] = !!volume_status.buttons[i];
+
+        return 0;
+}
+
+static int scarlett2_volume_ctl_info(struct snd_kcontrol *kctl,
+                                     struct snd_ctl_elem_info *uinfo)
+{
+        struct usb_mixer_elem_info *elem = kctl->private_data;
+
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+        uinfo->count = elem->channels;
+        uinfo->value.integer.min = 0;
+        uinfo->value.integer.max = SCARLETT2_VOLUME_BIAS;
+        uinfo->value.integer.step = 1;
+        return 0;
+}
+
+static int scarlett2_master_volume_ctl_get(struct snd_kcontrol *kctl,
+                                           struct snd_ctl_elem_value *ucontrol)
+{
+        struct usb_mixer_elem_info *elem = kctl->private_data;
+        struct usb_mixer_interface *mixer = elem->head.mixer;
+        struct scarlett2_mixer_data *private = mixer->private_data;
+
+        if (private->vol_updated) {
+                mutex_lock(&private->data_mutex);
+                scarlett2_update_volumes(mixer);
+                mutex_unlock(&private->data_mutex);
+        }
+
+        ucontrol->value.integer.value[0] = private->master_vol;
+        return 0;
+}
+
+static int scarlett2_volume_ctl_get(struct snd_kcontrol *kctl,
+                                    struct snd_ctl_elem_value *ucontrol)
+{
+        struct usb_mixer_elem_info *elem = kctl->private_data;
+        struct usb_mixer_interface *mixer = elem->head.mixer;
+        struct scarlett2_mixer_data *private = mixer->private_data;
+        int index = elem->control;
+
+        if (private->vol_updated) {
+                mutex_lock(&private->data_mutex);
+                scarlett2_update_volumes(mixer);
+                mutex_unlock(&private->data_mutex);
+        }
+
+        ucontrol->value.integer.value[0] = private->vol[index];
+        return 0;
+}
+
+static int scarlett2_volume_ctl_put(struct snd_kcontrol *kctl,
+                                    struct snd_ctl_elem_value *ucontrol)
+{
+        struct usb_mixer_elem_info *elem = kctl->private_data;
+        struct usb_mixer_interface *mixer = elem->head.mixer;
+        struct scarlett2_mixer_data *private = mixer->private_data;
+        int index = elem->control;
+        int oval, val, err = 0;
+
+        mutex_lock(&private->data_mutex);
+
+        oval = private->vol[index];
+        val = ucontrol->value.integer.value[0];
+
+        if (oval == val)
+                goto unlock;
+
+        private->vol[index] = val;
+        err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_LINE_OUT_VOLUME,
+                                       index, val - SCARLETT2_VOLUME_BIAS);
+        if (err == 0)
+                err = 1;
+
+unlock:
+        mutex_unlock(&private->data_mutex);
+        return err;
+}
+
+static const DECLARE_TLV_DB_MINMAX(
+        db_scale_scarlett2_gain, -SCARLETT2_VOLUME_BIAS * 100, 0
+);
+
+static const struct snd_kcontrol_new scarlett2_master_volume_ctl = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .access = SNDRV_CTL_ELEM_ACCESS_READ |
+                  SNDRV_CTL_ELEM_ACCESS_TLV_READ,
+        .name = "",
+        .info = scarlett2_volume_ctl_info,
+        .get  = scarlett2_master_volume_ctl_get,
+        .private_value = 0, /* max value */
+        .tlv = { .p = db_scale_scarlett2_gain }
+};
+
+static const struct snd_kcontrol_new scarlett2_line_out_volume_ctl = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
+                  SNDRV_CTL_ELEM_ACCESS_TLV_READ,
+        .name = "",
+        .info = scarlett2_volume_ctl_info,
+        .get  = scarlett2_volume_ctl_get,
+        .put  = scarlett2_volume_ctl_put,
+        .private_value = 0, /* max value */
+        .tlv = { .p = db_scale_scarlett2_gain }
+};
+
+/*** HW/SW Volume Switch Controls ***/
+
+static int scarlett2_sw_hw_enum_ctl_info(struct snd_kcontrol *kctl,
+                                         struct snd_ctl_elem_info *uinfo)
+{
+        static const char *const values[2] = {
+                "SW", "HW"
+        };
+
+        return snd_ctl_enum_info(uinfo, 1, 2, values);
+}
+
+static int scarlett2_sw_hw_enum_ctl_get(struct snd_kcontrol *kctl,
+                                        struct snd_ctl_elem_value *ucontrol)
+{
+        struct usb_mixer_elem_info *elem = kctl->private_data;
+        struct scarlett2_mixer_data *private = elem->head.mixer->private_data;
+
+        ucontrol->value.enumerated.item[0] =
+                private->vol_sw_hw_switch[elem->control];
+        return 0;
+}
+
+static int scarlett2_sw_hw_enum_ctl_put(struct snd_kcontrol *kctl,
+                                        struct snd_ctl_elem_value *ucontrol)
+{
+        struct usb_mixer_elem_info *elem = kctl->private_data;
+        struct usb_mixer_interface *mixer = elem->head.mixer;
+        struct scarlett2_mixer_data *private = mixer->private_data;
+
+        int index = elem->control;
+        int oval, val, err = 0;
+
+        mutex_lock(&private->data_mutex);
+
+        oval = private->vol_sw_hw_switch[index];
+        val = !!ucontrol->value.integer.value[0];
+
+        if (oval == val)
+                goto unlock;
+
+        private->vol_sw_hw_switch[index] = val;
+
+        /* Change access mode to RO (hardware controlled volume)
+         * or RW (software controlled volume)
+         */
+        if (val)
+                private->vol_ctls[index]->vd[0].access &=
+                        ~SNDRV_CTL_ELEM_ACCESS_WRITE;
+        else
+                private->vol_ctls[index]->vd[0].access |=
+                        SNDRV_CTL_ELEM_ACCESS_WRITE;
+
+        /* Reset volume to master volume */
+        private->vol[index] = private->master_vol;
+
+        /* Set SW volume to current HW volume */
+        err = scarlett2_usb_set_config(
+                mixer, SCARLETT2_CONFIG_LINE_OUT_VOLUME,
+                index, private->master_vol - SCARLETT2_VOLUME_BIAS);
+        if (err < 0)
+                goto unlock;
+
+        /* Notify of RO/RW change */
+        snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_INFO,
+                       &private->vol_ctls[index]->id);
+
+        /* Send SW/HW switch change to the device */
+        err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_SW_HW_SWITCH,
+                                       index, val);
+
+unlock:
+        mutex_unlock(&private->data_mutex);
+        return err;
+}
+
+static const struct snd_kcontrol_new scarlett2_sw_hw_enum_ctl = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name = "",
+        .info = scarlett2_sw_hw_enum_ctl_info,
+        .get  = scarlett2_sw_hw_enum_ctl_get,
+        .put  = scarlett2_sw_hw_enum_ctl_put,
+};
+
+/*** Line Level/Instrument Level Switch Controls ***/
+
+static int scarlett2_level_enum_ctl_info(struct snd_kcontrol *kctl,
+                                         struct snd_ctl_elem_info *uinfo)
+{
+        static const char *const values[2] = {
+                "Line", "Inst"
+        };
+
+        return snd_ctl_enum_info(uinfo, 1, 2, values);
+}
+
+static int scarlett2_level_enum_ctl_get(struct snd_kcontrol *kctl,
+                                        struct snd_ctl_elem_value *ucontrol)
+{
+        struct usb_mixer_elem_info *elem = kctl->private_data;
+        struct scarlett2_mixer_data *private = elem->head.mixer->private_data;
+
+        ucontrol->value.enumerated.item[0] =
+                private->level_switch[elem->control];
+        return 0;
+}
+
+static int scarlett2_level_enum_ctl_put(struct snd_kcontrol *kctl,
+                                        struct snd_ctl_elem_value *ucontrol)
+{
+        struct usb_mixer_elem_info *elem = kctl->private_data;
+        struct usb_mixer_interface *mixer = elem->head.mixer;
+        struct scarlett2_mixer_data *private = mixer->private_data;
+
+        int index = elem->control;
+        int oval, val, err = 0;
+
+        mutex_lock(&private->data_mutex);
+
+        oval = private->level_switch[index];
+        val = !!ucontrol->value.integer.value[0];
+
+        if (oval == val)
+                goto unlock;
+
+        private->level_switch[index] = val;
+
+        /* Send switch change to the device */
+        err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_LEVEL_SWITCH,
+                                       index, val);
+
+unlock:
+        mutex_unlock(&private->data_mutex);
+        return err;
+}
+
+static const struct snd_kcontrol_new scarlett2_level_enum_ctl = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name = "",
+        .info = scarlett2_level_enum_ctl_info,
+        .get  = scarlett2_level_enum_ctl_get,
+        .put  = scarlett2_level_enum_ctl_put,
+};
+
+/*** Pad Switch Controls ***/
+
+static int scarlett2_pad_ctl_get(struct snd_kcontrol *kctl,
+                                 struct snd_ctl_elem_value *ucontrol)
+{
+        struct usb_mixer_elem_info *elem = kctl->private_data;
+        struct scarlett2_mixer_data *private = elem->head.mixer->private_data;
+
+        ucontrol->value.enumerated.item[0] =
+                private->pad_switch[elem->control];
+        return 0;
+}
+
+static int scarlett2_pad_ctl_put(struct snd_kcontrol *kctl,
+                                 struct snd_ctl_elem_value *ucontrol)
+{
+        struct usb_mixer_elem_info *elem = kctl->private_data;
+        struct usb_mixer_interface *mixer = elem->head.mixer;
+        struct scarlett2_mixer_data *private = mixer->private_data;
+
+        int index = elem->control;
+        int oval, val, err = 0;
+
+        mutex_lock(&private->data_mutex);
+
+        oval = private->pad_switch[index];
+        val = !!ucontrol->value.integer.value[0];
+
+        if (oval == val)
+                goto unlock;
+
+        private->pad_switch[index] = val;
+
+        /* Send switch change to the device */
+        err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_PAD_SWITCH,
+                                       index, val);
+
+unlock:
+        mutex_unlock(&private->data_mutex);
+        return err;
+}
+
+static const struct snd_kcontrol_new scarlett2_pad_ctl = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name = "",
+        .info = snd_ctl_boolean_mono_info,
+        .get  = scarlett2_pad_ctl_get,
+        .put  = scarlett2_pad_ctl_put,
+};
+
+/*** Mute/Dim Controls ***/
+
+static int scarlett2_button_ctl_get(struct snd_kcontrol *kctl,
+                                    struct snd_ctl_elem_value *ucontrol)
+{
+        struct usb_mixer_elem_info *elem = kctl->private_data;
+        struct usb_mixer_interface *mixer = elem->head.mixer;
+        struct scarlett2_mixer_data *private = mixer->private_data;
+
+        if (private->vol_updated) {
+                mutex_lock(&private->data_mutex);
+                scarlett2_update_volumes(mixer);
+                mutex_unlock(&private->data_mutex);
+        }
+
+        ucontrol->value.enumerated.item[0] = private->buttons[elem->control];
+        return 0;
+}
+
+static int scarlett2_button_ctl_put(struct snd_kcontrol *kctl,
+                                    struct snd_ctl_elem_value *ucontrol)
+{
+        struct usb_mixer_elem_info *elem = kctl->private_data;
+        struct usb_mixer_interface *mixer = elem->head.mixer;
+        struct scarlett2_mixer_data *private = mixer->private_data;
+
+        int index = elem->control;
+        int oval, val, err = 0;
+
+        mutex_lock(&private->data_mutex);
+
+        oval = private->buttons[index];
+        val = !!ucontrol->value.integer.value[0];
+
+        if (oval == val)
+                goto unlock;
+
+        private->buttons[index] = val;
+
+        /* Send switch change to the device */
+        err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_BUTTONS,
+                                       index, val);
+
+unlock:
+        mutex_unlock(&private->data_mutex);
+        return err;
+}
+
+static const struct snd_kcontrol_new scarlett2_button_ctl = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name = "",
+        .info = snd_ctl_boolean_mono_info,
+        .get  = scarlett2_button_ctl_get,
+        .put  = scarlett2_button_ctl_put
+};
+
+/*** Create the analogue output controls ***/
+
+static int scarlett2_add_line_out_ctls(struct usb_mixer_interface *mixer)
+{
+        struct scarlett2_mixer_data *private = mixer->private_data;
+        const struct scarlett2_device_info *info = private->info;
+        const struct scarlett2_ports *ports = info->ports;
+        int num_line_out =
+                ports[SCARLETT2_PORT_TYPE_ANALOGUE].num[SCARLETT2_PORT_OUT];
+        int err, i;
+        char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
+
+        /* Add R/O HW volume control */
+        if (info->line_out_hw_vol) {
+                snprintf(s, sizeof(s), "Master HW Playback Volume");
+                err = scarlett2_add_new_ctl(mixer,
+                                            &scarlett2_master_volume_ctl,
+                                            0, 1, s, &private->master_vol_ctl);
+                if (err < 0)
+                        return err;
+        }
+
+        /* Add volume controls */
+        for (i = 0; i < num_line_out; i++) {
+
+                /* Fader */
+                if (info->line_out_descrs[i])
+                        snprintf(s, sizeof(s),
+                                 "Line %02d (%s) Playback Volume",
+                                 i + 1, info->line_out_descrs[i]);
+                else
+                        snprintf(s, sizeof(s),
+                                 "Line %02d Playback Volume",
+                                 i + 1);
+                err = scarlett2_add_new_ctl(mixer,
+                                            &scarlett2_line_out_volume_ctl,
+                                            i, 1, s, &private->vol_ctls[i]);
+                if (err < 0)
+                        return err;
+
+                /* Make the fader read-only if the SW/HW switch is set to HW */
+                if (private->vol_sw_hw_switch[i])
+                        private->vol_ctls[i]->vd[0].access &=
+                                ~SNDRV_CTL_ELEM_ACCESS_WRITE;
+
+                /* SW/HW Switch */
+                if (info->line_out_hw_vol) {
+                        snprintf(s, sizeof(s),
+                                 "Line Out %02d Volume Control Playback Enum",
+                                 i + 1);
+                        err = scarlett2_add_new_ctl(mixer,
+                                                    &scarlett2_sw_hw_enum_ctl,
+                                                    i, 1, s, NULL);
+                        if (err < 0)
+                                return err;
+                }
+        }
+
+        /* Add HW button controls */
+        for (i = 0; i < private->info->button_count; i++) {
+                err = scarlett2_add_new_ctl(mixer, &scarlett2_button_ctl,
+                                            i, 1, scarlett2_button_names[i],
+                                            &private->button_ctls[i]);
+                if (err < 0)
+                        return err;
+        }
+
+        return 0;
+}
+
+/*** Create the analogue input controls ***/
+
+static int scarlett2_add_line_in_ctls(struct usb_mixer_interface *mixer)
+{
+        struct scarlett2_mixer_data *private = mixer->private_data;
+        const struct scarlett2_device_info *info = private->info;
+        int err, i;
+        char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
+
+        /* Add input level (line/inst) controls */
+        for (i = 0; i < info->level_input_count; i++) {
+                snprintf(s, sizeof(s), "Line In %d Level Capture Enum", i + 1);
+                err = scarlett2_add_new_ctl(mixer, &scarlett2_level_enum_ctl,
+                                            i, 1, s, NULL);
+                if (err < 0)
+                        return err;
+        }
+
+        /* Add input pad controls */
+        for (i = 0; i < info->pad_input_count; i++) {
+                snprintf(s, sizeof(s), "Line In %d Pad Capture Switch", i + 1);
+                err = scarlett2_add_new_ctl(mixer, &scarlett2_pad_ctl,
+                                            i, 1, s, NULL);
+                if (err < 0)
+                        return err;
+        }
+
+        return 0;
+}
+
+/*** Mixer Volume Controls ***/
+
+static int scarlett2_mixer_ctl_info(struct snd_kcontrol *kctl,
+                                    struct snd_ctl_elem_info *uinfo)
+{
+        struct usb_mixer_elem_info *elem = kctl->private_data;
+
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+        uinfo->count = elem->channels;
+        uinfo->value.integer.min = 0;
+        uinfo->value.integer.max = SCARLETT2_MIXER_MAX_VALUE;
+        uinfo->value.integer.step = 1;
+        return 0;
+}
+
+static int scarlett2_mixer_ctl_get(struct snd_kcontrol *kctl,
+                                   struct snd_ctl_elem_value *ucontrol)
+{
+        struct usb_mixer_elem_info *elem = kctl->private_data;
+        struct scarlett2_mixer_data *private = elem->head.mixer->private_data;
+
+        ucontrol->value.integer.value[0] = private->mix[elem->control];
+        return 0;
+}
+
+static int scarlett2_mixer_ctl_put(struct snd_kcontrol *kctl,
+                                   struct snd_ctl_elem_value *ucontrol)
+{
+        struct usb_mixer_elem_info *elem = kctl->private_data;
+        struct usb_mixer_interface *mixer = elem->head.mixer;
+        struct scarlett2_mixer_data *private = mixer->private_data;
+        const struct scarlett2_device_info *info = private->info;
+        const struct scarlett2_ports *ports = info->ports;
+        int oval, val, num_mixer_in, mix_num, err = 0;
+
+        mutex_lock(&private->data_mutex);
+
+        oval = private->mix[elem->control];
+        val = ucontrol->value.integer.value[0];
+        num_mixer_in = ports[SCARLETT2_PORT_TYPE_MIX].num[SCARLETT2_PORT_OUT];
+        mix_num = elem->control / num_mixer_in;
+
+        if (oval == val)
+                goto unlock;
+
+        private->mix[elem->control] = val;
+        err = scarlett2_usb_set_mix(mixer, mix_num);
+        if (err == 0)
+                err = 1;
+
+unlock:
+        mutex_unlock(&private->data_mutex);
+        return err;
+}
+
+static const DECLARE_TLV_DB_MINMAX(
+        db_scale_scarlett2_mixer,
+        SCARLETT2_MIXER_MIN_DB * 100,
+        SCARLETT2_MIXER_MAX_DB * 100
+);
+
+static const struct snd_kcontrol_new scarlett2_mixer_ctl = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
+                  SNDRV_CTL_ELEM_ACCESS_TLV_READ,
+        .name = "",
+        .info = scarlett2_mixer_ctl_info,
+        .get  = scarlett2_mixer_ctl_get,
+        .put  = scarlett2_mixer_ctl_put,
+        .private_value = SCARLETT2_MIXER_MAX_DB, /* max value */
+        .tlv = { .p = db_scale_scarlett2_mixer }
+};
+
+static int scarlett2_add_mixer_ctls(struct usb_mixer_interface *mixer)
+{
+        struct scarlett2_mixer_data *private = mixer->private_data;
+        const struct scarlett2_ports *ports = private->info->ports;
+        int err, i, j;
+        int index;
+        char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
+
+        int num_inputs = ports[SCARLETT2_PORT_TYPE_MIX].num[SCARLETT2_PORT_OUT];
+        int num_outputs = ports[SCARLETT2_PORT_TYPE_MIX].num[SCARLETT2_PORT_IN];
+
+        for (i = 0, index = 0; i < num_outputs; i++) {
+                for (j = 0; j < num_inputs; j++, index++) {
+                        snprintf(s, sizeof(s),
+                                 "Mix %c Input %02d Playback Volume",
+                                 'A' + i, j + 1);
+                        err = scarlett2_add_new_ctl(mixer, &scarlett2_mixer_ctl,
+                                                    index, 1, s, NULL);
+                        if (err < 0)
+                                return err;
+                }
+        }
+
+        return 0;
+}
+
+/*** Mux Source Selection Controls ***/
+
+static int scarlett2_mux_src_enum_ctl_info(struct snd_kcontrol *kctl,
+                                           struct snd_ctl_elem_info *uinfo)
+{
+        struct usb_mixer_elem_info *elem = kctl->private_data;
+        struct scarlett2_mixer_data *private = elem->head.mixer->private_data;
+        const struct scarlett2_ports *ports = private->info->ports;
+        unsigned int item = uinfo->value.enumerated.item;
+        int items = private->num_mux_srcs;
+        int port_type;
+
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        uinfo->count = elem->channels;
+        uinfo->value.enumerated.items = items;
+
+        if (item >= items)
+                item = uinfo->value.enumerated.item = items - 1;
+
+        for (port_type = 0;
+             port_type < SCARLETT2_PORT_TYPE_COUNT;
+             port_type++) {
+                if (item < ports[port_type].num[SCARLETT2_PORT_IN]) {
+                        sprintf(uinfo->value.enumerated.name,
+                                ports[port_type].src_descr,
+                                item + ports[port_type].src_num_offset);
+                        return 0;
+                }
+                item -= ports[port_type].num[SCARLETT2_PORT_IN];
+        }
+
+        return -EINVAL;
+}
+
+static int scarlett2_mux_src_enum_ctl_get(struct snd_kcontrol *kctl,
+                                          struct snd_ctl_elem_value *ucontrol)
+{
+        struct usb_mixer_elem_info *elem = kctl->private_data;
+        struct scarlett2_mixer_data *private = elem->head.mixer->private_data;
+
+        ucontrol->value.enumerated.item[0] = private->mux[elem->control];
+        return 0;
+}
+
+static int scarlett2_mux_src_enum_ctl_put(struct snd_kcontrol *kctl,
+                                          struct snd_ctl_elem_value *ucontrol)
+{
+        struct usb_mixer_elem_info *elem = kctl->private_data;
+        struct usb_mixer_interface *mixer = elem->head.mixer;
+        struct scarlett2_mixer_data *private = mixer->private_data;
+        int index = elem->control;
+        int oval, val, err = 0;
+
+        mutex_lock(&private->data_mutex);
+
+        oval = private->mux[index];
+        val = clamp(ucontrol->value.integer.value[0],
+                    0L, private->num_mux_srcs - 1L);
+
+        if (oval == val)
+                goto unlock;
+
+        private->mux[index] = val;
+        err = scarlett2_usb_set_mux(mixer);
+        if (err == 0)
+                err = 1;
+
+unlock:
+        mutex_unlock(&private->data_mutex);
+        return err;
+}
+
+static const struct snd_kcontrol_new scarlett2_mux_src_enum_ctl = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name = "",
+        .info = scarlett2_mux_src_enum_ctl_info,
+        .get  = scarlett2_mux_src_enum_ctl_get,
+        .put  = scarlett2_mux_src_enum_ctl_put,
+};
+
+static int scarlett2_add_mux_enums(struct usb_mixer_interface *mixer)
+{
+        struct scarlett2_mixer_data *private = mixer->private_data;
+        const struct scarlett2_ports *ports = private->info->ports;
+        int port_type, channel, i;
+
+        for (i = 0, port_type = 0;
+             port_type < SCARLETT2_PORT_TYPE_COUNT;
+             port_type++) {
+                for (channel = 0;
+                     channel < ports[port_type].num[SCARLETT2_PORT_OUT];
+                     channel++, i++) {
+                        int err;
+                        char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
+                        const char *const descr = ports[port_type].dst_descr;
+
+                        snprintf(s, sizeof(s) - 5, descr, channel + 1);
+                        strcat(s, " Enum");
+
+                        err = scarlett2_add_new_ctl(mixer,
+                                                    &scarlett2_mux_src_enum_ctl,
+                                                    i, 1, s, NULL);
+                        if (err < 0)
+                                return err;
+                }
+        }
+
+        return 0;
+}
+
+/*** Meter Controls ***/
+
+static int scarlett2_meter_ctl_info(struct snd_kcontrol *kctl,
+                                    struct snd_ctl_elem_info *uinfo)
+{
+        struct usb_mixer_elem_info *elem = kctl->private_data;
+
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+        uinfo->count = elem->channels;
+        uinfo->value.integer.min = 0;
+        uinfo->value.integer.max = 4095;
+        uinfo->value.integer.step = 1;
+        return 0;
+}
+
+static int scarlett2_meter_ctl_get(struct snd_kcontrol *kctl,
+                                   struct snd_ctl_elem_value *ucontrol)
+{
+        struct usb_mixer_elem_info *elem = kctl->private_data;
+        u16 meter_levels[SCARLETT2_NUM_METERS];
+        int i, err;
+
+        err = scarlett2_usb_get_meter_levels(elem->head.mixer, meter_levels);
+        if (err < 0)
+                return err;
+
+        for (i = 0; i < elem->channels; i++)
+                ucontrol->value.integer.value[i] = meter_levels[i];
+
+        return 0;
+}
+
+static const struct snd_kcontrol_new scarlett2_meter_ctl = {
+        .iface = SNDRV_CTL_ELEM_IFACE_PCM,
+        .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
+        .name = "",
+        .info = scarlett2_meter_ctl_info,
+        .get  = scarlett2_meter_ctl_get
+};
+
+static int scarlett2_add_meter_ctl(struct usb_mixer_interface *mixer)
+{
+        return scarlett2_add_new_ctl(mixer, &scarlett2_meter_ctl,
+                                     0, SCARLETT2_NUM_METERS,
+                                     "Level Meter", NULL);
+}
+
+/*** Cleanup/Suspend Callbacks ***/
+
+static void scarlett2_private_free(struct usb_mixer_interface *mixer)
+{
+        struct scarlett2_mixer_data *private = mixer->private_data;
+
+        cancel_delayed_work_sync(&private->work);
+        kfree(private);
+        mixer->private_data = NULL;
+}
+
+static void scarlett2_private_suspend(struct usb_mixer_interface *mixer)
+{
+        struct scarlett2_mixer_data *private = mixer->private_data;
+
+        if (cancel_delayed_work_sync(&private->work))
+                scarlett2_config_save(private->mixer);
+}
+
+/*** Initialisation ***/
+
+static int scarlett2_count_mux_srcs(const struct scarlett2_ports *ports)
+{
+        int port_type, count = 0;
+
+        for (port_type = 0;
+             port_type < SCARLETT2_PORT_TYPE_COUNT;
+             port_type++)
+                count += ports[port_type].num[SCARLETT2_PORT_IN];
+
+        return count;
+}
+
+/* Default routing connects PCM outputs and inputs to Analogue,
+ * S/PDIF, then ADAT
+ */
+static void scarlett2_init_routing(u8 *mux,
+                                   const struct scarlett2_ports *ports)
+{
+        int i, input_num, input_count, port_type;
+        int output_num, output_count, port_type_connect_num;
+
+        static const int connect_order[] = {
+                SCARLETT2_PORT_TYPE_ANALOGUE,
+                SCARLETT2_PORT_TYPE_SPDIF,
+                SCARLETT2_PORT_TYPE_ADAT,
+                -1
+        };
+
+        /* Assign PCM inputs (routing outputs) */
+        output_num = scarlett2_get_port_start_num(ports,
+                                                  SCARLETT2_PORT_OUT,
+                                                  SCARLETT2_PORT_TYPE_PCM);
+        output_count = ports[SCARLETT2_PORT_TYPE_PCM].num[SCARLETT2_PORT_OUT];
+
+        for (port_type = connect_order[port_type_connect_num = 0];
+             port_type >= 0;
+             port_type = connect_order[++port_type_connect_num]) {
+                input_num = scarlett2_get_port_start_num(
+                        ports, SCARLETT2_PORT_IN, port_type);
+                input_count = ports[port_type].num[SCARLETT2_PORT_IN];
+                for (i = 0;
+                     i < input_count && output_count;
+                     i++, output_count--)
+                        mux[output_num++] = input_num++;
+        }
+
+        /* Assign PCM outputs (routing inputs) */
+        input_num = scarlett2_get_port_start_num(ports,
+                                                 SCARLETT2_PORT_IN,
+                                                 SCARLETT2_PORT_TYPE_PCM);
+        input_count = ports[SCARLETT2_PORT_TYPE_PCM].num[SCARLETT2_PORT_IN];
+
+        for (port_type = connect_order[port_type_connect_num = 0];
+             port_type >= 0;
+             port_type = connect_order[++port_type_connect_num]) {
+                output_num = scarlett2_get_port_start_num(
+                        ports, SCARLETT2_PORT_OUT, port_type);
+                output_count = ports[port_type].num[SCARLETT2_PORT_OUT];
+                for (i = 0;
+                     i < output_count && input_count;
+                     i++, input_count--)
+                        mux[output_num++] = input_num++;
+        }
+}
+
+/* Initialise private data, routing, sequence number */
+static int scarlett2_init_private(struct usb_mixer_interface *mixer,
+                                  const struct scarlett2_device_info *info)
+{
+        struct scarlett2_mixer_data *private =
+                kzalloc(sizeof(struct scarlett2_mixer_data), GFP_KERNEL);
+
+        if (!private)
+                return -ENOMEM;
+
+        mutex_init(&private->usb_mutex);
+        mutex_init(&private->data_mutex);
+        INIT_DELAYED_WORK(&private->work, scarlett2_config_save_work);
+        private->info = info;
+        private->num_mux_srcs = scarlett2_count_mux_srcs(info->ports);
+        private->scarlett2_seq = 0;
+        private->mixer = mixer;
+        mixer->private_data = private;
+        mixer->private_free = scarlett2_private_free;
+        mixer->private_suspend = scarlett2_private_suspend;
+
+        /* Setup default routing */
+        scarlett2_init_routing(private->mux, info->ports);
+
+        /* Initialise the sequence number used for the proprietary commands */
+        return scarlett2_usb(mixer, SCARLETT2_USB_INIT_SEQ, NULL, 0, NULL, 0);
+}
+
+/* Read line-in config and line-out volume settings on start */
+static int scarlett2_read_configs(struct usb_mixer_interface *mixer)
+{
+        struct scarlett2_mixer_data *private = mixer->private_data;
+        const struct scarlett2_device_info *info = private->info;
+        const struct scarlett2_ports *ports = info->ports;
+        int num_line_out =
+                ports[SCARLETT2_PORT_TYPE_ANALOGUE].num[SCARLETT2_PORT_OUT];
+        u8 level_switches[SCARLETT2_LEVEL_SWITCH_MAX];
+        u8 pad_switches[SCARLETT2_PAD_SWITCH_MAX];
+        struct scarlett2_usb_volume_status volume_status;
+        int err, i;
+
+        if (info->level_input_count) {
+                err = scarlett2_usb_get_config(
+                        mixer,
+                        SCARLETT2_CONFIG_LEVEL_SWITCH,
+                        info->level_input_count,
+                        level_switches);
+                if (err < 0)
+                        return err;
+                for (i = 0; i < info->level_input_count; i++)
+                        private->level_switch[i] = level_switches[i];
+        }
+
+        if (info->pad_input_count) {
+                err = scarlett2_usb_get_config(
+                        mixer,
+                        SCARLETT2_CONFIG_PAD_SWITCH,
+                        info->pad_input_count,
+                        pad_switches);
+                if (err < 0)
+                        return err;
+                for (i = 0; i < info->pad_input_count; i++)
+                        private->pad_switch[i] = pad_switches[i];
+        }
+
+        err = scarlett2_usb_get_volume_status(mixer, &volume_status);
+        if (err < 0)
+                return err;
+
+        private->master_vol = clamp(
+                volume_status.master_vol + SCARLETT2_VOLUME_BIAS,
+                0, SCARLETT2_VOLUME_BIAS);
+
+        for (i = 0; i < num_line_out; i++) {
+                int volume;
+
+                private->vol_sw_hw_switch[i] =
+                        info->line_out_hw_vol
+                                && volume_status.sw_hw_switch[i];
+
+                volume = private->vol_sw_hw_switch[i]
+                           ? volume_status.master_vol
+                           : volume_status.sw_vol[i];
+                volume = clamp(volume + SCARLETT2_VOLUME_BIAS,
+                               0, SCARLETT2_VOLUME_BIAS);
+                private->vol[i] = volume;
+        }
+
+        for (i = 0; i < info->button_count; i++)
+                private->buttons[i] = !!volume_status.buttons[i];
+
+        return 0;
+}
+
+/* Notify on volume change */
+static void scarlett2_mixer_interrupt_vol_change(
+        struct usb_mixer_interface *mixer)
+{
+        struct scarlett2_mixer_data *private = mixer->private_data;
+        const struct scarlett2_ports *ports = private->info->ports;
+        int num_line_out =
+                ports[SCARLETT2_PORT_TYPE_ANALOGUE].num[SCARLETT2_PORT_OUT];
+        int i;
+
+        private->vol_updated = 1;
+
+        snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
+                       &private->master_vol_ctl->id);
+
+        for (i = 0; i < num_line_out; i++) {
+                if (!private->vol_sw_hw_switch[i])
+                        continue;
+                snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
+                               &private->vol_ctls[i]->id);
+        }
+}
+
+/* Notify on button change */
+static void scarlett2_mixer_interrupt_button_change(
+        struct usb_mixer_interface *mixer)
+{
+        struct scarlett2_mixer_data *private = mixer->private_data;
+        int i;
+
+        private->vol_updated = 1;
+
+        for (i = 0; i < private->info->button_count; i++)
+                snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
+                               &private->button_ctls[i]->id);
+}
+
+/* Interrupt callback */
+static void scarlett2_mixer_interrupt(struct urb *urb)
+{
+        struct usb_mixer_interface *mixer = urb->context;
+        int len = urb->actual_length;
+        int ustatus = urb->status;
+        u32 data;
+
+        if (ustatus != 0)
+                goto requeue;
+
+        if (len == 8) {
+                data = le32_to_cpu(*(u32 *)urb->transfer_buffer);
+                if (data & SCARLETT2_USB_INTERRUPT_VOL_CHANGE)
+                        scarlett2_mixer_interrupt_vol_change(mixer);
+                if (data & SCARLETT2_USB_INTERRUPT_BUTTON_CHANGE)
+                        scarlett2_mixer_interrupt_button_change(mixer);
+        } else {
+                usb_audio_err(mixer->chip,
+                              "scarlett mixer interrupt length %d\n", len);
+        }
+
+requeue:
+        if (ustatus != -ENOENT &&
+            ustatus != -ECONNRESET &&
+            ustatus != -ESHUTDOWN) {
+                urb->dev = mixer->chip->dev;
+                usb_submit_urb(urb, GFP_ATOMIC);
+        }
+}
+
+static int scarlett2_mixer_status_create(struct usb_mixer_interface *mixer)
+{
+        struct usb_device *dev = mixer->chip->dev;
+        unsigned int pipe = usb_rcvintpipe(dev,
+                                           SCARLETT2_USB_INTERRUPT_ENDPOINT);
+        void *transfer_buffer;
+
+        if (mixer->urb) {
+                usb_audio_err(mixer->chip,
+                              "%s: mixer urb already in use!\n", __func__);
+                return 0;
+        }
+
+        if (snd_usb_pipe_sanity_check(dev, pipe))
+                return -EINVAL;
+
+        mixer->urb = usb_alloc_urb(0, GFP_KERNEL);
+        if (!mixer->urb)
+                return -ENOMEM;
+
+        transfer_buffer = kmalloc(SCARLETT2_USB_INTERRUPT_MAX_DATA, GFP_KERNEL);
+        if (!transfer_buffer)
+                return -ENOMEM;
+
+        usb_fill_int_urb(mixer->urb, dev, pipe,
+                         transfer_buffer, SCARLETT2_USB_INTERRUPT_MAX_DATA,
+                         scarlett2_mixer_interrupt, mixer,
+                         SCARLETT2_USB_INTERRUPT_INTERVAL);
+
+        return usb_submit_urb(mixer->urb, GFP_KERNEL);
+}
+
+/* Entry point */
+int snd_scarlett_gen2_controls_create(struct usb_mixer_interface *mixer)
+{
+        const struct scarlett2_device_info *info;
+        int err;
+
+        /* only use UAC_VERSION_2 */
+        if (!mixer->protocol)
+                return 0;
+
+        switch (mixer->chip->usb_id) {
+        case USB_ID(0x1235, 0x8203):
+                info = &s6i6_gen2_info;
+                break;
+        case USB_ID(0x1235, 0x8204):
+                info = &s18i8_gen2_info;
+                break;
+        case USB_ID(0x1235, 0x8201):
+                info = &s18i20_gen2_info;
+                break;
+        default: /* device not (yet) supported */
+                return -EINVAL;
+        }
+
+        if (!(mixer->chip->setup & SCARLETT2_ENABLE)) {
+                usb_audio_err(mixer->chip,
+                        "Focusrite Scarlett Gen 2 Mixer Driver disabled; "
+                        "use options snd_usb_audio device_setup=1 "
+                        "to enable and report any issues to g@b4.vu");
+                return 0;
+        }
+
+        /* Initialise private data, routing, sequence number */
+        err = scarlett2_init_private(mixer, info);
+        if (err < 0)
+                return err;
+
+        /* Read volume levels and controls from the interface */
+        err = scarlett2_read_configs(mixer);
+        if (err < 0)
+                return err;
+
+        /* Create the analogue output controls */
+        err = scarlett2_add_line_out_ctls(mixer);
+        if (err < 0)
+                return err;
+
+        /* Create the analogue input controls */
+        err = scarlett2_add_line_in_ctls(mixer);
+        if (err < 0)
+                return err;
+
+        /* Create the input, output, and mixer mux input selections */
+        err = scarlett2_add_mux_enums(mixer);
+        if (err < 0)
+                return err;
+
+        /* Create the matrix mixer controls */
+        err = scarlett2_add_mixer_ctls(mixer);
+        if (err < 0)
+                return err;
+
+        /* Create the level meter controls */
+        err = scarlett2_add_meter_ctl(mixer);
+        if (err < 0)
+                return err;
+
+        /* Set up the interrupt polling if there are hardware buttons */
+        if (info->button_count) {
+                err = scarlett2_mixer_status_create(mixer);
+                if (err < 0)
+                        return err;
+        }
+
+        return 0;
+}
diff --git a/sound/usb/mixer_scarlett_gen2.h b/sound/usb/mixer_scarlett_gen2.h
new file mode 100644
index 000000000000..52e1dad77afd
--- /dev/null
+++ b/sound/usb/mixer_scarlett_gen2.h
@@ -0,0 +1,7 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#ifndef __USB_MIXER_SCARLETT_GEN2_H
+#define __USB_MIXER_SCARLETT_GEN2_H
+
+int snd_scarlett_gen2_controls_create(struct usb_mixer_interface *mixer);
+
+#endif /* __USB_MIXER_SCARLETT_GEN2_H */
diff --git a/sound/usb/pcm.c b/sound/usb/pcm.c
index 75b96929f76c..51a8faf25ed8 100644
--- a/sound/usb/pcm.c
+++ b/sound/usb/pcm.c
@@ -456,6 +456,7 @@ static int set_sync_endpoint(struct snd_usb_substream *subs,
         }
         ep = get_endpoint(alts, 1)->bEndpointAddress;
         if (get_endpoint(alts, 0)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
+            get_endpoint(alts, 0)->bSynchAddress != 0 &&
             ((is_playback && ep != (unsigned int)(get_endpoint(alts, 0)->bSynchAddress | USB_DIR_IN)) ||
              (!is_playback && ep != (unsigned int)(get_endpoint(alts, 0)->bSynchAddress & ~USB_DIR_IN)))) {
                 dev_err(&dev->dev,
diff --git a/sound/usb/quirks-table.h b/sound/usb/quirks-table.h
index e918ce346027..70c338f3ae24 100644
--- a/sound/usb/quirks-table.h
+++ b/sound/usb/quirks-table.h
@@ -3534,5 +3534,62 @@ AU0828_DEVICE(0x2040, 0x7270, "Hauppauge", "HVR-950Q"),
                 }
         }
 },
+{
+        /*
+         * PIONEER DJ DDJ-SX3
+         * PCM is 12 channels out, 10 channels in @ 44.1 fixed
+         * interface 0, vendor class alt setting 1 for endpoints 5 and 0x86
+         * The feedback for the output is the input.
+         */
+        USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0023),
+        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
+                .ifnum = QUIRK_ANY_INTERFACE,
+                .type = QUIRK_COMPOSITE,
+                .data = (const struct snd_usb_audio_quirk[]) {
+                        {
+                                .ifnum = 0,
+                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
+                                .data = &(const struct audioformat) {
+                                        .formats = SNDRV_PCM_FMTBIT_S32_LE,
+                                        .channels = 12,
+                                        .iface = 0,
+                                        .altsetting = 1,
+                                        .altset_idx = 1,
+                                        .endpoint = 0x05,
+                                        .ep_attr = USB_ENDPOINT_XFER_ISOC|
+                                                   USB_ENDPOINT_SYNC_ASYNC,
+                                        .rates = SNDRV_PCM_RATE_44100,
+                                        .rate_min = 44100,
+                                        .rate_max = 44100,
+                                        .nr_rates = 1,
+                                        .rate_table = (unsigned int[]) { 44100 }
+                                }
+                        },
+                        {
+                                .ifnum = 0,
+                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
+                                .data = &(const struct audioformat) {
+                                        .formats = SNDRV_PCM_FMTBIT_S32_LE,
+                                        .channels = 10,
+                                        .iface = 0,
+                                        .altsetting = 1,
+                                        .altset_idx = 1,
+                                        .endpoint = 0x86,
+                                        .ep_attr = USB_ENDPOINT_XFER_ISOC|
+                                                 USB_ENDPOINT_SYNC_ASYNC|
+                                                 USB_ENDPOINT_USAGE_IMPLICIT_FB,
+                                        .rates = SNDRV_PCM_RATE_44100,
+                                        .rate_min = 44100,
+                                        .rate_max = 44100,
+                                        .nr_rates = 1,
+                                        .rate_table = (unsigned int[]) { 44100 }
+                                }
+                        },
+                        {
+                                .ifnum = -1
+                        }
+                }
+        }
+},
 
 #undef USB_DEVICE_VENDOR_SPEC
diff --git a/sound/usb/stream.c b/sound/usb/stream.c
index 7ee9d17d0143..fc3e9fcfbc38 100644
--- a/sound/usb/stream.c
+++ b/sound/usb/stream.c
@@ -28,6 +28,14 @@
 #include "power.h"
 #include "media.h"
 
+static void audioformat_free(struct audioformat *fp)
+{
+        list_del(&fp->list); /* unlink for avoiding double-free */
+        kfree(fp->rate_table);
+        kfree(fp->chmap);
+        kfree(fp);
+}
+
 /*
  * free a substream
  */
@@ -37,11 +45,8 @@ static void free_substream(struct snd_usb_substream *subs)
 
         if (!subs->num_formats)
                 return; /* not initialized */
-        list_for_each_entry_safe(fp, n, &subs->fmt_list, list) {
-                kfree(fp->rate_table);
-                kfree(fp->chmap);
-                kfree(fp);
-        }
+        list_for_each_entry_safe(fp, n, &subs->fmt_list, list)
+                audioformat_free(fp);
         kfree(subs->rate_list.list);
         kfree(subs->str_pd);
         snd_media_stream_delete(subs);
@@ -832,8 +837,7 @@ found_clock:
         /* ok, let's parse further... */
         if (snd_usb_parse_audio_format(chip, fp, format,
                                         fmt, stream) < 0) {
-                kfree(fp->rate_table);
-                kfree(fp);
+                audioformat_free(fp);
                 return NULL;
         }
 
@@ -1043,8 +1047,7 @@ found_clock:
 
                 pd = kzalloc(sizeof(*pd), GFP_KERNEL);
                 if (!pd) {
-                        kfree(fp->rate_table);
-                        kfree(fp);
+                        audioformat_free(fp);
                         return NULL;
                 }
                 pd->pd_id = (stream == SNDRV_PCM_STREAM_PLAYBACK) ?
@@ -1063,9 +1066,7 @@ found_clock:
                 /* ok, let's parse further... */
                 if (snd_usb_parse_audio_format_v3(chip, fp, as, stream) < 0) {
                         kfree(pd);
-                        kfree(fp->chmap);
-                        kfree(fp->rate_table);
-                        kfree(fp);
+                        audioformat_free(fp);
                         return NULL;
                 }
         }
@@ -1076,7 +1077,9 @@ found_clock:
         return fp;
 }
 
-int snd_usb_parse_audio_interface(struct snd_usb_audio *chip, int iface_no)
+static int __snd_usb_parse_audio_interface(struct snd_usb_audio *chip,
+                                           int iface_no,
+                                           bool *has_non_pcm, bool non_pcm)
 {
         struct usb_device *dev;
         struct usb_interface *iface;
@@ -1177,6 +1180,16 @@ int snd_usb_parse_audio_interface(struct snd_usb_audio *chip, int iface_no)
                 else if (IS_ERR(fp))
                         return PTR_ERR(fp);
 
+                if (fp->fmt_type != UAC_FORMAT_TYPE_I)
+                        *has_non_pcm = true;
+                if ((fp->fmt_type == UAC_FORMAT_TYPE_I) == non_pcm) {
+                        audioformat_free(fp);
+                        kfree(pd);
+                        fp = NULL;
+                        pd = NULL;
+                        continue;
+                }
+
                 dev_dbg(&dev->dev, "%u:%d: add audio endpoint %#x\n", iface_no, altno, fp->endpoint);
                 if (protocol == UAC_VERSION_3)
                         err = snd_usb_add_audio_stream_v3(chip, stream, fp, pd);
@@ -1184,11 +1197,8 @@ int snd_usb_parse_audio_interface(struct snd_usb_audio *chip, int iface_no)
                         err = snd_usb_add_audio_stream(chip, stream, fp);
 
                 if (err < 0) {
-                        list_del(&fp->list); /* unlink for avoiding double-free */
+                        audioformat_free(fp);
                         kfree(pd);
-                        kfree(fp->rate_table);
-                        kfree(fp->chmap);
-                        kfree(fp);
                         return err;
                 }
                 /* try to set the interface... */
@@ -1199,3 +1209,23 @@ int snd_usb_parse_audio_interface(struct snd_usb_audio *chip, int iface_no)
         return 0;
 }
 
+int snd_usb_parse_audio_interface(struct snd_usb_audio *chip, int iface_no)
+{
+        int err;
+        bool has_non_pcm = false;
+
+        /* parse PCM formats */
+        err = __snd_usb_parse_audio_interface(chip, iface_no, &has_non_pcm, false);
+        if (err < 0)
+                return err;
+
+        if (has_non_pcm) {
+                /* parse non-PCM formats */
+                err = __snd_usb_parse_audio_interface(chip, iface_no, &has_non_pcm, true);
+                if (err < 0)
+                        return err;
+        }
+
+        return 0;
+}
+