UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge series "ASoC: soc-pcm cleanup step6" from Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>: 

Hi Mark

We are using plural form for for_each_xxx() macro.
But, for_each_rtd_codec/cpu_dai() are out of this rule.
1) - 7) are for it.
8) - 9) add new for_each_card_xxx() macros.

Kuninori Morimoto (9):
   1) ASoC: soc.h: add for_each_rtd_codecs/cpus_dai() macro
   2) ASoC: Intel: use for_each_rtd_codecs/cpus_dai() macro
   3) ASoC: mediatek: use for_each_rtd_codecs/cpus_dai() macro
   4) ASoC: meson: use for_each_rtd_codecs/cpus_dai() macro
   5) ASoC: qcom: use for_each_rtd_codecs/cpus_dai() macro
   6) ASoC: soc: use for_each_rtd_codecs/cpus_dai() macro
   7) ASoC: soc.h: remove non plural form for_each_xxx macro
   8) ASoC: soc-dapm: add for_each_card_dapms() macro
   9) ASoC: soc-dapm: add for_each_card_widgets() macro

 drivers/soundwire/qcom.c                      |   2 +-
 include/sound/soc.h                           |  28 ++--
 sound/soc/intel/boards/cml_rt1011_rt5682.c    |   2 +-
 sound/soc/intel/boards/kbl_da7219_max98927.c  |   4 +-
 sound/soc/intel/boards/kbl_rt5663_max98927.c  |   2 +-
 .../intel/boards/kbl_rt5663_rt5514_max98927.c |   2 +-
 .../mediatek/mt8173/mt8173-rt5650-rt5514.c    |   2 +-
 .../mediatek/mt8173/mt8173-rt5650-rt5676.c    |   2 +-
 sound/soc/mediatek/mt8173/mt8173-rt5650.c     |   2 +-
 .../mediatek/mt8183/mt8183-da7219-max98357.c  |   4 +-
 sound/soc/meson/axg-card.c                    |   2 +-
 sound/soc/meson/meson-card-utils.c            |   2 +-
 sound/soc/qcom/apq8016_sbc.c                  |   2 +-
 sound/soc/qcom/sdm845.c                       |   8 +-
 sound/soc/soc-core.c                          |  16 +--
 sound/soc/soc-dapm.c                          |  53 ++++----
 sound/soc/soc-pcm.c                           | 124 +++++++++---------
 sound/soc/soc-topology.c                      |   2 +-
 18 files changed, 134 insertions(+), 125 deletions(-)

--
2.17.1
This commit is contained in:
Mark Brown 2020-03-10 13:51:00 +00:00
parent a3b7343e3f 1459669263
commit c23f044427
No known key found for this signature in database
GPG Key ID: 24D68B725D5487D0
18 changed files with 134 additions and 125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
drivers/soundwire/qcom.c
View File

@ -603,7 +603,7 @@ static int qcom_swrm_startup(struct snd_pcm_substream *substream,
ctrl->sruntime[dai->id] = sruntime;
for_each_rtd_codec_dai(rtd, i, codec_dai) {
for_each_rtd_codec_dais(rtd, i, codec_dai) {
ret = snd_soc_dai_set_sdw_stream(codec_dai, sruntime,
substream->stream);
if (ret < 0 && ret != -ENOTSUPP) {

28
include/sound/soc.h
View File

@ -1117,6 +1117,14 @@ struct snd_soc_card {
#define for_each_card_components(card, component) \
list_for_each_entry(component, &(card)->component_dev_list, card_list)
#define for_each_card_dapms(card, dapm) \
list_for_each_entry(dapm, &card->dapm_list, list)
#define for_each_card_widgets(card, w)\
list_for_each_entry(w, &card->widgets, list)
#define for_each_card_widgets_safe(card, w, _w) \
list_for_each_entry_safe(w, _w, &card->widgets, list)
/* SoC machine DAI configuration, glues a codec and cpu DAI together */
struct snd_soc_pcm_runtime {
struct device *dev;
@ -1163,19 +1171,19 @@ struct snd_soc_pcm_runtime {
for ((i) = 0; \
((i) < rtd->num_components) && ((component) = rtd->components[i]);\
(i)++)
#define for_each_rtd_codec_dai(rtd, i, dai)\
for ((i) = 0; \
((i) < rtd->num_codecs) && ((dai) = rtd->codec_dais[i]); \
#define for_each_rtd_cpu_dais(rtd, i, dai) \
for ((i) = 0; \
((i) < rtd->num_cpus) && ((dai) = rtd->cpu_dais[i]); \
(i)++)
#define for_each_rtd_codec_dai_rollback(rtd, i, dai) \
#define for_each_rtd_cpu_dais_rollback(rtd, i, dai) \
for (; (--(i) >= 0) && ((dai) = rtd->cpu_dais[i]);)
#define for_each_rtd_codec_dais(rtd, i, dai) \
for ((i) = 0; \
((i) < rtd->num_codecs) && ((dai) = rtd->codec_dais[i]); \
(i)++)
#define for_each_rtd_codec_dais_rollback(rtd, i, dai) \
for (; (--(i) >= 0) && ((dai) = rtd->codec_dais[i]);)
#define for_each_rtd_cpu_dai(rtd, i, dai)\
for ((i) = 0; \
((i) < rtd->num_cpus) && ((dai) = rtd->cpu_dais[i]); \
(i)++)
#define for_each_rtd_cpu_dai_rollback(rtd, i, dai) \
for (; (--(i) >= 0) && ((dai) = rtd->cpu_dais[i]);)
void snd_soc_close_delayed_work(struct snd_soc_pcm_runtime *rtd);

2
sound/soc/intel/boards/cml_rt1011_rt5682.c
View File

@ -164,7 +164,7 @@ static int cml_rt1011_hw_params(struct snd_pcm_substream *substream,
srate = params_rate(params);
for_each_rtd_codec_dai(rtd, i, codec_dai) {
for_each_rtd_codec_dais(rtd, i, codec_dai) {
/* 100 Fs to drive 24 bit data */
ret = snd_soc_dai_set_pll(codec_dai, 0, RT1011_PLL1_S_BCLK,

4
sound/soc/intel/boards/kbl_da7219_max98927.c
View File

@ -179,7 +179,7 @@ static int kabylake_ssp0_hw_params(struct snd_pcm_substream *substream,
struct snd_soc_dai *codec_dai;
int ret, j;
for_each_rtd_codec_dai(runtime, j, codec_dai) {
for_each_rtd_codec_dais(runtime, j, codec_dai) {
if (!strcmp(codec_dai->component->name, MAX98927_DEV0_NAME)) {
ret = snd_soc_dai_set_tdm_slot(codec_dai, 0x30, 3, 8, 16);
@ -224,7 +224,7 @@ static int kabylake_ssp0_trigger(struct snd_pcm_substream *substream, int cmd)
struct snd_soc_dai *codec_dai;
int j, ret;
for_each_rtd_codec_dai(rtd, j, codec_dai) {
for_each_rtd_codec_dais(rtd, j, codec_dai) {
const char *name = codec_dai->component->name;
struct snd_soc_component *component = codec_dai->component;
struct snd_soc_dapm_context *dapm =

2
sound/soc/intel/boards/kbl_rt5663_max98927.c
View File

@ -472,7 +472,7 @@ static int kabylake_ssp0_hw_params(struct snd_pcm_substream *substream,
struct snd_soc_dai *codec_dai;
int ret = 0, j;
for_each_rtd_codec_dai(rtd, j, codec_dai) {
for_each_rtd_codec_dais(rtd, j, codec_dai) {
if (!strcmp(codec_dai->component->name, MAXIM_DEV0_NAME)) {
/*
* Use channel 4 and 5 for the first amp

2
sound/soc/intel/boards/kbl_rt5663_rt5514_max98927.c
View File

@ -399,7 +399,7 @@ static int kabylake_ssp0_hw_params(struct snd_pcm_substream *substream,
struct snd_soc_dai *codec_dai;
int ret = 0, j;
for_each_rtd_codec_dai(rtd, j, codec_dai) {
for_each_rtd_codec_dais(rtd, j, codec_dai) {
if (!strcmp(codec_dai->component->name, RT5514_DEV_NAME)) {
ret = snd_soc_dai_set_tdm_slot(codec_dai, 0xF, 0, 8, 16);
if (ret < 0) {

2
sound/soc/mediatek/mt8173/mt8173-rt5650-rt5514.c
View File

@ -47,7 +47,7 @@ static int mt8173_rt5650_rt5514_hw_params(struct snd_pcm_substream *substream,
struct snd_soc_dai *codec_dai;
int i, ret;
for_each_rtd_codec_dai(rtd, i, codec_dai) {
for_each_rtd_codec_dais(rtd, i, codec_dai) {
/* pll from mclk 12.288M */
ret = snd_soc_dai_set_pll(codec_dai, 0, 0, MCLK_FOR_CODECS,
params_rate(params) * 512);

2
sound/soc/mediatek/mt8173/mt8173-rt5650-rt5676.c
View File

@ -51,7 +51,7 @@ static int mt8173_rt5650_rt5676_hw_params(struct snd_pcm_substream *substream,
struct snd_soc_dai *codec_dai;
int i, ret;
for_each_rtd_codec_dai(rtd, i, codec_dai) {
for_each_rtd_codec_dais(rtd, i, codec_dai) {
/* pll from mclk 12.288M */
ret = snd_soc_dai_set_pll(codec_dai, 0, 0, MCLK_FOR_CODECS,
params_rate(params) * 512);

2
sound/soc/mediatek/mt8173/mt8173-rt5650.c
View File

@ -78,7 +78,7 @@ static int mt8173_rt5650_hw_params(struct snd_pcm_substream *substream,
break;
}
for_each_rtd_codec_dai(rtd, i, codec_dai) {
for_each_rtd_codec_dais(rtd, i, codec_dai) {
/* pll from mclk */
ret = snd_soc_dai_set_pll(codec_dai, 0, 0, mclk_clock,
params_rate(params) * 512);

4
sound/soc/mediatek/mt8183/mt8183-da7219-max98357.c
View File

@ -52,7 +52,7 @@ static int mt8183_da7219_i2s_hw_params(struct snd_pcm_substream *substream,
if (ret < 0)
dev_err(rtd->dev, "failed to set cpu dai sysclk\n");
for_each_rtd_codec_dai(rtd, j, codec_dai) {
for_each_rtd_codec_dais(rtd, j, codec_dai) {
if (!strcmp(codec_dai->component->name, "da7219.5-001a")) {
ret = snd_soc_dai_set_sysclk(codec_dai,
@ -85,7 +85,7 @@ static int mt8183_da7219_hw_free(struct snd_pcm_substream *substream)
struct snd_soc_dai *codec_dai;
int ret = 0, j;
for_each_rtd_codec_dai(rtd, j, codec_dai) {
for_each_rtd_codec_dais(rtd, j, codec_dai) {
if (!strcmp(codec_dai->component->name, "da7219.5-001a")) {
ret = snd_soc_dai_set_pll(codec_dai,

2
sound/soc/meson/axg-card.c
View File

@ -60,7 +60,7 @@ static int axg_card_tdm_dai_init(struct snd_soc_pcm_runtime *rtd)
struct snd_soc_dai *codec_dai;
int ret, i;
for_each_rtd_codec_dai(rtd, i, codec_dai) {
for_each_rtd_codec_dais(rtd, i, codec_dai) {
ret = snd_soc_dai_set_tdm_slot(codec_dai,
be->codec_masks[i].tx,
be->codec_masks[i].rx,

2
sound/soc/meson/meson-card-utils.c
View File

@ -23,7 +23,7 @@ int meson_card_i2s_set_sysclk(struct snd_pcm_substream *substream,
mclk = params_rate(params) * mclk_fs;
for_each_rtd_codec_dai(rtd, i, codec_dai) {
for_each_rtd_codec_dais(rtd, i, codec_dai) {
ret = snd_soc_dai_set_sysclk(codec_dai, 0, mclk,
SND_SOC_CLOCK_IN);
if (ret && ret != -ENOTSUPP)

2
sound/soc/qcom/apq8016_sbc.c
View File

@ -90,7 +90,7 @@ static int apq8016_sbc_dai_init(struct snd_soc_pcm_runtime *rtd)
pdata->jack_setup = true;
}
for_each_rtd_codec_dai(rtd, i, codec_dai) {
for_each_rtd_codec_dais(rtd, i, codec_dai) {
component = codec_dai->component;
/* Set default mclk for internal codec */

8
sound/soc/qcom/sdm845.c
View File

@ -49,7 +49,7 @@ static int sdm845_slim_snd_hw_params(struct snd_pcm_substream *substream,
u32 rx_ch_cnt = 0, tx_ch_cnt = 0;
int ret = 0, i;
for_each_rtd_codec_dai(rtd, i, codec_dai) {
for_each_rtd_codec_dais(rtd, i, codec_dai) {
ret = snd_soc_dai_get_channel_map(codec_dai,
&tx_ch_cnt, tx_ch, &rx_ch_cnt, rx_ch);
@ -126,7 +126,7 @@ static int sdm845_tdm_snd_hw_params(struct snd_pcm_substream *substream,
}
}
for_each_rtd_codec_dai(rtd, j, codec_dai) {
for_each_rtd_codec_dais(rtd, j, codec_dai) {
if (!strcmp(codec_dai->component->name_prefix, "Left")) {
ret = snd_soc_dai_set_tdm_slot(
@ -265,7 +265,7 @@ static int sdm845_dai_init(struct snd_soc_pcm_runtime *rtd)
}
break;
case SLIMBUS_0_RX...SLIMBUS_6_TX:
for_each_rtd_codec_dai(rtd, i, codec_dai) {
for_each_rtd_codec_dais(rtd, i, codec_dai) {
rval = snd_soc_dai_set_channel_map(codec_dai,
ARRAY_SIZE(tx_ch),
tx_ch,
@ -344,7 +344,7 @@ static int sdm845_snd_startup(struct snd_pcm_substream *substream)
codec_dai_fmt |= SND_SOC_DAIFMT_IB_NF | SND_SOC_DAIFMT_DSP_B;
for_each_rtd_codec_dai(rtd, j, codec_dai) {
for_each_rtd_codec_dais(rtd, j, codec_dai) {
if (!strcmp(codec_dai->component->name_prefix,
"Left")) {

16
sound/soc/soc-core.c
View File

@ -547,7 +547,7 @@ int snd_soc_suspend(struct device *dev)
if (rtd->dai_link->ignore_suspend)
continue;
for_each_rtd_codec_dai(rtd, i, dai) {
for_each_rtd_codec_dais(rtd, i, dai) {
if (dai->stream_active[playback])
snd_soc_dai_digital_mute(dai, 1, playback);
}
@ -689,7 +689,7 @@ static void soc_resume_deferred(struct work_struct *work)
if (rtd->dai_link->ignore_suspend)
continue;
for_each_rtd_codec_dai(rtd, i, dai) {
for_each_rtd_codec_dais(rtd, i, dai) {
if (dai->stream_active[playback])
snd_soc_dai_digital_mute(dai, 0, playback);
}
@ -1321,10 +1321,10 @@ static void soc_remove_link_dais(struct snd_soc_card *card)
for_each_comp_order(order) {
for_each_card_rtds(card, rtd) {
/* remove the CODEC DAI */
for_each_rtd_codec_dai(rtd, i, codec_dai)
for_each_rtd_codec_dais(rtd, i, codec_dai)
soc_remove_dai(codec_dai, order);
for_each_rtd_cpu_dai(rtd, i, cpu_dai)
for_each_rtd_cpu_dais(rtd, i, cpu_dai)
soc_remove_dai(cpu_dai, order);
}
}
@ -1344,14 +1344,14 @@ static int soc_probe_link_dais(struct snd_soc_card *card)
card->name, rtd->num, order);
/* probe the CPU DAI */
for_each_rtd_cpu_dai(rtd, i, cpu_dai) {
for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
ret = soc_probe_dai(cpu_dai, order);
if (ret)
return ret;
}
/* probe the CODEC DAI */
for_each_rtd_codec_dai(rtd, i, codec_dai) {
for_each_rtd_codec_dais(rtd, i, codec_dai) {
ret = soc_probe_dai(codec_dai, order);
if (ret)
return ret;
@ -1486,7 +1486,7 @@ int snd_soc_runtime_set_dai_fmt(struct snd_soc_pcm_runtime *rtd,
unsigned int i;
int ret;
for_each_rtd_codec_dai(rtd, i, codec_dai) {
for_each_rtd_codec_dais(rtd, i, codec_dai) {
ret = snd_soc_dai_set_fmt(codec_dai, dai_fmt);
if (ret != 0 && ret != -ENOTSUPP) {
dev_warn(codec_dai->dev,
@ -1514,7 +1514,7 @@ int snd_soc_runtime_set_dai_fmt(struct snd_soc_pcm_runtime *rtd,
inv_dai_fmt |= SND_SOC_DAIFMT_CBM_CFM;
break;
}
for_each_rtd_cpu_dai(rtd, i, cpu_dai) {
for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
unsigned int fmt = dai_fmt;
if (cpu_dai->component->driver->non_legacy_dai_naming)

53
sound/soc/soc-dapm.c
View File

@ -302,7 +302,7 @@ void dapm_mark_endpoints_dirty(struct snd_soc_card *card)
mutex_lock(&card->dapm_mutex);
list_for_each_entry(w, &card->widgets, list) {
for_each_card_widgets(card, w) {
if (w->is_ep) {
dapm_mark_dirty(w, "Rechecking endpoints");
if (w->is_ep & SND_SOC_DAPM_EP_SINK)
@ -589,7 +589,7 @@ static void dapm_reset(struct snd_soc_card *card)
memset(&card->dapm_stats, 0, sizeof(card->dapm_stats));
list_for_each_entry(w, &card->widgets, list) {
for_each_card_widgets(card, w) {
w->new_power = w->power;
w->power_checked = false;
}
@ -833,7 +833,7 @@ static int dapm_is_shared_kcontrol(struct snd_soc_dapm_context *dapm,
*kcontrol = NULL;
list_for_each_entry(w, &dapm->card->widgets, list) {
for_each_card_widgets(dapm->card, w) {
if (w == kcontrolw || w->dapm != kcontrolw->dapm)
continue;
for (i = 0; i < w->num_kcontrols; i++) {
@ -1716,9 +1716,8 @@ static void dapm_seq_run(struct snd_soc_card *card,
i, cur_subseq);
}
list_for_each_entry(d, &card->dapm_list, list) {
for_each_card_dapms(card, d)
soc_dapm_async_complete(d);
}
}
static void dapm_widget_update(struct snd_soc_card *card)
@ -1949,7 +1948,7 @@ static int dapm_power_widgets(struct snd_soc_card *card, int event)
trace_snd_soc_dapm_start(card);
list_for_each_entry(d, &card->dapm_list, list) {
for_each_card_dapms(card, d) {
if (dapm_idle_bias_off(d))
d->target_bias_level = SND_SOC_BIAS_OFF;
else
@ -1968,7 +1967,7 @@ static int dapm_power_widgets(struct snd_soc_card *card, int event)
dapm_power_one_widget(w, &up_list, &down_list);
}
list_for_each_entry(w, &card->widgets, list) {
for_each_card_widgets(card, w) {
switch (w->id) {
case snd_soc_dapm_pre:
case snd_soc_dapm_post:
@ -2013,10 +2012,10 @@ static int dapm_power_widgets(struct snd_soc_card *card, int event)
* they're not ground referenced.
*/
bias = SND_SOC_BIAS_OFF;
list_for_each_entry(d, &card->dapm_list, list)
for_each_card_dapms(card, d)
if (d->target_bias_level > bias)
bias = d->target_bias_level;
list_for_each_entry(d, &card->dapm_list, list)
for_each_card_dapms(card, d)
if (!dapm_idle_bias_off(d))
d->target_bias_level = bias;
@ -2025,7 +2024,7 @@ static int dapm_power_widgets(struct snd_soc_card *card, int event)
/* Run card bias changes at first */
dapm_pre_sequence_async(&card->dapm, 0);
/* Run other bias changes in parallel */
list_for_each_entry(d, &card->dapm_list, list) {
for_each_card_dapms(card, d) {
if (d != &card->dapm && d->bias_level != d->target_bias_level)
async_schedule_domain(dapm_pre_sequence_async, d,
&async_domain);
@ -2049,7 +2048,7 @@ static int dapm_power_widgets(struct snd_soc_card *card, int event)
dapm_seq_run(card, &up_list, event, true);
/* Run all the bias changes in parallel */
list_for_each_entry(d, &card->dapm_list, list) {
for_each_card_dapms(card, d) {
if (d != &card->dapm && d->bias_level != d->target_bias_level)
async_schedule_domain(dapm_post_sequence_async, d,
&async_domain);
@ -2059,7 +2058,7 @@ static int dapm_power_widgets(struct snd_soc_card *card, int event)
dapm_post_sequence_async(&card->dapm, 0);
/* do we need to notify any clients that DAPM event is complete */
list_for_each_entry(d, &card->dapm_list, list) {
for_each_card_dapms(card, d) {
if (!d->component)
continue;
@ -2377,7 +2376,7 @@ static ssize_t dapm_widget_show_component(struct snd_soc_component *cmpnt,
if (!cmpnt->card)
return 0;
list_for_each_entry(w, &cmpnt->card->widgets, list) {
for_each_card_widgets(cmpnt->card, w) {
if (w->dapm != dapm)
continue;
@ -2437,7 +2436,7 @@ static ssize_t dapm_widget_show(struct device *dev,
mutex_lock(&rtd->card->dapm_mutex);
for_each_rtd_codec_dai(rtd, i, codec_dai) {
for_each_rtd_codec_dais(rtd, i, codec_dai) {
struct snd_soc_component *cmpnt = codec_dai->component;
count += dapm_widget_show_component(cmpnt, buf + count);
@ -2497,7 +2496,7 @@ static void dapm_free_widgets(struct snd_soc_dapm_context *dapm)
{
struct snd_soc_dapm_widget *w, *next_w;
list_for_each_entry_safe(w, next_w, &dapm->card->widgets, list) {
for_each_card_widgets_safe(dapm->card, w, next_w) {
if (w->dapm != dapm)
continue;
snd_soc_dapm_free_widget(w);
@ -2512,7 +2511,7 @@ static struct snd_soc_dapm_widget *dapm_find_widget(
struct snd_soc_dapm_widget *w;
struct snd_soc_dapm_widget *fallback = NULL;
list_for_each_entry(w, &dapm->card->widgets, list) {
for_each_card_widgets(dapm->card, w) {
if (!strcmp(w->name, pin)) {
if (w->dapm == dapm)
return w;
@ -2911,7 +2910,7 @@ static int snd_soc_dapm_add_route(struct snd_soc_dapm_context *dapm,
* find src and dest widgets over all widgets but favor a widget from
* current DAPM context
*/
list_for_each_entry(w, &dapm->card->widgets, list) {
for_each_card_widgets(dapm->card, w) {
if (!wsink && !(strcmp(w->name, sink))) {
wtsink = w;
if (w->dapm == dapm) {
@ -3190,7 +3189,7 @@ int snd_soc_dapm_new_widgets(struct snd_soc_card *card)
mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
list_for_each_entry(w, &card->widgets, list)
for_each_card_widgets(card, w)
{
if (w->new)
continue;
@ -3704,6 +3703,7 @@ snd_soc_dapm_new_control_unlocked(struct snd_soc_dapm_context *dapm,
w->dapm = dapm;
INIT_LIST_HEAD(&w->list);
INIT_LIST_HEAD(&w->dirty);
/* see for_each_card_widgets */
list_add_tail(&w->list, &dapm->card->widgets);
snd_soc_dapm_for_each_direction(dir) {
@ -4228,7 +4228,7 @@ int snd_soc_dapm_link_dai_widgets(struct snd_soc_card *card)
struct snd_soc_dai *dai;
/* For each DAI widget... */
list_for_each_entry(dai_w, &card->widgets, list) {
for_each_card_widgets(card, dai_w) {
switch (dai_w->id) {
case snd_soc_dapm_dai_in:
case snd_soc_dapm_dai_out:
@ -4247,7 +4247,7 @@ int snd_soc_dapm_link_dai_widgets(struct snd_soc_card *card)
dai = dai_w->priv;
/* ...find all widgets with the same stream and link them */
list_for_each_entry(w, &card->widgets, list) {
for_each_card_widgets(card, w) {
if (w->dapm != dai_w->dapm)
continue;
@ -4362,11 +4362,11 @@ static void dapm_connect_dai_link_widgets(struct snd_soc_card *card,
int i;
if (rtd->num_cpus == 1) {
for_each_rtd_codec_dai(rtd, i, codec_dai)
for_each_rtd_codec_dais(rtd, i, codec_dai)
dapm_add_valid_dai_widget(card, rtd, codec_dai,
rtd->cpu_dais[0]);
} else if (rtd->num_codecs == rtd->num_cpus) {
for_each_rtd_codec_dai(rtd, i, codec_dai)
for_each_rtd_codec_dais(rtd, i, codec_dai)
dapm_add_valid_dai_widget(card, rtd, codec_dai,
rtd->cpu_dais[i]);
} else {
@ -4437,9 +4437,9 @@ static void soc_dapm_stream_event(struct snd_soc_pcm_runtime *rtd, int stream,
struct snd_soc_dai *cpu_dai;
int i;
for_each_rtd_cpu_dai(rtd, i, cpu_dai)
for_each_rtd_cpu_dais(rtd, i, cpu_dai)
soc_dapm_dai_stream_event(cpu_dai, stream, event);
for_each_rtd_codec_dai(rtd, i, codec_dai)
for_each_rtd_codec_dais(rtd, i, codec_dai)
soc_dapm_dai_stream_event(codec_dai, stream, event);
dapm_power_widgets(rtd->card, event);
@ -4776,6 +4776,7 @@ void snd_soc_dapm_init(struct snd_soc_dapm_context *dapm,
}
INIT_LIST_HEAD(&dapm->list);
/* see for_each_card_dapms */
list_add(&dapm->list, &card->dapm_list);
}
EXPORT_SYMBOL_GPL(snd_soc_dapm_init);
@ -4789,7 +4790,7 @@ static void soc_dapm_shutdown_dapm(struct snd_soc_dapm_context *dapm)
mutex_lock(&card->dapm_mutex);
list_for_each_entry(w, &dapm->card->widgets, list) {
for_each_card_widgets(dapm->card, w) {
if (w->dapm != dapm)
continue;
if (w->power) {
@ -4822,7 +4823,7 @@ void snd_soc_dapm_shutdown(struct snd_soc_card *card)
{
struct snd_soc_dapm_context *dapm;
list_for_each_entry(dapm, &card->dapm_list, list) {
for_each_card_dapms(card, dapm) {
if (dapm != &card->dapm) {
soc_dapm_shutdown_dapm(dapm);
if (dapm->bias_level == SND_SOC_BIAS_STANDBY)

124
sound/soc/soc-pcm.c
View File

@ -265,17 +265,17 @@ static void snd_soc_runtime_action(struct snd_soc_pcm_runtime *rtd,
lockdep_assert_held(&rtd->card->pcm_mutex);
for_each_rtd_cpu_dai(rtd, i, cpu_dai)
for_each_rtd_cpu_dais(rtd, i, cpu_dai)
cpu_dai->stream_active[stream] += action;
for_each_rtd_codec_dai(rtd, i, codec_dai)
for_each_rtd_codec_dais(rtd, i, codec_dai)
codec_dai->stream_active[stream] += action;
for_each_rtd_cpu_dai(rtd, i, cpu_dai) {
for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
cpu_dai->active += action;
cpu_dai->component->active += action;
}
for_each_rtd_codec_dai(rtd, i, codec_dai) {
for_each_rtd_codec_dais(rtd, i, codec_dai) {
codec_dai->active += action;
codec_dai->component->active += action;
}
@ -455,14 +455,14 @@ static int soc_pcm_params_symmetry(struct snd_pcm_substream *substream,
/* reject unmatched parameters when applying symmetry */
symmetry = rtd->dai_link->symmetric_rates;
for_each_rtd_cpu_dai(rtd, i, cpu_dai)
for_each_rtd_cpu_dais(rtd, i, cpu_dai)
symmetry |= cpu_dai->driver->symmetric_rates;
for_each_rtd_codec_dai(rtd, i, codec_dai)
for_each_rtd_codec_dais(rtd, i, codec_dai)
symmetry |= codec_dai->driver->symmetric_rates;
if (symmetry) {
for_each_rtd_cpu_dai(rtd, i, cpu_dai) {
for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
if (cpu_dai->rate && cpu_dai->rate != rate) {
dev_err(rtd->dev, "ASoC: unmatched rate symmetry: %d - %d\n",
cpu_dai->rate, rate);
@ -473,14 +473,14 @@ static int soc_pcm_params_symmetry(struct snd_pcm_substream *substream,
symmetry = rtd->dai_link->symmetric_channels;
for_each_rtd_cpu_dai(rtd, i, cpu_dai)
for_each_rtd_cpu_dais(rtd, i, cpu_dai)
symmetry |= cpu_dai->driver->symmetric_channels;
for_each_rtd_codec_dai(rtd, i, codec_dai)
for_each_rtd_codec_dais(rtd, i, codec_dai)
symmetry |= codec_dai->driver->symmetric_channels;
if (symmetry) {
for_each_rtd_cpu_dai(rtd, i, cpu_dai) {
for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
if (cpu_dai->channels &&
cpu_dai->channels != channels) {
dev_err(rtd->dev, "ASoC: unmatched channel symmetry: %d - %d\n",
@ -492,14 +492,14 @@ static int soc_pcm_params_symmetry(struct snd_pcm_substream *substream,
symmetry = rtd->dai_link->symmetric_samplebits;
for_each_rtd_cpu_dai(rtd, i, cpu_dai)
for_each_rtd_cpu_dais(rtd, i, cpu_dai)
symmetry |= cpu_dai->driver->symmetric_samplebits;
for_each_rtd_codec_dai(rtd, i, codec_dai)
for_each_rtd_codec_dais(rtd, i, codec_dai)
symmetry |= codec_dai->driver->symmetric_samplebits;
if (symmetry) {
for_each_rtd_cpu_dai(rtd, i, cpu_dai) {
for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
if (cpu_dai->sample_bits &&
cpu_dai->sample_bits != sample_bits) {
dev_err(rtd->dev, "ASoC: unmatched sample bits symmetry: %d - %d\n",
@ -524,13 +524,13 @@ static bool soc_pcm_has_symmetry(struct snd_pcm_substream *substream)
link->symmetric_channels ||
link->symmetric_samplebits;
for_each_rtd_cpu_dai(rtd, i, cpu_dai)
for_each_rtd_cpu_dais(rtd, i, cpu_dai)
symmetry = symmetry ||
cpu_dai->driver->symmetric_rates ||
cpu_dai->driver->symmetric_channels ||
cpu_dai->driver->symmetric_samplebits;
for_each_rtd_codec_dai(rtd, i, codec_dai)
for_each_rtd_codec_dais(rtd, i, codec_dai)
symmetry = symmetry ||
codec_dai->driver->symmetric_rates ||
codec_dai->driver->symmetric_channels ||
@ -563,7 +563,7 @@ static void soc_pcm_apply_msb(struct snd_pcm_substream *substream)
int i;
unsigned int bits = 0, cpu_bits = 0;
for_each_rtd_codec_dai(rtd, i, codec_dai) {
for_each_rtd_codec_dais(rtd, i, codec_dai) {
pcm_codec = snd_soc_dai_get_pcm_stream(codec_dai, stream);
if (pcm_codec->sig_bits == 0) {
@ -573,7 +573,7 @@ static void soc_pcm_apply_msb(struct snd_pcm_substream *substream)
bits = max(pcm_codec->sig_bits, bits);
}
for_each_rtd_cpu_dai(rtd, i, cpu_dai) {
for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
pcm_cpu = snd_soc_dai_get_pcm_stream(cpu_dai, stream);
if (pcm_cpu->sig_bits == 0) {
@ -612,7 +612,7 @@ int snd_soc_runtime_calc_hw(struct snd_soc_pcm_runtime *rtd,
int i;
/* first calculate min/max only for CPUs in the DAI link */
for_each_rtd_cpu_dai(rtd, i, cpu_dai) {
for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
/*
* Skip CPUs which don't support the current stream type.
@ -635,7 +635,7 @@ int snd_soc_runtime_calc_hw(struct snd_soc_pcm_runtime *rtd,
}
/* second calculate min/max only for CODECs in the DAI link */
for_each_rtd_codec_dai(rtd, i, codec_dai) {
for_each_rtd_codec_dais(rtd, i, codec_dai) {
/*
* Skip CODECs which don't support the current stream type.
@ -780,10 +780,10 @@ static int soc_pcm_close(struct snd_pcm_substream *substream)
snd_soc_runtime_deactivate(rtd, substream->stream);
for_each_rtd_cpu_dai(rtd, i, cpu_dai)
for_each_rtd_cpu_dais(rtd, i, cpu_dai)
snd_soc_dai_shutdown(cpu_dai, substream);
for_each_rtd_codec_dai(rtd, i, codec_dai)
for_each_rtd_codec_dais(rtd, i, codec_dai)
snd_soc_dai_shutdown(codec_dai, substream);
soc_rtd_shutdown(rtd, substream);
@ -842,7 +842,7 @@ static int soc_pcm_open(struct snd_pcm_substream *substream)
}
/* startup the audio subsystem */
for_each_rtd_cpu_dai(rtd, i, cpu_dai) {
for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
ret = snd_soc_dai_startup(cpu_dai, substream);
if (ret < 0) {
dev_err(cpu_dai->dev, "ASoC: can't open interface %s: %d\n",
@ -851,7 +851,7 @@ static int soc_pcm_open(struct snd_pcm_substream *substream)
}
}
for_each_rtd_codec_dai(rtd, i, codec_dai) {
for_each_rtd_codec_dais(rtd, i, codec_dai) {
ret = snd_soc_dai_startup(codec_dai, substream);
if (ret < 0) {
dev_err(codec_dai->dev,
@ -903,7 +903,7 @@ static int soc_pcm_open(struct snd_pcm_substream *substream)
soc_pcm_apply_msb(substream);
/* Symmetry only applies if we've already got an active stream. */
for_each_rtd_cpu_dai(rtd, i, cpu_dai) {
for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
if (cpu_dai->active) {
ret = soc_pcm_apply_symmetry(substream, cpu_dai);
if (ret != 0)
@ -911,7 +911,7 @@ static int soc_pcm_open(struct snd_pcm_substream *substream)
}
}
for_each_rtd_codec_dai(rtd, i, codec_dai) {
for_each_rtd_codec_dais(rtd, i, codec_dai) {
if (codec_dai->active) {
ret = soc_pcm_apply_symmetry(substream, codec_dai);
if (ret != 0)
@ -935,10 +935,10 @@ dynamic:
return 0;
config_err:
for_each_rtd_codec_dai(rtd, i, codec_dai)
for_each_rtd_codec_dais(rtd, i, codec_dai)
snd_soc_dai_shutdown(codec_dai, substream);
cpu_dai_err:
for_each_rtd_cpu_dai(rtd, i, cpu_dai)
for_each_rtd_cpu_dais(rtd, i, cpu_dai)
snd_soc_dai_shutdown(cpu_dai, substream);
soc_rtd_shutdown(rtd, substream);
@ -1000,7 +1000,7 @@ static int soc_pcm_prepare(struct snd_pcm_substream *substream)
}
}
for_each_rtd_codec_dai(rtd, i, codec_dai) {
for_each_rtd_codec_dais(rtd, i, codec_dai) {
ret = snd_soc_dai_prepare(codec_dai, substream);
if (ret < 0) {
dev_err(codec_dai->dev,
@ -1010,7 +1010,7 @@ static int soc_pcm_prepare(struct snd_pcm_substream *substream)
}
}
for_each_rtd_cpu_dai(rtd, i, cpu_dai) {
for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
ret = snd_soc_dai_prepare(cpu_dai, substream);
if (ret < 0) {
dev_err(cpu_dai->dev,
@ -1029,10 +1029,10 @@ static int soc_pcm_prepare(struct snd_pcm_substream *substream)
snd_soc_dapm_stream_event(rtd, substream->stream,
SND_SOC_DAPM_STREAM_START);
for_each_rtd_codec_dai(rtd, i, codec_dai)
for_each_rtd_codec_dais(rtd, i, codec_dai)
snd_soc_dai_digital_mute(codec_dai, 0,
substream->stream);
for_each_rtd_cpu_dai(rtd, i, cpu_dai)
for_each_rtd_cpu_dais(rtd, i, cpu_dai)
snd_soc_dai_digital_mute(cpu_dai, 0, substream->stream);
out:
@ -1097,7 +1097,7 @@ static int soc_pcm_hw_params(struct snd_pcm_substream *substream,
goto out;
}
for_each_rtd_codec_dai(rtd, i, codec_dai) {
for_each_rtd_codec_dais(rtd, i, codec_dai) {
struct snd_pcm_hw_params codec_params;
/*
@ -1144,7 +1144,7 @@ static int soc_pcm_hw_params(struct snd_pcm_substream *substream,
snd_soc_dapm_update_dai(substream, &codec_params, codec_dai);
}
for_each_rtd_cpu_dai(rtd, i, cpu_dai) {
for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
/*
* Skip CPUs which don't support the current stream
* type. See soc_pcm_init_runtime_hw() for more details
@ -1186,7 +1186,7 @@ component_err:
i = rtd->num_cpus;
interface_err:
for_each_rtd_cpu_dai_rollback(rtd, i, cpu_dai) {
for_each_rtd_cpu_dais_rollback(rtd, i, cpu_dai) {
if (!snd_soc_dai_stream_valid(cpu_dai, substream->stream))
continue;
@ -1197,7 +1197,7 @@ interface_err:
i = rtd->num_codecs;
codec_err:
for_each_rtd_codec_dai_rollback(rtd, i, codec_dai) {
for_each_rtd_codec_dais_rollback(rtd, i, codec_dai) {
if (!snd_soc_dai_stream_valid(codec_dai, substream->stream))
continue;
@ -1224,7 +1224,7 @@ static int soc_pcm_hw_free(struct snd_pcm_substream *substream)
mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass);
/* clear the corresponding DAIs parameters when going to be inactive */
for_each_rtd_cpu_dai(rtd, i, cpu_dai) {
for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
if (cpu_dai->active == 1) {
cpu_dai->rate = 0;
cpu_dai->channels = 0;
@ -1232,7 +1232,7 @@ static int soc_pcm_hw_free(struct snd_pcm_substream *substream)
}
}
for_each_rtd_codec_dai(rtd, i, codec_dai) {
for_each_rtd_codec_dais(rtd, i, codec_dai) {
if (codec_dai->active == 1) {
codec_dai->rate = 0;
codec_dai->channels = 0;
@ -1241,7 +1241,7 @@ static int soc_pcm_hw_free(struct snd_pcm_substream *substream)
}
/* apply codec digital mute */
for_each_rtd_codec_dai(rtd, i, codec_dai) {
for_each_rtd_codec_dais(rtd, i, codec_dai) {
int active = codec_dai->stream_active[substream->stream];
if (active == 1)
@ -1249,7 +1249,7 @@ static int soc_pcm_hw_free(struct snd_pcm_substream *substream)
substream->stream);
}
for_each_rtd_cpu_dai(rtd, i, cpu_dai) {
for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
int active = cpu_dai->stream_active[substream->stream];
if (active == 1)
@ -1264,14 +1264,14 @@ static int soc_pcm_hw_free(struct snd_pcm_substream *substream)
soc_pcm_components_hw_free(substream, NULL);
/* now free hw params for the DAIs */
for_each_rtd_codec_dai(rtd, i, codec_dai) {
for_each_rtd_codec_dais(rtd, i, codec_dai) {
if (!snd_soc_dai_stream_valid(codec_dai, substream->stream))
continue;
snd_soc_dai_hw_free(codec_dai, substream);
}
for_each_rtd_cpu_dai(rtd, i, cpu_dai) {
for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
if (!snd_soc_dai_stream_valid(cpu_dai, substream->stream))
continue;
@ -1300,13 +1300,13 @@ static int soc_pcm_trigger_start(struct snd_pcm_substream *substream, int cmd)
return ret;
}
for_each_rtd_cpu_dai(rtd, i, cpu_dai) {
for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
ret = snd_soc_dai_trigger(cpu_dai, substream, cmd);
if (ret < 0)
return ret;
}
for_each_rtd_codec_dai(rtd, i, codec_dai) {
for_each_rtd_codec_dais(rtd, i, codec_dai) {
ret = snd_soc_dai_trigger(codec_dai, substream, cmd);
if (ret < 0)
return ret;
@ -1323,13 +1323,13 @@ static int soc_pcm_trigger_stop(struct snd_pcm_substream *substream, int cmd)
struct snd_soc_dai *codec_dai;
int i, ret;
for_each_rtd_codec_dai(rtd, i, codec_dai) {
for_each_rtd_codec_dais(rtd, i, codec_dai) {
ret = snd_soc_dai_trigger(codec_dai, substream, cmd);
if (ret < 0)
return ret;
}
for_each_rtd_cpu_dai(rtd, i, cpu_dai) {
for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
ret = snd_soc_dai_trigger(cpu_dai, substream, cmd);
if (ret < 0)
return ret;
@ -1378,13 +1378,13 @@ static int soc_pcm_bespoke_trigger(struct snd_pcm_substream *substream,
struct snd_soc_dai *codec_dai;
int i, ret;
for_each_rtd_codec_dai(rtd, i, codec_dai) {
for_each_rtd_codec_dais(rtd, i, codec_dai) {
ret = snd_soc_dai_bespoke_trigger(codec_dai, substream, cmd);
if (ret < 0)
return ret;
}
for_each_rtd_cpu_dai(rtd, i, cpu_dai) {
for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
ret = snd_soc_dai_bespoke_trigger(cpu_dai, substream, cmd);
if (ret < 0)
return ret;
@ -1417,13 +1417,13 @@ static snd_pcm_uframes_t soc_pcm_pointer(struct snd_pcm_substream *substream)
/* base delay if assigned in pointer callback */
delay = runtime->delay;
for_each_rtd_cpu_dai(rtd, i, cpu_dai) {
for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
cpu_delay = max(cpu_delay,
snd_soc_dai_delay(cpu_dai, substream));
}
delay += cpu_delay;
for_each_rtd_codec_dai(rtd, i, codec_dai) {
for_each_rtd_codec_dais(rtd, i, codec_dai) {
codec_delay = max(codec_delay,
snd_soc_dai_delay(codec_dai, substream));
}
@ -1544,7 +1544,7 @@ static struct snd_soc_pcm_runtime *dpcm_get_be(struct snd_soc_card *card,
if (!be->dai_link->no_pcm)
continue;
for_each_rtd_cpu_dai(be, i, dai) {
for_each_rtd_cpu_dais(be, i, dai) {
w = snd_soc_dai_get_widget(dai, stream);
dev_dbg(card->dev, "ASoC: try BE : %s\n",
@ -1554,7 +1554,7 @@ static struct snd_soc_pcm_runtime *dpcm_get_be(struct snd_soc_card *card,
return be;
}
for_each_rtd_codec_dai(be, i, dai) {
for_each_rtd_codec_dais(be, i, dai) {
w = snd_soc_dai_get_widget(dai, stream);
if (w == widget)
@ -1642,7 +1642,7 @@ static int dpcm_prune_paths(struct snd_soc_pcm_runtime *fe, int stream,
/* is there a valid CPU DAI widget for this BE */
do_prune = 1;
for_each_rtd_cpu_dai(dpcm->be, i, dai) {
for_each_rtd_cpu_dais(dpcm->be, i, dai) {
widget = snd_soc_dai_get_widget(dai, stream);
/*
@ -1657,7 +1657,7 @@ static int dpcm_prune_paths(struct snd_soc_pcm_runtime *fe, int stream,
/* is there a valid CODEC DAI widget for this BE */
do_prune = 1;
for_each_rtd_codec_dai(dpcm->be, i, dai) {
for_each_rtd_codec_dais(dpcm->be, i, dai) {
widget = snd_soc_dai_get_widget(dai, stream);
/* prune the BE if it's no longer in our active list */
@ -1910,7 +1910,7 @@ static void dpcm_runtime_merge_format(struct snd_pcm_substream *substream,
struct snd_soc_pcm_stream *codec_stream;
int i;
for_each_rtd_codec_dai(be, i, dai) {
for_each_rtd_codec_dais(be, i, dai) {
/*
* Skip CODECs which don't support the current stream
* type. See soc_pcm_init_runtime_hw() for more details
@ -1948,7 +1948,7 @@ static void dpcm_runtime_merge_chan(struct snd_pcm_substream *substream,
struct snd_soc_dai *dai;
int i;
for_each_rtd_cpu_dai(be, i, dai) {
for_each_rtd_cpu_dais(be, i, dai) {
/*
* Skip CPUs which don't support the current stream
* type. See soc_pcm_init_runtime_hw() for more details
@ -2003,7 +2003,7 @@ static void dpcm_runtime_merge_rate(struct snd_pcm_substream *substream,
struct snd_soc_dai *dai;
int i;
for_each_rtd_cpu_dai(be, i, dai) {
for_each_rtd_cpu_dais(be, i, dai) {
/*
* Skip CPUs which don't support the current stream
* type. See soc_pcm_init_runtime_hw() for more details
@ -2020,7 +2020,7 @@ static void dpcm_runtime_merge_rate(struct snd_pcm_substream *substream,
cpu_stream->rates);
}
for_each_rtd_codec_dai(be, i, dai) {
for_each_rtd_codec_dais(be, i, dai) {
/*
* Skip CODECs which don't support the current stream
* type. See soc_pcm_init_runtime_hw() for more details
@ -2046,7 +2046,7 @@ static void dpcm_set_fe_runtime(struct snd_pcm_substream *substream)
struct snd_soc_dai *cpu_dai;
int i;
for_each_rtd_cpu_dai(rtd, i, cpu_dai) {
for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
/*
* Skip CPUs which don't support the current stream
* type. See soc_pcm_init_runtime_hw() for more details
@ -2102,7 +2102,7 @@ static int dpcm_apply_symmetry(struct snd_pcm_substream *fe_substream,
if (soc_pcm_has_symmetry(fe_substream))
fe_substream->runtime->hw.info |= SNDRV_PCM_INFO_JOINT_DUPLEX;
for_each_rtd_cpu_dai (fe, i, fe_cpu_dai) {
for_each_rtd_cpu_dais (fe, i, fe_cpu_dai) {
/* Symmetry only applies if we've got an active stream. */
if (fe_cpu_dai->active) {
err = soc_pcm_apply_symmetry(fe_substream, fe_cpu_dai);
@ -2133,7 +2133,7 @@ static int dpcm_apply_symmetry(struct snd_pcm_substream *fe_substream,
be_substream->runtime->hw.info |= SNDRV_PCM_INFO_JOINT_DUPLEX;
/* Symmetry only applies if we've got an active stream. */
for_each_rtd_cpu_dai(rtd, i, cpu_dai) {
for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
if (cpu_dai->active) {
err = soc_pcm_apply_symmetry(fe_substream,
cpu_dai);
@ -2142,7 +2142,7 @@ static int dpcm_apply_symmetry(struct snd_pcm_substream *fe_substream,
}
}
for_each_rtd_codec_dai(rtd, i, codec_dai) {
for_each_rtd_codec_dais(rtd, i, codec_dai) {
if (codec_dai->active) {
err = soc_pcm_apply_symmetry(fe_substream,
codec_dai);
@ -3075,7 +3075,7 @@ int soc_new_pcm(struct snd_soc_pcm_runtime *rtd, int num)
int cpu_playback = rtd->dai_link->params ?
SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
for_each_rtd_codec_dai(rtd, i, codec_dai) {
for_each_rtd_codec_dais(rtd, i, codec_dai) {
if (rtd->num_cpus == 1) {
cpu_dai = rtd->cpu_dais[0];
} else if (rtd->num_cpus == rtd->num_codecs) {

2
sound/soc/soc-topology.c
View File

@ -2774,7 +2774,7 @@ void snd_soc_tplg_widget_remove_all(struct snd_soc_dapm_context *dapm,
{
struct snd_soc_dapm_widget *w, *next_w;
list_for_each_entry_safe(w, next_w, &dapm->card->widgets, list) {
for_each_card_widgets_safe(dapm->card, w, next_w) {
/* make sure we are a widget with correct context */
if (w->dobj.type != SND_SOC_DOBJ_WIDGET || w->dapm != dapm)