tree 65c16095cdfbbef874c085d6ad552983fea255c6
parent a84188eced6109983af54f9435a26d21eac3f8cc
author Kuninori Morimoto <kuninori.morimoto.gx@renesas.com> 1578623721 +0900
committer Mark Brown <broonie@kernel.org> 1578663082 +0000
gpgsig -----BEGIN PGP SIGNATURE-----
 
 iQFHBAABCgAxFiEEreZoqmdXGLWf4p/qJNaLcl1Uh9AFAl4YfKoTHGJyb29uaWVA
 a2VybmVsLm9yZwAKCRAk1otyXVSH0POVB/9KpeUBrAoM9dAEbjG74P7cb3vVbc+b
 e9oHqlI7uS5gv/hB5Hf6zBi5V03fqmEcZBgiHssGa9xzJrSZaoAUU6vvcvYAC44B
 kwhdkdy4GJ9lh9p9ietgqGnz7qVLfo7YfvYfN8kpPsWjGHUUgGgsRfklBYXPAIWC
 eE4Itn5zlBHOWrqYT4Hti41rFTDNVpv750CJPIFhGULqFu2MKOFy/g0JrpEhERKG
 34T01bZ2ygSHnjDT8GSvyxS5HibpRPSuqFdjKcTA6ygewIsViWQErWdUQrocgBzR
 j7pj8o30D1tnj7T851gLB8RbRqpqFkmXXmyZqkBmDNGUizGbIHxnRaFk
 =+xr2
 -----END PGP SIGNATURE-----

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>
