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>
|
2020-05-25 00:57:41 +00:00
|
|
|
#include <sound/soc-link.h>
|
2019-12-17 09:58:50 +00:00
|
|
|
#include <linux/pm_runtime.h>
|
2012-08-16 11:40:41 +00:00
|
|
|
|
2021-09-01 09:52:55 +00:00
|
|
|
static int snd_soc_compr_components_open(struct snd_compr_stream *cstream)
|
|
|
|
|
{
|
|
|
|
|
struct snd_soc_pcm_runtime *rtd = cstream->private_data;
|
|
|
|
|
struct snd_soc_component *component;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
for_each_rtd_components(rtd, i, component) {
|
|
|
|
|
ret = snd_soc_component_module_get_when_open(component, cstream);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
ret = snd_soc_component_compr_open(component, cstream);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void snd_soc_compr_components_free(struct snd_compr_stream *cstream,
|
|
|
|
|
int rollback)
|
|
|
|
|
{
|
|
|
|
|
struct snd_soc_pcm_runtime *rtd = cstream->private_data;
|
|
|
|
|
struct snd_soc_component *component;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
for_each_rtd_components(rtd, i, component) {
|
|
|
|
|
snd_soc_component_compr_free(component, cstream, rollback);
|
|
|
|
|
snd_soc_component_module_put_when_close(component, cstream, rollback);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2020-11-18 23:50:19 +00:00
|
|
|
static int soc_compr_clean(struct snd_compr_stream *cstream, int rollback)
|
2020-11-18 23:49:57 +00:00
|
|
|
{
|
|
|
|
|
struct snd_soc_pcm_runtime *rtd = cstream->private_data;
|
|
|
|
|
struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0);
|
|
|
|
|
struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
|
|
|
|
|
int stream = cstream->direction; /* SND_COMPRESS_xxx is same as SNDRV_PCM_STREAM_xxx */
|
|
|
|
|
|
|
|
|
|
mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass);
|
|
|
|
|
|
2020-11-18 23:50:19 +00:00
|
|
|
if (!rollback)
|
|
|
|
|
snd_soc_runtime_deactivate(rtd, stream);
|
2020-11-18 23:49:57 +00:00
|
|
|
|
|
|
|
|
snd_soc_dai_digital_mute(codec_dai, 1, stream);
|
|
|
|
|
|
|
|
|
|
if (!snd_soc_dai_active(cpu_dai))
|
|
|
|
|
cpu_dai->rate = 0;
|
|
|
|
|
|
|
|
|
|
if (!snd_soc_dai_active(codec_dai))
|
|
|
|
|
codec_dai->rate = 0;
|
|
|
|
|
|
2020-11-18 23:50:19 +00:00
|
|
|
snd_soc_link_compr_shutdown(cstream, rollback);
|
2020-11-18 23:49:57 +00:00
|
|
|
|
2021-09-01 09:52:55 +00:00
|
|
|
snd_soc_compr_components_free(cstream, rollback);
|
2020-11-18 23:49:57 +00:00
|
|
|
|
2020-11-18 23:50:19 +00:00
|
|
|
snd_soc_dai_compr_shutdown(cpu_dai, cstream, rollback);
|
2020-11-18 23:49:57 +00:00
|
|
|
|
2020-11-18 23:50:19 +00:00
|
|
|
if (!rollback)
|
|
|
|
|
snd_soc_dapm_stream_stop(rtd, stream);
|
2020-11-18 23:49:57 +00:00
|
|
|
|
|
|
|
|
mutex_unlock(&rtd->card->pcm_mutex);
|
|
|
|
|
|
2020-11-18 23:50:19 +00:00
|
|
|
snd_soc_pcm_component_pm_runtime_put(rtd, cstream, rollback);
|
2020-11-18 23:49:57 +00:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2020-11-18 23:50:19 +00:00
|
|
|
static int soc_compr_free(struct snd_compr_stream *cstream)
|
|
|
|
|
{
|
|
|
|
|
return soc_compr_clean(cstream, 0);
|
|
|
|
|
}
|
|
|
|
|
|
2018-04-24 15:39:03 +00:00
|
|
|
static int soc_compr_open(struct snd_compr_stream *cstream)
|
|
|
|
|
{
|
|
|
|
|
struct snd_soc_pcm_runtime *rtd = cstream->private_data;
|
2020-03-30 01:47:37 +00:00
|
|
|
struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0);
|
2020-10-30 01:01:22 +00:00
|
|
|
int stream = cstream->direction; /* SND_COMPRESS_xxx is same as SNDRV_PCM_STREAM_xxx */
|
ASoC: soc-component: add mark for snd_soc_pcm_component_pm_runtime_get/put()
soc_pcm_open() does rollback when failed (A),
but, it is almost same as soc_pcm_close().
static int soc_pcm_open(xxx)
{
...
if (ret < 0)
goto xxx_err;
...
return 0;
^ config_err:
| ...
| rtd_startup_err:
(A) ...
| component_err:
| ...
v return ret;
}
The difference is
soc_pcm_close() is for all dai/component/substream,
rollback is for succeeded part only.
This kind of duplicated code can be a hotbed of bugs,
thus, we want to share soc_pcm_close() and rollback.
Now, soc_pcm_open/close() are handling
1) snd_soc_dai_startup/shutdown()
2) snd_soc_link_startup/shutdown()
3) snd_soc_component_module_get/put()
4) snd_soc_component_open/close()
=> 5) pm_runtime_put/get()
This patch is for 5) pm_runtime_put/get().
The idea of having bit-flag or counter is not enough for this purpose.
For example if one DAI is used for 2xPlaybacks for some reasons,
and if 1st Playback was succeeded but 2nd Playback was failed,
2nd Playback rollback doesn't need to call shutdown.
But it has succeeded bit-flag or counter via 1st Playback,
thus, 2nd Playback rollback will call unneeded shutdown.
And 1st Playback's necessary shutdown will not be called,
because bit-flag or counter was cleared by wrong 2nd Playback rollback.
To avoid such case, this patch marks substream pointer when get() was
succeeded. If rollback needed, it will check rollback flag and marked
substream pointer.
One note here is that it cares *current* get() only now.
but we might want to check *whole* marked substream in the future.
This patch is using macro named "push/pop", so that it can be easily
update.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87h7ribwnb.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-09-28 00:01:17 +00:00
|
|
|
int ret;
|
2018-04-24 15:39:03 +00:00
|
|
|
|
ASoC: soc-component: add mark for snd_soc_pcm_component_pm_runtime_get/put()
soc_pcm_open() does rollback when failed (A),
but, it is almost same as soc_pcm_close().
static int soc_pcm_open(xxx)
{
...
if (ret < 0)
goto xxx_err;
...
return 0;
^ config_err:
| ...
| rtd_startup_err:
(A) ...
| component_err:
| ...
v return ret;
}
The difference is
soc_pcm_close() is for all dai/component/substream,
rollback is for succeeded part only.
This kind of duplicated code can be a hotbed of bugs,
thus, we want to share soc_pcm_close() and rollback.
Now, soc_pcm_open/close() are handling
1) snd_soc_dai_startup/shutdown()
2) snd_soc_link_startup/shutdown()
3) snd_soc_component_module_get/put()
4) snd_soc_component_open/close()
=> 5) pm_runtime_put/get()
This patch is for 5) pm_runtime_put/get().
The idea of having bit-flag or counter is not enough for this purpose.
For example if one DAI is used for 2xPlaybacks for some reasons,
and if 1st Playback was succeeded but 2nd Playback was failed,
2nd Playback rollback doesn't need to call shutdown.
But it has succeeded bit-flag or counter via 1st Playback,
thus, 2nd Playback rollback will call unneeded shutdown.
And 1st Playback's necessary shutdown will not be called,
because bit-flag or counter was cleared by wrong 2nd Playback rollback.
To avoid such case, this patch marks substream pointer when get() was
succeeded. If rollback needed, it will check rollback flag and marked
substream pointer.
One note here is that it cares *current* get() only now.
but we might want to check *whole* marked substream in the future.
This patch is using macro named "push/pop", so that it can be easily
update.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Link: https://lore.kernel.org/r/87h7ribwnb.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-09-28 00:01:17 +00:00
|
|
|
ret = snd_soc_pcm_component_pm_runtime_get(rtd, cstream);
|
|
|
|
|
if (ret < 0)
|
2020-11-18 23:50:19 +00:00
|
|
|
goto err_no_lock;
|
2019-12-17 09:58:50 +00:00
|
|
|
|
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
|
|
|
|
2020-04-23 23:15:24 +00:00
|
|
|
ret = snd_soc_dai_compr_startup(cpu_dai, cstream);
|
|
|
|
|
if (ret < 0)
|
2020-11-18 23:50:19 +00:00
|
|
|
goto err;
|
2018-04-24 15:39:03 +00:00
|
|
|
|
2021-09-01 09:52:55 +00:00
|
|
|
ret = snd_soc_compr_components_open(cstream);
|
2018-04-24 15:39:03 +00:00
|
|
|
if (ret < 0)
|
2020-11-18 23:50:19 +00:00
|
|
|
goto err;
|
2017-10-11 01:37:45 +00:00
|
|
|
|
2020-05-25 00:57:41 +00:00
|
|
|
ret = snd_soc_link_compr_startup(cstream);
|
|
|
|
|
if (ret < 0)
|
2020-11-18 23:50:19 +00:00
|
|
|
goto err;
|
2012-08-16 11:40:41 +00:00
|
|
|
|
2020-10-30 01:01:15 +00:00
|
|
|
snd_soc_runtime_activate(rtd, stream);
|
2020-11-18 23:50:19 +00:00
|
|
|
err:
|
2019-08-13 10:45:32 +00:00
|
|
|
mutex_unlock(&rtd->card->pcm_mutex);
|
2020-11-18 23:50:19 +00:00
|
|
|
err_no_lock:
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
soc_compr_clean(cstream, 1);
|
2019-12-17 09:58:50 +00:00
|
|
|
|
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;
|
2020-03-30 01:47:37 +00:00
|
|
|
struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(fe, 0);
|
2014-01-17 17:03:56 +00:00
|
|
|
struct snd_soc_dpcm *dpcm;
|
|
|
|
|
struct snd_soc_dapm_widget_list *list;
|
2020-10-30 01:01:22 +00:00
|
|
|
int stream = cstream->direction; /* SND_COMPRESS_xxx is same as SNDRV_PCM_STREAM_xxx */
|
2018-04-24 15:39:01 +00:00
|
|
|
int ret;
|
2014-01-17 17:03:56 +00:00
|
|
|
|
|
|
|
|
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;
|
2021-03-15 00:57:52 +00:00
|
|
|
|
2018-08-03 12:30:03 +00:00
|
|
|
/* 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
|
|
|
|
2020-04-23 23:15:24 +00:00
|
|
|
ret = snd_soc_dai_compr_startup(cpu_dai, cstream);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
goto out;
|
2016-11-13 06:40:02 +00:00
|
|
|
|
2021-09-01 09:52:55 +00:00
|
|
|
ret = snd_soc_compr_components_open(cstream);
|
2018-04-24 15:39:03 +00:00
|
|
|
if (ret < 0)
|
2018-08-03 12:30:03 +00:00
|
|
|
goto open_err;
|
2017-10-11 01:37:45 +00:00
|
|
|
|
2020-05-25 00:57:41 +00:00
|
|
|
ret = snd_soc_link_compr_startup(cstream);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
goto machine_err;
|
2014-01-17 17:03:56 +00:00
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
2021-04-07 04:14:04 +00:00
|
|
|
mutex_lock_nested(&fe->card->pcm_mutex, fe->card->pcm_subclass);
|
2014-03-05 12:17:43 +00:00
|
|
|
snd_soc_runtime_activate(fe, stream);
|
2021-04-07 04:14:04 +00:00
|
|
|
mutex_unlock(&fe->card->pcm_mutex);
|
2014-01-17 17:03:56 +00:00
|
|
|
|
|
|
|
|
mutex_unlock(&fe->card->mutex);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
machine_err:
|
2021-09-01 09:52:55 +00:00
|
|
|
snd_soc_compr_components_free(cstream, 1);
|
2018-08-03 12:30:03 +00:00
|
|
|
open_err:
|
2020-11-18 23:50:04 +00:00
|
|
|
snd_soc_dai_compr_shutdown(cpu_dai, cstream, 1);
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int soc_compr_free_fe(struct snd_compr_stream *cstream)
|
|
|
|
|
{
|
|
|
|
|
struct snd_soc_pcm_runtime *fe = cstream->private_data;
|
2020-03-30 01:47:37 +00:00
|
|
|
struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(fe, 0);
|
2014-01-17 17:03:56 +00:00
|
|
|
struct snd_soc_dpcm *dpcm;
|
2020-10-30 01:01:22 +00:00
|
|
|
int stream = cstream->direction; /* SND_COMPRESS_xxx is same as SNDRV_PCM_STREAM_xxx */
|
2014-01-17 17:03:56 +00:00
|
|
|
|
|
|
|
|
mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
|
|
|
|
|
|
2021-04-07 04:14:04 +00:00
|
|
|
mutex_lock_nested(&fe->card->pcm_mutex, fe->card->pcm_subclass);
|
2014-03-05 12:17:43 +00:00
|
|
|
snd_soc_runtime_deactivate(fe, stream);
|
2021-04-07 04:14:04 +00:00
|
|
|
mutex_unlock(&fe->card->pcm_mutex);
|
2014-01-17 17:03:56 +00:00
|
|
|
|
|
|
|
|
fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
|
|
|
|
|
|
2021-03-15 00:58:32 +00:00
|
|
|
dpcm_be_dai_hw_free(fe, stream);
|
2014-01-17 17:03:56 +00:00
|
|
|
|
2021-03-09 01:08:17 +00:00
|
|
|
dpcm_be_dai_shutdown(fe, stream);
|
2014-01-17 17:03:56 +00:00
|
|
|
|
|
|
|
|
/* 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;
|
|
|
|
|
|
2020-02-21 01:25:18 +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;
|
|
|
|
|
|
2020-11-18 23:50:14 +00:00
|
|
|
snd_soc_link_compr_shutdown(cstream, 0);
|
2014-01-17 17:03:56 +00:00
|
|
|
|
2021-09-01 09:52:55 +00:00
|
|
|
snd_soc_compr_components_free(cstream, 0);
|
2017-10-11 01:37:45 +00:00
|
|
|
|
2020-11-18 23:50:04 +00:00
|
|
|
snd_soc_dai_compr_shutdown(cpu_dai, cstream, 0);
|
2016-11-13 06:40:02 +00:00
|
|
|
|
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_trigger(struct snd_compr_stream *cstream, int cmd)
|
|
|
|
|
{
|
|
|
|
|
struct snd_soc_pcm_runtime *rtd = cstream->private_data;
|
2020-03-30 01:47:37 +00:00
|
|
|
struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
|
|
|
|
|
struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0);
|
2020-10-30 01:01:22 +00:00
|
|
|
int stream = cstream->direction; /* SND_COMPRESS_xxx is same as SNDRV_PCM_STREAM_xxx */
|
2019-02-05 11:18:13 +00:00
|
|
|
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
|
|
|
|
2020-11-13 04:15:33 +00:00
|
|
|
ret = snd_soc_component_compr_trigger(cstream, cmd);
|
2019-02-05 11:18:13 +00:00
|
|
|
if (ret < 0)
|
|
|
|
|
goto out;
|
|
|
|
|
|
2020-04-23 23:15:32 +00:00
|
|
|
ret = snd_soc_dai_compr_trigger(cpu_dai, cstream, cmd);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
goto out;
|
2016-11-13 06:40:02 +00:00
|
|
|
|
2013-02-06 15:44:07 +00:00
|
|
|
switch (cmd) {
|
|
|
|
|
case SNDRV_PCM_TRIGGER_START:
|
2020-10-30 01:01:15 +00:00
|
|
|
snd_soc_dai_digital_mute(codec_dai, 0, stream);
|
2013-02-06 15:44:07 +00:00
|
|
|
break;
|
|
|
|
|
case SNDRV_PCM_TRIGGER_STOP:
|
2020-10-30 01:01:15 +00:00
|
|
|
snd_soc_dai_digital_mute(codec_dai, 1, stream);
|
2013-02-06 15:44:07 +00:00
|
|
|
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;
|
2020-03-30 01:47:37 +00:00
|
|
|
struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(fe, 0);
|
2020-10-30 01:01:22 +00:00
|
|
|
int stream = cstream->direction; /* SND_COMPRESS_xxx is same as SNDRV_PCM_STREAM_xxx */
|
|
|
|
|
int ret;
|
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)
|
2020-11-13 04:15:33 +00:00
|
|
|
return snd_soc_component_compr_trigger(cstream, cmd);
|
2014-01-17 17:03:56 +00:00
|
|
|
|
|
|
|
|
mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
|
|
|
|
|
|
2020-04-23 23:15:32 +00:00
|
|
|
ret = snd_soc_dai_compr_trigger(cpu_dai, cstream, cmd);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
goto out;
|
2016-11-13 06:40:02 +00:00
|
|
|
|
2020-11-13 04:15:33 +00:00
|
|
|
ret = snd_soc_component_compr_trigger(cstream, cmd);
|
2019-02-05 11:18:13 +00:00
|
|
|
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_set_params(struct snd_compr_stream *cstream,
|
|
|
|
|
struct snd_compr_params *params)
|
|
|
|
|
{
|
|
|
|
|
struct snd_soc_pcm_runtime *rtd = cstream->private_data;
|
2020-03-30 01:47:37 +00:00
|
|
|
struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0);
|
2020-10-30 01:01:22 +00:00
|
|
|
int stream = cstream->direction; /* SND_COMPRESS_xxx is same as SNDRV_PCM_STREAM_xxx */
|
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
|
|
|
*/
|
2020-04-23 23:15:36 +00:00
|
|
|
ret = snd_soc_dai_compr_set_params(cpu_dai, cstream, params);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
goto err;
|
2016-11-13 06:40:02 +00:00
|
|
|
|
2020-11-13 04:15:49 +00:00
|
|
|
ret = snd_soc_component_compr_set_params(cstream, params);
|
2019-02-05 11:18:13 +00:00
|
|
|
if (ret < 0)
|
|
|
|
|
goto err;
|
2017-10-11 01:37:45 +00:00
|
|
|
|
2020-05-25 00:57:50 +00:00
|
|
|
ret = snd_soc_link_compr_set_params(cstream);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
goto err;
|
2012-08-16 11:40:41 +00:00
|
|
|
|
2020-10-30 01:01:22 +00:00
|
|
|
snd_soc_dapm_stream_event(rtd, stream, 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;
|
2020-03-30 01:47:37 +00:00
|
|
|
struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(fe, 0);
|
2020-10-30 01:01:22 +00:00
|
|
|
int stream = cstream->direction; /* SND_COMPRESS_xxx is same as SNDRV_PCM_STREAM_xxx */
|
|
|
|
|
int ret;
|
2014-01-17 17:03:56 +00:00
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
2020-04-23 23:15:36 +00:00
|
|
|
ret = snd_soc_dai_compr_set_params(cpu_dai, cstream, params);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
goto out;
|
2016-11-13 06:40:02 +00:00
|
|
|
|
2020-11-13 04:15:49 +00:00
|
|
|
ret = snd_soc_component_compr_set_params(cstream, params);
|
2019-02-05 11:18:13 +00:00
|
|
|
if (ret < 0)
|
|
|
|
|
goto out;
|
2017-10-11 01:37:45 +00:00
|
|
|
|
2020-05-25 00:57:50 +00:00
|
|
|
ret = snd_soc_link_compr_set_params(cstream);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
goto out;
|
2014-01-17 17:03:56 +00:00
|
|
|
|
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;
|
2020-03-30 01:47:37 +00:00
|
|
|
struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0);
|
2020-11-13 04:15:56 +00:00
|
|
|
int 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
|
|
|
|
2020-04-23 23:15:40 +00:00
|
|
|
ret = snd_soc_dai_compr_get_params(cpu_dai, cstream, params);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
goto err;
|
2016-11-13 06:40:02 +00:00
|
|
|
|
2020-11-13 04:15:56 +00:00
|
|
|
ret = snd_soc_component_compr_get_params(cstream, params);
|
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_ack(struct snd_compr_stream *cstream, size_t bytes)
|
|
|
|
|
{
|
|
|
|
|
struct snd_soc_pcm_runtime *rtd = cstream->private_data;
|
2020-03-30 01:47:37 +00:00
|
|
|
struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0);
|
2020-11-13 04:16:17 +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
|
|
|
|
2020-04-23 23:15:45 +00:00
|
|
|
ret = snd_soc_dai_compr_ack(cpu_dai, cstream, bytes);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
goto err;
|
2016-11-13 06:40:02 +00:00
|
|
|
|
2020-11-13 04:16:17 +00:00
|
|
|
ret = snd_soc_component_compr_ack(cstream, bytes);
|
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;
|
2020-11-13 04:16:24 +00:00
|
|
|
int ret;
|
2020-03-30 01:47:37 +00:00
|
|
|
struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 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
|
|
|
|
2020-04-23 23:15:49 +00:00
|
|
|
ret = snd_soc_dai_compr_pointer(cpu_dai, cstream, tstamp);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
goto out;
|
2016-11-13 06:40:02 +00:00
|
|
|
|
2020-11-13 04:16:24 +00:00
|
|
|
ret = snd_soc_component_compr_pointer(cstream, tstamp);
|
2020-04-23 23:15:49 +00:00
|
|
|
out:
|
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-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;
|
2020-03-30 01:47:37 +00:00
|
|
|
struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0);
|
2020-11-13 04:16:36 +00:00
|
|
|
int ret;
|
2013-03-26 15:52:28 +00:00
|
|
|
|
2020-04-23 23:15:54 +00:00
|
|
|
ret = snd_soc_dai_compr_set_metadata(cpu_dai, cstream, metadata);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
return ret;
|
2016-11-13 06:40:02 +00:00
|
|
|
|
2020-11-13 04:16:36 +00:00
|
|
|
return snd_soc_component_compr_set_metadata(cstream, metadata);
|
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;
|
2020-03-30 01:47:37 +00:00
|
|
|
struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0);
|
2020-11-13 04:16:41 +00:00
|
|
|
int ret;
|
2013-03-26 15:52:28 +00:00
|
|
|
|
2020-04-23 23:15:59 +00:00
|
|
|
ret = snd_soc_dai_compr_get_metadata(cpu_dai, cstream, metadata);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
return ret;
|
2016-11-13 06:40:02 +00:00
|
|
|
|
2020-11-13 04:16:41 +00:00
|
|
|
return snd_soc_component_compr_get_metadata(cstream, metadata);
|
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,
|
2020-11-13 04:16:03 +00:00
|
|
|
.get_caps = snd_soc_component_compr_get_caps,
|
2020-11-13 04:16:11 +00:00
|
|
|
.get_codec_caps = snd_soc_component_compr_get_codec_caps,
|
2012-08-16 11:40:41 +00:00
|
|
|
};
|
|
|
|
|
|
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,
|
2020-11-13 04:16:03 +00:00
|
|
|
.get_caps = snd_soc_component_compr_get_caps,
|
2020-11-13 04:16:11 +00:00
|
|
|
.get_codec_caps = snd_soc_component_compr_get_codec_caps,
|
2014-01-17 17:03:56 +00:00
|
|
|
};
|
|
|
|
|
|
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;
|
2020-03-30 01:47:37 +00:00
|
|
|
struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
|
|
|
|
|
struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0);
|
2012-08-16 11:40:41 +00:00
|
|
|
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
|
|
|
|
2020-10-30 01:01:22 +00:00
|
|
|
/*
|
|
|
|
|
* make sure these are same value,
|
|
|
|
|
* and then use these as equally
|
|
|
|
|
*/
|
|
|
|
|
BUILD_BUG_ON((int)SNDRV_PCM_STREAM_PLAYBACK != (int)SND_COMPRESS_PLAYBACK);
|
|
|
|
|
BUILD_BUG_ON((int)SNDRV_PCM_STREAM_CAPTURE != (int)SND_COMPRESS_CAPTURE);
|
|
|
|
|
|
2020-02-25 13:39:16 +00:00
|
|
|
if (rtd->num_cpus > 1 ||
|
|
|
|
|
rtd->num_codecs > 1) {
|
2018-01-26 13:08:45 +00:00
|
|
|
dev_err(rtd->card->dev,
|
2020-02-25 13:39:16 +00:00
|
|
|
"Compress ASoC: Multi CPU/Codec 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-compress: add snd_compress_ops
Current snd_soc_component_driver has compr_ops, and each driver can
have callback via it. But, it is mainly created for ALSA, thus, it
doesn't have "component" as parameter.
Thus, each callback can't know it is called for which component.
Each callback currently is getting "component" by using
snd_soc_rtdcom_lookup() with driver name.
--- ALSA SoC ---
...
if (component->driver->compr_ops &&
component->driver->compr_ops->open)
=> return component->driver->compr_ops->open(stream);
...
--- driver ---
static int xxx_open(struct snd_compr_stream *stream)
{
struct snd_soc_pcm_runtime *rtd = stream->private_data;
=> struct snd_soc_component *component = snd_soc_rtdcom_lookup(..);
...
}
It works today, but, will not work in the future if we support multi
CPU/Codec/Platform, because 1 rtd might have multiple same driver
name component.
To solve this issue, each callback need to be called with component.
We already have many component driver callbacks.
This patch adds new snd_compress_ops, and call it with "component".
--- ALSA SoC ---
...
if (component->driver->compress_ops->open)
=> return component->driver->compress_ops->open(
component, substream);
~~~~~~~~~
...
--- driver ---
static int xxx_open(struct snd_soc_component *component,
struct snd_compr_stream *stream)
{
=> /* it don't need to use snd_soc_rtdcom_lookup() */
...
}
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Tested-by: Charles Keepax <ckeepax@opensource.cirrus.com>
Reviewed-by: Charles Keepax <ckeepax@opensource.cirrus.com>
Reviewed-by: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Link: https://lore.kernel.org/r/87v9luvdmh.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-04-20 07:07:50 +00:00
|
|
|
for_each_rtd_components(rtd, i, component) {
|
|
|
|
|
if (!component->driver->compress_ops ||
|
|
|
|
|
!component->driver->compress_ops->copy)
|
|
|
|
|
continue;
|
|
|
|
|
|
2020-11-13 04:16:30 +00:00
|
|
|
compr->ops->copy = snd_soc_component_compr_copy;
|
ASoC: soc-compress: add snd_compress_ops
Current snd_soc_component_driver has compr_ops, and each driver can
have callback via it. But, it is mainly created for ALSA, thus, it
doesn't have "component" as parameter.
Thus, each callback can't know it is called for which component.
Each callback currently is getting "component" by using
snd_soc_rtdcom_lookup() with driver name.
--- ALSA SoC ---
...
if (component->driver->compr_ops &&
component->driver->compr_ops->open)
=> return component->driver->compr_ops->open(stream);
...
--- driver ---
static int xxx_open(struct snd_compr_stream *stream)
{
struct snd_soc_pcm_runtime *rtd = stream->private_data;
=> struct snd_soc_component *component = snd_soc_rtdcom_lookup(..);
...
}
It works today, but, will not work in the future if we support multi
CPU/Codec/Platform, because 1 rtd might have multiple same driver
name component.
To solve this issue, each callback need to be called with component.
We already have many component driver callbacks.
This patch adds new snd_compress_ops, and call it with "component".
--- ALSA SoC ---
...
if (component->driver->compress_ops->open)
=> return component->driver->compress_ops->open(
component, substream);
~~~~~~~~~
...
--- driver ---
static int xxx_open(struct snd_soc_component *component,
struct snd_compr_stream *stream)
{
=> /* it don't need to use snd_soc_rtdcom_lookup() */
...
}
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Tested-by: Charles Keepax <ckeepax@opensource.cirrus.com>
Reviewed-by: Charles Keepax <ckeepax@opensource.cirrus.com>
Reviewed-by: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Link: https://lore.kernel.org/r/87v9luvdmh.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>
2020-04-20 07:07:50 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
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) {
|
2020-03-30 01:47:37 +00:00
|
|
|
component = asoc_rtd_to_codec(rtd, 0)->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 */
|
2020-01-10 02:36:17 +00:00
|
|
|
rtd->close_delayed_work_func = snd_soc_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;
|
|
|
|
|
|
2020-06-12 20:40:50 +00:00
|
|
|
dev_dbg(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);
|