2018-07-02 09:24:57 +03: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 15:40:41 +04: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 21:03:56 +04:00
# include <sound/soc-dpcm.h>
2019-12-17 12:58:50 +03:00
# include <linux/pm_runtime.h>
2012-08-16 15:40:41 +04:00
2018-04-24 18:39:03 +03:00
static int soc_compr_components_open ( struct snd_compr_stream * cstream ,
struct snd_soc_component * * last )
2012-08-16 15:40:41 +04:00
{
struct snd_soc_pcm_runtime * rtd = cstream - > private_data ;
2017-10-11 04:37:45 +03: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 05:35:21 +03:00
int i , ret ;
2012-08-16 15:40:41 +04: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 05:35:21 +03:00
for_each_rtd_components ( rtd , i , component ) {
2017-10-11 04:37:45 +03:00
if ( ! component - > driver - > compr_ops | |
! component - > driver - > compr_ops - > open )
continue ;
2018-04-24 18:39:01 +03:00
ret = component - > driver - > compr_ops - > open ( cstream ) ;
if ( ret < 0 ) {
2018-01-26 16:08:45 +03:00
dev_err ( component - > dev ,
" Compress ASoC: can't open platform %s: %d \n " ,
2018-04-24 18:39:01 +03:00
component - > name , ret ) ;
2018-04-24 18:39:03 +03: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 05:35:21 +03:00
int i ;
2018-04-24 18:39:03 +03: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 05:35:21 +03:00
for_each_rtd_components ( rtd , i , component ) {
2018-04-24 18:39:03 +03: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 12:58:50 +03:00
struct snd_soc_component * component , * save = NULL ;
2018-04-24 18:39:03 +03: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 05:35:21 +03:00
int ret , i ;
2018-04-24 18:39:03 +03: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 05:35:21 +03:00
for_each_rtd_components ( rtd , i , component ) {
2019-12-17 12:58:50 +03: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 13:45:32 +03:00
mutex_lock_nested ( & rtd - > card - > pcm_mutex , rtd - > card - > pcm_subclass ) ;
2018-04-24 18:39:03 +03: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 04:37:45 +03:00
}
}
2018-04-24 18:39:03 +03:00
ret = soc_compr_components_open ( cstream , & component ) ;
if ( ret < 0 )
goto machine_err ;
2017-10-11 04:37:45 +03:00
2012-08-16 15:40:41 +04: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 16:08:45 +03:00
dev_err ( rtd - > dev ,
" Compress ASoC: %s startup failed: %d \n " ,
rtd - > dai_link - > name , ret ) ;
2012-08-16 15:40:41 +04:00
goto machine_err ;
}
}
2014-03-05 16:17:43 +04:00
snd_soc_runtime_activate ( rtd , cstream - > direction ) ;
2012-08-16 15:40:41 +04:00
2019-08-13 13:45:32 +03:00
mutex_unlock ( & rtd - > card - > pcm_mutex ) ;
2013-01-24 13:44:29 +04:00
2012-08-16 15:40:41 +04:00
return 0 ;
machine_err :
2018-04-24 18:39:03 +03:00
soc_compr_components_free ( cstream , component ) ;
2017-10-11 04:37:45 +03:00
2016-11-13 09:40:02 +03:00
if ( cpu_dai - > driver - > cops & & cpu_dai - > driver - > cops - > shutdown )
cpu_dai - > driver - > cops - > shutdown ( cstream , cpu_dai ) ;
2012-08-16 15:40:41 +04:00
out :
2019-08-13 13:45:32 +03:00
mutex_unlock ( & rtd - > card - > pcm_mutex ) ;
2019-12-17 12:58:50 +03: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 05:35:21 +03:00
for_each_rtd_components ( rtd , i , component ) {
2019-12-17 12:58:50 +03:00
if ( component = = save )
break ;
pm_runtime_mark_last_busy ( component - > dev ) ;
pm_runtime_put_autosuspend ( component - > dev ) ;
}
2012-08-16 15:40:41 +04:00
return ret ;
}
2014-01-17 21:03:56 +04:00
static int soc_compr_open_fe ( struct snd_compr_stream * cstream )
{
struct snd_soc_pcm_runtime * fe = cstream - > private_data ;
2017-06-17 03:33:40 +03:00
struct snd_pcm_substream * fe_substream =
fe - > pcm - > streams [ cstream - > direction ] . substream ;
2017-10-11 04:37:45 +03:00
struct snd_soc_component * component ;
2016-11-13 09:40:02 +03:00
struct snd_soc_dai * cpu_dai = fe - > cpu_dai ;
2014-01-17 21:03:56 +04:00
struct snd_soc_dpcm * dpcm ;
struct snd_soc_dapm_widget_list * list ;
int stream ;
2018-04-24 18:39:01 +03:00
int ret ;
2014-01-17 21:03:56 +04: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 15:30:03 +03: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 04:31:09 +03:00
for_each_dpcm_be ( fe , stream , dpcm )
2018-08-03 15:30:03 +03:00
dpcm - > state = SND_SOC_DPCM_LINK_STATE_FREE ;
dpcm_be_disconnect ( fe , stream ) ;
fe - > dpcm [ stream ] . runtime = NULL ;
goto out ;
}
2014-01-17 21:03:56 +04:00
2016-11-13 09:40:02 +03: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 16:08:45 +03:00
dev_err ( cpu_dai - > dev ,
" Compress ASoC: can't open interface %s: %d \n " ,
2016-11-13 09:40:02 +03:00
cpu_dai - > name , ret ) ;
goto out ;
}
}
2018-04-24 18:39:03 +03:00
ret = soc_compr_components_open ( cstream , & component ) ;
if ( ret < 0 )
2018-08-03 15:30:03 +03:00
goto open_err ;
2017-10-11 04:37:45 +03:00
2014-01-17 21:03:56 +04: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 16:08:45 +03:00
pr_err ( " Compress ASoC: %s startup failed: %d \n " ,
fe - > dai_link - > name , ret ) ;
2014-01-17 21:03:56 +04: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 16:17:43 +04:00
snd_soc_runtime_activate ( fe , stream ) ;
2014-01-17 21:03:56 +04:00
mutex_unlock ( & fe - > card - > mutex ) ;
return 0 ;
machine_err :
2018-04-24 18:39:03 +03:00
soc_compr_components_free ( cstream , component ) ;
2018-08-03 15:30:03 +03:00
open_err :
2016-11-13 09:40:02 +03:00
if ( cpu_dai - > driver - > cops & & cpu_dai - > driver - > cops - > shutdown )
cpu_dai - > driver - > cops - > shutdown ( cstream , cpu_dai ) ;
2014-01-17 21:03:56 +04:00
out :
2018-08-03 15:30:03 +03:00
dpcm_path_put ( & list ) ;
be_err :
2014-01-17 21:03:56 +04:00
fe - > dpcm [ stream ] . runtime_update = SND_SOC_DPCM_UPDATE_NO ;
mutex_unlock ( & fe - > card - > mutex ) ;
return ret ;
}
2012-08-16 15:40:41 +04:00
static int soc_compr_free ( struct snd_compr_stream * cstream )
{
struct snd_soc_pcm_runtime * rtd = cstream - > private_data ;
2019-12-17 12:58:50 +03:00
struct snd_soc_component * component ;
2012-08-16 15:40:41 +04: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 05:35:21 +03:00
int stream , i ;
2012-08-16 15:40:41 +04:00
2019-08-13 13:45:32 +03:00
mutex_lock_nested ( & rtd - > card - > pcm_mutex , rtd - > card - > pcm_subclass ) ;
2013-01-24 13:44:29 +04:00
2014-03-05 16:17:43 +04:00
if ( cstream - > direction = = SND_COMPRESS_PLAYBACK )
stream = SNDRV_PCM_STREAM_PLAYBACK ;
else
stream = SNDRV_PCM_STREAM_CAPTURE ;
2012-08-16 15:40:41 +04:00
2014-03-05 16:17:43 +04:00
snd_soc_runtime_deactivate ( rtd , stream ) ;
2013-02-06 19:44:07 +04:00
2014-03-05 16:17:43 +04:00
snd_soc_dai_digital_mute ( codec_dai , 1 , cstream - > direction ) ;
2012-08-16 15:40:41 +04: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 18:39:03 +03:00
soc_compr_components_free ( cstream , NULL ) ;
2017-10-11 04:37:45 +03:00
2016-11-13 09:40:02 +03:00
if ( cpu_dai - > driver - > cops & & cpu_dai - > driver - > cops - > shutdown )
cpu_dai - > driver - > cops - > shutdown ( cstream , cpu_dai ) ;
2020-01-10 05:36:23 +03:00
snd_soc_dapm_stream_stop ( rtd , stream ) ;
2012-08-16 15:40:41 +04:00
2019-08-13 13:45:32 +03:00
mutex_unlock ( & rtd - > card - > pcm_mutex ) ;
2019-12-17 12:58:50 +03: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 05:35:21 +03:00
for_each_rtd_components ( rtd , i , component ) {
2019-12-17 12:58:50 +03:00
pm_runtime_mark_last_busy ( component - > dev ) ;
pm_runtime_put_autosuspend ( component - > dev ) ;
}
2012-08-16 15:40:41 +04:00
return 0 ;
}
2014-01-17 21:03:56 +04:00
static int soc_compr_free_fe ( struct snd_compr_stream * cstream )
{
struct snd_soc_pcm_runtime * fe = cstream - > private_data ;
2016-11-13 09:40:02 +03:00
struct snd_soc_dai * cpu_dai = fe - > cpu_dai ;
2014-01-17 21:03:56 +04:00
struct snd_soc_dpcm * dpcm ;
int stream , ret ;
mutex_lock_nested ( & fe - > card - > mutex , SND_SOC_CARD_CLASS_RUNTIME ) ;
2014-03-05 16:17:43 +04:00
if ( cstream - > direction = = SND_COMPRESS_PLAYBACK )
2014-01-17 21:03:56 +04:00
stream = SNDRV_PCM_STREAM_PLAYBACK ;
2014-03-05 16:17:43 +04:00
else
2014-01-17 21:03:56 +04:00
stream = SNDRV_PCM_STREAM_CAPTURE ;
2014-03-05 16:17:43 +04:00
snd_soc_runtime_deactivate ( fe , stream ) ;
2014-01-17 21:03:56 +04: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 16:08:45 +03:00
dev_err ( fe - > dev , " Compressed ASoC: hw_free failed: %d \n " , ret ) ;
2014-01-17 21:03:56 +04:00
ret = dpcm_be_dai_shutdown ( fe , stream ) ;
/* mark FE's links ready to prune */
2018-09-18 04:31:09 +03:00
for_each_dpcm_be ( fe , stream , dpcm )
2014-01-17 21:03:56 +04:00
dpcm - > state = SND_SOC_DPCM_LINK_STATE_FREE ;
2020-02-21 04:25:18 +03:00
dpcm_dapm_stream_event ( fe , stream , SND_SOC_DAPM_STREAM_STOP ) ;
2014-01-17 21:03:56 +04: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 18:39:03 +03:00
soc_compr_components_free ( cstream , NULL ) ;
2017-10-11 04:37:45 +03:00
2016-11-13 09:40:02 +03:00
if ( cpu_dai - > driver - > cops & & cpu_dai - > driver - > cops - > shutdown )
cpu_dai - > driver - > cops - > shutdown ( cstream , cpu_dai ) ;
2014-01-17 21:03:56 +04:00
mutex_unlock ( & fe - > card - > mutex ) ;
return 0 ;
}
2019-02-05 14:18:13 +03:00
static int soc_compr_components_trigger ( struct snd_compr_stream * cstream ,
int cmd )
2012-08-16 15:40:41 +04:00
{
struct snd_soc_pcm_runtime * rtd = cstream - > private_data ;
2017-10-11 04:37:45 +03: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 05:35:21 +03:00
int i , ret ;
2013-01-24 13:44:29 +04: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 05:35:21 +03:00
for_each_rtd_components ( rtd , i , component ) {
2017-10-11 04:37:45 +03:00
if ( ! component - > driver - > compr_ops | |
! component - > driver - > compr_ops - > trigger )
continue ;
2019-02-05 14:18:12 +03:00
ret = component - > driver - > compr_ops - > trigger ( cstream , cmd ) ;
if ( ret < 0 )
2019-02-05 14:18:13 +03:00
return ret ;
2017-10-11 04:37:45 +03:00
}
2019-02-05 14:18:13 +03: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 13:45:32 +03:00
mutex_lock_nested ( & rtd - > card - > pcm_mutex , rtd - > card - > pcm_subclass ) ;
2019-02-05 14:18:13 +03:00
ret = soc_compr_components_trigger ( cstream , cmd ) ;
if ( ret < 0 )
goto out ;
2016-11-13 09:40:02 +03:00
if ( cpu_dai - > driver - > cops & & cpu_dai - > driver - > cops - > trigger )
cpu_dai - > driver - > cops - > trigger ( cstream , cmd , cpu_dai ) ;
2013-02-06 19:44:07 +04: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 17:52:42 +04:00
}
2012-08-16 15:40:41 +04:00
2013-01-24 13:44:29 +04:00
out :
2019-08-13 13:45:32 +03:00
mutex_unlock ( & rtd - > card - > pcm_mutex ) ;
2012-08-16 15:40:41 +04:00
return ret ;
}
2014-01-17 21:03:56 +04: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 09:40:02 +03:00
struct snd_soc_dai * cpu_dai = fe - > cpu_dai ;
2019-02-05 14:18:12 +03:00
int ret , stream ;
2014-01-17 21:03:56 +04:00
if ( cmd = = SND_COMPR_TRIGGER_PARTIAL_DRAIN | |
2019-02-05 14:18:13 +03:00
cmd = = SND_COMPR_TRIGGER_DRAIN )
return soc_compr_components_trigger ( cstream , cmd ) ;
2014-01-17 21:03:56 +04: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 09:40:02 +03: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 14:18:13 +03:00
ret = soc_compr_components_trigger ( cstream , cmd ) ;
if ( ret < 0 )
goto out ;
2017-10-11 04:37:45 +03:00
2014-01-17 21:03:56 +04: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 14:18:13 +03:00
static int soc_compr_components_set_params ( struct snd_compr_stream * cstream ,
struct snd_compr_params * params )
2012-08-16 15:40:41 +04:00
{
struct snd_soc_pcm_runtime * rtd = cstream - > private_data ;
2017-10-11 04:37:45 +03: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 05:35:21 +03:00
int i , ret ;
2019-02-05 14:18:13 +03: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 05:35:21 +03:00
for_each_rtd_components ( rtd , i , component ) {
2019-02-05 14:18:13 +03: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 09:40:02 +03:00
struct snd_soc_dai * cpu_dai = rtd - > cpu_dai ;
2019-02-05 14:18:12 +03:00
int ret ;
2012-08-16 15:40:41 +04:00
2019-08-13 13:45:32 +03:00
mutex_lock_nested ( & rtd - > card - > pcm_mutex , rtd - > card - > pcm_subclass ) ;
2013-01-24 13:44:29 +04:00
2018-04-24 18:39:02 +03: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 15:40:41 +04:00
*/
2016-11-13 09:40:02 +03: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 14:18:13 +03:00
ret = soc_compr_components_set_params ( cstream , params ) ;
if ( ret < 0 )
goto err ;
2017-10-11 04:37:45 +03:00
2012-08-16 15:40:41 +04: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 20:39:01 +04:00
goto err ;
2012-08-16 15:40:41 +04:00
}
2013-05-20 11:33:54 +04:00
if ( cstream - > direction = = SND_COMPRESS_PLAYBACK )
snd_soc_dapm_stream_event ( rtd , SNDRV_PCM_STREAM_PLAYBACK ,
2018-04-26 19:30:07 +03:00
SND_SOC_DAPM_STREAM_START ) ;
2013-05-20 11:33:54 +04:00
else
snd_soc_dapm_stream_event ( rtd , SNDRV_PCM_STREAM_CAPTURE ,
2018-04-26 19:30:07 +03:00
SND_SOC_DAPM_STREAM_START ) ;
2012-08-16 15:40:41 +04:00
2013-03-27 20:39:01 +04:00
/* cancel any delayed stream shutdown that is pending */
rtd - > pop_wait = 0 ;
2019-08-13 13:45:32 +03:00
mutex_unlock ( & rtd - > card - > pcm_mutex ) ;
2013-03-27 20:39:01 +04:00
cancel_delayed_work_sync ( & rtd - > delayed_work ) ;
2019-02-05 14:18:12 +03:00
return 0 ;
2013-03-27 20:39:01 +04:00
err :
2019-08-13 13:45:32 +03:00
mutex_unlock ( & rtd - > card - > pcm_mutex ) ;
2012-08-16 15:40:41 +04:00
return ret ;
}
2014-01-17 21:03:56 +04:00
static int soc_compr_set_params_fe ( struct snd_compr_stream * cstream ,
2018-04-26 19:30:07 +03:00
struct snd_compr_params * params )
2014-01-17 21:03:56 +04:00
{
struct snd_soc_pcm_runtime * fe = cstream - > private_data ;
2017-06-17 03:33:40 +03:00
struct snd_pcm_substream * fe_substream =
fe - > pcm - > streams [ cstream - > direction ] . substream ;
2016-11-13 09:40:02 +03:00
struct snd_soc_dai * cpu_dai = fe - > cpu_dai ;
2019-02-05 14:18:12 +03:00
int ret , stream ;
2014-01-17 21:03:56 +04: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 15:30:03 +03: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 09:40:02 +03: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 14:18:13 +03:00
ret = soc_compr_components_set_params ( cstream , params ) ;
if ( ret < 0 )
goto out ;
2017-10-11 04:37:45 +03:00
2014-01-17 21:03:56 +04: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 11:07:35 +04:00
dpcm_dapm_stream_event ( fe , stream , SND_SOC_DAPM_STREAM_START ) ;
2014-01-17 21:03:56 +04: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 15:40:41 +04:00
static int soc_compr_get_params ( struct snd_compr_stream * cstream ,
2018-04-26 19:30:07 +03:00
struct snd_codec * params )
2012-08-16 15:40:41 +04:00
{
struct snd_soc_pcm_runtime * rtd = cstream - > private_data ;
2017-10-11 04:37:45 +03:00
struct snd_soc_component * component ;
2016-11-13 09:40:02 +03: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 05:35:21 +03:00
int i , ret = 0 ;
2012-08-16 15:40:41 +04:00
2019-08-13 13:45:32 +03:00
mutex_lock_nested ( & rtd - > card - > pcm_mutex , rtd - > card - > pcm_subclass ) ;
2013-01-24 13:44:29 +04:00
2016-11-13 09:40:02 +03: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 05:35:21 +03:00
for_each_rtd_components ( rtd , i , component ) {
2017-10-11 04:37:45 +03:00
if ( ! component - > driver - > compr_ops | |
! component - > driver - > compr_ops - > get_params )
continue ;
2019-02-05 14:18:12 +03:00
ret = component - > driver - > compr_ops - > get_params ( cstream , params ) ;
break ;
2017-10-11 04:37:45 +03:00
}
2012-08-16 15:40:41 +04:00
2016-11-13 09:40:02 +03:00
err :
2019-08-13 13:45:32 +03:00
mutex_unlock ( & rtd - > card - > pcm_mutex ) ;
2012-08-16 15:40:41 +04:00
return ret ;
}
static int soc_compr_get_caps ( struct snd_compr_stream * cstream ,
2018-04-26 19:30:07 +03:00
struct snd_compr_caps * caps )
2012-08-16 15:40:41 +04:00
{
struct snd_soc_pcm_runtime * rtd = cstream - > private_data ;
2017-10-11 04:37:45 +03: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 05:35:21 +03:00
int i , ret = 0 ;
2012-08-16 15:40:41 +04:00
2019-08-13 13:45:32 +03:00
mutex_lock_nested ( & rtd - > card - > pcm_mutex , rtd - > card - > pcm_subclass ) ;
2013-01-24 13:44:29 +04: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 05:35:21 +03:00
for_each_rtd_components ( rtd , i , component ) {
2017-10-11 04:37:45 +03:00
if ( ! component - > driver - > compr_ops | |
! component - > driver - > compr_ops - > get_caps )
continue ;
2019-02-05 14:18:12 +03:00
ret = component - > driver - > compr_ops - > get_caps ( cstream , caps ) ;
break ;
2017-10-11 04:37:45 +03:00
}
2019-08-13 13:45:32 +03:00
mutex_unlock ( & rtd - > card - > pcm_mutex ) ;
2012-08-16 15:40:41 +04:00
return ret ;
}
static int soc_compr_get_codec_caps ( struct snd_compr_stream * cstream ,
2018-04-26 19:30:07 +03:00
struct snd_compr_codec_caps * codec )
2012-08-16 15:40:41 +04:00
{
struct snd_soc_pcm_runtime * rtd = cstream - > private_data ;
2017-10-11 04:37:45 +03: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 05:35:21 +03:00
int i , ret = 0 ;
2012-08-16 15:40:41 +04:00
2019-08-13 13:45:32 +03:00
mutex_lock_nested ( & rtd - > card - > pcm_mutex , rtd - > card - > pcm_subclass ) ;
2013-01-24 13:44:29 +04: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 05:35:21 +03:00
for_each_rtd_components ( rtd , i , component ) {
2017-10-11 04:37:45 +03:00
if ( ! component - > driver - > compr_ops | |
! component - > driver - > compr_ops - > get_codec_caps )
continue ;
2019-02-05 14:18:12 +03:00
ret = component - > driver - > compr_ops - > get_codec_caps ( cstream ,
codec ) ;
break ;
2017-10-11 04:37:45 +03:00
}
2019-08-13 13:45:32 +03:00
mutex_unlock ( & rtd - > card - > pcm_mutex ) ;
2012-08-16 15:40:41 +04: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 04:37:45 +03:00
struct snd_soc_component * component ;
2016-11-13 09:40:02 +03: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 05:35:21 +03:00
int i , ret = 0 ;
2012-08-16 15:40:41 +04:00
2019-08-13 13:45:32 +03:00
mutex_lock_nested ( & rtd - > card - > pcm_mutex , rtd - > card - > pcm_subclass ) ;
2013-01-24 13:44:29 +04:00
2016-11-13 09:40:02 +03: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 05:35:21 +03:00
for_each_rtd_components ( rtd , i , component ) {
2017-10-11 04:37:45 +03:00
if ( ! component - > driver - > compr_ops | |
! component - > driver - > compr_ops - > ack )
continue ;
2019-02-05 14:18:12 +03:00
ret = component - > driver - > compr_ops - > ack ( cstream , bytes ) ;
if ( ret < 0 )
goto err ;
2017-10-11 04:37:45 +03:00
}
2012-08-16 15:40:41 +04:00
2016-11-13 09:40:02 +03:00
err :
2019-08-13 13:45:32 +03:00
mutex_unlock ( & rtd - > card - > pcm_mutex ) ;
2012-08-16 15:40:41 +04:00
return ret ;
}
static int soc_compr_pointer ( struct snd_compr_stream * cstream ,
2018-04-26 19:30:07 +03:00
struct snd_compr_tstamp * tstamp )
2012-08-16 15:40:41 +04:00
{
struct snd_soc_pcm_runtime * rtd = cstream - > private_data ;
2017-10-11 04:37:45 +03: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 05:35:21 +03:00
int i , ret = 0 ;
2016-11-13 09:40:02 +03:00
struct snd_soc_dai * cpu_dai = rtd - > cpu_dai ;
2012-08-16 15:40:41 +04:00
2019-08-13 13:45:32 +03:00
mutex_lock_nested ( & rtd - > card - > pcm_mutex , rtd - > card - > pcm_subclass ) ;
2013-01-24 13:44:29 +04:00
2016-11-13 09:40:02 +03: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 05:35:21 +03:00
for_each_rtd_components ( rtd , i , component ) {
2017-10-11 04:37:45 +03:00
if ( ! component - > driver - > compr_ops | |
! component - > driver - > compr_ops - > pointer )
continue ;
2012-08-16 15:40:41 +04:00
2019-02-05 14:18:12 +03:00
ret = component - > driver - > compr_ops - > pointer ( cstream , tstamp ) ;
break ;
2017-10-11 04:37:45 +03:00
}
2019-08-13 13:45:32 +03:00
mutex_unlock ( & rtd - > card - > pcm_mutex ) ;
2016-06-20 11:51:32 +03:00
return ret ;
2012-08-16 15:40:41 +04:00
}
2013-02-05 14:41:47 +04:00
static int soc_compr_copy ( struct snd_compr_stream * cstream ,
2013-04-18 14:01:38 +04:00
char __user * buf , size_t count )
2013-02-05 14:41:47 +04:00
{
struct snd_soc_pcm_runtime * rtd = cstream - > private_data ;
2017-10-11 04:37:45 +03: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 05:35:21 +03:00
int i , ret = 0 ;
2013-02-05 14:41:47 +04:00
2019-08-13 13:45:32 +03:00
mutex_lock_nested ( & rtd - > card - > pcm_mutex , rtd - > card - > pcm_subclass ) ;
2013-02-05 14:41:47 +04: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 05:35:21 +03:00
for_each_rtd_components ( rtd , i , component ) {
2017-10-11 04:37:45 +03:00
if ( ! component - > driver - > compr_ops | |
! component - > driver - > compr_ops - > copy )
continue ;
2013-02-05 14:41:47 +04:00
2018-01-26 16:08:43 +03:00
ret = component - > driver - > compr_ops - > copy ( cstream , buf , count ) ;
break ;
2017-10-11 04:37:45 +03:00
}
2018-01-26 16:08:43 +03:00
2019-08-13 13:45:32 +03:00
mutex_unlock ( & rtd - > card - > pcm_mutex ) ;
2013-02-05 14:41:47 +04:00
return ret ;
}
2013-07-28 18:36:15 +04:00
static int soc_compr_set_metadata ( struct snd_compr_stream * cstream ,
2018-04-26 19:30:07 +03:00
struct snd_compr_metadata * metadata )
2013-03-26 19:52:28 +04:00
{
struct snd_soc_pcm_runtime * rtd = cstream - > private_data ;
2017-10-11 04:37:45 +03:00
struct snd_soc_component * component ;
2016-11-13 09:40:02 +03: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 05:35:21 +03:00
int i , ret ;
2013-03-26 19:52:28 +04:00
2016-11-13 09:40:02 +03: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 05:35:21 +03:00
for_each_rtd_components ( rtd , i , component ) {
2017-10-11 04:37:45 +03:00
if ( ! component - > driver - > compr_ops | |
! component - > driver - > compr_ops - > set_metadata )
continue ;
2019-02-05 14:18:12 +03:00
ret = component - > driver - > compr_ops - > set_metadata ( cstream ,
metadata ) ;
if ( ret < 0 )
return ret ;
2017-10-11 04:37:45 +03:00
}
2013-03-26 19:52:28 +04:00
2019-02-05 14:18:12 +03:00
return 0 ;
2013-03-26 19:52:28 +04:00
}
2013-07-28 18:36:15 +04:00
static int soc_compr_get_metadata ( struct snd_compr_stream * cstream ,
2018-04-26 19:30:07 +03:00
struct snd_compr_metadata * metadata )
2013-03-26 19:52:28 +04:00
{
struct snd_soc_pcm_runtime * rtd = cstream - > private_data ;
2017-10-11 04:37:45 +03:00
struct snd_soc_component * component ;
2016-11-13 09:40:02 +03: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 05:35:21 +03:00
int i , ret ;
2013-03-26 19:52:28 +04:00
2016-11-13 09:40:02 +03: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 05:35:21 +03:00
for_each_rtd_components ( rtd , i , component ) {
2017-10-11 04:37:45 +03:00
if ( ! component - > driver - > compr_ops | |
! component - > driver - > compr_ops - > get_metadata )
continue ;
2019-02-05 14:18:12 +03:00
return component - > driver - > compr_ops - > get_metadata ( cstream ,
metadata ) ;
2017-10-11 04:37:45 +03:00
}
2013-03-26 19:52:28 +04:00
2019-02-05 14:18:12 +03:00
return 0 ;
2013-03-26 19:52:28 +04:00
}
2014-01-17 21:03:56 +04:00
2012-08-16 15:40:41 +04: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 18:36:15 +04:00
. set_metadata = soc_compr_set_metadata ,
. get_metadata = soc_compr_get_metadata ,
2012-08-16 15:40:41 +04: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 21:03:56 +04: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 18:41:00 +03: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 15:40:41 +04:00
{
2017-10-11 04:37:45 +03:00
struct snd_soc_component * component ;
2012-08-16 15:40:41 +04: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 21:03:56 +04:00
struct snd_pcm * be_pcm ;
2012-08-16 15:40:41 +04:00
char new_name [ 64 ] ;
int ret = 0 , direction = 0 ;
2016-01-07 19:18:14 +03: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 05:35:21 +03:00
int i ;
2012-08-16 15:40:41 +04:00
2014-07-09 01:19:37 +04:00
if ( rtd - > num_codecs > 1 ) {
2018-01-26 16:08:45 +03:00
dev_err ( rtd - > card - > dev ,
" Compress ASoC: Multicodec not supported \n " ) ;
2014-07-09 01:19:37 +04:00
return - EINVAL ;
}
2012-08-16 15:40:41 +04:00
/* check client and interface hw capabilities */
2019-07-22 04:36:16 +03: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 19:18:14 +03:00
playback = 1 ;
2019-07-22 04:36:16 +03: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 19:18:14 +03: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 16:08:45 +03:00
dev_err ( rtd - > card - > dev ,
" Compress ASoC: Invalid direction for P %d, C %d \n " ,
playback , capture ) ;
2016-01-07 19:18:14 +03:00
return - EINVAL ;
}
2017-08-16 17:47:53 +03:00
if ( playback )
2013-04-18 14:02:38 +04:00
direction = SND_COMPRESS_PLAYBACK ;
else
2016-01-07 19:18:14 +03:00
direction = SND_COMPRESS_CAPTURE ;
2013-04-18 14:02:38 +04:00
2019-06-17 14:36:36 +03:00
compr = devm_kzalloc ( rtd - > card - > dev , sizeof ( * compr ) , GFP_KERNEL ) ;
2017-08-10 17:21:34 +03:00
if ( ! compr )
2012-08-16 15:40:41 +04:00
return - ENOMEM ;
2013-02-05 14:41:47 +04:00
compr - > ops = devm_kzalloc ( rtd - > card - > dev , sizeof ( soc_compr_ops ) ,
GFP_KERNEL ) ;
2019-06-17 14:36:36 +03:00
if ( ! compr - > ops )
return - ENOMEM ;
2014-01-17 21:03:56 +04: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 11:47:29 +03:00
rtd - > dai_link - > dpcm_playback ,
rtd - > dai_link - > dpcm_capture , & be_pcm ) ;
2014-01-17 21:03:56 +04:00
if ( ret < 0 ) {
2018-01-26 16:08:45 +03:00
dev_err ( rtd - > card - > dev ,
" Compress ASoC: can't create compressed for %s: %d \n " ,
rtd - > dai_link - > name , ret ) ;
2019-06-17 14:36:36 +03:00
return ret ;
2014-01-17 21:03:56 +04:00
}
rtd - > pcm = be_pcm ;
rtd - > fe_compr = 1 ;
2015-01-14 11:47:29 +03: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 21:03:56 +04:00
memcpy ( compr - > ops , & soc_compr_dyn_ops , sizeof ( soc_compr_dyn_ops ) ) ;
2017-08-16 17:47:53 +03:00
} else {
snprintf ( new_name , sizeof ( new_name ) , " %s %s-%d " ,
rtd - > dai_link - > stream_name , codec_dai - > name , num ) ;
2014-01-17 21:03:56 +04:00
memcpy ( compr - > ops , & soc_compr_ops , sizeof ( soc_compr_ops ) ) ;
2017-08-16 17:47:53 +03:00
}
2013-02-05 14:41:47 +04: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 05:35:21 +03:00
for_each_rtd_components ( rtd , i , component ) {
2017-10-11 04:37:45 +03:00
if ( ! component - > driver - > compr_ops | |
! component - > driver - > compr_ops - > copy )
continue ;
2013-02-05 14:41:47 +04:00
compr - > ops - > copy = soc_compr_copy ;
2018-04-26 19:30:04 +03:00
break ;
2017-10-11 04:37:45 +03:00
}
2012-08-16 15:40:41 +04:00
mutex_init ( & compr - > lock ) ;
2015-11-25 16:00:24 +03:00
ret = snd_compress_new ( rtd - > card - > snd_card , num , direction ,
new_name , compr ) ;
2012-08-16 15:40:41 +04:00
if ( ret < 0 ) {
2017-12-05 07:23:05 +03:00
component = rtd - > codec_dai - > component ;
2018-01-26 16:08:45 +03:00
dev_err ( component - > dev ,
" Compress ASoC: can't create compress for codec %s: %d \n " ,
component - > name , ret ) ;
2019-06-17 14:36:36 +03:00
return ret ;
2012-08-16 15:40:41 +04:00
}
2013-01-24 13:44:30 +04:00
/* DAPM dai link stream work */
2020-01-10 05:36:17 +03:00
rtd - > close_delayed_work_func = snd_soc_close_delayed_work ;
2013-01-24 13:44:30 +04:00
2012-08-16 15:40:41 +04:00
rtd - > compr = compr ;
compr - > private_data = rtd ;
2018-01-26 16:08:45 +03:00
dev_info ( rtd - > card - > dev , " Compress ASoC: %s <-> %s mapping ok \n " ,
codec_dai - > name , cpu_dai - > name ) ;
2013-02-05 14:41:47 +04:00
2019-06-17 14:36:36 +03:00
return 0 ;
2012-08-16 15:40:41 +04:00
}
2015-10-13 18:41:00 +03:00
EXPORT_SYMBOL_GPL ( snd_soc_new_compress ) ;
