git.samba.org / sfrench / cifs-2.6.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
ASoC: snd_soc_component_driver has snd_compr_ops
[sfrench/cifs-2.6.git] / sound / soc / soc-compress.c
diff --git a/sound/soc/soc-compress.c b/sound/soc/soc-compress.c
index 206f36bf43e8b8720db54a8b463305561979a20d..d9b1e6417fb947652f9186ea13c1845ca5882b85 100644 (file)
--- a/sound/soc/soc-compress.c
+++ b/sound/soc/soc-compress.c
@@ -30,8 +30,10 @@ static int soc_compr_open(struct snd_compr_stream *cstream)
 {
        struct snd_soc_pcm_runtime *rtd = cstream->private_data;
        struct snd_soc_platform *platform = rtd->platform;
+       struct snd_soc_component *component;
+       struct snd_soc_rtdcom_list *rtdcom;
        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
-       int ret = 0;
+       int ret = 0, __ret;
 
        mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 
@@ -44,7 +46,7 @@ static int soc_compr_open(struct snd_compr_stream *cstream)
                }
        }
 
-       if (platform->driver->compr_ops && platform->driver->compr_ops->open) {
+       if (platform && platform->driver->compr_ops && platform->driver->compr_ops->open) {
                ret = platform->driver->compr_ops->open(cstream);
                if (ret < 0) {
                        pr_err("compress asoc: can't open platform %s\n",
@@ -53,6 +55,27 @@ static int soc_compr_open(struct snd_compr_stream *cstream)
                }
        }
 
+       for_each_rtdcom(rtd, rtdcom) {
+               component = rtdcom->component;
+
+               /* ignore duplication for now */
+               if (platform && (component == &platform->component))
+                       continue;
+
+               if (!component->driver->compr_ops ||
+                   !component->driver->compr_ops->open)
+                       continue;
+
+               __ret = component->driver->compr_ops->open(cstream);
+               if (__ret < 0) {
+                       pr_err("compress asoc: can't open platform %s\n",
+                              component->name);
+                       ret = __ret;
+               }
+       }
+       if (ret < 0)
+               goto machine_err;
+
        if (rtd->dai_link->compr_ops && rtd->dai_link->compr_ops->startup) {
                ret = rtd->dai_link->compr_ops->startup(cstream);
                if (ret < 0) {
@@ -68,7 +91,21 @@ static int soc_compr_open(struct snd_compr_stream *cstream)
        return 0;
 
 machine_err:
-       if (platform->driver->compr_ops && platform->driver->compr_ops->free)
+       for_each_rtdcom(rtd, rtdcom) {
+               component = rtdcom->component;
+
+               /* ignore duplication for now */
+               if (platform && (component == &platform->component))
+                       continue;
+
+               if (!component->driver->compr_ops ||
+                   !component->driver->compr_ops->free)
+                       continue;
+
+               component->driver->compr_ops->free(cstream);
+       }
+
+       if (platform && platform->driver->compr_ops && platform->driver->compr_ops->free)
                platform->driver->compr_ops->free(cstream);
 plat_err:
        if (cpu_dai->driver->cops && cpu_dai->driver->cops->shutdown)
@@ -84,11 +121,13 @@ static int soc_compr_open_fe(struct snd_compr_stream *cstream)
        struct snd_pcm_substream *fe_substream =
                 fe->pcm->streams[cstream->direction].substream;
        struct snd_soc_platform *platform = fe->platform;
+       struct snd_soc_component *component;
+       struct snd_soc_rtdcom_list *rtdcom;
        struct snd_soc_dai *cpu_dai = fe->cpu_dai;
        struct snd_soc_dpcm *dpcm;
        struct snd_soc_dapm_widget_list *list;
        int stream;
-       int ret = 0;
+       int ret = 0, __ret;
 
        if (cstream->direction == SND_COMPRESS_PLAYBACK)
                stream = SNDRV_PCM_STREAM_PLAYBACK;
@@ -107,7 +146,7 @@ static int soc_compr_open_fe(struct snd_compr_stream *cstream)
        }
 
 
-       if (platform->driver->compr_ops && platform->driver->compr_ops->open) {
+       if (platform && platform->driver->compr_ops && platform->driver->compr_ops->open) {
                ret = platform->driver->compr_ops->open(cstream);
                if (ret < 0) {
                        pr_err("compress asoc: can't open platform %s\n",
@@ -116,6 +155,27 @@ static int soc_compr_open_fe(struct snd_compr_stream *cstream)
                }
        }
 
+       for_each_rtdcom(fe, rtdcom) {
+               component = rtdcom->component;
+
+               /* ignore duplication for now */
+               if (platform && (component == &platform->component))
+                       continue;
+
+               if (!component->driver->compr_ops ||
+                   !component->driver->compr_ops->open)
+                       continue;
+
+               __ret = component->driver->compr_ops->open(cstream);
+               if (__ret < 0) {
+                       pr_err("compress asoc: can't open platform %s\n",
+                              component->name);
+                       ret = __ret;
+               }
+       }
+       if (ret < 0)
+               goto machine_err;
+
        if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->startup) {
                ret = fe->dai_link->compr_ops->startup(cstream);
                if (ret < 0) {
@@ -167,7 +227,21 @@ fe_err:
        if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->shutdown)
                fe->dai_link->compr_ops->shutdown(cstream);
 machine_err:
-       if (platform->driver->compr_ops && platform->driver->compr_ops->free)
+       for_each_rtdcom(fe, rtdcom) {
+               component = rtdcom->component;
+
+               /* ignore duplication for now */
+               if (platform && (component == &platform->component))
+                       continue;
+
+               if (!component->driver->compr_ops ||
+                   !component->driver->compr_ops->free)
+                       continue;
+
+               component->driver->compr_ops->free(cstream);
+       }
+
+       if (platform && platform->driver->compr_ops && platform->driver->compr_ops->free)
                platform->driver->compr_ops->free(cstream);
 plat_err:
        if (cpu_dai->driver->cops && cpu_dai->driver->cops->shutdown)
@@ -210,6 +284,8 @@ static int soc_compr_free(struct snd_compr_stream *cstream)
 {
        struct snd_soc_pcm_runtime *rtd = cstream->private_data;
        struct snd_soc_platform *platform = rtd->platform;
+       struct snd_soc_component *component;
+       struct snd_soc_rtdcom_list *rtdcom;
        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
        struct snd_soc_dai *codec_dai = rtd->codec_dai;
        int stream;
@@ -235,7 +311,21 @@ static int soc_compr_free(struct snd_compr_stream *cstream)
        if (rtd->dai_link->compr_ops && rtd->dai_link->compr_ops->shutdown)
                rtd->dai_link->compr_ops->shutdown(cstream);
 
-       if (platform->driver->compr_ops && platform->driver->compr_ops->free)
+       for_each_rtdcom(rtd, rtdcom) {
+               component = rtdcom->component;
+
+               /* ignore duplication for now */
+               if (platform && (component == &platform->component))
+                       continue;
+
+               if (!component->driver->compr_ops ||
+                   !component->driver->compr_ops->free)
+                       continue;
+
+               component->driver->compr_ops->free(cstream);
+       }
+
+       if (platform && platform->driver->compr_ops && platform->driver->compr_ops->free)
                platform->driver->compr_ops->free(cstream);
 
        if (cpu_dai->driver->cops && cpu_dai->driver->cops->shutdown)
@@ -267,6 +357,8 @@ static int soc_compr_free_fe(struct snd_compr_stream *cstream)
 {
        struct snd_soc_pcm_runtime *fe = cstream->private_data;
        struct snd_soc_platform *platform = fe->platform;
+       struct snd_soc_component *component;
+       struct snd_soc_rtdcom_list *rtdcom;
        struct snd_soc_dai *cpu_dai = fe->cpu_dai;
        struct snd_soc_dpcm *dpcm;
        int stream, ret;
@@ -304,9 +396,23 @@ static int soc_compr_free_fe(struct snd_compr_stream *cstream)
        if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->shutdown)
                fe->dai_link->compr_ops->shutdown(cstream);
 
-       if (platform->driver->compr_ops && platform->driver->compr_ops->free)
+       if (platform && platform->driver->compr_ops && platform->driver->compr_ops->free)
                platform->driver->compr_ops->free(cstream);
 
+       for_each_rtdcom(fe, rtdcom) {
+               component = rtdcom->component;
+
+               /* ignore duplication for now */
+               if (platform && (component == &platform->component))
+                       continue;
+
+               if (!component->driver->compr_ops ||
+                   !component->driver->compr_ops->free)
+                       continue;
+
+               component->driver->compr_ops->free(cstream);
+       }
+
        if (cpu_dai->driver->cops && cpu_dai->driver->cops->shutdown)
                cpu_dai->driver->cops->shutdown(cstream, cpu_dai);
 
@@ -319,18 +425,38 @@ static int soc_compr_trigger(struct snd_compr_stream *cstream, int cmd)
 
        struct snd_soc_pcm_runtime *rtd = cstream->private_data;
        struct snd_soc_platform *platform = rtd->platform;
+       struct snd_soc_component *component;
+       struct snd_soc_rtdcom_list *rtdcom;
        struct snd_soc_dai *codec_dai = rtd->codec_dai;
        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
-       int ret = 0;
+       int ret = 0, __ret;
 
        mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 
-       if (platform->driver->compr_ops && platform->driver->compr_ops->trigger) {
+       if (platform && platform->driver->compr_ops && platform->driver->compr_ops->trigger) {
                ret = platform->driver->compr_ops->trigger(cstream, cmd);
                if (ret < 0)
                        goto out;
        }
 
+       for_each_rtdcom(rtd, rtdcom) {
+               component = rtdcom->component;
+
+               /* ignore duplication for now */
+               if (platform && (component == &platform->component))
+                       continue;
+
+               if (!component->driver->compr_ops ||
+                   !component->driver->compr_ops->trigger)
+                       continue;
+
+               __ret = component->driver->compr_ops->trigger(cstream, cmd);
+               if (__ret < 0)
+                       ret = __ret;
+       }
+       if (ret < 0)
+               goto out;
+
        if (cpu_dai->driver->cops && cpu_dai->driver->cops->trigger)
                cpu_dai->driver->cops->trigger(cstream, cmd, cpu_dai);
 
@@ -353,16 +479,36 @@ static int soc_compr_trigger_fe(struct snd_compr_stream *cstream, int cmd)
 {
        struct snd_soc_pcm_runtime *fe = cstream->private_data;
        struct snd_soc_platform *platform = fe->platform;
+       struct snd_soc_component *component;
+       struct snd_soc_rtdcom_list *rtdcom;
        struct snd_soc_dai *cpu_dai = fe->cpu_dai;
-       int ret = 0, stream;
+       int ret = 0, __ret, stream;
 
        if (cmd == SND_COMPR_TRIGGER_PARTIAL_DRAIN ||
                cmd == SND_COMPR_TRIGGER_DRAIN) {
 
-               if (platform->driver->compr_ops &&
+               if (platform &&
+                   platform->driver->compr_ops &&
                    platform->driver->compr_ops->trigger)
                        return platform->driver->compr_ops->trigger(cstream,
                                                                    cmd);
+
+               for_each_rtdcom(fe, rtdcom) {
+                       component = rtdcom->component;
+
+                       /* ignore duplication for now */
+                       if (platform && (component == &platform->component))
+                               continue;
+
+                       if (!component->driver->compr_ops ||
+                           !component->driver->compr_ops->trigger)
+                               continue;
+
+                       __ret = component->driver->compr_ops->trigger(cstream, cmd);
+                       if (__ret < 0)
+                               ret = __ret;
+               }
+               return ret;
        }
 
        if (cstream->direction == SND_COMPRESS_PLAYBACK)
@@ -379,12 +525,30 @@ static int soc_compr_trigger_fe(struct snd_compr_stream *cstream, int cmd)
                        goto out;
        }
 
-       if (platform->driver->compr_ops && platform->driver->compr_ops->trigger) {
+       if (platform && platform->driver->compr_ops && platform->driver->compr_ops->trigger) {
                ret = platform->driver->compr_ops->trigger(cstream, cmd);
                if (ret < 0)
                        goto out;
        }
 
+       for_each_rtdcom(fe, rtdcom) {
+               component = rtdcom->component;
+
+               /* ignore duplication for now */
+               if (platform && (component == &platform->component))
+                       continue;
+
+               if (!component->driver->compr_ops ||
+                   !component->driver->compr_ops->trigger)
+                       continue;
+
+               __ret = component->driver->compr_ops->trigger(cstream, cmd);
+               if (__ret < 0)
+                       ret = __ret;
+       }
+       if (ret < 0)
+               goto out;
+
        fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
 
        ret = dpcm_be_dai_trigger(fe, stream, cmd);
@@ -415,8 +579,10 @@ static int soc_compr_set_params(struct snd_compr_stream *cstream,
 {
        struct snd_soc_pcm_runtime *rtd = cstream->private_data;
        struct snd_soc_platform *platform = rtd->platform;
+       struct snd_soc_component *component;
+       struct snd_soc_rtdcom_list *rtdcom;
        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
-       int ret = 0;
+       int ret = 0, __ret;
 
        mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 
@@ -432,12 +598,30 @@ static int soc_compr_set_params(struct snd_compr_stream *cstream,
                        goto err;
        }
 
-       if (platform->driver->compr_ops && platform->driver->compr_ops->set_params) {
+       if (platform && platform->driver->compr_ops && platform->driver->compr_ops->set_params) {
                ret = platform->driver->compr_ops->set_params(cstream, params);
                if (ret < 0)
                        goto err;
        }
 
+       for_each_rtdcom(rtd, rtdcom) {
+               component = rtdcom->component;
+
+               /* ignore duplication for now */
+               if (platform && (component == &platform->component))
+                       continue;
+
+               if (!component->driver->compr_ops ||
+                   !component->driver->compr_ops->set_params)
+                       continue;
+
+               __ret = component->driver->compr_ops->set_params(cstream, params);
+               if (__ret < 0)
+                       ret = __ret;
+       }
+       if (ret < 0)
+               goto err;
+
        if (rtd->dai_link->compr_ops && rtd->dai_link->compr_ops->set_params) {
                ret = rtd->dai_link->compr_ops->set_params(cstream);
                if (ret < 0)
@@ -471,8 +655,10 @@ static int soc_compr_set_params_fe(struct snd_compr_stream *cstream,
        struct snd_pcm_substream *fe_substream =
                 fe->pcm->streams[cstream->direction].substream;
        struct snd_soc_platform *platform = fe->platform;
+       struct snd_soc_component *component;
+       struct snd_soc_rtdcom_list *rtdcom;
        struct snd_soc_dai *cpu_dai = fe->cpu_dai;
-       int ret = 0, stream;
+       int ret = 0, __ret, stream;
 
        if (cstream->direction == SND_COMPRESS_PLAYBACK)
                stream = SNDRV_PCM_STREAM_PLAYBACK;
@@ -487,12 +673,30 @@ static int soc_compr_set_params_fe(struct snd_compr_stream *cstream,
                        goto out;
        }
 
-       if (platform->driver->compr_ops && platform->driver->compr_ops->set_params) {
+       if (platform && platform->driver->compr_ops && platform->driver->compr_ops->set_params) {
                ret = platform->driver->compr_ops->set_params(cstream, params);
                if (ret < 0)
                        goto out;
        }
 
+       for_each_rtdcom(fe, rtdcom) {
+               component = rtdcom->component;
+
+               /* ignore duplication for now */
+               if (platform && (component == &platform->component))
+                       continue;
+
+               if (!component->driver->compr_ops ||
+                   !component->driver->compr_ops->set_params)
+                       continue;
+
+               __ret = component->driver->compr_ops->set_params(cstream, params);
+               if (__ret < 0)
+                       ret = __ret;
+       }
+       if (ret < 0)
+               goto out;
+
        if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->set_params) {
                ret = fe->dai_link->compr_ops->set_params(cstream);
                if (ret < 0)
@@ -531,8 +735,10 @@ static int soc_compr_get_params(struct snd_compr_stream *cstream,
 {
        struct snd_soc_pcm_runtime *rtd = cstream->private_data;
        struct snd_soc_platform *platform = rtd->platform;
+       struct snd_soc_component *component;
+       struct snd_soc_rtdcom_list *rtdcom;
        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
-       int ret = 0;
+       int ret = 0, __ret;
 
        mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 
@@ -542,8 +748,27 @@ static int soc_compr_get_params(struct snd_compr_stream *cstream,
                        goto err;
        }
 
-       if (platform->driver->compr_ops && platform->driver->compr_ops->get_params)
+       if (platform && platform->driver->compr_ops && platform->driver->compr_ops->get_params) {
                ret = platform->driver->compr_ops->get_params(cstream, params);
+               if (ret < 0)
+                       goto err;
+       }
+
+       for_each_rtdcom(rtd, rtdcom) {
+               component = rtdcom->component;
+
+               /* ignore duplication for now */
+               if (platform && (component == &platform->component))
+                       continue;
+
+               if (!component->driver->compr_ops ||
+                   !component->driver->compr_ops->get_params)
+                       continue;
+
+               __ret = component->driver->compr_ops->get_params(cstream, params);
+               if (__ret < 0)
+                       ret = __ret;
+       }
 
 err:
        mutex_unlock(&rtd->pcm_mutex);
@@ -555,13 +780,35 @@ static int soc_compr_get_caps(struct snd_compr_stream *cstream,
 {
        struct snd_soc_pcm_runtime *rtd = cstream->private_data;
        struct snd_soc_platform *platform = rtd->platform;
-       int ret = 0;
+       struct snd_soc_component *component;
+       struct snd_soc_rtdcom_list *rtdcom;
+       int ret = 0, __ret;
 
        mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 
-       if (platform->driver->compr_ops && platform->driver->compr_ops->get_caps)
+       if (platform && platform->driver->compr_ops && platform->driver->compr_ops->get_caps) {
                ret = platform->driver->compr_ops->get_caps(cstream, caps);
+               if (ret < 0)
+                       goto err;
+       }
+
+       for_each_rtdcom(rtd, rtdcom) {
+               component = rtdcom->component;
 
+               /* ignore duplication for now */
+               if (platform && (component == &platform->component))
+                       continue;
+
+               if (!component->driver->compr_ops ||
+                   !component->driver->compr_ops->get_caps)
+                       continue;
+
+               __ret = component->driver->compr_ops->get_caps(cstream, caps);
+               if (__ret < 0)
+                       ret = __ret;
+       }
+
+err:
        mutex_unlock(&rtd->pcm_mutex);
        return ret;
 }
@@ -571,13 +818,35 @@ static int soc_compr_get_codec_caps(struct snd_compr_stream *cstream,
 {
        struct snd_soc_pcm_runtime *rtd = cstream->private_data;
        struct snd_soc_platform *platform = rtd->platform;
-       int ret = 0;
+       struct snd_soc_component *component;
+       struct snd_soc_rtdcom_list *rtdcom;
+       int ret = 0, __ret;
 
        mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 
-       if (platform->driver->compr_ops && platform->driver->compr_ops->get_codec_caps)
+       if (platform && platform->driver->compr_ops && platform->driver->compr_ops->get_codec_caps) {
                ret = platform->driver->compr_ops->get_codec_caps(cstream, codec);
+               if (ret < 0)
+                       goto err;
+       }
+
+       for_each_rtdcom(rtd, rtdcom) {
+               component = rtdcom->component;
+
+               /* ignore duplication for now */
+               if (platform && (component == &platform->component))
+                       continue;
 
+               if (!component->driver->compr_ops ||
+                   !component->driver->compr_ops->get_codec_caps)
+                       continue;
+
+               __ret = component->driver->compr_ops->get_codec_caps(cstream, codec);
+               if (__ret < 0)
+                       ret = __ret;
+       }
+
+err:
        mutex_unlock(&rtd->pcm_mutex);
        return ret;
 }
@@ -586,8 +855,10 @@ static int soc_compr_ack(struct snd_compr_stream *cstream, size_t bytes)
 {
        struct snd_soc_pcm_runtime *rtd = cstream->private_data;
        struct snd_soc_platform *platform = rtd->platform;
+       struct snd_soc_component *component;
+       struct snd_soc_rtdcom_list *rtdcom;
        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
-       int ret = 0;
+       int ret = 0, __ret;
 
        mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 
@@ -597,8 +868,27 @@ static int soc_compr_ack(struct snd_compr_stream *cstream, size_t bytes)
                        goto err;
        }
 
-       if (platform->driver->compr_ops && platform->driver->compr_ops->ack)
+       if (platform && platform->driver->compr_ops && platform->driver->compr_ops->ack) {
                ret = platform->driver->compr_ops->ack(cstream, bytes);
+               if (ret < 0)
+                       goto err;
+       }
+
+       for_each_rtdcom(rtd, rtdcom) {
+               component = rtdcom->component;
+
+               /* ignore duplication for now */
+               if (platform && (component == &platform->component))
+                       continue;
+
+               if (!component->driver->compr_ops ||
+                   !component->driver->compr_ops->ack)
+                       continue;
+
+               __ret = component->driver->compr_ops->ack(cstream, bytes);
+               if (__ret < 0)
+                       ret = __ret;
+       }
 
 err:
        mutex_unlock(&rtd->pcm_mutex);
@@ -610,7 +900,9 @@ static int soc_compr_pointer(struct snd_compr_stream *cstream,
 {
        struct snd_soc_pcm_runtime *rtd = cstream->private_data;
        struct snd_soc_platform *platform = rtd->platform;
-       int ret = 0;
+       struct snd_soc_component *component;
+       struct snd_soc_rtdcom_list *rtdcom;
+       int ret = 0, __ret;
        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 
        mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
@@ -618,9 +910,29 @@ static int soc_compr_pointer(struct snd_compr_stream *cstream,
        if (cpu_dai->driver->cops && cpu_dai->driver->cops->pointer)
                cpu_dai->driver->cops->pointer(cstream, tstamp, cpu_dai);
 
-       if (platform->driver->compr_ops && platform->driver->compr_ops->pointer)
+       if (platform && platform->driver->compr_ops && platform->driver->compr_ops->pointer) {
                ret = platform->driver->compr_ops->pointer(cstream, tstamp);
+               if (ret < 0)
+                       goto err;
+       }
+
+       for_each_rtdcom(rtd, rtdcom) {
+               component = rtdcom->component;
+
+               /* ignore duplication for now */
+               if (platform && (component == &platform->component))
+                       continue;
 
+               if (!component->driver->compr_ops ||
+                   !component->driver->compr_ops->pointer)
+                       continue;
+
+               __ret = component->driver->compr_ops->pointer(cstream, tstamp);
+               if (__ret < 0)
+                       ret = __ret;
+       }
+
+err:
        mutex_unlock(&rtd->pcm_mutex);
        return ret;
 }
@@ -630,13 +942,34 @@ static int soc_compr_copy(struct snd_compr_stream *cstream,
 {
        struct snd_soc_pcm_runtime *rtd = cstream->private_data;
        struct snd_soc_platform *platform = rtd->platform;
-       int ret = 0;
+       struct snd_soc_component *component;
+       struct snd_soc_rtdcom_list *rtdcom;
+       int ret = 0, __ret;
 
        mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 
-       if (platform->driver->compr_ops && platform->driver->compr_ops->copy)
+       if (platform && platform->driver->compr_ops && platform->driver->compr_ops->copy) {
                ret = platform->driver->compr_ops->copy(cstream, buf, count);
+               if (ret < 0)
+                       goto err;
+       }
+
+       for_each_rtdcom(rtd, rtdcom) {
+               component = rtdcom->component;
+
+               /* ignore duplication for now */
+               if (platform && (component == &platform->component))
+                       continue;
 
+               if (!component->driver->compr_ops ||
+                   !component->driver->compr_ops->copy)
+                       continue;
+
+               __ret = component->driver->compr_ops->copy(cstream, buf, count);
+               if (__ret < 0)
+                       ret = __ret;
+       }
+err:
        mutex_unlock(&rtd->pcm_mutex);
        return ret;
 }
@@ -646,8 +979,10 @@ static int soc_compr_set_metadata(struct snd_compr_stream *cstream,
 {
        struct snd_soc_pcm_runtime *rtd = cstream->private_data;
        struct snd_soc_platform *platform = rtd->platform;
+       struct snd_soc_component *component;
+       struct snd_soc_rtdcom_list *rtdcom;
        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
-       int ret = 0;
+       int ret = 0, __ret;
 
        if (cpu_dai->driver->cops && cpu_dai->driver->cops->set_metadata) {
                ret = cpu_dai->driver->cops->set_metadata(cstream, metadata, cpu_dai);
@@ -655,8 +990,27 @@ static int soc_compr_set_metadata(struct snd_compr_stream *cstream,
                        return ret;
        }
 
-       if (platform->driver->compr_ops && platform->driver->compr_ops->set_metadata)
+       if (platform && platform->driver->compr_ops && platform->driver->compr_ops->set_metadata) {
                ret = platform->driver->compr_ops->set_metadata(cstream, metadata);
+               if (ret < 0)
+                       return ret;
+       }
+
+       for_each_rtdcom(rtd, rtdcom) {
+               component = rtdcom->component;
+
+               /* ignore duplication for now */
+               if (platform && (component == &platform->component))
+                       continue;
+
+               if (!component->driver->compr_ops ||
+                   !component->driver->compr_ops->set_metadata)
+                       continue;
+
+               __ret = component->driver->compr_ops->set_metadata(cstream, metadata);
+               if (__ret < 0)
+                       ret = __ret;
+       }
 
        return ret;
 }
@@ -666,8 +1020,10 @@ static int soc_compr_get_metadata(struct snd_compr_stream *cstream,
 {
        struct snd_soc_pcm_runtime *rtd = cstream->private_data;
        struct snd_soc_platform *platform = rtd->platform;
+       struct snd_soc_component *component;
+       struct snd_soc_rtdcom_list *rtdcom;
        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
-       int ret = 0;
+       int ret = 0, __ret;
 
        if (cpu_dai->driver->cops && cpu_dai->driver->cops->get_metadata) {
                ret = cpu_dai->driver->cops->get_metadata(cstream, metadata, cpu_dai);
@@ -675,8 +1031,27 @@ static int soc_compr_get_metadata(struct snd_compr_stream *cstream,
                        return ret;
        }
 
-       if (platform->driver->compr_ops && platform->driver->compr_ops->get_metadata)
+       if (platform && platform->driver->compr_ops && platform->driver->compr_ops->get_metadata) {
                ret = platform->driver->compr_ops->get_metadata(cstream, metadata);
+               if (ret < 0)
+                       return ret;
+       }
+
+       for_each_rtdcom(rtd, rtdcom) {
+               component = rtdcom->component;
+
+               /* ignore duplication for now */
+               if (platform && (component == &platform->component))
+                       continue;
+
+               if (!component->driver->compr_ops ||
+                   !component->driver->compr_ops->get_metadata)
+                       continue;
+
+               __ret = component->driver->compr_ops->get_metadata(cstream, metadata);
+               if (__ret < 0)
+                       ret = __ret;
+       }
 
        return ret;
 }
@@ -723,6 +1098,8 @@ int snd_soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num)
 {
        struct snd_soc_codec *codec = rtd->codec;
        struct snd_soc_platform *platform = rtd->platform;
+       struct snd_soc_component *component;
+       struct snd_soc_rtdcom_list *rtdcom;
        struct snd_soc_dai *codec_dai = rtd->codec_dai;
        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
        struct snd_compr *compr;
@@ -737,9 +1114,6 @@ int snd_soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num)
        }
 
        /* check client and interface hw capabilities */
-       snprintf(new_name, sizeof(new_name), "%s %s-%d",
-                       rtd->dai_link->stream_name, codec_dai->name, num);
-
        if (codec_dai->driver->playback.channels_min)
                playback = 1;
        if (codec_dai->driver->capture.channels_min)
@@ -758,21 +1132,18 @@ int snd_soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num)
                return -EINVAL;
        }
 
-       if(playback)
+       if (playback)
                direction = SND_COMPRESS_PLAYBACK;
        else
                direction = SND_COMPRESS_CAPTURE;
 
        compr = kzalloc(sizeof(*compr), GFP_KERNEL);
-       if (compr == NULL) {
-               snd_printk(KERN_ERR "Cannot allocate compr\n");
+       if (!compr)
                return -ENOMEM;
-       }
 
        compr->ops = devm_kzalloc(rtd->card->dev, sizeof(soc_compr_ops),
                                  GFP_KERNEL);
-       if (compr->ops == NULL) {
-               dev_err(rtd->card->dev, "Cannot allocate compressed ops\n");
+       if (!compr->ops) {
                ret = -ENOMEM;
                goto compr_err;
        }
@@ -797,19 +1168,34 @@ int snd_soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num)
                else if (rtd->dai_link->dpcm_capture)
                        be_pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream->private_data = rtd;
                memcpy(compr->ops, &soc_compr_dyn_ops, sizeof(soc_compr_dyn_ops));
-       } else
+       } else {
+               snprintf(new_name, sizeof(new_name), "%s %s-%d",
+                       rtd->dai_link->stream_name, codec_dai->name, num);
+
                memcpy(compr->ops, &soc_compr_ops, sizeof(soc_compr_ops));
+       }
+
 
        /* Add copy callback for not memory mapped DSPs */
-       if (platform->driver->compr_ops && platform->driver->compr_ops->copy)
+       if (platform && platform->driver->compr_ops && platform->driver->compr_ops->copy)
                compr->ops->copy = soc_compr_copy;
 
-       mutex_init(&compr->lock);
+       for_each_rtdcom(rtd, rtdcom) {
+               component = rtdcom->component;
 
-       snprintf(new_name, sizeof(new_name), "%s %s-%d",
-                rtd->dai_link->stream_name,
-                rtd->codec_dai->name, num);
+               /* ignore duplication for now */
+               if (platform && (component == &platform->component))
+                       continue;
 
+               if (!component->driver->compr_ops ||
+                   !component->driver->compr_ops->copy)
+                       continue;
+
+               compr->ops->copy = soc_compr_copy;
+       }
+
+
+       mutex_init(&compr->lock);
        ret = snd_compress_new(rtd->card->snd_card, num, direction,
                                new_name, compr);
        if (ret < 0) {
Unnamed repository; edit this file 'description' to name the repository.