2018-07-02 06:24:57 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0+
|
|
|
|
|
//
|
|
|
|
|
// soc-compress.c -- ALSA SoC Compress
|
|
|
|
|
//
|
|
|
|
|
// Copyright (C) 2012 Intel Corp.
|
|
|
|
|
//
|
|
|
|
|
// Authors: Namarta Kohli <namartax.kohli@intel.com>
|
|
|
|
|
// Ramesh Babu K V <ramesh.babu@linux.intel.com>
|
|
|
|
|
// Vinod Koul <vinod.koul@linux.intel.com>
|
2012-08-16 11:40:41 +00:00
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
|
#include <linux/init.h>
|
|
|
|
|
#include <linux/delay.h>
|
|
|
|
|
#include <linux/slab.h>
|
|
|
|
|
#include <linux/workqueue.h>
|
|
|
|
|
#include <sound/core.h>
|
|
|
|
|
#include <sound/compress_params.h>
|
|
|
|
|
#include <sound/compress_driver.h>
|
|
|
|
|
#include <sound/soc.h>
|
|
|
|
|
#include <sound/initval.h>
|
2014-01-17 17:03:56 +00:00
|
|
|
#include <sound/soc-dpcm.h>
|
2019-12-17 09:58:50 +00:00
|
|
|
#include <linux/pm_runtime.h>
|
2012-08-16 11:40:41 +00:00
|
|
|
|
2018-04-24 15:39:03 +00:00
|
|
|
static int soc_compr_components_open(struct snd_compr_stream *cstream,
|
|
|
|
|
struct snd_soc_component **last)
|
2012-08-16 11:40:41 +00:00
|
|
|
{
|
|
|
|
|
struct snd_soc_pcm_runtime *rtd = cstream->private_data;
|
2017-10-11 01:37:45 +00:00
|
|
|
struct snd_soc_component *component;
|
ASoC: soc-core: remove snd_soc_rtdcom_list
Current ALSA SoC is using struct snd_soc_rtdcom_list to
connecting component to rtd by using list_head.
struct snd_soc_rtdcom_list {
struct snd_soc_component *component;
struct list_head list; /* rtd::component_list */
};
struct snd_soc_pcm_runtime {
...
struct list_head component_list; /* list of connected components */
...
};
The CPU/Codec/Platform component which will be connected to rtd (a)
is indicated via dai_link at snd_soc_add_pcm_runtime()
int snd_soc_add_pcm_runtime(...)
{
...
/* Find CPU from registered CPUs */
rtd->cpu_dai = snd_soc_find_dai(dai_link->cpus);
...
(a) snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);
...
/* Find CODEC from registered CODECs */
(b) for_each_link_codecs(dai_link, i, codec) {
rtd->codec_dais[i] = snd_soc_find_dai(codec);
...
(a) snd_soc_rtdcom_add(rtd, rtd->codec_dais[i]->component);
}
...
/* Find PLATFORM from registered PLATFORMs */
(b) for_each_link_platforms(dai_link, i, platform) {
for_each_component(component) {
...
(a) snd_soc_rtdcom_add(rtd, component);
}
}
}
It shows, it is possible to know how many components will be
connected to rtd by using
dai_link->num_cpus
dai_link->num_codecs
dai_link->num_platforms
If so, we can use component pointer array instead of list_head,
in such case, code can be more simple.
This patch removes struct snd_soc_rtdcom_list that is only
of temporary value, and convert to pointer array.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-By: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Link: https://lore.kernel.org/r/87a76wt4wm.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-01-10 02:35:21 +00:00
|
|
|
int i, ret;
|
2012-08-16 11:40:41 +00:00
|
|
|
|
ASoC: soc-core: remove snd_soc_rtdcom_list
Current ALSA SoC is using struct snd_soc_rtdcom_list to
connecting component to rtd by using list_head.
struct snd_soc_rtdcom_list {
struct snd_soc_component *component;
struct list_head list; /* rtd::component_list */
};
struct snd_soc_pcm_runtime {
...
struct list_head component_list; /* list of connected components */
...
};
The CPU/Codec/Platform component which will be connected to rtd (a)
is indicated via dai_link at snd_soc_add_pcm_runtime()
int snd_soc_add_pcm_runtime(...)
{
...
/* Find CPU from registered CPUs */
rtd->cpu_dai = snd_soc_find_dai(dai_link->cpus);
...
(a) snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);
...
/* Find CODEC from registered CODECs */
(b) for_each_link_codecs(dai_link, i, codec) {
rtd->codec_dais[i] = snd_soc_find_dai(codec);
...
(a) snd_soc_rtdcom_add(rtd, rtd->codec_dais[i]->component);
}
...
/* Find PLATFORM from registered PLATFORMs */
(b) for_each_link_platforms(dai_link, i, platform) {
for_each_component(component) {
...
(a) snd_soc_rtdcom_add(rtd, component);
}
}
}
It shows, it is possible to know how many components will be
connected to rtd by using
dai_link->num_cpus
dai_link->num_codecs
dai_link->num_platforms
If so, we can use component pointer array instead of list_head,
in such case, code can be more simple.
This patch removes struct snd_soc_rtdcom_list that is only
of temporary value, and convert to pointer array.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-By: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Link: https://lore.kernel.org/r/87a76wt4wm.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-01-10 02:35:21 +00:00
|
|
|
for_each_rtd_components(rtd, i, component) {
|
2017-10-11 01:37:45 +00:00
|
|
|
if (!component->driver->compr_ops ||
|
|
|
|
|
!component->driver->compr_ops->open)
|
|
|
|
|
continue;
|
|
|
|
|
|
2018-04-24 15:39:01 +00:00
|
|
|
ret = component->driver->compr_ops->open(cstream);
|
|
|
|
|
if (ret < 0) {
|
2018-01-26 13:08:45 +00:00
|
|
|
dev_err(component->dev,
|
|
|
|
|
"Compress ASoC: can't open platform %s: %d\n",
|
2018-04-24 15:39:01 +00:00
|
|
|
component->name, ret);
|
2018-04-24 15:39:03 +00:00
|
|
|
|
|
|
|
|
*last = component;
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
*last = NULL;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int soc_compr_components_free(struct snd_compr_stream *cstream,
|
|
|
|
|
struct snd_soc_component *last)
|
|
|
|
|
{
|
|
|
|
|
struct snd_soc_pcm_runtime *rtd = cstream->private_data;
|
|
|
|
|
struct snd_soc_component *component;
|
ASoC: soc-core: remove snd_soc_rtdcom_list
Current ALSA SoC is using struct snd_soc_rtdcom_list to
connecting component to rtd by using list_head.
struct snd_soc_rtdcom_list {
struct snd_soc_component *component;
struct list_head list; /* rtd::component_list */
};
struct snd_soc_pcm_runtime {
...
struct list_head component_list; /* list of connected components */
...
};
The CPU/Codec/Platform component which will be connected to rtd (a)
is indicated via dai_link at snd_soc_add_pcm_runtime()
int snd_soc_add_pcm_runtime(...)
{
...
/* Find CPU from registered CPUs */
rtd->cpu_dai = snd_soc_find_dai(dai_link->cpus);
...
(a) snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);
...
/* Find CODEC from registered CODECs */
(b) for_each_link_codecs(dai_link, i, codec) {
rtd->codec_dais[i] = snd_soc_find_dai(codec);
...
(a) snd_soc_rtdcom_add(rtd, rtd->codec_dais[i]->component);
}
...
/* Find PLATFORM from registered PLATFORMs */
(b) for_each_link_platforms(dai_link, i, platform) {
for_each_component(component) {
...
(a) snd_soc_rtdcom_add(rtd, component);
}
}
}
It shows, it is possible to know how many components will be
connected to rtd by using
dai_link->num_cpus
dai_link->num_codecs
dai_link->num_platforms
If so, we can use component pointer array instead of list_head,
in such case, code can be more simple.
This patch removes struct snd_soc_rtdcom_list that is only
of temporary value, and convert to pointer array.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-By: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Link: https://lore.kernel.org/r/87a76wt4wm.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-01-10 02:35:21 +00:00
|
|
|
int i;
|
2018-04-24 15:39:03 +00:00
|
|
|
|
ASoC: soc-core: remove snd_soc_rtdcom_list
Current ALSA SoC is using struct snd_soc_rtdcom_list to
connecting component to rtd by using list_head.
struct snd_soc_rtdcom_list {
struct snd_soc_component *component;
struct list_head list; /* rtd::component_list */
};
struct snd_soc_pcm_runtime {
...
struct list_head component_list; /* list of connected components */
...
};
The CPU/Codec/Platform component which will be connected to rtd (a)
is indicated via dai_link at snd_soc_add_pcm_runtime()
int snd_soc_add_pcm_runtime(...)
{
...
/* Find CPU from registered CPUs */
rtd->cpu_dai = snd_soc_find_dai(dai_link->cpus);
...
(a) snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);
...
/* Find CODEC from registered CODECs */
(b) for_each_link_codecs(dai_link, i, codec) {
rtd->codec_dais[i] = snd_soc_find_dai(codec);
...
(a) snd_soc_rtdcom_add(rtd, rtd->codec_dais[i]->component);
}
...
/* Find PLATFORM from registered PLATFORMs */
(b) for_each_link_platforms(dai_link, i, platform) {
for_each_component(component) {
...
(a) snd_soc_rtdcom_add(rtd, component);
}
}
}
It shows, it is possible to know how many components will be
connected to rtd by using
dai_link->num_cpus
dai_link->num_codecs
dai_link->num_platforms
If so, we can use component pointer array instead of list_head,
in such case, code can be more simple.
This patch removes struct snd_soc_rtdcom_list that is only
of temporary value, and convert to pointer array.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-By: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Link: https://lore.kernel.org/r/87a76wt4wm.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-01-10 02:35:21 +00:00
|
|
|
for_each_rtd_components(rtd, i, component) {
|
2018-04-24 15:39:03 +00:00
|
|
|
if (component == last)
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
if (!component->driver->compr_ops ||
|
|
|
|
|
!component->driver->compr_ops->free)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
component->driver->compr_ops->free(cstream);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int soc_compr_open(struct snd_compr_stream *cstream)
|
|
|
|
|
{
|
|
|
|
|
struct snd_soc_pcm_runtime *rtd = cstream->private_data;
|
2019-12-17 09:58:50 +00:00
|
|
|
struct snd_soc_component *component, *save = NULL;
|
2018-04-24 15:39:03 +00:00
|
|
|
struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
|
ASoC: soc-core: remove snd_soc_rtdcom_list
Current ALSA SoC is using struct snd_soc_rtdcom_list to
connecting component to rtd by using list_head.
struct snd_soc_rtdcom_list {
struct snd_soc_component *component;
struct list_head list; /* rtd::component_list */
};
struct snd_soc_pcm_runtime {
...
struct list_head component_list; /* list of connected components */
...
};
The CPU/Codec/Platform component which will be connected to rtd (a)
is indicated via dai_link at snd_soc_add_pcm_runtime()
int snd_soc_add_pcm_runtime(...)
{
...
/* Find CPU from registered CPUs */
rtd->cpu_dai = snd_soc_find_dai(dai_link->cpus);
...
(a) snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);
...
/* Find CODEC from registered CODECs */
(b) for_each_link_codecs(dai_link, i, codec) {
rtd->codec_dais[i] = snd_soc_find_dai(codec);
...
(a) snd_soc_rtdcom_add(rtd, rtd->codec_dais[i]->component);
}
...
/* Find PLATFORM from registered PLATFORMs */
(b) for_each_link_platforms(dai_link, i, platform) {
for_each_component(component) {
...
(a) snd_soc_rtdcom_add(rtd, component);
}
}
}
It shows, it is possible to know how many components will be
connected to rtd by using
dai_link->num_cpus
dai_link->num_codecs
dai_link->num_platforms
If so, we can use component pointer array instead of list_head,
in such case, code can be more simple.
This patch removes struct snd_soc_rtdcom_list that is only
of temporary value, and convert to pointer array.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-By: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Link: https://lore.kernel.org/r/87a76wt4wm.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-01-10 02:35:21 +00:00
|
|
|
int ret, i;
|
2018-04-24 15:39:03 +00:00
|
|
|
|
ASoC: soc-core: remove snd_soc_rtdcom_list
Current ALSA SoC is using struct snd_soc_rtdcom_list to
connecting component to rtd by using list_head.
struct snd_soc_rtdcom_list {
struct snd_soc_component *component;
struct list_head list; /* rtd::component_list */
};
struct snd_soc_pcm_runtime {
...
struct list_head component_list; /* list of connected components */
...
};
The CPU/Codec/Platform component which will be connected to rtd (a)
is indicated via dai_link at snd_soc_add_pcm_runtime()
int snd_soc_add_pcm_runtime(...)
{
...
/* Find CPU from registered CPUs */
rtd->cpu_dai = snd_soc_find_dai(dai_link->cpus);
...
(a) snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);
...
/* Find CODEC from registered CODECs */
(b) for_each_link_codecs(dai_link, i, codec) {
rtd->codec_dais[i] = snd_soc_find_dai(codec);
...
(a) snd_soc_rtdcom_add(rtd, rtd->codec_dais[i]->component);
}
...
/* Find PLATFORM from registered PLATFORMs */
(b) for_each_link_platforms(dai_link, i, platform) {
for_each_component(component) {
...
(a) snd_soc_rtdcom_add(rtd, component);
}
}
}
It shows, it is possible to know how many components will be
connected to rtd by using
dai_link->num_cpus
dai_link->num_codecs
dai_link->num_platforms
If so, we can use component pointer array instead of list_head,
in such case, code can be more simple.
This patch removes struct snd_soc_rtdcom_list that is only
of temporary value, and convert to pointer array.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-By: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Link: https://lore.kernel.org/r/87a76wt4wm.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-01-10 02:35:21 +00:00
|
|
|
for_each_rtd_components(rtd, i, component) {
|
2019-12-17 09:58:50 +00:00
|
|
|
ret = pm_runtime_get_sync(component->dev);
|
|
|
|
|
if (ret < 0 && ret != -EACCES) {
|
|
|
|
|
pm_runtime_put_noidle(component->dev);
|
|
|
|
|
save = component;
|
|
|
|
|
goto pm_err;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-08-13 10:45:32 +00:00
|
|
|
mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass);
|
2018-04-24 15:39:03 +00:00
|
|
|
|
|
|
|
|
if (cpu_dai->driver->cops && cpu_dai->driver->cops->startup) {
|
|
|
|
|
ret = cpu_dai->driver->cops->startup(cstream, cpu_dai);
|
|
|
|
|
if (ret < 0) {
|
|
|
|
|
dev_err(cpu_dai->dev,
|
|
|
|
|
"Compress ASoC: can't open interface %s: %d\n",
|
|
|
|
|
cpu_dai->name, ret);
|
|
|
|
|
goto out;
|
2017-10-11 01:37:45 +00:00
|
|
|
}
|
|
|
|
|
}
|
2018-04-24 15:39:03 +00:00
|
|
|
|
|
|
|
|
ret = soc_compr_components_open(cstream, &component);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
goto machine_err;
|
2017-10-11 01:37:45 +00:00
|
|
|
|
2012-08-16 11:40:41 +00:00
|
|
|
if (rtd->dai_link->compr_ops && rtd->dai_link->compr_ops->startup) {
|
|
|
|
|
ret = rtd->dai_link->compr_ops->startup(cstream);
|
|
|
|
|
if (ret < 0) {
|
2018-01-26 13:08:45 +00:00
|
|
|
dev_err(rtd->dev,
|
|
|
|
|
"Compress ASoC: %s startup failed: %d\n",
|
|
|
|
|
rtd->dai_link->name, ret);
|
2012-08-16 11:40:41 +00:00
|
|
|
goto machine_err;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-05 12:17:43 +00:00
|
|
|
snd_soc_runtime_activate(rtd, cstream->direction);
|
2012-08-16 11:40:41 +00:00
|
|
|
|
2019-08-13 10:45:32 +00:00
|
|
|
mutex_unlock(&rtd->card->pcm_mutex);
|
2013-01-24 09:44:29 +00:00
|
|
|
|
2012-08-16 11:40:41 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
machine_err:
|
2018-04-24 15:39:03 +00:00
|
|
|
soc_compr_components_free(cstream, component);
|
2017-10-11 01:37:45 +00:00
|
|
|
|
2016-11-13 06:40:02 +00:00
|
|
|
if (cpu_dai->driver->cops && cpu_dai->driver->cops->shutdown)
|
|
|
|
|
cpu_dai->driver->cops->shutdown(cstream, cpu_dai);
|
2012-08-16 11:40:41 +00:00
|
|
|
out:
|
2019-08-13 10:45:32 +00:00
|
|
|
mutex_unlock(&rtd->card->pcm_mutex);
|
2019-12-17 09:58:50 +00:00
|
|
|
pm_err:
|
ASoC: soc-core: remove snd_soc_rtdcom_list
Current ALSA SoC is using struct snd_soc_rtdcom_list to
connecting component to rtd by using list_head.
struct snd_soc_rtdcom_list {
struct snd_soc_component *component;
struct list_head list; /* rtd::component_list */
};
struct snd_soc_pcm_runtime {
...
struct list_head component_list; /* list of connected components */
...
};
The CPU/Codec/Platform component which will be connected to rtd (a)
is indicated via dai_link at snd_soc_add_pcm_runtime()
int snd_soc_add_pcm_runtime(...)
{
...
/* Find CPU from registered CPUs */
rtd->cpu_dai = snd_soc_find_dai(dai_link->cpus);
...
(a) snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);
...
/* Find CODEC from registered CODECs */
(b) for_each_link_codecs(dai_link, i, codec) {
rtd->codec_dais[i] = snd_soc_find_dai(codec);
...
(a) snd_soc_rtdcom_add(rtd, rtd->codec_dais[i]->component);
}
...
/* Find PLATFORM from registered PLATFORMs */
(b) for_each_link_platforms(dai_link, i, platform) {
for_each_component(component) {
...
(a) snd_soc_rtdcom_add(rtd, component);
}
}
}
It shows, it is possible to know how many components will be
connected to rtd by using
dai_link->num_cpus
dai_link->num_codecs
dai_link->num_platforms
If so, we can use component pointer array instead of list_head,
in such case, code can be more simple.
This patch removes struct snd_soc_rtdcom_list that is only
of temporary value, and convert to pointer array.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-By: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Link: https://lore.kernel.org/r/87a76wt4wm.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-01-10 02:35:21 +00:00
|
|
|
for_each_rtd_components(rtd, i, component) {
|
2019-12-17 09:58:50 +00:00
|
|
|
if (component == save)
|
|
|
|
|
break;
|
|
|
|
|
pm_runtime_mark_last_busy(component->dev);
|
|
|
|
|
pm_runtime_put_autosuspend(component->dev);
|
|
|
|
|
}
|
|
|
|
|
|
2012-08-16 11:40:41 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2014-01-17 17:03:56 +00:00
|
|
|
static int soc_compr_open_fe(struct snd_compr_stream *cstream)
|
|
|
|
|
{
|
|
|
|
|
struct snd_soc_pcm_runtime *fe = cstream->private_data;
|
2017-06-17 00:33:40 +00:00
|
|
|
struct snd_pcm_substream *fe_substream =
|
|
|
|
|
fe->pcm->streams[cstream->direction].substream;
|
2017-10-11 01:37:45 +00:00
|
|
|
struct snd_soc_component *component;
|
2016-11-13 06:40:02 +00:00
|
|
|
struct snd_soc_dai *cpu_dai = fe->cpu_dai;
|
2014-01-17 17:03:56 +00:00
|
|
|
struct snd_soc_dpcm *dpcm;
|
|
|
|
|
struct snd_soc_dapm_widget_list *list;
|
|
|
|
|
int stream;
|
2018-04-24 15:39:01 +00:00
|
|
|
int ret;
|
2014-01-17 17:03:56 +00:00
|
|
|
|
|
|
|
|
if (cstream->direction == SND_COMPRESS_PLAYBACK)
|
|
|
|
|
stream = SNDRV_PCM_STREAM_PLAYBACK;
|
|
|
|
|
else
|
|
|
|
|
stream = SNDRV_PCM_STREAM_CAPTURE;
|
|
|
|
|
|
|
|
|
|
mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
|
2018-08-03 12:30:03 +00:00
|
|
|
fe->dpcm[stream].runtime = fe_substream->runtime;
|
|
|
|
|
|
|
|
|
|
ret = dpcm_path_get(fe, stream, &list);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
goto be_err;
|
|
|
|
|
else if (ret == 0)
|
|
|
|
|
dev_dbg(fe->dev, "Compress ASoC: %s no valid %s route\n",
|
|
|
|
|
fe->dai_link->name, stream ? "capture" : "playback");
|
|
|
|
|
/* calculate valid and active FE <-> BE dpcms */
|
|
|
|
|
dpcm_process_paths(fe, stream, &list, 1);
|
|
|
|
|
fe->dpcm[stream].runtime = fe_substream->runtime;
|
|
|
|
|
|
|
|
|
|
fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
|
|
|
|
|
|
|
|
|
|
ret = dpcm_be_dai_startup(fe, stream);
|
|
|
|
|
if (ret < 0) {
|
|
|
|
|
/* clean up all links */
|
2018-09-18 01:31:09 +00:00
|
|
|
for_each_dpcm_be(fe, stream, dpcm)
|
2018-08-03 12:30:03 +00:00
|
|
|
dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;
|
|
|
|
|
|
|
|
|
|
dpcm_be_disconnect(fe, stream);
|
|
|
|
|
fe->dpcm[stream].runtime = NULL;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2014-01-17 17:03:56 +00:00
|
|
|
|
2016-11-13 06:40:02 +00:00
|
|
|
if (cpu_dai->driver->cops && cpu_dai->driver->cops->startup) {
|
|
|
|
|
ret = cpu_dai->driver->cops->startup(cstream, cpu_dai);
|
|
|
|
|
if (ret < 0) {
|
2018-01-26 13:08:45 +00:00
|
|
|
dev_err(cpu_dai->dev,
|
|
|
|
|
"Compress ASoC: can't open interface %s: %d\n",
|
2016-11-13 06:40:02 +00:00
|
|
|
cpu_dai->name, ret);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2018-04-24 15:39:03 +00:00
|
|
|
ret = soc_compr_components_open(cstream, &component);
|
|
|
|
|
if (ret < 0)
|
2018-08-03 12:30:03 +00:00
|
|
|
goto open_err;
|
2017-10-11 01:37:45 +00:00
|
|
|
|
2014-01-17 17:03:56 +00:00
|
|
|
if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->startup) {
|
|
|
|
|
ret = fe->dai_link->compr_ops->startup(cstream);
|
|
|
|
|
if (ret < 0) {
|
2018-01-26 13:08:45 +00:00
|
|
|
pr_err("Compress ASoC: %s startup failed: %d\n",
|
|
|
|
|
fe->dai_link->name, ret);
|
2014-01-17 17:03:56 +00:00
|
|
|
goto machine_err;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
dpcm_clear_pending_state(fe, stream);
|
|
|
|
|
dpcm_path_put(&list);
|
|
|
|
|
|
|
|
|
|
fe->dpcm[stream].state = SND_SOC_DPCM_STATE_OPEN;
|
|
|
|
|
fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
|
|
|
|
|
|
2014-03-05 12:17:43 +00:00
|
|
|
snd_soc_runtime_activate(fe, stream);
|
2014-01-17 17:03:56 +00:00
|
|
|
|
|
|
|
|
mutex_unlock(&fe->card->mutex);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
machine_err:
|
2018-04-24 15:39:03 +00:00
|
|
|
soc_compr_components_free(cstream, component);
|
2018-08-03 12:30:03 +00:00
|
|
|
open_err:
|
2016-11-13 06:40:02 +00:00
|
|
|
if (cpu_dai->driver->cops && cpu_dai->driver->cops->shutdown)
|
|
|
|
|
cpu_dai->driver->cops->shutdown(cstream, cpu_dai);
|
2014-01-17 17:03:56 +00:00
|
|
|
out:
|
2018-08-03 12:30:03 +00:00
|
|
|
dpcm_path_put(&list);
|
|
|
|
|
be_err:
|
2014-01-17 17:03:56 +00:00
|
|
|
fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
|
|
|
|
|
mutex_unlock(&fe->card->mutex);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2013-01-24 09:44:30 +00:00
|
|
|
/*
|
|
|
|
|
* Power down the audio subsystem pmdown_time msecs after close is called.
|
|
|
|
|
* This is to ensure there are no pops or clicks in between any music tracks
|
|
|
|
|
* due to DAPM power cycling.
|
|
|
|
|
*/
|
2019-12-03 17:30:07 +00:00
|
|
|
static void close_delayed_work(struct snd_soc_pcm_runtime *rtd)
|
2013-01-24 09:44:30 +00:00
|
|
|
{
|
|
|
|
|
struct snd_soc_dai *codec_dai = rtd->codec_dai;
|
|
|
|
|
|
2019-08-13 10:45:32 +00:00
|
|
|
mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass);
|
2013-01-24 09:44:30 +00:00
|
|
|
|
2018-01-26 13:08:45 +00:00
|
|
|
dev_dbg(rtd->dev,
|
|
|
|
|
"Compress ASoC: pop wq checking: %s status: %s waiting: %s\n",
|
|
|
|
|
codec_dai->driver->playback.stream_name,
|
|
|
|
|
codec_dai->playback_active ? "active" : "inactive",
|
|
|
|
|
rtd->pop_wait ? "yes" : "no");
|
2013-01-24 09:44:30 +00:00
|
|
|
|
|
|
|
|
/* are we waiting on this codec DAI stream */
|
|
|
|
|
if (rtd->pop_wait == 1) {
|
|
|
|
|
rtd->pop_wait = 0;
|
|
|
|
|
snd_soc_dapm_stream_event(rtd, SNDRV_PCM_STREAM_PLAYBACK,
|
|
|
|
|
SND_SOC_DAPM_STREAM_STOP);
|
|
|
|
|
}
|
|
|
|
|
|
2019-08-13 10:45:32 +00:00
|
|
|
mutex_unlock(&rtd->card->pcm_mutex);
|
2013-01-24 09:44:30 +00:00
|
|
|
}
|
|
|
|
|
|
2012-08-16 11:40:41 +00:00
|
|
|
static int soc_compr_free(struct snd_compr_stream *cstream)
|
|
|
|
|
{
|
|
|
|
|
struct snd_soc_pcm_runtime *rtd = cstream->private_data;
|
2019-12-17 09:58:50 +00:00
|
|
|
struct snd_soc_component *component;
|
2012-08-16 11:40:41 +00:00
|
|
|
struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
|
|
|
|
|
struct snd_soc_dai *codec_dai = rtd->codec_dai;
|
ASoC: soc-core: remove snd_soc_rtdcom_list
Current ALSA SoC is using struct snd_soc_rtdcom_list to
connecting component to rtd by using list_head.
struct snd_soc_rtdcom_list {
struct snd_soc_component *component;
struct list_head list; /* rtd::component_list */
};
struct snd_soc_pcm_runtime {
...
struct list_head component_list; /* list of connected components */
...
};
The CPU/Codec/Platform component which will be connected to rtd (a)
is indicated via dai_link at snd_soc_add_pcm_runtime()
int snd_soc_add_pcm_runtime(...)
{
...
/* Find CPU from registered CPUs */
rtd->cpu_dai = snd_soc_find_dai(dai_link->cpus);
...
(a) snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);
...
/* Find CODEC from registered CODECs */
(b) for_each_link_codecs(dai_link, i, codec) {
rtd->codec_dais[i] = snd_soc_find_dai(codec);
...
(a) snd_soc_rtdcom_add(rtd, rtd->codec_dais[i]->component);
}
...
/* Find PLATFORM from registered PLATFORMs */
(b) for_each_link_platforms(dai_link, i, platform) {
for_each_component(component) {
...
(a) snd_soc_rtdcom_add(rtd, component);
}
}
}
It shows, it is possible to know how many components will be
connected to rtd by using
dai_link->num_cpus
dai_link->num_codecs
dai_link->num_platforms
If so, we can use component pointer array instead of list_head,
in such case, code can be more simple.
This patch removes struct snd_soc_rtdcom_list that is only
of temporary value, and convert to pointer array.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-By: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Link: https://lore.kernel.org/r/87a76wt4wm.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-01-10 02:35:21 +00:00
|
|
|
int stream, i;
|
2012-08-16 11:40:41 +00:00
|
|
|
|
2019-08-13 10:45:32 +00:00
|
|
|
mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass);
|
2013-01-24 09:44:29 +00:00
|
|
|
|
2014-03-05 12:17:43 +00:00
|
|
|
if (cstream->direction == SND_COMPRESS_PLAYBACK)
|
|
|
|
|
stream = SNDRV_PCM_STREAM_PLAYBACK;
|
|
|
|
|
else
|
|
|
|
|
stream = SNDRV_PCM_STREAM_CAPTURE;
|
2012-08-16 11:40:41 +00:00
|
|
|
|
2014-03-05 12:17:43 +00:00
|
|
|
snd_soc_runtime_deactivate(rtd, stream);
|
2013-02-06 15:44:07 +00:00
|
|
|
|
2014-03-05 12:17:43 +00:00
|
|
|
snd_soc_dai_digital_mute(codec_dai, 1, cstream->direction);
|
2012-08-16 11:40:41 +00:00
|
|
|
|
|
|
|
|
if (!cpu_dai->active)
|
|
|
|
|
cpu_dai->rate = 0;
|
|
|
|
|
|
|
|
|
|
if (!codec_dai->active)
|
|
|
|
|
codec_dai->rate = 0;
|
|
|
|
|
|
|
|
|
|
if (rtd->dai_link->compr_ops && rtd->dai_link->compr_ops->shutdown)
|
|
|
|
|
rtd->dai_link->compr_ops->shutdown(cstream);
|
|
|
|
|
|
2018-04-24 15:39:03 +00:00
|
|
|
soc_compr_components_free(cstream, NULL);
|
2017-10-11 01:37:45 +00:00
|
|
|
|
2016-11-13 06:40:02 +00:00
|
|
|
if (cpu_dai->driver->cops && cpu_dai->driver->cops->shutdown)
|
|
|
|
|
cpu_dai->driver->cops->shutdown(cstream, cpu_dai);
|
|
|
|
|
|
2012-08-16 11:40:41 +00:00
|
|
|
if (cstream->direction == SND_COMPRESS_PLAYBACK) {
|
2014-03-05 12:17:42 +00:00
|
|
|
if (snd_soc_runtime_ignore_pmdown_time(rtd)) {
|
2012-08-16 11:40:41 +00:00
|
|
|
snd_soc_dapm_stream_event(rtd,
|
2018-04-26 16:30:07 +00:00
|
|
|
SNDRV_PCM_STREAM_PLAYBACK,
|
|
|
|
|
SND_SOC_DAPM_STREAM_STOP);
|
2013-01-24 09:44:28 +00:00
|
|
|
} else {
|
ASoC: Prevent pop_wait overwrite
pop_wait is used to determine if a deferred playback close
needs to be cancelled when the a PCM is open or if after
the power-down delay expires it needs to run. pop_wait is
associated with the CODEC DAI, so the CODEC DAI must be
unique. This holds true for most CODECs, except for the
dummy CODEC and its DAI.
In DAI links with non-unique dummy CODECs (e.g. front-ends),
pop_wait can be overwritten by another DAI link using also a
dummy CODEC. Failure to cancel a deferred close can cause
mute due to the DAPM STOP event sent in the deferred work.
One scenario where pop_wait is overwritten and causing mute
is below (where hw:0,0 and hw:0,1 are two front-ends with
default pmdown_time = 5 secs):
aplay /dev/urandom -D hw:0,0 -c 2 -r 48000 -f S16_LE -d 1
sleep 1
aplay /dev/urandom -D hw:0,1 -c 2 -r 48000 -f S16_LE -d 3 &
aplay /dev/urandom -D hw:0,0 -c 2 -r 48000 -f S16_LE
Since CODECs may not be unique, pop_wait is moved to the PCM
runtime structure. Creating separate dummy CODECs for each
DAI link can also solve the problem, but at this point it's
only pop_wait variable in the CODEC DAI that has negative
effects by not being unique.
Signed-off-by: Misael Lopez Cruz <misael.lopez@ti.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
2012-12-13 18:23:05 +00:00
|
|
|
rtd->pop_wait = 1;
|
2013-08-09 17:12:29 +00:00
|
|
|
queue_delayed_work(system_power_efficient_wq,
|
|
|
|
|
&rtd->delayed_work,
|
|
|
|
|
msecs_to_jiffies(rtd->pmdown_time));
|
2013-01-24 09:44:28 +00:00
|
|
|
}
|
2012-08-16 11:40:41 +00:00
|
|
|
} else {
|
|
|
|
|
/* capture streams can be powered down now */
|
|
|
|
|
snd_soc_dapm_stream_event(rtd,
|
2018-04-26 16:30:07 +00:00
|
|
|
SNDRV_PCM_STREAM_CAPTURE,
|
|
|
|
|
SND_SOC_DAPM_STREAM_STOP);
|
2012-08-16 11:40:41 +00:00
|
|
|
}
|
|
|
|
|
|
2019-08-13 10:45:32 +00:00
|
|
|
mutex_unlock(&rtd->card->pcm_mutex);
|
2019-12-17 09:58:50 +00:00
|
|
|
|
ASoC: soc-core: remove snd_soc_rtdcom_list
Current ALSA SoC is using struct snd_soc_rtdcom_list to
connecting component to rtd by using list_head.
struct snd_soc_rtdcom_list {
struct snd_soc_component *component;
struct list_head list; /* rtd::component_list */
};
struct snd_soc_pcm_runtime {
...
struct list_head component_list; /* list of connected components */
...
};
The CPU/Codec/Platform component which will be connected to rtd (a)
is indicated via dai_link at snd_soc_add_pcm_runtime()
int snd_soc_add_pcm_runtime(...)
{
...
/* Find CPU from registered CPUs */
rtd->cpu_dai = snd_soc_find_dai(dai_link->cpus);
...
(a) snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);
...
/* Find CODEC from registered CODECs */
(b) for_each_link_codecs(dai_link, i, codec) {
rtd->codec_dais[i] = snd_soc_find_dai(codec);
...
(a) snd_soc_rtdcom_add(rtd, rtd->codec_dais[i]->component);
}
...
/* Find PLATFORM from registered PLATFORMs */
(b) for_each_link_platforms(dai_link, i, platform) {
for_each_component(component) {
...
(a) snd_soc_rtdcom_add(rtd, component);
}
}
}
It shows, it is possible to know how many components will be
connected to rtd by using
dai_link->num_cpus
dai_link->num_codecs
dai_link->num_platforms
If so, we can use component pointer array instead of list_head,
in such case, code can be more simple.
This patch removes struct snd_soc_rtdcom_list that is only
of temporary value, and convert to pointer array.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-By: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Link: https://lore.kernel.org/r/87a76wt4wm.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-01-10 02:35:21 +00:00
|
|
|
for_each_rtd_components(rtd, i, component) {
|
2019-12-17 09:58:50 +00:00
|
|
|
pm_runtime_mark_last_busy(component->dev);
|
|
|
|
|
pm_runtime_put_autosuspend(component->dev);
|
|
|
|
|
}
|
|
|
|
|
|
2012-08-16 11:40:41 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2014-01-17 17:03:56 +00:00
|
|
|
static int soc_compr_free_fe(struct snd_compr_stream *cstream)
|
|
|
|
|
{
|
|
|
|
|
struct snd_soc_pcm_runtime *fe = cstream->private_data;
|
2016-11-13 06:40:02 +00:00
|
|
|
struct snd_soc_dai *cpu_dai = fe->cpu_dai;
|
2014-01-17 17:03:56 +00:00
|
|
|
struct snd_soc_dpcm *dpcm;
|
|
|
|
|
int stream, ret;
|
|
|
|
|
|
|
|
|
|
mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
|
|
|
|
|
|
2014-03-05 12:17:43 +00:00
|
|
|
if (cstream->direction == SND_COMPRESS_PLAYBACK)
|
2014-01-17 17:03:56 +00:00
|
|
|
stream = SNDRV_PCM_STREAM_PLAYBACK;
|
2014-03-05 12:17:43 +00:00
|
|
|
else
|
2014-01-17 17:03:56 +00:00
|
|
|
stream = SNDRV_PCM_STREAM_CAPTURE;
|
|
|
|
|
|
2014-03-05 12:17:43 +00:00
|
|
|
snd_soc_runtime_deactivate(fe, stream);
|
2014-01-17 17:03:56 +00:00
|
|
|
|
|
|
|
|
fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
|
|
|
|
|
|
|
|
|
|
ret = dpcm_be_dai_hw_free(fe, stream);
|
|
|
|
|
if (ret < 0)
|
2018-01-26 13:08:45 +00:00
|
|
|
dev_err(fe->dev, "Compressed ASoC: hw_free failed: %d\n", ret);
|
2014-01-17 17:03:56 +00:00
|
|
|
|
|
|
|
|
ret = dpcm_be_dai_shutdown(fe, stream);
|
|
|
|
|
|
|
|
|
|
/* mark FE's links ready to prune */
|
2018-09-18 01:31:09 +00:00
|
|
|
for_each_dpcm_be(fe, stream, dpcm)
|
2014-01-17 17:03:56 +00:00
|
|
|
dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;
|
|
|
|
|
|
2014-10-19 07:07:35 +00:00
|
|
|
dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_STOP);
|
2014-01-17 17:03:56 +00:00
|
|
|
|
|
|
|
|
fe->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE;
|
|
|
|
|
fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
|
|
|
|
|
|
|
|
|
|
dpcm_be_disconnect(fe, stream);
|
|
|
|
|
|
|
|
|
|
fe->dpcm[stream].runtime = NULL;
|
|
|
|
|
|
|
|
|
|
if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->shutdown)
|
|
|
|
|
fe->dai_link->compr_ops->shutdown(cstream);
|
|
|
|
|
|
2018-04-24 15:39:03 +00:00
|
|
|
soc_compr_components_free(cstream, NULL);
|
2017-10-11 01:37:45 +00:00
|
|
|
|
2016-11-13 06:40:02 +00:00
|
|
|
if (cpu_dai->driver->cops && cpu_dai->driver->cops->shutdown)
|
|
|
|
|
cpu_dai->driver->cops->shutdown(cstream, cpu_dai);
|
|
|
|
|
|
2014-01-17 17:03:56 +00:00
|
|
|
mutex_unlock(&fe->card->mutex);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2019-02-05 11:18:13 +00:00
|
|
|
static int soc_compr_components_trigger(struct snd_compr_stream *cstream,
|
|
|
|
|
int cmd)
|
2012-08-16 11:40:41 +00:00
|
|
|
{
|
|
|
|
|
struct snd_soc_pcm_runtime *rtd = cstream->private_data;
|
2017-10-11 01:37:45 +00:00
|
|
|
struct snd_soc_component *component;
|
ASoC: soc-core: remove snd_soc_rtdcom_list
Current ALSA SoC is using struct snd_soc_rtdcom_list to
connecting component to rtd by using list_head.
struct snd_soc_rtdcom_list {
struct snd_soc_component *component;
struct list_head list; /* rtd::component_list */
};
struct snd_soc_pcm_runtime {
...
struct list_head component_list; /* list of connected components */
...
};
The CPU/Codec/Platform component which will be connected to rtd (a)
is indicated via dai_link at snd_soc_add_pcm_runtime()
int snd_soc_add_pcm_runtime(...)
{
...
/* Find CPU from registered CPUs */
rtd->cpu_dai = snd_soc_find_dai(dai_link->cpus);
...
(a) snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);
...
/* Find CODEC from registered CODECs */
(b) for_each_link_codecs(dai_link, i, codec) {
rtd->codec_dais[i] = snd_soc_find_dai(codec);
...
(a) snd_soc_rtdcom_add(rtd, rtd->codec_dais[i]->component);
}
...
/* Find PLATFORM from registered PLATFORMs */
(b) for_each_link_platforms(dai_link, i, platform) {
for_each_component(component) {
...
(a) snd_soc_rtdcom_add(rtd, component);
}
}
}
It shows, it is possible to know how many components will be
connected to rtd by using
dai_link->num_cpus
dai_link->num_codecs
dai_link->num_platforms
If so, we can use component pointer array instead of list_head,
in such case, code can be more simple.
This patch removes struct snd_soc_rtdcom_list that is only
of temporary value, and convert to pointer array.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-By: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Link: https://lore.kernel.org/r/87a76wt4wm.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-01-10 02:35:21 +00:00
|
|
|
int i, ret;
|
2013-01-24 09:44:29 +00:00
|
|
|
|
ASoC: soc-core: remove snd_soc_rtdcom_list
Current ALSA SoC is using struct snd_soc_rtdcom_list to
connecting component to rtd by using list_head.
struct snd_soc_rtdcom_list {
struct snd_soc_component *component;
struct list_head list; /* rtd::component_list */
};
struct snd_soc_pcm_runtime {
...
struct list_head component_list; /* list of connected components */
...
};
The CPU/Codec/Platform component which will be connected to rtd (a)
is indicated via dai_link at snd_soc_add_pcm_runtime()
int snd_soc_add_pcm_runtime(...)
{
...
/* Find CPU from registered CPUs */
rtd->cpu_dai = snd_soc_find_dai(dai_link->cpus);
...
(a) snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);
...
/* Find CODEC from registered CODECs */
(b) for_each_link_codecs(dai_link, i, codec) {
rtd->codec_dais[i] = snd_soc_find_dai(codec);
...
(a) snd_soc_rtdcom_add(rtd, rtd->codec_dais[i]->component);
}
...
/* Find PLATFORM from registered PLATFORMs */
(b) for_each_link_platforms(dai_link, i, platform) {
for_each_component(component) {
...
(a) snd_soc_rtdcom_add(rtd, component);
}
}
}
It shows, it is possible to know how many components will be
connected to rtd by using
dai_link->num_cpus
dai_link->num_codecs
dai_link->num_platforms
If so, we can use component pointer array instead of list_head,
in such case, code can be more simple.
This patch removes struct snd_soc_rtdcom_list that is only
of temporary value, and convert to pointer array.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-By: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Link: https://lore.kernel.org/r/87a76wt4wm.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-01-10 02:35:21 +00:00
|
|
|
for_each_rtd_components(rtd, i, component) {
|
2017-10-11 01:37:45 +00:00
|
|
|
if (!component->driver->compr_ops ||
|
|
|
|
|
!component->driver->compr_ops->trigger)
|
|
|
|
|
continue;
|
|
|
|
|
|
2019-02-05 11:18:12 +00:00
|
|
|
ret = component->driver->compr_ops->trigger(cstream, cmd);
|
|
|
|
|
if (ret < 0)
|
2019-02-05 11:18:13 +00:00
|
|
|
return ret;
|
2017-10-11 01:37:45 +00:00
|
|
|
}
|
|
|
|
|
|
2019-02-05 11:18:13 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int soc_compr_trigger(struct snd_compr_stream *cstream, int cmd)
|
|
|
|
|
{
|
|
|
|
|
struct snd_soc_pcm_runtime *rtd = cstream->private_data;
|
|
|
|
|
struct snd_soc_dai *codec_dai = rtd->codec_dai;
|
|
|
|
|
struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
|
|
|
|
|
int ret;
|
|
|
|
|
|
2019-08-13 10:45:32 +00:00
|
|
|
mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass);
|
2019-02-05 11:18:13 +00:00
|
|
|
|
|
|
|
|
ret = soc_compr_components_trigger(cstream, cmd);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
goto out;
|
|
|
|
|
|
2016-11-13 06:40:02 +00:00
|
|
|
if (cpu_dai->driver->cops && cpu_dai->driver->cops->trigger)
|
|
|
|
|
cpu_dai->driver->cops->trigger(cstream, cmd, cpu_dai);
|
|
|
|
|
|
2013-02-06 15:44:07 +00:00
|
|
|
switch (cmd) {
|
|
|
|
|
case SNDRV_PCM_TRIGGER_START:
|
|
|
|
|
snd_soc_dai_digital_mute(codec_dai, 0, cstream->direction);
|
|
|
|
|
break;
|
|
|
|
|
case SNDRV_PCM_TRIGGER_STOP:
|
|
|
|
|
snd_soc_dai_digital_mute(codec_dai, 1, cstream->direction);
|
|
|
|
|
break;
|
2013-02-06 13:52:42 +00:00
|
|
|
}
|
2012-08-16 11:40:41 +00:00
|
|
|
|
2013-01-24 09:44:29 +00:00
|
|
|
out:
|
2019-08-13 10:45:32 +00:00
|
|
|
mutex_unlock(&rtd->card->pcm_mutex);
|
2012-08-16 11:40:41 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2014-01-17 17:03:56 +00:00
|
|
|
static int soc_compr_trigger_fe(struct snd_compr_stream *cstream, int cmd)
|
|
|
|
|
{
|
|
|
|
|
struct snd_soc_pcm_runtime *fe = cstream->private_data;
|
2016-11-13 06:40:02 +00:00
|
|
|
struct snd_soc_dai *cpu_dai = fe->cpu_dai;
|
2019-02-05 11:18:12 +00:00
|
|
|
int ret, stream;
|
2014-01-17 17:03:56 +00:00
|
|
|
|
|
|
|
|
if (cmd == SND_COMPR_TRIGGER_PARTIAL_DRAIN ||
|
2019-02-05 11:18:13 +00:00
|
|
|
cmd == SND_COMPR_TRIGGER_DRAIN)
|
|
|
|
|
return soc_compr_components_trigger(cstream, cmd);
|
2014-01-17 17:03:56 +00:00
|
|
|
|
|
|
|
|
if (cstream->direction == SND_COMPRESS_PLAYBACK)
|
|
|
|
|
stream = SNDRV_PCM_STREAM_PLAYBACK;
|
|
|
|
|
else
|
|
|
|
|
stream = SNDRV_PCM_STREAM_CAPTURE;
|
|
|
|
|
|
|
|
|
|
mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
|
|
|
|
|
|
2016-11-13 06:40:02 +00:00
|
|
|
if (cpu_dai->driver->cops && cpu_dai->driver->cops->trigger) {
|
|
|
|
|
ret = cpu_dai->driver->cops->trigger(cstream, cmd, cpu_dai);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2019-02-05 11:18:13 +00:00
|
|
|
ret = soc_compr_components_trigger(cstream, cmd);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
goto out;
|
2017-10-11 01:37:45 +00:00
|
|
|
|
2014-01-17 17:03:56 +00:00
|
|
|
fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
|
|
|
|
|
|
|
|
|
|
ret = dpcm_be_dai_trigger(fe, stream, cmd);
|
|
|
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
|
case SNDRV_PCM_TRIGGER_START:
|
|
|
|
|
case SNDRV_PCM_TRIGGER_RESUME:
|
|
|
|
|
case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
|
|
|
|
|
fe->dpcm[stream].state = SND_SOC_DPCM_STATE_START;
|
|
|
|
|
break;
|
|
|
|
|
case SNDRV_PCM_TRIGGER_STOP:
|
|
|
|
|
case SNDRV_PCM_TRIGGER_SUSPEND:
|
|
|
|
|
fe->dpcm[stream].state = SND_SOC_DPCM_STATE_STOP;
|
|
|
|
|
break;
|
|
|
|
|
case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
|
|
|
|
|
fe->dpcm[stream].state = SND_SOC_DPCM_STATE_PAUSED;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
|
|
|
|
|
mutex_unlock(&fe->card->mutex);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2019-02-05 11:18:13 +00:00
|
|
|
static int soc_compr_components_set_params(struct snd_compr_stream *cstream,
|
|
|
|
|
struct snd_compr_params *params)
|
2012-08-16 11:40:41 +00:00
|
|
|
{
|
|
|
|
|
struct snd_soc_pcm_runtime *rtd = cstream->private_data;
|
2017-10-11 01:37:45 +00:00
|
|
|
struct snd_soc_component *component;
|
ASoC: soc-core: remove snd_soc_rtdcom_list
Current ALSA SoC is using struct snd_soc_rtdcom_list to
connecting component to rtd by using list_head.
struct snd_soc_rtdcom_list {
struct snd_soc_component *component;
struct list_head list; /* rtd::component_list */
};
struct snd_soc_pcm_runtime {
...
struct list_head component_list; /* list of connected components */
...
};
The CPU/Codec/Platform component which will be connected to rtd (a)
is indicated via dai_link at snd_soc_add_pcm_runtime()
int snd_soc_add_pcm_runtime(...)
{
...
/* Find CPU from registered CPUs */
rtd->cpu_dai = snd_soc_find_dai(dai_link->cpus);
...
(a) snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);
...
/* Find CODEC from registered CODECs */
(b) for_each_link_codecs(dai_link, i, codec) {
rtd->codec_dais[i] = snd_soc_find_dai(codec);
...
(a) snd_soc_rtdcom_add(rtd, rtd->codec_dais[i]->component);
}
...
/* Find PLATFORM from registered PLATFORMs */
(b) for_each_link_platforms(dai_link, i, platform) {
for_each_component(component) {
...
(a) snd_soc_rtdcom_add(rtd, component);
}
}
}
It shows, it is possible to know how many components will be
connected to rtd by using
dai_link->num_cpus
dai_link->num_codecs
dai_link->num_platforms
If so, we can use component pointer array instead of list_head,
in such case, code can be more simple.
This patch removes struct snd_soc_rtdcom_list that is only
of temporary value, and convert to pointer array.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-By: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Link: https://lore.kernel.org/r/87a76wt4wm.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-01-10 02:35:21 +00:00
|
|
|
int i, ret;
|
2019-02-05 11:18:13 +00:00
|
|
|
|
ASoC: soc-core: remove snd_soc_rtdcom_list
Current ALSA SoC is using struct snd_soc_rtdcom_list to
connecting component to rtd by using list_head.
struct snd_soc_rtdcom_list {
struct snd_soc_component *component;
struct list_head list; /* rtd::component_list */
};
struct snd_soc_pcm_runtime {
...
struct list_head component_list; /* list of connected components */
...
};
The CPU/Codec/Platform component which will be connected to rtd (a)
is indicated via dai_link at snd_soc_add_pcm_runtime()
int snd_soc_add_pcm_runtime(...)
{
...
/* Find CPU from registered CPUs */
rtd->cpu_dai = snd_soc_find_dai(dai_link->cpus);
...
(a) snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);
...
/* Find CODEC from registered CODECs */
(b) for_each_link_codecs(dai_link, i, codec) {
rtd->codec_dais[i] = snd_soc_find_dai(codec);
...
(a) snd_soc_rtdcom_add(rtd, rtd->codec_dais[i]->component);
}
...
/* Find PLATFORM from registered PLATFORMs */
(b) for_each_link_platforms(dai_link, i, platform) {
for_each_component(component) {
...
(a) snd_soc_rtdcom_add(rtd, component);
}
}
}
It shows, it is possible to know how many components will be
connected to rtd by using
dai_link->num_cpus
dai_link->num_codecs
dai_link->num_platforms
If so, we can use component pointer array instead of list_head,
in such case, code can be more simple.
This patch removes struct snd_soc_rtdcom_list that is only
of temporary value, and convert to pointer array.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-By: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Link: https://lore.kernel.org/r/87a76wt4wm.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-01-10 02:35:21 +00:00
|
|
|
for_each_rtd_components(rtd, i, component) {
|
2019-02-05 11:18:13 +00:00
|
|
|
if (!component->driver->compr_ops ||
|
|
|
|
|
!component->driver->compr_ops->set_params)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
ret = component->driver->compr_ops->set_params(cstream, params);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int soc_compr_set_params(struct snd_compr_stream *cstream,
|
|
|
|
|
struct snd_compr_params *params)
|
|
|
|
|
{
|
|
|
|
|
struct snd_soc_pcm_runtime *rtd = cstream->private_data;
|
2016-11-13 06:40:02 +00:00
|
|
|
struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
|
2019-02-05 11:18:12 +00:00
|
|
|
int ret;
|
2012-08-16 11:40:41 +00:00
|
|
|
|
2019-08-13 10:45:32 +00:00
|
|
|
mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass);
|
2013-01-24 09:44:29 +00:00
|
|
|
|
2018-04-24 15:39:02 +00:00
|
|
|
/*
|
|
|
|
|
* First we call set_params for the CPU DAI, then the component
|
|
|
|
|
* driver this should configure the SoC side. If the machine has
|
|
|
|
|
* compressed ops then we call that as well. The expectation is
|
|
|
|
|
* that these callbacks will configure everything for this compress
|
|
|
|
|
* path, like configuring a PCM port for a CODEC.
|
2012-08-16 11:40:41 +00:00
|
|
|
*/
|
2016-11-13 06:40:02 +00:00
|
|
|
if (cpu_dai->driver->cops && cpu_dai->driver->cops->set_params) {
|
|
|
|
|
ret = cpu_dai->driver->cops->set_params(cstream, params, cpu_dai);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
goto err;
|
|
|
|
|
}
|
|
|
|
|
|
2019-02-05 11:18:13 +00:00
|
|
|
ret = soc_compr_components_set_params(cstream, params);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
goto err;
|
2017-10-11 01:37:45 +00:00
|
|
|
|
2012-08-16 11:40:41 +00:00
|
|
|
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)
|
2013-03-27 16:39:01 +00:00
|
|
|
goto err;
|
2012-08-16 11:40:41 +00:00
|
|
|
}
|
|
|
|
|
|
2013-05-20 07:33:54 +00:00
|
|
|
if (cstream->direction == SND_COMPRESS_PLAYBACK)
|
|
|
|
|
snd_soc_dapm_stream_event(rtd, SNDRV_PCM_STREAM_PLAYBACK,
|
2018-04-26 16:30:07 +00:00
|
|
|
SND_SOC_DAPM_STREAM_START);
|
2013-05-20 07:33:54 +00:00
|
|
|
else
|
|
|
|
|
snd_soc_dapm_stream_event(rtd, SNDRV_PCM_STREAM_CAPTURE,
|
2018-04-26 16:30:07 +00:00
|
|
|
SND_SOC_DAPM_STREAM_START);
|
2012-08-16 11:40:41 +00:00
|
|
|
|
2013-03-27 16:39:01 +00:00
|
|
|
/* cancel any delayed stream shutdown that is pending */
|
|
|
|
|
rtd->pop_wait = 0;
|
2019-08-13 10:45:32 +00:00
|
|
|
mutex_unlock(&rtd->card->pcm_mutex);
|
2013-03-27 16:39:01 +00:00
|
|
|
|
|
|
|
|
cancel_delayed_work_sync(&rtd->delayed_work);
|
|
|
|
|
|
2019-02-05 11:18:12 +00:00
|
|
|
return 0;
|
2013-03-27 16:39:01 +00:00
|
|
|
|
|
|
|
|
err:
|
2019-08-13 10:45:32 +00:00
|
|
|
mutex_unlock(&rtd->card->pcm_mutex);
|
2012-08-16 11:40:41 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2014-01-17 17:03:56 +00:00
|
|
|
static int soc_compr_set_params_fe(struct snd_compr_stream *cstream,
|
2018-04-26 16:30:07 +00:00
|
|
|
struct snd_compr_params *params)
|
2014-01-17 17:03:56 +00:00
|
|
|
{
|
|
|
|
|
struct snd_soc_pcm_runtime *fe = cstream->private_data;
|
2017-06-17 00:33:40 +00:00
|
|
|
struct snd_pcm_substream *fe_substream =
|
|
|
|
|
fe->pcm->streams[cstream->direction].substream;
|
2016-11-13 06:40:02 +00:00
|
|
|
struct snd_soc_dai *cpu_dai = fe->cpu_dai;
|
2019-02-05 11:18:12 +00:00
|
|
|
int ret, stream;
|
2014-01-17 17:03:56 +00:00
|
|
|
|
|
|
|
|
if (cstream->direction == SND_COMPRESS_PLAYBACK)
|
|
|
|
|
stream = SNDRV_PCM_STREAM_PLAYBACK;
|
|
|
|
|
else
|
|
|
|
|
stream = SNDRV_PCM_STREAM_CAPTURE;
|
|
|
|
|
|
|
|
|
|
mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
|
|
|
|
|
|
2018-08-03 12:30:03 +00:00
|
|
|
/*
|
|
|
|
|
* Create an empty hw_params for the BE as the machine driver must
|
|
|
|
|
* fix this up to match DSP decoder and ASRC configuration.
|
|
|
|
|
* I.e. machine driver fixup for compressed BE is mandatory.
|
|
|
|
|
*/
|
|
|
|
|
memset(&fe->dpcm[fe_substream->stream].hw_params, 0,
|
|
|
|
|
sizeof(struct snd_pcm_hw_params));
|
|
|
|
|
|
|
|
|
|
fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
|
|
|
|
|
|
|
|
|
|
ret = dpcm_be_dai_hw_params(fe, stream);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
ret = dpcm_be_dai_prepare(fe, stream);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
goto out;
|
|
|
|
|
|
2016-11-13 06:40:02 +00:00
|
|
|
if (cpu_dai->driver->cops && cpu_dai->driver->cops->set_params) {
|
|
|
|
|
ret = cpu_dai->driver->cops->set_params(cstream, params, cpu_dai);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2019-02-05 11:18:13 +00:00
|
|
|
ret = soc_compr_components_set_params(cstream, params);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
goto out;
|
2017-10-11 01:37:45 +00:00
|
|
|
|
2014-01-17 17:03:56 +00:00
|
|
|
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)
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2014-10-19 07:07:35 +00:00
|
|
|
dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_START);
|
2014-01-17 17:03:56 +00:00
|
|
|
fe->dpcm[stream].state = SND_SOC_DPCM_STATE_PREPARE;
|
|
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
|
|
|
|
|
mutex_unlock(&fe->card->mutex);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2012-08-16 11:40:41 +00:00
|
|
|
static int soc_compr_get_params(struct snd_compr_stream *cstream,
|
2018-04-26 16:30:07 +00:00
|
|
|
struct snd_codec *params)
|
2012-08-16 11:40:41 +00:00
|
|
|
{
|
|
|
|
|
struct snd_soc_pcm_runtime *rtd = cstream->private_data;
|
2017-10-11 01:37:45 +00:00
|
|
|
struct snd_soc_component *component;
|
2016-11-13 06:40:02 +00:00
|
|
|
struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
|
ASoC: soc-core: remove snd_soc_rtdcom_list
Current ALSA SoC is using struct snd_soc_rtdcom_list to
connecting component to rtd by using list_head.
struct snd_soc_rtdcom_list {
struct snd_soc_component *component;
struct list_head list; /* rtd::component_list */
};
struct snd_soc_pcm_runtime {
...
struct list_head component_list; /* list of connected components */
...
};
The CPU/Codec/Platform component which will be connected to rtd (a)
is indicated via dai_link at snd_soc_add_pcm_runtime()
int snd_soc_add_pcm_runtime(...)
{
...
/* Find CPU from registered CPUs */
rtd->cpu_dai = snd_soc_find_dai(dai_link->cpus);
...
(a) snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);
...
/* Find CODEC from registered CODECs */
(b) for_each_link_codecs(dai_link, i, codec) {
rtd->codec_dais[i] = snd_soc_find_dai(codec);
...
(a) snd_soc_rtdcom_add(rtd, rtd->codec_dais[i]->component);
}
...
/* Find PLATFORM from registered PLATFORMs */
(b) for_each_link_platforms(dai_link, i, platform) {
for_each_component(component) {
...
(a) snd_soc_rtdcom_add(rtd, component);
}
}
}
It shows, it is possible to know how many components will be
connected to rtd by using
dai_link->num_cpus
dai_link->num_codecs
dai_link->num_platforms
If so, we can use component pointer array instead of list_head,
in such case, code can be more simple.
This patch removes struct snd_soc_rtdcom_list that is only
of temporary value, and convert to pointer array.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-By: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Link: https://lore.kernel.org/r/87a76wt4wm.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-01-10 02:35:21 +00:00
|
|
|
int i, ret = 0;
|
2012-08-16 11:40:41 +00:00
|
|
|
|
2019-08-13 10:45:32 +00:00
|
|
|
mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass);
|
2013-01-24 09:44:29 +00:00
|
|
|
|
2016-11-13 06:40:02 +00:00
|
|
|
if (cpu_dai->driver->cops && cpu_dai->driver->cops->get_params) {
|
|
|
|
|
ret = cpu_dai->driver->cops->get_params(cstream, params, cpu_dai);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
goto err;
|
|
|
|
|
}
|
|
|
|
|
|
ASoC: soc-core: remove snd_soc_rtdcom_list
Current ALSA SoC is using struct snd_soc_rtdcom_list to
connecting component to rtd by using list_head.
struct snd_soc_rtdcom_list {
struct snd_soc_component *component;
struct list_head list; /* rtd::component_list */
};
struct snd_soc_pcm_runtime {
...
struct list_head component_list; /* list of connected components */
...
};
The CPU/Codec/Platform component which will be connected to rtd (a)
is indicated via dai_link at snd_soc_add_pcm_runtime()
int snd_soc_add_pcm_runtime(...)
{
...
/* Find CPU from registered CPUs */
rtd->cpu_dai = snd_soc_find_dai(dai_link->cpus);
...
(a) snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);
...
/* Find CODEC from registered CODECs */
(b) for_each_link_codecs(dai_link, i, codec) {
rtd->codec_dais[i] = snd_soc_find_dai(codec);
...
(a) snd_soc_rtdcom_add(rtd, rtd->codec_dais[i]->component);
}
...
/* Find PLATFORM from registered PLATFORMs */
(b) for_each_link_platforms(dai_link, i, platform) {
for_each_component(component) {
...
(a) snd_soc_rtdcom_add(rtd, component);
}
}
}
It shows, it is possible to know how many components will be
connected to rtd by using
dai_link->num_cpus
dai_link->num_codecs
dai_link->num_platforms
If so, we can use component pointer array instead of list_head,
in such case, code can be more simple.
This patch removes struct snd_soc_rtdcom_list that is only
of temporary value, and convert to pointer array.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-By: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Link: https://lore.kernel.org/r/87a76wt4wm.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-01-10 02:35:21 +00:00
|
|
|
for_each_rtd_components(rtd, i, component) {
|
2017-10-11 01:37:45 +00:00
|
|
|
if (!component->driver->compr_ops ||
|
|
|
|
|
!component->driver->compr_ops->get_params)
|
|
|
|
|
continue;
|
|
|
|
|
|
2019-02-05 11:18:12 +00:00
|
|
|
ret = component->driver->compr_ops->get_params(cstream, params);
|
|
|
|
|
break;
|
2017-10-11 01:37:45 +00:00
|
|
|
}
|
2012-08-16 11:40:41 +00:00
|
|
|
|
2016-11-13 06:40:02 +00:00
|
|
|
err:
|
2019-08-13 10:45:32 +00:00
|
|
|
mutex_unlock(&rtd->card->pcm_mutex);
|
2012-08-16 11:40:41 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int soc_compr_get_caps(struct snd_compr_stream *cstream,
|
2018-04-26 16:30:07 +00:00
|
|
|
struct snd_compr_caps *caps)
|
2012-08-16 11:40:41 +00:00
|
|
|
{
|
|
|
|
|
struct snd_soc_pcm_runtime *rtd = cstream->private_data;
|
2017-10-11 01:37:45 +00:00
|
|
|
struct snd_soc_component *component;
|
ASoC: soc-core: remove snd_soc_rtdcom_list
Current ALSA SoC is using struct snd_soc_rtdcom_list to
connecting component to rtd by using list_head.
struct snd_soc_rtdcom_list {
struct snd_soc_component *component;
struct list_head list; /* rtd::component_list */
};
struct snd_soc_pcm_runtime {
...
struct list_head component_list; /* list of connected components */
...
};
The CPU/Codec/Platform component which will be connected to rtd (a)
is indicated via dai_link at snd_soc_add_pcm_runtime()
int snd_soc_add_pcm_runtime(...)
{
...
/* Find CPU from registered CPUs */
rtd->cpu_dai = snd_soc_find_dai(dai_link->cpus);
...
(a) snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);
...
/* Find CODEC from registered CODECs */
(b) for_each_link_codecs(dai_link, i, codec) {
rtd->codec_dais[i] = snd_soc_find_dai(codec);
...
(a) snd_soc_rtdcom_add(rtd, rtd->codec_dais[i]->component);
}
...
/* Find PLATFORM from registered PLATFORMs */
(b) for_each_link_platforms(dai_link, i, platform) {
for_each_component(component) {
...
(a) snd_soc_rtdcom_add(rtd, component);
}
}
}
It shows, it is possible to know how many components will be
connected to rtd by using
dai_link->num_cpus
dai_link->num_codecs
dai_link->num_platforms
If so, we can use component pointer array instead of list_head,
in such case, code can be more simple.
This patch removes struct snd_soc_rtdcom_list that is only
of temporary value, and convert to pointer array.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-By: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Link: https://lore.kernel.org/r/87a76wt4wm.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-01-10 02:35:21 +00:00
|
|
|
int i, ret = 0;
|
2012-08-16 11:40:41 +00:00
|
|
|
|
2019-08-13 10:45:32 +00:00
|
|
|
mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass);
|
2013-01-24 09:44:29 +00:00
|
|
|
|
ASoC: soc-core: remove snd_soc_rtdcom_list
Current ALSA SoC is using struct snd_soc_rtdcom_list to
connecting component to rtd by using list_head.
struct snd_soc_rtdcom_list {
struct snd_soc_component *component;
struct list_head list; /* rtd::component_list */
};
struct snd_soc_pcm_runtime {
...
struct list_head component_list; /* list of connected components */
...
};
The CPU/Codec/Platform component which will be connected to rtd (a)
is indicated via dai_link at snd_soc_add_pcm_runtime()
int snd_soc_add_pcm_runtime(...)
{
...
/* Find CPU from registered CPUs */
rtd->cpu_dai = snd_soc_find_dai(dai_link->cpus);
...
(a) snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);
...
/* Find CODEC from registered CODECs */
(b) for_each_link_codecs(dai_link, i, codec) {
rtd->codec_dais[i] = snd_soc_find_dai(codec);
...
(a) snd_soc_rtdcom_add(rtd, rtd->codec_dais[i]->component);
}
...
/* Find PLATFORM from registered PLATFORMs */
(b) for_each_link_platforms(dai_link, i, platform) {
for_each_component(component) {
...
(a) snd_soc_rtdcom_add(rtd, component);
}
}
}
It shows, it is possible to know how many components will be
connected to rtd by using
dai_link->num_cpus
dai_link->num_codecs
dai_link->num_platforms
If so, we can use component pointer array instead of list_head,
in such case, code can be more simple.
This patch removes struct snd_soc_rtdcom_list that is only
of temporary value, and convert to pointer array.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-By: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Link: https://lore.kernel.org/r/87a76wt4wm.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-01-10 02:35:21 +00:00
|
|
|
for_each_rtd_components(rtd, i, component) {
|
2017-10-11 01:37:45 +00:00
|
|
|
if (!component->driver->compr_ops ||
|
|
|
|
|
!component->driver->compr_ops->get_caps)
|
|
|
|
|
continue;
|
|
|
|
|
|
2019-02-05 11:18:12 +00:00
|
|
|
ret = component->driver->compr_ops->get_caps(cstream, caps);
|
|
|
|
|
break;
|
2017-10-11 01:37:45 +00:00
|
|
|
}
|
|
|
|
|
|
2019-08-13 10:45:32 +00:00
|
|
|
mutex_unlock(&rtd->card->pcm_mutex);
|
2012-08-16 11:40:41 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int soc_compr_get_codec_caps(struct snd_compr_stream *cstream,
|
2018-04-26 16:30:07 +00:00
|
|
|
struct snd_compr_codec_caps *codec)
|
2012-08-16 11:40:41 +00:00
|
|
|
{
|
|
|
|
|
struct snd_soc_pcm_runtime *rtd = cstream->private_data;
|
2017-10-11 01:37:45 +00:00
|
|
|
struct snd_soc_component *component;
|
ASoC: soc-core: remove snd_soc_rtdcom_list
Current ALSA SoC is using struct snd_soc_rtdcom_list to
connecting component to rtd by using list_head.
struct snd_soc_rtdcom_list {
struct snd_soc_component *component;
struct list_head list; /* rtd::component_list */
};
struct snd_soc_pcm_runtime {
...
struct list_head component_list; /* list of connected components */
...
};
The CPU/Codec/Platform component which will be connected to rtd (a)
is indicated via dai_link at snd_soc_add_pcm_runtime()
int snd_soc_add_pcm_runtime(...)
{
...
/* Find CPU from registered CPUs */
rtd->cpu_dai = snd_soc_find_dai(dai_link->cpus);
...
(a) snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);
...
/* Find CODEC from registered CODECs */
(b) for_each_link_codecs(dai_link, i, codec) {
rtd->codec_dais[i] = snd_soc_find_dai(codec);
...
(a) snd_soc_rtdcom_add(rtd, rtd->codec_dais[i]->component);
}
...
/* Find PLATFORM from registered PLATFORMs */
(b) for_each_link_platforms(dai_link, i, platform) {
for_each_component(component) {
...
(a) snd_soc_rtdcom_add(rtd, component);
}
}
}
It shows, it is possible to know how many components will be
connected to rtd by using
dai_link->num_cpus
dai_link->num_codecs
dai_link->num_platforms
If so, we can use component pointer array instead of list_head,
in such case, code can be more simple.
This patch removes struct snd_soc_rtdcom_list that is only
of temporary value, and convert to pointer array.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-By: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Link: https://lore.kernel.org/r/87a76wt4wm.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-01-10 02:35:21 +00:00
|
|
|
int i, ret = 0;
|
2012-08-16 11:40:41 +00:00
|
|
|
|
2019-08-13 10:45:32 +00:00
|
|
|
mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass);
|
2013-01-24 09:44:29 +00:00
|
|
|
|
ASoC: soc-core: remove snd_soc_rtdcom_list
Current ALSA SoC is using struct snd_soc_rtdcom_list to
connecting component to rtd by using list_head.
struct snd_soc_rtdcom_list {
struct snd_soc_component *component;
struct list_head list; /* rtd::component_list */
};
struct snd_soc_pcm_runtime {
...
struct list_head component_list; /* list of connected components */
...
};
The CPU/Codec/Platform component which will be connected to rtd (a)
is indicated via dai_link at snd_soc_add_pcm_runtime()
int snd_soc_add_pcm_runtime(...)
{
...
/* Find CPU from registered CPUs */
rtd->cpu_dai = snd_soc_find_dai(dai_link->cpus);
...
(a) snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);
...
/* Find CODEC from registered CODECs */
(b) for_each_link_codecs(dai_link, i, codec) {
rtd->codec_dais[i] = snd_soc_find_dai(codec);
...
(a) snd_soc_rtdcom_add(rtd, rtd->codec_dais[i]->component);
}
...
/* Find PLATFORM from registered PLATFORMs */
(b) for_each_link_platforms(dai_link, i, platform) {
for_each_component(component) {
...
(a) snd_soc_rtdcom_add(rtd, component);
}
}
}
It shows, it is possible to know how many components will be
connected to rtd by using
dai_link->num_cpus
dai_link->num_codecs
dai_link->num_platforms
If so, we can use component pointer array instead of list_head,
in such case, code can be more simple.
This patch removes struct snd_soc_rtdcom_list that is only
of temporary value, and convert to pointer array.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-By: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Link: https://lore.kernel.org/r/87a76wt4wm.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-01-10 02:35:21 +00:00
|
|
|
for_each_rtd_components(rtd, i, component) {
|
2017-10-11 01:37:45 +00:00
|
|
|
if (!component->driver->compr_ops ||
|
|
|
|
|
!component->driver->compr_ops->get_codec_caps)
|
|
|
|
|
continue;
|
|
|
|
|
|
2019-02-05 11:18:12 +00:00
|
|
|
ret = component->driver->compr_ops->get_codec_caps(cstream,
|
|
|
|
|
codec);
|
|
|
|
|
break;
|
2017-10-11 01:37:45 +00:00
|
|
|
}
|
|
|
|
|
|
2019-08-13 10:45:32 +00:00
|
|
|
mutex_unlock(&rtd->card->pcm_mutex);
|
2012-08-16 11:40:41 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int soc_compr_ack(struct snd_compr_stream *cstream, size_t bytes)
|
|
|
|
|
{
|
|
|
|
|
struct snd_soc_pcm_runtime *rtd = cstream->private_data;
|
2017-10-11 01:37:45 +00:00
|
|
|
struct snd_soc_component *component;
|
2016-11-13 06:40:02 +00:00
|
|
|
struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
|
ASoC: soc-core: remove snd_soc_rtdcom_list
Current ALSA SoC is using struct snd_soc_rtdcom_list to
connecting component to rtd by using list_head.
struct snd_soc_rtdcom_list {
struct snd_soc_component *component;
struct list_head list; /* rtd::component_list */
};
struct snd_soc_pcm_runtime {
...
struct list_head component_list; /* list of connected components */
...
};
The CPU/Codec/Platform component which will be connected to rtd (a)
is indicated via dai_link at snd_soc_add_pcm_runtime()
int snd_soc_add_pcm_runtime(...)
{
...
/* Find CPU from registered CPUs */
rtd->cpu_dai = snd_soc_find_dai(dai_link->cpus);
...
(a) snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);
...
/* Find CODEC from registered CODECs */
(b) for_each_link_codecs(dai_link, i, codec) {
rtd->codec_dais[i] = snd_soc_find_dai(codec);
...
(a) snd_soc_rtdcom_add(rtd, rtd->codec_dais[i]->component);
}
...
/* Find PLATFORM from registered PLATFORMs */
(b) for_each_link_platforms(dai_link, i, platform) {
for_each_component(component) {
...
(a) snd_soc_rtdcom_add(rtd, component);
}
}
}
It shows, it is possible to know how many components will be
connected to rtd by using
dai_link->num_cpus
dai_link->num_codecs
dai_link->num_platforms
If so, we can use component pointer array instead of list_head,
in such case, code can be more simple.
This patch removes struct snd_soc_rtdcom_list that is only
of temporary value, and convert to pointer array.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-By: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Link: https://lore.kernel.org/r/87a76wt4wm.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-01-10 02:35:21 +00:00
|
|
|
int i, ret = 0;
|
2012-08-16 11:40:41 +00:00
|
|
|
|
2019-08-13 10:45:32 +00:00
|
|
|
mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass);
|
2013-01-24 09:44:29 +00:00
|
|
|
|
2016-11-13 06:40:02 +00:00
|
|
|
if (cpu_dai->driver->cops && cpu_dai->driver->cops->ack) {
|
|
|
|
|
ret = cpu_dai->driver->cops->ack(cstream, bytes, cpu_dai);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
goto err;
|
|
|
|
|
}
|
|
|
|
|
|
ASoC: soc-core: remove snd_soc_rtdcom_list
Current ALSA SoC is using struct snd_soc_rtdcom_list to
connecting component to rtd by using list_head.
struct snd_soc_rtdcom_list {
struct snd_soc_component *component;
struct list_head list; /* rtd::component_list */
};
struct snd_soc_pcm_runtime {
...
struct list_head component_list; /* list of connected components */
...
};
The CPU/Codec/Platform component which will be connected to rtd (a)
is indicated via dai_link at snd_soc_add_pcm_runtime()
int snd_soc_add_pcm_runtime(...)
{
...
/* Find CPU from registered CPUs */
rtd->cpu_dai = snd_soc_find_dai(dai_link->cpus);
...
(a) snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);
...
/* Find CODEC from registered CODECs */
(b) for_each_link_codecs(dai_link, i, codec) {
rtd->codec_dais[i] = snd_soc_find_dai(codec);
...
(a) snd_soc_rtdcom_add(rtd, rtd->codec_dais[i]->component);
}
...
/* Find PLATFORM from registered PLATFORMs */
(b) for_each_link_platforms(dai_link, i, platform) {
for_each_component(component) {
...
(a) snd_soc_rtdcom_add(rtd, component);
}
}
}
It shows, it is possible to know how many components will be
connected to rtd by using
dai_link->num_cpus
dai_link->num_codecs
dai_link->num_platforms
If so, we can use component pointer array instead of list_head,
in such case, code can be more simple.
This patch removes struct snd_soc_rtdcom_list that is only
of temporary value, and convert to pointer array.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-By: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Link: https://lore.kernel.org/r/87a76wt4wm.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-01-10 02:35:21 +00:00
|
|
|
for_each_rtd_components(rtd, i, component) {
|
2017-10-11 01:37:45 +00:00
|
|
|
if (!component->driver->compr_ops ||
|
|
|
|
|
!component->driver->compr_ops->ack)
|
|
|
|
|
continue;
|
|
|
|
|
|
2019-02-05 11:18:12 +00:00
|
|
|
ret = component->driver->compr_ops->ack(cstream, bytes);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
goto err;
|
2017-10-11 01:37:45 +00:00
|
|
|
}
|
2012-08-16 11:40:41 +00:00
|
|
|
|
2016-11-13 06:40:02 +00:00
|
|
|
err:
|
2019-08-13 10:45:32 +00:00
|
|
|
mutex_unlock(&rtd->card->pcm_mutex);
|
2012-08-16 11:40:41 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int soc_compr_pointer(struct snd_compr_stream *cstream,
|
2018-04-26 16:30:07 +00:00
|
|
|
struct snd_compr_tstamp *tstamp)
|
2012-08-16 11:40:41 +00:00
|
|
|
{
|
|
|
|
|
struct snd_soc_pcm_runtime *rtd = cstream->private_data;
|
2017-10-11 01:37:45 +00:00
|
|
|
struct snd_soc_component *component;
|
ASoC: soc-core: remove snd_soc_rtdcom_list
Current ALSA SoC is using struct snd_soc_rtdcom_list to
connecting component to rtd by using list_head.
struct snd_soc_rtdcom_list {
struct snd_soc_component *component;
struct list_head list; /* rtd::component_list */
};
struct snd_soc_pcm_runtime {
...
struct list_head component_list; /* list of connected components */
...
};
The CPU/Codec/Platform component which will be connected to rtd (a)
is indicated via dai_link at snd_soc_add_pcm_runtime()
int snd_soc_add_pcm_runtime(...)
{
...
/* Find CPU from registered CPUs */
rtd->cpu_dai = snd_soc_find_dai(dai_link->cpus);
...
(a) snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);
...
/* Find CODEC from registered CODECs */
(b) for_each_link_codecs(dai_link, i, codec) {
rtd->codec_dais[i] = snd_soc_find_dai(codec);
...
(a) snd_soc_rtdcom_add(rtd, rtd->codec_dais[i]->component);
}
...
/* Find PLATFORM from registered PLATFORMs */
(b) for_each_link_platforms(dai_link, i, platform) {
for_each_component(component) {
...
(a) snd_soc_rtdcom_add(rtd, component);
}
}
}
It shows, it is possible to know how many components will be
connected to rtd by using
dai_link->num_cpus
dai_link->num_codecs
dai_link->num_platforms
If so, we can use component pointer array instead of list_head,
in such case, code can be more simple.
This patch removes struct snd_soc_rtdcom_list that is only
of temporary value, and convert to pointer array.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-By: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Link: https://lore.kernel.org/r/87a76wt4wm.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-01-10 02:35:21 +00:00
|
|
|
int i, ret = 0;
|
2016-11-13 06:40:02 +00:00
|
|
|
struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
|
2012-08-16 11:40:41 +00:00
|
|
|
|
2019-08-13 10:45:32 +00:00
|
|
|
mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass);
|
2013-01-24 09:44:29 +00:00
|
|
|
|
2016-11-13 06:40:02 +00:00
|
|
|
if (cpu_dai->driver->cops && cpu_dai->driver->cops->pointer)
|
|
|
|
|
cpu_dai->driver->cops->pointer(cstream, tstamp, cpu_dai);
|
|
|
|
|
|
ASoC: soc-core: remove snd_soc_rtdcom_list
Current ALSA SoC is using struct snd_soc_rtdcom_list to
connecting component to rtd by using list_head.
struct snd_soc_rtdcom_list {
struct snd_soc_component *component;
struct list_head list; /* rtd::component_list */
};
struct snd_soc_pcm_runtime {
...
struct list_head component_list; /* list of connected components */
...
};
The CPU/Codec/Platform component which will be connected to rtd (a)
is indicated via dai_link at snd_soc_add_pcm_runtime()
int snd_soc_add_pcm_runtime(...)
{
...
/* Find CPU from registered CPUs */
rtd->cpu_dai = snd_soc_find_dai(dai_link->cpus);
...
(a) snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);
...
/* Find CODEC from registered CODECs */
(b) for_each_link_codecs(dai_link, i, codec) {
rtd->codec_dais[i] = snd_soc_find_dai(codec);
...
(a) snd_soc_rtdcom_add(rtd, rtd->codec_dais[i]->component);
}
...
/* Find PLATFORM from registered PLATFORMs */
(b) for_each_link_platforms(dai_link, i, platform) {
for_each_component(component) {
...
(a) snd_soc_rtdcom_add(rtd, component);
}
}
}
It shows, it is possible to know how many components will be
connected to rtd by using
dai_link->num_cpus
dai_link->num_codecs
dai_link->num_platforms
If so, we can use component pointer array instead of list_head,
in such case, code can be more simple.
This patch removes struct snd_soc_rtdcom_list that is only
of temporary value, and convert to pointer array.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-By: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Link: https://lore.kernel.org/r/87a76wt4wm.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-01-10 02:35:21 +00:00
|
|
|
for_each_rtd_components(rtd, i, component) {
|
2017-10-11 01:37:45 +00:00
|
|
|
if (!component->driver->compr_ops ||
|
|
|
|
|
!component->driver->compr_ops->pointer)
|
|
|
|
|
continue;
|
2012-08-16 11:40:41 +00:00
|
|
|
|
2019-02-05 11:18:12 +00:00
|
|
|
ret = component->driver->compr_ops->pointer(cstream, tstamp);
|
|
|
|
|
break;
|
2017-10-11 01:37:45 +00:00
|
|
|
}
|
|
|
|
|
|
2019-08-13 10:45:32 +00:00
|
|
|
mutex_unlock(&rtd->card->pcm_mutex);
|
2016-06-20 08:51:32 +00:00
|
|
|
return ret;
|
2012-08-16 11:40:41 +00:00
|
|
|
}
|
|
|
|
|
|
2013-02-05 10:41:47 +00:00
|
|
|
static int soc_compr_copy(struct snd_compr_stream *cstream,
|
2013-04-18 10:01:38 +00:00
|
|
|
char __user *buf, size_t count)
|
2013-02-05 10:41:47 +00:00
|
|
|
{
|
|
|
|
|
struct snd_soc_pcm_runtime *rtd = cstream->private_data;
|
2017-10-11 01:37:45 +00:00
|
|
|
struct snd_soc_component *component;
|
ASoC: soc-core: remove snd_soc_rtdcom_list
Current ALSA SoC is using struct snd_soc_rtdcom_list to
connecting component to rtd by using list_head.
struct snd_soc_rtdcom_list {
struct snd_soc_component *component;
struct list_head list; /* rtd::component_list */
};
struct snd_soc_pcm_runtime {
...
struct list_head component_list; /* list of connected components */
...
};
The CPU/Codec/Platform component which will be connected to rtd (a)
is indicated via dai_link at snd_soc_add_pcm_runtime()
int snd_soc_add_pcm_runtime(...)
{
...
/* Find CPU from registered CPUs */
rtd->cpu_dai = snd_soc_find_dai(dai_link->cpus);
...
(a) snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);
...
/* Find CODEC from registered CODECs */
(b) for_each_link_codecs(dai_link, i, codec) {
rtd->codec_dais[i] = snd_soc_find_dai(codec);
...
(a) snd_soc_rtdcom_add(rtd, rtd->codec_dais[i]->component);
}
...
/* Find PLATFORM from registered PLATFORMs */
(b) for_each_link_platforms(dai_link, i, platform) {
for_each_component(component) {
...
(a) snd_soc_rtdcom_add(rtd, component);
}
}
}
It shows, it is possible to know how many components will be
connected to rtd by using
dai_link->num_cpus
dai_link->num_codecs
dai_link->num_platforms
If so, we can use component pointer array instead of list_head,
in such case, code can be more simple.
This patch removes struct snd_soc_rtdcom_list that is only
of temporary value, and convert to pointer array.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-By: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Link: https://lore.kernel.org/r/87a76wt4wm.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-01-10 02:35:21 +00:00
|
|
|
int i, ret = 0;
|
2013-02-05 10:41:47 +00:00
|
|
|
|
2019-08-13 10:45:32 +00:00
|
|
|
mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass);
|
2013-02-05 10:41:47 +00:00
|
|
|
|
ASoC: soc-core: remove snd_soc_rtdcom_list
Current ALSA SoC is using struct snd_soc_rtdcom_list to
connecting component to rtd by using list_head.
struct snd_soc_rtdcom_list {
struct snd_soc_component *component;
struct list_head list; /* rtd::component_list */
};
struct snd_soc_pcm_runtime {
...
struct list_head component_list; /* list of connected components */
...
};
The CPU/Codec/Platform component which will be connected to rtd (a)
is indicated via dai_link at snd_soc_add_pcm_runtime()
int snd_soc_add_pcm_runtime(...)
{
...
/* Find CPU from registered CPUs */
rtd->cpu_dai = snd_soc_find_dai(dai_link->cpus);
...
(a) snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);
...
/* Find CODEC from registered CODECs */
(b) for_each_link_codecs(dai_link, i, codec) {
rtd->codec_dais[i] = snd_soc_find_dai(codec);
...
(a) snd_soc_rtdcom_add(rtd, rtd->codec_dais[i]->component);
}
...
/* Find PLATFORM from registered PLATFORMs */
(b) for_each_link_platforms(dai_link, i, platform) {
for_each_component(component) {
...
(a) snd_soc_rtdcom_add(rtd, component);
}
}
}
It shows, it is possible to know how many components will be
connected to rtd by using
dai_link->num_cpus
dai_link->num_codecs
dai_link->num_platforms
If so, we can use component pointer array instead of list_head,
in such case, code can be more simple.
This patch removes struct snd_soc_rtdcom_list that is only
of temporary value, and convert to pointer array.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-By: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Link: https://lore.kernel.org/r/87a76wt4wm.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-01-10 02:35:21 +00:00
|
|
|
for_each_rtd_components(rtd, i, component) {
|
2017-10-11 01:37:45 +00:00
|
|
|
if (!component->driver->compr_ops ||
|
|
|
|
|
!component->driver->compr_ops->copy)
|
|
|
|
|
continue;
|
2013-02-05 10:41:47 +00:00
|
|
|
|
2018-01-26 13:08:43 +00:00
|
|
|
ret = component->driver->compr_ops->copy(cstream, buf, count);
|
|
|
|
|
break;
|
2017-10-11 01:37:45 +00:00
|
|
|
}
|
2018-01-26 13:08:43 +00:00
|
|
|
|
2019-08-13 10:45:32 +00:00
|
|
|
mutex_unlock(&rtd->card->pcm_mutex);
|
2013-02-05 10:41:47 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2013-07-28 14:36:15 +00:00
|
|
|
static int soc_compr_set_metadata(struct snd_compr_stream *cstream,
|
2018-04-26 16:30:07 +00:00
|
|
|
struct snd_compr_metadata *metadata)
|
2013-03-26 15:52:28 +00:00
|
|
|
{
|
|
|
|
|
struct snd_soc_pcm_runtime *rtd = cstream->private_data;
|
2017-10-11 01:37:45 +00:00
|
|
|
struct snd_soc_component *component;
|
2016-11-13 06:40:02 +00:00
|
|
|
struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
|
ASoC: soc-core: remove snd_soc_rtdcom_list
Current ALSA SoC is using struct snd_soc_rtdcom_list to
connecting component to rtd by using list_head.
struct snd_soc_rtdcom_list {
struct snd_soc_component *component;
struct list_head list; /* rtd::component_list */
};
struct snd_soc_pcm_runtime {
...
struct list_head component_list; /* list of connected components */
...
};
The CPU/Codec/Platform component which will be connected to rtd (a)
is indicated via dai_link at snd_soc_add_pcm_runtime()
int snd_soc_add_pcm_runtime(...)
{
...
/* Find CPU from registered CPUs */
rtd->cpu_dai = snd_soc_find_dai(dai_link->cpus);
...
(a) snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);
...
/* Find CODEC from registered CODECs */
(b) for_each_link_codecs(dai_link, i, codec) {
rtd->codec_dais[i] = snd_soc_find_dai(codec);
...
(a) snd_soc_rtdcom_add(rtd, rtd->codec_dais[i]->component);
}
...
/* Find PLATFORM from registered PLATFORMs */
(b) for_each_link_platforms(dai_link, i, platform) {
for_each_component(component) {
...
(a) snd_soc_rtdcom_add(rtd, component);
}
}
}
It shows, it is possible to know how many components will be
connected to rtd by using
dai_link->num_cpus
dai_link->num_codecs
dai_link->num_platforms
If so, we can use component pointer array instead of list_head,
in such case, code can be more simple.
This patch removes struct snd_soc_rtdcom_list that is only
of temporary value, and convert to pointer array.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-By: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Link: https://lore.kernel.org/r/87a76wt4wm.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-01-10 02:35:21 +00:00
|
|
|
int i, ret;
|
2013-03-26 15:52:28 +00:00
|
|
|
|
2016-11-13 06:40:02 +00:00
|
|
|
if (cpu_dai->driver->cops && cpu_dai->driver->cops->set_metadata) {
|
|
|
|
|
ret = cpu_dai->driver->cops->set_metadata(cstream, metadata, cpu_dai);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
ASoC: soc-core: remove snd_soc_rtdcom_list
Current ALSA SoC is using struct snd_soc_rtdcom_list to
connecting component to rtd by using list_head.
struct snd_soc_rtdcom_list {
struct snd_soc_component *component;
struct list_head list; /* rtd::component_list */
};
struct snd_soc_pcm_runtime {
...
struct list_head component_list; /* list of connected components */
...
};
The CPU/Codec/Platform component which will be connected to rtd (a)
is indicated via dai_link at snd_soc_add_pcm_runtime()
int snd_soc_add_pcm_runtime(...)
{
...
/* Find CPU from registered CPUs */
rtd->cpu_dai = snd_soc_find_dai(dai_link->cpus);
...
(a) snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);
...
/* Find CODEC from registered CODECs */
(b) for_each_link_codecs(dai_link, i, codec) {
rtd->codec_dais[i] = snd_soc_find_dai(codec);
...
(a) snd_soc_rtdcom_add(rtd, rtd->codec_dais[i]->component);
}
...
/* Find PLATFORM from registered PLATFORMs */
(b) for_each_link_platforms(dai_link, i, platform) {
for_each_component(component) {
...
(a) snd_soc_rtdcom_add(rtd, component);
}
}
}
It shows, it is possible to know how many components will be
connected to rtd by using
dai_link->num_cpus
dai_link->num_codecs
dai_link->num_platforms
If so, we can use component pointer array instead of list_head,
in such case, code can be more simple.
This patch removes struct snd_soc_rtdcom_list that is only
of temporary value, and convert to pointer array.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-By: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Link: https://lore.kernel.org/r/87a76wt4wm.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-01-10 02:35:21 +00:00
|
|
|
for_each_rtd_components(rtd, i, component) {
|
2017-10-11 01:37:45 +00:00
|
|
|
if (!component->driver->compr_ops ||
|
|
|
|
|
!component->driver->compr_ops->set_metadata)
|
|
|
|
|
continue;
|
|
|
|
|
|
2019-02-05 11:18:12 +00:00
|
|
|
ret = component->driver->compr_ops->set_metadata(cstream,
|
|
|
|
|
metadata);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
return ret;
|
2017-10-11 01:37:45 +00:00
|
|
|
}
|
2013-03-26 15:52:28 +00:00
|
|
|
|
2019-02-05 11:18:12 +00:00
|
|
|
return 0;
|
2013-03-26 15:52:28 +00:00
|
|
|
}
|
|
|
|
|
|
2013-07-28 14:36:15 +00:00
|
|
|
static int soc_compr_get_metadata(struct snd_compr_stream *cstream,
|
2018-04-26 16:30:07 +00:00
|
|
|
struct snd_compr_metadata *metadata)
|
2013-03-26 15:52:28 +00:00
|
|
|
{
|
|
|
|
|
struct snd_soc_pcm_runtime *rtd = cstream->private_data;
|
2017-10-11 01:37:45 +00:00
|
|
|
struct snd_soc_component *component;
|
2016-11-13 06:40:02 +00:00
|
|
|
struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
|
ASoC: soc-core: remove snd_soc_rtdcom_list
Current ALSA SoC is using struct snd_soc_rtdcom_list to
connecting component to rtd by using list_head.
struct snd_soc_rtdcom_list {
struct snd_soc_component *component;
struct list_head list; /* rtd::component_list */
};
struct snd_soc_pcm_runtime {
...
struct list_head component_list; /* list of connected components */
...
};
The CPU/Codec/Platform component which will be connected to rtd (a)
is indicated via dai_link at snd_soc_add_pcm_runtime()
int snd_soc_add_pcm_runtime(...)
{
...
/* Find CPU from registered CPUs */
rtd->cpu_dai = snd_soc_find_dai(dai_link->cpus);
...
(a) snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);
...
/* Find CODEC from registered CODECs */
(b) for_each_link_codecs(dai_link, i, codec) {
rtd->codec_dais[i] = snd_soc_find_dai(codec);
...
(a) snd_soc_rtdcom_add(rtd, rtd->codec_dais[i]->component);
}
...
/* Find PLATFORM from registered PLATFORMs */
(b) for_each_link_platforms(dai_link, i, platform) {
for_each_component(component) {
...
(a) snd_soc_rtdcom_add(rtd, component);
}
}
}
It shows, it is possible to know how many components will be
connected to rtd by using
dai_link->num_cpus
dai_link->num_codecs
dai_link->num_platforms
If so, we can use component pointer array instead of list_head,
in such case, code can be more simple.
This patch removes struct snd_soc_rtdcom_list that is only
of temporary value, and convert to pointer array.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-By: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Link: https://lore.kernel.org/r/87a76wt4wm.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-01-10 02:35:21 +00:00
|
|
|
int i, ret;
|
2013-03-26 15:52:28 +00:00
|
|
|
|
2016-11-13 06:40:02 +00:00
|
|
|
if (cpu_dai->driver->cops && cpu_dai->driver->cops->get_metadata) {
|
|
|
|
|
ret = cpu_dai->driver->cops->get_metadata(cstream, metadata, cpu_dai);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
ASoC: soc-core: remove snd_soc_rtdcom_list
Current ALSA SoC is using struct snd_soc_rtdcom_list to
connecting component to rtd by using list_head.
struct snd_soc_rtdcom_list {
struct snd_soc_component *component;
struct list_head list; /* rtd::component_list */
};
struct snd_soc_pcm_runtime {
...
struct list_head component_list; /* list of connected components */
...
};
The CPU/Codec/Platform component which will be connected to rtd (a)
is indicated via dai_link at snd_soc_add_pcm_runtime()
int snd_soc_add_pcm_runtime(...)
{
...
/* Find CPU from registered CPUs */
rtd->cpu_dai = snd_soc_find_dai(dai_link->cpus);
...
(a) snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);
...
/* Find CODEC from registered CODECs */
(b) for_each_link_codecs(dai_link, i, codec) {
rtd->codec_dais[i] = snd_soc_find_dai(codec);
...
(a) snd_soc_rtdcom_add(rtd, rtd->codec_dais[i]->component);
}
...
/* Find PLATFORM from registered PLATFORMs */
(b) for_each_link_platforms(dai_link, i, platform) {
for_each_component(component) {
...
(a) snd_soc_rtdcom_add(rtd, component);
}
}
}
It shows, it is possible to know how many components will be
connected to rtd by using
dai_link->num_cpus
dai_link->num_codecs
dai_link->num_platforms
If so, we can use component pointer array instead of list_head,
in such case, code can be more simple.
This patch removes struct snd_soc_rtdcom_list that is only
of temporary value, and convert to pointer array.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-By: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Link: https://lore.kernel.org/r/87a76wt4wm.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-01-10 02:35:21 +00:00
|
|
|
for_each_rtd_components(rtd, i, component) {
|
2017-10-11 01:37:45 +00:00
|
|
|
if (!component->driver->compr_ops ||
|
|
|
|
|
!component->driver->compr_ops->get_metadata)
|
|
|
|
|
continue;
|
|
|
|
|
|
2019-02-05 11:18:12 +00:00
|
|
|
return component->driver->compr_ops->get_metadata(cstream,
|
|
|
|
|
metadata);
|
2017-10-11 01:37:45 +00:00
|
|
|
}
|
2013-03-26 15:52:28 +00:00
|
|
|
|
2019-02-05 11:18:12 +00:00
|
|
|
return 0;
|
2013-03-26 15:52:28 +00:00
|
|
|
}
|
2014-01-17 17:03:56 +00:00
|
|
|
|
2012-08-16 11:40:41 +00:00
|
|
|
/* ASoC Compress operations */
|
|
|
|
|
static struct snd_compr_ops soc_compr_ops = {
|
|
|
|
|
.open = soc_compr_open,
|
|
|
|
|
.free = soc_compr_free,
|
|
|
|
|
.set_params = soc_compr_set_params,
|
2013-07-28 14:36:15 +00:00
|
|
|
.set_metadata = soc_compr_set_metadata,
|
|
|
|
|
.get_metadata = soc_compr_get_metadata,
|
2012-08-16 11:40:41 +00:00
|
|
|
.get_params = soc_compr_get_params,
|
|
|
|
|
.trigger = soc_compr_trigger,
|
|
|
|
|
.pointer = soc_compr_pointer,
|
|
|
|
|
.ack = soc_compr_ack,
|
|
|
|
|
.get_caps = soc_compr_get_caps,
|
|
|
|
|
.get_codec_caps = soc_compr_get_codec_caps
|
|
|
|
|
};
|
|
|
|
|
|
2014-01-17 17:03:56 +00:00
|
|
|
/* ASoC Dynamic Compress operations */
|
|
|
|
|
static struct snd_compr_ops soc_compr_dyn_ops = {
|
|
|
|
|
.open = soc_compr_open_fe,
|
|
|
|
|
.free = soc_compr_free_fe,
|
|
|
|
|
.set_params = soc_compr_set_params_fe,
|
|
|
|
|
.get_params = soc_compr_get_params,
|
|
|
|
|
.set_metadata = soc_compr_set_metadata,
|
|
|
|
|
.get_metadata = soc_compr_get_metadata,
|
|
|
|
|
.trigger = soc_compr_trigger_fe,
|
|
|
|
|
.pointer = soc_compr_pointer,
|
|
|
|
|
.ack = soc_compr_ack,
|
|
|
|
|
.get_caps = soc_compr_get_caps,
|
|
|
|
|
.get_codec_caps = soc_compr_get_codec_caps
|
|
|
|
|
};
|
|
|
|
|
|
2015-10-13 15:41:00 +00:00
|
|
|
/**
|
|
|
|
|
* snd_soc_new_compress - create a new compress.
|
|
|
|
|
*
|
|
|
|
|
* @rtd: The runtime for which we will create compress
|
|
|
|
|
* @num: the device index number (zero based - shared with normal PCMs)
|
|
|
|
|
*
|
|
|
|
|
* Return: 0 for success, else error.
|
|
|
|
|
*/
|
|
|
|
|
int snd_soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num)
|
2012-08-16 11:40:41 +00:00
|
|
|
{
|
2017-10-11 01:37:45 +00:00
|
|
|
struct snd_soc_component *component;
|
2012-08-16 11:40:41 +00:00
|
|
|
struct snd_soc_dai *codec_dai = rtd->codec_dai;
|
|
|
|
|
struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
|
|
|
|
|
struct snd_compr *compr;
|
2014-01-17 17:03:56 +00:00
|
|
|
struct snd_pcm *be_pcm;
|
2012-08-16 11:40:41 +00:00
|
|
|
char new_name[64];
|
|
|
|
|
int ret = 0, direction = 0;
|
2016-01-07 16:18:14 +00:00
|
|
|
int playback = 0, capture = 0;
|
ASoC: soc-core: remove snd_soc_rtdcom_list
Current ALSA SoC is using struct snd_soc_rtdcom_list to
connecting component to rtd by using list_head.
struct snd_soc_rtdcom_list {
struct snd_soc_component *component;
struct list_head list; /* rtd::component_list */
};
struct snd_soc_pcm_runtime {
...
struct list_head component_list; /* list of connected components */
...
};
The CPU/Codec/Platform component which will be connected to rtd (a)
is indicated via dai_link at snd_soc_add_pcm_runtime()
int snd_soc_add_pcm_runtime(...)
{
...
/* Find CPU from registered CPUs */
rtd->cpu_dai = snd_soc_find_dai(dai_link->cpus);
...
(a) snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);
...
/* Find CODEC from registered CODECs */
(b) for_each_link_codecs(dai_link, i, codec) {
rtd->codec_dais[i] = snd_soc_find_dai(codec);
...
(a) snd_soc_rtdcom_add(rtd, rtd->codec_dais[i]->component);
}
...
/* Find PLATFORM from registered PLATFORMs */
(b) for_each_link_platforms(dai_link, i, platform) {
for_each_component(component) {
...
(a) snd_soc_rtdcom_add(rtd, component);
}
}
}
It shows, it is possible to know how many components will be
connected to rtd by using
dai_link->num_cpus
dai_link->num_codecs
dai_link->num_platforms
If so, we can use component pointer array instead of list_head,
in such case, code can be more simple.
This patch removes struct snd_soc_rtdcom_list that is only
of temporary value, and convert to pointer array.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-By: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Link: https://lore.kernel.org/r/87a76wt4wm.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-01-10 02:35:21 +00:00
|
|
|
int i;
|
2012-08-16 11:40:41 +00:00
|
|
|
|
2014-07-08 21:19:37 +00:00
|
|
|
if (rtd->num_codecs > 1) {
|
2018-01-26 13:08:45 +00:00
|
|
|
dev_err(rtd->card->dev,
|
|
|
|
|
"Compress ASoC: Multicodec not supported\n");
|
2014-07-08 21:19:37 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
|
2012-08-16 11:40:41 +00:00
|
|
|
/* check client and interface hw capabilities */
|
2019-07-22 01:36:16 +00:00
|
|
|
if (snd_soc_dai_stream_valid(codec_dai, SNDRV_PCM_STREAM_PLAYBACK) &&
|
|
|
|
|
snd_soc_dai_stream_valid(cpu_dai, SNDRV_PCM_STREAM_PLAYBACK))
|
2016-01-07 16:18:14 +00:00
|
|
|
playback = 1;
|
2019-07-22 01:36:16 +00:00
|
|
|
if (snd_soc_dai_stream_valid(codec_dai, SNDRV_PCM_STREAM_CAPTURE) &&
|
|
|
|
|
snd_soc_dai_stream_valid(cpu_dai, SNDRV_PCM_STREAM_CAPTURE))
|
2016-01-07 16:18:14 +00:00
|
|
|
capture = 1;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Compress devices are unidirectional so only one of the directions
|
|
|
|
|
* should be set, check for that (xor)
|
|
|
|
|
*/
|
|
|
|
|
if (playback + capture != 1) {
|
2018-01-26 13:08:45 +00:00
|
|
|
dev_err(rtd->card->dev,
|
|
|
|
|
"Compress ASoC: Invalid direction for P %d, C %d\n",
|
|
|
|
|
playback, capture);
|
2016-01-07 16:18:14 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
|
2017-08-16 14:47:53 +00:00
|
|
|
if (playback)
|
2013-04-18 10:02:38 +00:00
|
|
|
direction = SND_COMPRESS_PLAYBACK;
|
|
|
|
|
else
|
2016-01-07 16:18:14 +00:00
|
|
|
direction = SND_COMPRESS_CAPTURE;
|
2013-04-18 10:02:38 +00:00
|
|
|
|
2019-06-17 11:36:36 +00:00
|
|
|
compr = devm_kzalloc(rtd->card->dev, sizeof(*compr), GFP_KERNEL);
|
2017-08-10 14:21:34 +00:00
|
|
|
if (!compr)
|
2012-08-16 11:40:41 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
|
|
2013-02-05 10:41:47 +00:00
|
|
|
compr->ops = devm_kzalloc(rtd->card->dev, sizeof(soc_compr_ops),
|
|
|
|
|
GFP_KERNEL);
|
2019-06-17 11:36:36 +00:00
|
|
|
if (!compr->ops)
|
|
|
|
|
return -ENOMEM;
|
2014-01-17 17:03:56 +00:00
|
|
|
|
|
|
|
|
if (rtd->dai_link->dynamic) {
|
|
|
|
|
snprintf(new_name, sizeof(new_name), "(%s)",
|
|
|
|
|
rtd->dai_link->stream_name);
|
|
|
|
|
|
|
|
|
|
ret = snd_pcm_new_internal(rtd->card->snd_card, new_name, num,
|
2015-01-14 08:47:29 +00:00
|
|
|
rtd->dai_link->dpcm_playback,
|
|
|
|
|
rtd->dai_link->dpcm_capture, &be_pcm);
|
2014-01-17 17:03:56 +00:00
|
|
|
if (ret < 0) {
|
2018-01-26 13:08:45 +00:00
|
|
|
dev_err(rtd->card->dev,
|
|
|
|
|
"Compress ASoC: can't create compressed for %s: %d\n",
|
|
|
|
|
rtd->dai_link->name, ret);
|
2019-06-17 11:36:36 +00:00
|
|
|
return ret;
|
2014-01-17 17:03:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
rtd->pcm = be_pcm;
|
|
|
|
|
rtd->fe_compr = 1;
|
2015-01-14 08:47:29 +00:00
|
|
|
if (rtd->dai_link->dpcm_playback)
|
|
|
|
|
be_pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream->private_data = rtd;
|
|
|
|
|
else if (rtd->dai_link->dpcm_capture)
|
|
|
|
|
be_pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream->private_data = rtd;
|
2014-01-17 17:03:56 +00:00
|
|
|
memcpy(compr->ops, &soc_compr_dyn_ops, sizeof(soc_compr_dyn_ops));
|
2017-08-16 14:47:53 +00:00
|
|
|
} else {
|
|
|
|
|
snprintf(new_name, sizeof(new_name), "%s %s-%d",
|
|
|
|
|
rtd->dai_link->stream_name, codec_dai->name, num);
|
|
|
|
|
|
2014-01-17 17:03:56 +00:00
|
|
|
memcpy(compr->ops, &soc_compr_ops, sizeof(soc_compr_ops));
|
2017-08-16 14:47:53 +00:00
|
|
|
}
|
2013-02-05 10:41:47 +00:00
|
|
|
|
ASoC: soc-core: remove snd_soc_rtdcom_list
Current ALSA SoC is using struct snd_soc_rtdcom_list to
connecting component to rtd by using list_head.
struct snd_soc_rtdcom_list {
struct snd_soc_component *component;
struct list_head list; /* rtd::component_list */
};
struct snd_soc_pcm_runtime {
...
struct list_head component_list; /* list of connected components */
...
};
The CPU/Codec/Platform component which will be connected to rtd (a)
is indicated via dai_link at snd_soc_add_pcm_runtime()
int snd_soc_add_pcm_runtime(...)
{
...
/* Find CPU from registered CPUs */
rtd->cpu_dai = snd_soc_find_dai(dai_link->cpus);
...
(a) snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);
...
/* Find CODEC from registered CODECs */
(b) for_each_link_codecs(dai_link, i, codec) {
rtd->codec_dais[i] = snd_soc_find_dai(codec);
...
(a) snd_soc_rtdcom_add(rtd, rtd->codec_dais[i]->component);
}
...
/* Find PLATFORM from registered PLATFORMs */
(b) for_each_link_platforms(dai_link, i, platform) {
for_each_component(component) {
...
(a) snd_soc_rtdcom_add(rtd, component);
}
}
}
It shows, it is possible to know how many components will be
connected to rtd by using
dai_link->num_cpus
dai_link->num_codecs
dai_link->num_platforms
If so, we can use component pointer array instead of list_head,
in such case, code can be more simple.
This patch removes struct snd_soc_rtdcom_list that is only
of temporary value, and convert to pointer array.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Reviewed-By: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Link: https://lore.kernel.org/r/87a76wt4wm.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-01-10 02:35:21 +00:00
|
|
|
for_each_rtd_components(rtd, i, component) {
|
2017-10-11 01:37:45 +00:00
|
|
|
if (!component->driver->compr_ops ||
|
|
|
|
|
!component->driver->compr_ops->copy)
|
|
|
|
|
continue;
|
|
|
|
|
|
2013-02-05 10:41:47 +00:00
|
|
|
compr->ops->copy = soc_compr_copy;
|
2018-04-26 16:30:04 +00:00
|
|
|
break;
|
2017-10-11 01:37:45 +00:00
|
|
|
}
|
|
|
|
|
|
2012-08-16 11:40:41 +00:00
|
|
|
mutex_init(&compr->lock);
|
2015-11-25 13:00:24 +00:00
|
|
|
ret = snd_compress_new(rtd->card->snd_card, num, direction,
|
|
|
|
|
new_name, compr);
|
2012-08-16 11:40:41 +00:00
|
|
|
if (ret < 0) {
|
2017-12-05 04:23:05 +00:00
|
|
|
component = rtd->codec_dai->component;
|
2018-01-26 13:08:45 +00:00
|
|
|
dev_err(component->dev,
|
|
|
|
|
"Compress ASoC: can't create compress for codec %s: %d\n",
|
|
|
|
|
component->name, ret);
|
2019-06-17 11:36:36 +00:00
|
|
|
return ret;
|
2012-08-16 11:40:41 +00:00
|
|
|
}
|
|
|
|
|
|
2013-01-24 09:44:30 +00:00
|
|
|
/* DAPM dai link stream work */
|
2019-12-03 17:30:07 +00:00
|
|
|
rtd->close_delayed_work_func = close_delayed_work;
|
2013-01-24 09:44:30 +00:00
|
|
|
|
2012-08-16 11:40:41 +00:00
|
|
|
rtd->compr = compr;
|
|
|
|
|
compr->private_data = rtd;
|
|
|
|
|
|
2018-01-26 13:08:45 +00:00
|
|
|
dev_info(rtd->card->dev, "Compress ASoC: %s <-> %s mapping ok\n",
|
|
|
|
|
codec_dai->name, cpu_dai->name);
|
2013-02-05 10:41:47 +00:00
|
|
|
|
2019-06-17 11:36:36 +00:00
|
|
|
return 0;
|
2012-08-16 11:40:41 +00:00
|
|
|
}
|
2015-10-13 15:41:00 +00:00
|
|
|
EXPORT_SYMBOL_GPL(snd_soc_new_compress);
|
