korg/linux
0
0
Fork 0
mirror of https://mirrors.bfsu.edu.cn/git/linux.git synced 2024-12-03 00:54:09 +08:00
Code Issues Packages Projects Releases Wiki Activity

ASoC: intel: sof_sdw: Use consistent variable naming for links

Browse Source 
The driver makes extensive use of both ACPI link and ASoC DAI link
structs, often referring to both with the variable name link. Make the
code a little easier to follow by consistently using adr_link for the
ACPI bits and dai_links for the ASoC bits.

Reviewed-by: Bard Liao <yung-chuan.liao@linux.intel.com>
Reviewed-by: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Reviewed-by: Rander Wang <rander.wang@intel.com>
Signed-off-by: Charles Keepax <ckeepax@opensource.cirrus.com>
Signed-off-by: Pierre-Louis Bossart <pierre-louis.bossart@linux.intel.com>
Link: https://lore.kernel.org/r/20230731214257.444605-10-pierre-louis.bossart@linux.intel.com
Signed-off-by: Mark Brown <broonie@kernel.org>
This commit is contained in:
Charles Keepax 2023-07-31 16:42:43 -05:00 committed by Mark Brown
parent 0cc85f2bfb
commit 1d1062382b
No known key found for this signature in database
GPG Key ID: 24D68B725D5487D0
1 changed files with 60 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

118
sound/soc/intel/boards/sof_sdw.c
View File

@ -1021,10 +1021,10 @@ static inline int find_codec_info_acpi(const u8 *acpi_id)
* Since some sdw slaves may be aggregated, the CPU DAI number
* may be larger than the number of BE dailinks.
*/
static int get_sdw_dailink_info(struct device *dev, const struct snd_soc_acpi_link_adr *links,
static int get_sdw_dailink_info(struct device *dev,
const struct snd_soc_acpi_link_adr *adr_link,
int *sdw_be_num, int *sdw_cpu_dai_num)
{
const struct snd_soc_acpi_link_adr *link;
bool group_visited[SDW_MAX_GROUPS];
bool no_aggregation;
int i;
@ -1034,27 +1034,27 @@ static int get_sdw_dailink_info(struct device *dev, const struct snd_soc_acpi_li
*sdw_cpu_dai_num = 0;
*sdw_be_num = 0;
if (!links)
if (!adr_link)
return -EINVAL;
for (i = 0; i < SDW_MAX_GROUPS; i++)
group_visited[i] = false;
for (link = links; link->num_adr; link++) {
for (; adr_link->num_adr; adr_link++) {
const struct snd_soc_acpi_endpoint *endpoint;
struct sof_sdw_codec_info *codec_info;
int codec_index;
int stream;
u64 adr;
for (i = 0; i < link->num_adr; i++) {
adr = link->adr_d[i].adr;
for (i = 0; i < adr_link->num_adr; i++) {
adr = adr_link->adr_d[i].adr;
codec_index = find_codec_info_part(adr);
if (codec_index < 0)
return codec_index;
codec_info = &codec_info_list[codec_index];
endpoint = link->adr_d[i].endpoints;
endpoint = adr_link->adr_d[i].endpoints;
for (j = 0; j < codec_info->dai_num; j++) {
/* count DAI number for playback and capture */
@ -1102,7 +1102,7 @@ static void init_dai_link(struct device *dev, struct snd_soc_dai_link *dai_links
dai_links->ops = ops;
}
static bool is_unique_device(const struct snd_soc_acpi_link_adr *link,
static bool is_unique_device(const struct snd_soc_acpi_link_adr *adr_link,
unsigned int sdw_version,
unsigned int mfg_id,
unsigned int part_id,
@ -1112,7 +1112,7 @@ static bool is_unique_device(const struct snd_soc_acpi_link_adr *link,
{
int i;
for (i = 0; i < link->num_adr; i++) {
for (i = 0; i < adr_link->num_adr; i++) {
unsigned int sdw1_version, mfg1_id, part1_id, class1_id;
u64 adr;
@ -1120,7 +1120,7 @@ static bool is_unique_device(const struct snd_soc_acpi_link_adr *link,
if (i == index_in_link)
continue;
adr = link->adr_d[i].adr;
adr = adr_link->adr_d[i].adr;
sdw1_version = SDW_VERSION(adr);
mfg1_id = SDW_MFG_ID(adr);
@ -1138,7 +1138,7 @@ static bool is_unique_device(const struct snd_soc_acpi_link_adr *link,
}
static int create_codec_dai_name(struct device *dev,
const struct snd_soc_acpi_link_adr *link,
const struct snd_soc_acpi_link_adr *adr_link,
struct snd_soc_dai_link_component *codec,
int offset,
struct snd_soc_codec_conf *codec_conf,
@ -1151,19 +1151,19 @@ static int create_codec_dai_name(struct device *dev,
int i;
/* sanity check */
if (*codec_conf_index + link->num_adr - adr_index > codec_count) {
if (*codec_conf_index + adr_link->num_adr - adr_index > codec_count) {
dev_err(dev, "codec_conf: out-of-bounds access requested\n");
return -EINVAL;
}
for (i = adr_index; i < link->num_adr; i++) {
for (i = adr_index; i < adr_link->num_adr; i++) {
unsigned int sdw_version, unique_id, mfg_id;
unsigned int link_id, part_id, class_id;
int codec_index, comp_index;
char *codec_str;
u64 adr;
adr = link->adr_d[i].adr;
adr = adr_link->adr_d[i].adr;
sdw_version = SDW_VERSION(adr);
link_id = SDW_DISCO_LINK_ID(adr);
@ -1173,7 +1173,7 @@ static int create_codec_dai_name(struct device *dev,
class_id = SDW_CLASS_ID(adr);
comp_index = i - adr_index + offset;
if (is_unique_device(link, sdw_version, mfg_id, part_id,
if (is_unique_device(adr_link, sdw_version, mfg_id, part_id,
class_id, i)) {
codec_str = "sdw:%01x:%04x:%04x:%02x";
codec[comp_index].name =
@ -1204,7 +1204,7 @@ static int create_codec_dai_name(struct device *dev,
codec_info_list[codec_index].dais[dai_index].dai_name;
codec_conf[*codec_conf_index].dlc = codec[comp_index];
codec_conf[*codec_conf_index].name_prefix = link->adr_d[i].name_prefix;
codec_conf[*codec_conf_index].name_prefix = adr_link->adr_d[i].name_prefix;
++*codec_conf_index;
}
@ -1213,7 +1213,7 @@ static int create_codec_dai_name(struct device *dev,
}
static int set_codec_init_func(struct snd_soc_card *card,
const struct snd_soc_acpi_link_adr *link,
const struct snd_soc_acpi_link_adr *adr_link,
struct snd_soc_dai_link *dai_links,
bool playback, int group_id, int adr_index, int dai_index)
{
@ -1224,34 +1224,35 @@ static int set_codec_init_func(struct snd_soc_card *card,
* Initialize the codec. If codec is part of an aggregated
* group (group_id>0), initialize all codecs belonging to
* same group.
* The first link should start with link->adr_d[adr_index]
* The first link should start with adr_link->adr_d[adr_index]
* because that is the device that we want to initialize and
* we should end immediately if it is not aggregated (group_id=0)
*/
for ( ; i < link->num_adr; i++) {
for ( ; i < adr_link->num_adr; i++) {
int codec_index;
codec_index = find_codec_info_part(link->adr_d[i].adr);
codec_index = find_codec_info_part(adr_link->adr_d[i].adr);
if (codec_index < 0)
return codec_index;
/* The group_id is > 0 iff the codec is aggregated */
if (link->adr_d[i].endpoints->group_id != group_id)
if (adr_link->adr_d[i].endpoints->group_id != group_id)
continue;
if (codec_info_list[codec_index].dais[dai_index].init)
codec_info_list[codec_index].dais[dai_index].init(card,
link,
adr_link,
dai_links,
&codec_info_list[codec_index],
playback);
if (!group_id)
return 0;
}
i = 0;
link++;
} while (link->mask);
adr_link++;
} while (adr_link->mask);
return 0;
}
@ -1361,7 +1362,7 @@ static int create_sdw_dailink(struct snd_soc_card *card,
struct snd_soc_dai_link *dai_links,
int sdw_be_num, int sdw_cpu_dai_num,
struct snd_soc_dai_link_component *cpus,
const struct snd_soc_acpi_link_adr *link,
const struct snd_soc_acpi_link_adr *adr_link,
int *cpu_id, bool *group_generated,
struct snd_soc_codec_conf *codec_conf,
int codec_count, int *be_id,
@ -1371,7 +1372,7 @@ static int create_sdw_dailink(struct snd_soc_card *card,
int adr_index,
int dai_index)
{
const struct snd_soc_acpi_link_adr *link_next;
const struct snd_soc_acpi_link_adr *adr_link_next;
struct snd_soc_dai_link_component *codecs;
struct sof_sdw_codec_info *codec_info;
int cpu_dai_id[SDW_MAX_CPU_DAIS];
@ -1385,7 +1386,7 @@ static int create_sdw_dailink(struct snd_soc_card *card,
int ret;
int k;
ret = get_slave_info(link, dev, cpu_dai_id, &cpu_dai_num, &codec_num,
ret = get_slave_info(adr_link, dev, cpu_dai_id, &cpu_dai_num, &codec_num,
&group_id, group_generated, adr_index);
if (ret)
return ret;
@ -1395,20 +1396,20 @@ static int create_sdw_dailink(struct snd_soc_card *card,
return -ENOMEM;
/* generate codec name on different links in the same group */
for (link_next = link; link_next && link_next->num_adr &&
i < cpu_dai_num; link_next++) {
for (adr_link_next = adr_link; adr_link_next && adr_link_next->num_adr &&
i < cpu_dai_num; adr_link_next++) {
const struct snd_soc_acpi_endpoint *endpoints;
endpoints = link_next->adr_d->endpoints;
endpoints = adr_link_next->adr_d->endpoints;
if (group_id && (!endpoints->aggregated ||
endpoints->group_id != group_id))
continue;
/* skip the link excluded by this processed group */
if (cpu_dai_id[i] != ffs(link_next->mask) - 1)
if (cpu_dai_id[i] != ffs(adr_link_next->mask) - 1)
continue;
ret = create_codec_dai_name(dev, link_next, codecs, codec_idx,
ret = create_codec_dai_name(dev, adr_link_next, codecs, codec_idx,
codec_conf, codec_count, codec_conf_index,
adr_index, dai_index);
if (ret < 0)
@ -1416,11 +1417,11 @@ static int create_sdw_dailink(struct snd_soc_card *card,
/* check next link to create codec dai in the processed group */
i++;
codec_idx += link_next->num_adr;
codec_idx += adr_link_next->num_adr;
}
/* find codec info to create BE DAI */
codec_index = find_codec_info_part(link->adr_d[adr_index].adr);
codec_index = find_codec_info_part(adr_link->adr_d[adr_index].adr);
if (codec_index < 0)
return codec_index;
codec_info = &codec_info_list[codec_index];
@ -1516,7 +1517,7 @@ static int create_sdw_dailink(struct snd_soc_card *card,
set_dailink_map(sdw_codec_ch_maps, codec_num, cpu_dai_num);
dai_links[*link_index].codec_ch_maps = sdw_codec_ch_maps;
ret = set_codec_init_func(card, link, dai_links + (*link_index)++,
ret = set_codec_init_func(card, adr_link, dai_links + (*link_index)++,
playback, group_id, adr_index, dai_index);
if (ret < 0) {
dev_err(dev, "failed to init codec %d", codec_index);
@ -1589,7 +1590,7 @@ static int sof_card_dai_links_create(struct device *dev,
int codec_conf_index = 0;
bool group_generated[SDW_MAX_GROUPS];
int ssp_codec_index, ssp_mask;
struct snd_soc_dai_link *links;
struct snd_soc_dai_link *dai_links;
int num_links, link_index = 0;
char *name, *cpu_name;
int total_cpu_dai_num;
@ -1650,14 +1651,14 @@ static int sof_card_dai_links_create(struct device *dev,
/* allocate BE dailinks */
num_links = comp_num + sdw_be_num;
links = devm_kcalloc(dev, num_links, sizeof(*links), GFP_KERNEL);
dai_links = devm_kcalloc(dev, num_links, sizeof(*dai_links), GFP_KERNEL);
/* allocated CPU DAIs */
total_cpu_dai_num = comp_num + sdw_cpu_dai_num;
cpus = devm_kcalloc(dev, total_cpu_dai_num, sizeof(*cpus),
GFP_KERNEL);
if (!links || !cpus)
if (!dai_links || !cpus)
return -ENOMEM;
/* SDW */
@ -1731,9 +1732,9 @@ out:
return codec_index;
for (j = 0; j < codec_info_list[codec_index].dai_num ; j++) {
ret = create_sdw_dailink(card, dev, &link_index, links, sdw_be_num,
sdw_cpu_dai_num, cpus, adr_link,
&cpu_id, group_generated,
ret = create_sdw_dailink(card, dev, &link_index, dai_links,
sdw_be_num, sdw_cpu_dai_num, cpus,
adr_link, &cpu_id, group_generated,
codec_conf, codec_conf_count,
&be_id, &codec_conf_index,
&ignore_pch_dmic, append_dai_type, i, j);
@ -1785,13 +1786,13 @@ SSP:
playback = info->dais[0].direction[SNDRV_PCM_STREAM_PLAYBACK];
capture = info->dais[0].direction[SNDRV_PCM_STREAM_CAPTURE];
init_dai_link(dev, links + link_index, be_id, name,
init_dai_link(dev, dai_links + link_index, be_id, name,
playback, capture,
cpus + cpu_id, 1,
ssp_components, 1,
NULL, info->ops);
ret = info->dais[0].init(card, NULL, links + link_index, info, 0);
ret = info->dais[0].init(card, NULL, dai_links + link_index, info, 0);
if (ret < 0)
return ret;
@ -1806,7 +1807,7 @@ DMIC:
goto HDMI;
}
cpus[cpu_id].dai_name = "DMIC01 Pin";
init_dai_link(dev, links + link_index, be_id, "dmic01",
init_dai_link(dev, dai_links + link_index, be_id, "dmic01",
0, 1, // DMIC only supports capture
cpus + cpu_id, 1,
dmic_component, 1,
@ -1814,7 +1815,7 @@ DMIC:
INC_ID(be_id, cpu_id, link_index);
cpus[cpu_id].dai_name = "DMIC16k Pin";
init_dai_link(dev, links + link_index, be_id, "dmic16k",
init_dai_link(dev, dai_links + link_index, be_id, "dmic16k",
0, 1, // DMIC only supports capture
cpus + cpu_id, 1,
dmic_component, 1,
@ -1857,7 +1858,7 @@ HDMI:
return -ENOMEM;
cpus[cpu_id].dai_name = cpu_name;
init_dai_link(dev, links + link_index, be_id, name,
init_dai_link(dev, dai_links + link_index, be_id, name,
1, 0, // HDMI only supports playback
cpus + cpu_id, 1,
idisp_components + i, 1,
@ -1878,11 +1879,11 @@ HDMI:
return -ENOMEM;
cpus[cpu_id].dai_name = cpu_name;
init_dai_link(dev, links + link_index, be_id, name, 1, 1,
cpus + cpu_id, 1, &asoc_dummy_dlc, 1, NULL, NULL);
init_dai_link(dev, dai_links + link_index, be_id, name, 1, 1,
cpus + cpu_id, 1, &asoc_dummy_dlc, 1, NULL, NULL);
}
card->dai_link = links;
card->dai_link = dai_links;
card->num_links = num_links;
card->codec_conf = codec_conf;
@ -1925,15 +1926,15 @@ static struct snd_soc_card card_sof_sdw = {
static struct snd_soc_dai_link *mc_find_codec_dai_used(struct snd_soc_card *card,
const char *dai_name)
{
struct snd_soc_dai_link *link;
struct snd_soc_dai_link *dai_link;
int i;
int j;
for_each_card_prelinks(card, i, link) {
for (j = 0; j < link->num_codecs; j++) {
for_each_card_prelinks(card, i, dai_link) {
for (j = 0; j < dai_link->num_codecs; j++) {
/* Check each codec in a link */
if (!strcmp(link->codecs[j].dai_name, dai_name))
return link;
if (!strcmp(dai_link->codecs[j].dai_name, dai_name))
return dai_link;
}
}
return NULL;
@ -1941,7 +1942,7 @@ static struct snd_soc_dai_link *mc_find_codec_dai_used(struct snd_soc_card *card
static void mc_dailink_exit_loop(struct snd_soc_card *card)
{
struct snd_soc_dai_link *link;
struct snd_soc_dai_link *dai_link;
int ret;
int i, j;
@ -1954,10 +1955,11 @@ static void mc_dailink_exit_loop(struct snd_soc_card *card)
* We don't need to call .exit function if there is no matched
* dai link found.
*/
link = mc_find_codec_dai_used(card, codec_info_list[i].dais[j].dai_name);
if (link) {
dai_link = mc_find_codec_dai_used(card,
codec_info_list[i].dais[j].dai_name);
if (dai_link) {
/* Do the .exit function if the codec dai is used in the link */
ret = codec_info_list[i].dais[j].exit(card, link);
ret = codec_info_list[i].dais[j].exit(card, dai_link);
if (ret)
dev_warn(card->dev,
"codec exit failed %d\n",